checkmate5 4.0.67__py3-none-any.whl

checkmate/helpers/issue.py

@@ -0,0 +1,101 @@
+from collections import defaultdict
+from checkmate.lib.stats.mapreduce import MapReducer
+
+
+class IssuesMapReducer(MapReducer):
+
+    def __init__(self, aggregators, count_column='count', group_by=['language', 'analyzer', 'code']):
+        self.aggregators = aggregators
+        self.count_column = count_column
+        self.group_by = group_by
+
+    def map(self, item):
+        for group in self.group_by:
+            if not group in item:
+                return []
+        return [(key, item) for aggregator in self.aggregators
+                for key in aggregator(item)]
+
+    def reduce(self, key, items):
+        grouped_issues = {}
+
+        if self.group_by:
+            for item in items:
+                invalid_item = False
+                current_dict = grouped_issues
+                for group in self.group_by[:-1]:
+                    if not group in item:
+                        invalid_item = True
+                        break
+                    if not item[group] in current_dict:
+                        current_dict[item[group]] = {}
+                    current_dict = current_dict[item[group]]
+                if not self.group_by[-1] in item:
+                    invalid_item = True
+                if invalid_item:
+                    continue
+                if not item[self.group_by[-1]] in current_dict:
+                    current_dict[item[self.group_by[-1]]] = [0, 0]
+                cd = current_dict[item[self.group_by[-1]]]
+                cd[0] += 1
+                cd[1] += item[self.count_column]
+            return grouped_issues
+        else:
+            issues_sum = [0, 0]
+            for item in items:
+                issues_sum[0] += 1
+                issues_sum[1] += item[self.count_column]
+            return issues_sum
+
+
+def group_issues_by_fingerprint(issues):
+    """
+    Groups issues by fingerprint. Grouping is done by issue code in addition.
+    IMPORTANT: It is assumed that all issues come from the SAME analyzer.
+    """
+    issues_by_fingerprint = defaultdict(list)
+    for issue in issues:
+        if not 'fingerprint' in issue:
+            raise AttributeError("No fingerprint defined for issue with analyzer %s and code %s!" %
+                                 (issue.get('analyzer', '(undefined)'), issue['code']))
+        fp_code = "%s:%s" % (issue['fingerprint'], issue['code'])
+        if fp_code in issues_by_fingerprint:
+            grouped_issue = issues_by_fingerprint[fp_code]
+        else:
+            grouped_issue = issue.copy()
+            grouped_issue['occurrences'] = []
+            if 'location' in grouped_issue:
+                del grouped_issue['location']
+            issues_by_fingerprint[fp_code] = grouped_issue
+
+        locations = issue.get('location', [])
+        if locations:
+            for i, start_stop in enumerate(locations):
+
+                occurrence = {
+                    'from_row': None,
+                    'to_row': None,
+                    'from_column': None,
+                    'to_column': None,
+                    'sequence': i
+                }
+
+                grouped_issue['occurrences'].append(occurrence)
+
+                if not isinstance(start_stop, (list, tuple)) or not len(start_stop) == 2:
+                    continue
+
+                start, stop = start_stop
+
+                if isinstance(start, (list, tuple)) and len(start) == 2:
+                    occurrence['from_row'] = start[0]
+                    occurrence['from_column'] = start[1]
+
+                if isinstance(stop, (list, tuple)) and len(stop) == 2:
+                    occurrence['to_row'] = stop[0]
+                    occurrence['to_column'] = stop[1]
+
+            grouped_issue['occurrences'] = sorted(
+                grouped_issue['occurrences'], key=lambda x: (x['from_row'], x['from_column']))
+
+    return list(issues_by_fingerprint.values())

checkmate/helpers/settings.py

@@ -0,0 +1,14 @@
+
+def update(d, ud):
+    """
+    Recursively merge the values of ud into d.
+    """
+    if ud is None:
+        return
+    for key, value in list(ud.items()):
+        if not key in d:
+            d[key] = value
+        elif isinstance(value, dict):
+            update(d[key], value)
+        else:
+            d[key] = value

checkmate/lib/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

checkmate/lib/analysis/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+from .base import *

checkmate/lib/analysis/base.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+
+
+import abc
+from checkmate.helpers.hashing import Hasher
+
+
+class AnalyzerSettingsError(BaseException):
+
+    def __init__(self, errors):
+        "Errors should be a dictionary"
+        self.errors = errors
+
+
+class BaseAnalyzer(object):
+
+    """
+    This abstract base class defines an analyzer, which takes file content and produces
+    statistics as well as a list of issues. It is also responsible for diffing statistical
+    data and issues obtained for different file revisions or snapshots.
+    """
+
+    def __init__(self,
+                 code_environment,
+                 settings=None,
+                 ignore=None):
+        self.code_environment = code_environment
+        if settings:
+            self.validate_settings(settings)
+        self.settings = settings
+        if ignore is not None:
+            self.ignore = {}
+            for code in ignore:
+                self.ignore[code] = True
+
+    def get_fingerprint_from_code(self, file_revision, location, extra_data=None):
+        """
+        This function generates a fingerprint from a series of code snippets.
+
+        Can be used by derived analyzers to generate fingerprints based on code
+        if nothing better is available.
+        """
+        code = file_revision.get_file_content()
+        if not isinstance(code, str):
+            code = str(code, errors='ignore')
+        lines = code.split("\n")
+        s = ""
+        for l in location:
+            ((from_row, from_column), (to_row, to_column)) = l
+            if from_column is None:
+                continue
+            if from_row == to_row:
+                s += lines[from_row-1][from_column:to_column]
+            else:
+                if to_row < from_row:
+                    raise ValueError("from_row must be smaller than to_row")
+                s += lines[from_row-1][from_column:]
+                current_row = from_row+1
+                while current_row < to_row:
+                    s += lines[current_row-1]
+                    current_row += 1
+                s += lines[current_row-1][:to_column]
+
+        hasher = Hasher()
+        hasher.add(s)
+
+        if extra_data is not None:
+            hasher.add(extra_data)
+
+        return hasher.digest.hexdigest()
+
+    @classmethod
+    def validate_settings(cls, settings):
+        # should raise AnalyzerSettingsError if the settings are not valid
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def analyze(self, file_revision):
+        """
+        Analyze a file and return a tuple (stats,issues) containing statistics and issues.
+
+        This method should return a dictionary with one of the following entries:
+
+        * issues: A list of issues found in the file revision
+        * stats: Statistics about the file revision
+        * depends_on: A list of dependencies for the file revision
+        * provides: A list of things the file revision provides (e.g. a module),
+                    to be used with the `depends_on` field.
+        """
+        pass
+
+    def diff(self, results_a, results_b):
+        pass
+
+    def diff_summary(self, summary_a, summary_b):
+        pass
+
+    @abc.abstractmethod
+    def summarize(self, items):
+        """
+        Aggregate a list of items containing statistical information generated by 'analyze'.
+        """
+        pass

checkmate/lib/code/__init__.py

@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+
+from checkmate.lib.code.environment import CodeEnvironment