rley 0.8.01 → 0.8.02

data/spec/rley/notation/tokenizer_spec.rb

@@ -19,10 +19,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(token.lexeme).to eq(lexeme)
         end
       end
-      
+
       context 'Initialization:' do
-      let(:sample_text) { 'begin-object member-list end-object' }
-      subject { Tokenizer.new }
+        let(:sample_text) { 'begin-object member-list end-object' }
+        subject { Tokenizer.new }
 
         it 'could be initialized with a text to tokenize or...' do
           expect { Tokenizer.new(sample_text) }.not_to raise_error
@@ -36,7 +36,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.scanner).to be_kind_of(StringScanner)
         end
       end # context
-      
+
       context 'Input tokenization:' do
         it 'should recognize single special character token' do
           input = '(){}?*+,'
@@ -47,9 +47,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             %w[RIGHT_PAREN )],
             %w[LEFT_BRACE {],
             %w[RIGHT_BRACE }],
-            %w[QUESTION_MARK ?],            
-            %w[STAR *],             
-            %w[PLUS +],             
+            %w[QUESTION_MARK ?],
+            %w[STAR *],
+            %w[PLUS +],
             %w[COMMA ,]
           ]
           match_expectations(subject, expectations)
@@ -64,7 +64,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ]
           match_expectations(subject, expectations)
         end
-        
+
         it 'should treat ? * + as symbols if they occur as suffix' do
           input = 'a+ + b* * 3 ?'
           subject.start_with(input)
@@ -80,7 +80,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             %w[SYMBOL ?]
           ]
           match_expectations(subject, expectations)
-        end        
+        end
 
         it 'should recognize annotation keywords' do
           keywords = 'match_closest: repeat:'
@@ -110,7 +110,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.tokens[0..-2].each_with_index do |tok, i|
             expect(tok).to be_kind_of(Rley::Lexical::Token)
             expect(tok.terminal).to eq('INT_LIT')
-            (lexeme, val) = expectations[i]
+            (lexeme,) = expectations[i]
             expect(tok.lexeme).to eq(lexeme)
           end
         end
@@ -135,37 +135,31 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.tokens.each_with_index do |str, i|
             expect(str).to be_kind_of(Rley::Lexical::Token)
             expect(str.terminal).to eq('STR_LIT')
-            (lexeme, val) = expectations[i]
+            (lexeme,) = expectations[i]
             expect(str.lexeme).to eq(lexeme)
           end
         end
 
         it 'should recognize a sequence of symbols' do
-          input = "IF ifCondition statement ELSE statement"
-          expectations = [
-            'IF',
-            'ifCondition',
-            'statement',
-            'ELSE',
-            'statement'
-          ]
+          input = 'IF ifCondition statement ELSE statement'
+          expectations = %w[IF ifCondition statement ELSE statement]
 
           subject.start_with(input)
           subject.tokens.each_with_index do |str, i|
             expect(str).to be_kind_of(Rley::Lexical::Token)
             expect(str.terminal).to eq('SYMBOL')
-            (lexeme, val) = expectations[i]
+            (lexeme,) = expectations[i]
             expect(str.lexeme).to eq(lexeme)
           end
         end
 
         it 'should recognize an optional symbol' do
-          input = "RETURN expression? SEMICOLON"
+          input = 'RETURN expression? SEMICOLON'
           expectations = [
-            ['RETURN', 'SYMBOL'],
-            ['expression', 'SYMBOL'],
-            ['?', 'QUESTION_MARK'],
-            ['SEMICOLON', 'SYMBOL'],
+            %w[RETURN SYMBOL],
+            %w[expression SYMBOL],
+            %w[? QUESTION_MARK],
+            %w[SEMICOLON SYMBOL]
           ]
 
           subject.start_with(input)
@@ -178,11 +172,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should recognize a symbol with a star quantifier' do
-          input = "declaration* EOF"
+          input = 'declaration* EOF'
           expectations = [
-            ['declaration', 'SYMBOL'],
-            ['*', 'STAR'],
-            ['EOF', 'SYMBOL'],
+            %w[declaration SYMBOL],
+            %w[* STAR],
+            %w[EOF SYMBOL]
           ]
 
           subject.start_with(input)
@@ -195,11 +189,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should recognize a symbol with a plus quantifier' do
-          input = "declaration+ EOF"
+          input = 'declaration+ EOF'
           expectations = [
-            ['declaration', 'SYMBOL'],
-            ['+', 'PLUS'],
-            ['EOF', 'SYMBOL'],
+            %w[declaration SYMBOL],
+            %w[+ PLUS],
+            %w[EOF SYMBOL]
           ]
 
           subject.start_with(input)
@@ -212,16 +206,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should recognize a grouping with a quantifier' do
-          input = "IF ifCondition statement (ELSE statement)?"
+          input = 'IF ifCondition statement (ELSE statement)?'
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['(', 'LEFT_PAREN'],
-            ['ELSE', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            [')', 'RIGHT_PAREN'],
-            ['?', 'QUESTION_MARK']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[( LEFT_PAREN],
+            %w[ELSE SYMBOL],
+            %w[statement SYMBOL],
+            %w[) RIGHT_PAREN],
+            %w[? QUESTION_MARK]
           ]
 
           subject.start_with(input)
@@ -236,15 +230,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should recognize a match closest constraint' do
           input = "IF ifCondition statement ELSE { match_closest: 'IF' } statement"
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['ELSE', 'SYMBOL'],
-            ['{', 'LEFT_BRACE'],
-            ['match_closest', 'KEY'],
-            ['IF', 'STR_LIT'],
-            ['}', 'RIGHT_BRACE'],
-            ['statement', 'SYMBOL']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[ELSE SYMBOL],
+            %w[{ LEFT_BRACE],
+            %w[match_closest KEY],
+            %w[IF STR_LIT],
+            %w[} RIGHT_BRACE],
+            %w[statement SYMBOL]
           ]
 
           subject.start_with(input)
@@ -257,17 +251,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should recognize a repeat constraint' do
-          input = "IF ifCondition statement { repeat: 1 }  ELSE statement"
+          input = 'IF ifCondition statement { repeat: 1 }  ELSE statement'
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['{', 'LEFT_BRACE'],
-            ['repeat', 'KEY'],
-            ['1', 'INT_LIT'],
-            ['}', 'RIGHT_BRACE'],
-            ['ELSE', 'SYMBOL'],
-            ['statement', 'SYMBOL']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[{ LEFT_BRACE],
+            %w[repeat KEY],
+            %w[1 INT_LIT],
+            %w[} RIGHT_BRACE],
+            %w[ELSE SYMBOL],
+            %w[statement SYMBOL]
           ]
 
           subject.start_with(input)
@@ -280,21 +274,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         it 'should recognize a grouping with a repeat constraint' do
-          input = "IF ifCondition statement ( ELSE statement ){ repeat: 0..1 }"
+          input = 'IF ifCondition statement ( ELSE statement ){ repeat: 0..1 }'
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['(', 'LEFT_PAREN'],
-            ['ELSE', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            [')', 'RIGHT_PAREN'],
-            ['{', 'LEFT_BRACE'],
-            ['repeat', 'KEY'],
-            ['0', 'INT_LIT'],
-            ['..', 'ELLIPSIS'],
-            ['1', 'INT_LIT'],
-            ['}', 'RIGHT_BRACE']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[( LEFT_PAREN],
+            %w[ELSE SYMBOL],
+            %w[statement SYMBOL],
+            %w[) RIGHT_PAREN],
+            %w[{ LEFT_BRACE],
+            %w[repeat KEY],
+            %w[0 INT_LIT],
+            %w[.. ELLIPSIS],
+            %w[1 INT_LIT],
+            %w[} RIGHT_BRACE]
           ]
 
           subject.start_with(input)
@@ -309,18 +303,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should recognize a combination of constraints' do
           input = "IF ifCondition statement ELSE { repeat: 1, match_closest: 'IF' } statement"
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['ELSE', 'SYMBOL'],
-            ['{', 'LEFT_BRACE'],
-            ['repeat', 'KEY'],
-            ['1', 'INT_LIT'],
-            [',', 'COMMA'],
-            ['match_closest', 'KEY'],
-            ['IF', 'STR_LIT'],
-            ['}', 'RIGHT_BRACE'],
-            ['statement', 'SYMBOL']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[ELSE SYMBOL],
+            %w[{ LEFT_BRACE],
+            %w[repeat KEY],
+            %w[1 INT_LIT],
+            %w[, COMMA],
+            %w[match_closest KEY],
+            %w[IF STR_LIT],
+            %w[} RIGHT_BRACE],
+            %w[statement SYMBOL]
           ]
 
           subject.start_with(input)
@@ -335,23 +329,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should recognize a grouping with a nested constraint' do
           input = "IF ifCondition statement ( ELSE { match_closest: 'IF' } statement ){ repeat: 0..1 }"
           expectations = [
-            ['IF', 'SYMBOL'],
-            ['ifCondition', 'SYMBOL'],
-            ['statement', 'SYMBOL'],
-            ['(', 'LEFT_PAREN'],
-            ['ELSE', 'SYMBOL'],
-            ['{', 'LEFT_BRACE'],
-            ['match_closest', 'KEY'],
-            ['IF', 'STR_LIT'],
-            ['}', 'RIGHT_BRACE'],
-            ['statement', 'SYMBOL'],
-            [')', 'RIGHT_PAREN'],
-            ['{', 'LEFT_BRACE'],
-            ['repeat', 'KEY'],
-            ['0', 'INT_LIT'],
-            ['..', 'ELLIPSIS'],
-            ['1', 'INT_LIT'],
-            ['}', 'RIGHT_BRACE']
+            %w[IF SYMBOL],
+            %w[ifCondition SYMBOL],
+            %w[statement SYMBOL],
+            %w[( LEFT_PAREN],
+            %w[ELSE SYMBOL],
+            %w[{ LEFT_BRACE],
+            %w[match_closest KEY],
+            %w[IF STR_LIT],
+            %w[} RIGHT_BRACE],
+            %w[statement SYMBOL],
+            %w[) RIGHT_PAREN],
+            %w[{ LEFT_BRACE],
+            %w[repeat KEY],
+            %w[0 INT_LIT],
+            %w[.. ELLIPSIS],
+            %w[1 INT_LIT],
+            %w[} RIGHT_BRACE]
           ]
 
           subject.start_with(input)

data/spec/rley/parser/dangling_else_spec.rb

@@ -19,15 +19,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe GFGEarleyParser do
       include ExpectationHelper # Mix-in with expectation on parse entry sets
-    
+
+      # rubocop: disable Lint/ConstantDefinitionInBlock
+
       Keyword = {
         'else' => 'ELSE',
         'false' => 'FALSE',
         'if' => 'IF',
         'then' => 'THEN',
         'true' => 'TRUE'
-      }.freeze      
-      
+      }.freeze
+      # rubocop: enable Lint/ConstantDefinitionInBlock
+
       def tokenizer(aTextToParse)
         scanner = StringScanner.new(aTextToParse)
         tokens = []
@@ -35,20 +38,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         loop do
           scanner.skip(/\s+/)
           break if scanner.eos?
-          curr_pos = scanner.pos          
-          lexeme = scanner.scan(/\S+/)        
+
+          curr_pos = scanner.pos
+          lexeme = scanner.scan(/\S+/)
 
           term_name = Keyword[lexeme]
           unless term_name
             if lexeme =~ /\d+/
               term_name = 'INTEGER'
-            else 
+            else
               err_msg = "Unknown token '#{lexeme}'"
               raise StandardError,  err_msg
             end
           end
           pos = Rley::Lexical::Position.new(1, curr_pos + 1)
-          tokens << Rley::Lexical::Token.new(lexeme, term_name, pos)            
+          tokens << Rley::Lexical::Token.new(lexeme, term_name, pos)
         end
 
         tokens
@@ -57,12 +61,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:input) { 'if false then if true then 1 else 2' }
 
       context 'Ambiguous parse: ' do
-        # Factory method. Creates a grammar builder for a simple grammar. 
+        # Factory method. Creates a grammar builder for a simple grammar.
         def grammar_if_else_amb
           builder = Rley::Syntax::BaseGrammarBuilder.new do
             add_terminals('IF', 'THEN', 'ELSE')
             add_terminals('FALSE', 'TRUE', 'INTEGER')
-            
+
             rule 'program' => 'stmt'
             rule 'stmt' => 'IF boolean THEN stmt'
             rule 'stmt' => 'IF boolean THEN stmt ELSE stmt'
@@ -72,7 +76,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             rule 'boolean' => 'FALSE'
             rule 'boolean' => 'TRUE'
           end
-          
+
           builder.grammar
         end
 
@@ -390,7 +394,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'boolean => . TRUE | 8'
           ]
           result8 = parse_result.chart[8]
-          found = parse_result.chart.search_entries(4, {before: 'IF'})
+          # found = parse_result.chart.search_entries(4, { before: 'IF' })
           expect(result8.entries.size).to eq(11)
           compare_entry_texts(result8, expected)
           expected_terminals(result8, %w[FALSE IF INTEGER TRUE])
@@ -441,5 +445,3 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     end # describe
   end # module
 end # module
-  
-      

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -22,6 +22,7 @@ require_relative '../support/expectation_helper'
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
+  # rubocop: disable Metrics/BlockLength
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe GFGEarleyParser do
       include GrammarABCHelper # Mix-in module with builder for grammar abc
@@ -302,7 +303,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'sequence => . sequence comma integer | 0', # start rule
             'sequence => . integer | 0',                # start rule
             '.integer | 0',                             # call rule
-            'integer => . digit_plus | 0' ,             # start rule
+            'integer => . digit_plus | 0',              # start rule
             '.digit_plus | 0',                          # call rule
             'digit_plus => . digit_plus digit | 0',     # start rule (generated)
             'digit_plus => . digit | 0'                 # start rule (generated)
@@ -314,7 +315,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = [
             'digit_plus => digit . | 0',                # Scan
             'digit_plus. | 0',                          # exit rule
-            'integer => digit_plus . | 0' ,             # end rule
+            'integer => digit_plus . | 0',              # end rule
             'digit_plus => digit_plus . digit | 0',     # rule (generated)
             'integer. | 0',                             # exit rule
             'sequence => integer . | 0',                # end rule
@@ -329,8 +330,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # Expectation chart[2]:
           expected = [
             'sequence => sequence comma . integer | 0', #  Scan
-            '.integer | 2',                # call rule
-            'integer => . digit_plus | 2' ,             # start rule
+            '.integer | 2',                             # call rule
+            'integer => . digit_plus | 2',              # start rule
             '.digit_plus | 2',                          # call rule
             'digit_plus => . digit_plus digit | 2',     # start rule (generated)
             'digit_plus => . digit | 2'                 # start rule (generated)
@@ -342,13 +343,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = [
             'digit_plus => digit . | 2',                # Scan
             'digit_plus. | 2',                          # exit rule
-            'integer => digit_plus . | 2' ,             # end rule
+            'integer => digit_plus . | 2',              # end rule
             'digit_plus => digit_plus . digit | 2',     # rule (generated)
             'integer. | 2',                             # exit rule
             'sequence => sequence comma integer . | 0', # rule
-            'sequence. | 0',                             # exit rule
+            'sequence. | 0',                            # exit rule
             'S => sequence . | 0',                      # end rule
-            'sequence => sequence . comma integer | 0', #  rule
+            'sequence => sequence . comma integer | 0'  #  rule
           ]
           compare_entry_texts(parse_result.chart[3], expected)
 
@@ -357,12 +358,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = [
             'digit_plus => digit_plus digit . | 2',     # Scan
             'digit_plus. | 2',                          # exit rule
-            'integer => digit_plus . | 2' ,             # end rule
+            'integer => digit_plus . | 2',              # end rule
             'digit_plus => digit_plus . digit | 2',     #
             'integer. | 2',                             # exit rule
             'sequence => sequence comma integer . | 0', # rule
             'sequence. | 0',                            # exit rule
-            'S => sequence . | 0',                      # end rule
+            'S => sequence . | 0'                       # end rule
           ]
           compare_entry_texts(parse_result.chart[4], expected)
         end
@@ -1040,5 +1041,6 @@ MSG
       end # context
     end # describe
   end # module
+  # rubocop: enable Metrics/BlockLength
 end # module
 # End of file