Rename detection_rules to detection_log

Signed-off-by: Ayan Sinha Mahapatra <ayansmahapatra@gmail.com>

Author: AyanSinhaMahapatra

src/formattedcode/output_csv.py

@@ -146,13 +146,13 @@ def collect_keys(mapping, key_group):
 
         for detection in scanned_file.get('license_detections', []):
             license_expression = detection["license_expression"]
-            detection_rules = detection["detection_rules"]
-            detection_rules = '\n'.join(detection_rules)
+            detection_log = detection["detection_log"]
+            detection_log = '\n'.join(detection_log)
             license_matches = detection["matches"]
             for match in license_matches:
                 lic = dict(path=path)
                 lic["license_expression"] = license_expression
-                lic["detection_rules"] = detection_rules
+                lic["detection_log"] = detection_log
 
                 for k, val in match.items():
                     # do not include matched text for now.

src/licensedcode/detection.py

@@ -66,7 +66,7 @@ def logger_debug(*args):
 
 
 MATCHER_UNDETECTED = '5-undetected'
- 
+
 # All values of match_coverage less than this value and more than
 # `IMPERFECT_MATCH_COVERAGE_THR` are taken as `near-perfect-match-coverage` cases
 IMPERFECT_MATCH_COVERAGE_THR = 100
@@ -153,7 +153,7 @@ class LicenseDetection:
             'using the SPDX license expression syntax and ScanCode license keys.')
     )
 
-    detection_rules = attr.ib(
+    detection_log = attr.ib(
         repr=False,
         default=attr.Factory(list),
         metadata=dict(
@@ -197,7 +197,7 @@ def from_matches(
                 package_license=package_license
             )
 
-        reasons, license_expression = get_detected_license_expression(
+        detection_log, license_expression = get_detected_license_expression(
             matches=matches,
             analysis=analysis,
             post_scan=post_scan,
@@ -209,7 +209,7 @@ def from_matches(
         return cls(
             matches=matches,
             license_expression=str(license_expression),
-            detection_rules=reasons,
+            detection_log=detection_log,
         )
 
     def __eq__(self, other):
@@ -346,7 +346,7 @@ def append(
         """
         Append the ``match`` LicenseMatch to this detection and update it
         accordingly.
-        Append the ``reason`` to the detection_rules.
+        Append the ``reason`` to the detection_log.
 
         If ``combine_license`` is True the license_expression of the ``match``
         is combined with the detection license_expression. Do not combine
@@ -373,7 +373,7 @@ def append(
         self.matches.append(match)
         self.length += match.length
         if reason:
-            self.detection_rules.append(reason)
+            self.detection_log.append(reason)
 
         licensing = get_cache().licensing
         if combine_license:
@@ -705,92 +705,92 @@ def has_unknown_references_to_local_files(license_matches):
 
 def get_detected_license_expression(matches, analysis, post_scan=False):
     """
-    Return a tuple of (reasons, combined_expression) by combining a `matches` list of
+    Return a tuple of (detection_log, combined_expression) by combining a `matches` list of
     LicenseMatch objects using an `analysis` code string.
     """
     if TRACE or TRACE_ANALYSIS:
         logger_debug(f'license_matches {matches}', f'package_license {analysis}', f'post_scan: {post_scan}')
 
     matches_for_expression = None
     combined_expression = None
-    reasons = []
+    detection_log = []
 
     if analysis == DetectionCategory.FALSE_POSITVE.value:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionRule.FALSE_POSITIVE.value}')
-        reasons.append(DetectionRule.FALSE_POSITIVE.value)
-        return reasons, combined_expression
+        detection_log.append(DetectionRule.FALSE_POSITIVE.value)
+        return detection_log, combined_expression
 
     elif analysis == DetectionCategory.UNDETECTED_LICENSE.value:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionCategory.UNDETECTED_LICENSE.value}')
         matches_for_expression = matches
-        reasons.append(DetectionRule.UNDETECTED_LICENSE.value)
+        detection_log.append(DetectionRule.UNDETECTED_LICENSE.value)
 
     elif analysis == DetectionCategory.UNKNOWN_INTRO_BEFORE_DETECTION.value:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionCategory.UNKNOWN_INTRO_BEFORE_DETECTION.value}')
         matches_for_expression = filter_license_intros(matches)
-        reasons.append(DetectionRule.UNKNOWN_INTRO_FOLLOWED_BY_MATCH.value)
+        detection_log.append(DetectionRule.UNKNOWN_INTRO_FOLLOWED_BY_MATCH.value)
 
     elif post_scan:
         if analysis == DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value)
+            detection_log.append(DetectionRule.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value)
 
         elif analysis == DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_NONEXISTENT_PACKAGE.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_NONEXISTENT_PACKAGE.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.UNKNOWN_REFERENCE_IN_FILE_TO_NONEXISTENT_PACKAGE.value)
+            detection_log.append(DetectionRule.UNKNOWN_REFERENCE_IN_FILE_TO_NONEXISTENT_PACKAGE.value)
 
         elif analysis == DetectionCategory.UNKNOWN_FILE_REFERENCE_LOCAL.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.UNKNOWN_FILE_REFERENCE_LOCAL.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.UNKNOWN_REFERENCE_TO_LOCAL_FILE.value)
+            detection_log.append(DetectionRule.UNKNOWN_REFERENCE_TO_LOCAL_FILE.value)
 
         elif analysis == DetectionCategory.PACKAGE_UNKNOWN_FILE_REFERENCE_LOCAL.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.PACKAGE_UNKNOWN_FILE_REFERENCE_LOCAL.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.PACKAGE_UNKNOWN_REFERENCE_TO_LOCAL_FILE.value)
+            detection_log.append(DetectionRule.PACKAGE_UNKNOWN_REFERENCE_TO_LOCAL_FILE.value)
 
         elif analysis == DetectionCategory.PACKAGE_ADD_FROM_SIBLING_FILE.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.PACKAGE_ADD_FROM_SIBLING_FILE.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.PACKAGE_ADD_FROM_SIBLING_FILE.value)
+            detection_log.append(DetectionRule.PACKAGE_ADD_FROM_SIBLING_FILE.value)
 
         elif analysis == DetectionCategory.PACKAGE_ADD_FROM_FILE.value:
             if TRACE_ANALYSIS:
                 logger_debug(f'analysis {DetectionCategory.PACKAGE_ADD_FROM_FILE.value}')
             matches_for_expression = filter_license_references(matches)
-            reasons.append(DetectionRule.PACKAGE_ADD_FROM_FILE.value)
+            detection_log.append(DetectionRule.PACKAGE_ADD_FROM_FILE.value)
 
     elif analysis == DetectionCategory.UNKNOWN_MATCH.value:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionCategory.UNKNOWN_MATCH.value}')
         matches_for_expression = matches
-        reasons.append(DetectionRule.UNKNOWN_MATCH.value)
-        return reasons, combined_expression
+        detection_log.append(DetectionRule.UNKNOWN_MATCH.value)
+        return detection_log, combined_expression
 
     elif analysis == DetectionCategory.LICENSE_CLUES.value:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionCategory.LICENSE_CLUES.value}')
-        reasons.append(DetectionRule.LICENSE_CLUES.value)
-        return reasons, combined_expression
+        detection_log.append(DetectionRule.LICENSE_CLUES.value)
+        return detection_log, combined_expression
 
     else:
         if TRACE_ANALYSIS:
             logger_debug(f'analysis {DetectionRule.NOT_COMBINED.value}')
         matches_for_expression = matches
-        reasons.append(DetectionRule.NOT_COMBINED.value)
+        detection_log.append(DetectionRule.NOT_COMBINED.value)
 
     if TRACE:
-        logger_debug(f'matches_for_expression: {matches_for_expression}', f'reasons: {reasons}')
+        logger_debug(f'matches_for_expression: {matches_for_expression}', f'detection_log: {detection_log}')
 
     if isinstance(matches[0], dict):
         combined_expression = combine_expressions(
@@ -804,7 +804,7 @@ def get_detected_license_expression(matches, analysis, post_scan=False):
     if TRACE or TRACE_ANALYSIS:
         logger_debug(f'combined_expression {combined_expression}')
 
-    return reasons, combined_expression
+    return detection_log, combined_expression
 
 
 def get_unknown_license_detection(query_string):

src/licensedcode/plugin_license.py

@@ -252,13 +252,13 @@ def add_referenced_license_matches_for_detections(resource, codebase):
         if not detection_modified:
             continue
 
-        reasons, license_expression = get_detected_license_expression(
+        detection_log, license_expression = get_detected_license_expression(
             matches=matches,
             analysis=DetectionCategory.UNKNOWN_FILE_REFERENCE_LOCAL.value,
             post_scan=True,
         )
         detection["license_expression"] = str(license_expression)
-        detection["detection_rules"] = reasons
+        detection["detection_log"] = detection_log
 
     if modified:
         license_expressions = [

src/licensedcode/plugin_licenses_reference.py

@@ -228,7 +228,7 @@ def get_license_detection_references(license_detections_by_path):
     Get LicenseDetection data for references from a mapping of path:[LicenseDetection],
     i.e. path and a list of LicenseDetection at that path.
 
-    Also removes `matches` and `detection_rules` from each LicenseDetection mapping
+    Also removes `matches` and `detection_log` from each LicenseDetection mapping
     and only keeps a LicenseExpression string and an computed identifier per detection,
     as this LicenseDetection data is referenced at top-level by the identifier.
     """
@@ -239,7 +239,7 @@ def get_license_detection_references(license_detections_by_path):
         for detection in detections:
             detection_obj = LicenseDetection(**detection)
             _matches = detection.pop('matches')
-            _reasons = detection.pop('detection_rules')
+            _detection_log = detection.pop('detection_log')
             detection_obj.file_region = detection_obj.get_file_region(path=path)
             detection["id"] = detection_obj.identifier
 

src/packagedcode/licensing.py

@@ -114,13 +114,13 @@ def add_referenced_license_matches_for_package(resource, codebase, no_licenses):
             if not detection_modified:
                 continue
 
-            reasons, license_expression = get_detected_license_expression(
+            detection_log, license_expression = get_detected_license_expression(
                 matches=matches,
                 analysis=DetectionCategory.PACKAGE_UNKNOWN_FILE_REFERENCE_LOCAL.value,
                 post_scan=True,
             )
             detection["license_expression"] = str(license_expression)
-            detection["detection_rules"] = reasons
+            detection["detection_log"] = detection_log
 
         if modified:
             license_expressions = [
@@ -211,18 +211,18 @@ def add_referenced_license_detection_from_package(resource, codebase, no_license
                     modified = True
                     detection_modified = True
                     matches.extend(pkg_detection["matches"])
-                    analysis=DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value
+                    analysis = DetectionCategory.UNKNOWN_REFERENCE_IN_FILE_TO_PACKAGE.value
 
         if not detection_modified:
             continue
 
-        reasons, license_expression = get_detected_license_expression(
+        detection_log, license_expression = get_detected_license_expression(
             matches=matches,
             analysis=analysis,
             post_scan=True,
         )
         detection["license_expression"] = str(license_expression)
-        detection["detection_rules"] = reasons
+        detection["detection_log"] = detection_log
 
     if modified:
 

src/packagedcode/plugin_package.py

@@ -238,10 +238,10 @@ def add_license_from_file(resource, codebase, no_licenses):
             pkg["license_detections"] = license_detections_file.copy()
             for detection in pkg["license_detections"]:
 
-                if detection["detection_rules"] == [DetectionRule.NOT_COMBINED.value]:
-                    detection["detection_rules"] = [DetectionRule.PACKAGE_ADD_FROM_FILE.value]
+                if detection["detection_log"] == [DetectionRule.NOT_COMBINED.value]:
+                    detection["detection_log"] = [DetectionRule.PACKAGE_ADD_FROM_FILE.value]
                 else:
-                    detection["detection_rules"].append(DetectionRule.PACKAGE_ADD_FROM_FILE.value)
+                    detection["detection_log"].append(DetectionRule.PACKAGE_ADD_FROM_FILE.value)
 
             license_expression = get_license_expression_from_detection_mappings(
                 detections=license_detections_file,

tests/cluecode/data/plugin_filter_clues/filtered-expected.json

@@ -24,7 +24,7 @@
       "license_detections": [
         {
           "license_expression": "apache-1.1",
-          "detection_rules": [
+          "detection_log": [
             "not-combined"
           ],
           "matches": [

tests/cluecode/data/plugin_filter_clues/filtered-expected2.json

@@ -24,7 +24,7 @@
       "license_detections": [
         {
           "license_expression": "pygres-2.2",
-          "detection_rules": [
+          "detection_log": [
             "not-combined"
           ],
           "matches": [

tests/cluecode/data/plugin_filter_clues/filtered-expected3.json

@@ -24,7 +24,7 @@
       "license_detections": [
         {
           "license_expression": "pcre",
-          "detection_rules": [
+          "detection_log": [
             "not-combined"
           ],
           "matches": [