golang.py

# Copyright (c) nexB Inc. and others. All rights reserved.
# ScanCode is a trademark of nexB Inc.
# SPDX-License-Identifier: Apache-2.0
# See http://www.apache.org/licenses/LICENSE-2.0 for the license text.
# See https://github.com/nexB/scancode-toolkit for support or download.
# See https://aboutcode.org for more information about nexB OSS projects.
#

from packagedcode import go_mod
from packagedcode import models

"""
Handle Go packages including go.mod and go.sum files.
"""

# FIXME: !!improve how we handle packages names vs. subpath.
# we need to have shorter names and use subpath

# TODO: go.mod file does not contain version number.
# valid download url need version number
# CHECK: https://forum.golangbridge.org/t/url-to-download-package/19811

# TODO: use the LICENSE file convention!
# TODO: support "vendor" layout


class BaseGoModuleHandler(models.DatafileHandler):

    @classmethod
    def assemble(cls, package_data, resource, codebase, package_adder):
        """
        Always use go.mod first then go.sum
        """
        yield from cls.assemble_from_many_datafiles(
            datafile_name_patterns=('go.mod', 'go.sum',),
            directory=resource.parent(codebase),
            codebase=codebase,
            package_adder=package_adder,
        )


class GoModHandler(BaseGoModuleHandler):
    datasource_id = 'go_mod'
    path_patterns = ('*/go.mod',)
    default_package_type = 'golang'
    default_primary_language = 'Go'
    description = 'Go modules file'
    documentation_url = 'https://go.dev/ref/mod'

    @classmethod
    def parse(cls, location, package_only=False):
        gomods = go_mod.parse_gomod(location)

        dependencies = []
        require = gomods.require or []
        for gomod in require:
            dependencies.append(
                models.DependentPackage(
                    purl=gomod.purl(include_version=True),
                    extracted_requirement=gomod.version,
                    scope='require',
                    is_runtime=True,
                    is_optional=False,
                    is_pinned=False,
                )
            )

        exclude = gomods.exclude or []
        for gomod in exclude:
            dependencies.append(
                models.DependentPackage(
                    purl=gomod.purl(include_version=True),
                    extracted_requirement=gomod.version,
                    scope='exclude',
                    is_runtime=True,
                    is_optional=False,
                    is_pinned=False,
                )
            )

        name = gomods.name
        namespace = gomods.namespace

        homepage_url = f'https://pkg.go.dev/{gomods.namespace}/{gomods.name}'
        vcs_url = f'https://{gomods.namespace}/{gomods.name}.git'

        repository_homepage_url = None
        if namespace and name:
            repository_homepage_url = f'https://pkg.go.dev/{namespace}/{name}'

        package_data = dict(
            datasource_id=cls.datasource_id,
            type=cls.default_package_type,
            name=name,
            namespace=namespace,
            vcs_url=vcs_url,
            homepage_url=homepage_url,
            repository_homepage_url=repository_homepage_url,
            dependencies=dependencies,
            primary_language=cls.default_primary_language,
        )
        yield models.PackageData.from_data(package_data, package_only)


class GoSumHandler(BaseGoModuleHandler):
    datasource_id = 'go_sum'
    path_patterns = ('*/go.sum',)
    default_package_type = 'golang'
    default_primary_language = 'Go'
    description = 'Go module checksums file'
    documentation_url = 'https://go.dev/ref/mod#go-sum-files'

    @classmethod
    def parse(cls, location, package_only=False):
        gosums = go_mod.parse_gosum(location)
        package_dependencies = []
        for gosum in gosums:
            package_dependencies.append(
                models.DependentPackage(
                    purl=gosum.purl(),
                    extracted_requirement=gosum.version,
                    scope='dependency',
                    is_runtime=True,
                    is_optional=False,
                    is_pinned=True,
                )
            )

        package_data = dict(
            datasource_id=cls.datasource_id,
            type=cls.default_package_type,
            dependencies=package_dependencies,
            primary_language=cls.default_primary_language,
        )
        yield models.PackageData.from_data(package_data, package_only)


class GoWorkHandler(models.DatafileHandler):
    """
    Handle Go workspace files (go.work) introduced in Go 1.18.

    A go.work file identifies a workspace: a collection of Go modules
    that can be developed together. It lists ``use`` directives pointing
    to local module directories, and optional ``require`` directives for
    external dependencies.

    See https://go.dev/ref/mod#go-work-files for details.
    """
    datasource_id = 'go_work'
    path_patterns = ('*/go.work',)
    default_package_type = 'golang'
    default_primary_language = 'Go'
    description = 'Go workspace file'
    documentation_url = 'https://go.dev/ref/mod#go-work-files'

    @classmethod
    def parse(cls, location, package_only=False):
        workspace = go_mod.parse_gowork(location)

        dependencies = []
        for req in workspace.require or []:
            dependencies.append(
                models.DependentPackage(
                    purl=req.purl(include_version=True),
                    extracted_requirement=req.version,
                    scope='require',
                    is_runtime=True,
                    is_optional=False,
                    is_pinned=False,
                )
            )

        extra_data = {}
        if workspace.go_version:
            extra_data['go_version'] = workspace.go_version
        if workspace.use:
            extra_data['use'] = workspace.use

        package_data = dict(
            datasource_id=cls.datasource_id,
            type=cls.default_package_type,
            primary_language=cls.default_primary_language,
            dependencies=dependencies,
            extra_data=extra_data,
        )
        yield models.PackageData.from_data(package_data, package_only)