rley 0.6.00 → 0.6.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7fa26ec5c47c28dd6d0cc68f32e8f023f92ce75
-  data.tar.gz: 73717a9a1c2daa9886952c502020b2fcf5e4bb33
+  metadata.gz: e5431e3dddd23b1b29be7db8b2b5fe268301f16f
+  data.tar.gz: 929f4f15a4d996cf0e14ddf903b15a5c5325fb93
 SHA512:
-  metadata.gz: 055963ec1637d43b33703e87b454fd9a1590a3993609f2df89f0d3ca94a1b8eba7b39cf102d318e0c1da6fc3e29c51a84bd3929f3000b7c800ee4585260d9b78
-  data.tar.gz: 2b0bc71c159ecac03789644497af1ce789b7975efe2fb6fecc399e41fb346aec26ad67a9d1015ebed1d43a9e9fdd09321d7dfef5f86afa3ce5402b4f04b8f062
+  metadata.gz: 3cda86bffff68e3591e89cbd05a669a59a7ee111dc75cd29fa56b0968798a981210ba3d3565bf5ed8435c2070b6ac9cb1efd35290ea10b60eee1ad3bb7d3caa7
+  data.tar.gz: c49cbc2d61484807e23cee6801057cf7618e9a0f18e85a80082acb8c08bad9012067c895ad581b7b0cdc3d3ac02699f45db42d525ce8b62e4803023d9a5cbca0

data/.rubocop.yml

@@ -78,6 +78,9 @@ Metrics/ModuleLength:
 Metrics/PerceivedComplexity:
   Enabled: true
   Max: 50
+  
+Naming/MethodName:
+  Enabled: false
  
 NonNilCheck:
   Enabled: false
@@ -101,4 +104,8 @@ VariableName:
   Enabled: false
 
 VariableNumber:
-  Enabled: false  
+  Enabled: false
+  
+Style/CommentedKeyword:
+  Enabled: false
+  

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.6.01 / 2018-02-25
+* [FIX] Code re-styling to remove most style offenses found by Rubocop 0.52.1
+
 ### 0.6.00 / 2018-02-25
 Version bump. Highlights: new programming interface through facade object, improved AST generation. 
 * [NEW] Class `Rley::Engine`: Implementation of Facade design pattern to reach more convenient interface.

data/Gemfile

@@ -2,8 +2,8 @@ source 'https://rubygems.org'
 # Prevent Bundler to load the dependencies from our .gemspec file
 
 group :development do
+  gem 'coveralls', '>= 0.7.0'
   gem 'rake',  '>= 10.0.0' 
   gem 'rspec', '>= 3.5.0'
   gem 'simplecov', '>= 0.1.0'
-  gem 'coveralls', '>= 0.7.0'
 end

data/examples/NLP/benchmark_pico_en.rb

@@ -79,14 +79,10 @@ input_to_parse = 'John saw Mary with a telescope'
 # input_to_parse = 'the dog saw a man in the park' # This one is ambiguous
 # Convert input text into a sequence of token objects...
 tokens = tokenizer(input_to_parse)
-result = engine.parse(tokens)
 
-# Use Benchmark mix-in
-include Benchmark
-
-bm(6) do |meter|
-  meter.report("Parse 100 times") { 100.times { engine.parse(tokens) } }
-  meter.report("Parse 1000 times") { 1000.times { engine.parse(tokens) } }
-  meter.report("Parse 10000 times") { 10000.times { engine.parse(tokens) } }
-  meter.report("Parse 1000000 times") { 100000.times { engine.parse(tokens) } }
-end
+Benchmark.bm(6) do |meter|
+  meter.report('Parse 100 times') { 100.times { engine.parse(tokens) } }
+  meter.report('Parse 1000 times') { 1000.times { engine.parse(tokens) } }
+  meter.report('Parse 10000 times') { 10000.times { engine.parse(tokens) } }
+  meter.report('Parse 1000000 times') { 100000.times { engine.parse(tokens) } }
+end

data/examples/NLP/nano_eng/nano_en_demo.rb

@@ -26,8 +26,8 @@ engine.build_grammar do
   rule 'NP' => 'Pronoun'
   rule 'NP' => 'Proper-Noun'
   rule 'NP' => %w[Determiner Nominal]
-  rule 'Nominal' => %[Noun]
-  rule 'Nominal' => %[Nominal Noun]
+  rule 'Nominal' => %w[Noun]
+  rule 'Nominal' => %w[Nominal Noun]
   rule 'VP' => 'Verb'
   rule 'VP' => %w[Verb NP]
   rule 'VP' => %w[Verb NP PP]

data/examples/NLP/nano_eng/nano_grammar.rb

@@ -43,7 +43,7 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'Ord' => 'Ordinal_number'
   rule 'Ord' =>  []  
   rule 'Nominal' => 'Noun'
-  rule 'Nominal' => %[Nominal Noun]
+  rule 'Nominal' => %w[Nominal Noun]
   rule 'Nominal' => %w[Nominal GerundVP]
   rule 'Nominal' => %w[Nominal RelClause]
   rule 'PP' => %w[Preposition NP]  
@@ -52,7 +52,6 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'GerundVP' => %w[GerundV NP PP]
   rule 'GerundVP' => %w[GerundV PP]
   rule 'RelClause' => %w[Relative_pronoun VP]
-
 end
 
 # And now build the grammar...

data/examples/data_formats/JSON/json_ast_builder.rb

@@ -9,12 +9,12 @@ require_relative 'json_ast_nodes'
 # nodes) and using a step by step approach.
 class JSONASTBuilder < Rley::ParseRep::ParseTreeBuilder 
   Terminal2NodeClass = {
-                         'false' => JSONBooleanNode,
-                         'true' => JSONBooleanNode,
-                         'null' => JSONNullNode,
-                         'string' => JSONStringNode,
-                         'number' => JSONNumberNode
-                       }.freeze
+    'false' => JSONBooleanNode,
+    'true' => JSONBooleanNode,
+    'null' => JSONNullNode,
+    'string' => JSONStringNode,
+    'number' => JSONNumberNode
+  }.freeze
 
   protected
   
@@ -28,8 +28,8 @@ class JSONASTBuilder < Rley::ParseRep::ParseTreeBuilder
     JSONTerminalNode
   end
   
-  def reduce_JSON_text_0(_aProd, _range, _tokens, theChildren)
-    return_first_child(_range, _tokens, theChildren)
+  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]

data/examples/general/SRL/lib/ast_builder.rb

@@ -9,8 +9,7 @@ require_relative 'regex_repr'
 # (say, a parse tree) from simpler objects (terminal and non-terminal
 # nodes) and using a step by step approach.
 class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-
-  Terminal2NodeClass = { }.freeze
+  Terminal2NodeClass = {}.freeze
 
   attr_reader :options
 
@@ -26,7 +25,7 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   # @param aTerminal [Terminal] Terminal symbol associated with the token
   # @param aTokenPosition [Integer] Position of token in the input stream
   # @param aToken [Token] The input token
-  def new_leaf_node(aProduction, aTerminal, aTokenPosition, aToken)
+  def new_leaf_node(_production, _terminal, aTokenPosition, aToken)
     node = Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
 
     return node
@@ -46,13 +45,12 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
         chars << Regex::Character.new(ch)
       end
       result = Regex::Concatenation.new(*chars)
+    elsif to_escape && Regex::Character::MetaChars.include?(aString)
+      backslash = Regex::Character.new("\\")
+      a_string = Regex::Character.new(aString)
+      result = Regex::Concatenation.new(backslash, a_string)
     else
-        if to_escape && Regex::Character::MetaChars.include?(aString)
-          result = Regex::Concatenation.new(Regex::Character.new("\\"),
-            Regex::Character.new(aString))
-        else
-          result = Regex::Character.new(aString)
-        end
+      result = Regex::Character.new(aString)
     end
 
     return result
@@ -61,7 +59,7 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   def char_range(lowerBound, upperBound)
     # TODO fix module nesting
     lower = Regex::Character.new(lowerBound)
-    upper =  Regex::Character.new(upperBound)
+    upper = Regex::Character.new(upperBound)
     return Regex::CharRange.new(lower, upper)
   end
 
@@ -86,106 +84,106 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
   
   # rule('expression' => %w[pattern separator flags]).as 'flagged_expr'
-  def reduce_flagged_expr(aProduction, aRange, theTokens, theChildren)
+  def reduce_flagged_expr(_production, aRange, theTokens, theChildren)
     @options = theChildren[2] if theChildren[2]
     return_first_child(aRange, theTokens, theChildren)
   end
 
   # rule('pattern' => %w[pattern separator quantifiable]).as 'pattern_sequence'
-  def reduce_pattern_sequence(aProduction, aRange, theTokens, theChildren)
+  def reduce_pattern_sequence(_production, _range, _tokens, theChildren)
     return Regex::Concatenation.new(theChildren[0], theChildren[2])
   end
 
   # rule('flags' => %[flags separator single_flag]).as 'flag_sequence'
-  def reduce_flag_sequence(aProduction, aRange, theTokens, theChildren)
+  def reduce_flag_sequence(_production, _range, _tokens, theChildren)
     theChildren[0] << theChildren[2]
   end
 
   # rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
-  def reduce_case_insensitive(aProduction, aRange, theTokens, theChildren)
-    return [ Regex::MatchOption.new(:IGNORECASE, true) ]
+  def reduce_case_insensitive(_production, _range, _tokens, _children)
+    return [Regex::MatchOption.new(:IGNORECASE, true)]
   end
 
   # rule('single_flag' => %w[MULTI LINE]).as 'multi_line'
-  def reduce_multi_line(aProduction, aRange, theTokens, theChildren)
-    return [ Regex::MatchOption.new(:MULTILINE, true) ]
+  def reduce_multi_line(_production, _range, _tokens, _children)
+    return [Regex::MatchOption.new(:MULTILINE, true)]
   end
 
   # rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
-  def reduce_all_lazy(aProduction, aRange, theTokens, theChildren)
-    return [ Regex::MatchOption.new(:ALL_LAZY, true) ]
+  def reduce_all_lazy(_production, _range, _tokens, _children)
+    return [Regex::MatchOption.new(:ALL_LAZY, true)]
   end
 
   # rule 'quantifiable' => %w[begin_anchor anchorable end_anchor]
-  def reduce_pinned_quantifiable(aProduction, aRange, theTokens, theChildren)
+  def reduce_pinned_quantifiable(_production, _range, _tokens, theChildren)
     theChildren[1].begin_anchor = theChildren[0]
     theChildren[1].end_anchor = theChildren[2]
     return theChildren[1]
   end
 
   # rule 'quantifiable' => %w[begin_anchor anchorable]
-  def reduce_begin_anchor_quantifiable(aProduction, aRange, theTokens, theChildren)
+  def reduce_begin_anchor_quantifiable(_production, _range, _tokens, theChildren)
     theChildren[1].begin_anchor = theChildren[0]
     return theChildren[1]
   end
 
   # rule 'quantifiable' => %w[anchorable end_anchor]
-  def reduce_end_anchor_quantifiable(aProduction, aRange, theTokens, theChildren)
+  def reduce_end_anchor_quantifiable(_production, _range, _tokens, theChildren)
     theChildren[0].end_anchor = theChildren[1]
     return theChildren[0]
   end
 
   # rule 'begin_anchor' => %w[STARTS WITH]
-  def reduce_starts_with(aProduction, aRange, theTokens, theChildren)
+  def reduce_starts_with(_production, _range, _tokens, _children)
     begin_anchor
   end
 
   # rule 'begin_anchor' => %w[BEGIN WITH]  
-  def reduce_begin_with(aProduction, aRange, theTokens, theChildren)
+  def reduce_begin_with(_production, _range, _tokens, _children)
     begin_anchor
   end  
 
   # rule 'end_anchor' => %w[MUST END].as 'end_anchor'
-  def reduce_end_anchor(aProduction, aRange, theTokens, theChildren)
+  def reduce_end_anchor(_production, _range, _tokens, _children)
     return Regex::Anchor.new('$')
   end
 
   # rule('anchorable' => %w[assertable assertion]).as 'asserted_anchorable'
-  def reduce_asserted_anchorable(aProduction, aRange, theTokens, theChildren)
+  def reduce_asserted_anchorable(_production, _range, _tokens, theChildren)
     assertion = theChildren.last
     assertion.children.unshift(theChildren[0])
     return assertion
   end
 
   # rule('assertion' => %w[IF FOLLOWED BY assertable]).as 'if_followed'
-  def reduce_if_followed(aProduction, aRange, theTokens, theChildren)
+  def reduce_if_followed(_production, _range, _tokens, theChildren)
     return Regex::Lookaround.new(theChildren.last, :ahead, :positive)
   end
 
   # rule('assertion' => %w[IF NOT FOLLOWED BY assertable]).as 'if_not_followed'
-  def reduce_if_not_followed(aProduction, aRange, theTokens, theChildren)
+  def reduce_if_not_followed(_production, _range, _tokens, theChildren)
     return Regex::Lookaround.new(theChildren.last, :ahead, :negative)
   end
 
   # rule('assertion' => %w[IF ALREADY HAD assertable]).as 'if_had'
-  def reduce_if_had(aProduction, aRange, theTokens, theChildren)
+  def reduce_if_had(_production, _range, _tokens, theChildren)
     return Regex::Lookaround.new(theChildren.last, :behind, :positive)
   end
 
   # rule('assertion' => %w[IF NOT ALREADY HAD assertable]).as 'if_not_had'
-  def reduce_if_not_had(aProduction, aRange, theTokens, theChildren)
+  def reduce_if_not_had(_production, _range, _tokens, theChildren)
     return Regex::Lookaround.new(theChildren.last, :behind, :negative)
   end
 
   # rule('assertable' => %w[term quantifier]).as 'quantified_assertable'
-  def reduce_quantified_assertable(aProduction, aRange, theTokens, theChildren)
+  def reduce_quantified_assertable(_production, _range, _tokens, theChildren)
     quantifier = theChildren[1]
     term = theChildren[0]
     repetition(term, quantifier)
   end
 
   # rule('letter_range' => %w[LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'lowercase_from_to'
-  def reduce_lowercase_from_to(aProduction, aRange, theTokens, theChildren)
+  def reduce_lowercase_from_to(_production, _range, _tokens, theChildren)
     lower = theChildren[2].token.lexeme
     upper =  theChildren[4].token.lexeme
     ch_range = char_range(lower, upper)
@@ -193,7 +191,7 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'uppercase_from_to'
-  def reduce_uppercase_from_to(aProduction, aRange, theTokens, theChildren)
+  def reduce_uppercase_from_to(_production, _range, _tokens, theChildren)
     lower = theChildren[3].token.lexeme
     upper =  theChildren[5].token.lexeme
     ch_range = char_range(lower.upcase, upper.upcase)
@@ -201,13 +199,13 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule('letter_range' => 'LETTER').as 'any_lowercase'
-  def reduce_any_lowercase(aProduction, aRange, theTokens, theChildren)
+  def reduce_any_lowercase(_production, _range, _tokens, _children)
     ch_range = char_range('a', 'z')
     char_class(false, ch_range)
   end
 
   # rule('letter_range' => %w[UPPERCASE LETTER]).as 'any_uppercase'
-  def reduce_any_uppercase(aProduction, aRange, theTokens, theChildren)
+  def reduce_any_uppercase(_production, _range, _tokens, _children)
     ch_range = char_range('A', 'Z')
     char_class(false, ch_range)
   end
@@ -218,163 +216,167 @@ class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
   end
 
   # rule('digit_range' => 'digit_or_number').as 'simple_digit_range'
-  def reduce_simple_digit_range(aProduction, aRange, theTokens, theChildren)
+  def reduce_simple_digit_range(_production, _range, _tokens, _children)
     char_shorthand('d')
   end
 
   # rule('character_class' => %w[ANY CHARACTER]).as 'any_character'
-  def reduce_any_character(aProduction, aRange, theTokens, theChildren)
+  def reduce_any_character(_production, _range, _tokens, _children)
     char_shorthand('w')
   end
 
   # rule('character_class' => %w[NO CHARACTER]).as 'no_character'
-  def reduce_no_character(aProduction, aRange, theTokens, theChildren)
+  def reduce_no_character(_production, _range, _tokens, _children)
     char_shorthand('W')
   end
 
   # rule('character_class' => 'WHITESPACE').as 'whitespace'
-  def reduce_whitespace(aProduction, aRange, theTokens, theChildren)
+  def reduce_whitespace(_production, _range, _tokens, _children)
     char_shorthand('s')
   end
 
   # rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
-  def reduce_no_whitespace(aProduction, aRange, theTokens, theChildren)
+  def reduce_no_whitespace(_production, _range, _tokens, _children)
     char_shorthand('S')
   end
 
   # rule('character_class' => 'ANYTHING').as 'anything'
-  def reduce_anything(aProduction, aRange, theTokens, theChildren)
+  def reduce_anything(_production, _range, _tokens, _children)
     wildcard
   end
 
   # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
-  def reduce_one_of(aProduction, aRange, theTokens, theChildren)
+  def reduce_one_of(_production, _range, _tokens, theChildren)
     raw_literal = theChildren[-1].token.lexeme.dup
     alternatives = raw_literal.chars.map { |ch| Regex::Character.new(ch) }
-    return Regex::CharClass.new(false, *alternatives) # TODO check other implementations
+    # TODO check other implementations
+    return Regex::CharClass.new(false, *alternatives)
   end
 
   # rule('special_char' => 'TAB').as 'tab'
-  def reduce_tab(aProduction, aRange, theTokens, theChildren)
+  def reduce_tab(_production, _range, _tokens, _children)
     Regex::Character.new('\t')
   end
 
   # rule('special_char' => 'BACKSLASH').as 'backslash'
-  def reduce_backslash(aProduction, aRange, theTokens, theChildren)
+  def reduce_backslash(_production, _range, _tokens, _children)
     Regex::Character.new('\\')
   end
 
   # rule('special_char' => %w[NEW LINE]).as 'new_line'
-  def reduce_new_line(aProduction, aRange, theTokens, theChildren)
+  def reduce_new_line(_production, _range, _tokens, _children)
     # TODO: control portability
     Regex::Character.new('\n')
   end
 
   # rule('literal' => %w[LITERALLY STRING_LIT]).as 'literally'
-  def reduce_literally(aProduction, aRange, theTokens, theChildren)
+  def reduce_literally(_production, _range, _tokens, theChildren)
     # What if literal is empty?...
 
     raw_literal = theChildren[-1].token.lexeme.dup
     return string_literal(raw_literal)
   end
 
-  #rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
-  def reduce_any_of(aProduction, aRange, theTokens, theChildren)
+  # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
+  def reduce_any_of(_production, _range, _tokens, theChildren)
     return Regex::Alternation.new(*theChildren[3])
   end
 
   # rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'
-  def reduce_alternative_list(aProduction, aRange, theTokens, theChildren)
+  def reduce_alternative_list(_production, _range, _tokens, theChildren)
     return theChildren[0] << theChildren[-1]
   end
 
   # rule('alternatives' => 'quantifiable').as 'simple_alternative'
-  def reduce_simple_alternative(aProduction, aRange, theTokens, theChildren)
+  def reduce_simple_alternative(_production, _range, _tokens, theChildren)
     return [theChildren.last]
   end
 
   # rule('grouping' => %w[LPAREN pattern RPAREN]).as 'grouping_parenthenses'
-  def reduce_grouping_parenthenses(aProduction, aRange, theTokens, theChildren)
+  def reduce_grouping_parenthenses(_production, _range, _tokens, theChildren)
     return Regex::NonCapturingGroup.new(theChildren[1])
   end
 
   # rule('capturing_group' => %w[CAPTURE assertable]).as 'capture'
-  def reduce_capture(aProduction, aRange, theTokens, theChildren)
+  def reduce_capture(_production, _range, _tokens, theChildren)
     return Regex::CapturingGroup.new(theChildren[1])
   end
 
-  # rule('capturing_group' => %w[CAPTURE assertable UNTIL assertable]).as 'capture_until'
-  def reduce_capture_until(aProduction, aRange, theTokens, theChildren)
+  # rule('capturing_group' => %w[CAPTURE assertable UNTIL assertable]).as
+  #   'capture_until'
+  def reduce_capture_until(_production, _range, _tokens, theChildren)
     group = Regex::CapturingGroup.new(theChildren[1])
     return Regex::Concatenation.new(group, theChildren[3])
   end
 
-  # rule('capturing_group' => %w[CAPTURE assertable AS var_name]).as 'named_capture'
-  def reduce_named_capture(aProduction, aRange, theTokens, theChildren)
+  # rule('capturing_group' => %w[CAPTURE assertable AS var_name]).as 
+  #   'named_capture'
+  def reduce_named_capture(_production, _range, _tokens, theChildren)
     name = theChildren[3].token.lexeme.dup
     return Regex::CapturingGroup.new(theChildren[1], name)
   end
 
-  # rule('capturing_group' => %w[CAPTURE assertable AS var_name UNTIL assertable]).as 'named_capture_until'
-  def reduce_named_capture_until(aProduction, aRange, theTokens, theChildren)
+  # rule('capturing_group' => %w[CAPTURE assertable AS var_name 
+  #   UNTIL assertable]).as 'named_capture_until'
+  def reduce_named_capture_until(_production, _range, _tokens, theChildren)
     name = theChildren[3].token.lexeme.dup
     group = Regex::CapturingGroup.new(theChildren[1], name)
     return Regex::Concatenation.new(group, theChildren[5])
   end
   
   # rule('quantifier' => 'ONCE').as 'once'
-  def reduce_once(aProduction, aRange, theTokens, theChildren)
+  def reduce_once(_production, _range, _tokens, _children)
     multiplicity(1, 1)
   end
   
   # rule('quantifier' => 'TWICE').as 'twice'
-  def reduce_twice(aProduction, aRange, theTokens, theChildren)
+  def reduce_twice(_production, _range, _tokens, _children)
     multiplicity(2, 2)
   end  
 
   # rule('quantifier' => %w[EXACTLY count TIMES]).as 'exactly'
-  def reduce_exactly(aProduction, aRange, theTokens, theChildren)
+  def reduce_exactly(_production, _range, _tokens, theChildren)
     count = theChildren[1].token.lexeme.to_i
     multiplicity(count, count)
   end
 
-  # rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as 'between_and'
-  def reduce_between_and(aProduction, aRange, theTokens, theChildren)
+  # rule('quantifier' => %w[BETWEEN count AND count times_suffix]).as
+  #   'between_and'
+  def reduce_between_and(_production, _range, _tokens, theChildren)
     lower = theChildren[1].token.lexeme.to_i
     upper = theChildren[3].token.lexeme.to_i
     multiplicity(lower, upper)
   end
   
   # rule('quantifier' => 'OPTIONAL').as 'optional'
-  def reduce_optional(aProduction, aRange, theTokens, theChildren)
+  def reduce_optional(_production, _range, _tokens, _children)
     multiplicity(0, 1)
   end
 
-   # rule('quantifier' => %w[ONCE OR MORE]).as 'once_or_more'
-  def reduce_once_or_more(aProduction, aRange, theTokens, theChildren)
+  # rule('quantifier' => %w[ONCE OR MORE]).as 'once_or_more'
+  def reduce_once_or_more(_production, _range, _tokens, _children)
     multiplicity(1, :more)
   end
   
   # rule('quantifier' => %w[NEVER OR MORE]).as 'never_or_more'
-  def reduce_never_or_more(aProduction, aRange, theTokens, theChildren)
+  def reduce_never_or_more(_production, _range, _tokens, _children)
     multiplicity(0, :more)
   end
   
   # rule('quantifier' => %w[AT LEAST count TIMES]).as 'at_least' 
-  def reduce_at_least(aProduction, aRange, theTokens, theChildren)
+  def reduce_at_least(_production, _range, _tokens, theChildren)
     count = theChildren[2].token.lexeme.to_i
     multiplicity(count, :more)
   end 
   
   # rule('times_suffix' => 'TIMES').as 'times_keyword'
-  def reduce_times_keyword(aProduction, aRange, theTokens, theChildren)
+  def reduce_times_keyword(_production, _range, _tokens, _children)
     return nil
   end
   
   # rule('times_suffix' => []).as 'times_dropped'
-  def reduce_times_dropped(aProduction, aRange, theTokens, theChildren)
+  def reduce_times_dropped(_production, _range, _tokens, _children)
     return nil
   end  
-
 end # class
 # End of file