cuke_modeler 0.2.0 → 0.3.0

data/features/modeling/gherkin4/table_modeling.feature

@@ -0,0 +1,42 @@
+@gherkin4
+Feature: Table elements can be modeled.
+
+
+  Acceptance criteria
+
+  1. All conceptual pieces of a table can be modeled:
+  - the table's contents
+  - the table's raw element
+
+  2. Tables can be outputted in a convenient form
+
+
+  Background: Test file setup.
+    Given the following feature file:
+    """
+    Feature:
+
+      Scenario:
+        * some data filled step:
+          | value 1 | value 2 |
+          | value 3 | value 4 |
+        * some data filled step:
+          | value 1 |
+          | value 2 |
+    """
+    When the file is read
+
+
+  Scenario: The table's contents are modeled.
+    Then the step "1" table has the following contents:
+      | value 1 | value 2 |
+      | value 3 | value 4 |
+    And the step "2" table has the following contents:
+      | value 1 |
+      | value 2 |
+
+  Scenario: The raw table element is modeled.
+    Then the table correctly stores its underlying implementation
+
+  Scenario: Convenient output of a table
+    Then the table has convenient output

data/features/modeling/gherkin4/table_output.feature

@@ -0,0 +1,43 @@
+@gherkin4
+Feature: Outputting table elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a table that has one row
+    Given a table element based on the following gherkin:
+    """
+    |value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value |
+    """
+
+  Scenario: Output of a table that has multiple rows
+    Given a table element based on the following gherkin:
+    """
+    |value1|
+    |value2|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value1 |
+    | value2 |
+    """
+
+  Scenario: Whitespace buffers are based on the longest value in a column
+    Given a table element based on the following gherkin:
+    """
+    |value|x|
+    |y|another_value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value | x             |
+    | y     | another_value |
+    """

data/features/modeling/gherkin4/table_row_modeling.feature

@@ -0,0 +1,57 @@
+@gherkin4
+Feature: Table Row elements can be modeled.
+
+
+  Acceptance criteria
+
+  1. All conceptual pieces of a table row can be modeled:
+  - the row's source line
+  - the row's cells
+  - the row's raw element
+
+  2. Rows can be outputted in a convenient form
+
+
+  Background: Test file setup.
+    Given the following feature file:
+    """
+    Feature:
+
+      Scenario:
+        * some data filled step:
+          | value 1 | value 2 |
+          | value 3 | value 4 |
+        * some data filled step:
+          | value 1 |
+          | value 2 |
+    """
+    When the file is read
+
+
+  Scenario: The raw table row element is modeled.
+    Then the step table row correctly stores its underlying implementation
+
+  Scenario: The table row's source line is modeled.
+    Then step "1" table row "1" is found to have the following properties:
+      | source_line | 5 |
+    And step "1" table row "2" is found to have the following properties:
+      | source_line | 6 |
+    And step "2" table row "1" is found to have the following properties:
+      | source_line | 8 |
+    And step "2" table row "2" is found to have the following properties:
+      | source_line | 9 |
+
+  Scenario: The table row's cells are modeled.
+    Then step "1" table row "1" cells are as follows:
+      | value 1 |
+      | value 2 |
+    And step "1" table row "2" cells are as follows:
+      | value 3 |
+      | value 4 |
+    And step "2" table row "1" cells are as follows:
+      | value 1 |
+    And step "2" table row "2" cells are as follows:
+      | value 2 |
+
+  Scenario: Convenient output of a table row
+    Then the table row has convenient output

data/features/modeling/gherkin4/table_row_output.feature

@@ -0,0 +1,28 @@
+@gherkin4
+Feature: Outputting table row elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a table row that has one cell
+    Given a table row element based on the following gherkin:
+    """
+    |value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value |
+    """
+
+  Scenario: Output of a table row that has multiple cells
+    Given a table row element based on the following gherkin:
+    """
+    |value|another_value|
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    | value | another_value |
+    """

data/features/modeling/gherkin4/tag_modeling.feature

@@ -0,0 +1,48 @@
+@gherkin4
+Feature: Tag elements can be modeled.
+
+
+  Acceptance criteria
+
+  1. All conceptual pieces of a tag can be modeled:
+  - the tag's name
+  - the tags's source line
+  - the tags's raw element
+
+  2. Features can be outputted in a convenient form
+
+
+  Background: Test file setup.
+    Given the following feature file:
+    """
+    @feature_tag
+    Feature:
+
+      @outline_tag
+      Scenario Outline:
+        * a step
+
+      @example_tag
+      Examples:
+        | a param |
+    """
+    When the file is read
+
+
+  Scenario: The raw tag element is modeled.
+    Then the feature tag correctly stores its underlying implementation
+    And the test tag correctly stores its underlying implementation
+    And the example tag correctly stores its underlying implementation
+
+  Scenario: The tag's source line is modeled.
+    Then the feature tag source line "1"
+    And the test tag source line "4"
+    And the example tag source line "8"
+
+  Scenario: The tag name is modeled.
+    Then the feature tag name is "@feature_tag"
+    And the test tag name is "@outline_tag"
+    And the example tag name is "@example_tag"
+
+  Scenario: Convenient output of a tag
+    Then the tag has convenient output

data/features/modeling/gherkin4/tag_output.feature

@@ -0,0 +1,17 @@
+@gherkin4
+Feature: Outputting tag elements
+
+  The output of an element model is a representation of the element as it would
+  appear in gherkin.
+
+
+  Scenario: Output of a tag that has a name
+    Given a tag element based on the following gherkin:
+    """
+    @some_tag
+    """
+    When it is outputted
+    Then the following text is provided:
+    """
+    @some_tag
+    """

data/features/step_definitions/background_steps.rb

@@ -66,7 +66,7 @@ Then(/^the(?: feature "([^"]*)")? background correctly stores its underlying imp
   raw_element = @parsed_files[file - 1].feature.background.raw_element
 
   expected = 'Background'
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     actual = raw_element[:keyword]
   else
     actual = raw_element['keyword']

data/features/step_definitions/doc_string_steps.rb

@@ -47,7 +47,7 @@ Then(/^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  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

data/features/step_definitions/feature_steps.rb

@@ -77,10 +77,13 @@ Then /^(?:the )?feature(?: "([^"]*)")? correctly stores its underlying implement
 
   raw_element = @parsed_files[file - 1].feature.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
-    raw_element.has_key?(:scenarioDefinitions).should be_true
-  else
-    raw_element.has_key?('elements').should be_true
+  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
 

data/features/step_definitions/outline_steps.rb

@@ -193,7 +193,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   row ||= 1
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].row_elements[row - 1].raw_element
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:cells).should be_true
   else
     raw_element.has_key?('cells').should be_true
@@ -206,7 +206,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? example block(?: "([^
   example ||= 1
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].examples[example - 1].raw_element
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:tableHeader).should be_true
   else
     raw_element.has_key?('rows').should be_true

data/features/step_definitions/step_steps.rb

@@ -108,7 +108,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? step(?: "([^"]*)")? c
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:keyword).should be_true
   else
     raw_element.has_key?('keyword').should be_true
@@ -139,7 +139,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?step(?: "([^"]*)
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.row_elements[row - 1].raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:cells).should be_true
   else
     raw_element.has_key?('cells').should be_true

data/features/step_definitions/table_steps.rb

@@ -17,7 +17,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?(?:test(?: "([^"]*)")? )?(?:step(?: "([^"
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].steps[step - 1].block.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     expect(raw_element).to have_key(:rows)
   else
     raw_element.is_a?(Array).should be_true

data/features/step_definitions/tag_steps.rb

@@ -1,7 +1,7 @@
 Then /^the feature tag correctly stores its underlying implementation$/ do
   raw_element = @parsed_files.first.feature.tag_elements.first.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:name).should be_true
   else
     raw_element.has_key?('name').should be_true
@@ -11,7 +11,7 @@ end
 When(/^the test tag correctly stores its underlying implementation$/) do
   raw_element = @parsed_files.first.feature.tests.first.tag_elements.first.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:name).should be_true
   else
     raw_element.has_key?('name').should be_true
@@ -21,7 +21,7 @@ end
 When(/^the example tag correctly stores its underlying implementation$/) do
   raw_element = @parsed_files.first.feature.tests.first.examples.first.tag_elements.first.raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     raw_element.has_key?(:name).should be_true
   else
     raw_element.has_key?('name').should be_true

data/features/step_definitions/test_steps.rb

@@ -99,7 +99,7 @@ Then /^(?:the )?(?:feature "([^"]*)" )?test(?: "([^"]*)")? correctly stores its
 
   raw_element = @parsed_files[file - 1].feature.tests[test - 1].raw_element
 
-  if Gem.loaded_specs['gherkin'].version.version[/^3/]
+  if Gem.loaded_specs['gherkin'].version.version[/^3|4/]
     expected = ['Scenario', 'Scenario Outline']
     actual = raw_element[:keyword]
   else

data/gemfiles/gherkin.gemfile

@@ -8,6 +8,7 @@ if RUBY_VERSION =~ /^1\.8/
   gem 'cucumber', '<1.3.0'
   gem 'mime-types', '<2.0.0'
   gem 'rest-client', '<1.7.0'
+  gem 'rake', '< 11.0' # Rake dropped 1.8.x support after this version
 elsif RUBY_VERSION =~ /^1\./
   gem 'cucumber', '>=1.0.0', '<2.0.0'
 end

data/gemfiles/gherkin3.gemfile

@@ -1,13 +1,14 @@
 source 'https://rubygems.org'
 
 gemspec :path => "../"
-gem "gherkin", ">= 3.0.0"
+gem "gherkin", "~> 3.0"
 
 # cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
 if RUBY_VERSION =~ /^1\.8/
   gem 'cucumber', '<1.3.0'
   gem 'mime-types', '<2.0.0'
   gem 'rest-client', '<1.7.0'
+  gem 'rake', '< 11.0' # Rake dropped 1.8.x support after this version
 end
 
 if RUBY_VERSION =~ /^2\.[23456789]/

data/gemfiles/gherkin4.gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+
+gemspec :path => "../"
+gem "gherkin", "~> 4.0"
+
+# cuke_modeler can play with pretty much any version of these but they all play differently with Ruby
+if RUBY_VERSION =~ /^1\.8/
+  gem 'cucumber', '<1.3.0'
+  gem 'mime-types', '<2.0.0'
+  gem 'rest-client', '<1.7.0'
+  gem 'rake', '< 11.0' # Rake dropped 1.8.x support after this version
+end
+
+if RUBY_VERSION =~ /^2\.[23456789]/
+  gem 'test-unit'
+end

data/lib/cuke_modeler/adapters/gherkin_4_adapter.rb

@@ -0,0 +1,220 @@
+module CukeModeler
+  class Gherkin4Adapter
+
+
+    def adapt(parsed_ast)
+      adapt_feature!(parsed_ast[:feature]) if parsed_ast[:feature]
+
+      [parsed_ast[:feature]].compact
+    end
+
+    def adapt_feature!(parsed_feature)
+      # Saving off the original data
+      parsed_feature['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_feature))
+
+      parsed_feature['name'] = parsed_feature.delete(:name)
+      parsed_feature['description'] = parsed_feature.delete(:description) || ''
+      parsed_feature['line'] = parsed_feature.delete(:location)[:line]
+
+      parsed_feature['elements'] = []
+      adapt_child_elements!(parsed_feature[:children])
+      parsed_feature['elements'].concat(parsed_feature.delete(:children))
+
+      parsed_feature['tags'] = []
+      parsed_feature[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_feature['tags'].concat(parsed_feature.delete(:tags))
+    end
+
+    def adapt_child_elements!(parsed_children)
+      return if parsed_children.empty?
+
+      if parsed_children.first[:type] == :Background
+        adapt_background!(parsed_children.first)
+
+        remaining_children = parsed_children[1..-1]
+      end
+
+      adapt_tests!(remaining_children || parsed_children)
+    end
+
+    def adapt_background!(parsed_background)
+      # Saving off the original data
+      parsed_background['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_background))
+
+      parsed_background['keyword'] = parsed_background.delete(:type).to_s
+      parsed_background['name'] = parsed_background.delete(:name)
+      parsed_background['description'] = parsed_background.delete(:description) || ''
+      parsed_background['line'] = parsed_background.delete(:location)[:line]
+
+      parsed_background['steps'] = []
+      parsed_background[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_background['steps'].concat(parsed_background.delete(:steps))
+    end
+
+    def adapt_tests!(parsed_tests)
+      return unless parsed_tests
+
+      parsed_tests.each do |test|
+        adapt_test!(test)
+      end
+    end
+
+    def adapt_test!(parsed_test)
+      # Saving off the original data
+      parsed_test['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_test))
+
+      parsed_test['keyword'] = parsed_test.delete(:type).to_s
+
+      case parsed_test['keyword']
+        when 'Scenario'
+          adapt_scenario!(parsed_test)
+        when 'ScenarioOutline'
+          parsed_test['keyword'] = 'Scenario Outline'
+          adapt_outline!(parsed_test)
+        else
+          raise(ArgumentError, "Unknown test type: #{parsed_test['keyword']}")
+      end
+    end
+
+    def adapt_scenario!(parsed_test)
+      parsed_test['name'] = parsed_test.delete(:name)
+      parsed_test['description'] = parsed_test.delete(:description) || ''
+      parsed_test['line'] = parsed_test.delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test.delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test.delete(:steps))
+    end
+
+    def adapt_outline!(parsed_test)
+      parsed_test['name'] = parsed_test.delete(:name)
+      parsed_test['description'] = parsed_test.delete(:description) || ''
+      parsed_test['line'] = parsed_test.delete(:location)[:line]
+
+      parsed_test['tags'] = []
+      parsed_test[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_test['tags'].concat(parsed_test.delete(:tags))
+
+      parsed_test['steps'] = []
+      parsed_test[:steps].each do |step|
+        adapt_step!(step)
+      end
+      parsed_test['steps'].concat(parsed_test.delete(:steps))
+
+      parsed_test['examples'] = []
+      parsed_test[:examples].each do |step|
+        adapt_example!(step)
+      end
+      parsed_test['examples'].concat(parsed_test.delete(:examples))
+    end
+
+    def adapt_example!(parsed_example)
+      # Saving off the original data
+      parsed_example['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_example))
+
+      parsed_example['name'] = parsed_example.delete(:name)
+      parsed_example['line'] = parsed_example.delete(:location)[:line]
+      parsed_example['description'] = parsed_example.delete(:description) || ''
+
+      parsed_example['rows'] = []
+
+      if parsed_example[:tableHeader]
+        parsed_example['rows'] << adapt_table_row!(parsed_example.delete(:tableHeader))
+      end
+
+      if parsed_example[:tableBody]
+
+        parsed_example[:tableBody].each do |row|
+          adapt_table_row!(row)
+        end
+        parsed_example['rows'].concat(parsed_example.delete(:tableBody))
+      end
+
+
+      parsed_example['tags'] = []
+      parsed_example[:tags].each do |tag|
+        adapt_tag!(tag)
+      end
+      parsed_example['tags'].concat(parsed_example.delete(:tags))
+    end
+
+    def adapt_tag!(parsed_tag)
+      # Saving off the original data
+      parsed_tag['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_tag))
+
+      parsed_tag['name'] = parsed_tag.delete(:name)
+      parsed_tag['line'] = parsed_tag.delete(:location)[:line]
+    end
+
+    def adapt_step!(parsed_step)
+      # Saving off the original data
+      parsed_step['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step))
+
+      parsed_step['keyword'] = parsed_step.delete(:keyword)
+      parsed_step['name'] = parsed_step.delete(:text)
+      parsed_step['line'] = parsed_step.delete(:location)[:line]
+
+
+      step_argument = parsed_step[:argument]
+
+      if step_argument
+        case step_argument[:type]
+          when :DocString
+            adapt_doc_string!(step_argument)
+            parsed_step['doc_string'] = parsed_step.delete(:argument)
+          when :DataTable
+            adapt_step_table!(step_argument)
+            parsed_step['rows'] = parsed_step.delete(:argument)
+          else
+            raise(ArgumentError, "Unknown step argument type: #{step_argument[:type]}")
+        end
+      end
+    end
+
+    def adapt_doc_string!(parsed_doc_string)
+      # Saving off the original data
+      parsed_doc_string['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_doc_string))
+
+      parsed_doc_string['value'] = parsed_doc_string.delete(:content)
+      parsed_doc_string['content_type'] = parsed_doc_string.delete(:contentType)
+    end
+
+    def adapt_step_table!(parsed_step_table)
+      # Saving off the original data
+      parsed_step_table['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_step_table))
+
+      parsed_step_table['rows'] = []
+      parsed_step_table[:rows].each do |row|
+        adapt_table_row!(row)
+      end
+      parsed_step_table['rows'].concat(parsed_step_table.delete(:rows))
+    end
+
+    def adapt_table_row!(parsed_table_row)
+      # Saving off the original data
+      parsed_table_row['cuke_modeler_raw_adapter_output'] = Marshal::load(Marshal.dump(parsed_table_row))
+
+      parsed_table_row['line'] = parsed_table_row.delete(:location)[:line]
+
+      parsed_table_row['cells'] = parsed_table_row.delete(:cells).collect { |cell| cell[:value] }
+
+
+      parsed_table_row
+    end
+
+  end
+end