cuke_modeler 1.1.1 → 1.2.0

data/lib/cuke_modeler/models/directory.rb

@@ -80,13 +80,10 @@ module CukeModeler
     end
 
     def process_feature_file(file_path)
-      feature_file_data = {'path' => file_path}
-
       source_text = IO.read(file_path)
-      feature = Parsing::parse_text(source_text, file_path).first
-
-      feature_file_data['feature'] = feature
 
+      feature_file_data = Parsing::parse_text(source_text, file_path).first
+      feature_file_data = feature_file_data.merge({'path' => file_path})
 
       feature_file_data
     end

data/lib/cuke_modeler/models/doc_string.rb

@@ -45,7 +45,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_doc_string.feature')
 
-      parsed_file.first['elements'].first['steps'].first['doc_string']
+      parsed_file.first['feature']['elements'].first['steps'].first['doc_string']
     end
 
     def content_type_output_string

data/lib/cuke_modeler/models/example.rb

@@ -124,7 +124,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_example.feature')
 
-      parsed_file.first['elements'].first['examples'].first
+      parsed_file.first['feature']['elements'].first['examples'].first
     end
 
     def determine_buffer_size(index)

data/lib/cuke_modeler/models/feature.rb

@@ -90,7 +90,7 @@ module CukeModeler
     def parse_source(source_text)
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_feature.feature')
 
-      parsed_file.first
+      parsed_file.first['feature']
     end
 
     def background_output_string

data/lib/cuke_modeler/models/feature_file.rb

@@ -4,6 +4,11 @@ module CukeModeler
 
   class FeatureFile < Model
 
+    include Parsed
+
+
+    # The comment models contained by the modeled feature file
+    attr_accessor :comments
 
     # The feature model contained by the modeled feature file
     attr_accessor :feature
@@ -16,6 +21,7 @@ module CukeModeler
     # populates the object.
     def initialize(file_path = nil)
       @path = file_path
+      @comments = []
 
       super(file_path)
 
@@ -49,13 +55,10 @@ module CukeModeler
 
 
     def process_feature_file(file_path)
-      feature_file_data = {'path' => file_path}
-
       source_text = IO.read(file_path)
-      feature = Parsing::parse_text(source_text, file_path).first
-
-      feature_file_data['feature'] = feature
 
+      feature_file_data = Parsing::parse_text(source_text, file_path).first
+      feature_file_data = feature_file_data.merge({'path' => file_path})
 
       feature_file_data
     end

data/lib/cuke_modeler/models/outline.rb

@@ -72,7 +72,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_outline.feature')
 
-      parsed_file.first['elements'].first
+      parsed_file.first['feature']['elements'].first
     end
 
     def examples_output_string

data/lib/cuke_modeler/models/row.rb

@@ -43,7 +43,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_row.feature')
 
-      parsed_file.first['elements'].first['steps'].first['table']['rows'].first
+      parsed_file.first['feature']['elements'].first['steps'].first['table']['rows'].first
     end
 
   end

data/lib/cuke_modeler/models/scenario.rb

@@ -67,7 +67,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_scenario.feature')
 
-      parsed_file.first['elements'].first
+      parsed_file.first['feature']['elements'].first
     end
 
   end

data/lib/cuke_modeler/models/step.rb

@@ -62,7 +62,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_step.feature')
 
-      parsed_file.first['elements'].first['steps'].first
+      parsed_file.first['feature']['elements'].first['steps'].first
     end
 
   end

data/lib/cuke_modeler/models/table.rb

@@ -47,7 +47,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_table.feature')
 
-      parsed_file.first['elements'].first['steps'].first['table']
+      parsed_file.first['feature']['elements'].first['steps'].first['table']
     end
 
     def row_output_string(row)

data/lib/cuke_modeler/models/tag.rb

@@ -40,7 +40,7 @@ module CukeModeler
 
       parsed_file = Parsing::parse_text(source_text, 'cuke_modeler_stand_alone_tag.feature')
 
-      parsed_file.first['tags'].first
+      parsed_file.first['feature']['tags'].first
     end
 
   end

data/lib/cuke_modeler/version.rb

@@ -1,4 +1,4 @@
 module CukeModeler
   # The gem version
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/cuke_modeler.rb

@@ -29,3 +29,4 @@ require 'cuke_modeler/models/table'
 require 'cuke_modeler/models/row'
 require 'cuke_modeler/models/tag'
 require 'cuke_modeler/models/cell'
+require 'cuke_modeler/models/comment'

data/testing/cucumber/features/modeling/comment_modeling.feature

@@ -0,0 +1,43 @@
+Feature: Comment modeling
+
+  Comment models represent a comment portion of a feature. They expose several attributes of the comment
+  that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      # a comment
+      """
+    And a comment model based on that gherkin
+      """
+        @model = CukeModeler::Comment.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a comments text
+    When the comment's text is requested
+      """
+        @model.text
+      """
+    Then the model returns "# a comment"
+
+  Scenario: Modeling a comment's source line
+    Given a feature file with the following gherkin:
+      """
+      # a comment
+      Feature:
+      """
+    And a feature file model based on that file
+      """
+        @model = CukeModeler::FeatureFile.new(<file_path>)
+      """
+    And the comment model of that feature file model
+      """
+        @model = @model.comments.first
+      """
+    When the comment's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "1"

data/testing/cucumber/features/modeling/comment_output.feature

@@ -0,0 +1,27 @@
+Feature: Comment output
+
+  A comment model's string output is a Gherkin representation of itself. As such, output from a comment model can be used as
+  input for the same kind of model.
+
+
+  Scenario: Outputting a comment model
+    Given the following gherkin:
+      """
+      # a comment
+      """
+    And a comment model based on that gherkin
+      """
+        @model = CukeModeler::Comment.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      # a comment
+      """
+    And the output can be used to make an equivalent model
+      """
+        CukeModeler::Comment.new(@model.to_s)
+      """

data/testing/cucumber/features/modeling/feature_file_modeling.feature

@@ -9,6 +9,8 @@ Feature: Feature file modeling
     Given the directory "test_directory"
     And the file "test_directory/foo.feature":
       """
+      # A comment
+      # Another comment
       Feature: Bar
       """
     And the feature file is modeled
@@ -31,6 +33,15 @@ Feature: Feature file modeling
       """
     Then the model returns "foo.feature"
 
+  Scenario: Modeling a feature file's comments
+    When the feature file's comments are requested
+      """
+        @model.comments
+      """
+    Then the model returns models for the following comments:
+      | # A comment       |
+      | # Another comment |
+
   Scenario: Modeling a feature file's feature
     When the feature file's feature is requested
       """

data/testing/cucumber/features/modeling/model_structure.feature

@@ -36,8 +36,8 @@ being populated dynamically based on an actual test suite.
 
   Scenario: Accessing the parsing data
 
-  Note: Directory and feature file models do not store any parsing data because parsing Gherkin source text
-  does not come into play until the feature level of modeling.
+  Note: Directory models do not store any parsing data because parsing Gherkin source text
+  does not come into play until the feature file level of modeling.
 
     Given the models provided by CukeModeler
     Then  all of them provide access to the parsing data that was used to create them

data/testing/cucumber/features/modeling/tag_output.feature

@@ -9,7 +9,7 @@ Feature: Tag output
       """
       @a_tag
       """
-    And a scenario model based on that gherkin
+    And a tag model based on that gherkin
       """
         @model = CukeModeler::Tag.new(<source_text>)
       """

data/testing/cucumber/step_definitions/feature_file_steps.rb

@@ -4,3 +4,13 @@ Given(/^a feature file model based on "([^"]*)"$/) do |file_name|
 
   @model = CukeModeler::FeatureFile.new(file_path)
 end
+
+And(/^a feature file model based on that file$/) do |code_text|
+  code_text.gsub!('<file_path>', "'#{@file_path}'")
+
+  eval(code_text)
+end
+
+And(/^the comment model of that feature file model$/) do |code_text|
+  eval(code_text)
+end

data/testing/cucumber/step_definitions/setup_steps.rb

@@ -26,3 +26,9 @@ end
 Given(/^the following gherkin:$/) do |text|
   @source_text = text
 end
+
+Given(/^a feature file with the following gherkin:$/) do |file_text|
+  @file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
+
+  File.open(@file_path, 'w') { |file| file.write(file_text) }
+end

data/testing/cucumber/step_definitions/verification_steps.rb

@@ -94,7 +94,7 @@ end
 
 Then(/^all of them provide access to the parsing data that was used to create them$/) do |code_text|
   original_text = code_text
-  unparsed_models = [CukeModeler::Model, CukeModeler::FeatureFile, CukeModeler::Directory]
+  unparsed_models = [CukeModeler::Model, CukeModeler::Directory]
 
   @available_model_classes.each do |clazz|
     next if unparsed_models.include?(clazz)
@@ -164,3 +164,9 @@ But(/^none of the models are equivalent with a model for the following scenario:
     expect(model == other_model).to_not be true
   end
 end
+
+Then(/^the model returns models for the following comments:$/) do |model_values|
+  model_values = model_values.raw.flatten
+
+  expect(@result.collect { |model| model.text }).to eq(model_values)
+end

data/testing/rspec/spec/integration/comment_integration_spec.rb

@@ -0,0 +1,168 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+
+describe 'Comment, Integration' do
+
+  let(:clazz) { CukeModeler::Comment }
+
+
+  describe 'common behavior' do
+
+    it_should_behave_like 'a model, integration'
+
+  end
+
+
+  describe 'unique behavior' do
+
+    it 'can be instantiated with the minimum viable Gherkin' do
+      source = '# a comment'
+
+      expect { clazz.new(source) }.to_not raise_error
+    end
+
+    it 'can parse text that uses a non-default dialect' do
+      original_dialect = CukeModeler::Parsing.dialect
+      CukeModeler::Parsing.dialect = 'en-au'
+
+      begin
+        source_text = '# a comment'
+
+        expect { @model = clazz.new(source_text) }.to_not raise_error
+
+        # Sanity check in case modeling failed in a non-explosive manner
+        expect(@model.text).to eq('# a comment')
+      ensure
+        # Making sure that our changes don't escape a test and ruin the rest of the suite
+        CukeModeler::Parsing.dialect = original_dialect
+      end
+    end
+
+    it 'provides a descriptive filename when being parsed from stand alone text' do
+      source = 'bad comment text'
+
+      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_comment\.feature'/)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
+      comment = clazz.new('# a comment')
+      data = comment.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :text])
+      expect(data[:type]).to eq(:Comment)
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
+      comment = clazz.new('# a comment')
+      data = comment.parsing_data
+
+      expect(data.keys).to match_array([:type, :location, :text])
+      expect(data[:type]).to eq('Comment')
+    end
+
+    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
+      comment = clazz.new('# a comment')
+      data = comment.parsing_data
+
+      expect(data.keys).to match_array(['value', 'line'])
+    end
+
+
+    describe 'getting ancestors' do
+
+      before(:each) do
+        source = "# feature comment
+                  #{@feature_keyword}: Test feature"
+
+        file_path = "#{@default_file_directory}/comment_test_file.feature"
+        File.open(file_path, 'w') { |file| file.write(source) }
+      end
+
+      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
+      let(:comment) { directory.feature_files.first.comments.first }
+
+
+      it 'can get its directory' do
+        ancestor = comment.get_ancestor(:directory)
+
+        expect(ancestor).to equal(directory)
+      end
+
+      it 'can get its feature file' do
+        ancestor = comment.get_ancestor(:feature_file)
+
+        expect(ancestor).to equal(directory.feature_files.first)
+      end
+
+      it 'returns nil if it does not have the requested type of ancestor' do
+        ancestor = comment.get_ancestor(:example)
+
+        expect(ancestor).to be_nil
+      end
+
+    end
+
+
+    describe 'model population' do
+
+      context 'from source text' do
+
+        let(:source_text) { '# a comment' }
+        let(:comment) { clazz.new(source_text) }
+
+
+        it "models the comment's text" do
+          expect(comment.text).to eq('# a comment')
+        end
+
+        it "models the comment's source line" do
+          path = "#{@default_file_directory}/#{@default_feature_file_name}"
+          source_text = "# a comment
+                         #{@feature_keyword}:"
+
+          File.open(path, "w") { |file| file.puts source_text }
+          comment = CukeModeler::FeatureFile.new(path).comments.first
+
+          expect(comment.source_line).to eq(1)
+        end
+
+        it 'removes surrounding whitespace' do
+          comment = clazz.new('           # a comment             ')
+
+          expect(comment.text).to eq('# a comment')
+        end
+
+      end
+
+    end
+
+
+    describe 'comment output' do
+
+      it 'can be remade from its own output' do
+        source = '# a comment'
+        comment = clazz.new(source)
+
+        comment_output = comment.to_s
+        remade_comment_output = clazz.new(comment_output).to_s
+
+        expect(remade_comment_output).to eq(comment_output)
+      end
+
+
+      context 'from source text' do
+
+        it 'can output a comment' do
+          source = '# a comment'
+          comment = clazz.new(source)
+
+          expect(comment.to_s).to eq('# a comment')
+        end
+
+      end
+
+    end
+
+  end
+
+end