rley 0.7.06 → 0.8.01

data/examples/NLP/nano_eng/nano_en_demo.rb

@@ -24,20 +24,16 @@ engine.build_grammar do
 
   # Here we define the productions (= grammar rules)
   rule 'Start' => 'S'
-  rule 'S' => %w[NP VP]
-  rule 'S' => %w[Aux NP VP]
+  rule 'S' => 'Aux? NP VP'
   rule 'S' => 'VP'
   rule 'NP' => 'Pronoun'
   rule 'NP' => 'Proper-Noun'
-  rule 'NP' => %w[Determiner Nominal]
-  rule 'Nominal' => %w[Noun]
-  rule 'Nominal' => %w[Nominal Noun]
-  rule 'VP' => 'Verb'
-  rule 'VP' => %w[Verb NP]
-  rule 'VP' => %w[Verb NP PP]
-  rule 'VP' => %w[Verb PP]
-  rule 'VP' => %w[VP PP]
-  rule 'PP' => %w[Preposition NP]
+  rule 'NP' => 'Determiner Nominal'
+  rule 'Nominal' => 'Nominal? Noun'
+  rule 'VP' => 'Verb PP?'
+  rule 'VP' => 'Verb NP PP?'
+  rule 'VP' => 'VP PP'
+  rule 'PP' => 'Preposition NP'
 end
 
 ########################################

data/examples/NLP/nano_eng/nano_grammar.rb

@@ -11,8 +11,8 @@ require 'rley' # Load the gem
 # based on chapter 12 from Jurafski & Martin book.
 # Daniel Jurafsky,‎ James H. Martin: "Speech and Language Processing";
 # 2009, Pearson Education, Inc., ISBN 978-0135041963
-# It defines the syntax of a sentence in a mini English-like language 
-builder = Rley::Syntax::GrammarBuilder.new do
+# It defines the syntax of a sentence in a mini English-like language
+builder = Rley::grammar_builder do
   add_terminals('Pronoun', 'Proper-Noun')
   add_terminals('Determiner', 'Noun')
   add_terminals('Cardinal_number', 'Ordinal_number', 'Quant')
@@ -21,39 +21,39 @@ builder = Rley::Syntax::GrammarBuilder.new do
 
   rule 'language' => 'sentence'
   rule 'sentence' => 'declarative'
-  rule 'sentence' => 'imperative'  
+  rule 'sentence' => 'imperative'
   rule 'sentence' => 'yes_no_question'
   rule 'sentence' => 'wh_subject_question'
   rule 'sentence' => 'wh_non_subject_question'
-  rule 'declarative' => %w[NP VP]
+  rule 'declarative' => 'NP VP'
   rule 'imperative' => 'VP'
-  rule 'yes_no_question' => %w[Aux NP VP]
-  rule 'wh_subject_question' => %w[Wh_NP NP VP]
-  rule 'wh_non_subject_question' => %w[Wh_NP Aux NP VP]
-  rule 'NP' => %w[Predeterminer NP]
+  rule 'yes_no_question' => 'Aux NP VP'
+  rule 'wh_subject_question' => 'Wh_NP NP VP'
+  rule 'wh_non_subject_question' => 'Wh_NP Aux NP VP'
+  rule 'NP' => 'Predeterminer NP'
   rule 'NP' => 'Pronoun'
   rule 'NP' => 'Proper-Noun'
-  rule 'NP' => %w[Det Card Ord Quant Nominal] 
+  rule 'NP' => 'Det Card Ord Quant Nominal'
   rule 'VP' => 'Verb'
-  rule 'VP' => %w[Verb NP]
-  rule 'VP' => %w[Verb NP PP]
-  rule 'VP' => %w[Verb PP]
+  rule 'VP' => 'Verb NP'
+  rule 'VP' => 'Verb NP PP'
+  rule 'VP' => 'Verb PP'
   rule 'Det' => 'Determiner'
   rule 'Det' => []
   rule 'Card' => 'Cardinal_number'
   rule 'Card' => []
   rule 'Ord' => 'Ordinal_number'
-  rule 'Ord' =>  []  
+  rule 'Ord' =>  []
   rule 'Nominal' => 'Noun'
-  rule 'Nominal' => %w[Nominal Noun]
-  rule 'Nominal' => %w[Nominal GerundVP]
-  rule 'Nominal' => %w[Nominal RelClause]
-  rule 'PP' => %w[Preposition NP]  
+  rule 'Nominal' => 'Nominal Noun'
+  rule 'Nominal' => 'Nominal GerundVP'
+  rule 'Nominal' => 'Nominal RelClause'
+  rule 'PP' => 'Preposition NP'
   rule 'GerundVP' => 'GerundV'
-  rule 'GerundVP' => %w[GerundV NP]
-  rule 'GerundVP' => %w[GerundV NP PP]
-  rule 'GerundVP' => %w[GerundV PP]
-  rule 'RelClause' => %w[Relative_pronoun VP]
+  rule 'GerundVP' => 'GerundV NP'
+  rule 'GerundVP' => 'GerundV NP PP'
+  rule 'GerundVP' => 'GerundV PP'
+  rule 'RelClause' => 'Relative_pronoun VP'
 end
 
 # And now build the grammar...

data/examples/NLP/pico_en_demo.rb

@@ -26,8 +26,8 @@ engine.build_grammar do
   rule 'S' => 'NP VP'
   rule 'NP' => 'Proper-Noun'
   rule 'NP' => 'Determiner Noun'
-  rule 'NP' => 'Determiner Noun PP'
-  rule 'VP' => 'Verb NP'
+  rule 'NP' => 'Determiner Noun PP'  
+  rule 'VP' => 'Verb NP'  
   rule 'VP' => 'Verb NP PP'
   rule 'PP' => 'Preposition NP'
 end

data/examples/data_formats/JSON/cli_options.rb

@@ -55,7 +55,7 @@ END_TEXT
 
       rep_help = <<-END_TEXT
 Set the parse tree representation (default: cst)
-        cst         Concrete Syntax Tree. The out-of-the-box parse tree 
+        cst         Concrete Syntax Tree. The out-of-the-box parse tree
                     representation.
         ast         Abstract Syntaxt Tree. A customized parse tree for JSON.
                     It is a more compact and practical representation.

data/examples/data_formats/JSON/json_ast_builder.rb

@@ -9,7 +9,7 @@ require_relative 'json_ast_nodes'
 # The Builder pattern creates a complex object
 # (say, a parse tree) from simpler objects (terminal and non-terminal
 # nodes) and using a step by step approach.
-class JSONASTBuilder < Rley::ParseRep::ASTBaseBuilder 
+class JSONASTBuilder < Rley::ParseRep::ASTBaseBuilder
   Terminal2NodeClass = {
     'false' => JSONBooleanNode,
     'true' => JSONBooleanNode,
@@ -19,35 +19,33 @@ class JSONASTBuilder < Rley::ParseRep::ASTBaseBuilder
   }.freeze
 
   protected
-  
-  def terminal2node()
+
+  def terminal2node
     Terminal2NodeClass
   end
-  
+
   # Default class for representing terminal nodes.
   # @return [Class]
-  def terminalnode_class()
+  def terminalnode_class
     JSONTerminalNode
   end
-  
+
+  # rubocop: disable Naming/VariableNumber
+
+  # rule 'JSON_text' => 'value'
   def reduce_JSON_text_0(_aProd, aRange, theTokens, theChildren)
     return_first_child(aRange, theTokens, theChildren)
   end
-  
-  # rule 'object' => %w[begin-object member-list end-object]
+
+  # rule 'object' => 'begin-object member-list? end-object'
   def reduce_object_0(aProduction, _range, _tokens, theChildren)
     second_child = theChildren[1]
     second_child.symbol = aProduction.lhs
     return second_child
   end
 
-  # rule 'object' => %w[begin-object end-object]
-  def reduce_object_1(aProduction, _range, _tokens, _children)
-    return JSONObjectNode.new(aProduction.lhs)
-  end
-
-  # rule 'member-list' => %w[member-list value-separator member]
-  def reduce_member_list_0(_range, _tokens, theChildren)
+  # rule 'member-list' => 'member-list value-separator member'
+  def reduce_member_list_0(_production, _range, _tokens, theChildren)
     node = theChildren[0]
     node.members << theChildren.last
     return node
@@ -60,35 +58,31 @@ class JSONASTBuilder < Rley::ParseRep::ASTBaseBuilder
     return node
   end
 
-  # rule 'member' => %w[string name-separator value]
+  # rule 'member' => 'string name-separator value'
   def reduce_member_0(aProduction, _range, _tokens, theChildren)
     return JSONPair.new(theChildren[0], theChildren[2], aProduction.lhs)
   end
 
-  # rule 'array' => %w[begin-array array-items end-array]
+  # rule 'array' => 'begin-array array-items? end-array'
   def reduce_array_0(aProduction, _range, _tokens, theChildren)
     second_child = theChildren[1]
     second_child.symbol = aProduction.lhs
-    return second_child  
-  end
-
-  # rule 'array' => %w[begin-array end-array]
-  def reduce_array_1(_range, _tokens, _children)
-    return JSONArrayNode.new
+    return second_child
   end
 
-  # rule 'array-items' => %w[array-items value-separator value]
-  def reduce_array_items_0(_range, _tokens, theChildren)
+  # rule 'array-items' => 'array-items value-separator value'
+  def reduce_array_items_0(_production, _range, _tokens, theChildren)
     node = theChildren[0]
     node.children << theChildren[2]
     return node
   end
-  
-  #   rule 'array-items' => %w[value]
+
+  #   rule 'array-items' => 'value'
   def reduce_array_items_1(aProduction, _range, _tokens, theChildren)
     node = JSONArrayNode.new(aProduction.lhs)
     node.children << theChildren[0]
     return node
   end
+  # rubocop: enable Naming/VariableNumber
 end # class
 # End of file

data/examples/data_formats/JSON/json_ast_nodes.rb

@@ -16,11 +16,11 @@ JSONTerminalNode = Struct.new(:token, :value, :position) do
     self.value = aLiteral.dup
   end
 
-  def symbol()
+  def symbol
     token.terminal
   end
 
-  def to_ruby()
+  def to_ruby
     value
   end
 
@@ -29,9 +29,9 @@ JSONTerminalNode = Struct.new(:token, :value, :position) do
   def accept(aVisitor)
     aVisitor.visit_terminal(self)
   end
-  
+
   def done!
-    # Do nothing  
+    # Do nothing
   end
 end
 
@@ -77,23 +77,18 @@ class JSONCompositeNode
   def accept(aVisitor)
     aVisitor.visit_nonterminal(self)
   end
-  
+
   def done!
-    # Do nothing  
+    # Do nothing
   end
 
   alias subnodes children
 end # class
 
-
 class JSONArrayNode < JSONCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-
   # Convert this tree node in a simpler Ruby representation.
   # Basically a JSON object corresponds to a Ruhy Hash
-  def to_ruby()
+  def to_ruby
     rep = []
     children.each do |child|
       rep << child.to_ruby
@@ -114,7 +109,7 @@ class JSONPair
     @symbol = aSymbol
   end
 
-  def children()
+  def children
     return [name, value]
   end
 
@@ -125,27 +120,23 @@ class JSONPair
   def accept(aVisitor)
     aVisitor.visit_nonterminal(self)
   end
-  
+
   def done!
     # Do nothing
   end
-  
+
   def to_ruby
     rep = {}
     rep[name.to_ruby] = value.to_ruby
 
-    return rep    
+    return rep
   end
 end # class
 
 class JSONObjectNode < JSONCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-
   # Convert this tree node in a simpler Ruby representation.
   # Basically a JSON object corresponds to a Ruby Hash
-  def to_ruby()
+  def to_ruby
     rep = {}
     members.each do |pair|
       rep[pair.name.to_ruby] = pair.value.to_ruby

data/examples/data_formats/JSON/json_demo.rb

@@ -37,9 +37,8 @@ case cli_options[:format]
     raise StandardError, msg if tree_rep == :cst
 end
 
-
 # Create a Rley facade object
-# If necessary, select AST representation
+# If requested, select AST representation
 engine = Rley::Engine.new do |cfg|
   builder = tree_rep == :ast ? JSONASTBuilder : nil
   cfg.repr_builder = builder

data/examples/data_formats/JSON/json_grammar.rb

@@ -9,30 +9,30 @@ require 'rley' # Load the gem
 # Original JSON grammar is available at: http://www.json.org/fatfree.html
 # Official JSON grammar:  http://rfc7159.net/rfc7159#rfc.section.2
 # Names of grammar elements are based on the RFC 7159 documentation
-builder = Rley::Syntax::GrammarBuilder.new do
+builder = Rley::grammar_builder do
   add_terminals('false', 'null', 'true') # Literal names
   add_terminals('string', 'number')
   add_terminals('begin-object', 'end-object') # For '{', '}' delimiters
   add_terminals('begin-array', 'end-array') # For '[', ']' delimiters
   add_terminals('name-separator', 'value-separator') # For ':', ',' separators
+
   rule 'JSON_text' => 'value'
   rule 'value' => 'false'
   rule 'value' => 'null'
-  rule 'value' => 'true'   
-  rule 'value' => 'object'
+  rule 'value' => 'true'
   rule 'value' => 'array'
+  rule 'value' => 'object'
   rule 'value' => 'number'
-  rule 'value' => 'string'  
-  rule 'object' => %w[begin-object member-list end-object]
-  rule 'object' => %w[begin-object end-object]
+  rule 'value' => 'string'
+  rule 'object' => 'begin-object member_list? end-object'
+
   # Next rule is an example of a left recursive rule
-  rule 'member-list' => %w[member-list value-separator member]
-  rule 'member-list' => 'member'
-  rule 'member' => %w[string name-separator value]
-  rule 'array' => %w[begin-array array-items end-array]
-  rule 'array' => %w[begin-array end-array]
-  rule 'array-items' => %w[array-items value-separator value]
-  rule 'array-items' => %w[value]
+  rule 'member_list' => 'member_list value-separator member'
+  rule 'member_list' => 'member'
+  rule 'member' => 'string name-separator value'
+  rule 'array' => 'begin-array array_items? end-array'
+  rule 'array_items' => 'array_items value-separator value'
+  rule 'array_items' => 'value'
 end
 
 # And now build the JSON grammar...

data/examples/data_formats/JSON/json_lexer.rb

@@ -28,19 +28,19 @@ class JSONLexer
     @line_start = 0
   end
 
-  def tokens()
+  def tokens
     tok_sequence = []
     until @scanner.eos?
       token = _next_token
       tok_sequence << token unless token.nil?
     end
 
-    return tok_sequence
+    tok_sequence
   end
 
   private
 
-  def _next_token()
+  def _next_token
     token = nil
     skip_whitespaces
     curr_ch = scanner.getch # curr_ch is at start of token or eof reached...
@@ -58,7 +58,7 @@ class JSONLexer
           keyw = scanner.scan(/false|true|null/)
           if keyw.nil?
             invalid_keyw = scanner.scan(/\w+/)
-            raise ScanError.new("Invalid keyword: #{invalid_keyw}")
+            raise ScanError, "Invalid keyword: #{invalid_keyw}"
           else
             token = build_token(keyw, keyw)
           end
@@ -68,7 +68,7 @@ class JSONLexer
           value = scanner.scan(/([^"\\]|\\.)*/)
           end_delimiter = scanner.getch
           err_msg = 'No closing quotes (") found'
-          raise ScanError.new(err_msg) if end_delimiter.nil?
+          raise ScanError, err_msg if end_delimiter.nil?
 
           token = build_token(value, 'string')
 
@@ -81,12 +81,12 @@ class JSONLexer
           erroneous = curr_ch.nil? ? '' : curr_ch
           sequel = scanner.scan(/.{1,20}/)
           erroneous += sequel unless sequel.nil?
-          raise ScanError.new("Unknown token #{erroneous}")
+          raise ScanError, "Unknown token #{erroneous}"
       end # case
       break unless token.nil? && (curr_ch = scanner.getch)
     end
 
-    return token
+    token
   end
 
   def build_token(lexeme, token)
@@ -94,7 +94,7 @@ class JSONLexer
     Rley::Lexical::Token.new(lexeme, token, pos)
   end
 
-  def skip_whitespaces()
+  def skip_whitespaces
     matched = scanner.scan(/[ \t\f\n\r]+/)
     return if matched.nil?
 

data/examples/data_formats/JSON/json_minifier.rb

@@ -35,7 +35,7 @@ class JSONMinifier
     lexeme = aTerm.token.lexeme
     literal = if aTerm.symbol.name == 'string'
                 # String values are delimited by double quotes
-                '"' + lexeme + '"'
+                "\"#{lexeme}\""
               else
                 lexeme
               end

data/examples/general/calc_iter1/calc_ast_builder.rb

@@ -15,8 +15,8 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   }.freeze
 
   protected
-  
-  def terminal2node()
+
+  def terminal2node
     Terminal2NodeClass
   end
 
@@ -26,7 +26,9 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
     operator_node.children << theChildren[2]
     return operator_node
   end
-  
+
+  # rubocop: disable Naming/VariableNumber
+
   # rule 'expression' => 'simple_expression'
   def reduce_expression_0(_production, aRange, theTokens, theChildren)
     return_first_child(aRange, theTokens, theChildren)
@@ -35,32 +37,32 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   # rule 'simple_expression' => 'term'
   def reduce_simple_expression_0(_production, aRange, theTokens, theChildren)
     return_first_child(aRange, theTokens, theChildren)
-  end          
+  end
 
   # rule 'simple_expression' => %w[simple_expression add_operator term]
   def reduce_simple_expression_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
   end
-  
-  # rule 'term' => 'factor' 
+
+  # rule 'term' => 'factor'
   def reduce_term_0(_production, aRange, theTokens, theChildren)
     return_first_child(aRange, theTokens, theChildren)
-  end  
+  end
 
   # rule 'term' => %w[term mul_operator factor]
   def reduce_term_1(_production, _range, _tokens, theChildren)
     reduce_binary_operator(theChildren)
   end
-  
+
   # rule 'factor' => 'NUMBER'
   def reduce_factor_0(_aProd, aRange, theTokens, theChildren)
     return_first_child(aRange, theTokens, theChildren)
   end
-  
+
   # # rule 'factor' => %w[LPAREN expression RPAREN]
   def reduce_factor_1(_aProd, aRange, theTokens, theChildren)
     return_second_child(aRange, theTokens, theChildren)
-  end   
+  end
 
   # rule 'add_operator' => 'PLUS'
   def reduce_add_operator_0(_production, _range, _tokens, theChildren)
@@ -81,5 +83,6 @@ class CalcASTBuilder < Rley::ParseRep::ASTBaseBuilder
   def reduce_mul_operator_1(_production, _range, _tokens, theChildren)
     return CalcDivideNode.new(theChildren[0].symbol)
   end
+  # rubocop: enable Naming/VariableNumber
 end # class
 # End of file