bare-script 3.7.2__tar.gz → 3.7.3__tar.gz

{bare_script-3.7.2/src/bare_script.egg-info → bare_script-3.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 3.7.2
+Version: 3.7.3
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs

{bare_script-3.7.2 → bare_script-3.7.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bare-script
-version = 3.7.2
+version = 3.7.3
 url = https://github.com/craigahobbs/bare-script
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com

{bare_script-3.7.2 → bare_script-3.7.3}/src/bare_script/bare.py

@@ -75,11 +75,11 @@ def main(argv=None):
             if args.static or args.debug:
                 warnings = lint_script(script)
                 if not warnings:
-                    print(f'BareScript: Static analysis "{script_name}" ... OK')
+                    print(f'BareScript static analysis "{script_name}" ... OK')
                 else:
-                    print(f'BareScript: Static analysis "{script_name}" ... {len(warnings)} warning{"s" if len(warnings) > 1 else ""}:')
+                    print(f'BareScript static analysis "{script_name}" ... {len(warnings)} warning{"s" if len(warnings) > 1 else ""}:')
                     for warning in warnings:
-                        print(f'BareScript:     {warning}')
+                        print(warning)
                     if args.static:
                         status_code = 1
                         break
@@ -104,7 +104,7 @@ def main(argv=None):
             # 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')
+                print(f'BareScript executed in {1000 * (time_end - time_begin):.1f} milliseconds')
 
             # Stop on error status code
             if status_code != 0:

{bare_script-3.7.2 → bare_script-3.7.3}/src/bare_script/model.py

@@ -330,10 +330,11 @@ def lint_script(script):
     """
 
     warnings = []
+    statements = script['statements']
 
     # Empty script?
     if len(script['statements']) == 0:
-        warnings.append('Empty script')
+        _lint_script_warning(warnings, script, None, 'Empty script')
 
     # Variable used before assignment?
     var_assigns = {}
@@ -341,15 +342,13 @@ def lint_script(script):
     _get_variable_assignments_and_uses(script['statements'], var_assigns, var_uses)
     for var_name in sorted(var_assigns.keys()):
         if var_name in var_uses and var_uses[var_name] <= var_assigns[var_name]:
-            warnings.append(
-                f'Global variable "{var_name}" used (index {var_uses[var_name]}) before assignment (index {var_assigns[var_name]})'
-            )
+            _lint_script_warning(warnings, script, statements[var_uses[var_name]], f'Global variable "{var_name}" used before assignment')
 
     # Iterate global statements
     functions_defined = {}
     labels_defined = {}
     labels_used = {}
-    for ix_statement, statement in enumerate(script['statements']):
+    for ix_statement, statement in enumerate(statements):
         statement_key = next(iter(statement.keys()))
 
         # Function definition checks
@@ -358,7 +357,7 @@ def lint_script(script):
 
             # Function redefinition?
             if function_name in functions_defined:
-                warnings.append(f'Redefinition of function "{function_name}" (index {ix_statement})')
+                _lint_script_warning(warnings, script, statement, f'Redefinition of function "{function_name}"')
             else:
                 functions_defined[function_name] = ix_statement
 
@@ -372,16 +371,17 @@ def lint_script(script):
                 if args is not None and var_name in args:
                     continue
                 if var_name in fn_var_uses and fn_var_uses[var_name] <= fn_var_assigns[var_name]:
-                    warnings.append(
-                        f'Variable "{var_name}" of function "{function_name}" used (index {fn_var_uses[var_name]}) ' +
-                            f'before assignment (index {fn_var_assigns[var_name]})'
+                    _lint_script_warning(
+                        warnings, script, statement,
+                        f'Variable "{var_name}" of function "{function_name}" used before assignment'
                     )
 
             # Unused variables?
             for var_name in sorted(fn_var_assigns.keys()):
                 if var_name not in fn_var_uses:
-                    warnings.append(
-                        f'Unused variable "{var_name}" defined in function "{function_name}" (index {fn_var_assigns[var_name]})'
+                    _lint_script_warning(
+                        warnings, script, statement,
+                        f'Unused variable "{var_name}" defined in function "{function_name}"'
                     )
 
             # Function argument checks
@@ -390,13 +390,13 @@ def lint_script(script):
                 for arg in args:
                     # Duplicate argument?
                     if arg in args_defined:
-                        warnings.append(f'Duplicate argument "{arg}" of function "{function_name}" (index {ix_statement})')
+                        _lint_script_warning(warnings, script, statement, f'Duplicate argument "{arg}" of function "{function_name}"')
                     else:
                         args_defined.add(arg)
 
                         # Unused argument?
                         if arg not in fn_var_uses:
-                            warnings.append(f'Unused argument "{arg}" of function "{function_name}" (index {ix_statement})')
+                            _lint_script_warning(warnings, script, statement, f'Unused argument "{arg}" of function "{function_name}"')
 
             # Iterate function statements
             fn_labels_defined = {}
@@ -408,15 +408,16 @@ def lint_script(script):
                 if fn_statement_key == 'expr':
                     # Pointless function expression statement?
                     if 'name' not in fn_statement['expr'] and _is_pointless_expression(fn_statement['expr']['expr']):
-                        warnings.append(f'Pointless statement in function "{function_name}" (index {ix_fn_statement})')
+                        _lint_script_warning(warnings, script, statement, f'Pointless statement in function "{function_name}"')
 
                 # Function label statement checks
                 elif fn_statement_key == 'label':
                     # Label redefinition?
                     fn_statement_label = fn_statement['label']['name']
                     if fn_statement_label in fn_labels_defined:
-                        warnings.append(
-                            f'Redefinition of label "{fn_statement_label}" in function "{function_name}" (index {ix_fn_statement})'
+                        _lint_script_warning(
+                            warnings, script, statement,
+                            f'Redefinition of label "{fn_statement_label}" in function "{function_name}"'
                         )
                     else:
                         fn_labels_defined[fn_statement_label] = ix_fn_statement
@@ -428,25 +429,25 @@ def lint_script(script):
             # Unused function labels?
             for label in sorted(fn_labels_defined.keys()):
                 if label not in fn_labels_used:
-                    warnings.append(f'Unused label "{label}" in function "{function_name}" (index {fn_labels_defined[label]})')
+                    _lint_script_warning(warnings, script, statement, f'Unused label "{label}" in function "{function_name}"')
 
             # Unknown function labels?
             for label in sorted(fn_labels_used.keys()):
                 if label not in fn_labels_defined:
-                    warnings.append(f'Unknown label "{label}" in function "{function_name}" (index {fn_labels_used[label]})')
+                    _lint_script_warning(warnings, script, statement, f'Unknown label "{label}" in function "{function_name}"')
 
         # Global expression statement checks
         elif statement_key == 'expr':
             # Pointless global expression statement?
             if 'name' not in statement['expr'] and _is_pointless_expression(statement['expr']['expr']):
-                warnings.append(f'Pointless global statement (index {ix_statement})')
+                _lint_script_warning(warnings, script, statement, 'Pointless global statement')
 
         # Global label statement checks
         elif statement_key == 'label':
             # Label redefinition?
             statement_label = statement['label']['name']
             if statement_label in labels_defined:
-                warnings.append(f'Redefinition of global label "{statement_label}" (index {ix_statement})')
+                _lint_script_warning(warnings, script, statement, f'Redefinition of global label "{statement_label}"')
             else:
                 labels_defined[statement_label] = ix_statement
 
@@ -457,16 +458,28 @@ def lint_script(script):
     # Unused global labels?
     for label in sorted(labels_defined.keys()):
         if label not in labels_used:
-            warnings.append(f'Unused global label "{label}" (index {labels_defined[label]})')
+            _lint_script_warning(warnings, script, statements[labels_defined[label]], f'Unused global label "{label}"')
 
     # Unknown global labels?
     for label in sorted(labels_used.keys()):
         if label not in labels_defined:
-            warnings.append(f'Unknown global label "{label}" (index {labels_used[label]})')
+            _lint_script_warning(warnings, script, statements[labels_used[label]], f'Unknown global label "{label}"')
 
     return warnings
 
 
+# Helper to format static analysis warnings
+def _lint_script_warning(warnings, script, statement, message):
+    if script and statement:
+        statement_key = next(iter(statement.keys()))
+        script_name = script.get('scriptName', '')
+        lineno = statement[statement_key].get('lineNumber', '')
+        warning = f'{script_name}:{lineno}: {message}' if script_name or lineno else message
+    else:
+        warning = message
+    warnings.append(warning)
+
+
 # Helper function to determine if an expression statement's expression is pointless
 def _is_pointless_expression(expr):
     expr_key = next(iter(expr.keys()))

{bare_script-3.7.2 → bare_script-3.7.3}/src/bare_script/parser.py

@@ -77,20 +77,24 @@ def parse_script(script_text, start_line_number=1, script_name=None):
         # Assignment?
         match_assignment = _R_SCRIPT_ASSIGNMENT.match(line)
         if match_assignment:
+            # Parse the expression
             try:
-                expr_statement = {
-                    'expr': {
-                        'name': match_assignment.group('name'),
-                        'expr': parse_expression(match_assignment.group('expr'), line_number, script_name, True),
-                        **statement_base
-                    }
-                }
-                statements.append(expr_statement)
-                continue
+                assignment_expr = parse_expression(match_assignment.group('expr'), line_number, script_name, True)
             except BareScriptParserError as error:
                 column_number = len(line) - len(match_assignment.group('expr')) + error.column_number
                 raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
 
+            # Add the expression statement
+            expr_statement = {
+                'expr': {
+                    'name': match_assignment.group('name'),
+                    'expr': assignment_expr,
+                    **statement_base
+                }
+            }
+            statements.append(expr_statement)
+            continue
+
         # Function definition begin?
         match_function_begin = _R_SCRIPT_FUNCTION_BEGIN.match(line)
         if match_function_begin:
@@ -136,11 +140,18 @@ def parse_script(script_text, start_line_number=1, script_name=None):
         # If-then begin?
         match_if_begin = _R_SCRIPT_IF_BEGIN.match(line)
         if match_if_begin:
+            # Parse the if-then expression
+            try:
+                ifthen_expr = parse_expression(match_if_begin.group('expr'), line_number, script_name, True)
+            except BareScriptParserError as error:
+                column_number = len(match_if_begin.group('if')) + error.column_number
+                raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
+
             # Add the if-then label definition
             ifthen = {
                 'jump': {
                     'label': f"__bareScriptIf{label_index}",
-                    'expr': {'unary': {'op': '!', 'expr': parse_expression(match_if_begin.group('expr'), line_number, script_name, True)}},
+                    'expr': {'unary': {'op': '!', 'expr': ifthen_expr}},
                     **statement_base
                 },
                 'done': f"__bareScriptDone{label_index}",
@@ -158,7 +169,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
         # Else-if-then?
         match_if_else_if = _R_SCRIPT_IF_ELSE_IF.match(line)
         if match_if_else_if:
-            # Get the if-then definition
+            # Get the else-if-then definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
             ifthen = label_defs[len(label_defs) - 1].get('if') if len(label_defs) > label_def_depth else None
             if ifthen is None:
@@ -168,11 +179,18 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             if ifthen['hasElse']:
                 raise BareScriptParserError('Elif statement following else statement', line, 1, start_line_number + ix_line, script_name)
 
+            # Parse teh else-if-then expression
+            try:
+                if_else_if_expr = parse_expression(match_if_else_if.group('expr'), line_number, script_name, True)
+            except BareScriptParserError as error:
+                column_number = len(match_if_else_if.group('elif')) + error.column_number
+                raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
+
             # Generate the next if-then jump statement
             prev_label = ifthen['jump']['label']
             ifthen['jump'] = {
                 'label': f"__bareScriptIf{label_index}",
-                'expr': {'unary': {'op': '!', 'expr': parse_expression(match_if_else_if.group('expr'), line_number, script_name, True)}},
+                'expr': {'unary': {'op': '!', 'expr': if_else_if_expr}},
                 **statement_base
             }
             label_index += 1
@@ -226,12 +244,19 @@ def parse_script(script_text, start_line_number=1, script_name=None):
         # While-do begin?
         match_while_begin = _R_SCRIPT_WHILE_BEGIN.match(line)
         if match_while_begin:
+            # Parse the while-do expression
+            try:
+                while_begin_expr = parse_expression(match_while_begin.group('expr'), line_number, script_name, True)
+            except BareScriptParserError as error:
+                column_number = len(match_while_begin.group('while')) + error.column_number
+                raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
+
             # Add the while-do label
             whiledo = {
                 'loop': f'__bareScriptLoop{label_index}',
                 'continue': f'__bareScriptLoop{label_index}',
                 'done': f'__bareScriptDone{label_index}',
-                'expr': parse_expression(match_while_begin.group('expr'), line_number, script_name, True),
+                'expr': while_begin_expr,
                 'line': line,
                 'lineNumber': start_line_number + ix_line
             }
@@ -282,11 +307,18 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             label_defs.append({'for': foreach})
             label_index += 1
 
+            # Parse the for-each expression
+            try:
+                for_begin_expr = parse_expression(match_for_begin.group('values'), line_number, script_name, True)
+            except BareScriptParserError as error:
+                column_number = len(match_for_begin.group('for')) + error.column_number
+                raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
+
             # Add the for-each header statements
             statements.extend([
                 {'expr': {
                     'name': foreach['values'],
-                    'expr': parse_expression(match_for_begin.group('values'), line_number, script_name, True),
+                    'expr': for_begin_expr,
                     **statement_base
                 }},
                 {'expr': {
@@ -453,15 +485,15 @@ _R_SCRIPT_JUMP = re.compile(r'^(?P<jump>\s*(?:jump|jumpif\s*\((?P<expr>.+)\)))\s
 _R_SCRIPT_RETURN = re.compile(r'^(?P<return>\s*return(?:\s+(?P<expr>[^#\s].*))?)' + _R_PART_COMMENT)
 _R_SCRIPT_INCLUDE = re.compile(r"^\s*include\s+(?P<delim>')(?P<url>(?:\\'|[^'])*)'" + _R_PART_COMMENT)
 _R_SCRIPT_INCLUDE_SYSTEM = re.compile(r'^\s*include\s+(?P<delim><)(?P<url>[^>]*)>' + _R_PART_COMMENT)
-_R_SCRIPT_IF_BEGIN = re.compile(r'^\s*if\s+(?P<expr>.+)\s*:' + _R_PART_COMMENT)
-_R_SCRIPT_IF_ELSE_IF = re.compile(r'^\s*elif\s+(?P<expr>.+)\s*:' + _R_PART_COMMENT)
+_R_SCRIPT_IF_BEGIN = re.compile(r'^(?P<if>\s*if\s+)(?P<expr>.+)\s*:' + _R_PART_COMMENT)
+_R_SCRIPT_IF_ELSE_IF = re.compile(r'^(?P<elif>\s*elif\s+)(?P<expr>.+)\s*:' + _R_PART_COMMENT)
 _R_SCRIPT_IF_ELSE = re.compile(r'^\s*else\s*:' + _R_PART_COMMENT)
 _R_SCRIPT_IF_END = re.compile(r'^\s*endif' + _R_PART_COMMENT)
 _R_SCRIPT_FOR_BEGIN = re.compile(
-    r'^\s*for\s+(?P<value>[A-Za-z_]\w*)(?:\s*,\s*(?P<index>[A-Za-z_]\w*))?\s+in\s+(?P<values>.+)\s*:' + _R_PART_COMMENT
+    r'^(?P<for>\s*for\s+(?P<value>[A-Za-z_]\w*)(?:\s*,\s*(?P<index>[A-Za-z_]\w*))?\s+in\s+)(?P<values>.+)\s*:' + _R_PART_COMMENT
 )
 _R_SCRIPT_FOR_END = re.compile(r'^\s*endfor' + _R_PART_COMMENT)
-_R_SCRIPT_WHILE_BEGIN = re.compile(r'^\s*while\s+(?P<expr>.+)\s*:' + _R_PART_COMMENT)
+_R_SCRIPT_WHILE_BEGIN = re.compile(r'^(?P<while>\s*while\s+)(?P<expr>.+)\s*:' + _R_PART_COMMENT)
 _R_SCRIPT_WHILE_END = re.compile(r'^\s*endwhile' + _R_PART_COMMENT)
 _R_SCRIPT_BREAK = re.compile(r'^\s*break' + _R_PART_COMMENT)
 _R_SCRIPT_CONTINUE = re.compile(r'^\s*continue' + _R_PART_COMMENT)
@@ -637,22 +669,22 @@ def _parse_unary_expression(expr_text, array_literals):
                 arg_text = arg_text[len(match_object_close.group(0)):]
                 break
 
-            # Object key separator
+            # Key/value pair separator
             if args:
-                match_object_key_separator = _R_EXPR_OBJECT_SEPARATOR2.match(arg_text)
-                if match_object_key_separator is None:
+                match_object_separator = _R_EXPR_OBJECT_SEPARATOR.match(arg_text)
+                if match_object_separator is None:
                     raise BareScriptParserError('Syntax error', arg_text, 1, None, None)
-                arg_text = arg_text[len(match_object_key_separator.group(0)):]
+                arg_text = arg_text[len(match_object_separator.group(0)):]
 
             # Get the key
             arg_key, arg_text = _parse_binary_expression(arg_text, None, array_literals)
             args.append(arg_key)
 
-            # Value separator
-            match_object_value_separator = _R_EXPR_OBJECT_SEPARATOR.match(arg_text)
-            if match_object_value_separator is None:
+            # Key/value separator
+            match_object_separator_key = _R_EXPR_OBJECT_SEPARATOR_KEY.match(arg_text)
+            if match_object_separator_key is None:
                 raise BareScriptParserError('Syntax error', arg_text, 1, None, None)
-            arg_text = arg_text[len(match_object_value_separator.group(0)):]
+            arg_text = arg_text[len(match_object_separator_key.group(0)):]
 
             # Get the value
             arg_value, arg_text = _parse_binary_expression(arg_text, None, array_literals)
@@ -719,8 +751,8 @@ _R_EXPR_ARRAY_OPEN = re.compile(r'^\s*\[')
 _R_EXPR_ARRAY_SEPARATOR = re.compile(r'^\s*,')
 _R_EXPR_ARRAY_CLOSE = re.compile(r'^\s*\]')
 _R_EXPR_OBJECT_OPEN = re.compile(r'^\s*\{')
-_R_EXPR_OBJECT_SEPARATOR = re.compile(r'^\s*:')
-_R_EXPR_OBJECT_SEPARATOR2 = re.compile(r'^\s*,')
+_R_EXPR_OBJECT_SEPARATOR_KEY = re.compile(r'^\s*:')
+_R_EXPR_OBJECT_SEPARATOR = re.compile(r'^\s*,')
 _R_EXPR_OBJECT_CLOSE = re.compile(r'^\s*\}')
 _R_EXPR_STRING = re.compile(r"^\s*'((?:\\\\|\\'|[^'])*)'")
 _R_EXPR_STRING_DOUBLE = re.compile(r'^\s*"((?:\\\\|\\"|[^"])*)"')

{bare_script-3.7.2 → bare_script-3.7.3}/src/bare_script/runtime.py

@@ -151,7 +151,7 @@ def _execute_script_helper(script, statements, options, locals_):
                         warning_prefix = f'BareScript: Include "{include_url}" static analysis...'
                         log_fn(f'{warning_prefix} {len(warnings)} warning{"s" if len(warnings) > 1 else ""}:')
                         for warning in warnings:
-                            log_fn(f'BareScript:     {warning}')
+                            log_fn(f'BareScript: {warning}')
 
                 # Execute the include script
                 include_options = options.copy()

{bare_script-3.7.2 → bare_script-3.7.3/src/bare_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 3.7.2
+Version: 3.7.3
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs