sequitur 0.1.18 → 0.1.19

data/examples/symbol_sample.rb

@@ -1,19 +1,17 @@
-require 'sequitur'  # Load the Sequitur library
+require 'sequitur' # Load the Sequitur library
 
 #
 # Purpose: show how to apply Sequitur on a stream of Symbol values
 #
-input_sequence =  [
-  :aa, :bb, :aa, :bb,
-  :cc, :aa, :bb, :cc, 
-  :dd, :aa, :bb, :cc, 
-  :dd, :ee
+input_sequence = %i[
+  aa bb aa bb cc
+  aa bb cc dd aa
+  bb cc dd ee
 ]
 
 # Generate the grammar from the sequence
 grammar = Sequitur.build_from(input_sequence)
 
-
 # Use a formatter to display the grammar rules on the console output
 formatter = Sequitur::Formatter::BaseText.new(STDOUT)
 
@@ -25,4 +23,3 @@ formatter.render(grammar.visitor)
 # P1 : aa bb.
 # P2 : P1 cc.
 # P3 : P2 dd.
-

data/examples/word_sample.rb

@@ -1,4 +1,4 @@
-require 'sequitur'  # Load the Sequitur library
+require 'sequitur' # Load the Sequitur library
 
 #
 # Purpose: show how to apply Sequitur on a stream of text words
@@ -27,4 +27,3 @@ formatter.render(grammar.visitor)
 # start : P2 6 Error illegal P1 20 P2 9.
 # P1 : character at position.
 # P2 : Error unknown P1.
-

data/lib/sequitur/constants.rb

@@ -3,7 +3,7 @@
 
 module Sequitur # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.18'.freeze
+  Version = '0.1.19'.freeze
 
   # Brief description of the gem.
   Description = 'Ruby implementation of the Sequitur algorithm'.freeze

data/lib/sequitur/digram.rb

@@ -1,49 +1,49 @@
 # File: digram.rb
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
-# In linguistics, a digram is a sequence of two letters.
-# In Sequitur, a digram is a sequence of two consecutive symbols that
-# appear in a production rule. Each symbol in a digram
-# can be a terminal or not.
-class Digram
-  # The sequence of two consecutive grammar symbols.
-  #   The two symbols should respond to the :hash message.
-  attr_reader(:symbols)
+  # In linguistics, a digram is a sequence of two letters.
+  # In Sequitur, a digram is a sequence of two consecutive symbols that
+  # appear in a production rule. Each symbol in a digram
+  # can be a terminal or not.
+  class Digram
+    # The sequence of two consecutive grammar symbols.
+    #   The two symbols should respond to the :hash message.
+    attr_reader(:symbols)
 
-  # An unique hash key of the digram
-  attr_reader(:key)
+    # An unique hash key of the digram
+    attr_reader(:key)
 
-  # The production in which the digram occurs
-  attr_reader(:production)
+    # The production in which the digram occurs
+    attr_reader(:production)
 
-  # Constructor.
-  # A digram represents a sequence of two symbols
-  # (that appears in a rhs of a production).
-  # Terminal symbols must respond to the :hash message.
-  # @param symbol1 [StringOrSymbol] First element of the digram
-  # @param symbol2 [StringOrSymbol] Second element of the digram
-  # @param aProduction [Production] Production in which the RHS
-  #   the sequence symbol1 symbol2 appears.
-  def initialize(symbol1, symbol2, aProduction)
-    @symbols = [symbol1, symbol2]
-    @key = symbol1.hash.to_s(16) + ':' + symbol2.hash.to_s(16)
-    @production = aProduction
-  end
+    # Constructor.
+    # A digram represents a sequence of two symbols
+    # (that appears in a rhs of a production).
+    # Terminal symbols must respond to the :hash message.
+    # @param symbol1 [StringOrSymbol] First element of the digram
+    # @param symbol2 [StringOrSymbol] Second element of the digram
+    # @param aProduction [Production] Production in which the RHS
+    #   the sequence symbol1 symbol2 appears.
+    def initialize(symbol1, symbol2, aProduction)
+      @symbols = [symbol1, symbol2]
+      @key = symbol1.hash.to_s(16) + ':' + symbol2.hash.to_s(16)
+      @production = aProduction
+    end
 
-  # Equality testing.
-  #   true iff keys of both digrams are equal, false otherwise
-  # @param other [Digram] another to compare with
-  # @return [true/false]
-  def ==(other)
-    return key == other.key
-  end
+    # Equality testing.
+    #   true iff keys of both digrams are equal, false otherwise
+    # @param other [Digram] another to compare with
+    # @return [true/false]
+    def ==(other)
+      return key == other.key
+    end
 
-  # Does the digram consists of twice the same symbols?
-  # @return [true/false] true when symbols.first == symbols.last
-  def repeating?()
-    return symbols[0] == symbols[1]
-  end
-end # class
+    # Does the digram consists of twice the same symbols?
+    # @return [true/false] true when symbols.first == symbols.last
+    def repeating?
+      return symbols[0] == symbols[1]
+    end
+  end # class
 end # module
 
 # End of file

data/lib/sequitur/dynamic_grammar.rb

@@ -2,100 +2,96 @@ require_relative 'production'
 require_relative 'grammar_visitor'
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
-# A dynamic grammar is a context-free grammar that can be built incrementally.
-#   Formally, a grammar has:
-#   One start production
-#   Zero or more other productions
-#   Each production has a rhs that is a sequence of grammar symbols.
-#   Grammar symbols are categorized into
-#   -terminal symbols (i.e. String, Ruby Symbol,...)
-#   -non-terminal symbols (i.e. ProductionRef)
-class DynamicGrammar
-  # Link to the start production.
-  attr_reader(:start)
-
-  # The set of production rules of the grammar
-  attr_reader(:productions)
-
-  # nodoc Trace the execution of the algorithm.
-  attr(:trace)
-
-
-  # Constructor.
-  # Build a grammar with one empty rule as start/start rule.
-  def initialize()
-    @start = Production.new
-    @productions = [ start ]
-    @trace = false
-  end
-
-  # Emit a text representation of the grammar.
-  # Each production rule is emitted per line.
-  # @return [String]
-  def to_string()
-    rule_text = productions.map(&:to_string).join("\n")
-    return rule_text
-  end
-
-
-  # Add a given production to the grammar.
-  # @param aProduction [Production]
-  def add_production(aProduction)
-    # TODO: remove output
-    puts "Adding #{aProduction.object_id}" if trace
-    puts aProduction.to_string if trace
-    productions << aProduction
-  end
-
-
-  # Remove a production with given index from the grammar
-  # @param anIndex [Fixnum]
-  # @return [Production] the production removed from the grammar.
-  def remove_production(anIndex)
-    puts "Before production removal #{productions[anIndex].object_id}" if trace
-    puts to_string if trace
-    prod = productions.delete_at(anIndex)
-    # TODO: remove output
-    puts('Removed: ' + prod.to_string) if trace
-    prod.clear_rhs
-
-    return prod
-  end
-
-
-  # Add the given token to the grammar.
-  #   Append the token to the rhs of the start/start rule.
-  # @param aToken [Object] input token to add
-  def add_token(aToken)
-    append_symbol_to(start, aToken)
-  end
-
-  # Part of the 'visitee' role in the Visitor design pattern.
-  #   A visitee is expected to accept the visit from a visitor object
-  # @param aVisitor [GrammarVisitor] the visitor object
-  def accept(aVisitor)
-    aVisitor.start_visit_grammar(self)
-
-    # Let's proceed with the visit of productions
-    productions.each { |prod| prod.accept(aVisitor) }
-
-    aVisitor.end_visit_grammar(self)
-  end
-
-  # Factory method. Returns a visitor for this grammar.
-  # @return [GrammarVisitor]
-  def visitor()
-    return GrammarVisitor.new(self)
-  end
-
-  protected
-
-  # Append a given symbol to the rhs of passed production.
-  # @param aProduction [Production]
-  # @param aSymbol [Object]
-  def append_symbol_to(aProduction, aSymbol)
-    aProduction.append_symbol(aSymbol)
-  end
-end # class
+  # A dynamic grammar is a context-free grammar that can be built incrementally.
+  #   Formally, a grammar has:
+  #   One start production
+  #   Zero or more other productions
+  #   Each production has a rhs that is a sequence of grammar symbols.
+  #   Grammar symbols are categorized into
+  #   -terminal symbols (i.e. String, Ruby Symbol,...)
+  #   -non-terminal symbols (i.e. ProductionRef)
+  class DynamicGrammar
+    # Link to the start production.
+    attr_reader(:start)
+
+    # The set of production rules of the grammar
+    attr_reader(:productions)
+
+    # nodoc Trace the execution of the algorithm.
+    attr(:trace)
+
+    # Constructor.
+    # Build a grammar with one empty rule as start/start rule.
+    def initialize
+      @start = Production.new
+      @productions = [start]
+      @trace = false
+    end
+
+    # Emit a text representation of the grammar.
+    # Each production rule is emitted per line.
+    # @return [String]
+    def to_string
+      rule_text = productions.map(&:to_string).join("\n")
+      return rule_text
+    end
+
+    # Add a given production to the grammar.
+    # @param aProduction [Production]
+    def add_production(aProduction)
+      # TODO: remove output
+      puts "Adding #{aProduction.object_id}" if trace
+      puts aProduction.to_string if trace
+      productions << aProduction
+    end
+
+    # Remove a production with given index from the grammar
+    # @param anIndex [Fixnum]
+    # @return [Production] the production removed from the grammar.
+    def remove_production(anIndex)
+      puts "Before production removal #{productions[anIndex].object_id}" if trace
+      puts to_string if trace
+      prod = productions.delete_at(anIndex)
+      # TODO: remove output
+      puts('Removed: ' + prod.to_string) if trace
+      prod.clear_rhs
+
+      return prod
+    end
+
+    # Add the given token to the grammar.
+    #   Append the token to the rhs of the start/start rule.
+    # @param aToken [Object] input token to add
+    def add_token(aToken)
+      append_symbol_to(start, aToken)
+    end
+
+    # Part of the 'visitee' role in the Visitor design pattern.
+    #   A visitee is expected to accept the visit from a visitor object
+    # @param aVisitor [GrammarVisitor] the visitor object
+    def accept(aVisitor)
+      aVisitor.start_visit_grammar(self)
+
+      # Let's proceed with the visit of productions
+      productions.each { |prod| prod.accept(aVisitor) }
+
+      aVisitor.end_visit_grammar(self)
+    end
+
+    # Factory method. Returns a visitor for this grammar.
+    # @return [GrammarVisitor]
+    def visitor
+      return GrammarVisitor.new(self)
+    end
+
+    protected
+
+    # Append a given symbol to the rhs of passed production.
+    # @param aProduction [Production]
+    # @param aSymbol [Object]
+    def append_symbol_to(aProduction, aSymbol)
+      aProduction.append_symbol(aSymbol)
+    end
+  end # class
 end # module
 # End of file

data/lib/sequitur/formatter/base_text.rb

@@ -72,7 +72,7 @@ module Sequitur
       private
 
       # Read accessor of the production lookup
-      def prod_lookup()
+      def prod_lookup
         return @prod_lookup
       end
 

data/lib/sequitur/formatter/debug.rb

@@ -109,11 +109,11 @@ module Sequitur
 
       private
 
-      def indent()
+      def indent
         @indentation += 1
       end
 
-      def dedent()
+      def dedent
         @indentation -= 1
       end
 

data/lib/sequitur/grammar_visitor.rb

@@ -1,104 +1,102 @@
 module Sequitur # Module for classes implementing the Sequitur algorithm
 # A visitor class dedicated in the visit of Grammar.
-class GrammarVisitor
-  # Link to the grammar to visit
-  attr_reader(:grammar)
-
-  # List of objects that subscribed to the visit event notification.
-  attr_reader(:subscribers)
-
-  # Build a visitor for the given grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def initialize(aGrammar)
-    @grammar = aGrammar
-    @subscribers = []
-  end
-
-  # Add a subscriber for the visit event notification.
-  # @param aSubscriber [Object]
-  def subscribe(aSubscriber)
-    subscribers << aSubscriber
-  end
-
-  # Remove the given object from the subscription list.
-  # The object won't be notified of visit events.
-  # @param aSubscriber [Object]
-  def unsubscribe(aSubscriber)
-    subscribers.delete_if { |entry| entry == aSubscriber }
-  end
-
-  # The signal to start the visit.
-  def start()
-    grammar.accept(self)
-  end
-
-
-  # Visit event. The visitor is about to visit the grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def start_visit_grammar(aGrammar)
-    broadcast(:before_grammar, aGrammar)
-  end
-
-
-  # Visit event. The visitor is about to visit the given production.
-  # @param aProduction [Production] the production to visit.
-  def start_visit_production(aProduction)
-    broadcast(:before_production, aProduction)
-  end
-
-  # Visit event. The visitor is about to visit the given rhs of production.
-  # @param rhs [SymbolSequence] the rhs of a production to visit.
-  def start_visit_rhs(rhs)
-    broadcast(:before_rhs, rhs)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given reference production (= non-terminal symbol).
-  # @param aProdRef [ProductionRef] the production reference to visit.
-  def visit_prod_ref(aProdRef)
-    production = aProdRef.production
-    broadcast(:before_non_terminal, production)
-    broadcast(:after_non_terminal, production)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given terminal symbol.
-  # @param aTerminal [Object] the terminal to visit.
-  def visit_terminal(aTerminal)
-    broadcast(:before_terminal, aTerminal)
-    broadcast(:after_terminal, aTerminal)
-  end
-
-  # Visit event. The visitor has completed its visit of the given rhs.
-  # @param rhs [SymbolSequence] the rhs of a production to visit.
-  def end_visit_rhs(rhs)
-    broadcast(:after_rhs, rhs)
-  end
-
-  # Visit event. The visitor has completed its visit of the given production.
-  # @param aProduction [Production] the production to visit.
-  def end_visit_production(aProduction)
-    broadcast(:after_production, aProduction)
-  end
-
-  # Visit event. The visitor has completed the visit of the grammar.
-  # @param aGrammar [DynamicGrammar-like] the grammar to visit.
-  def end_visit_grammar(aGrammar)
-    broadcast(:after_grammar, aGrammar)
-  end
-
-  private
-
-  # Send a notification to all subscribers.
-  # @param msg [Symbol] event to notify
-  # @param args [Array] arguments of the notification.
-  def broadcast(msg, *args)
-    subscribers.each do |a_subscriber|
-      next unless a_subscriber.respond_to?(msg)
-      a_subscriber.send(msg, *args)
+  class GrammarVisitor
+    # Link to the grammar to visit
+    attr_reader(:grammar)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+
+    # Build a visitor for the given grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def initialize(aGrammar)
+      @grammar = aGrammar
+      @subscribers = []
     end
-  end
-end # class
+
+    # Add a subscriber for the visit event notification.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to start the visit.
+    def start
+      grammar.accept(self)
+    end
+
+    # Visit event. The visitor is about to visit the grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def start_visit_grammar(aGrammar)
+      broadcast(:before_grammar, aGrammar)
+    end
+
+    # Visit event. The visitor is about to visit the given production.
+    # @param aProduction [Production] the production to visit.
+    def start_visit_production(aProduction)
+      broadcast(:before_production, aProduction)
+    end
+
+    # Visit event. The visitor is about to visit the given rhs of production.
+    # @param rhs [SymbolSequence] the rhs of a production to visit.
+    def start_visit_rhs(rhs)
+      broadcast(:before_rhs, rhs)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given reference production (= non-terminal symbol).
+    # @param aProdRef [ProductionRef] the production reference to visit.
+    def visit_prod_ref(aProdRef)
+      production = aProdRef.production
+      broadcast(:before_non_terminal, production)
+      broadcast(:after_non_terminal, production)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given terminal symbol.
+    # @param aTerminal [Object] the terminal to visit.
+    def visit_terminal(aTerminal)
+      broadcast(:before_terminal, aTerminal)
+      broadcast(:after_terminal, aTerminal)
+    end
+
+    # Visit event. The visitor has completed its visit of the given rhs.
+    # @param rhs [SymbolSequence] the rhs of a production to visit.
+    def end_visit_rhs(rhs)
+      broadcast(:after_rhs, rhs)
+    end
+
+    # Visit event. The visitor has completed its visit of the given production.
+    # @param aProduction [Production] the production to visit.
+    def end_visit_production(aProduction)
+      broadcast(:after_production, aProduction)
+    end
+
+    # Visit event. The visitor has completed the visit of the grammar.
+    # @param aGrammar [DynamicGrammar-like] the grammar to visit.
+    def end_visit_grammar(aGrammar)
+      broadcast(:after_grammar, aGrammar)
+    end
+
+    private
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |a_subscriber|
+        next unless a_subscriber.respond_to?(msg)
+        a_subscriber.send(msg, *args)
+      end
+    end
+  end # class
 end # module
 
 # End of file