sequitur 0.1.13 → 0.1.14

data/spec/sequitur/formatter/base_text_spec.rb

@@ -1,95 +1,92 @@
-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 visit events with an explicit visitor' do
-      instance = BaseText.new(destination)
-      a_visitor = sample_grammar.visitor  # Use visitor explicitly
-      instance.render(a_visitor)
-      expectations = <<-SNIPPET
-start :.
-P1 : a.
-P2 : b.
-P3 : c.
-P4 : P2 P3.
-SNIPPET
-      expect(destination.string).to eq(expectations)
-    end
-
-    it 'should support visit events without an explicit visitor' do
-      instance = BaseText.new(destination)
-      instance.render(sample_grammar)
-      expectations = <<-SNIPPET
-start :.
-P1 : a.
-P2 : b.
-P3 : c.
-P4 : P2 P3.
-SNIPPET
-      expect(destination.string).to eq(expectations)
-    end
-  end # context
-end # describe
-
-end # module
-end # module
-
-# End of file
+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 visit events with an explicit visitor' do
+      instance = BaseText.new(destination)
+      a_visitor = sample_grammar.visitor  # Use visitor explicitly
+      instance.render(a_visitor)
+      expectations = <<-SNIPPET
+start :.
+P1 : a.
+P2 : b.
+P3 : c.
+P4 : P2 P3.
+SNIPPET
+      expect(destination.string).to eq(expectations)
+    end
+
+    it 'should support visit events without an explicit visitor' do
+      instance = BaseText.new(destination)
+      instance.render(sample_grammar)
+      expectations = <<-SNIPPET
+start :.
+P1 : a.
+P2 : b.
+P3 : c.
+P4 : P2 P3.
+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

@@ -1,114 +1,111 @@
-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
+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

@@ -1,88 +1,80 @@
-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
-
-  end # context  
-
-end # describe
-
-end # module
-
-# End of file
+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
+  end # context
+end # describe
+end # module
+
+# End of file