bare-script 0.9.0__py3-none-any.whl

bare_script/__init__.py

@@ -0,0 +1,33 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script package
+"""
+
+from .library import \
+    EXPRESSION_FUNCTIONS, \
+    SCRIPT_FUNCTIONS
+
+from .model import \
+    BARE_SCRIPT_TYPES, \
+    lint_script, \
+    validate_expression, \
+    validate_script
+
+from .options import \
+    fetch_http, \
+    fetch_read_only, \
+    fetch_read_write, \
+    log_print, \
+    url_file_relative
+
+from .parser import \
+    BareScriptParserError, \
+    parse_expression, \
+    parse_script
+
+from .runtime import \
+    BareScriptRuntimeError, \
+    evaluate_expression, \
+    execute_script

bare_script/__main__.py

@@ -0,0 +1,12 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script top-level script environment
+"""
+
+from .bare import main
+
+
+if __name__ == '__main__': # pragma: no cover
+    main()

bare_script/bare.py

@@ -0,0 +1,109 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script command-line interface (CLI) main module
+"""
+
+import argparse
+from functools import partial
+import sys
+import time
+
+from .model import lint_script
+from .options import fetch_read_write, log_print, url_file_relative
+from .parser import parse_script
+from .runtime import execute_script
+
+
+def main(argv=None):
+    """
+    BareScript command-line interface (CLI) main entry point
+    """
+
+    # Command line arguments
+    parser = argparse.ArgumentParser(prog='bare', description='The BareScript command-line interface')
+    parser.add_argument('filename', nargs='*', action=_ScriptAction, help='files to process')
+    parser.add_argument('-c', '--code', nargs=1, action=_ScriptAction, help='execute the BareScript code')
+    parser.add_argument('-d', '--debug', action='store_true', help='enable debug mode')
+    parser.add_argument('-s', '--static', action='store_true', help='perform static analysis')
+    parser.add_argument('-v', '--var', nargs=2, action='append', metavar=('VAR', 'EXPR'),
+                        help='set a global variable to an expression value')
+    args = parser.parse_args(args=argv)
+
+    status_code = 0
+    current_file = None
+    try:
+        # Parse and execute all source files in order
+        globals_ = dict(args.var) if args.var is not None else {}
+        for file_, source in args.files:
+            current_file = file_
+
+            # Parse the source
+            script = parse_script(source if source is not None else fetch_read_write({'url': file_}))
+
+            # Run the bare-script linter?
+            if args.static or args.debug:
+                warnings = lint_script(script)
+                warning_prefix = f'BareScript: Static analysis "{file_}" ...'
+                if not warnings:
+                    print(f'{warning_prefix} OK')
+                else:
+                    print(f'{warning_prefix} {len(warnings)} warning{"s" if len(warnings) > 1 else ""}:')
+                    for warning in warnings:
+                        print(f'BareScript:     {warning}')
+                    if args.static:
+                        # pylint: disable=broad-exception-raised
+                        raise Exception('Static analysis failed')
+            if args.static:
+                continue
+
+            # Execute the script
+            time_begin = time.time()
+            result = execute_script(script, {
+                'debug': args.debug or False,
+                'fetchFn': fetch_read_write,
+                'globals': globals_,
+                'logFn': log_print,
+                'systemPrefix': 'https://craigahobbs.github.io/markdown-up/include/',
+                'urlFn': partial(url_file_relative, file_)
+            })
+            if isinstance(result, (int, float)) and int(result) == result and 0 <= result <= 255:
+                status_code = int(result)
+            else:
+                status_code = 1 if result else 0
+
+            # Log script execution end with timing
+            if args.debug:
+                time_end = time.time()
+                print(f'BareScript: Script executed in {1000 * (time_end - time_begin):.1f} milliseconds')
+
+            # Stop on error status code
+            if status_code != 0:
+                break
+
+    except Exception as e: # pylint: disable=broad-exception-caught
+        if current_file is not None:
+            print(f'{current_file}:')
+        print(str(e))
+        status_code = 1
+
+    # Return the status code
+    sys.exit(status_code)
+
+
+# Custom argparse action for script file arguments
+class _ScriptAction(argparse.Action):
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        files = getattr(namespace, 'files', [])
+        if option_string in ['-c', '--code']:
+            code_count = getattr(namespace, 'code_count', 0)
+            code_count += 1
+            setattr(namespace, 'code_count', code_count)
+            for value in values:
+                files.append((f'-c {code_count}', value))
+        elif option_string is None:
+            for value in values:
+                files.append((value, None))
+        setattr(namespace, 'files', files)

bare_script/baredoc.py

@@ -0,0 +1,137 @@
+# Licensed under the MIT License
+# https://github.com/craigahobbs/bare-script-py/blob/main/LICENSE
+
+"""
+bare-script library documentation command-line interface (CLI) main module
+"""
+
+import json
+import re
+import sys
+
+
+def main():
+    """
+    BareScript library documentation command-line interface (CLI) main entry point
+    """
+
+    # Parse each source file line-by-line
+    errors = []
+    funcs = {}
+    func = None
+    for filename in sys.argv[1:]:
+        with open(filename, 'r', encoding='utf-8') as fh:
+            source = fh.read()
+        lines = R_SPLIT.split(source)
+        for ix_line, line in enumerate(lines):
+            # function/group/doc/return documentation keywords?
+            match_key = R_KEY.match(line)
+            if match_key is not None:
+                key = match_key['key']
+                text = match_key['text']
+                text_trim = text.strip()
+
+                # Keyword used outside of function?
+                if key != 'function' and func is None:
+                    errors.append(f'{filename}:{ix_line + 1}: {key} keyword outside function')
+                    continue
+
+                # Process the keyword
+                if key == 'group':
+                    if text_trim == '':
+                        errors.append(f'{filename}:{ix_line + 1}: Invalid function group name "{text_trim}"')
+                        continue
+                    if 'group' in func:
+                        errors.append(f'{filename}:{ix_line + 1}: Function "{func["name"]}" group redefinition')
+                        continue
+
+                    # Set the function group
+                    func['group'] = text_trim
+
+                elif key in ('doc', 'return'):
+                    # Add the documentation line - don't add leading blank lines
+                    func_doc = func.get('key')
+                    if func_doc is not None or text_trim != '':
+                        if func_doc is None:
+                            func_doc = []
+                            func[key] = func_doc
+                        func_doc.append(text)
+
+                else:
+                    # key == 'function'
+                    if text_trim == '':
+                        errors.append(f'{filename}:{ix_line + 1}: Invalid function name "{text_trim}"')
+                        continue
+                    if text_trim in funcs:
+                        errors.append(f'{filename}:{ix_line + 1}: Function "{text_trim}" redefinition')
+                        continue
+
+                    # Add the function
+                    func = {'name': text_trim}
+                    funcs[text_trim] = func
+
+                continue
+
+            # arg keyword?
+            match_arg = R_ARG.match(line)
+            if match_arg is not None:
+                name = match_arg['name']
+                text = match_arg['text']
+                text_trim = text.strip()
+
+                # Keyword used outside of function?
+                if func is None:
+                    errors.append(f'{filename}:{ix_line + 1}: Function argument "{name}" outside function')
+                    continue
+
+                # Add the function arg documentation line - don't add leading blank lines
+                args = func.get('args')
+                arg = None
+                if args is not None:
+                    arg = next((arg_find for arg_find in args if arg_find['name'] == name), None)
+                if arg is not None or text_trim != '':
+                    if args is None:
+                        args = []
+                        func['args'] = args
+                    if arg is None:
+                        arg = {'name': name, 'doc': []}
+                        args.append(arg)
+                    arg['doc'].append(text)
+
+                continue
+
+            # Unknown documentation comment?
+            match_unknown = R_UNKNOWN.match(line)
+            if match_unknown is not None:
+                unknown = match_unknown.groups['unknown']
+                errors.append(f'{filename}:{ix_line + 1}: Invalid documentation comment "{unknown}"')
+                continue
+
+    # Create the library documentation model
+    library = {
+        'functions': sorted(funcs.values(), key=lambda func: func['name'])
+    }
+
+    # Validate
+    if len(library['functions']) == 0:
+        errors.append('error: No library functions')
+    for func in library['functions']:
+        if 'group' not in func:
+            errors.append(f'error: Function "{func.name}" missing group')
+        if 'doc' not in func:
+            errors.append(f'error: Function "{func.name}" missing documentation')
+
+    # Errors?
+    if len(errors) != 0:
+        print('\n'.join(errors))
+        sys.exit(len(errors))
+
+    # Output the library JSON
+    print(json.dumps(library))
+
+
+# Library documentation regular expressions
+R_KEY = re.compile(r'^\s*(?:\/\/|#)\s*\$(?P<key>function|group|doc|return):\s?(?P<text>.*)$')
+R_ARG = re.compile(r'^\s*(?:\/\/|#)\s*\$arg\s+(?P<name>[A-Za-z_][A-Za-z0-9_]*(?:\.\.\.)?):\s?(?P<text>.*)$')
+R_UNKNOWN = re.compile(r'^\s*(?:\/\/|#)\s*\$(?P<unknown>[^:]+):')
+R_SPLIT = re.compile(r'\r?\n')