rley 0.6.01 → 0.6.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5431e3dddd23b1b29be7db8b2b5fe268301f16f
-  data.tar.gz: 929f4f15a4d996cf0e14ddf903b15a5c5325fb93
+  metadata.gz: 9764b3e89d5395584b93ca2a06d80a3381d58560
+  data.tar.gz: 91eb805167c77da1d86cf23e04382d9c791f47c5
 SHA512:
-  metadata.gz: 3cda86bffff68e3591e89cbd05a669a59a7ee111dc75cd29fa56b0968798a981210ba3d3565bf5ed8435c2070b6ac9cb1efd35290ea10b60eee1ad3bb7d3caa7
-  data.tar.gz: c49cbc2d61484807e23cee6801057cf7618e9a0f18e85a80082acb8c08bad9012067c895ad581b7b0cdc3d3ac02699f45db42d525ce8b62e4803023d9a5cbca0
+  metadata.gz: 9dc181140698cab328974cbbca977ccbd0de1afc5eb0af628f2c7517fbb1ad93af058341e6146542540adcd7ea7268dd3a234131b3b046838c6a26e2cf05146e
+  data.tar.gz: 90e957d8e37e957b50c769de6661c3ce5f5ad9d6c48beb5c7a8e7487622568273f715c5bacdbbd7ed382f410c6cd9b420218ac447e92fc279fd901b6e0a2baea

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-### 0.6.01 / 2018-02-25
+### 0.6.02 / 2018-03-03
+* [FIX] File `examples/general/NLP/engtagger.rb` ode re-styling to remove most style offenses found by Rubocop 0.52.1
+* [DELETE] All files `examples/general/SRL` are removed. It will become a new gem by itself.
+
+### 0.6.01 / 2018-03-03
 * [FIX] Code re-styling to remove most style offenses found by Rubocop 0.52.1
 
 ### 0.6.00 / 2018-02-25

data/examples/NLP/engtagger.rb

@@ -1,6 +1,5 @@
-require "rley"
-require "engtagger"
-require "pp"
+require 'rley'
+require 'engtagger' # Load POS (Part-Of-Speech) tagger EngTagger
 
 # REGEX to remove XML tags from Engtagger output
 GET_TAG = /<(.+?)>(.*?)<.+?>/
@@ -23,7 +22,7 @@ end
 def valid_text(text)
     if !text
       # there's nothing to parse
-      "method call on uninitialized variable" if @conf[:debug]
+      puts 'method call on uninitialized variable'
       return false
     elsif /\A\s*\z/ =~ text
       # text is an empty string, nothing to parse
@@ -36,26 +35,26 @@ end
 
 def split_sentences(array)
     tokenized = array
-    people = %w(jr mr ms mrs dr prof esq sr sen sens rep reps gov attys attys
-                supt det mssrs rev)
-    army   = %w(col gen lt cmdr adm capt sgt cpl maj brig)
-    inst   = %w(dept univ assn bros ph.d)
-    place  = %w(arc al ave blvd bld cl ct cres exp expy dist mt mtn ft fy fwy
-                hwy hway la pde pd plz pl rd st tce)
-    comp   = %w(mfg inc ltd co corp)
-    state  = %w(ala ariz ark cal calif colo col conn del fed fla ga ida id ill
+    people = %w[jr mr ms mrs dr prof esq sr sen sens rep reps gov attys attys
+                supt det mssrs rev]
+    army   = %w[col gen lt cmdr adm capt sgt cpl maj brig]
+    inst   = %w[dept univ assn bros ph.d]
+    place  = %w[arc al ave blvd bld cl ct cres exp expy dist mt mtn ft fy fwy
+                hwy hway la pde pd plz pl rd st tce]
+    comp   = %w[mfg inc ltd co corp]
+    state  = %w[ala ariz ark cal calif colo col conn del fed fla ga ida id ill
                 ind ia kans kan ken ky la me md is mass mich minn miss mo mont
                 neb nebr nev mex okla ok ore penna penn pa dak tenn tex ut vt
-                va wash wis wisc wy wyo usafa alta man ont que sask yuk)
-    month  = %w(jan feb mar apr may jun jul aug sep sept oct nov dec)
-    misc   = %w(vs etc no esp)
+                va wash wis wisc wy wyo usafa alta man ont que sask yuk]
+    month  = %w[jan feb mar apr may jun jul aug sep sept oct nov dec]
+    misc   = %w[vs etc no esp]
     abbr = Hash.new
     [people, army, inst, place, comp, state, month, misc].flatten.each do |i|
       abbr[i] = true
     end
     words = Array.new
-    tokenized.each_with_index do |t, i|
-      if tokenized[i + 1] and tokenized [i + 1] =~ /[A-Z\W]/ and tokenized[i] =~ /\A(.+)\.\z/
+    tokenized.each_with_index do |_t, i|
+      if tokenized[i + 1] && tokenized [i + 1] =~ /[A-Z\W]/ && tokenized[i] =~ /\A(.+)\.\z/
         w = $1
         # Don't separate the period off words that
         # meet any of the following conditions:
@@ -63,7 +62,7 @@ def split_sentences(array)
         # 1. It is defined in one of the lists above
         # 2. It is only one letter long: Alfred E. Sloan
         # 3. It has a repeating letter-dot: U.S.A. or J.C. Penney
-        unless abbr[w.downcase] or w =~ /\A[a-z]\z/i or w =~ /[a-z](?:\.[a-z])+\z/i
+        unless abbr[w.downcase] || w =~ /\A[a-z]\z/i || w =~ /[a-z](?:\.[a-z])+\z/i
           words <<  w
           words << '.'
           next
@@ -72,7 +71,7 @@ def split_sentences(array)
       words << tokenized[i]
     end
     # If the final word ends in a period..
-    if words[-1] and words[-1] =~ /\A(.*\w)\.\z/
+    if words[-1] && words[-1] =~ /\A(.*\w)\.\z/
       words[-1] = $1
       words.push '.'
     end
@@ -85,39 +84,42 @@ def split_punct(text)
     # If there's no punctuation, return immediately
     return [text] if /\A\w+\z/ =~ text
     # Sanity checks
-    text = text.gsub(/\W{10,}/o, " ")
+    text = text.gsub(/\W{10,}/o, ' ')
 
     # Put quotes into a standard format
-    text = text.gsub(/`(?!`)(?=.*\w)/o, "` ") # Shift left quotes off text
-    text = text.gsub(/"(?=.*\w)/o, " `` ") # Convert left quotes to ``
-    text = text.gsub(/(\W|^)'(?=.*\w)/o){$1 ? $1 + " ` " : " ` "} # Convert left quotes to `
+    text = text.gsub(/`(?!`)(?=.*\w)/o, '` ') # Shift left quotes off text
+    text = text.gsub(/"(?=.*\w)/o, ' `` ') # Convert left quotes to ``
+    text = text.gsub(/(\W|^)'(?=.*\w)/o) { $1 ? $1 + ' ` ' : ' ` ' } # Convert left quote to `
     text = text.gsub(/"/, " '' ") # Convert (remaining) quotes to ''
-    text = text.gsub(/(\w)'(?!')(?=\W|$)/o){$1 + " ' "} # Separate right single quotes
+    text = text.gsub(/(\w)'(?!')(?=\W|$)/o, "\\1 ' ") # Separate right single quotes
 
     # Handle all other punctuation
-    text = text.gsub(/--+/o, " - ") # Convert and separate dashes
-    text = text.gsub(/,(?!\d)/o, " , ") # Shift commas off everything but numbers
-    text = text.gsub(/:/o, " :") # Shift semicolons off
-    text = text.gsub(/(\.\.\.+)/o){" " + $1 + " "} # Shift ellipses off
-    text = text.gsub(/([\(\[\{\}\]\)])/o){" " + $1 + " "} # Shift off brackets
-    text = text.gsub(/([\!\?#\$%;~|])/o){" " + $1 + " "} # Shift off other ``standard'' punctuation
+    text = text.gsub(/--+/o, ' - ') # Convert and separate dashes
+    text = text.gsub(/,(?!\d)/o, ' , ') # Shift comma if not following by digit
+    text = text.gsub(/:/o, ' :') # Shift semicolon off
+    text = text.gsub(/(\.\.\.+)/o, ' \1 ') # Shift ellipses off
+    text = text.gsub(/([\(\[\{\}\]\)])/o, ' \1 ') # Shift off brackets
+    text = text.gsub(/([\!\?#\$%;~|])/o, ' \1 ') # Shift off other ``standard'' punctuation
 
     # English-specific contractions
-    text = text.gsub(/([A-Za-z])'([dms])\b/o){$1 + " '" + $2}  # Separate off 'd 'm 's
-    text = text.gsub(/n't\b/o, " n't")                     # Separate off n't
-    text = text.gsub(/'(ve|ll|re)\b/o){" '" + $1}         # Separate off 've, 'll, 're
+    text = text.gsub(/([A-Za-z])'([dms])\b/o, "\\1 '\\2") # Separate off 'd 'm 's
+    text = text.gsub(/n't\b/o, " n't") # Separate off n't
+    text = text.gsub(/'(ve|ll|re)\b/o, " '\\1") # Separate off 've, 'll, 're
     result = text.split(' ')
     return result
 end
 
 
-# Instantiate a builder object that will build the grammar for us
-builder = Rley::Syntax::GrammarBuilder.new do
+# Instantiate a facade object as our Rley interface
+nlp_engine = Rley::Engine.new
 
-  add_terminals('NN', 'NNP') 
+# Now build a very simplified English grammar...
+nlp_engine.build_grammar do
+  # Terminals have same names as POS tags returned by Engtagger
+  add_terminals('NN', 'NNP')
   add_terminals('DET', 'IN', 'VBD')
 
-# Here we define the productions (= grammar rules)
+  # Here we define the productions (= grammar rules)
   rule 'S' => %w[NP VP]
   rule 'NP' => 'NNP'
   rule 'NP' => %w[DET NN]
@@ -125,52 +127,48 @@ builder = Rley::Syntax::GrammarBuilder.new do
   rule 'VP' => %w[VBD NP]
   rule 'VP' => %w[VBD NP PP]
   rule 'PP' => %w[IN NP]
-end 
-
-# And now, let's build the grammar...
-grammar = builder.grammar
-
-parser = Rley::Parser::GFGEarleyParser.new(grammar)
+end
 
 # text = "Yo I'm not done with you"
-text= "John saw Mary with a telescope"
-pp "Input text --> #{text}"
+text = 'John saw Mary with a telescope'
+puts "Input text --> #{text}"
 
 tgr = EngTagger.new
 
-# Generte POS
+# Generate raw POS output
 tagged = tgr.add_tags(text)
 
 # Generte tokenied lexicon of input text
-# Instead of creating a lexicon dictionary, we would simply generate one each time on the fly for the current text only.
+# Instead of creating a lexicon dictionary, 
+# we would simply generate one each time on the fly for the current text only.
 lexicon = clean_text(text)
 
-# Generte POS tokens in [[word, pos], ..] format
+# Convert EngTagger POS tokens in [[word, pos], ..] format
 tokens = tagged.scan(GET_TAG).map { |tag, word| [word, tag.upcase] }
 
-def tokenizer(lexicon, grammar, tokens)
+def tokenizer(lexicon, tokens)
   rley_tokens = []
-  lexicon.each_with_index do |word, i| 
+  lexicon.each_with_index do |word, i|
     term_name = tokens[i].last
-    terminal = grammar.name2symbol[term_name]
-    rley_tokens << Rley::Lexical::Token.new(word, terminal)
+    rley_tokens << Rley::Lexical::Token.new(word, term_name)
   end
   return rley_tokens
 end
 
 # Convert input text into a sequence of rley token objects...
-rley_tokens = tokenizer(lexicon, grammar, tokens)
+rley_tokens = tokenizer(lexicon, tokens)
 
-result = parser.parse(rley_tokens)
+# Let Rley grok the tokens
+result = nlp_engine.parse(rley_tokens)
 
-pp "Parsing successful? #{result.success?}" # => Parsing successful? true
-pp result.failure_reason.message unless result.success?
+puts "Parsing successful? #{result.success?}" # => Parsing successful? true
+puts result.failure_reason.message unless result.success?
 
-ptree = result.parse_tree
+ptree = nlp_engine.convert(result)
 
-visitor = Rley::ParseTreeVisitor.new(ptree)
+visitor = nlp_engine.ptree_visitor(ptree)
 
 renderer = Rley::Formatter::Asciitree.new($stdout)
 
-# Subscribe the formatter to the visitor's event and launch the visit
-pp renderer.render(visitor)   
+# Let's visualize the parse tree (in text format...)
+puts renderer.render(visitor)

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.6.01'.freeze
+  Version = '0.6.02'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.6.01
+  version: 0.6.02
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-02 00:00:00.000000000 Z
+date: 2018-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -142,37 +142,6 @@ files:
 - examples/data_formats/JSON/json_grammar.rb
 - examples/data_formats/JSON/json_lexer.rb
 - examples/data_formats/JSON/json_minifier.rb
-- examples/general/SRL/lib/ast_builder.rb
-- examples/general/SRL/lib/grammar.rb
-- examples/general/SRL/lib/regex/abstract_method.rb
-- examples/general/SRL/lib/regex/alternation.rb
-- examples/general/SRL/lib/regex/anchor.rb
-- examples/general/SRL/lib/regex/atomic_expression.rb
-- examples/general/SRL/lib/regex/capturing_group.rb
-- examples/general/SRL/lib/regex/char_class.rb
-- examples/general/SRL/lib/regex/char_range.rb
-- examples/general/SRL/lib/regex/char_shorthand.rb
-- examples/general/SRL/lib/regex/character.rb
-- examples/general/SRL/lib/regex/compound_expression.rb
-- examples/general/SRL/lib/regex/concatenation.rb
-- examples/general/SRL/lib/regex/expression.rb
-- examples/general/SRL/lib/regex/lookaround.rb
-- examples/general/SRL/lib/regex/match_option.rb
-- examples/general/SRL/lib/regex/monadic_expression.rb
-- examples/general/SRL/lib/regex/multiplicity.rb
-- examples/general/SRL/lib/regex/non_capturing_group.rb
-- examples/general/SRL/lib/regex/polyadic_expression.rb
-- examples/general/SRL/lib/regex/quantifiable.rb
-- examples/general/SRL/lib/regex/repetition.rb
-- examples/general/SRL/lib/regex/wildcard.rb
-- examples/general/SRL/lib/regex_repr.rb
-- examples/general/SRL/lib/tokenizer.rb
-- examples/general/SRL/spec/integration_spec.rb
-- examples/general/SRL/spec/regex/character_spec.rb
-- examples/general/SRL/spec/regex/multiplicity_spec.rb
-- examples/general/SRL/spec/spec_helper.rb
-- examples/general/SRL/spec/tokenizer_spec.rb
-- examples/general/SRL/srl_demo.rb
 - examples/general/calc_iter1/calc_ast_builder.rb
 - examples/general/calc_iter1/calc_ast_nodes.rb
 - examples/general/calc_iter1/calc_demo.rb

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

@@ -1,382 +0,0 @@
-require 'stringio'
-require_relative 'regex_repr'
-
-# The purpose of a ASTBuilder is to build piece by piece an AST
-# (Abstract Syntax Tree) from a sequence of input tokens and
-# visit events produced by walking over a GFGParsing object.
-# Uses the Builder GoF pattern.
-# 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 ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-  Terminal2NodeClass = {}.freeze
-
-  attr_reader :options
-
-  protected
-  
-  def terminal2node()
-    Terminal2NodeClass
-  end
-
-  # Overriding method.
-  # Factory method for creating a node object for the given
-  # input token.
-  # @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(_production, _terminal, aTokenPosition, aToken)
-    node = Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
-
-    return node
-  end
-
-  def multiplicity(lowerBound, upperBound)
-    return SRL::Regex::Multiplicity.new(lowerBound, upperBound, :greedy)
-  end
-
-  def string_literal(aString, to_escape = true)
-    if aString.size > 1
-      chars = []
-      aString.each_char do |ch|
-        if to_escape && Regex::Character::MetaChars.include?(ch)
-          chars << Regex::Character.new("\\")
-        end
-        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
-      result = Regex::Character.new(aString)
-    end
-
-    return result
-  end
-
-  def char_range(lowerBound, upperBound)
-    # TODO fix module nesting
-    lower = Regex::Character.new(lowerBound)
-    upper = Regex::Character.new(upperBound)
-    return Regex::CharRange.new(lower, upper)
-  end
-
-  def char_class(toNegate, *theChildren)
-    Regex::CharClass.new(toNegate, *theChildren)
-  end
-
-  def char_shorthand(shortName)
-    Regex::CharShorthand.new(shortName)
-  end
-
-  def wildcard()
-    Regex::Wildcard.new
-  end
-
-  def repetition(expressionToRepeat, aMultiplicity)
-    return Regex::Repetition.new(expressionToRepeat, aMultiplicity)
-  end
-  
-  def begin_anchor
-    return Regex::Anchor.new('^')
-  end
-  
-  # rule('expression' => %w[pattern separator flags]).as 'flagged_expr'
-  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(_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(_production, _range, _tokens, theChildren)
-    theChildren[0] << theChildren[2]
-  end
-
-  # rule('single_flag' => %w[CASE INSENSITIVE]).as 'case_insensitive'
-  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(_production, _range, _tokens, _children)
-    return [Regex::MatchOption.new(:MULTILINE, true)]
-  end
-
-  # rule('single_flag' => %w[ALL LAZY]).as 'all_lazy'
-  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(_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(_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(_production, _range, _tokens, theChildren)
-    theChildren[0].end_anchor = theChildren[1]
-    return theChildren[0]
-  end
-
-  # rule 'begin_anchor' => %w[STARTS WITH]
-  def reduce_starts_with(_production, _range, _tokens, _children)
-    begin_anchor
-  end
-
-  # rule 'begin_anchor' => %w[BEGIN WITH]  
-  def reduce_begin_with(_production, _range, _tokens, _children)
-    begin_anchor
-  end  
-
-  # rule 'end_anchor' => %w[MUST END].as 'end_anchor'
-  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(_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(_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(_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(_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(_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(_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(_production, _range, _tokens, theChildren)
-    lower = theChildren[2].token.lexeme
-    upper =  theChildren[4].token.lexeme
-    ch_range = char_range(lower, upper)
-    char_class(false, ch_range)
-  end
-
-  # rule('letter_range' => %w[UPPERCASE LETTER FROM LETTER_LIT TO LETTER_LIT]).as 'uppercase_from_to'
-  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)
-    char_class(false, ch_range)
-  end
-
-  # rule('letter_range' => 'LETTER').as 'any_lowercase'
-  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(_production, _range, _tokens, _children)
-    ch_range = char_range('A', 'Z')
-    char_class(false, ch_range)
-  end
-
-  # rule('digit_range' => %w[digit_or_number FROM DIGIT_LIT TO DIGIT_LIT]).as 'digits_from_to'
-  def reduce_digits_from_to(aProduction, aRange, theTokens, theChildren)
-    reduce_lowercase_from_to(aProduction, aRange, theTokens, theChildren)
-  end
-
-  # rule('digit_range' => 'digit_or_number').as 'simple_digit_range'
-  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(_production, _range, _tokens, _children)
-    char_shorthand('w')
-  end
-
-  # rule('character_class' => %w[NO CHARACTER]).as 'no_character'
-  def reduce_no_character(_production, _range, _tokens, _children)
-    char_shorthand('W')
-  end
-
-  # rule('character_class' => 'WHITESPACE').as 'whitespace'
-  def reduce_whitespace(_production, _range, _tokens, _children)
-    char_shorthand('s')
-  end
-
-  # rule('character_class' => %w[NO WHITESPACE]).as 'no_whitespace'
-  def reduce_no_whitespace(_production, _range, _tokens, _children)
-    char_shorthand('S')
-  end
-
-  # rule('character_class' => 'ANYTHING').as 'anything'
-  def reduce_anything(_production, _range, _tokens, _children)
-    wildcard
-  end
-
-  # rule('alternation' => %w[ANY OF LPAREN alternatives RPAREN]).as 'any_of'
-  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) }
-    # TODO check other implementations
-    return Regex::CharClass.new(false, *alternatives)
-  end
-
-  # rule('special_char' => 'TAB').as 'tab'
-  def reduce_tab(_production, _range, _tokens, _children)
-    Regex::Character.new('\t')
-  end
-
-  # rule('special_char' => 'BACKSLASH').as 'backslash'
-  def reduce_backslash(_production, _range, _tokens, _children)
-    Regex::Character.new('\\')
-  end
-
-  # rule('special_char' => %w[NEW LINE]).as 'new_line'
-  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(_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(_production, _range, _tokens, theChildren)
-    return Regex::Alternation.new(*theChildren[3])
-  end
-
-  # rule('alternatives' => %w[alternatives separator quantifiable]).as 'alternative_list'
-  def reduce_alternative_list(_production, _range, _tokens, theChildren)
-    return theChildren[0] << theChildren[-1]
-  end
-
-  # rule('alternatives' => 'quantifiable').as 'simple_alternative'
-  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(_production, _range, _tokens, theChildren)
-    return Regex::NonCapturingGroup.new(theChildren[1])
-  end
-
-  # rule('capturing_group' => %w[CAPTURE assertable]).as 'capture'
-  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(_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(_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(_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(_production, _range, _tokens, _children)
-    multiplicity(1, 1)
-  end
-  
-  # rule('quantifier' => 'TWICE').as 'twice'
-  def reduce_twice(_production, _range, _tokens, _children)
-    multiplicity(2, 2)
-  end  
-
-  # rule('quantifier' => %w[EXACTLY count TIMES]).as 'exactly'
-  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(_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(_production, _range, _tokens, _children)
-    multiplicity(0, 1)
-  end
-
-  # 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(_production, _range, _tokens, _children)
-    multiplicity(0, :more)
-  end
-  
-  # rule('quantifier' => %w[AT LEAST count TIMES]).as 'at_least' 
-  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(_production, _range, _tokens, _children)
-    return nil
-  end
-  
-  # rule('times_suffix' => []).as 'times_dropped'
-  def reduce_times_dropped(_production, _range, _tokens, _children)
-    return nil
-  end  
-end # class
-# End of file