sequitur 0.0.14 → 0.1.00

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTMxYzgwZmZkMzg1YTYzMjEzZTA4Yzg0NWY2YTdkZjk2ODI2ZDVhYg==
+    ZDAyNmJiYjE4YTQzNWMxZDI0ZWU2NTJhMGZiMTBiMmI0ZDg5MTBkOA==
   data.tar.gz: !binary |-
-    NTgxM2M1MjY2MzNkYmE0NjhhNzBkOTIwNDdmOGM0OWYwMjNkOGMwZA==
+    MzI2YzIxMmZkYjExYTk1Yjc4ZTk0MDg0ZjczYjUxNDI4YWNkMWMxZg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NmI0YzAyNTRhYmRmODc5MTgwZmYyYWNmMzExMmRhM2FjNWI0OGQyOTYxZmRk
-    N2FkOTc2ZDU1Mzg3NjllN2M1ZmQyMDM2YWJjNGIzY2IwN2JjYzhiZjg2MGQ1
-    ZjcxYmQxYzAwYmFlOTc2MTRmMmU4YzJmMDk5ZDU5OTZkZWFlYjE=
+    NzEwYTk3ZGFhOGU5ZDZkMWRlMWVmZWU5MDQxOTQ0YTk5ZDIzMGM4YjY1ODAw
+    NjQyYmU0ODEwZTRhYzM4ZjVmMWQ3ZDgyNjdiNDkzNjMyZmExZjFmN2Q0MTk3
+    ODE4NTQwYjBiZGQ5M2QyY2JlZTczMzIzMWI0YjUwYzVmNzkyNjg=
   data.tar.gz: !binary |-
-    NDU3NDUxZjA1NDg0Njg5MzYzMmM0MDRiMDIzOGY2ZTlmMDIwYWNlMjJjYTNm
-    ZjA0YTdhMjc0MTg3MTFkNjBmMWVlZTQzY2FlMDVmNjg5ODFmODMwNDMxY2U5
-    OGI3ZGI4ZDFjZDFhMzFjMTFjZTg5MWYzMzc3Y2QwZWIyNmFiZDU=
+    MTYxOWNiMjg5MzRhY2JlOTdmYjJjZmI0YjVkYzA1MmIxMmY5NjQ4NDY2Zjc1
+    NWJlY2MyY2Q4ZWE2OTFmZGFiZWU1YjZkMjNmMzYzY2ZmYmM2MTE3MWVjODNj
+    ZDBlNzA3M2VjNmI3NTJhNTk5NGY0OGY4ODFlOGJhZDY1MDMyZmU=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.00 / 2014-09-16
+* [CHANGE] Version number bumped. Added grammar rendering through specialized formatters.
+
+
 ### 0.0.14 / 2014-09-10
 * [CHANGE] Removal of invariant checking methods in `SequiturGrammar` class. These caused polynomial slowdown.
 

data/README.md

@@ -5,6 +5,7 @@ _Ruby gem implementing the Sequitur algorithm_
 
 [![Build Status](https://travis-ci.org/famished-tiger/Sequitur.svg?branch=master)](https://travis-ci.org/famished-tiger/Sequitur)
 [![Gem Version](https://badge.fury.io/rb/sequitur.svg)](http://badge.fury.io/rb/sequitur)
+[![Dependency Status](https://gemnasium.com/famished-tiger/Sequitur.png)](https://gemnasium.com/famished-tiger/Sequitur)
 
 
 ### What is the Sequitur algorithm? ###
@@ -19,22 +20,30 @@ It detects repeated token patterns and can represent them in a compact way.
 
 ```ruby  
 
-    require 'sequitur' # Load the Sequitur library
-    
-    input_sequence =  'abcabdab'  # Let's analyze this string
+    require 'sequitur'  # Load the Sequitur library
+
+    input_sequence =  'abcabdabcabd'  # Let's analyze this string
 
     # The SEQUITUR algorithm will detect the repeated 'ab' pattern
     # and will generate a context-free grammar that represents the input string
     grammar = Sequitur.build_from(input_sequence)
 
-    # Display the grammar rules
-    # Each rule is displayed with the format:
-    # rule_id : a_sequence_of_grammar_symbols
+    # To display the grammar rules on the console output
+    # We use a formatter
+    formatter = Sequitur::Formatter::BaseText.new(STDOUT)
+
+    # Now render the rules. Each rule is displayed with the format:
+    # rule_id : a_sequence_grammar_symbols.
     # Where: 
-    # - rule_id is the object id of a rule (in decimal)
+    # - rule_id is either 'start' or a name like 'P_xxxx' (xxxx is a sequential number)
     # - a grammar symbol is either a terminal symbol 
-    # (i.e. a character from the input) or the id of a production
-    puts grammar.to_string
+    # (i.e. a character from the input) or a rule id
+    formatter.render(grammar.visitor)
+
+    # Rendered output is:
+    # start : P_2 P_2.
+    # P_1 : a b.
+    # P_2 : P_1 c P_1 d.
 ```
 
 ### TODO: Add more documentation ###

data/lib/sequitur/constants.rb

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

data/lib/sequitur/dynamic_grammar.rb

@@ -1,4 +1,5 @@
 require_relative 'production'
+require_relative 'grammar_visitor'
 
 module Sequitur # Module for classes implementing the Sequitur algorithm
 
@@ -8,7 +9,7 @@ class DynamicGrammar
 
   # The set of production rules of the grammar
   attr_reader(:productions)
-  
+
   # nodoc Trace the execution of the algorithm.
   attr(:trace)
 
@@ -31,7 +32,7 @@ class DynamicGrammar
   end
 
 
-  # Add a production to the grammar.
+  # Add a given production to the grammar.
   def add_production(aProduction)
     # TODO: remove output
     puts "Adding #{aProduction.object_id}" if trace
@@ -42,7 +43,7 @@ class DynamicGrammar
 
 
   # Remove a production from the grammar
-  def delete_production(anIndex)
+  def remove_production(anIndex)
     puts "Before production removal #{productions[anIndex].object_id}" if trace
     puts to_string if trace
     prod = productions.delete_at(anIndex)
@@ -59,6 +60,19 @@ class DynamicGrammar
     append_symbol_to(root, aToken)
   end
 
+  # Part of the 'visitee' role.
+  # [aVisitor] a GrammarVisitor instance
+  def accept(aVisitor)
+    aVisitor.start_visit_grammar(self)
+    productions.each { |prod| prod.accept(aVisitor) }
+    aVisitor.end_visit_grammar(self)
+  end
+
+  # Factory method. Returns a visitor for this grammar.
+  def visitor()
+    return GrammarVisitor.new(self)
+  end
+
   protected
 
   def append_symbol_to(aProduction, aSymbol)
@@ -80,6 +94,17 @@ class DynamicGrammar
     end
   end
 
+
+  # Visitor pattern.
+  # A visitee is expected to accept the visit from a visitor object
+  def accept(aVisitor)
+    aVisitor.start_visit_grammar(self)
+
+    # Let's proceed with the visit of productions
+    productions.each { |a_prod| a_prod.accept(aVisitor) }
+
+    aVisitor.end_visit_grammar(self)
+  end
 end # class
 
 end # module

data/lib/sequitur/formatter/base_text.rb

@@ -0,0 +1,74 @@
+module Sequitur
+  module Formatter
+  
+    # A formatter class that can render a dynamic grammar in plain text.
+    # Synopsis:
+    # some_grammar = ... # Points to a DynamicGrammar-like object
+    # Output the result to the standard console output
+    # formatter = Sequitur::Formatter::BaseText.new(STDOUT)
+    # Render the grammar (through a visitor)
+    # formatter.run(some_grammar.visitor)
+    class BaseText
+      attr(:output)
+
+      # Constructor.
+      # [anIO]
+      def initialize(anIO)
+        @output = anIO
+        @prod_lookup = {}
+      end
+
+      public
+
+      def render(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start()
+        aVisitor.unsubscribe(self)
+      end
+      
+      def before_grammar(aGrammar)
+        aGrammar.productions.each_with_index do |a_prod, index|
+          prod_lookup[a_prod] = index
+        end
+      end
+
+      def before_production(aProduction)
+        p_name = prod_name(aProduction)
+        output.print p_name
+      end
+
+      def before_rhs(_)
+        output.print ' :'
+      end
+
+      def before_terminal(aSymbol)
+        output.print " #{aSymbol}"
+      end
+
+
+      def before_non_terminal(aProduction)
+        p_name = prod_name(aProduction)
+        output.print " #{p_name}"
+      end
+
+      def after_production(_)
+        output.print ".\n"
+      end
+
+      private
+      
+      def prod_lookup()
+        return @prod_lookup
+      end
+      
+      def prod_name(aProduction)
+        prod_index = prod_lookup[aProduction]
+        name = (prod_index == 0) ? 'start' : "P_#{prod_index}"
+        return name
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/sequitur/formatter/debug.rb

@@ -0,0 +1,86 @@
+module Sequitur
+  module Formatter
+    class Debug
+      attr(:indentation)
+      attr(:output)
+
+      # Constructor.
+      # [anIO]
+      def initialize(anIO)
+        @indentation = 0
+        @output = anIO
+      end
+
+      public
+
+      def render(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start()
+        aVisitor.unsubscribe(self)
+      end
+
+      def before_grammar(_)
+        output_event(__method__, indentation)
+        indent
+      end
+
+      def before_production(_)
+        output_event(__method__, indentation)
+        indent
+      end
+
+      def before_rhs(_)
+        output_event(__method__, indentation)
+        indent
+      end
+
+      def before_terminal(_)
+        output_event(__method__, indentation)
+      end
+
+      def after_terminal(_)
+        output_event(__method__, indentation)
+      end
+
+      def before_non_terminal(_)
+        output_event(__method__, indentation)
+      end
+
+      def after_non_terminal(_)
+        output_event(__method__, indentation)
+      end
+
+      def after_rhs(_)
+        dedent
+        output_event(__method__, indentation)
+      end
+
+      def after_production(_)
+        dedent
+        output_event(__method__, indentation)
+      end
+
+      def after_grammar(_)
+        dedent
+        output_event(__method__, indentation)
+      end
+
+      private
+
+      def indent()
+        @indentation += 1
+      end
+
+      def dedent()
+        @indentation -= 1
+      end
+
+      def output_event(anEvent, indentationLevel)
+        output.puts "#{' ' * 2 * indentationLevel}#{anEvent}"
+      end
+
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/sequitur/grammar_visitor.rb

@@ -0,0 +1,81 @@
+module Sequitur # Module for classes implementing the Sequitur algorithm
+
+# A visitor class dedicated in the visit of Grammar.
+
+class GrammarVisitor
+  attr_reader(:grammar)
+  
+  attr_reader(:subscribers)
+  
+  # Constructor.
+  # [aGrammar] a DynamicGrammar-like instance.
+  def initialize(aGrammar)
+    @grammar = aGrammar
+    @subscribers = []
+  end
+  
+  public
+  
+  # Add a subscriber to the list.
+  def subscribe(aSubscriber)
+    subscribers << aSubscriber
+  end
+  
+  def unsubscribe(aSubscriber)
+    subscribers.delete_if { |entry| entry == aSubscriber}
+  end
+  
+  # The signal to start the visit.
+  def start()
+    grammar.send(:accept, self)
+  end
+
+  
+  def start_visit_grammar(aGrammar)
+    broadcast(:before_grammar, aGrammar)
+  end
+  
+
+  def start_visit_production(aProduction)
+    broadcast(:before_production, aProduction)
+    broadcast(:before_rhs, aProduction.rhs)
+  end
+
+
+  def visit_prod_ref(aProdRef)
+    production = aProdRef.production
+    broadcast(:before_non_terminal, production)
+    broadcast(:after_non_terminal, production)
+  end
+
+  def visit_terminal(aTerminal)
+    broadcast(:before_terminal, aTerminal)
+    broadcast(:after_terminal, aTerminal)
+  end 
+
+
+  def end_visit_production(aProduction)
+    broadcast(:after_rhs, aProduction.rhs)
+    broadcast(:after_production, aProduction)
+
+  end  
+  
+  
+  def end_visit_grammar(aGrammar)
+    broadcast(:after_grammar, aGrammar)
+  end
+  
+  private
+  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

data/lib/sequitur/production.rb

@@ -15,7 +15,7 @@ module Sequitur # Module for classes implementing the Sequitur algorithm
 class Production
   # The right-hand side (rhs) consists of a sequence of grammar symbols
   attr_reader(:rhs)
-  
+
   # The reference count (= how times other productions reference this one)
   attr_reader(:refcount)
 
@@ -59,7 +59,7 @@ class Production
   end
 
 
-  # Return the set of productions appearing in the rhs.
+  # Return the set of references to production appearing in the rhs.
   def references()
     return rhs.select { |symb| symb.is_a?(ProductionRef) }
   end
@@ -71,8 +71,6 @@ class Production
   end
 
 
-
-
   # Return the list digrams found in rhs of this production.
   def recalc_digrams()
     return [] if rhs.size < 2
@@ -137,11 +135,11 @@ class Production
           msg << to_string
           fail StandardError, msg
         end
-        new_symb = aSymbol.dup       
+        new_symb = aSymbol.dup
       else
         new_symb = aSymbol
     end
-    
+
     rhs << new_symb
     digrams << Digram.new(rhs[-2], rhs[-1], self) if rhs.size >= 2
   end
@@ -197,7 +195,7 @@ class Production
       rhs[index1].unbind if rhs[index1].is_a?(ProductionRef)
       rhs.delete_at(index1)
     end
-    
+
     recalc_digrams
   end
 
@@ -211,19 +209,36 @@ class Production
   def replace_production(another)
     (0...rhs.size).to_a.reverse.each do |index|
       next unless rhs[index] == another
-      
+
       # Avoid the aliasing of production reference
-      other_rhs = another.rhs.map do |symb| 
+      other_rhs = another.rhs.map do |symb|
         symb.is_a?(ProductionRef) ? symb.dup : symb
       end
       rhs.insert(index + 1, *other_rhs)
       another.decr_refcount
       rhs.delete_at(index)
     end
-    
+
     recalc_digrams
   end
 
+
+  # Part of the 'visitee' role.
+  # [aVisitor] a GrammarVisitor instance
+  def accept(aVisitor)
+    aVisitor.start_visit_production(self)
+
+    rhs.each do |a_symb|
+      if a_symb.is_a?(ProductionRef)
+        a_symb.accept(aVisitor)
+      else
+        aVisitor.visit_terminal(a_symb)
+      end
+    end
+
+    aVisitor.end_visit_production(self)
+  end
+
 end # class
 
 end # module

data/lib/sequitur/production_ref.rb

@@ -81,6 +81,12 @@ class ProductionRef
   def unbound?()
     return production.nil?
   end
+  
+  # Part of the 'visitee' role.
+  # [aVisitor]  a GrammarVisitor instance
+  def accept(aVisitor)
+    aVisitor.visit_prod_ref(self)  
+  end
 
 end # class
 

data/lib/sequitur/sequitur_grammar.rb

@@ -41,7 +41,7 @@ class SequiturGrammar < DynamicGrammar
   end
 
   # Remove a production from the grammar
-  def delete_production(anIndex)
+  def remove_production(anIndex)
     prod = productions[anIndex]
 
     # Retrieve in the Hash all registered digrams from the removed production
@@ -170,7 +170,7 @@ class SequiturGrammar < DynamicGrammar
           !a_prod.references_of(curr_production).empty?
         end
         dependent.replace_production(productions[index])
-        delete_production(index)
+        remove_production(index)
         update_digrams_from(dependent)
       end
 

data/lib/sequitur.rb

@@ -4,6 +4,8 @@
 
 require_relative './sequitur/constants'
 require_relative './sequitur/sequitur_grammar'
+require_relative './sequitur/formatter/debug'
+require_relative './sequitur/formatter/base_text'
 
 
 module Sequitur

data/spec/sequitur/digram_spec.rb

@@ -46,3 +46,4 @@ end # describe
 end # module
 
 # End of file
+

data/spec/sequitur/dynamic_grammar_spec.rb

@@ -40,7 +40,7 @@ describe DynamicGrammar do
       subject.add_production(p_a)
       expect(subject.productions.size).to eq(2)
       expect(subject.productions.last).to eq(p_a)
-      
+
       # Error: p_b, p_c not in grammar
       expect { add_production(p_bc) }.to raise_error(StandardError)
 
@@ -48,18 +48,18 @@ describe DynamicGrammar do
       expect(subject.productions.size).to eq(3)
       expect(subject.productions.last).to eq(p_b)
 
-      # Error: p_c not in grammar      
+      # Error: p_c not in grammar
       expect { add_production(p_bc) }.to raise_error(StandardError)
 
       subject.add_production(p_c)
       expect(subject.productions.size).to eq(4)
       expect(subject.productions.last).to eq(p_c)
-      
+
       subject.add_production(p_bc)
       expect(subject.productions.size).to eq(5)
-      expect(subject.productions.last).to eq(p_bc) 
+      expect(subject.productions.last).to eq(p_bc)
     end
-    
+
     it 'should complain when rhs refers to unknown production' do
       subject.add_production(p_a)
       subject.add_production(p_b)
@@ -67,11 +67,11 @@ describe DynamicGrammar do
       msg = "Production #{p_bc.object_id} refers to production #{p_c.object_id}"
       msg << ' that is not part of the grammar.'
       expect { subject.add_production(p_bc) }.to raise_error(StandardError, msg)
-      
+
     end
   end # context
 
-  
+
   context 'Removing a production from the grammar:' do
     it 'should remove an existing production' do
       subject.add_production(p_a) # index = 1
@@ -79,25 +79,67 @@ describe DynamicGrammar do
       subject.add_production(p_c) # index = 3
       subject.add_production(p_bc) # index = 4
       expect(subject.productions.size).to eq(5)
-      
+
       expect(p_a.refcount).to eq(0)
       expect(p_b.refcount).to eq(1)
       expect(p_c.refcount).to eq(1)
-      
-      subject.delete_production(1)  # 1 => p_a
+
+      subject.remove_production(1)  # 1 => p_a
       expect(subject.productions.size).to eq(4)
       expect(p_b.refcount).to eq(1)
       expect(p_c.refcount).to eq(1)
       expect(subject.productions).not_to include(p_a)
-      
-      subject.delete_production(3) # 3 => p_bc
-      
+
+      subject.remove_production(3) # 3 => p_bc
+
       expect(subject.productions.size).to eq(3)
       expect(p_b.refcount).to eq(0)
-      expect(p_c.refcount).to eq(0) 
-      expect(subject.productions).not_to include(p_bc)      
+      expect(p_c.refcount).to eq(0)
+      expect(subject.productions).not_to include(p_bc)
+    end
+
+  end # context
+
+  context 'Visiting:' do
+    it 'should return a visitor' do
+      expect { subject.visitor }.not_to raise_error
+      expect(subject.visitor).to be_kind_of(GrammarVisitor)
+    end
+
+    it 'should accept a visitor' do
+      subject.add_production(p_a) # index = 1
+      subject.add_production(p_b) # index = 2
+      subject.add_production(p_c) # index = 3
+      subject.add_production(p_bc) # index = 4
+
+      a_visitor = subject.visitor
+      fake_formatter = double('fake-formatter')
+      a_visitor.subscribe(fake_formatter)
+
+      expect(fake_formatter).to receive(:before_grammar).with(subject).ordered
+      expect(fake_formatter).to receive(:before_production).with(subject.root).ordered
+      expect(fake_formatter).to receive(:before_rhs).with([]).ordered
+      expect(fake_formatter).to receive(:after_rhs).with([]).ordered
+      expect(fake_formatter).to receive(:after_production).with(subject.root)
+      expect(fake_formatter).to receive(:before_production).with(p_a)
+      expect(fake_formatter).to receive(:before_rhs).with(p_a.rhs)
+      expect(fake_formatter).to receive(:after_rhs).with(p_a.rhs)
+      expect(fake_formatter).to receive(:after_production).with(p_a)
+      expect(fake_formatter).to receive(:before_production).with(p_b)
+      expect(fake_formatter).to receive(:before_rhs).with(p_b.rhs)
+      expect(fake_formatter).to receive(:after_rhs).with(p_b.rhs)
+      expect(fake_formatter).to receive(:after_production).with(p_b)
+      expect(fake_formatter).to receive(:before_production).with(p_c)
+      expect(fake_formatter).to receive(:before_rhs).with(p_c.rhs)
+      expect(fake_formatter).to receive(:after_rhs).with(p_c.rhs)
+      expect(fake_formatter).to receive(:after_production).with(p_c)
+      expect(fake_formatter).to receive(:before_production).with(p_bc)
+      expect(fake_formatter).to receive(:before_rhs).with(p_bc.rhs)
+      expect(fake_formatter).to receive(:after_rhs).with(p_bc.rhs)
+      expect(fake_formatter).to receive(:after_production).with(p_bc)
+      expect(fake_formatter).to receive(:after_grammar).with(subject)
+      subject.send(:accept, a_visitor)
     end
-    
   end # context
 
 

data/spec/sequitur/formatter/base_text_spec.rb

@@ -0,0 +1,82 @@
+require_relative '../../spec_helper'
+require 'stringio'
+
+require_relative '../../../lib/sequitur/dynamic_grammar'
+
+# Load the class under test
+require_relative '../../../lib/sequitur/formatter/base_text'
+
+module Sequitur # Re-open the module to get rid of qualified names
+module Formatter
+
+describe BaseText do
+  # Factory method. Build a production with the given sequence
+  # of symbols as its rhs.
+  def build_production(*symbols)
+    prod = Production.new
+    symbols.each { |symb| prod.append_symbol(symb) }
+    return prod
+  end
+
+  let(:p_a) { build_production(:a) }
+  let(:p_b) { build_production(:b) }
+  let(:p_c) { build_production(:c) }
+  let(:p_bc) { build_production(p_b, p_c) }
+  
+  let(:empty_grammar) { DynamicGrammar.new }
+  let(:sample_grammar) do
+    grm = DynamicGrammar.new
+    grm.add_production(p_a)
+    grm.add_production(p_b)
+    grm.add_production(p_c)
+    grm.add_production(p_bc)
+    grm
+  end
+  
+  let(:destination) { StringIO.new('', 'w') }
+
+  context 'Standard creation & initialization:' do
+
+    it 'should be initialized with an IO argument' do
+      expect { BaseText.new(StringIO.new('', 'w')) }.not_to raise_error
+    end
+    
+    it "should know its output destination" do
+      instance = BaseText.new(destination)
+      expect(instance.output).to eq(destination)
+    end
+  end # context
+  
+
+ 
+  context 'Formatting events:' do
+    it 'should support events of an empty grammar' do
+      instance = BaseText.new(destination)
+      a_visitor = empty_grammar.visitor
+      instance.render(a_visitor)
+      expectations =<<-SNIPPET
+start :.
+SNIPPET
+      expect(destination.string).to eq(expectations)
+    end
+    
+    it 'should support events of a non-empty grammar' do
+      instance = BaseText.new(destination)
+      a_visitor = sample_grammar.visitor
+      instance.render(a_visitor)
+      expectations =<<-SNIPPET
+start :.
+P_1 : a.
+P_2 : b.
+P_3 : c.
+P_4 : P_2 P_3.
+SNIPPET
+      expect(destination.string).to eq(expectations)
+    end
+  end # context
+end # describe
+
+end # module
+end # module
+
+# End of file

data/spec/sequitur/formatter/debug_spec.rb

@@ -0,0 +1,114 @@
+require_relative '../../spec_helper'
+require 'stringio'
+
+require_relative '../../../lib/sequitur/dynamic_grammar'
+
+# Load the class under test
+require_relative '../../../lib/sequitur/formatter/debug'
+
+module Sequitur # Re-open the module to get rid of qualified names
+module Formatter
+
+describe Debug do
+  # Factory method. Build a production with the given sequence
+  # of symbols as its rhs.
+  def build_production(*symbols)
+    prod = Production.new
+    symbols.each { |symb| prod.append_symbol(symb) }
+    return prod
+  end
+
+  let(:p_a) { build_production(:a) }
+  let(:p_b) { build_production(:b) }
+  let(:p_c) { build_production(:c) }
+  let(:p_bc) { build_production(p_b, p_c) }
+  
+  let(:empty_grammar) { DynamicGrammar.new }
+  let(:sample_grammar) do
+    grm = DynamicGrammar.new
+    grm.add_production(p_a)
+    grm.add_production(p_b)
+    grm.add_production(p_c)
+    grm.add_production(p_bc)
+    grm
+  end
+  
+  let(:destination) { StringIO.new('', 'w') }
+
+  context 'Standard creation & initialization:' do
+
+    it 'should be initialized with an IO argument' do
+      expect { Debug.new(StringIO.new('', 'w')) }.not_to raise_error
+    end
+    
+    it "should know its output destination" do
+      instance = Debug.new(destination)
+      expect(instance.output).to eq(destination)
+    end
+  end # context
+  
+
+ 
+  context 'Formatting events:' do
+    it 'should support events of an empty grammar' do
+      instance = Debug.new(destination)
+      a_visitor = empty_grammar.visitor
+      instance.render(a_visitor)
+      expectations =<<-SNIPPET
+before_grammar
+  before_production
+    before_rhs
+    after_rhs
+  after_production
+after_grammar
+SNIPPET
+      expect(destination.string).to eq(expectations)
+    end
+    
+    it 'should support events of a non-empty grammar' do
+      instance = Debug.new(destination)
+      a_visitor = sample_grammar.visitor
+      instance.render(a_visitor)
+      expectations =<<-SNIPPET
+before_grammar
+  before_production
+    before_rhs
+    after_rhs
+  after_production
+  before_production
+    before_rhs
+      before_terminal
+      after_terminal
+    after_rhs
+  after_production
+  before_production
+    before_rhs
+      before_terminal
+      after_terminal
+    after_rhs
+  after_production
+  before_production
+    before_rhs
+      before_terminal
+      after_terminal
+    after_rhs
+  after_production
+  before_production
+    before_rhs
+      before_non_terminal
+      after_non_terminal
+      before_non_terminal
+      after_non_terminal
+    after_rhs
+  after_production
+after_grammar
+SNIPPET
+      expect(destination.string).to eq(expectations)
+    end
+  end # context
+end # describe
+
+end # module
+end # module
+
+# End of file

data/spec/sequitur/grammar_visitor_spec.rb

@@ -0,0 +1,98 @@
+require_relative '../spec_helper'
+
+# Load the class under test
+require_relative '../../lib/sequitur/grammar_visitor'
+
+module Sequitur # Re-open the module to get rid of qualified names
+
+describe GrammarVisitor do
+  # Use a double(mock) as a grammar
+  let(:fake) { double('fake-grammar') }
+
+  context 'Standard creation & initialization:' do
+  
+    # Default instantiation rule
+    subject { GrammarVisitor.new(fake) }
+
+    it 'should be initialized with a grammar argument' do
+      expect { GrammarVisitor.new(fake) }.not_to raise_error
+    end
+
+    it 'should know the grammar to visit' do
+      expect(subject.grammar).to eq(fake)
+    end
+
+    it "shouldn't have subscribers at start" do
+      expect(subject.subscribers).to be_empty
+    end
+  end # context
+
+
+  context 'Subscribing:' do
+  
+    # Default instantiation rule
+    subject { GrammarVisitor.new(fake) }
+    
+    let(:listener1) { double('fake-formatter1') }
+    let(:listener2) { double('fake-formatter2') }
+  
+    it 'should allow subscriptions' do
+      subject.subscribe(listener1)
+      expect(subject.subscribers.size).to eq(1)
+      expect(subject.subscribers).to eq([listener1])
+      
+      subject.subscribe(listener2)
+      expect(subject.subscribers.size).to eq(2)
+      expect(subject.subscribers).to eq([listener1, listener2])
+    end
+    
+    it 'should allow un-subcriptions' do
+      subject.subscribe(listener1)
+      subject.subscribe(listener2)
+      subject.unsubscribe(listener2)
+      expect(subject.subscribers.size).to eq(1)
+      expect(subject.subscribers).to eq([listener1])
+      subject.unsubscribe(listener1)
+      expect(subject.subscribers).to be_empty
+    end
+  
+  end # context
+  
+  context 'Notifying visit events:' do
+  
+    # Default instantiation rule
+    subject do 
+      instance = GrammarVisitor.new(fake) 
+      instance.subscribe(listener1)
+      instance
+    end
+    
+    # Use doubles/mocks to simulate formatters
+    let(:listener1) { double('fake-formatter1') }
+    let(:listener2) { double('fake-formatter2') }
+    let(:mock_production) { double('fake-production') }
+    
+    it 'should react to the start_visit_grammar message' do
+      # Notify subscribers when start the visit of the grammar
+      expect(listener1).to receive(:before_grammar).with(fake)
+      
+      subject.start_visit_grammar(fake)
+    end
+    
+    it 'should react to the start_visit_production message' do
+      expect(mock_production).to receive(:rhs).and_return([1, 2, 3])
+      
+      # Notify subscribers when start the visit of the production
+      expect(listener1).to receive(:before_production).with(mock_production)
+      expect(listener1).to receive(:before_rhs).with([1, 2, 3])
+      
+      subject.start_visit_production(mock_production)
+    end
+
+  end # context  
+
+end # describe
+
+end # module
+
+# End of file

data/spec/sequitur/production_ref_spec.rb

@@ -92,7 +92,17 @@ describe ProductionRef do
       subject.unbind
       expect { subject.hash }.to raise_error(StandardError)
     end
-  end
+    
+    it 'should accept a visitor' do
+      # Use a mock visitor
+      fake = double('fake_visitor')
+      
+      # Visitor should receive a visit message
+      expect(fake).to receive(:visit_prod_ref).once
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+    
+  end # context
 
 end # describe
 

data/spec/sequitur/production_spec.rb

@@ -322,6 +322,45 @@ describe Production do
     end
 
   end # context
+  
+  context 'Visiting:' do
+    it 'should accept a visitor when its rhs is empty' do
+      # Use a mock visitor
+      fake = double('fake_visitor')
+      
+      # Empty production: visitor will receive a start and end visit messages
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+    
+    it 'should accept a visitor when rhs consists of terminals only' do
+      # Use a mock visitor
+      fake = double('fake_visitor')      
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:visit_terminal).with('b').ordered
+      expect(fake).to receive(:visit_terminal).with('c').ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { p_bc.accept(fake) }.not_to raise_error
+    end
+    
+    it 'should accept a visitor when rhs consists of non-terminals' do
+      # Add two production references (=non-terminals) to RHS of subject
+      subject.append_symbol(p_a)
+      subject.append_symbol(p_bc)
+      
+      fake = double('fake_visitor')      
+      expect(fake).to receive(:start_visit_production).once.ordered
+      expect(fake).to receive(:visit_prod_ref).with(p_a).ordered
+      expect(fake).to receive(:visit_prod_ref).with(p_bc).ordered
+      expect(fake).to receive(:end_visit_production).once.ordered
+
+      expect { subject.accept(fake) }.not_to raise_error
+    end
+  
+  end # context
 
 end # describe
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequitur
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.1.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-10 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,11 +89,17 @@ files:
 - lib/sequitur/constants.rb
 - lib/sequitur/digram.rb
 - lib/sequitur/dynamic_grammar.rb
+- lib/sequitur/formatter/base_text.rb
+- lib/sequitur/formatter/debug.rb
+- lib/sequitur/grammar_visitor.rb
 - lib/sequitur/production.rb
 - lib/sequitur/production_ref.rb
 - lib/sequitur/sequitur_grammar.rb
 - spec/sequitur/digram_spec.rb
 - spec/sequitur/dynamic_grammar_spec.rb
+- spec/sequitur/formatter/base_text_spec.rb
+- spec/sequitur/formatter/debug_spec.rb
+- spec/sequitur/grammar_visitor_spec.rb
 - spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb
@@ -132,6 +138,9 @@ summary: Ruby implementation of the Sequitur algorithm
 test_files:
 - spec/sequitur/digram_spec.rb
 - spec/sequitur/dynamic_grammar_spec.rb
+- spec/sequitur/formatter/base_text_spec.rb
+- spec/sequitur/formatter/debug_spec.rb
+- spec/sequitur/grammar_visitor_spec.rb
 - spec/sequitur/production_ref_spec.rb
 - spec/sequitur/production_spec.rb
 - spec/sequitur/sequitur_grammar_spec.rb