cuke_modeler 0.3.0 → 0.4.0

data/spec/unit/taggable_unit_spec.rb

@@ -4,75 +4,82 @@ SimpleCov.command_name('Taggable') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'Taggable, Unit' do
 
-  nodule = CukeModeler::Taggable
+  let(:nodule) { CukeModeler::Taggable }
+  let(:element) { o = Object.new.extend(nodule)
 
-  before(:each) do
-    @element = Object.new.extend(nodule)
+                  def o.parent_element
+                    @parent_element
+                  end
 
-    def @element.parent_element
-      @parent_element
-    end
+                  def o.parent_element=(parent)
+                    @parent_element = parent
+                  end
+
+                  o
+                }
+
+
+  describe 'unique behavior' do
 
-    def @element.parent_element=(parent)
-      @parent_element = parent
+    it 'has tags' do
+      element.should respond_to(:tags)
+      element.should respond_to(:tag_elements)
     end
-  end
 
+    it 'can change its tags' do
+      expect(element).to respond_to(:tags=)
+      expect(element).to respond_to(:tag_elements=)
 
-  it 'has tags' do
-    @element.should respond_to(:tags)
-    @element.should respond_to(:tag_elements)
-  end
+      element.tags = :some_tags
+      element.tags.should == :some_tags
+      element.tags = :some_other_tags
+      element.tags.should == :some_other_tags
 
-  it 'can get and set its tags' do
-    @element.tags = :some_tags
-    @element.tags.should == :some_tags
-    @element.tags = :some_other_tags
-    @element.tags.should == :some_other_tags
+      element.tag_elements = :some_tag_elements
+      element.tag_elements.should == :some_tag_elements
+      element.tag_elements = :some_other_tag_elements
+      element.tag_elements.should == :some_other_tag_elements
+    end
 
-    @element.tag_elements = :some_tag_elements
-    @element.tag_elements.should == :some_tag_elements
-    @element.tag_elements = :some_other_tag_elements
-    @element.tag_elements.should == :some_other_tag_elements
-  end
+    it 'has applied tags' do
+      element.should respond_to(:applied_tags)
+      element.should respond_to(:applied_tag_elements)
+    end
 
-  it 'has applied tags' do
-    @element.should respond_to(:applied_tags)
-    @element.should respond_to(:applied_tag_elements)
-  end
+    it 'inherits its applied tags from its ancestors' do
+      all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+      all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+      parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
 
-  it 'inherits its applied tags from its ancestors' do
-    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
-    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
-    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+      element.parent_element = parent
 
-    @element.parent_element = parent
+      element.applied_tags.should == all_parent_tags
+      element.applied_tag_elements.should == all_parent_tag_elements
+    end
 
-    @element.applied_tags.should == all_parent_tags
-    @element.applied_tag_elements.should == all_parent_tag_elements
-  end
+    it 'knows all of its applicable tags' do
+      all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
+      all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
+      own_tags = ['@tag_1', '@tag_2']
+      own_tag_elements = [:tag_element_1, :tag_element_2]
 
-  it 'knows all of its applicable tags' do
-    all_parent_tag_elements = [:parent_tag_element_1, :parent_tag_element_2, :grandparent_tag_element_1]
-    all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
-    own_tags = ['@tag_1', '@tag_2']
-    own_tag_elements = [:tag_element_1, :tag_element_2]
+      parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
 
-    parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
+      element.parent_element = parent
+      element.tags = own_tags
+      element.tag_elements = own_tag_elements
 
-    @element.parent_element = parent
-    @element.tags = own_tags
-    @element.tag_elements = own_tag_elements
+      element.all_tags.should == all_parent_tags + own_tags
+      element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+    end
 
-    @element.all_tags.should == all_parent_tags + own_tags
-    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
-  end
+    it 'may have no applied tags' do
+      element.parent_element = :not_a_tagged_object
 
-  it 'may have no applied tags' do
-    @element.parent_element = :not_a_tagged_object
+      element.applied_tags.should == []
+      element.applied_tag_elements.should == []
+    end
 
-    @element.applied_tags.should == []
-    @element.applied_tag_elements.should == []
   end
 
 end

data/spec/unit/tagged_element_unit_specs.rb

@@ -4,35 +4,37 @@ shared_examples_for 'a tagged element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @element = clazz.new
-  end
+  let(:element) { clazz.new }
+
 
   it 'has tags' do
-    @element.should respond_to(:tags)
-    @element.should respond_to(:tag_elements)
+    element.should respond_to(:tags)
+    element.should respond_to(:tag_elements)
   end
 
   it 'can get and set its tags' do
-    @element.tags = :some_tags
-    @element.tags.should == :some_tags
-    @element.tags = :some_other_tags
-    @element.tags.should == :some_other_tags
-
-    @element.tag_elements = :some_tag_elements
-    @element.tag_elements.should == :some_tag_elements
-    @element.tag_elements = :some_other_tag_elements
-    @element.tag_elements.should == :some_other_tag_elements
+    expect(element).to respond_to(:tags=)
+    expect(element).to respond_to(:tag_elements=)
+
+    element.tags = :some_tags
+    element.tags.should == :some_tags
+    element.tags = :some_other_tags
+    element.tags.should == :some_other_tags
+
+    element.tag_elements = :some_tag_elements
+    element.tag_elements.should == :some_tag_elements
+    element.tag_elements = :some_other_tag_elements
+    element.tag_elements.should == :some_other_tag_elements
   end
 
   it 'starts with no tags' do
-    @element.tags.should == []
-    @element.tag_elements.should == []
+    element.tags.should == []
+    element.tag_elements.should == []
   end
 
   it 'has applied tags' do
-    @element.should respond_to(:applied_tags)
-    @element.should respond_to(:applied_tag_elements)
+    element.should respond_to(:applied_tags)
+    element.should respond_to(:applied_tag_elements)
   end
 
   it 'inherits its applied tags from its ancestors' do
@@ -40,10 +42,10 @@ shared_examples_for 'a tagged element' do
     all_parent_tags = ['@parent_tag_1', '@parent_tag_2', '@grandparent_tag_1']
     parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
 
-    @element.parent_element = parent
+    element.parent_element = parent
 
-    @element.applied_tags.should == all_parent_tags
-    @element.applied_tag_elements.should == all_parent_tag_elements
+    element.applied_tags.should == all_parent_tags
+    element.applied_tag_elements.should == all_parent_tag_elements
   end
 
   it 'knows all of its applicable tags' do
@@ -54,12 +56,12 @@ shared_examples_for 'a tagged element' do
 
     parent = double(:all_tags => all_parent_tags, :all_tag_elements => all_parent_tag_elements)
 
-    @element.parent_element = parent
-    @element.tags = own_tags
-    @element.tag_elements = own_tag_elements
+    element.parent_element = parent
+    element.tags = own_tags
+    element.tag_elements = own_tag_elements
 
-    @element.all_tags.should == all_parent_tags + own_tags
-    @element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
+    element.all_tags.should == all_parent_tags + own_tags
+    element.all_tag_elements.should == all_parent_tag_elements + own_tag_elements
   end
 
 end

data/spec/unit/test_element_unit_spec.rb

@@ -5,44 +5,50 @@ SimpleCov.command_name('TestElement') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'TestElement, Unit' do
 
   let(:clazz) { CukeModeler::TestElement }
+  let(:element) { clazz.new }
 
-  it_should_behave_like 'a test element'
-  it_should_behave_like 'a feature element'
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a prepopulated element'
-  it_should_behave_like 'a bare bones element'
 
+  describe 'common behavior' do
+
+    it_should_behave_like 'a test element'
+    it_should_behave_like 'a feature element'
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a bare bones element'
 
-  before(:each) do
-    @element = clazz.new
   end
 
-  it 'contains only steps - #contains' do
-    steps = [:step_1, :step_2, :step_3]
-    @element.steps = steps
 
-    @element.contains.should =~ steps
-  end
+  describe 'unique behavior' do
 
-  it 'can determine its equality with another TestElement - #==' do
-    element_1 = clazz.new
-    element_2 = clazz.new
-    element_3 = clazz.new
+    it 'contains only steps' do
+      steps = [:step_1, :step_2, :step_3]
+      element.steps = steps
 
-    element_1.steps = :some_steps
-    element_2.steps = :some_steps
-    element_3.steps = :some_other_steps
+      element.contains.should =~ steps
+    end
 
-    (element_1 == element_2).should be_true
-    (element_1 == element_3).should be_false
-  end
+    it 'can determine its equality with another TestElement' do
+      element_1 = clazz.new
+      element_2 = clazz.new
+      element_3 = clazz.new
 
-  it 'can gracefully be compared to other types of objects' do
-    # Some common types of object
-    [1, 'foo', :bar, [], {}].each do |thing|
-      expect { @element == thing }.to_not raise_error
-      expect(@element == thing).to be false
+      element_1.steps = :some_steps
+      element_2.steps = :some_steps
+      element_3.steps = :some_other_steps
+
+      (element_1 == element_2).should be_true
+      (element_1 == element_3).should be_false
+    end
+
+    it 'can gracefully be compared to other types of objects' do
+      # Some common types of object
+      [1, 'foo', :bar, [], {}].each do |thing|
+        expect { element == thing }.to_not raise_error
+        expect(element == thing).to be false
+      end
     end
+
   end
 
 end

data/spec/unit/test_element_unit_specs.rb

@@ -4,30 +4,31 @@ shared_examples_for 'a test element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @element = clazz.new
-  end
+  let(:element) { clazz.new }
+
 
-  it 'has steps - #steps' do
-    @element.should respond_to(:steps)
+  it 'has steps' do
+    element.should respond_to(:steps)
   end
 
-  it 'can get and set its steps - #steps, #steps=' do
-    @element.steps = :some_steps
-    @element.steps.should == :some_steps
-    @element.steps = :some_other_steps
-    @element.steps.should == :some_other_steps
+  it 'can change its steps' do
+    expect(element).to respond_to(:steps=)
+
+    element.steps = :some_steps
+    element.steps.should == :some_steps
+    element.steps = :some_other_steps
+    element.steps.should == :some_other_steps
   end
 
   it 'starts with no steps' do
-    @element.steps.should == []
+    element.steps.should == []
   end
 
-  it 'contains steps - #contains' do
+  it 'contains steps' do
     steps = [:step_1, :step_2, :step_3]
-    @element.steps = steps
+    element.steps = steps
 
-    steps.each { |step| @element.contains.should include(step) }
+    steps.each { |step| element.contains.should include(step) }
   end
 
 end

data/spec/unit/world_unit_spec.rb

@@ -4,125 +4,135 @@ SimpleCov.command_name('World') unless RUBY_VERSION.to_s < '1.9.0'
 
 describe 'World, Unit' do
 
-  before(:each) do
-    @world = CukeModeler::World
-    @world.loaded_step_patterns.clear
-    @world.delimiter = nil
-  end
+  let(:nodule) { CukeModeler::World }
+  let(:world) { nodule }
 
-  it 'has left and right delimiters used for step argument parsing - #left_delimiter, #right_delimiter' do
-    @world.should respond_to(:left_delimiter)
-    @world.should respond_to(:right_delimiter)
-  end
 
-  it 'can get and set the delimiters used for step argument parsing' do
-    @world.left_delimiter = '"'
-    @world.right_delimiter = '"'
-    @world.left_delimiter.should == '"'
-    @world.right_delimiter.should == '"'
+  describe 'unique behavior' do
 
-    @world.left_delimiter = '!'
-    @world.right_delimiter = '!'
-    @world.left_delimiter.should == '!'
-    @world.right_delimiter.should == '!'
-  end
+    before(:each) do
+      world.loaded_step_patterns.clear
+      world.delimiter = nil
+    end
 
-  it 'can have different left and right delimiters' do
-    @world.left_delimiter = '"'
-    @world.right_delimiter = '*'
+    it 'has left and right delimiters used for step argument parsing' do
+      world.should respond_to(:left_delimiter)
+      world.should respond_to(:right_delimiter)
+    end
 
-    (@world.left_delimiter != @world.right_delimiter).should be_true
-  end
+    it 'can get and set the delimiters used for step argument parsing' do
+      expect(world).to respond_to(:left_delimiter=)
+      expect(world).to respond_to(:right_delimiter=)
 
-  it 'can set both of its delimiters at once - #delimiter=' do
-    @world.delimiter = '*'
+      world.left_delimiter = '"'
+      world.right_delimiter = '"'
+      world.left_delimiter.should == '"'
+      world.right_delimiter.should == '"'
 
-    @world.left_delimiter.should == '*'
-    @world.right_delimiter.should == '*'
-  end
+      world.left_delimiter = '!'
+      world.right_delimiter = '!'
+      world.left_delimiter.should == '!'
+      world.right_delimiter.should == '!'
+    end
 
-  it 'starts with no delimiters' do
-    @world.left_delimiter.should == nil
-    @world.right_delimiter.should == nil
-  end
+    it 'can have different left and right delimiters' do
+      world.left_delimiter = '"'
+      world.right_delimiter = '*'
+
+      (world.left_delimiter != world.right_delimiter).should be_true
+    end
 
-  context 'step patterns' do
+    it 'can set both of its delimiters at once' do
+      world.delimiter = '*'
 
-    it 'can load step patterns - #load_step_pattern' do
-      @world.should respond_to(:load_step_pattern)
+      world.left_delimiter.should == '*'
+      world.right_delimiter.should == '*'
     end
 
-    it 'starts with no patterns loaded' do
-      @world.loaded_step_patterns.should == []
+    it 'starts with no delimiters' do
+      world.left_delimiter.should == nil
+      world.right_delimiter.should == nil
     end
 
-    it 'keeps track of loaded step patterns - #loaded_step_patterns' do
-      patterns = [/a pattern/, /another pattern/]
+    describe 'step patterns' do
 
-      patterns.each do |pattern|
-        @world.load_step_pattern(pattern)
+      it 'can load step patterns' do
+        world.should respond_to(:load_step_pattern)
       end
 
-      @world.loaded_step_patterns.should =~ patterns
-    end
+      it 'starts with no patterns loaded' do
+        world.loaded_step_patterns.should == []
+      end
 
-    it 'can load step definition files - #load_step_file' do
-      file_path = "#{@default_file_directory}/step_file.rb"
-      patterns = [/a pattern/, /another pattern/]
+      it 'keeps track of loaded step patterns' do
+        patterns = [/a pattern/, /another pattern/]
 
-      File.open(file_path, 'w') { |file|
         patterns.each do |pattern|
-          file.puts "Given #{pattern.inspect} do end"
+          world.load_step_pattern(pattern)
         end
-      }
 
-      @world.load_step_file(file_path)
+        world.loaded_step_patterns.should =~ patterns
+      end
 
-      @world.loaded_step_patterns.should =~ patterns
-    end
+      it 'can load step definition files' do
+        file_path = "#{@default_file_directory}/step_file.rb"
+        patterns = [/a pattern/, /another pattern/]
 
-    it 'can handle different step keywords - #load_step_file' do
-      file_path = "#{@default_file_directory}/step_file.rb"
-      patterns = [/given pattern/, /when pattern/, /then pattern/, /and pattern/, /but pattern/]
+        File.open(file_path, 'w') { |file|
+          patterns.each do |pattern|
+            file.puts "Given #{pattern.inspect} do end"
+          end
+        }
 
-      File.open(file_path, 'w') { |file|
-        file.puts "Given #{patterns[0].inspect} do end"
-        file.puts "When #{patterns[1].inspect} do end"
-        file.puts "Then #{patterns[2].inspect} do end"
-        file.puts "And #{patterns[3].inspect} do end"
-        file.puts "But #{patterns[4].inspect} do end"
-      }
+        world.load_step_file(file_path)
 
-      @world.load_step_file(file_path)
+        world.loaded_step_patterns.should =~ patterns
+      end
 
-      @world.loaded_step_patterns.should =~ patterns
-    end
+      it 'can handle different step keywords' do
+        file_path = "#{@default_file_directory}/step_file.rb"
+        patterns = [/given pattern/, /when pattern/, /then pattern/, /and pattern/, /but pattern/]
 
-    it 'can handle a variety of declaration structures - #load_step_file' do
-      file_path = "#{@default_file_directory}/step_file.rb"
-      patterns = [/parentheses pattern/, /no parentheses pattern/, /excess whitespace pattern/]
+        File.open(file_path, 'w') { |file|
+          file.puts "Given #{patterns[0].inspect} do end"
+          file.puts "When #{patterns[1].inspect} do end"
+          file.puts "Then #{patterns[2].inspect} do end"
+          file.puts "And #{patterns[3].inspect} do end"
+          file.puts "But #{patterns[4].inspect} do end"
+        }
 
-      File.open(file_path, 'w') { |file|
-        file.puts "Given(#{patterns[0].inspect}) do end"
-        file.puts "Given #{patterns[1].inspect} do end"
-        file.puts "Given   #{patterns[2].inspect}   do end"
-      }
+        world.load_step_file(file_path)
 
-      @world.load_step_file(file_path)
+        world.loaded_step_patterns.should =~ patterns
+      end
 
-      @world.loaded_step_patterns.should =~ patterns
-    end
+      it 'can handle a variety of declaration structures' do
+        file_path = "#{@default_file_directory}/step_file.rb"
+        patterns = [/parentheses pattern/, /no parentheses pattern/, /excess whitespace pattern/]
+
+        File.open(file_path, 'w') { |file|
+          file.puts "Given(#{patterns[0].inspect}) do end"
+          file.puts "Given #{patterns[1].inspect} do end"
+          file.puts "Given   #{patterns[2].inspect}   do end"
+        }
 
-    it 'can clear its loaded step patterns - #clear_step_patterns' do
-      patterns = [/a pattern/, /another pattern/]
+        world.load_step_file(file_path)
+
+        world.loaded_step_patterns.should =~ patterns
+      end
+
+      it 'can clear its loaded step patterns' do
+        patterns = [/a pattern/, /another pattern/]
+
+        patterns.each do |pattern|
+          world.load_step_pattern(pattern)
+        end
 
-      patterns.each do |pattern|
-        @world.load_step_pattern(pattern)
+        world.loaded_step_patterns.should =~ patterns
+        world.clear_step_patterns
+        world.loaded_step_patterns.should == []
       end
 
-      @world.loaded_step_patterns.should =~ patterns
-      @world.clear_step_patterns
-      @world.loaded_step_patterns.should == []
     end
 
   end