yard-gherkin-turnip 1.0.0

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+
+task :default => :gendoc
+
+desc "Clean out any existing documentation"
+task :clean do
+  `rm -rf doc`
+  `rm -rf .yardoc`
+end
+
+desc "Generate documentation from the example data"
+task :gendoc => :clean do
+  puts `yardoc -e ./lib/yard-gherkin-turnip.rb 'example/**/*' --debug`
+end
+
+desc "Run the YARD Server"
+task :server => :gendoc do
+  puts `yard server -e ./lib/yard-gherkin-turnip.rb`
+end
+
+desc "Create the yard-gherkin-turnip gem"
+task :gem do
+  puts `gem build yard-gherkin-turnip.gemspec`
+end

data/example/README.md

@@ -0,0 +1,8 @@
+This collection of features are really just to test some of the varied cases
+that CITY may come in contact with while parsing a series of features.  All
+of the features, tags, and directories displayed here are contained in this 
+directory and all subdirectories.
+
+* First, the features which are broken down alphabetically and displayed
+* Second, the tags, used by all the features and scenarios
+* Third, the subdirectories, contained in this directory and in the subdirectories.

data/example/child_feature/README.md

@@ -0,0 +1,21 @@
+Child Features
+==============
+
+Synopsis
+--------
+
+This collection of features are contained in this folder.  The description README
+allows a user to place a description for entire directory of the features and appears
+in the output to assist with understanding about the collection of features.
+
+Resources
+---------
+
+Links to particular resources like the links to the stories, tasks, or other areas
+can also be represented.
+
+The implemented example has been deployed at [http://recursivegames.com/cukes/](http://recursivegames.com/cukes/).
+
+**1. An Item** [example](http://recursivegames.com/cukes/requirements/)
+
+

data/example/child_feature/child.feature

@@ -0,0 +1,11 @@
+@scenarios
+Feature: Child Feature
+  As a reader of the documentation I expect that scenario are documented correctly
+
+  Background:
+    Given this background step
+
+  Scenario: Child Scenario
+    Given this first step
+	  When this second step
+	  Then this third step

data/example/child_feature/grandchild_feature/grandchild.feature

@@ -0,0 +1,12 @@
+@scenarios
+Feature: Grandchild Feature
+  As a reader of the documentation I expect that scenario are documented correctly
+
+  Background:
+    Given this background step
+
+  @first
+  Scenario: Grandchild Scenario
+    Given this first step
+  	When this second step
+	  Then this third step

data/example/empty.feature

@@ -0,0 +1,2 @@
+# This is a feature that has not been written
+# However, I don't want parser to fail when reaching this file

data/example/placeholder.feature

@@ -0,0 +1,34 @@
+@scenarios @bvt
+Feature: Step Placeholders
+  As a developer of the test suite I expect that step placeholders are documented correctly
+
+  @first
+  Scenario: Step with custom placeholders
+    Given this scenario step
+    Then I expect that the step, on the step transformer page, will link to the step transform
+
+  @first
+  Scenario: Step with custom placeholders
+    Given the first step
+    Then I expect that the step, on the step transformer page, will link to the step transform
+
+  @second
+  Scenario: Step with simple placeholders
+    Given the step called 'bob'
+    And the steps called 'pop'
+    Then I expect that the step, on the step transformer page, will link to the step transform
+
+  @third
+  Scenario: Step with multiple custom placeholders
+    Given the second scenario step on 12/04/2020
+    Then I expect that the step, on the step transformer page, will link to the step transform 
+
+  @third
+  Scenario: Step with both simple and custom placeholders
+    Given the second 'bob' step
+    Then I expect that the step, on the step transformer page, will link to the step transform
+    
+  Scenario: Step with complex placeholder reges
+    Given the step at the [0 + 1] index
+    Then I expect that the step, on the step transformer page, will link to the step transform
+    

data/example/scenario.feature

@@ -0,0 +1,63 @@
+# Comments that appear before the feature are associated with the feature
+@scenarios
+Feature: Displaying Scenarios
+  As a reader of the documentation I expect that scenario are documented correctly
+  
+  # Comments after the feature description belong to the background or first scenario
+  Background:
+    Given this background step
+
+  @first @bvt
+  Scenario: No Step Scenario
+
+  @second @bvt
+  Scenario: Scenario With Steps
+    Given this first step
+	When this second step
+	Then this third step
+	
+  @third @optional_parameters
+  Scenario: Optional Parameter Step Definition
+    # This step definition has some optional parameters
+    Given a project
+    And an inactive project
+    And a project with the name 'optional', start date 10/26/2010, nicknamed 'norman'
+
+  @fourth @highlight
+  Scenario: Matched Term Highlighting
+    Given a duck that has a bill
+    Then I expect the duck to quack
+
+  @fifth @table
+  Scenario: Scenario With Table
+    Given the following table:
+      | column 1 | column 2 | column 3 |
+      | value 1  | value 2  | value 3  |
+
+  @sixth @text
+  Scenario: Scenario With Text
+    Given the following text:
+    """
+    Oh what a bother!
+    That this text has to take up two lines
+      This line should be indented 2 spaces
+        This line should be indented 4 spaces      
+    """
+
+  # Comments before the scenario
+  @seventh @comments
+  Scenario: Scenario with comments and a description
+    There once was a need for information to be displayed alongside all the
+    entities that I hoped to test
+    # First Comment
+    Given this first step
+    # Second Comment that
+    # spans a few lines
+    And this second step
+    # Third Comment
+    And this third step
+    # Comments after the last step, where do they go?
+
+  Scenario: Step ending with a match with double-quotes
+    When searching the log for the exact match of the message "Entering application."
+    When the step definition has HTML escaped characters like: "<>&"

data/example/scenario_outline.feature

@@ -0,0 +1,100 @@
+@scenario_outlines @bvt @duplicate
+Feature: Displaying Scenario Outlines
+  As a reader of the documentation I expect that scenario outlines are documented correctly
+
+  @first
+  Scenario Outline: Three Examples
+    Given that <Customer> is a valid customer
+    And that the product, named '<Product>', is a valid product
+    When the customer has purchased the product
+    Then I expect the customer to be a member of the '<Product>' group
+
+    @tagged_examples
+    Examples:
+     | Customer   | Product   |
+     | Customer A | Product A |
+     | Customer A | Product B |
+     | Customer A | Product C |
+
+  @second
+  Scenario Outline: Step contains a text block
+    Given the following text:
+    """
+    The <noun> jumped over the <place>
+    """
+    When I click on an example row
+ 	  Then I expect <noun> to be replaced by the example noun
+    And I expect <place> to be replaced by the example place
+    
+    Examples:
+     | noun  | place |
+     | cow   | moon  |
+     | horse | spoon |
+
+  @third
+  Scenario Outline: Step contains a table
+    Given the following table:
+      | name   | price   | quantity |
+      | <name> | <price> | 100000   |
+    When I click on an example row
+ 	  Then I expect <name> to be replaced by the example name
+    And I expect <price> to be replaced by the example price
+
+    Examples:
+     | name | price |
+     | toy  | $99   |
+     | game | $49   |
+
+  @fourth
+  Scenario Outline: Step contains a table; table header uses an example
+    Given the following table:
+      | name   | <denomination> | quantity |
+      | <name> | <price>        | 100000   |
+	  When I click on an example row
+    Then I expect <name> to be replaced by the example name
+    And I expect <price> to be replaced by the example price
+    And I expect <denomination> to be replaced by the example denomination
+
+    Examples:
+     | name | price | denomination    |
+     | toy  | 99    | cost in euros   |
+     | game | 49    | cost in dollars |
+     
+  # This is an example of a scenario outline in development.
+  # The example table has not been defined yet
+  @fifth
+  Scenario Outline: Example Table Missing
+    When I click on an example row
+    Then I expect <name> to be replaced by the example name
+    And I expect <price> to be replaced by the example price
+    And I expect <denomination> to be replaced by the example denomination
+      
+    
+  # This is an example of a scenario outline in development.  
+  # The examples table has been defined, but is missing data.
+  @sixth
+  Scenario Outline: Empty Example Table
+    When I click on an example row
+    Then I expect <name> to be replaced by the example name
+    And I expect <price> to be replaced by the example price
+    And I expect <denomination> to be replaced by the example denomination
+    
+    Examples:
+      | name | price | denomination |
+
+  @seventh @duplicate
+  Scenario Outline: Multiple Example Table
+    Given that <Customer> is a valid customer
+    And that the product, named '<Product>', is a valid product
+    When the customer has purchased the product
+    Then I expect the customer to be a member of the '<Product>' group
+
+    @groupA @duplicate
+    Examples: Example group A
+     | Customer   | Product   |
+     | Customer A | Product A |
+
+    @groupB
+    Examples: Example group B
+     | Customer   | Product   |
+     | Customer B | Product A |

data/example/scenario_outline_multi.feature

@@ -0,0 +1,15 @@
+Feature: My Feature
+
+Scenario Outline: Multiple Example Table
+  Given that <Customer> is a valid customer
+  And that the product, named '<Product>', is a valid product
+  When the customer has purchased the product
+  Then I expect the customer to be a member of the '<Product>' group
+
+  Examples: Example group A
+   | Customer   | Product   |
+   | Customer A | Product A |
+
+  Examples: Example group B
+   | Customer   | Product   |
+   | Customer B | Product A |

data/example/step_definitions/customer.step.rb

@@ -0,0 +1,16 @@
+step "that Customer :customer_number is a valid customer" do
+end
+
+step "that the product, named ':product', is a valid product" do
+end
+
+step "the customer has purchased the product" do
+  skip # pending step
+end
+
+step "I expect the customer to be a member of the ':product_type' group" do
+end
+
+placeholder :product_type do
+  match %r{(Product A|Product B|Product C)}
+end

data/example/step_definitions/duck.step.rb

@@ -0,0 +1,6 @@
+step "a duck that "\
+      "has a bill" do
+end
+
+step "I expect the " + "duck to quack" do
+end

data/example/step_definitions/placeholder.step.rb

@@ -0,0 +1,70 @@
+#
+# This step definition uses a placeholder custom
+#
+step "the/this :step_type step" do |step_type|
+  puts "step type #{step_type}"
+end
+
+#
+# This step definition uses a custom placeholder with forward slashes
+#
+step "the :step_number :step_type step on :date" do |step_number, step_type, day, month, year|
+  puts "step type #{step_type}"
+end
+
+#
+# This step definition uses alternative text syntax
+#
+step "the/this :step_number step" do |step_type|
+  puts "step number #{step_type}"
+end
+
+#
+# This step definition uses a default placeholder with optional text
+#
+step "the step(s) called :name" do |name|
+  puts "name #{name}"
+end
+
+
+#
+# This step definition uses both default and custom placeholders
+#
+step "the :step_number :name step" do |step_number, name|
+  puts "step_number #{step_number} and name #{name}"
+end
+
+#
+# This step definition uses a custom placeholder with regex special chars
+#
+step "the step at the [:first_term :arithmetic_operation :first_term] index" do
+end
+
+#
+# Shouldn't match our handler as it's not inside a placeholder
+#
+match /blob/ do
+end
+
+#
+# This placeholder matches the type of step
+#
+placeholder :step_type do
+  match /(?:background|scenario)/
+end
+
+#
+# This placeholder matches the step number using 2 separate calls to match
+#
+placeholder :step_number do
+  match(/(?:first|second)/)
+  match(/third/)
+end
+
+placeholder :date do
+  match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
+end
+
+placeholder :arithmetic_operation do
+  match /\+|-|\*|\//
+end

data/example/step_definitions/text.step.rb

@@ -0,0 +1,11 @@
+step :symbol, "the following text:"
+
+step "I click on an example row" do
+end
+
+step "I expect :noun to be replaced by the example noun" do
+end
+
+step "I expect :place to be replaced by the example place" do
+end
+

data/example/tags.feature

@@ -0,0 +1,18 @@
+@tags
+Feature: Tags
+  As a developer of the test suite I expect that various tags will be supported
+
+  @tag
+  Scenario: Basic Tag
+
+  @tag123456  
+  Scenario: Tag With Numbers
+  
+  @tag_with_underscore
+  Scenario: Tag With Underscore
+
+  @tag-with-dash
+  Scenario: Tag With Dash
+  
+  @tag+with+plus
+  Scenario: Tag With Plus

data/lib/cucumber/city_builder.rb

@@ -0,0 +1,412 @@
+module Cucumber
+  module Parser
+    class CityBuilder < ::Gherkin::AstBuilder
+
+      #
+      # The Gherkin Parser is going to call the various methods within this
+      # class as it finds items. This is similar to how Cucumber generates
+      # it's Abstract Syntax Tree (AST). Here instead this generates the
+      # various YARD::CodeObjects defined within this template.
+      #
+      # A namespace is specified and that is the place in the YARD namespacing
+      # where all cucumber features generated will reside. The namespace specified
+      # is the root namespaces.
+      #
+      # @param [String] file the name of the file which the content belongs
+      #
+      def initialize(file)
+        super()
+        @namespace = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE
+        find_or_create_namespace(file)
+        @file = file
+      end
+
+      # Return the feature that has been defined. This method is the final
+      # method that is called when all the work is done. It is called by
+      # the feature parser to return the complete Feature object that was created
+      #
+      # @return [YARD::CodeObject::Cucumber::Feature] the completed feature
+      #
+      # @see YARD::Parser::Cucumber::FeatureParser
+      def ast
+        feature(get_result) unless @feature
+        @feature
+      end
+
+      #
+      # Feature that are found in sub-directories are considered, in the way
+      # that I chose to implement it, in another namespace. This is because
+      # when you execute a cucumber test run on a directory any sub-directories
+      # of features will be executed with that directory so the file is split
+      # and then namespaces are generated if they have not already have been.
+      #
+      # The other duty that this does is look for a README.md file within the
+      # specified directory of the file and loads it as the description for the
+      # namespace. This is useful if you want to give a particular directory
+      # some flavor or text to describe what is going on.
+      #
+      def find_or_create_namespace(file)
+        @namespace = YARD::CodeObjects::Cucumber::CUCUMBER_NAMESPACE
+
+        File.dirname(file).split('/').each do |directory|
+          @namespace = @namespace.children.find {|child| child.is_a?(YARD::CodeObjects::Cucumber::FeatureDirectory) && child.name.to_s == directory } ||
+            @namespace = YARD::CodeObjects::Cucumber::FeatureDirectory.new(@namespace,directory) {|dir| dir.add_file(directory)}
+        end
+
+        if @namespace.description == "" && File.exists?("#{File.dirname(file)}/README.md")
+          @namespace.description = File.read("#{File.dirname(file)}/README.md")
+        end
+      end
+
+      #
+      # Find the tag if it exists within the YARD Registry, if it doesn't then
+      # create it.
+      #
+      # We note that the tag was used in this file at the current line.
+      #
+      # Then we add the tag to the current scenario or feature. We also add the
+      # feature or scenario to the tag.
+      #
+      # @param [String] tag_name the name of the tag
+      # @param [parent] parent the scenario or feature that is going to adopt
+      #     this tag.
+      #
+      def find_or_create_tag(tag_name,parent)
+        #log.debug "Processing tag #{tag_name}"
+        tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.value == tag_name } ||
+          YARD::CodeObjects::Cucumber::Tag.new(YARD::CodeObjects::Cucumber::CUCUMBER_TAG_NAMESPACE,tag_name.gsub('@','')) {|t| t.owners = [] ; t.value = tag_name ; t.total_scenarios = 0}
+
+        tag_code_object.add_file(@file,parent.line)
+
+        parent.tags << tag_code_object unless parent.tags.find {|tag| tag == tag_code_object }
+        tag_code_object.owners << parent unless tag_code_object.owners.find {|owner| owner == parent}
+      end
+
+      #
+      # Each feature found will call this method, generating the feature object.
+      # This is once, as the gherkin parser does not like multiple feature per
+      # file.
+      #
+      def feature(document)
+        #log.debug "FEATURE"
+        feature = document[:feature]
+        return unless document[:feature]
+        return if has_exclude_tags?(feature[:tags].map { |t| t[:name].gsub(/^@/, '') })
+
+        @feature = YARD::CodeObjects::Cucumber::Feature.new(@namespace,File.basename(@file.gsub('.feature','').gsub('.','_'))) do |f|
+          f.comments = feature[:comments] ? feature[:comments].map{|comment| comment[:text]}.join("\n") : ''
+          f.description = feature[:description] || ''
+          f.add_file(@file,feature[:location][:line])
+          f.keyword = feature[:keyword]
+          f.value = feature[:name]
+          f.tags = []
+
+          feature[:tags].each {|feature_tag| find_or_create_tag(feature_tag[:name],f) }
+        end
+
+        background(feature[:background]) if feature[:background]
+
+        feature[:children].each do |child|
+          case child[:type]
+            when :Background
+              background(child)
+            when :ScenarioOutline
+              outline = scenario_outline(child)
+              @feature.total_scenarios += outline.scenarios.size
+            when :Scenario
+              scenario(child)
+          end
+        end
+
+        @feature.tags.each do |feature_tag|
+          tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.name.to_s == feature_tag[:name].to_s }
+          tag_code_object.total_scenarios += @feature.total_scenarios
+        end
+      end
+
+      #
+      # Called when a background has been found
+      #
+      # @see #feature
+      def background(background)
+        #log.debug "BACKGROUND"
+
+        @background = YARD::CodeObjects::Cucumber::Scenario.new(@feature,"background") do |b|
+          b.comments = background[:comments] ? background[:comments].map{|comment| comment.value}.join("\n") : ''
+          b.description = background[:description] || ''
+          b.keyword = background[:keyword]
+          b.value = background[:name]
+          b.add_file(@file,background[:location][:line])
+        end
+
+        @feature.background = @background
+        @background.feature = @feature
+        @step_container = @background
+        background[:steps].each { |s|
+          step(s)
+        }
+      end
+
+      #
+      # Called when a scenario has been found
+      #   - create a scenario
+      #   - assign the scenario to the feature
+      #   - assign the feature to the scenario
+      #   - find or create tags associated with the scenario
+      #
+      # The scenario is set as the @step_container, which means that any steps
+      # found before another scenario is defined belong to this scenario
+      #
+      # @param [Scenario] statement is a scenario object returned from Gherkin
+      # @see #find_or_create_tag
+      #
+      def scenario(statement)
+        #log.debug "SCENARIO"
+
+        return if has_exclude_tags?(statement[:tags].map { |t| t[:name].gsub(/^@/, '') })
+
+        scenario = YARD::CodeObjects::Cucumber::Scenario.new(@feature,"scenario_#{@feature.scenarios.length + 1}") do |s|
+          s.comments = statement[:comments] ? statement[:comments].map{|comment| comment.value}.join("\n") : ''
+          s.description = statement[:description] || ''
+          s.add_file(@file,statement[:location][:line])
+          s.keyword = statement[:keyword]
+          s.value = statement[:name]
+
+          statement[:tags].each {|scenario_tag| find_or_create_tag(scenario_tag[:name],s) }
+        end
+
+        scenario.feature = @feature
+        @feature.scenarios << scenario
+        @step_container = scenario
+        statement[:steps].each { |s|
+          step(s)
+        }
+
+        # count scenarios for scenario level tags
+        scenario.tags.uniq.each { |scenario_tag|
+          if !scenario.feature.tags.include?(scenario_tag)
+            tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.name.to_s == scenario_tag[:name].to_s }
+            tag_code_object.total_scenarios += 1
+          end
+        }
+      end
+
+      #
+      # Called when a scenario outline is found. Very similar to a scenario,
+      # the ScenarioOutline is still a distinct object as it can contain
+      # multiple different example groups that can contain different values.
+      #
+      # @see #scenario
+      #
+      def scenario_outline(statement)
+        #log.debug "SCENARIO OUTLINE"
+
+        return if has_exclude_tags?(statement[:tags].map { |t| t[:name].gsub(/^@/, '') })
+
+        outline = YARD::CodeObjects::Cucumber::ScenarioOutline.new(@feature,"scenario_#{@feature.scenarios.length + 1}") do |s|
+          s.comments = statement[:comments] ? statement[:comments].map{|comment| comment.value}.join("\n") : ''
+          s.description = statement[:description] || ''
+          s.add_file(@file,statement[:location][:line])
+          s.keyword = statement[:keyword]
+          s.value = statement[:name]
+
+          statement[:tags].each {|scenario_tag| find_or_create_tag(scenario_tag[:name],s) }
+        end
+
+        outline.feature = @feature
+        @step_container = outline
+        statement[:steps].each { |s|
+          step(s)
+        }
+
+        statement[:examples].each { |e|
+          example = examples(e, outline)
+        }
+
+        @feature.scenarios << outline
+
+        # count scenarios for scenario outline level tags
+        outline.tags.uniq.each { |outline_tag|
+          if !outline.feature.tags.include?(outline_tag)
+            tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.name.to_s == outline_tag[:name].to_s }
+            tag_code_object.total_scenarios += outline.scenarios.size
+          end
+        }
+
+        # count scenarios for example table level tags
+        outline.examples.each { |example|
+          unless !example.tags.any?
+            example.tags.uniq.each { |example_tag|
+              if !outline.feature.tags.include?(example_tag) && !outline.tags.include?(example_tag)
+                tag_code_object = YARD::Registry.all(:tag).find {|tag| tag.name.to_s == example_tag[:name].to_s }
+                tag_code_object.total_scenarios += example.data.size
+              end
+            }
+          end
+        }
+
+        return outline
+      end
+
+
+      #
+      # Examples for a scenario outline are called here. This section differs
+      # from the Cucumber parser because here each of the examples are exploded
+      # out here as individual scenarios and step definitions. This is so that
+      # later we can ensure that we have all the variations of the scenario
+      # outline defined to be displayed.
+      #
+      def examples(examples, outline)
+        #log.debug "EXAMPLES"
+        return if has_exclude_tags?(examples[:tags].map { |t| t[:name].gsub(/^@/, '') })
+        example = YARD::CodeObjects::Cucumber::ScenarioOutline::Examples.new(:keyword => examples[:keyword],
+                                                                             :name => examples[:name],
+                                                                             :line => examples[:location][:line],
+                                                                             :comments => examples[:comments] ? examples.comments.map{|comment| comment.value}.join("\n") : '',
+                                                                             :rows => [],
+                                                                             :tags => [],
+                                                                             :scenario => outline )
+
+        unless !examples[:tags].any?
+          examples[:tags].each {|example_tag| find_or_create_tag(example_tag[:name], example)}
+        end
+
+        example.rows = [examples[:tableHeader][:cells].map{ |c| c[:value] }] if examples[:tableHeader]
+        example.rows += matrix(examples[:tableBody]) if examples[:tableBody]
+
+        # add the example to the step containers list of examples
+
+        @step_container.examples << example
+
+        # For each example data row we want to generate a new scenario using our
+        # current scenario as the template.
+
+        example.data.length.times do |row_index|
+
+          # Generate a copy of the scenario.
+
+          scenario = YARD::CodeObjects::Cucumber::Scenario.new(@step_container,"example_#{@step_container.scenarios.length + 1}") do |s|
+            s.comments = @step_container.comments
+            s.description = @step_container.description
+            s.add_file(@file,@step_container.line_number)
+            s.keyword = @step_container.keyword
+            s.value = "#{@step_container.value} (#{@step_container.scenarios.length + 1})"
+          end
+
+          # Generate a copy of the scenario steps.
+
+          @step_container.steps.each do |step|
+            step_instance = YARD::CodeObjects::Cucumber::Step.new(scenario,step.line_number.to_s) do |s|
+              s.keyword = step.keyword.dup
+              s.value = step.value.dup
+              s.add_file(@file,step.line_number)
+
+              s.text = step.text.dup if step.has_text?
+              s.table = clone_table(step.table) if step.has_table?
+            end
+
+            # Look at the particular data for the example row and do a simple
+            # find and replace of the <key> with the associated values.
+
+            example.values_for_row(row_index).each do |key,text|
+              text ||= "" #handle empty cells in the example table
+              step_instance.value.gsub!("<#{key}>",text)
+              step_instance.text.gsub!("<#{key}>",text) if step_instance.has_text?
+              step_instance.table.each{|row| row.each{|col| col.gsub!("<#{key}>",text)}} if step_instance.has_table?
+            end
+
+            # Connect these steps that we created to the scenario we created
+            # and then add the steps to the scenario created.
+
+            step_instance.scenario = scenario
+            scenario.steps << step_instance
+          end
+
+          # Add the scenario to the list of scenarios maintained by the  feature
+          # and add the feature to the scenario
+
+          scenario.feature = @feature
+          @step_container.scenarios << scenario
+
+        end
+
+        return example
+      end
+
+      #
+      # Called when a step is found. The step is refered to a table owner, though
+      # not all steps have a table or multliline arguments associated with them.
+      #
+      # If a multiline string is present with the step it is included as the text
+      # of the step. If the step has a table it is added to the step using the
+      # same method used by the Cucumber Gherkin model.
+      #
+      def step(step)
+        #log.debug "STEP"
+
+        @table_owner = YARD::CodeObjects::Cucumber::Step.new(@step_container,"#{step[:location][:line]}") do |s|
+          s.keyword = step[:keyword]
+          s.value = step[:text]
+          s.add_file(@file,step[:location][:line])
+        end
+
+        @table_owner.comments = step[:comments] ? step[:comments].map{|comment| comment.value}.join("\n") : ''
+
+        multiline_arg = step[:argument]
+
+        case(multiline_arg[:type])
+        when :DocString
+          @table_owner.text = multiline_arg[:content]
+        when :DataTable
+          #log.info "Matrix: #{matrix(multiline_arg).collect{|row| row.collect{|cell| cell.class } }.flatten.join("\n")}"
+          @table_owner.table = matrix(multiline_arg[:rows])
+        end if multiline_arg
+
+        @table_owner.scenario = @step_container
+        @step_container.steps << @table_owner
+      end
+
+      # Defined in the cucumber version so left here. No events for the end-of-file
+      def eof
+      end
+
+      # When a syntax error were to occurr. This parser is not interested in errors
+      def syntax_error(state, event, legal_events, line)
+        # raise "SYNTAX ERROR"
+      end
+
+      private
+      def matrix(gherkin_table)
+        gherkin_table.map {|gherkin_row| gherkin_row[:cells].map{ |cell| cell[:value] } }
+      end
+
+      #
+      # This helper method is used to deteremine what class is the current
+      # Gherkin class.
+      #
+      # @return [Class] the class that is the current supported Gherkin Model
+      #     for multiline strings. Prior to Gherkin 2.4.0 this was the PyString
+      #     class. As of Gherkin 2.4.0 it is the DocString class.
+      def gherkin_multiline_string_class
+        if defined?(Gherkin::Formatter::Model::PyString)
+          Gherkin::Formatter::Model::PyString
+        elsif defined?(Gherkin::Formatter::Model::DocString)
+          Gherkin::Formatter::Model::DocString
+        else
+          raise "Unable to find a suitable class in the Gherkin Library to parse the multiline step data."
+        end
+      end
+
+      def clone_table(base)
+        base.map {|row| row.map {|cell| cell.dup }}
+      end
+
+      def has_exclude_tags?(tags)
+        if YARD::Config.options["yard-gherkin-turnip"] and YARD::Config.options["yard-gherkin-turnip"]["exclude_tags"]
+          return true unless (YARD::Config.options["yard-gherkin-turnip"]["exclude_tags"] & tags).empty?
+        end
+      end
+
+    end
+  end
+end