loxxy 0.4.00 → 0.4.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47c5d65fa1f3c2d0025013577f46edf741572df743d8986e238f49a08ea32702
-  data.tar.gz: 72a3beb6828362e6dc7c73072555ed6f87ed5bf57b4052ac55e06503b9582e29
+  metadata.gz: 03ef0a6b112537abbb890f56a5746a22be8aa9373451ce57a25d33ffd4cfe2be
+  data.tar.gz: 3abea4f9bfd799de85840c93a91aa37d0f9676b5e1d9af6a68bef7d189843470
 SHA512:
-  metadata.gz: e83ee511c1ead4592153bb1e8ed8167439894bfefa2bb54060100eb9d221d77c453b4bad3d3e4a36209f3761812a5b9b0aa98b02a53556314c022d1f0b605bca
-  data.tar.gz: 8d939d7ff60687dd64c4dc6e4beccffa512e3483f5b38042a83fffbc0a5cc83d218999f855b8765a47e24b8c0df7808ecd649e70cec11832a0591b5c141a659c
+  metadata.gz: 74a279e2033090d6f4df08f30e4e71cf3c34c29dff2d2400a066528b68e73b2019345a84cabfad59f0342f8ba0a0d2ebf47ce87ac2195223a9c68886febb6a72
+  data.tar.gz: 9e1c5ba2b8e88af10c198bcefdc8a791be2900df2ee71127df560f1bcbfa18f03bc4cf86d149cc475cf5392938e4d74bb769d4a80630c9a5c82e0da90c936135

data/.rubocop.yml

@@ -50,6 +50,9 @@ Layout/IndentationConsistency:
 Layout/HeredocIndentation:
   Enabled: false
 
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: true
+
 Layout/MultilineHashBraceLayout:
   Enabled: true
 
@@ -81,6 +84,9 @@ Layout/TrailingWhitespace:
 Lint/AmbiguousAssignment:
   Enabled: true
 
+Lint/AmbiguousRange:
+  Enabled: true
+
 Lint/DeprecatedConstants:
   Enabled: true
 
@@ -96,6 +102,9 @@ Lint/EmptyBlock:
 Lint/EmptyClass:
   Enabled: false
 
+Lint/EmptyInPattern:
+  Enabled: true
+
 Lint/LambdaWithoutLiteralBlock:
   Enabled: true
 
@@ -192,6 +201,9 @@ Naming/ClassAndModuleCamelCase:
 Naming/BlockParameterName:
   Enabled: true
 
+Naming/InclusiveLanguage:
+  Enabled: true
+
 Naming/MethodParameterName:
   Enabled: false
 
@@ -273,11 +285,17 @@ Style/HashTransformValues:
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/InPatternThen:
+  Enabled: true
+
 Style/InverseMethods:
   Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false
+  
+Style/MultilineInPatternThen:
+  Enabled: true  
 
 Style/NegatedIfElseCondition:
   Enabled: true
@@ -290,6 +308,9 @@ Style/NilLambda:
 
 Style/NumericLiterals:
   Enabled: false
+  
+Style/QuotedSymbols:
+  Enabled: true  
 
 Style/RaiseArgs:
   Enabled: true
@@ -302,6 +323,9 @@ Style/RedundantReturn:
 
 Style/RedundantSelf:
   Enabled: true
+  
+Style/RedundantSelfAssignmentBranch:
+  Enabled: true  
 
 Style/RegexpLiteral:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.4.01] - 2021-08-22
+- Grammar and AST::AstBuilder adapted to take profit of extended grammar notiation in Rley 0.8.01
+
+### Changed
+- Class `Ast::ASTBuilder` removal of methods made redundant with new Rley version
+- File `.rubocop.yml` added config for new cops
+- File `grammar.rb` changed rules to use new extended rule syntax in Rley
+
 ## [0.4.00] - 2021-05-24
 - Version bump. `Loxxy` is capable to run the LoxLox interpreter, an interpreter written in `Lox`.
 

data/lib/loxxy/ast/ast_builder.rb

@@ -143,63 +143,36 @@ module Loxxy
       #  SEMANTIC ACTIONS
       #####################################
 
-      # rule('program' => 'EOF').as 'null_program'
-      def reduce_null_program(_production, _range, _tokens, _theChildren)
-        Ast::LoxNoopExpr.new(tokens[0].position)
-      end
-
-      # rule('program' => 'declaration_plus EOF').as ''
+      # rule('program' => 'declaration+ EOF').as ''
       def reduce_lox_program(_production, _range, tokens, theChildren)
-        LoxSeqDecl.new(tokens[0].position, theChildren[0])
-      end
-
-      # rule('declaration_plus' => 'declaration_plus declaration').as ''
-      def reduce_declaration_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('declaration_plus' => 'declaration')
-      def reduce_declaration_plus_end(_production, _range, _tokens, theChildren)
-        [theChildren[0]]
+        if theChildren[0].empty?
+          Ast::LoxNoopExpr.new(tokens[0].position)
+        else
+          LoxSeqDecl.new(tokens[0].position, theChildren[0])
+        end
       end
 
       # rule('classDecl' => 'CLASS classNaming class_body')
       def reduce_class_decl(_production, _range, _tokens, theChildren)
-        if theChildren[1].kind_of?(Array)
-          name = theChildren[1].first
-          parent = theChildren[1].last
-        else
-          name = theChildren[1]
-          parent = nil
-        end
+        name = theChildren[1].first
+        parent = theChildren[1].last
         Ast::LoxClassStmt.new(tokens[1].position, name, parent, theChildren[2])
       end
 
-      # rule('classNaming' => 'IDENTIFIER')
-      def reduce_class_name(_production, _range, _tokens, theChildren)
-        theChildren[0].token.lexeme
-      end
-
-      # rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
-      def reduce_class_subclassing(_production, _range, _tokens, theChildren)
-        super_token = theChildren[2].token
-        super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+      # rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?')
+      def reduce_class_naming(_production, _range, _tokens, theChildren)
+        if theChildren[1].nil?
+          super_var = nil
+        else
+          super_token = theChildren[1].subnodes[1].token
+          super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+        end
         [theChildren[0].token.lexeme, super_var]
       end
 
-      # rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE')
+      # rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE')
       def reduce_class_body(_production, _range, _tokens, theChildren)
-        theChildren[1].nil? ? [] : theChildren[1]
-      end
-
-      # rule('method_plus' => 'method_plus function')
-      def reduce_method_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('method_plus' => 'function')
-      def reduce_method_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        theChildren[1]
       end
 
       # rule('funDecl' => 'FUN function')
@@ -212,16 +185,11 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
-      # rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      # rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? SEMICOLON')
       def reduce_var_declaration(_production, _range, tokens, theChildren)
         var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxVarStmt.new(tokens[1].position, var_name, nil)
-      end
-
-      # rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
-      def reduce_var_initialization(_production, _range, tokens, theChildren)
-        var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
+        init_val = theChildren[2] ? theChildren[2].subnodes[1] : nil
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, init_val)
       end
 
       # rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
@@ -248,7 +216,7 @@ module Loxxy
         for_stmt
       end
 
-      # rule('forControl' => 'forInitialization forTest forUpdate')
+      # rule('forControl' => 'forInitialization forTest expression?')
       def reduce_for_control(_production, _range, tokens, theChildren)
         (init, test, update) = theChildren
         if test.nil? && update
@@ -265,7 +233,7 @@ module Loxxy
         nil
       end
 
-      # rule('forTest' => 'expression_opt SEMICOLON')
+      # rule('forTest' => 'expression? SEMICOLON')
       def reduce_for_test(_production, range, tokens, theChildren)
         return_first_child(range, tokens, theChildren)
       end
@@ -292,7 +260,7 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       end
 
-      # rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      # rule('returnStmt' => 'RETURN expression? SEMICOLON')
       def reduce_return_stmt(_production, _range, tokens, theChildren)
         Ast::LoxReturnStmt.new(tokens[1].position, theChildren[1])
       end
@@ -302,34 +270,31 @@ module Loxxy
         Ast::LoxWhileStmt.new(tokens[1].position, theChildren[2], theChildren[4])
       end
 
-      # rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      # rule('block' => 'LEFT_BRACE declaration* RIGHT_BRACE')
       def reduce_block_stmt(_production, _range, tokens, theChildren)
-        decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
-        Ast::LoxBlockStmt.new(tokens[1].position, decls)
-      end
-
-      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
-      def reduce_block_empty(_production, _range, tokens, _children)
-        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+        decls = nil
+        if theChildren[1]
+          pos = tokens[1].position
+          decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
+        else
+          pos = tokens[0].position
+        end
+        Ast::LoxBlockStmt.new(pos, decls)
       end
 
-      # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      # rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         name_assignee = theChildren[1].token.lexeme.dup
-        if theChildren[0].kind_of?(Ast::LoxSetExpr)
-          theChildren[0].property = name_assignee
-          theChildren[0].value = theChildren[3]
-          theChildren[0]
+        if theChildren[0]
+          set_expr = Ast::LoxSetExpr.new(tokens[1].position, theChildren[0].subnodes[0])
+          set_expr.property = name_assignee
+          set_expr.value = theChildren[3]
+          set_expr
         else
           Ast::LoxAssignExpr.new(tokens[1].position, name_assignee, theChildren[3])
         end
       end
 
-      # rule('owner_opt' => 'call DOT')
-      def reduce_set_expr(_production, _range, tokens, theChildren)
-        Ast::LoxSetExpr.new(tokens[1].position, theChildren[0])
-      end
-
 
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
@@ -343,6 +308,7 @@ module Loxxy
 
       # rule('call' => 'primary refinement_plus').as 'call_expr'
       def reduce_call_expr(_production, _range, _tokens, theChildren)
+        # return theChildren[0] unless theChildren[1]
         members = theChildren.flatten
         call_expr = nil
         loop do
@@ -365,7 +331,7 @@ module Loxxy
         theChildren
       end
 
-      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      # rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN')
       def reduce_call_arglist(_production, _range, tokens, theChildren)
         args = theChildren[1] || []
         if args.size > 255
@@ -422,24 +388,21 @@ module Loxxy
         LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
       end
 
-      # rule('parameters' => 'parameters COMMA IDENTIFIER')
-      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[2].token.lexeme
-      end
+      # rule('parameters' => 'IDENTIFIER (COMMA IDENTIFIER)*').as 'parameters'
+      def reduce_parameters(_production, _range, _tokens, theChildren)
+        first_lexeme = theChildren[0].token.lexeme
+        return [first_lexeme] unless theChildren[1]
 
-      # rule('parameters' => 'IDENTIFIER')
-      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
-        [theChildren[0].token.lexeme]
+        successors = theChildren[1].map { |seq_node| seq_node.subnodes[1].token.lexeme }
+        successors.unshift(first_lexeme)
       end
 
-      # rule('arguments' => 'arguments COMMA expression')
-      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[2]
-      end
+      # rule('arguments' => 'expression (COMMA expression)*')
+      def reduce_arguments(_production, _range, _tokens, theChildren)
+        return [theChildren[0]] unless theChildren[1]
 
-      # rule('arguments' => 'expression')
-      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        successors = theChildren[1].map { |seq_node| seq_node.subnodes[1] }
+        successors.unshift(theChildren[0])
       end
     end # class
   end # module

data/lib/loxxy/ast/lox_node.rb

@@ -11,7 +11,7 @@ module Loxxy
       # Let nodes take `visitee` role as defined in the Visitor design pattern
       extend ASTVisitee
 
-      # return [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @return [Rley::Lexical::Position] Position of the entry in the input stream.
       attr_reader :position
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/front_end/grammar.rb

@@ -7,9 +7,9 @@ module Loxxy
   module FrontEnd
     ########################################
     # Grammar for Lox language
-    # Authoritave grammar at:
+    # Authoritative grammar at:
     #   https://craftinginterpreters.com/appendix-i.html
-    builder = Rley::Syntax::GrammarBuilder.new do
+    builder = Rley::grammar_builder do
       # Punctuators, separators...
       add_terminals('LEFT_PAREN', 'RIGHT_PAREN', 'LEFT_BRACE', 'RIGHT_BRACE')
       add_terminals('COMMA', 'DOT', 'MINUS', 'PLUS')
@@ -26,30 +26,21 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF').as 'null_program'
-      rule('program' => 'declaration_plus EOF').as 'lox_program'
+      rule('program' => 'declaration* EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
-      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
       rule('declaration' => 'stmt')
 
       rule('classDecl' => 'CLASS classNaming class_body').as 'class_decl'
-      rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER').as 'class_subclassing'
-      rule('classNaming' => 'IDENTIFIER').as 'class_name'
-      rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE').as 'class_body'
-      rule('methods_opt' => 'method_plus')
-      rule('methods_opt' => [])
-      rule('method_plus' => 'method_plus function').as 'method_plus_more'
-      rule('method_plus' => 'function').as 'method_plus_end'
+      rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?').as 'class_naming'
+      rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE').as 'class_body'
 
       rule('funDecl' => 'FUN function').as 'fun_decl'
 
-      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
-      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
+      rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? SEMICOLON').as 'var_declaration'
 
       # Statements: produce side effects, but don't introduce bindings
       rule('stmt' => 'statement')
@@ -65,12 +56,11 @@ module Loxxy
       rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement').as 'for_stmt'
-      rule('forControl' => 'forInitialization forTest forUpdate').as 'for_control'
+      rule('forControl' => 'forInitialization forTest expression?').as 'for_control'
       rule('forInitialization' => 'varDecl')
       rule('forInitialization' => 'exprStmt')
       rule('forInitialization' => 'SEMICOLON').as 'empty_for_initialization'
-      rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
-      rule('forUpdate' => 'expression_opt')
+      rule('forTest' => 'expression? SEMICOLON').as 'for_test'
 
       rule('ifStmt' => 'IF ifCondition statement ELSE statement').as 'if_else_stmt'
       rule('unbalancedStmt' => 'IF ifCondition stmt').as 'if_stmt'
@@ -78,19 +68,14 @@ module Loxxy
       rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
-      rule('returnStmt' => 'RETURN expression_opt SEMICOLON').as 'return_stmt'
+      rule('returnStmt' => 'RETURN expression? SEMICOLON').as 'return_stmt'
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
-      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
-      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      rule('block' => 'LEFT_BRACE declaration* RIGHT_BRACE').as 'block_stmt'
 
       # Expressions: produce values
-      rule('expression_opt' => 'expression')
-      rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
+      rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
-      rule('owner_opt' => 'call DOT').as 'set_expr'
-      rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
       rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
       rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'binary_plus_more'
@@ -130,10 +115,8 @@ module Loxxy
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
       rule('call' => 'primary')
-      rule('call' => 'primary refinement_plus').as 'call_expr'
-      rule('refinement_plus' => 'refinement_plus refinement').as 'refinement_plus_more'
-      rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
-      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
+      rule('call' => 'primary refinement+').as 'call_expr'
+      rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN').as 'call_arglist'
       rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
@@ -146,15 +129,9 @@ module Loxxy
       rule('primary' => 'SUPER DOT IDENTIFIER').as 'super_expr'
 
       # Utility rules
-      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
-      rule('params_opt' => 'parameters')
-      rule('params_opt' => [])
-      rule('parameters' => 'parameters COMMA IDENTIFIER').as 'parameters_plus_more'
-      rule('parameters' => 'IDENTIFIER').as 'parameters_plus_end'
-      rule('arguments_opt' => 'arguments')
-      rule('arguments_opt' => [])
-      rule('arguments' => 'arguments COMMA expression').as 'arguments_plus_more'
-      rule('arguments' => 'expression').as 'arguments_plus_end'
+      rule('function' => 'IDENTIFIER LEFT_PAREN parameters? RIGHT_PAREN block').as 'function'
+      rule('parameters' => 'IDENTIFIER (COMMA IDENTIFIER)*').as 'parameters'
+      rule('arguments' => 'expression (COMMA expression)*').as 'arguments'
     end
 
     unless defined?(Grammar)

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.4.00'
+  VERSION = '0.4.01'
 end

data/loxxy.gemspec

@@ -48,7 +48,7 @@ Gem::Specification.new do |spec|
   DESCR_END
   spec.homepage      = 'https://github.com/famished-tiger/loxxy'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '~> 2.4'
+  spec.required_ruby_version = '~> 2.5'
 
   spec.bindir        = 'bin'
   spec.executables   = ['loxxy']
@@ -58,7 +58,7 @@ Gem::Specification.new do |spec|
   PkgExtending.pkg_documentation(spec)
 
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.06'
+  spec.add_dependency 'rley', '~> 0.8.01'
 
   # Development dependencies
   spec.add_development_dependency 'bundler', '~> 2.0'

data/spec/front_end/raw_parser_spec.rb

@@ -26,7 +26,10 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          eof = aParseTree.root.subnodes.first
+          (decls, eof) = aParseTree.root.subnodes
+          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes).to be_empty
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -73,8 +76,12 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_plus')
-          stmt = decls.subnodes[0].subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[0].symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[1].symbol.name).to eq('declaration')
+          stmt = decls.subnodes[1].subnodes[0]
           expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(stmt.symbol.name).to eq('stmt')
           statement = stmt.subnodes[0]

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'rspec' # Use the RSpec framework
-require 'loxxy'
+require_relative '../lib/loxxy'
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.4.00
+  version: 0.4.01
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-24 00:00:00.000000000 Z
+date: 2021-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.01
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.01
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="