cuke_modeler 0.3.0 → 0.4.0

data/spec/unit/bare_bones_unit_specs.rb

@@ -4,9 +4,8 @@ shared_examples_for 'a bare bones element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @element = clazz.new
-  end
+  let(:element) { clazz.new }
+
 
   it 'can be initialized empty' do
     expect { clazz.new }.to_not raise_error

data/spec/unit/containing_element_unit_specs.rb

@@ -4,16 +4,15 @@ shared_examples_for 'a containing element' do
 
   # clazz must be defined by the calling file
 
-  before(:each) do
-    @element = clazz.new
-  end
+  let(:element) { clazz.new }
+
 
-  it 'has children - #contains' do
-    @element.should respond_to(:contains)
+  it 'has children' do
+    element.should respond_to(:contains)
   end
 
-  it 'returns a collection of children - #contains' do
-    @element.contains.is_a?(Array).should be_true
+  it 'returns a collection of children' do
+    element.contains.is_a?(Array).should be_true
   end
 
 end

data/spec/unit/directory_unit_spec.rb

@@ -5,99 +5,138 @@ SimpleCov.command_name('Directory') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'Directory, Unit' do
 
   let(:clazz) { CukeModeler::Directory }
+  let(:directory) { clazz.new }
 
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a containing element'
-  it_should_behave_like 'a bare bones element'
-  it_should_behave_like 'a prepopulated element'
 
-  before(:each) do
-    @directory = clazz.new
-  end
+  describe 'common behavior' do
 
-  it 'cannot model a non-existent directory' do
-    path = "#{@default_file_directory}/missing_directory"
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a containing element'
+    it_should_behave_like 'a bare bones element'
+    it_should_behave_like 'a prepopulated element'
 
-    expect { CukeModeler::Directory.new(path) }.to raise_error(ArgumentError)
   end
 
-  it 'knows the name of the directory that it is modeling' do
-    path = "#{@default_file_directory}"
 
-    directory = CukeModeler::Directory.new(path)
+  describe 'unique behavior' do
 
-    directory.name.should == 'temp_files'
-  end
+    it 'has a name' do
+      expect(directory).to respond_to(:name)
+    end
 
-  it 'knows the path of the directory that it is modeling' do
-    path = "#{@default_file_directory}"
+    it 'derives its directory name from its path' do
+      directory.path = 'path/to/foo'
 
-    directory = CukeModeler::Directory.new(path)
+      expect(directory.name).to eq('foo')
+    end
 
-    directory.path.should == path
-  end
+    it 'has a path' do
+      expect(directory).to respond_to(:path)
+    end
 
-  it 'has feature files - #feature_files' do
-    @directory.should respond_to(:feature_files)
-  end
+    it 'can change its path' do
+      expect(directory).to respond_to(:path=)
 
-  it 'can get and set its feature files - #feature_files, #feature_files=' do
-    @directory.feature_files = :some_feature_files
-    @directory.feature_files.should == :some_feature_files
-    @directory.feature_files = :some_other_feature_files
-    @directory.feature_files.should == :some_other_feature_files
-  end
+      directory.path = :some_path
+      directory.path.should == :some_path
+      directory.path = :some_other_path
+      directory.path.should == :some_other_path
+    end
 
-  it 'knows how many feature files it has - #feature_file_count' do
-    @directory.feature_files = [:file_1, :file_2, :file_3]
+    it 'knows the path of the directory that it is modeling' do
+      path = "#{@default_file_directory}"
 
-    @directory.feature_file_count.should == 3
-  end
+      directory = clazz.new(path)
 
-  it 'has directories - #directories' do
-    @directory.should respond_to(:directories)
-  end
+      directory.path.should == path
+    end
 
-  it 'can get and set its directories - #directories, #directories=' do
-    @directory.directories = :some_directories
-    @directory.directories.should == :some_directories
-    @directory.directories = :some_other_directories
-    @directory.directories.should == :some_other_directories
-  end
+    it 'has feature files' do
+      directory.should respond_to(:feature_files)
+    end
 
-  it 'knows how many directories it has - #directory_count' do
-    @directory.directories = [:directory_1, :directory_2, :directory_3]
+    it 'can change its feature files' do
+      expect(directory).to respond_to(:feature_files=)
 
-    @directory.directory_count.should == 3
-  end
+      directory.feature_files = :some_feature_files
+      directory.feature_files.should == :some_feature_files
+      directory.feature_files = :some_other_feature_files
+      directory.feature_files.should == :some_other_feature_files
+    end
 
-  it 'starts with no feature files or directories' do
-    @directory.feature_files.should == []
-    @directory.directories.should == []
-  end
+    it 'knows how many feature files it has' do
+      directory.feature_files = [:file_1, :file_2, :file_3]
 
-  it 'contains feature files and directories' do
-    directories = [:directory_1, :directory_2, :directory_3]
-    files = [:file_1, :file_2, :file_3]
-    everything = files + directories
+      directory.feature_file_count.should == 3
+    end
 
-    @directory.directories = directories
-    @directory.feature_files = files
+    it 'has directories' do
+      directory.should respond_to(:directories)
+    end
 
-    @directory.contains.should =~ everything
-  end
+    it 'can change its directories' do
+      expect(directory).to respond_to(:directories=)
 
-  context 'directory output edge cases' do
+      directory.directories = :some_directories
+      directory.directories.should == :some_directories
+      directory.directories = :some_other_directories
+      directory.directories.should == :some_other_directories
+    end
 
-    it 'is a String' do
-      @directory.to_s.should be_a(String)
+    it 'knows how many directories it has' do
+      directory.directories = [:directory_1, :directory_2, :directory_3]
+
+      directory.directory_count.should == 3
+    end
+
+    describe 'abstract instantiation' do
+
+      it 'starts with no path' do
+        expect(directory.path).to be nil
+      end
+
+      it 'starts with no name' do
+        expect(directory.name).to be nil
+      end
+
+      it 'starts with no feature files or directories' do
+        directory.feature_files.should == []
+        directory.directories.should == []
+      end
+
+    end
+
+    it 'contains feature files and directories' do
+      directories = [:directory_1, :directory_2, :directory_3]
+      files = [:file_1, :file_2, :file_3]
+      everything = files + directories
+
+      directory.directories = directories
+      directory.feature_files = files
+
+      directory.contains.should =~ everything
     end
 
-    it 'can output an empty directory' do
-      expect { @directory.to_s }.to_not raise_error
+    describe 'directory output edge cases' do
+
+      it 'is a String' do
+        directory.to_s.should be_a(String)
+      end
+
+
+      context 'a new directory object' do
+
+        let(:directory) { clazz.new }
+
+
+        it 'can output an empty directory' do
+          expect { directory.to_s }.to_not raise_error
+        end
+
+      end
+
     end
 
   end
 
 end
-

data/spec/unit/doc_string_unit_spec.rb

@@ -5,134 +5,152 @@ SimpleCov.command_name('DocString') unless RUBY_VERSION.to_s < '1.9.0'
 describe 'DocString, Unit' do
 
   let(:clazz) { CukeModeler::DocString }
+  let(:doc_string) { clazz.new }
 
-  it_should_behave_like 'a nested element'
-  it_should_behave_like 'a bare bones element'
-  it_should_behave_like 'a prepopulated element'
-  it_should_behave_like 'a raw element'
+  describe 'common behavior' do
 
-  it 'can be parsed from stand alone text' do
-    source = "\"\"\"\nsome doc string\n\"\"\""
+    it_should_behave_like 'a nested element'
+    it_should_behave_like 'a bare bones element'
+    it_should_behave_like 'a prepopulated element'
+    it_should_behave_like 'a raw element'
 
-    expect { @element = clazz.new(source) }.to_not raise_error
-
-    # Sanity check in case instantiation failed in a non-explosive manner
-    @element.contents_text.should == "some doc string"
-    #todo Remove once Array contents is no longer supported
-    @element.contents.should == ["some doc string"]
   end
 
-  it 'provides a descriptive filename when being parsed from stand alone text' do
-    source = 'bad doc string text'
 
-    expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_doc_string\.feature'/)
-  end
+  describe 'unique behavior' do
 
-  it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
-    doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-    raw_data = doc_string.raw_element
+    it 'can be parsed from stand alone text' do
+      source = "\"\"\"\nsome doc string\n\"\"\""
 
-    expect(raw_data.keys).to match_array([:type, :location, :content])
-    expect(raw_data[:type]).to eq(:DocString)
-  end
+      expect { @element = clazz.new(source) }.to_not raise_error
 
-  it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
-    doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-    raw_data = doc_string.raw_element
+      # Sanity check in case instantiation failed in a non-explosive manner
+      @element.contents_text.should == "some doc string"
+      #todo Remove once Array contents is no longer supported
+      @element.contents.should == ["some doc string"]
+    end
 
-    expect(raw_data.keys).to match_array([:type, :location, :content])
-    expect(raw_data[:type]).to eq(:DocString)
-  end
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = 'bad doc string text'
 
-  it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
-    doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
-    raw_data = doc_string.raw_element
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_doc_string\.feature'/)
+    end
 
-    expect(raw_data.keys).to match_array(['value', 'content_type', 'line'])
-    expect(raw_data['value']).to eq('some doc string')
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
+      raw_data = doc_string.raw_element
 
+      expect(raw_data.keys).to match_array([:type, :location, :content])
+      expect(raw_data[:type]).to eq(:DocString)
+    end
 
-  before(:each) do
-    @doc_string = clazz.new
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
+      raw_data = doc_string.raw_element
 
-  it 'has a content type - #content_type' do
-    @doc_string.should respond_to(:content_type)
-  end
+      expect(raw_data.keys).to match_array([:type, :location, :content])
+      expect(raw_data[:type]).to eq(:DocString)
+    end
 
-  it 'can get and set its content type - #content_type, #content_type=' do
-    @doc_string.content_type = :some_content_type
-    @doc_string.content_type.should == :some_content_type
-    @doc_string.content_type = :some_other_content_type
-    @doc_string.content_type.should == :some_other_content_type
-  end
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      doc_string = clazz.new("\"\"\"\nsome doc string\n\"\"\"")
+      raw_data = doc_string.raw_element
 
-  it 'starts with no content type' do
-    @doc_string.content_type.should == nil
-  end
+      expect(raw_data.keys).to match_array(['value', 'content_type', 'line'])
+      expect(raw_data['value']).to eq('some doc string')
+    end
 
-  it 'has contents' do
-    #todo Remove once Array contents is no longer supported
-    @doc_string.should respond_to(:contents)
-    @doc_string.should respond_to(:contents_text)
-  end
+    it 'has a content type' do
+      doc_string.should respond_to(:content_type)
+    end
 
-  it 'can get and set its contents' do
-    #todo Remove once Array contents is no longer supported
-    @doc_string.contents = :some_contents
-    @doc_string.contents.should == :some_contents
-    @doc_string.contents = :some_other_contents
-    @doc_string.contents.should == :some_other_contents
-
-    @doc_string.contents_text = :some_contents
-    @doc_string.contents_text.should == :some_contents
-    @doc_string.contents_text = :some_other_contents
-    @doc_string.contents_text.should == :some_other_contents
-  end
+    it 'can change its content type' do
+      expect(doc_string).to respond_to(:content_type=)
 
-  it 'starts with no contents' do
-    #todo Remove once Array contents is no longer supported
-    @doc_string.contents.should == []
-    @doc_string.contents_text.should == ''
-  end
-
-  #todo Remove once Array contents is no longer supported
-  it 'stores its contents as an array of strings - deprecated' do
-    source = "\"\"\"\nsome text\nsome more text\n\"\"\""
-    doc_string = CukeModeler::DocString.new(source)
+      doc_string.content_type = :some_content_type
+      doc_string.content_type.should == :some_content_type
+      doc_string.content_type = :some_other_content_type
+      doc_string.content_type.should == :some_other_content_type
+    end
 
-    contents = doc_string.contents
+    it 'starts with no content type' do
+      doc_string.content_type.should == nil
+    end
 
-    contents.is_a?(Array).should be_true
-    contents.each do |line|
-      line.is_a?(String).should be_true
+    it 'has contents' do
+      #todo Remove once Array contents is no longer supported
+      doc_string.should respond_to(:contents)
+      doc_string.should respond_to(:contents_text)
     end
-  end
 
-  it 'stores its contents as a String' do
-    source = "\"\"\"\nsome text\nsome more text\n\"\"\""
-    doc_string = clazz.new(source)
+    it 'can get and set its contents' do
+      expect(doc_string).to respond_to(:contents=)
+      expect(doc_string).to respond_to(:contents_text=)
 
-    contents = doc_string.contents_text
+      #todo Remove once Array contents is no longer supported
+      doc_string.contents = :some_contents
+      doc_string.contents.should == :some_contents
+      doc_string.contents = :some_other_contents
+      doc_string.contents.should == :some_other_contents
 
-    contents.is_a?(String).should be_true
-  end
+      doc_string.contents_text = :some_contents
+      doc_string.contents_text.should == :some_contents
+      doc_string.contents_text = :some_other_contents
+      doc_string.contents_text.should == :some_other_contents
+    end
 
-  context 'doc string output edge cases' do
+    it 'starts with no contents' do
+      #todo Remove once Array contents is no longer supported
+      doc_string.contents.should == []
+      doc_string.contents_text.should == ''
+    end
+
+    #todo Remove once Array contents is no longer supported
+    it 'stores its contents as an array of strings - deprecated' do
+      source = "\"\"\"\nsome text\nsome more text\n\"\"\""
+      doc_string = clazz.new(source)
 
-    it 'is a String' do
-      @doc_string.to_s.should be_a(String)
+      contents = doc_string.contents
+
+      contents.is_a?(Array).should be_true
+      contents.each do |line|
+        line.is_a?(String).should be_true
+      end
     end
 
-    it 'can output an empty doc string' do
-      expect { @doc_string.to_s }.to_not raise_error
+    it 'stores its contents as a String' do
+      source = "\"\"\"\nsome text\nsome more text\n\"\"\""
+      doc_string = clazz.new(source)
+
+      contents = doc_string.contents_text
+
+      contents.is_a?(String).should be_true
     end
 
-    it 'can output a doc string that has only a content type' do
-      @doc_string.content_type = 'some type'
+    describe 'doc string output edge cases' do
+
+      it 'is a String' do
+        doc_string.to_s.should be_a(String)
+      end
+
+
+      context 'a new doc string object' do
+
+        let(:doc_string) { clazz.new }
+
+
+        it 'can output an empty doc string' do
+          expect { doc_string.to_s }.to_not raise_error
+        end
+
+        it 'can output a doc string that has only a content type' do
+          doc_string.content_type = 'some type'
+
+          expect { doc_string.to_s }.to_not raise_error
+        end
+
+      end
 
-      expect { @doc_string.to_s }.to_not raise_error
     end
 
   end