Create validate method on Licensing #56

    * Create functions that loads a Licensing object with SPDX licenses

Signed-off-by: Jono Yang <[email protected]>

Author: JonoYang

src/license_expression/__init__.py

@@ -39,6 +39,7 @@
 from copy import deepcopy
 from functools import total_ordering
 import itertools
+import json
 import re
 import string
 
@@ -599,6 +600,102 @@ def simple_tokenizer(self, expression):
                         sym = LicenseSymbol(key=sym_or_op)
                     yield Token(start, end, sym_or_op, sym)
 
+    def validate(self, expression, strict=False, simple=False, **kwargs):
+        data = {
+            'normalized_license_expression': '',
+            'errors': [],
+            'valid_symbols': [],
+            'invalid_symbols': [],
+            'exception_symbols': [],
+        }
+
+        if expression is None:
+            return data
+
+        if isinstance(expression, LicenseExpression):
+            data['normalized_license_expression'] = expression.render()
+            return data
+
+        if isinstance(expression, bytes):
+            try:
+                expression = str(expression)
+            except:
+                ext = type(expression)
+                data['errors'].append('expression must be a string and not: %(ext)r' % locals())
+                return data
+
+        if not isinstance(expression, str):
+            ext = type(expression)
+            data['errors'].append('expression must be a string and not: %(ext)r' % locals())
+            return data
+
+        if not expression or not expression.strip():
+            return
+        try:
+            # this will raise a ParseError on errors
+            tokens = list(self.tokenize(expression, strict=strict, simple=simple))
+            expression = super(Licensing, self).parse(tokens)
+        except ParseError as e:
+            new_error = ExpressionParseError(
+                token_type=e.token_type, token_string=e.token_string,
+                position=e.position, error_code=e.error_code)
+            data['errors'].append(str(new_error))
+            data['invalid_symbols'].append(e.token_string)
+            return data
+
+        if not isinstance(expression, LicenseExpression):
+            data['errors'].append('expression must be a LicenseExpression once parsed.')
+            return data
+
+        unknown_keys = self.unknown_license_keys(expression, unique=True)
+        if unknown_keys:
+            msg = 'Unknown license key(s): {}'.format(', '.join(unknown_keys))
+            data['errors'].append(msg)
+            data['invalid_symbols'].extend(unknown_keys)
+            return data
+
+        symbols = list(expression.symbols)
+        data['normalized_license_expression'] = expression.render()
+        data['valid_symbols'] = [s.render() for s in symbols]
+        data['exception_symbols'] = [s.render() for s in symbols if isinstance(s, LicenseWithExceptionSymbol) or s.is_exception]
+        return data
+
+
+def build_spdx_licensing(index_json_location=None):
+    # if no index_json, use vendored version
+    # TODO: vendor index.json
+
+    if index_json_location:
+        with open(index_json_location, 'r') as f:
+            license_info = json.load(f)
+    else:
+        with open(vendored_index_json_location, 'r') as f:
+            license_info = json.load(f)
+
+    lics = [
+        {
+            'key': l.get('spdx_license_key', ''),
+            'aliases': l.get('other_spdx_license_keys', ''),
+            'is_exception': l.get('is_exception', ''),
+        } for l in license_info
+    ]
+    syms = [LicenseSymbol(**l) for l in lics]
+    return Licensing(syms)
+
+
+def build_spdx_licensing_scancode():
+    from licensedcode.cache import get_licenses_db
+    ld = get_licenses_db()
+    ld_spdx = [
+        {
+            'key': l.spdx_license_key,
+            'aliases': l.other_spdx_license_keys,
+            'is_exception': l.is_exception
+        } for _, l in ld.items()
+    ]
+    syms = [LicenseSymbol(**l) for l in ld_spdx]
+    return Licensing(syms)
+
 
 def build_symbols_from_unknown_tokens(tokens):
     """