sequitur 0.1.23 → 0.1.24

data/spec/sequitur/formatter/base_text_spec.rb

@@ -9,86 +9,84 @@ require_relative '../../../lib/sequitur/dynamic_grammar'
 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
+  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) }
+        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(: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(: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') }
+      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
+      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
+        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
 
-  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
+        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

@@ -9,105 +9,103 @@ require_relative '../../../lib/sequitur/dynamic_grammar'
 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
+  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) }
+        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(: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(: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') }
+      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
+      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
+        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
 
-
-  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
+        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

@@ -6,77 +6,76 @@ require_relative '../spec_helper'
 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
+  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