rley 0.7.07 → 0.7.08

data/lib/rley/syntax/grammar_builder.rb

@@ -18,12 +18,12 @@ module Rley # This module is used as a namespace
       #   to the matching grammar symbol object.
       attr_reader(:symbols)
 
-      # @return [Array<Production>] The list of production rules for 
+      # @return [Array<Production>] The list of production rules for
       #   the grammar to build.
       attr_reader(:productions)
 
       # Creates a new grammar builder.
-      # @param aBlock [Proc] code block used to build the grammar. 
+      # @param aBlock [Proc] code block used to build the grammar.
       # @example Building a tiny English grammar
       #   builder = Rley::Syntax::GrammarBuilder.new do
       #     add_terminals('n', 'v', 'adj', 'det')
@@ -45,7 +45,7 @@ module Rley # This module is used as a namespace
       # @param aSymbolName [String] the name of a grammar symbol.
       # @return [GrmSymbol] the retrieved symbol object.
       def [](aSymbolName)
-        return symbols[aSymbolName]
+        symbols[aSymbolName]
       end
 
       # Add the given terminal symbols to the grammar of the language
@@ -67,7 +67,7 @@ module Rley # This module is used as a namespace
       #   builder.rule('A' => ['a', 'A', 'c']) # 'rule' is a synonym
       #   builder.rule('A' => %w[a A  c]) # Use %w syntax for Array of String
       #   builder.rule 'A' => %w[a A  c]  # Call parentheses are optional
-      # @param aProductionRepr [Hash{String, Array<String>}] 
+      # @param aProductionRepr [Hash{String, Array<String>}]
       #   A Hash-based representation of a production.
       # @return [Production] The created Production instance
       def add_production(aProductionRepr)
@@ -85,14 +85,14 @@ module Rley # This module is used as a namespace
           new_prod = Production.new(lhs, rhs_members)
           productions << new_prod
         end
-        
+
         return productions.last
       end
 
       # Given the grammar symbols and productions added to the builder,
       # build the resulting grammar (if not yet done).
-      # @return [Grammar] the created grammar object.      
-      def grammar()
+      # @return [Grammar] the created grammar object.
+      def grammar
         unless @grammar
           raise StandardError, 'No symbol found for grammar' if symbols.empty?
           if productions.empty?
@@ -113,7 +113,7 @@ module Rley # This module is used as a namespace
           unused = all_terminals.reject { |a_term| in_use.include?(a_term) }
           unless unused.empty?
             suffix = "#{unused.map(&:name).join(', ')}."
-            raise StandardError, 'Useless terminal symbol(s): ' + suffix
+            raise StandardError, "Useless terminal symbol(s): #{suffix}"
           end
 
           @grammar = Grammar.new(productions.dup)
@@ -166,7 +166,7 @@ module Rley # This module is used as a namespace
         unless symbols.include? aSymbolName
           symbols[aSymbolName] = NonTerminal.new(aSymbolName)
         end
-        return symbols[aSymbolName]
+        symbols[aSymbolName]
       end
     end # class
   end # module

data/lib/rley/syntax/grm_symbol.rb

@@ -23,19 +23,19 @@ module Rley # This module is used as a namespace
 
       # The String representation of the grammar symbol
       # @return [String]
-      def to_s()
-        return name.to_s
+      def to_s
+        name.to_s
       end
 
       # @return [Boolean] true iff the symbol is a terminal
-      def terminal?()
+      def terminal?
         # Default implementation to override if necessary
-        return false
+        false
       end
 
       # @return [Boolean] true iff the symbol is generative.
-      def generative?()
-        return @generative
+      def generative?
+        @generative
       end
     end # class
   end # module

data/lib/rley/syntax/non_terminal.rb

@@ -9,41 +9,35 @@ module Rley # This module is used as a namespace
     class NonTerminal < GrmSymbol
       # A non-terminal symbol is nullable if it can match an empty string.
       attr_writer(:nullable)
-      
+
       # A non-terminal symbol is undefined if no production rule in the grammar
       # has that non-terminal symbol in its left-hand side.
       attr_writer(:undefined)
-      
-      # A non-terminal symbol is unreachable if it cannot be reached (derived) 
+
+      # A non-terminal symbol is unreachable if it cannot be reached (derived)
       # from the start symbol.
       attr_writer(:unreachable)
 
-      # Constructor.
-      # @param aName [String] The name of the grammar symbol.
-      def initialize(aName)
-        super(aName)
-      end
-
       # @return [false/true] Return true if the symbol derives
       # the empty string. As non-terminal symbol is nullable when it can
       # can match to zero input token.
       # The "nullability" of a non-terminal can practically be determined once
       # all the production rules of the grammar are specified.
-      def nullable?()
+      def nullable?
         return @nullable
       end
-      
+
       # @return [false/true] Return true if the symbol doesn't appear
       # on the left-hand side of any production rule.
-      def undefined?()
+      def undefined?
         return @undefined
       end
-      
+
       # @return [false/true] Return true if the symbol cannot be derived
       # from the start symbol.
-      def unreachable?()
+      def unreachable?
         return @unreachable
-      end      
+      end
     end # class
   end # module
 end # module

data/lib/rley/syntax/production.rb

@@ -46,33 +46,33 @@ module Rley # This module is used as a namespace
 
       # Is the rhs empty?
       # @return [Boolean] true if the rhs has no members.
-      def empty?()
-        return rhs.empty?
+      def empty?
+        rhs.empty?
       end
 
       # Return true iff the production is generative
-      def generative?()
-        if @generative.nil?
-        end
+      def generative?
+        # if @generative.nil?
+        # end
 
-        return @generative
+        @generative
       end
 
       # @return [Boolen] true iff the production is nullable
-      def nullable?()
-        return @nullable
+      def nullable?
+        @nullable
       end
 
       # Returns a string containing a human-readable representation of the
       # production.
       # @return [String]
-      def inspect()
+      def inspect
         result = +"#<#{self.class.name}:#{object_id}"
         result << " @name=\"#{name}\""
         result << " @lhs=#{lhs.name}"
         result << " @rhs=#{rhs.inspect}"
         result << " @generative=#{@generative}>"
-        return result
+        result
       end
 
       # A setter for the production name

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
@@ -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,6 +64,7 @@ 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
@@ -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)