Initial PR for Packages: composer.json, cargo.toml, bower.json & .gemspec

.gitignore

@@ -10,6 +10,10 @@ Lib/*
 Scripts/*
 .idea/*
 *.json
+!**/codemeta.json
+!**/composer.json
+!**/package.json
+!**/bower.json
 *.ttl
 env_3.9/*
 src/somef/create_corpus_for_NER.py

docs/output.md

@@ -114,6 +114,11 @@ SOMEF aims to recognize the following categories (in alphabetical order):
 - `type`: Software type: Commandline Application, Notebook Application, Ontology, Scientific Workflow. Non-Software types: Static Website, Uncategorized
 - `usage`: Usage examples and considerations of a code repository.
 - `workflows`: URL and path to the computational workflow files present in the repository.
+- `homepage`: URL to the homepage of the software or organization.
+- `reference_publication`: URL to the paper associated with the code repository.
+- `package_id`: Identifier extracted from packages. (e.g., `packages.json`)
+-  `funding`: Funding code for the related project.
+- `has_package_file`: Specifies what package file is present in the code repository.
 
 The following table summarized the properties used to describe a `category`:
 
@@ -210,10 +215,15 @@ The following formats for a result value are currently recognized:
 - `docker_compose`: [orchestration file](https://docs.docker.com/compose/compose-file/) used to communicate multiple containers.
 - `readthedocs`: documentation format used by many repositories in order to describe their projects.
 - `wiki`: documentation format used in GitHub repositories.
-- `setup.py`: package file format used in python projects
-- `pyproject.toml`: package file format used in python projects
-- `pom.xml`: package file used in Java projects
-- `package.json`: package file used in Javascript projects
+- `setup.py`: package file format used in python projects.
+- `pyproject.toml`: package file format used in python projects.
+- `pom.xml`: package file used in Java projects.
+- `package.json`: package file used in Javascript projects.
+- `bower.json`: package descriptor used for configuring packages that can be used as a dependency for Bower-managed front-end projects.
+- `composer.json`: manifest file serves as the package descriptor used in PHP projects.
+- `cargo.toml.json`: manifest file serves as the package descriptor used in Rust projects.
+- `[name].gemspec`:manifest file serves as the package descriptor used in Ruby gem projects.
+
 
 ### Technique
 The techniques can be of several types: 

src/somef/parser/bower_parser.py

@@ -0,0 +1,162 @@
+import json
+import logging
+import os
+from pathlib import Path
+from ..process_results import Result
+from ..utils import constants
+from ..regular_expressions import detect_license_spdx
+
+def parse_bower_json_file(file_path, metadata_result: Result, source):
+    """
+
+    Parameters
+    ----------
+    file_path: path of the bower file being analysed
+    metadata_result: metadata object where the metadata dictionary is kept
+    source: source of the package file (URL)
+
+    Returns
+    -------
+
+    """
+    try:
+        if Path(file_path).name.lower() in ["bower.json"]:
+            metadata_result.add_result(
+                constants.CAT_HAS_PACKAGE_FILE,
+                {
+                    "value": "bower.json",
+                    "type": constants.URL,
+                },
+                1,
+                constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                source
+            )
+
+            with open(file_path, 'r', encoding='utf-8') as file:
+                data = json.load(file)
+
+                if "name" in data:
+                    metadata_result.add_result(
+                        constants.CAT_NAME,
+                        {
+                            "value": data["name"],
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                if "description" in data:
+                    metadata_result.add_result(
+                        constants.CAT_DESCRIPTION,
+                        {
+                            "value": data["description"],
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                if "homepage" in data:
+                    metadata_result.add_result(
+                        constants.CAT_HOMEPAGE,
+                        {
+                            "value": data["homepage"],
+                            "type": constants.URL
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                if "version" in data:
+                    metadata_result.add_result(
+                        constants.CAT_VERSION,
+                        {
+                            "value": data["version"],
+                            "type": constants.RELEASE,
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                if "authors" in data:
+                    metadata_result.add_result(
+                        constants.CAT_AUTHORS,
+                        {
+                            "value": data["authors"],
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                if "license" in data:                   
+                    metadata_result.add_result(
+                        constants.CAT_LICENSE,
+                        {
+                            "value": data["license"],
+                            "type": constants.LICENSE
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+
+                if "dependencies" in data and isinstance(data["dependencies"], dict):
+                    for name, version in data["dependencies"].items():
+                        req = f"{name}: {version}"
+
+                        metadata_result.add_result(
+                            constants.CAT_REQUIREMENTS,
+                            {
+                                "value": req,
+                                "name": name,
+                                "version": version,
+                                "type": constants.SOFTWARE_APPLICATION,
+                                "dependency_type": "runtime"
+                            },
+                            1,
+                            constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                            source
+                        )
+
+                if "devDependencies" in data and isinstance(data["devDependencies"], dict):
+                    for name, version in data["devDependencies"].items():
+                        req = f"{name}: {version}"
+
+                        metadata_result.add_result(
+                            constants.CAT_REQUIREMENTS,
+                            {
+                                "value": req,
+                                "name": name,
+                                "version": version,
+                                "type": constants.SOFTWARE_APPLICATION,
+                                "dependency_type": "dev"
+                            },
+                            1,
+                            constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                            source
+                        )
+
+                if "keywords" in data:
+                    for keyword in data["keywords"]:
+                        metadata_result.add_result(
+                            constants.CAT_KEYWORDS,
+                            {
+                                "value": keyword,
+                                "type": constants.STRING
+                            },
+                            1,
+                            constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                            source
+                        )
+
+    except Exception as e:
+        logging.error(f"Error parsing bower.json from {file_path}: {str(e)}")
+
+    return metadata_result

src/somef/parser/cabal_parser.py

@@ -0,0 +1,168 @@
+import os
+import re
+import logging
+from pathlib import Path
+from ..process_results import Result
+from ..regular_expressions import detect_license_spdx
+from ..utils import constants
+
+def parse_cabal_file(file_path, metadata_result: Result, source):
+    """
+    Parse a .cabal file and extract relevant metadata.
+
+    Parameters
+    ----------
+    file_path: path of the cabal file being analysed
+    metadata_result: metadata object where the metadata dictionary is kept
+    source: source of the package file (URL)
+
+    Returns
+    """
+
+    try:
+        if file_path.endswith('.cabal'):
+            metadata_result.add_result(
+                constants.CAT_HAS_PACKAGE_FILE,
+                {
+                    "value": Path(file_path).name,
+                    "type": constants.URL,
+                },
+                1,
+                constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                source
+            )
+
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
+
+                name_match = re.search(r'name:\s*(.*)', content, re.IGNORECASE)
+                if name_match:
+                    metadata_result.add_result(
+                        constants.CAT_PACKAGE_ID,
+                        {
+                            "value": name_match.group(1),
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                version_match = re.search(r'version:\s*(.*)', content, re.IGNORECASE)
+                if version_match:
+                    metadata_result.add_result(
+                        constants.CAT_VERSION,
+                        {
+                            "value": version_match.group(1),
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                description_match = re.search(r'description:\s*(.*)', content, re.IGNORECASE)
+                if description_match:
+                    metadata_result.add_result(
+                        constants.CAT_DESCRIPTION,
+                        {
+                            "value": description_match.group(1),
+                            "type": constants.STRING
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                homepage_match = re.search(r'homepage:\s*(.*)', content, re.IGNORECASE)
+                if homepage_match:
+                    metadata_result.add_result(
+                        constants.CAT_HOMEPAGE,
+                        {
+                            "value": homepage_match.group(1),
+                            "type": constants.URL
+                        },
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                license_match = re.search(r'license:\s*(.*)', content, re.IGNORECASE)
+                if license_match:
+                    license_value = license_match.group(1)
+                    license_text = ""
+
+                    dir_path = os.path.dirname(file_path)
+                    license_paths = [
+                        os.path.join(dir_path, "LICENSE"),
+                        os.path.join(dir_path, "LICENSE.txt"),
+                        os.path.join(dir_path, "LICENSE.md")
+                    ]
+
+                    for license_path in license_paths:
+                        if os.path.exists(license_path):
+                            with open(license_path, "r", encoding="utf-8") as lf:
+                                license_text = lf.read()
+                            break
+
+                    license_info_spdx = detect_license_spdx(license_text, 'Ruby')
+
+                    if license_info_spdx:
+                        license_data = {
+                            "value": license_value,
+                            "spdx_id": license_info_spdx.get('spdx_id'),
+                            "name": license_info_spdx.get('name'),
+                            "type": constants.LICENSE
+                        }
+                    else:
+                        license_data = {
+                            "value": license_value,
+                            "type": constants.LICENSE
+                        }
+
+                    metadata_result.add_result(
+                        constants.CAT_LICENSE,
+                        license_data,
+                        1,
+                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                        source
+                    )
+
+                library_section_match = re.search(r'library\s*\n(.*?)(?=\n\S|\Z)', content, re.DOTALL | re.IGNORECASE)
+                if library_section_match:
+                    library_content = library_section_match.group(1)
+
+                    build_depends_match = re.search(r'build-depends:\s*(.*?)(?=\n\s*\w+:|\Z)', library_content, re.DOTALL)
+                    if build_depends_match:
+                        build_depends_content = build_depends_match.group(1)
+
+                        dependencies = re.split(r'[,\n]', build_depends_content)
+
+                        for dep_line in dependencies:
+                            dep_line = dep_line.strip()
+                            if dep_line and not dep_line.startswith(','):
+
+                                dep_match = re.match(r'^([a-zA-Z0-9-_]+)\s*(.*?)$', dep_line)
+                                if dep_match:
+                                    name = dep_match.group(1)
+                                    version_constraint = dep_match.group(2).strip() if dep_match.group(2) else "any"
+                                    req = f"{name}: {version_constraint}" if version_constraint != "any" else name
+
+                                    metadata_result.add_result(
+                                        constants.CAT_REQUIREMENTS,
+                                        {
+                                            "value": req,
+                                            "name": name,
+                                            "version": version_constraint,
+                                            "type": constants.SOFTWARE_APPLICATION,
+                                            "dependency_type": "runtime"
+                                        },
+                                        1,
+                                        constants.TECHNIQUE_CODE_CONFIG_PARSER,
+                                        source
+                                    )
+
+    except Exception as e:
+        logging.error(f"Error parsing gemspec file from {file_path}: {str(e)}")
+
+    return metadata_result