cukedep 0.1.11 → 0.2.00

data/spec/cukedep/file-parsing.rb

@@ -1,41 +1,39 @@
-# File: file-parsing.rb
-
-require_relative '../../lib/cukedep/gherkin-facade'
-
-module Cukedep # This module is used as a namespace
-  # Mixin module used in tests.
-  # Purpose: to parse a sample of feature files.
-  module FileParsing
-    # The list of sample feature file names.
-    SampleFileNames = 
-      [ 'a_few_tests.feature', 
-        'some_tests.feature',
-        'still_other_tests.feature',
-        'yet_other_tests.feature',
-        'more_tests.feature',
-        'standalone.feature'
-      ]
-
-    # Helper method. It parses sample feature files and
-    # notifies the provided listener of its progress.
-    def parse_for(aListener)
-      orig_dir = Dir.getwd
-      begin
-        # Determine the folder where the sample files reside
-        my_dir = File.dirname(__FILE__)
-        sample_dir = File.expand_path(my_dir + '/sample_features')
-        Dir.chdir(sample_dir)
-        
-        # Parse the specified feature files in work directory
-        is_verbose = false
-        gherkin_facade = GherkinFacade.new(is_verbose, 'UTF-8')
-        gherkin_facade.parse_features(aListener, SampleFileNames)
-      ensure
-        Dir.chdir(orig_dir)
-      end
-      
-    end
-  
-  end # module
-end # module
-# End of file
+# File: file-parsing.rb
+
+require_relative '../../lib/cukedep/gherkin-facade'
+
+module Cukedep # This module is used as a namespace
+  # Mixin module used in tests.
+  # Purpose: to parse a sample of feature files.
+  module FileParsing
+    # The list of sample feature file names.
+    SampleFileNames = [
+      'a_few_tests.feature',
+      'some_tests.feature',
+      'still_other_tests.feature',
+      'yet_other_tests.feature',
+      'more_tests.feature',
+      'standalone.feature'
+    ].freeze
+
+    # Helper method. It parses sample feature files and
+    # notifies the provided listener of its progress.
+    def parse_for(aListener)
+      orig_dir = Dir.getwd
+      begin
+        # Determine the folder where the sample files reside
+        my_dir = File.dirname(__FILE__)
+        sample_dir = File.expand_path(my_dir + '/sample_features')
+        Dir.chdir(sample_dir)
+
+        # Parse the specified feature files in work directory
+        is_verbose = false
+        gherkin_facade = GherkinFacade.new(is_verbose, 'UTF-8')
+        gherkin_facade.parse_features(aListener, SampleFileNames)
+      ensure
+        Dir.chdir(orig_dir)
+      end
+    end
+  end # module
+end # module
+# End of file

data/spec/cukedep/gherkin-facade_spec.rb

@@ -1,49 +1,48 @@
-# File: file-actions_spec.rb
-
-require_relative '../spec_helper'
-
-# Load the class under testing
-require_relative '../../lib/cukedep/gherkin-facade'
-require_relative '../../lib/cukedep/gherkin-listener'
-
-module Cukedep # Open module to get rid of long qualified names
-describe GherkinFacade do
-  subject { GherkinFacade.new(false, 'UTF-8') }
-
-  context 'Creation & initialization:' do
-    it 'should be created with two arguments' do
-      expect { GherkinFacade.new(true, 'UTF-8') }.not_to raise_error
-    end
-    
-    it 'should whether it is verbose or not' do
-      # Case 1: instance is verbose
-      expect(subject.verbose).to be_falsey
-      
-      # Case 2: instance is silent
-      instance =  GherkinFacade.new(true, 'UTF-8')
-      expect(instance.verbose).to be_truthy 
-    end
-    
-    it 'should know the feature file external encoding' do
-      expect(subject.external_encoding).to eq('UTF-8')
-    end
-  end # context
-
-
-  
-  context 'Provided services:' do
-    let(:listener) { GherkinListener.new }
-    it 'should parse ASCII feature files' do
-      instance = GherkinFacade.new(false, 'US-ASCII')
-      patterns = [ 'sample_features/a_few_tests.feature' ]
-      expect { instance.parse_features(listener, patterns) }.not_to raise_error
-    end
-    
-    it 'should parse feature files with other external encoding' do
-      patterns = [ 'sample_features/standalone.feature' ]
-      expect { subject.parse_features(listener, patterns) }.not_to raise_error
-    end
-  end # context
-end # describe
-end # module
-# End of file
+# File: file-actions_spec.rb
+
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/gherkin-facade'
+require_relative '../../lib/cukedep/gherkin-listener'
+
+module Cukedep # Open module to get rid of long qualified names
+describe GherkinFacade do
+  subject { GherkinFacade.new(false, 'UTF-8') }
+
+  context 'Creation & initialization:' do
+    it 'should be created with two arguments' do
+      expect { GherkinFacade.new(true, 'UTF-8') }.not_to raise_error
+    end
+
+    it 'should whether it is verbose or not' do
+      # Case 1: instance is verbose
+      expect(subject.verbose).to be_falsey
+
+      # Case 2: instance is silent
+      instance = GherkinFacade.new(true, 'UTF-8')
+      expect(instance.verbose).to be_truthy
+    end
+
+    it 'should know the feature file external encoding' do
+      expect(subject.external_encoding).to eq('UTF-8')
+    end
+  end # context
+
+
+  context 'Provided services:' do
+    let(:listener) { GherkinListener.new }
+    it 'should parse ASCII feature files' do
+      instance = GherkinFacade.new(false, 'US-ASCII')
+      patterns = ['sample_features/a_few_tests.feature']
+      expect { instance.parse_features(listener, patterns) }.not_to raise_error
+    end
+
+    # it 'should parse feature files with other external encoding' do
+      # patterns = [ 'sample_features/standalone.feature' ]
+      # expect { subject.parse_features(listener, patterns) }.not_to raise_error
+    # end
+  end # context
+end # describe
+end # module
+# End of file

data/spec/cukedep/gherkin-listener_spec.rb

@@ -1,57 +1,55 @@
-# File: gherkin-listener_spec.rb
-
-require_relative '../spec_helper'
-
-
-require_relative 'file-parsing'
-
-# Load the class under testing
-require_relative '../../lib/cukedep/gherkin-listener'
-
-module Cukedep # Open module to get rid of long qualified names
-describe GherkinListener do
-  include FileParsing # Use mixin module to parse of sample feature files
-  
-  subject { GherkinListener.new }
-
-  context 'Creation and initialization:' do
-    it 'should be created without argument' do
-      expect { GherkinListener.new }.not_to raise_error
-    end
-    
-    it 'should have no feature file at start' do
-      expect(subject.feature_files.size).to eq(0)
-    end
-  end # context
-  
-  context 'Provided services:' do
-    it 'should build a FeatureFileRep per parsed file' do
-      parse_for(subject)
-      expect(subject.feature_files.size)
-        .to eq(FileParsing::SampleFileNames.size)
-    end
-    
-    it 'should know the tags of each feature' do
-      parse_for(subject)
-      
-      expectations = [
-        %w(a_few feature:qux),
-        %w(some feature:foo depends_on:bar depends_on:qux),
-        %w(still_other feature:baz),
-        %w(yet_other feature:bar depends_on:baz depends_on:qux depends_on:quux),
-        %w(feature:quux more),
-        []
-      ]
-
-      # Sort the expectations to ease further comparison
-      expectations.map!(&:sort)
-      
-      subject.feature_files.each_with_index do |file, i|
-        expect(file.feature.tags.sort).to eq(expectations[i])
-      end
-    end
-  end # context
-end # describe
-end # module
-
-# End of file
+# File: gherkin-listener_spec.rb
+
+require_relative '../spec_helper'
+require_relative 'file-parsing'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/gherkin-listener'
+
+module Cukedep # Open module to get rid of long qualified names
+describe GherkinListener do
+  include FileParsing # Use mixin module to parse of sample feature files
+
+  subject { GherkinListener.new }
+
+  context 'Creation and initialization:' do
+    it 'should be created without argument' do
+      expect { GherkinListener.new }.not_to raise_error
+    end
+
+    it 'should have no feature file at start' do
+      expect(subject.feature_files.size).to eq(0)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'should build a FeatureFileRep per parsed file' do
+      parse_for(subject)
+      expect(subject.feature_files.size)
+        .to eq(FileParsing::SampleFileNames.size)
+    end
+
+    it 'should know the tags of each feature' do
+      parse_for(subject)
+
+      expectations = [
+        %w(a_few feature:qux),
+        %w(some feature:foo depends_on:bar depends_on:qux),
+        %w(still_other feature:baz),
+        %w(yet_other feature:bar depends_on:baz depends_on:qux depends_on:quux),
+        %w(feature:quux more),
+        []
+      ]
+
+      # Sort the expectations to ease further comparison
+      expectations.map!(&:sort)
+
+      subject.feature_files.each_with_index do |file, i|
+        expect(file.feature.tags.sort).to eq(expectations[i])
+      end
+    end
+  end # context
+end # describe
+end # module
+
+# End of file

data/spec/cukedep/hook-dsl_spec.rb

@@ -1,182 +1,182 @@
-# File: file-action_spec.rb
-
-require 'stringio'
-require_relative '../spec_helper'
-
-# Load the class under testing
-require_relative '../../lib/cukedep/hook-dsl'
-
-module Cukedep # Open module to get rid of long qualified names
-# Let's specify the behaviour of the mix-in module
-describe HookDSL do
-  subject do
-    obj = Object.new
-    obj.extend(HookDSL)
-    obj
-  end
-
-  context 'Hook definitions:' do
-    let(:code_block) do
-      -> { }
-    end
-
-    it 'should accept the before all hook' do
-      # Case 1: before all with block code
-      expect { subject.before_cuke(:all, &code_block) }.not_to raise_error
-
-      # Case 2: before all without block code
-      expect { subject.before_cuke(:all) }.not_to raise_error
-    end
-
-    it 'should accept the before each hook' do
-      # Case 1: before each with block code
-      expect { subject.before_cuke(:each, &code_block) }.not_to raise_error
-
-      # Case 2: before each without block code
-      expect { subject.before_cuke(:each) }.not_to raise_error
-    end
-
-
-    it 'should accept the after all hook' do
-      # Case 1: after all with block code
-      expect { subject.after_cuke(:all, &code_block) }.not_to raise_error
-
-      # Case 2: before all without block code
-      expect { subject.after_cuke(:all) }.not_to raise_error
-    end
-
-    it 'should accept the after each hook' do
-      # Case 1: after each with block code
-      expect { subject.after_cuke(:each, &code_block) }.not_to raise_error
-
-      # Case 2: after each without block code
-      expect { subject.after_cuke(:each) }.not_to raise_error
-    end
-
-    it 'should reject invalid scope argument' do
-      # Case 1: before invalid with block code
-      msg = "Unknown scope 'invalid' for before_cuke hook."
-      error = StandardError
-      expect { subject.before_cuke(:invalid, &code_block) }
-        .to raise_error(error, msg)
-
-      # Case 2: after invalid with block code
-      msg = "Unknown scope 'invalid' for after_cuke hook."
-      expect { subject.after_cuke(:invalid, &code_block) }
-        .to raise_error(error, msg)
-    end
-
-
-    it 'should register the block code with the event' do
-      # No block code registered yet.
-      expect(subject.instance_variables).not_to include(:@before_hooks)
-
-      # Case 1: No before all handler provided
-      subject.before_cuke(:all)
-      expect(subject.instance_variables).not_to include(:@before_hooks)
-
-      # Case 1: Add before all handler
-      subject.before_cuke(:all, &code_block)
-
-      # Check that handler code is stored in instance variable
-      expect(subject.instance_variables).to include(:@before_hooks)
-      expect(subject.before_hooks.keys).to eq([:all])
-      expect(subject.before_hooks[:all]).to eq(code_block)
-
-      # Case 2: No before each handler provided
-      subject.before_cuke(:each)
-      expect(subject.before_hooks.keys).to eq([:all])
-
-      # Case 3: Add before each handler
-      subject.before_cuke(:each, &code_block)
-
-      # Check that handler code is stored in instance variable
-      expect(subject.before_hooks.keys).to eq([:all, :each])
-      expect(subject.before_hooks[:each]).to eq(code_block)
-
-
-      # Case 4: No after all handler provided
-      subject.after_cuke(:all)
-      expect(subject.instance_variables).not_to include(:@after_hooks)
-
-      # Case 5: Add after all handler
-      subject.after_cuke(:all, &code_block)
-
-      # Check that handler code is stored in instance variable
-      expect(subject.instance_variables).to include(:@after_hooks)
-      expect(subject.after_hooks.keys).to eq([:all])
-      expect(subject.after_hooks[:all]).to eq(code_block)
-
-      # Case 6: No after each handler provided
-      subject.after_cuke(:each)
-      expect(subject.after_hooks.keys).to eq([:all])
-
-      # Case 7: Add after each handler
-      subject.after_cuke(:each, &code_block)
-
-      # Check that handler code is stored in instance variable
-      expect(subject.after_hooks.keys).to eq([:all, :each])
-      expect(subject.after_hooks[:each]).to eq(code_block)
-    end
-  end # context
-=begin
-  context 'Executing handler code:' do
-    let(:ostream) { StringIO.new('', 'w') }
-    
-    it 'should ignore missing handler' do
-      expect { subject.execute_hook(:before, :all) }.not_to raise_error
-    end
-
-    it 'should execute the before all handler' do
-      text = 'before all'
-      # Let's create the hook
-      subject.before_cuke(:all) { ostream.print text }
-
-      # Let's execute it...
-      subject.execute_hook(:before, :all)
-
-      expect(ostream.string).to eq(text)
-    end
-
-
-    it 'should execute the before all handler' do
-      text = 'before each'
-      # Let's create the hook
-      subject.before_cuke(:each) { ostream.print text }
-
-      # Let's execute it...
-      subject.execute_hook(:before, :each)
-
-      expect(ostream.string).to eq(text)
-    end
-
-
-    it 'should execute the after all handler' do
-      text = 'after all'
-      # Let's create the hook
-      subject.after_cuke(:all) { ostream.print text }
-
-      # Let's execute it...
-      subject.execute_hook(:after, :all)
-
-      expect(ostream.string).to eq(text)
-    end
-
-
-    it 'should execute the after each handler' do
-      text = 'after each'
-      # Let's create the hook
-      subject.after_cuke(:each) { ostream.print text }
-
-      # Let's execute it...
-      subject.execute_hook(:after, :each)
-
-      expect(ostream.string).to eq(text)
-    end
-
-  end # context
-=end
-end # describe
-end # module
-
-# End of file
+# File: file-action_spec.rb
+
+require 'stringio'
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/hook-dsl'
+
+module Cukedep # Open module to get rid of long qualified names
+# Let's specify the behaviour of the mix-in module
+describe HookDSL do
+  subject do
+    obj = Object.new
+    obj.extend(HookDSL)
+    obj
+  end
+
+  context 'Hook definitions:' do
+    let(:code_block) do
+      -> {}
+    end
+
+    it 'should accept the before all hook' do
+      # Case 1: before all with block code
+      expect { subject.before_cuke(:all, &code_block) }.not_to raise_error
+
+      # Case 2: before all without block code
+      expect { subject.before_cuke(:all) }.not_to raise_error
+    end
+
+    it 'should accept the before each hook' do
+      # Case 1: before each with block code
+      expect { subject.before_cuke(:each, &code_block) }.not_to raise_error
+
+      # Case 2: before each without block code
+      expect { subject.before_cuke(:each) }.not_to raise_error
+    end
+
+
+    it 'should accept the after all hook' do
+      # Case 1: after all with block code
+      expect { subject.after_cuke(:all, &code_block) }.not_to raise_error
+
+      # Case 2: before all without block code
+      expect { subject.after_cuke(:all) }.not_to raise_error
+    end
+
+    it 'should accept the after each hook' do
+      # Case 1: after each with block code
+      expect { subject.after_cuke(:each, &code_block) }.not_to raise_error
+
+      # Case 2: after each without block code
+      expect { subject.after_cuke(:each) }.not_to raise_error
+    end
+
+    it 'should reject invalid scope argument' do
+      # Case 1: before invalid with block code
+      msg = "Unknown scope 'invalid' for before_cuke hook."
+      error = StandardError
+      expect { subject.before_cuke(:invalid, &code_block) }
+        .to raise_error(error, msg)
+
+      # Case 2: after invalid with block code
+      msg = "Unknown scope 'invalid' for after_cuke hook."
+      expect { subject.after_cuke(:invalid, &code_block) }
+        .to raise_error(error, msg)
+    end
+
+
+    it 'should register the block code with the event' do
+      # No block code registered yet.
+      expect(subject.instance_variables).not_to include(:@before_hooks)
+
+      # Case 1: No before all handler provided
+      subject.before_cuke(:all)
+      expect(subject.instance_variables).not_to include(:@before_hooks)
+
+      # Case 1: Add before all handler
+      subject.before_cuke(:all, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.instance_variables).to include(:@before_hooks)
+      expect(subject.before_hooks.keys).to eq([:all])
+      expect(subject.before_hooks[:all]).to eq(code_block)
+
+      # Case 2: No before each handler provided
+      subject.before_cuke(:each)
+      expect(subject.before_hooks.keys).to eq([:all])
+
+      # Case 3: Add before each handler
+      subject.before_cuke(:each, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.before_hooks.keys).to eq(%i[all each])
+      expect(subject.before_hooks[:each]).to eq(code_block)
+
+
+      # Case 4: No after all handler provided
+      subject.after_cuke(:all)
+      expect(subject.instance_variables).not_to include(:@after_hooks)
+
+      # Case 5: Add after all handler
+      subject.after_cuke(:all, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.instance_variables).to include(:@after_hooks)
+      expect(subject.after_hooks.keys).to eq([:all])
+      expect(subject.after_hooks[:all]).to eq(code_block)
+
+      # Case 6: No after each handler provided
+      subject.after_cuke(:each)
+      expect(subject.after_hooks.keys).to eq([:all])
+
+      # Case 7: Add after each handler
+      subject.after_cuke(:each, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.after_hooks.keys).to eq(%i[all each])
+      expect(subject.after_hooks[:each]).to eq(code_block)
+    end
+  end # context
+=begin
+  context 'Executing handler code:' do
+    let(:ostream) { StringIO.new('', 'w') }
+
+    it 'should ignore missing handler' do
+      expect { subject.execute_hook(:before, :all) }.not_to raise_error
+    end
+
+    it 'should execute the before all handler' do
+      text = 'before all'
+      # Let's create the hook
+      subject.before_cuke(:all) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:before, :all)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the before all handler' do
+      text = 'before each'
+      # Let's create the hook
+      subject.before_cuke(:each) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:before, :each)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the after all handler' do
+      text = 'after all'
+      # Let's create the hook
+      subject.after_cuke(:all) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:after, :all)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the after each handler' do
+      text = 'after each'
+      # Let's create the hook
+      subject.after_cuke(:each) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:after, :each)
+
+      expect(ostream.string).to eq(text)
+    end
+
+  end # context
+=end
+end # describe
+end # module
+
+# End of file