cuke_modeler 0.4.1 → 1.0.0

data/features/modeling/table_output.feature

@@ -0,0 +1,24 @@
+Feature: Table output
+
+  A table model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a table model
+    Given the following gherkin:
+      """
+      |value1|value2|
+      |value3|value4|
+      """
+    And a table model based on that gherkin
+      """
+        @model = CukeModeler::Table.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      | value1 | value2 |
+      | value3 | value4 |
+      """

data/features/modeling/tag_modeling.feature

@@ -0,0 +1,43 @@
+Feature: Tag modeling
+
+  Tag models represent a tag portion of a feature. They expose several attributes of the tag
+  that they represent.
+
+
+  Background:
+    Given the following gherkin:
+      """
+      @a_tag
+      """
+    And a tag model based on that gherkin
+      """
+        @model = CukeModeler::Tag.new(<source_text>)
+      """
+
+
+  Scenario: Modeling a tag's name
+    When the tag's name is requested
+      """
+        @model.name
+      """
+    Then the model returns "@a_tag"
+
+  Scenario: Modeling a tag's source line
+    Given the following gherkin:
+      """
+      @a_tag
+      Feature:
+      """
+    And a feature model based on that gherkin
+      """
+        @model = CukeModeler::Feature.new(<source_text>)
+      """
+    And the tag model of that feature model
+      """
+        @model = @model.tags.first
+      """
+    When the tag's source line is requested
+      """
+        @model.source_line
+      """
+    Then the model returns "1"

data/features/modeling/tag_output.feature

@@ -0,0 +1,22 @@
+Feature: Tag output
+
+  A tag model's string output is a Gherkin representation of itself.
+
+
+  Scenario: Outputting a tag model
+    Given the following gherkin:
+      """
+      @a_tag
+      """
+    And a scenario model based on that gherkin
+      """
+        @model = CukeModeler::Tag.new(<source_text>)
+      """
+    When the model is output as a string
+      """
+        @model.to_s
+      """
+    Then the following text is provided:
+      """
+      @a_tag
+      """

data/features/step_definitions/action_steps.rb

@@ -1,3 +1,13 @@
 When(/^it is outputted$/) do
-  @output = @element.to_s
+  @output = @model.to_s
+end
+
+When(/^the models are compared$/) do
+  @results = []
+
+  (@models.count - 1).times do |index|
+    @results << (@models[index] == @models[index + 1])
+  end
+
+  @results << (@models.first == @models.last)
 end

data/features/step_definitions/background_steps.rb

@@ -1,85 +1 @@
-Then /^the(?: feature "([^"]*)")? background is found to have the following properties:$/ do |file, properties|
-  file ||= 1
-  properties = properties.rows_hash
-
-  properties.each do |property, expected_value|
-    expected = expected_value
-    actual = @parsed_files[file - 1].feature.background.send(property.to_sym).to_s
-
-    actual.should == expected
-  end
-end
-
-Then /^the(?: feature "([^"]*)")? background has the following description:/ do |file, text|
-  file ||= 1
-
-  expected = text
-
-  new_description = @parsed_files[file - 1].feature.background.description_text
-  old_description = @parsed_files[file - 1].feature.background.description
-
-  new_description.should == expected
-  old_description.should == remove_whitespace(expected)
-end
-
-Then /^the(?: feature "([^"]*)")? background's steps are as follows:$/ do |file, steps|
-  file ||= 1
-
-  steps = steps.raw.flatten.collect do |step|
-    if step.start_with? "'"
-      step.slice(1..step.length - 2)
-    else
-      step
-    end
-  end
-
-  actual_steps = Array.new.tap do |steps|
-    @parsed_files[file - 1].feature.background.steps.each do |step|
-      steps << step.base
-    end
-  end
-
-  expected = steps
-  actual = actual_steps.flatten
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-When /^step "([^"]*)" of the background (?:of feature "([^"]*)" )?has the following block:$/ do |step, file, block|
-  file ||= 1
-
-  block = block.raw.flatten.collect do |line|
-    if line.start_with? "'"
-      line.slice(1..line.length - 2)
-    else
-      line
-    end
-  end
-
-  assert @parsed_files[file - 1].feature.background.steps[step - 1].block == block
-end
-
-
-Then(/^the(?: feature "([^"]*)")? background correctly stores its underlying implementation$/) do |file|
-  file ||= 1
-
-  raw_element = @parsed_files[file - 1].feature.background.raw_element
-
-  expected = 'Background'
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    actual = raw_element[:keyword]
-  else
-    actual = raw_element['keyword']
-  end
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Given(/^a background element based on the following gherkin:$/) do |background_text|
-  @element = CukeModeler::Background.new(background_text)
-end
-
-Then /^the background has convenient output$/ do
-  @parsed_files.first.feature.background.method(:to_s).owner.should == CukeModeler::Background
-end
-
+# No steps specific to this type of model

data/features/step_definitions/directory_steps.rb

@@ -1,52 +1,6 @@
-Then /^(?:the )?directory(?: "([^"]*)")? is found to have the following properties:$/ do |directory, properties|
-  directory ||= 1
-  properties = properties.rows_hash
-
-  properties.each do |property, expected_value|
-    if property == 'path'
-      expected_value.sub!('path_to', @default_file_directory)
-    end
-
-    expected = expected_value
-    actual = @parsed_directories[directory - 1].send(property.to_sym).to_s
-
-    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-  end
-end
-
-When /^(?:the )?directory(?: "([^"]*)")? feature files are as follows:$/ do |directory, files|
-  directory ||= 1
-
-  actual_files = @parsed_directories[directory - 1].feature_files.collect { |file| file.name }
-
-  assert actual_files.flatten.sort == files.raw.flatten.sort
-end
-
-When /^(?:the )?directory(?: "([^"]*)")? directories are as follows:$/ do |directory, directories|
-  directory ||= 1
-
-  expected = directories.raw.flatten.sort
-  actual = @parsed_directories[directory - 1].directories.collect { |sub_directory| sub_directory.name }
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-When /^(?:the )?directory(?: "([^"]*)")? has no directories$/ do |directory|
-  directory ||= 1
-
-  expected = []
-  actual = @parsed_directories[directory - 1].directories
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Given(/^a directory element based on "([^"]*)"$/) do |directory_name|
+Given(/^a directory model based on "([^"]*)"$/) do |directory_name|
   directory_path = "#{@default_file_directory}/#{directory_name}"
   FileUtils.mkdir(directory_path) unless File.exists?(directory_path)
 
-  @element = CukeModeler::Directory.new(directory_path)
-end
-
-Then(/^the directory has convenient output$/) do
-  @parsed_directories.first.method(:to_s).owner.should == CukeModeler::Directory
+  @model = CukeModeler::Directory.new(directory_path)
 end

data/features/step_definitions/doc_string_steps.rb

@@ -1,67 +1 @@
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string content type is "([^"]*)"$/ do |file, test, step, type|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = type
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has no content type$/ do |file, test, step|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  expected = nil
-  actual = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.content_type
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string has the following contents:$/ do |file, test, step, contents|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents_text.should == contents
-  # Remove once Array contents is no longer supported
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should == contents.split("\n", -1)
-end
-
-Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string contents are empty$/ do |file, test, step|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  #todo Remove once Array contents is no longer supported
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents.should be_empty
-  @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.contents_text.should be_empty
-end
-
-Then(/^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"]*)") )?doc string correctly stores its underlying implementation$/) do |file, test, step|
-  file ||= 1
-  test ||= 1
-  step ||= 1
-
-  raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.raw_element
-
-  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
-    raw_element.has_key?(:contentType).should be_true
-  else
-    raw_element.has_key?('content_type').should be_true
-  end
-end
-
-Then(/^the doc string has convenient output$/) do
-  @parsed_files.first.feature.tests.first.steps.first.block.method(:to_s).owner.should == CukeModeler::DocString
-end
-
-Given(/^a doc string element based on the following gherkin:$/) do |doc_string_text|
-  @element = CukeModeler::DocString.new(doc_string_text)
-end
-
-Given(/^a doc string element based on the string "(.*)"$/) do |string|
-  @element = CukeModeler::DocString.new(string.gsub('\n', "\n"))
-end
+# No steps specific to this type of model

data/features/step_definitions/feature_file_steps.rb

@@ -1,41 +1,6 @@
-Then /^(?:the )?file(?: "([^"]*)")? is found to have the following properties:$/ do |file, properties|
-  file ||= 1
-  properties = properties.rows_hash
-
-  properties.each do |property, expected_value|
-    if property == 'path'
-      expected_value.sub!('path_to', @test_directory)
-    end
-
-    expected = expected_value
-    actual = @parsed_files[file - 1].send(property.to_sym).to_s
-
-    assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-  end
-end
-
-When /^(?:the )?file(?: "([^"]*)")? features are as follows:$/ do |file, feature|
-  file ||= 1
-
-  expected = feature.raw.flatten.first
-  actual = @parsed_files[file - 1].feature.name
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-When /^(?:the )?file(?: "([^"]*)")? has no features$/ do |file|
-  file ||= 1
-
-  assert @parsed_files[file - 1].feature.nil?
-end
-
-Then(/^the feature file has convenient output$/) do
-  @parsed_files.first.method(:to_s).owner.should == CukeModeler::FeatureFile
-end
-
-Given(/^a feature file element based on "([^"]*)"$/) do |file_name|
+Given(/^a feature file model based on "([^"]*)"$/) do |file_name|
   file_path = "#{@default_file_directory}/#{file_name}"
   File.open(file_path, 'w') { |file| file.puts "Feature:" } unless File.exists?(file_path)
 
-  @element = CukeModeler::FeatureFile.new(file_path)
+  @model = CukeModeler::FeatureFile.new(file_path)
 end

data/features/step_definitions/feature_steps.rb

@@ -1,103 +1,7 @@
-Then /^(?:the )?feature(?: "([^"]*)")? is found to have the following properties:$/ do |file, properties|
-  file ||= 1
-  properties = properties.rows_hash
-
-  properties.each do |property, expected_value|
-    expected = expected_value
-    actual = @parsed_files[file - 1].feature.send(property.to_sym).to_s
-
-    assert(actual == expected, "Expected #{property} to be: #{expected}\n but was: #{actual}")
-  end
-end
-
-Then /^(?:the )?feature "([^"]*)" has the following description:$/ do |file, text|
-  new_description = @parsed_files[file - 1].feature.description_text
-  old_description = @parsed_files[file - 1].feature.description
-
-  new_description.should == text
-  old_description.should == remove_whitespace(text)
-end
-
-Then /^feature "([^"]*)" is found to have the following tags:$/ do |file, expected_tags|
-  expected_tags = expected_tags.raw.flatten
-
-  @parsed_files[file - 1].feature.tags.should == expected_tags
-  @parsed_files[file - 1].feature.tag_elements.collect { |tag| tag.name }.should == expected_tags
-end
-
-Then /^feature "([^"]*)" has no description$/ do |file|
-  @parsed_files[file - 1].feature.description_text.should == ''
-  @parsed_files[file - 1].feature.description.should == []
+And(/^the \w+ model of that feature model$/) do |code_text|
+  eval(code_text)
 end
 
-Then /^feature "([^"]*)" has no tags$/ do |file|
-  assert @parsed_files[file - 1].feature.tags == []
-  assert @parsed_files[file - 1].feature.tag_elements.collect { |tag| tag.name } == []
-end
-
-When /^(?:the )?feature(?: "([^"]*)")? scenarios are as follows:$/ do |file, scenarios|
-  file ||= 1
-
-  actual_scenarios = @parsed_files[file - 1].feature.scenarios.collect { |scenario| scenario.name }
-
-  assert actual_scenarios.flatten.sort == scenarios.raw.flatten.sort
-end
-
-When /^(?:the )?feature(?: "([^"]*)")? outlines are as follows:$/ do |file, outlines|
-  file ||= 1
-
-  actual_outlines = @parsed_files[file - 1].feature.outlines.collect { |outline| outline.name }
-
-  expected = outlines.raw.flatten.sort
-  actual = actual_outlines.flatten.sort
-
-  assert(actual == expected, "Expected: #{expected}\n but was: #{actual}")
-end
-
-When /^(?:the )?feature(?: "([^"]*)")? background is as follows:$/ do |file, background|
-  file ||= 1
-
-  @parsed_files[file - 1].feature.background.name.should == background.raw.flatten.first
-end
-
-When /^feature "([^"]*)" has no scenarios$/ do |file|
-  assert @parsed_files[file - 1].feature.scenarios == []
-end
-
-When /^feature "([^"]*)" has no outlines/ do |file|
-  assert @parsed_files[file - 1].feature.outlines == []
-end
-
-When /^feature "([^"]*)" has no background/ do |file|
-  assert @parsed_files[file - 1].feature.has_background? == false
-end
-
-Then /^(?:the )?feature(?: "([^"]*)")? correctly stores its underlying implementation$/ do |file|
-  file ||= 1
-
-  raw_element = @parsed_files[file - 1].feature.raw_element
-
-  case
-    when Gem.loaded_specs['gherkin'].version.version[/^4/]
-      expect(raw_element).to have_key(:children)
-    when Gem.loaded_specs['gherkin'].version.version[/^3/]
-      expect(raw_element).to have_key(:scenarioDefinitions)
-    else
-      expect(raw_element).to have_key('elements')
-  end
-end
-
-Then(/^the feature has convenient output$/) do
-  @parsed_files.first.feature.method(:to_s).owner.should == CukeModeler::Feature
-end
-
-Given(/^a feature element based on the following gherkin:$/) do |feature_text|
-  @element = CukeModeler::Feature.new(feature_text)
-end
-
-def remove_whitespace(text)
-  stripped_text = text.split("\n").collect { |line| line.strip }
-  stripped_text.delete('')
-
-  stripped_text
+And(/^the \w+(?: \w+)? model inside of that feature model$/) do |code_text|
+  eval(code_text)
 end