rley 0.7.03 → 0.7.08

data/lib/rley/syntax/grammar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative '../rley_error'
 
@@ -46,13 +48,13 @@ module Rley # This module is used as a namespace
       end
 
       # @return [Array] The list of non-terminals in the grammar.
-      def non_terminals()
+      def non_terminals
         @non_terminals ||= symbols.select { |s| s.kind_of?(NonTerminal) }
       end
 
       # @return [Production] The start production of the grammar (i.e.
       #   the rule that specifies the syntax for the start symbol.
-      def start_production()
+      def start_production
         return rules[0]
       end
 
@@ -97,7 +99,7 @@ module Rley # This module is used as a namespace
       end
 
       # Perform some check of the grammar.
-      def diagnose()
+      def diagnose
         mark_undefined
         mark_generative
         compute_nullable
@@ -191,7 +193,7 @@ module Rley # This module is used as a namespace
 
       # For each non-terminal determine whether it is nullable or not.
       # A nullable nonterminal is a nonterminal that can match an empty string.
-      def compute_nullable()
+      def compute_nullable
         non_terminals.each { |nterm| nterm.nullable = false }
         nullable_sets = [direct_nullable]
 
@@ -234,7 +236,7 @@ module Rley # This module is used as a namespace
           nullables << prod.lhs
         end
 
-        return nullables
+        nullables
       end
 
       # For each prodction determine whether it is nullable or not.

data/lib/rley/syntax/grammar_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require_relative 'terminal'
 require_relative 'non_terminal'
@@ -16,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')
@@ -43,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
@@ -65,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)
@@ -83,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?
@@ -111,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)
@@ -164,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rley # This module is used as a namespace
   module Syntax # This module is used as a namespace
     # Abstract class for grammar symbols.
@@ -21,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/literal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'terminal' # Load superclass
 
 module Rley # This module is used as a namespace

data/lib/rley/syntax/non_terminal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'grm_symbol' # Load superclass
 
 module Rley # This module is used as a namespace
@@ -7,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'symbol_seq'
 
 module Rley # This module is used as a namespace
@@ -44,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()
-        result = "#<#{self.class.name}:#{object_id}"
+      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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Rley # This module is used as a namespace
@@ -10,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
@@ -31,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()
-        result = "#<#{self.class.name}:#{object_id}"
+      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

@@ -1,30 +1,31 @@
+# frozen_string_literal: true
+
 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'terminal' # Load superclass
 
 module Rley # This module is used as a namespace
@@ -12,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

@@ -1,21 +1,29 @@
+# frozen_string_literal: true
+
 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
@@ -32,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)
@@ -55,29 +63,29 @@ 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)
       col = scanner.pos - aLexeme.size - @line_start + 1
       pos = Rley::Lexical::Position.new(@lineno, col)
       token = Rley::Lexical::Token.new(value, aSymbolName, pos)
-    rescue StandardError => exc
+    rescue StandardError => e
       puts "Failing with '#{aSymbolName}' and '#{aLexeme}'"
-      raise exc
+      raise e
     end
 
     return token
   end
-  
+
   def convert_to(aLexeme, _symbol_name, _format)
     return aLexeme
   end
- 
+
   def skip_whitespaces
     pre_pos = scanner.pos
 
@@ -91,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