rley 0.7.06 → 0.8.01

data/lib/rley/syntax/symbol_seq.rb

@@ -12,9 +12,9 @@ module Rley # This module is used as a namespace
       # @return [Array<GrmSymbol>] The sequence of symbols
       attr_reader(:members)
 
-      # Create a sequence of grammar symbols (as in right-hand side of 
+      # Create a sequence of grammar symbols (as in right-hand side of
       # a production rule).
-      # @param theSymbols [Array<GrmSymbol>] An array of symbols.      
+      # @param theSymbols [Array<GrmSymbol>] An array of symbols.
       def initialize(theSymbols)
         @members = theSymbols.dup
       end
@@ -33,20 +33,18 @@ module Rley # This module is used as a namespace
             raise StandardError, msg
         end
 
-        return result
+        result
       end
-      
-      # Returns a string containing a human-readable representation of the 
+
+      # Returns a string containing a human-readable representation of the
       # sequence of symbols.
       # @return [String]
-      def inspect()
+      def inspect
         result = +"#<#{self.class.name}:#{object_id}"
         symbol_names = members.map(&:name)
         result << " @members=#{symbol_names}>"
-        return result
+        result
       end
-      
-      
     end # class
   end # module
 end # module

data/lib/rley/syntax/terminal.rb

@@ -4,29 +4,28 @@ require_relative 'grm_symbol' # Load superclass
 
 module Rley # This module is used as a namespace
   module Syntax # This module is used as a namespace
-    # A terminal symbol represents a class of words in the language 
+    # A terminal symbol represents a class of words in the language
     # defined the grammar.
     class Terminal < GrmSymbol
-      
       # Constructor.
       # @param aName [String] The name of the grammar symbol.
       def initialize(aName)
         super(aName)
         self.generative = true
       end
-      
+
       # Return true iff the symbol is a terminal
       def terminal?
         return true
       end
-      
+
       # @return [false] Return true if the symbol derives
       # the empty string. As terminal symbol corresponds to a input token
       # it is by definition non-nullable.
       def nullable?
         false
       end
-      
+
       def to_s
         name
       end

data/lib/rley/syntax/verbatim_symbol.rb

@@ -14,11 +14,11 @@ module Rley # This module is used as a namespace
         super(aText) # Do we need to separate the text from the name?
         @text = aText.dup
       end
-      
+
       # The String representation of the verbatim symbol
       # @return [String]
-      def to_s()
-        return "'#{text}'"
+      def to_s
+        "'#{text}'"
       end
     end # class
   end # module

data/lib/support/base_tokenizer.rb

@@ -3,21 +3,27 @@
 require 'strscan'
 require_relative '../rley/lexical/token'
 
+# Simplistic tokenizer used mostly for testing purposes
 class BaseTokenizer
+  # @return [StringScanner]
   attr_reader(:scanner)
+
+  # @return [Integer] current line number
   attr_reader(:lineno)
+
+  # @return [Integer] position of start of current line in source text
   attr_reader(:line_start)
-  
+
   class ScanError < StandardError; end
 
-  # Constructor. Initialize a tokenizer for Skeem.
+  # Constructor. Initialize a tokenizer.
   # @param source [String] Skeem text to tokenize.
   def initialize(source)
     @scanner = StringScanner.new('')
     restart(source)
   end
 
-  # @param source [String] Skeem text to tokenize.
+  # @param source [String] input text to tokenize.
   def restart(source)
     @scanner.string = source
     @lineno = 1
@@ -34,13 +40,13 @@ class BaseTokenizer
 
     return tok_sequence
   end
-  
+
   protected
-  
+
   # Patterns:
   # Unambiguous single character
   # Conditional single character:
-  #  (e.g. '+' operator, '+' prefix for positive numbers) 
+  #  (e.g. '+' operator, '+' prefix for positive numbers)
   def _next_token
     skip_whitespaces
     curr_ch = scanner.peek(1)
@@ -57,11 +63,11 @@ class BaseTokenizer
 
     return token
   end
-  
+
   def recognize_token
     raise NotImplementedError
   end
-  
+
   def build_token(aSymbolName, aLexeme, aFormat = :default)
     begin
       value = convert_to(aLexeme, aSymbolName, aFormat)
@@ -75,11 +81,11 @@ class BaseTokenizer
 
     return token
   end
-  
+
   def convert_to(aLexeme, _symbol_name, _format)
     return aLexeme
   end
- 
+
   def skip_whitespaces
     pre_pos = scanner.pos
 
@@ -93,21 +99,16 @@ class BaseTokenizer
         ws_found = true
         next_line
       end
-      # next_ch = scanner.peek(1)
-      # if next_ch == ';'
-      #   cmt_found = true
-      #   scanner.skip(/;[^\r\n]*(?:(?:\r\n)|\r|\n)?/)
-      #   next_line
-      # end
+
       break unless ws_found || cmt_found
     end
 
     curr_pos = scanner.pos
     return if curr_pos == pre_pos
   end
-  
+
   def next_line
     @lineno += 1
     @line_start = scanner.pos
-  end  
+  end
 end # class

data/spec/rley/base/dotted_item_spec.rb

@@ -125,7 +125,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should determine if it is a successor of another dotted item' do
           expect(subject).not_to be_successor_of(subject)
-          
+
           # Case: different productions
           instance = DottedItem.new(empty_prod, 0)
           expect(subject).not_to be_successor_of(instance)
@@ -139,7 +139,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance2 = DottedItem.new(sample_prod, 2)
           expect(instance).not_to be_successor_of(instance2)
           expect(subject).not_to be_successor_of(instance2)
-          expect(instance2).to be_successor_of(subject)           
+          expect(instance2).to be_successor_of(subject)
         end
 
 

data/spec/rley/engine_spec.rb

@@ -19,11 +19,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       it 'could be created with block argument' do
-        expect do 
-                 Engine.new do |config|
-                   config.parse_repr = :raw
-                 end
-               end.not_to raise_error
+        expect do
+          Engine.new do |config|
+            config.parse_repr = :raw
+          end
+        end.not_to raise_error
       end
 
       it "shouldn't have a link to a grammar yet" do
@@ -35,9 +35,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       it 'should build grammar' do
         subject.build_grammar do
           add_terminals('a', 'b', 'c')
-          add_production('S' => ['A'])
-          add_production('A' => %w[a A c])
-          add_production('A' => ['b'])
+          add_production('S' => 'A')
+          add_production('A' => 'a A c')
+          add_production('A' => 'b')
         end
 
         expect(subject.grammar).to be_kind_of(Rley::Syntax::Grammar)
@@ -45,13 +45,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
     end # context
 
+    # rubocop: disable Lint/ConstantDefinitionInBlock
     class ABCTokenizer
       # Constructor
       def initialize(someText)
         @input = someText.dup
       end
 
-      def each()
+      def each
         pos = Rley::Lexical::Position.new(1, 1) # Dummy position
         lexemes = @input.scan(/\S/)
         lexemes.each do |ch|
@@ -63,15 +64,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end
     end # class
+    # rubocop: enable Lint/ConstantDefinitionInBlock
 
     # Utility method. Ensure that the engine
     # has the defnition of a sample grammar
     def add_sample_grammar(anEngine)
       anEngine.build_grammar do
         add_terminals('a', 'b', 'c')
-        add_production('S' => ['A'])
-        add_production('A' => %w[a A c])
-        add_production('A' => ['b'])
+        add_production('S' => 'A')
+        add_production('A' => 'a A c')
+        add_production('A' => 'b')
       end
     end
 
@@ -101,7 +103,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         sample_text = 'a a b c c'
         ABCTokenizer.new(sample_text)
       end
-      
+
       it 'should build a parse tree even for a nullable production' do
         instance = Engine.new
         instance.build_grammar do
@@ -112,12 +114,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           add_production 'B_opt' => 'b'
           add_production 'B_opt' => []
           add_production 'C_opt' => 'c'
-          add_production 'C_opt' => []            
+          add_production 'C_opt' => []
         end
         input = ABCTokenizer.new('a')
         raw_result = instance.parse(input)
         expect { instance.to_ptree(raw_result) }.not_to raise_error
-      end      
+      end
 
       it 'should build default parse trees' do
         raw_result = subject.parse(sample_tokenizer)
@@ -152,7 +154,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         sample_text = 'a a b c c'
         ABCTokenizer.new(sample_text)
       end
-      
+
       it 'should build a parse forest even for a nullable production' do
         instance = Engine.new
         instance.build_grammar do
@@ -163,19 +165,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           add_production 'B_opt' => 'b'
           add_production 'B_opt' => []
           add_production 'C_opt' => 'c'
-          add_production 'C_opt' => []            
+          add_production 'C_opt' => []
         end
         input = ABCTokenizer.new('a')
         raw_result = instance.parse(input)
         expect { instance.to_pforest(raw_result) }.not_to raise_error
-      end       
-      
+      end
+
       it 'should build parse forest' do
         raw_result = subject.parse(sample_tokenizer)
         pforest = subject.to_pforest(raw_result)
         expect(pforest).to be_kind_of(SPPF::ParseForest)
-      end      
-      
+      end
+
       it 'should provide a parse visitor' do
         raw_result = subject.parse(sample_tokenizer)
         ptree = subject.to_pforest(raw_result)

data/spec/rley/formatter/asciitree_spec.rb

@@ -23,12 +23,12 @@ module Rley # Re-open the module to get rid of qualified names
         builder = sandbox.grammar_abc_builder
         builder.grammar
       end
-      
+
       # Variables for the terminal symbols
       let(:a_) { grammar_abc.name2symbol['a'] }
       let(:b_) { grammar_abc.name2symbol['b'] }
       let(:c_) { grammar_abc.name2symbol['c'] }
-      
+
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
@@ -50,12 +50,12 @@ module Rley # Re-open the module to get rid of qualified names
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
         engine = Rley::Engine.new
-        engine.use_grammar(grammar_abc)     
+        engine.use_grammar(grammar_abc)
         parse_result = engine.parse(grm_abc_tokens1)
         ptree = engine.convert(parse_result)
         ptree
       end
-  
+
       let(:destination) { StringIO.new(+'', 'w') }
       subject { Asciitree.new(destination) }
 
@@ -63,14 +63,14 @@ module Rley # Re-open the module to get rid of qualified names
         it 'should be initialized with an IO argument' do
           expect { Asciitree.new(StringIO.new(+'', 'w')) }.not_to raise_error
         end
-        
+
         it 'should know its output destination' do
           expect(subject.output).to eq(destination)
         end
       end # context
-  
 
-      context 'Rendering:' do   
+
+      context 'Rendering:' do
         it 'should render a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           subject.render(visitor)

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -23,12 +23,12 @@ module Rley # Re-open the module to get rid of qualified names
         builder = sandbox.grammar_abc_builder
         builder.grammar
       end
-      
+
       # Variables for the terminal symbols
       let(:a_) { grammar_abc.name2symbol['a'] }
       let(:b_) { grammar_abc.name2symbol['b'] }
       let(:c_) { grammar_abc.name2symbol['c'] }
-      
+
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
@@ -50,45 +50,45 @@ module Rley # Re-open the module to get rid of qualified names
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
         engine = Rley::Engine.new
-        engine.use_grammar(grammar_abc)     
+        engine.use_grammar(grammar_abc)
         parse_result = engine.parse(grm_abc_tokens1)
         ptree = engine.convert(parse_result)
-        ptree   
+        ptree
       end
-  
+
       let(:destination) { StringIO.new(+'', 'w') }
       subject { BracketNotation.new(destination) }
 
       context 'Standard creation & initialization:' do
         it 'should be initialized with an IO argument' do
-          expect do 
-            BracketNotation.new(StringIO.new(+'', 'w')) 
+          expect do
+            BracketNotation.new(StringIO.new(+'', 'w'))
           end.not_to raise_error
         end
-        
+
         it 'should know its output destination' do
           expect(subject.output).to eq(destination)
         end
       end # context
-  
 
-      context 'Formatting events:' do   
+
+      context 'Formatting events:' do
         it 'should support visit events of a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           subject.render(visitor)
           expectations = '[S [A [a a][A [a a][A [b b]][c c]][c c]]]'
           expect(destination.string).to eq(expectations)
         end
-        
+
         it 'should escape square brackets' do
           f_node = double('fake-node')
           f_token = double('fake-token')
           expect(f_node).to receive(:token).and_return(f_token)
           expect(f_token).to receive(:lexeme).and_return('[][]')
-          
+
           subject.after_terminal(f_node)
           expectations = '\[\]\[\]]'
-          expect(destination.string).to eq(expectations)          
+          expect(destination.string).to eq(expectations)
         end
       end # context
     end # describe

data/spec/rley/formatter/json_spec.rb

@@ -49,7 +49,7 @@ module Rley # Re-open the module to get rid of qualified names
       # Capital letters represent non-terminal nodes
       let(:grm_abc_ptree1) do
         engine = Rley::Engine.new
-        engine.use_grammar(grammar_abc)     
+        engine.use_grammar(grammar_abc)
         parse_result = engine.parse(grm_abc_tokens1)
         ptree = engine.convert(parse_result)
         ptree