fosslight-source 2.3.8__tar.gz → 2.3.9__tar.gz

{fosslight_source-2.3.8/src/fosslight_source.egg-info → fosslight_source-2.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_source
-Version: 2.3.8
+Version: 2.3.9
 Summary: FOSSLight Source Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0
@@ -20,7 +20,7 @@ Requires-Dist: setuptools<=80.10.2
 Requires-Dist: pyparsing
 Requires-Dist: scanoss>=1.45.0
 Requires-Dist: XlsxWriter
-Requires-Dist: fosslight_util>=2.2.7
+Requires-Dist: fosslight_util>=2.2.8
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fosslight_source"
-version = "2.3.8"
+version = "2.3.9"
 description = "FOSSLight Source Scanner"
 readme = "README.md"
 license = "Apache-2.0"
@@ -29,7 +29,7 @@ dependencies = [
     "pyparsing",
     "scanoss>=1.45.0",
     "XlsxWriter",
-    "fosslight_util>=2.2.7",
+    "fosslight_util>=2.2.8",
     "PyYAML",
     "wheel>=0.38.1",
     "intbitset",

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/_parsing_scancode_file_item.py

@@ -7,6 +7,7 @@ import os
 import logging
 import re
 import fosslight_util.constant as constant
+from fosslight_util.exclude import is_excluded_filename
 from ._license_matched import MatchedLicense
 from ._scan_item import SourceItem
 from ._scan_item import replace_word
@@ -20,9 +21,15 @@ SPDX_LICENSE_IDENTIFIER_PATTERN = re.compile(
     r'SPDX[-\s]+License[-\s]+Identifier(?:\s*[:,-]\s*|\s+)([^\r\n]+)',
     re.IGNORECASE,
 )
+# Android Soong license_kinds string, e.g. "SPDX-license-identifier-BSD"
+SOONG_SPDX_LICENSE_KIND_PATTERN = re.compile(
+    r'SPDX-license-identifier-([A-Za-z0-9.-]+)',
+    re.IGNORECASE,
+)
 LICENSE_REF_PREFIX_PATTERN = re.compile(r'^LicenseRef-', re.IGNORECASE)
 # Trailing closers from comments and quoted lists, e.g. "MIT */", "MIT -->", or '"MIT",'.
 SPDX_DECLARATION_TRAILER_PATTERN = re.compile(r'\s*(?:\*/|-->|["\']\s*,?)\s*$')
+SPDX_DECLARATION_LINE_COMMENT_PATTERN = re.compile(r'\s//.*$')
 KEYWORD_SPDX_ID = r'SPDX-License-Identifier\s*[\S]+'
 KEYWORD_DOWNLOAD_LOC = r'DownloadLocation\s*[\S]+'
 KEYWORD_SCANCODE_UNKNOWN = "unknown-spdx"
@@ -294,11 +301,22 @@ def _omit_parens_for_two_license_expression(expression: str) -> str:
 
 
 def _clean_spdx_declaration(raw: str) -> str:
-    """Strip whitespace and trailing comment or quoted-list terminators."""
+    """Strip whitespace, line comments, and trailing comment or quoted-list terminators."""
     cleaned = (raw or "").strip()
     if not cleaned:
         return ""
-    return SPDX_DECLARATION_TRAILER_PATTERN.sub('', cleaned).strip()
+    cleaned = SPDX_DECLARATION_LINE_COMMENT_PATTERN.sub('', cleaned).strip()
+    cleaned = SPDX_DECLARATION_TRAILER_PATTERN.sub('', cleaned).strip()
+    cleaned = cleaned.strip('"\'')
+    return cleaned.strip()
+
+
+def _extract_soong_license_kind(matched_txt: str) -> str:
+    """Extract license id from Android Soong SPDX-license-identifier-* strings."""
+    matched = SOONG_SPDX_LICENSE_KIND_PATTERN.search(matched_txt or "")
+    if not matched:
+        return ""
+    return matched.group(1)
 
 
 def _strip_license_ref_prefix(token: str) -> str:
@@ -309,9 +327,14 @@ def _extract_spdx_declared_expression(matched_txt: str) -> str:
     """
     Extract SPDX-License-Identifier value from matched_text.
 
-    - Removes trailing comment closers (*/ , -->)
+    - Android Soong license_kinds (SPDX-license-identifier-*) first
+    - Removes trailing line comments and comment closers (*/, -->)
     - Strips LicenseRef- from each AND/OR token
     """
+    soong_license = _extract_soong_license_kind(matched_txt)
+    if soong_license:
+        return soong_license
+
     matched = SPDX_LICENSE_IDENTIFIER_PATTERN.search(matched_txt or "")
     if not matched:
         return ""
@@ -493,6 +516,9 @@ def parsing_scancode(
                 if (not file_path) or is_binary or is_dir:
                     logger.info(f"Skipping {file_path} because it is binary or directory")
                     continue
+                if is_excluded_filename(file_path):
+                    logger.debug(f"Skipping {file_path} because it is an excluded filename")
+                    continue
                 result_item = SourceItem(file_path)
                 if has_error:
                     error_msg = file.get("scan_errors", [])

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/_scan_item.py

@@ -25,6 +25,7 @@ _manifest_filename = [
     r'.*\.podspec$',
     r'Cargo\.toml$',
     r'huggingface_hub_metadata\.json$',
+    r'Android\.bp$',
 ]
 MAX_LICENSE_LENGTH = 200
 MAX_LICENSE_TOTAL_LENGTH = 600

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/cli.py

@@ -29,13 +29,12 @@ import tqdm
 import argparse
 from .run_spdx_extractor import get_spdx_downloads
 from .run_manifest_extractor import get_manifest_licenses
-from ._scan_item import SourceItem, resolve_kb_config, is_notice_file
+from ._scan_item import SourceItem, resolve_kb_config, is_notice_file, is_manifest_file
 from ._kb_client import fetch_origin_urls_via_scan_job
 from fosslight_util.cover import dump_result_log
 from fosslight_util.time import current_timestamp_utc, format_running_time, timestamp_for_filename
 from fosslight_util.oss_item import ScannerItem
 from typing import Optional, Tuple
-from ._scan_item import is_manifest_file
 import shutil
 from ._merge import (
     _add_pre_merge_sheet,
@@ -454,11 +453,11 @@ def merge_results(
     if manifest_licenses:
         for file_name, licenses in manifest_licenses.items():
             valid_licenses = [lic.strip() for lic in licenses if isinstance(lic, str) and lic.strip()]
-            # Non-UI: skip manifests with no extracted licenses.
-            # UI: keep/create the row and mark is_manifest_file even without licenses.
-            if not valid_licenses and not ui_mode:
+            item = _get_or_append_source_item(
+                scancode_result, file_name, append=bool(valid_licenses) or ui_mode
+            )
+            if item is None:
                 continue
-            item = _get_or_append_source_item(scancode_result, file_name)
             item.is_manifest_file = True
             if valid_licenses:
                 # overwrite existing detected licenses with manifest-provided licenses
@@ -501,9 +500,13 @@ def merge_results(
     return scancode_result, kb_status_message, kb_requested_count, kb_returned_count
 
 
-def _get_or_append_source_item(scancode_result: list, file_name: str) -> SourceItem:
+def _get_or_append_source_item(
+    scancode_result: list, file_name: str, append: bool = True
+) -> Optional[SourceItem]:
     if file_name in scancode_result:
         return scancode_result[scancode_result.index(file_name)]
+    if not append:
+        return None
     item = SourceItem(file_name)
     scancode_result.append(item)
     return item
@@ -706,7 +709,7 @@ def run_scanners(
     return success, result_log.get(RESULT_KEY, ""), scan_item, license_list, scanoss_result
 
 
-def metadata_collector(path_to_scan: str, excluded_files: set) -> dict:
+def metadata_collector(path_to_scan: str, excluded_files: set) -> tuple[dict, dict]:
     """
     Collect metadata for merging.
 

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/run_manifest_extractor.py

@@ -178,16 +178,28 @@ def get_licenses_from_pyproject_toml(file_path: str) -> list[str]:
                 data = None
 
         if isinstance(data, dict):
-            project_tbl = data.get('project') or {}
-            license_value = project_tbl.get('license')
-            if isinstance(license_value, str) and license_value.strip():
-                return [license_value.strip()]
-            if isinstance(license_value, dict):
-                text_value = license_value.get('text')
-                if isinstance(text_value, str) and text_value.strip():
-                    return [text_value.strip()]
-                if license_value.get('file'):
-                    return []
+            project_tbl = data.get('project')
+            if isinstance(project_tbl, dict) and 'license' in project_tbl:
+                license_value = project_tbl.get('license')
+                if isinstance(license_value, str) and license_value.strip():
+                    return [license_value.strip()]
+                if isinstance(license_value, dict):
+                    text_value = license_value.get('text')
+                    if isinstance(text_value, str) and text_value.strip():
+                        return [text_value.strip()]
+                    if license_value.get('file'):
+                        return []
+                return []
+
+            tool_tbl = data.get('tool')
+            if isinstance(tool_tbl, dict):
+                poetry_tbl = tool_tbl.get('poetry')
+                if isinstance(poetry_tbl, dict):
+                    poetry_license = poetry_tbl.get('license')
+                    if isinstance(poetry_license, str) and poetry_license.strip():
+                        return [poetry_license.strip()]
+            # Structured parse succeeded; do not re-read/regex the same file.
+            return []
     except Exception as ex:
         logger.info(f"Failed to parse pyproject.toml via toml parser for {file_path}: {ex}")
 
@@ -195,24 +207,40 @@ def get_licenses_from_pyproject_toml(file_path: str) -> list[str]:
         with open(file_path, 'r', encoding='utf-8') as f:
             content = f.read()
         project_match = re.search(r'^\s*\[project\]\s*(.*?)(?=^\s*\[|\Z)', content, flags=re.MULTILINE | re.DOTALL)
-        if not project_match:
-            return []
-        block = project_match.group(1)
-        m = re.search(r'^\s*license\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)', block,
-                      flags=re.MULTILINE | re.DOTALL)
-        if m:
-            val = m.group('val').strip()
-            if val:
-                return [val]
-        m2 = re.search(r'^\s*license\s*=\s*\{[^}]*?\btext\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)',
-                       block, flags=re.MULTILINE | re.DOTALL)
-        if m2:
-            val = m2.group('val').strip()
-            if val:
-                return [val]
-        m3 = re.search(r'^\s*license\s*=\s*\{[^}]*?\bfile\s*=', block, flags=re.MULTILINE | re.DOTALL)
-        if m3:
-            return []
+        if project_match:
+            block = project_match.group(1)
+            project_license_declared = re.search(r'^\s*license\s*=', block, flags=re.MULTILINE)
+            if project_license_declared:
+                m = re.search(r'^\s*license\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)', block,
+                              flags=re.MULTILINE | re.DOTALL)
+                if m:
+                    val = m.group('val').strip()
+                    if val:
+                        return [val]
+                m2 = re.search(r'^\s*license\s*=\s*\{[^}]*?\btext\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)',
+                               block, flags=re.MULTILINE | re.DOTALL)
+                if m2:
+                    val = m2.group('val').strip()
+                    if val:
+                        return [val]
+                return []
+
+        poetry_match = re.search(
+            r'^\s*\[tool\.poetry\]\s*(.*?)(?=^\s*\[|\Z)',
+            content,
+            flags=re.MULTILINE | re.DOTALL,
+        )
+        if poetry_match:
+            poetry_block = poetry_match.group(1)
+            poetry_license = re.search(
+                r'^\s*license\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)',
+                poetry_block,
+                flags=re.MULTILINE | re.DOTALL,
+            )
+            if poetry_license:
+                val = poetry_license.group('val').strip()
+                if val:
+                    return [val]
     except Exception as ex:
         logger.info(f"Failed to parse pyproject.toml {file_path}: {ex}")
         return []
@@ -345,6 +373,9 @@ def get_licenses_from_huggingface_metadata(file_path: str) -> list[str]:
 
 
 def get_manifest_licenses(file_path: str) -> list[str]:
+    # Android.bp licenses come from ScanCode; manifest merge only sets is_manifest_file.
+    if os.path.basename(file_path).lower() == 'android.bp':
+        return []
     if file_path.endswith('.pom'):
         try:
             pom_licenses = get_license_from_pom(group_id='', artifact_id='', version='', pom_path=file_path, check_parent=True)

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/run_scancode.py

@@ -19,7 +19,6 @@ from fosslight_util.output_format import check_output_formats_v2
 from fosslight_util.exclude import (
     EXCLUDE_DIRECTORY,
     EXCLUDE_FILE_EXTENSION,
-    EXCLUDE_FILENAME,
     PACKAGE_DIRECTORY,
 )
 
@@ -166,14 +165,14 @@ def _default_scancode_ignore_patterns(
     Directory names use path-based globs (e.g. **/tests/**) so they do not match
     the scan root directory name itself.
     Binary files are excluded separately via scancode --ignore-binaries.
+    EXCLUDE_FILENAME is not passed to ScanCode --ignore: matching many exact
+    names on a large tree is slow. Those files are dropped after parsing.
     """
     patterns = {".*"}
     for name in PACKAGE_DIRECTORY + EXCLUDE_DIRECTORY:
         patterns.add(_directory_ignore_pattern(name))
     for ext in EXCLUDE_FILE_EXTENSION:
         patterns.add(f"*.{ext}")
-    for name in EXCLUDE_FILENAME:
-        patterns.add(name)
 
     for pattern in path_to_exclude or []:
         if os.path.isabs(pattern):

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source/run_spdx_extractor.py

@@ -22,5 +22,5 @@ def get_spdx_downloads(file_path: str) -> list[str]:
                     for word in find_word.findall(mmap_obj):
                         results.append(word.decode('utf-8'))
     except Exception as ex:
-        logger.warning(f"Failed to extract SPDX download location. {file_path}, {ex}")
+        logger.debug(f"Failed to extract SPDX download location. {file_path}, {ex}")
     return results

{fosslight_source-2.3.8 → fosslight_source-2.3.9/src/fosslight_source.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_source
-Version: 2.3.8
+Version: 2.3.9
 Summary: FOSSLight Source Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0
@@ -20,7 +20,7 @@ Requires-Dist: setuptools<=80.10.2
 Requires-Dist: pyparsing
 Requires-Dist: scanoss>=1.45.0
 Requires-Dist: XlsxWriter
-Requires-Dist: fosslight_util>=2.2.7
+Requires-Dist: fosslight_util>=2.2.8
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source.egg-info/SOURCES.txt

@@ -22,6 +22,9 @@ src/fosslight_source.egg-info/dependency_links.txt
 src/fosslight_source.egg-info/entry_points.txt
 src/fosslight_source.egg-info/requires.txt
 src/fosslight_source.egg-info/top_level.txt
+tests/test_manifest_android_bp.py
 tests/test_manifest_composer.py
+tests/test_manifest_pyproject.py
+tests/test_manifest_recommended_scenarios.py
 tests/test_parsing_unknown_spdx.py
 tests/test_tox.py

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/src/fosslight_source.egg-info/requires.txt

@@ -2,7 +2,7 @@ setuptools<=80.10.2
 pyparsing
 scanoss>=1.45.0
 XlsxWriter
-fosslight_util>=2.2.7
+fosslight_util>=2.2.8
 PyYAML
 wheel>=0.38.1
 intbitset

fosslight_source-2.3.9/tests/test_manifest_android_bp.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2026 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for Android.bp manifest handling."""
+
+from unittest.mock import patch
+
+from fosslight_source._scan_item import (
+    SourceItem,
+    is_manifest_file,
+)
+from fosslight_source.cli import merge_results, metadata_collector
+from fosslight_source.run_manifest_extractor import get_manifest_licenses
+
+
+def test_is_manifest_file_recognizes_android_bp():
+    assert is_manifest_file("/tmp/module/Android.bp") is True
+    assert is_manifest_file("/tmp/module/android.bp") is True
+    assert is_manifest_file("/tmp/module/package.json") is True
+
+
+def test_get_manifest_licenses_returns_empty_for_android_bp(tmp_path):
+    android_bp = tmp_path / "Android.bp"
+    android_bp.write_text('license { name: "test_license" }', encoding="utf-8")
+    assert get_manifest_licenses(str(android_bp)) == []
+
+
+def test_metadata_collector_adds_android_bp_without_license_extraction(tmp_path):
+    android_bp = tmp_path / "Android.bp"
+    android_bp.write_text('license { name: "test_license" }', encoding="utf-8")
+    package_json = tmp_path / "package.json"
+    package_json.write_text('{"license": "MIT"}', encoding="utf-8")
+
+    with patch("fosslight_source.cli.get_manifest_licenses", wraps=get_manifest_licenses) as mock_get:
+        spdx_downloads, manifest_licenses = metadata_collector(str(tmp_path), set())
+
+    assert spdx_downloads == {}
+    assert manifest_licenses == {"Android.bp": [], "package.json": ["MIT"]}
+    assert mock_get.call_count == 2
+
+
+def test_merge_results_sets_manifest_flag_without_overwriting_scancode_licenses():
+    scancode_item = SourceItem("carrois-gothic-sc/Android.bp")
+    scancode_item.licenses = ["Apache-2.0", "MIT", "BSD"]
+
+    merged, _, _, _ = merge_results(
+        scancode_result=[scancode_item],
+        manifest_licenses={"carrois-gothic-sc/Android.bp": []},
+    )
+
+    assert len(merged) == 1
+    assert merged[0].is_manifest_file is True
+    assert merged[0].licenses == ["Apache-2.0", "MIT", "BSD"]
+
+
+def test_merge_results_skips_android_bp_not_in_scancode_result():
+    merged, _, _, _ = merge_results(
+        scancode_result=[],
+        manifest_licenses={"module/Android.bp": []},
+    )
+
+    assert merged == []

fosslight_source-2.3.9/tests/test_manifest_pyproject.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2026 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+"""Tests for pyproject.toml manifest license extraction."""
+
+from fosslight_source.run_manifest_extractor import get_licenses_from_pyproject_toml
+
+
+def test_pep621_license_string(tmp_path):
+    path = tmp_path / "pyproject.toml"
+    path.write_text(
+        '[project]\nname = "demo"\nlicense = "MIT"\n',
+        encoding="utf-8",
+    )
+    assert get_licenses_from_pyproject_toml(str(path)) == ["MIT"]
+
+
+def test_pep621_license_text_table(tmp_path):
+    path = tmp_path / "pyproject.toml"
+    path.write_text(
+        '[project]\nname = "demo"\nlicense = {text = "MIT"}\n',
+        encoding="utf-8",
+    )
+    assert get_licenses_from_pyproject_toml(str(path)) == ["MIT"]
+
+
+def test_pep621_license_file_returns_empty(tmp_path):
+    path = tmp_path / "pyproject.toml"
+    path.write_text(
+        '[project]\nname = "demo"\nlicense = {file = "LICENSE"}\n',
+        encoding="utf-8",
+    )
+    assert get_licenses_from_pyproject_toml(str(path)) == []
+
+
+def test_legacy_poetry_license(tmp_path):
+    path = tmp_path / "pyproject.toml"
+    path.write_text(
+        '[tool.poetry]\nname = "demo"\nlicense = "Apache-2.0"\n',
+        encoding="utf-8",
+    )
+    assert get_licenses_from_pyproject_toml(str(path)) == ["Apache-2.0"]
+
+
+def test_project_license_file_does_not_fall_back_to_poetry(tmp_path):
+    path = tmp_path / "pyproject.toml"
+    path.write_text(
+        '[project]\nname = "demo"\nlicense = {file = "LICENSE"}\n\n'
+        '[tool.poetry]\nname = "demo"\nlicense = "MIT"\n',
+        encoding="utf-8",
+    )
+    assert get_licenses_from_pyproject_toml(str(path)) == []

fosslight_source-2.3.9/tests/test_manifest_recommended_scenarios.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2026 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+"""Recommended verification scenarios for Android.bp manifest handling."""
+
+from fosslight_source._scan_item import SourceItem
+from fosslight_source.cli import merge_results
+
+
+def test_scenario1_android_bp_keeps_scancode_licenses():
+    """Android.bp with ScanCode licenses: is_manifest_file=True, licenses preserved."""
+    scancode_item = SourceItem("Android.bp")
+    scancode_item.licenses = ["Apache-2.0", "unknown-license-reference", "BSD", "MIT", "OFL"]
+
+    merged, _, _, _ = merge_results(
+        scancode_result=[scancode_item],
+        manifest_licenses={"Android.bp": []},
+    )
+
+    assert len(merged) == 1
+    assert merged[0].is_manifest_file is True
+    assert merged[0].licenses == ["Apache-2.0", "unknown-license-reference", "BSD", "MIT", "OFL"]
+
+
+def test_scenario2_package_json_manifest_fail_keeps_scancode_licenses():
+    """package.json manifest extraction fails but ScanCode row exists: manifest flag only."""
+    scancode_item = SourceItem("app/package.json")
+    scancode_item.licenses = ["Apache-2.0"]
+
+    merged, _, _, _ = merge_results(
+        scancode_result=[scancode_item],
+        manifest_licenses={"app/package.json": []},
+    )
+
+    assert len(merged) == 1
+    assert merged[0].is_manifest_file is True
+    assert merged[0].licenses == ["Apache-2.0"]
+
+
+def test_scenario3_android_bp_from_spdx_marks_manifest_without_new_row():
+    """Android.bp added by spdx merge: manifest flag on existing item, no duplicate row."""
+    spdx_item = SourceItem("module/Android.bp")
+    spdx_item.download_location = ["https://example.com/repo"]
+
+    merged, _, _, _ = merge_results(
+        scancode_result=[spdx_item],
+        manifest_licenses={"module/Android.bp": []},
+    )
+
+    assert len(merged) == 1
+    assert merged[0].is_manifest_file is True
+    assert merged[0].download_location == ["https://example.com/repo"]
+    assert merged[0].licenses == []
+
+
+def test_scenario3_android_bp_not_in_result_no_row_non_ui():
+    """Android.bp absent from merge result: no row in non-UI mode."""
+    merged_non_ui, _, _, _ = merge_results(
+        scancode_result=[],
+        manifest_licenses={"module/Android.bp": []},
+        ui_mode=False,
+    )
+    assert merged_non_ui == []
+
+
+def test_scenario3_android_bp_not_in_result_ui_keeps_empty_row():
+    """Android.bp absent from merge result: UI mode still creates manifest row."""
+    merged_ui, _, _, _ = merge_results(
+        scancode_result=[],
+        manifest_licenses={"module/Android.bp": []},
+        ui_mode=True,
+    )
+
+    assert len(merged_ui) == 1
+    assert merged_ui[0].source_name_or_path == "module/Android.bp"
+    assert merged_ui[0].is_manifest_file is True
+    assert merged_ui[0].licenses == []

{fosslight_source-2.3.8 → fosslight_source-2.3.9}/tests/test_parsing_unknown_spdx.py

@@ -21,6 +21,7 @@ from fosslight_source._parsing_scancode_file_item import (
         ("// SPDX-License-Identifier, MIT", "MIT"),
         ("// SPDX-License-Identifier MIT", "MIT"),
         ('        "SPDX-license-identifier-BSD",', "BSD"),
+        ('        "SPDX-license-identifier-OFL", // by exception only', "OFL"),
         ("/* SPDX-License-Identifier: MIT */", "MIT"),
         ("<!-- SPDX-License-Identifier: MIT -->", "MIT"),
         ("# SPDX-License-Identifier: LicenseRef-MIT-like", "MIT-like"),
@@ -281,3 +282,65 @@ def test_two_license_comment_omits_outer_parentheses():
     assert success is True
     assert results[0].licenses == ["Apache-2.0", "MIT"]
     assert results[0].comment == "Apache-2.0 OR MIT"
+
+
+def test_android_bp_soong_license_kinds_without_line_comment_in_license():
+    scancode_file_list = [{
+        "path": "Android.bp",
+        "type": "file",
+        "detected_license_expression": (
+            "(apache-2.0 AND unknown-license-reference) AND (unknown-spdx AND mit)"
+        ),
+        "license_detections": [
+            {
+                "license_expression": "apache-2.0 AND unknown-license-reference",
+                "matches": [
+                    {
+                        "license_expression": "apache-2.0",
+                        "matched_text": (
+                            "// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
+                            "// limitations under the License."
+                        ),
+                    },
+                    {
+                        "license_expression": "unknown-license-reference",
+                        "matched_text": "// *** THIS PACKAGE HAS SPECIAL LICENSING CONDITIONS.  PLEASE",
+                    },
+                ],
+            },
+            {
+                "license_expression": "unknown-spdx AND mit",
+                "matches": [
+                    {
+                        "license_expression": "unknown-spdx",
+                        "matched_text": '        "SPDX-license-identifier-BSD",',
+                    },
+                    {
+                        "license_expression": "mit",
+                        "matched_text": '        "SPDX-license-identifier-MIT",',
+                    },
+                    {
+                        "license_expression": "unknown-spdx",
+                        "matched_text": (
+                            '        "SPDX-license-identifier-OFL", // by exception only'
+                        ),
+                    },
+                ],
+            },
+        ],
+        "copyrights": [],
+    }]
+
+    success, results, _messages, _ = parsing_scancode(scancode_file_list)
+
+    assert success is True
+    licenses = results[0].licenses
+    assert licenses == [
+        "Apache-2.0",
+        "unknown-license-reference",
+        "BSD",
+        "MIT",
+        "OFL",
+    ]
+    assert all("//" not in lic for lic in results[0].licenses)
+    assert all('"' not in lic for lic in results[0].licenses)