turnip 3.0.0.pre.beta.1 → 3.0.0.pre.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8425f714759628ba119de6a3d1c4f8d7b8822c1
-  data.tar.gz: 342a721605fd9f29e0812962c1abbd7f98d5eaa7
+  metadata.gz: c0b502b56a65a996d87ad7262b06c8f2766a6f76
+  data.tar.gz: 8d2895b87e0b01423729ae4cae984765325856f5
 SHA512:
-  metadata.gz: 83c07693eb5d083086cbd570532566e3bbcdbce60b5114f57091612b2d4dc1ec25b46794d9c5603eee547a4167eaad555d6cc9969a8bac2e53941455b51ad649
-  data.tar.gz: 2116eac308a84e0d4119f26fef894dafd9fcfbf11d34671297bf50920268e8b4a2102da61aeae8b43396a1c4a1fad0f16847b23aa45ccba2575367461059ba64
+  metadata.gz: 8f1b62c64c693630465be6b58f6997ef4a231356c3024a8a6c99f28ced4b11113610413e271e859f2e137cbb99e6517ee365a77b04e5d31d9b8200e0c80fb3f4
+  data.tar.gz: 8f818d8d209117f591738fc92e223039c029685fec002ddd7333e59e305229b7573fd47873061b5b6be60174bb98e0edbadf97ba6815757071b3e29285fb3e04

data/lib/turnip/builder.rb

@@ -1,138 +1,8 @@
 require "gherkin/parser"
-require "gherkin/token_scanner"
+require 'turnip/node/feature'
 
 module Turnip
   class Builder
-    module Tags
-      def tags
-        @raw[:tags].map { |tag| tag[:name].sub(/^@/, '') }
-      end
-
-      def tags_hash
-        Hash[tags.map { |t| [t.to_sym, true] }]
-      end
-
-      def metadata_hash
-        tags_hash
-      end
-    end
-
-    module Name
-      def name
-        @raw[:name]
-      end
-    end
-
-    module Line
-      def line
-        @raw[:location][:line]
-      end
-    end
-
-    module Steps
-      def steps
-        @steps ||= @raw[:steps].map do |step|
-          extra_args = []
-          if (arg = step[:argument])
-            if arg[:type] == :DataTable
-              table = Turnip::Table.new(arg[:rows].map {|r| r[:cells].map {|c| c[:value]}})
-              extra_args.push(table)
-            else
-              extra_args.push arg[:content]
-            end
-          end
-          Step.new(step[:text], extra_args, step[:location][:line], step[:keyword])
-        end
-      end
-    end
-
-    class Feature
-      include Tags
-      include Name
-      include Line
-
-      attr_reader :scenarios, :backgrounds
-      attr_accessor :feature_tag
-
-      def initialize(raw)
-        @raw = raw
-        @scenarios = []
-        @backgrounds = []
-      end
-
-      def metadata_hash
-        super.merge(:type => Turnip.type, :turnip => true)
-      end
-    end
-
-    class Background
-      include Steps
-
-      def initialize(raw)
-        @raw = raw
-      end
-    end
-
-    class Scenario
-      include Tags
-      include Name
-      include Line
-      include Steps
-
-      attr_writer :steps
-
-      def initialize(raw)
-        @raw = raw
-      end
-    end
-
-    class ScenarioOutline
-      include Tags
-      include Name
-      include Steps
-
-      def initialize(raw)
-        @raw = raw
-      end
-
-      def to_scenarios
-        return [] unless @raw[:examples]
-        @raw[:examples].map { |example|
-          headers = example[:tableHeader][:cells].map {|c| c[:value]}
-          rows = example[:tableBody].map {|r| r[:cells].map {|c| c[:value]}}
-          rows.map do |row|
-            Scenario.new(@raw).tap do |scenario|
-              scenario.steps = steps.map do |step|
-                new_description = substitute(step.description, headers, row)
-                new_extra_args = step.extra_args.map do |ea|
-                  case ea
-                  when String
-                    substitute(ea, headers, row)
-                  when Turnip::Table
-                    Turnip::Table.new(ea.map {|t_row| t_row.map {|t_col| substitute(t_col, headers, row) } })
-                  else
-                    ea
-                  end
-                end
-                Step.new(new_description, new_extra_args, step.line, step.keyword)
-              end
-            end
-          end
-        }.flatten
-      end
-
-      private
-
-      def substitute(text, headers, row)
-        text.gsub(/<([^>]*)>/) { |_| Hash[headers.zip(row)][$1] }
-      end
-    end
-
-    class Step < Struct.new(:description, :extra_args, :line, :keyword)
-      def to_s
-        "#{keyword}#{description}"
-      end
-    end
 
     attr_reader :features
 
@@ -152,19 +22,8 @@ module Turnip
 
     def build(attributes)
       return unless attributes[:feature]
-      attr = attributes[:feature]
-      feature = Feature.new(attr)
-      attr[:children].each do |child|
-        case child[:type]
-        when :Background
-          feature.backgrounds << Background.new(child)
-        when :Scenario
-          feature.scenarios << Scenario.new(child)
-        else
-          feature.scenarios.push(*ScenarioOutline.new(child).to_scenarios)
-        end
-      end
-      @features << feature
+
+      @features << Node::Feature.new(attributes[:feature])
     end
   end
 end

data/lib/turnip/execute.rb

@@ -1,10 +1,13 @@
 module Turnip
   module Execute
     def step(step_or_description, *extra_args)
-      if step_or_description.respond_to?(:extra_args)
+
+      if step_or_description.respond_to?(:argument) # Turnip::Node::Step
         description = step_or_description.description
-        extra_args.concat(step_or_description.extra_args)
-      else
+        if step_or_description.argument
+          extra_args << step_or_description.argument
+        end
+      else # String
         description = step_or_description
       end
 

data/lib/turnip/node/background.rb

@@ -0,0 +1,19 @@
+require 'turnip/node/scenario_definition'
+
+module Turnip
+  module Node
+    #
+    # @note Background metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Background,
+    #       location: { line: 10, column: 3 },
+    #       keyword: "Background",
+    #       name: "Background Description",
+    #       steps: []
+    #     }
+    #
+    class Background < ScenarioDefinition
+    end
+  end
+end

data/lib/turnip/node/base.rb

@@ -0,0 +1,15 @@
+require 'turnip/node/location'
+
+module Turnip
+  module Node
+    class Base
+      include HasLocation
+
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+    end
+  end
+end

data/lib/turnip/node/example.rb

@@ -0,0 +1,65 @@
+require 'turnip/node/base'
+require 'turnip/node/tag'
+
+module Turnip
+  module Node
+    #
+    # @note Example metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Examples,
+    #       tags: [], # Array of Tag
+    #       location: { line: 10, column: 3 },
+    #       keyword: "Examples",
+    #       name: "Example Description",
+    #       tableHeader: {},
+    #       tableBody: {}
+    #     }
+    #
+    class Example < Base
+      include HasTags
+
+      def keyword
+        @raw[:keyword]
+      end
+
+      def name
+        @raw[:name]
+      end
+
+      def description
+        @raw[:description]
+      end
+
+      #
+      # @note
+      #
+      #   Examples:
+      #   | monster | hp |
+      #   | slime   | 10 | => [ 'monster', 'hp' ]
+      #   | daemon  | 70 |
+      #
+      # @return [Array]
+      #
+      def header
+        @header ||= @raw[:tableHeader][:cells].map { |c| c[:value] }
+      end
+
+      #
+      # @note
+      #
+      #   Examples:
+      #   | monster | hp |
+      #   | slime   | 10 | => [ ['slime', '10'], ['daemon', '70'] ]
+      #   | daemon  | 70 |
+      #
+      # @return [Array]
+      #
+      def rows
+        @rows ||= @raw[:tableBody].map do |row|
+          row[:cells].map { |c| c[:value] }
+        end
+      end
+    end
+  end
+end

data/lib/turnip/node/feature.rb

@@ -0,0 +1,77 @@
+require 'turnip/node/base'
+require 'turnip/node/tag'
+require 'turnip/node/scenario'
+require 'turnip/node/scenario_outline'
+require 'turnip/node/background'
+
+module Turnip
+  module Node
+    #
+    # @note Feature metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Feature,
+    #       tags: [], # Array of Tag
+    #       location: { line: 10, column: 3 },
+    #       language: 'en',
+    #       keyword: 'Feature',
+    #       name: 'Feature name',
+    #       description: 'Feature description',
+    #       children: [], # Array of Background, Scenario and Scenario Outline
+    #     }
+    #
+    class Feature < Base
+      include HasTags
+
+      def name
+        @raw[:name]
+      end
+
+      def language
+        @raw[:language]
+      end
+
+      def keyword
+        @raw[:keyword]
+      end
+
+      def description
+        @raw[:description]
+      end
+
+      def children
+        @children ||= @raw[:children].map do |c|
+          case c[:type]
+          when :Background
+            Background.new(c)
+          when :Scenario
+            Scenario.new(c)
+          when :ScenarioOutline
+            ScenarioOutline.new(c)
+          end
+        end.compact
+      end
+
+      def backgrounds
+        @backgrounds ||= children.select do |c|
+          c.is_a?(Background)
+        end
+      end
+
+      def scenarios
+        @scenarios ||= children.map do |c|
+          case c
+          when Scenario
+            c
+          when ScenarioOutline
+            c.to_scenarios
+          end
+        end.flatten.compact
+      end
+
+      def metadata_hash
+        super.merge(:type => Turnip.type, :turnip => true)
+      end
+    end
+  end
+end

data/lib/turnip/node/location.rb

@@ -0,0 +1,34 @@
+module Turnip
+  module Node
+    #
+    # @note Location metadata generated by Gherkin
+    #
+    #     {
+    #       line: 10,
+    #       column: 3
+    #     }
+    #
+    class Location
+      attr_reader :line,
+                  :column
+
+      def initialize(line, column)
+        @line = line
+        @column = column
+      end
+    end
+
+    module HasLocation
+      #
+      # @return [Location]
+      #
+      def location
+        @location ||= Location.new(@raw[:location][:line], @raw[:location][:column])
+      end
+
+      def line
+        location.line
+      end
+    end
+  end
+end

data/lib/turnip/node/scenario.rb

@@ -0,0 +1,22 @@
+require 'turnip/node/scenario_definition'
+require 'turnip/node/tag'
+
+module Turnip
+  module Node
+    #
+    # @note Scenario metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Scenario,
+    #       tags: [], # Array of Tag
+    #       location: { line: 10, column: 3 },
+    #       keyword: "Scenario",
+    #       name: "Scenario Description",
+    #       steps: []
+    #     }
+    #
+    class Scenario < ScenarioDefinition
+      include HasTags
+    end
+  end
+end

data/lib/turnip/node/scenario_definition.rb

@@ -0,0 +1,26 @@
+require 'turnip/node/base'
+require 'turnip/node/step'
+
+module Turnip
+  module Node
+    class ScenarioDefinition < Base
+      def name
+        @raw[:name]
+      end
+
+      def keyword
+        @raw[:keyword]
+      end
+
+      def description
+        @raw[:description]
+      end
+
+      def steps
+        @steps ||= @raw[:steps].map do |step|
+          Step.new(step)
+        end
+      end
+    end
+  end
+end

data/lib/turnip/node/scenario_outline.rb

@@ -0,0 +1,151 @@
+require 'turnip/node/scenario_definition'
+require 'turnip/node/tag'
+require 'turnip/node/example'
+
+module Turnip
+  module Node
+    #
+    # @note ScenarioOutline metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Scenario,
+    #       tags: [], # Array of Tag
+    #       location: { line: 10, column: 3 },
+    #       keyword: "Scenario Outline",
+    #       name: "Scenario Outline Description",
+    #       steps: []
+    #     }
+    #
+    class ScenarioOutline < ScenarioDefinition
+      include HasTags
+
+      def examples
+        @examples ||= @raw[:examples].map do |raw|
+          Example.new(raw)
+        end
+      end
+
+      #
+      # Return array of Scenario
+      #
+      # @note
+      #
+      #    example:
+      #
+      #      Scenario Outline: Test
+      #        Then I go to <where>
+      #
+      #        Examples:
+      #          | where   |
+      #          | bank    |
+      #          | airport |
+      #
+      #      to
+      #
+      #      Scenario: Test
+      #        Then I go to bank
+      #
+      #      Scenario: Test
+      #        Then I go to airport
+      #
+      # @return  [Array]
+      #
+      def to_scenarios
+        return [] if examples.nil?
+
+        @scenarios ||= examples.map do |example|
+          header = example.header
+
+          example.rows.map do |row|
+            metadata = convert_metadata_to_scenario
+
+            #
+            # Replace <placeholder> using Example values
+            #
+            metadata[:steps].each do |step|
+              step[:text] = substitute(step[:text], header, row)
+
+              next if step[:argument].nil?
+
+              case step[:argument][:type]
+              when :DocString
+                step[:argument][:content] = substitute(step[:argument][:content], header, row)
+              when :DataTable
+                step[:argument][:rows].map do |table_row|
+                  table_row[:cells].map do |cell|
+                    cell[:value] = substitute(cell[:value], header, row)
+                  end
+                end
+              end
+            end
+
+            Scenario.new(metadata)
+          end
+        end.flatten.compact
+      end
+
+      private
+
+      #
+      # Convert ScenariOutline metadata for Scenario
+      #
+      # @example:
+      #
+      #     {
+      #       "type": "ScenarioOutline",
+      #       "tags": ['tag'],
+      #       "location": {'loc'},
+      #       "keyword": "Scenario Outline",
+      #       "name": "...",
+      #       "steps": [],
+      #       "examples": []
+      #     }
+      #
+      #     to
+      #
+      #     {
+      #       "type": "Scenario",
+      #       "tags": ['tag'],
+      #       "location": {'loc'},
+      #       "keyword": "Scenario",
+      #       "name": "...",
+      #       "steps": []
+      #     }
+      #
+      # @note At this method, placeholder of step text is not replaced yet
+      #
+      # @todo :keyword is not considered a language (en only)
+      # @return  [Hash]
+      #
+      def convert_metadata_to_scenario()
+        # deep copy
+        Marshal.load(Marshal.dump(raw)).tap do |new_raw|
+          new_raw.delete(:examples)
+          new_raw[:type] = :Scenario
+          new_raw[:keyword] = 'Scenario'
+        end
+      end
+
+      #
+      # Replace placeholder `<..>`
+      #
+      # @example:
+      #
+      #    text = 'There is a <monster> that has <hp> hitpoints.'
+      #    header = ['monster', 'hp']
+      #    row = ['slime', '10']
+      #
+      #    substitute(text, header, row)
+      #    # => 'There is a slime that has 10 hitpoints.'
+      #
+      # @param  text    [String]
+      # @param  header  [Array]
+      # @param  row     [Array]
+      # @return [String]
+      #
+      def substitute(text, header, row)
+        text.gsub(/<([^>]*)>/) { |_| Hash[header.zip(row)][$1] }
+      end
+    end
+  end
+end

data/lib/turnip/node/step.rb

@@ -0,0 +1,64 @@
+require 'turnip/node/base'
+require 'turnip/table'
+
+module Turnip
+  module Node
+    #
+    # @note Step metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Step,
+    #       location: { line: 10, column: 3 },
+    #       keyword: 'Step',
+    #       text: 'Step description',
+    #       argument: {}, # DocString or DataTable
+    #     }
+    #
+    class Step < Base
+      def keyword
+        @raw[:keyword]
+      end
+
+      def text
+        @raw[:text]
+      end
+
+      #
+      # Backward compatibility
+      #
+      def description
+        text
+      end
+
+      def argument
+        return nil if @raw[:argument].nil?
+
+        @argument ||= case @raw[:argument][:type]
+                      when :DocString
+                        doc_string(@raw[:argument])
+                      when :DataTable
+                        data_table(@raw[:argument])
+                      end
+      end
+
+      def to_s
+        "#{keyword}#{text}"
+      end
+
+      private
+
+      def doc_string(doc)
+        doc[:content]
+      end
+
+      def data_table(table)
+        rows = table[:rows].map do |row|
+          row[:cells].map do |cell|
+            cell[:value]
+          end
+        end
+        Turnip::Table.new(rows)
+      end
+    end
+  end
+end

data/lib/turnip/node/tag.rb

@@ -0,0 +1,40 @@
+require 'turnip/node/base'
+
+module Turnip
+  module Node
+    #
+    # @note Location metadata generated by Gherkin
+    #
+    #     {
+    #       type: :Tag,
+    #       location: { line: 10, column: 3 },
+    #       name: '@tag'
+    #     }
+    #
+    class Tag < Base
+      def name
+        @name ||= @raw[:name].gsub(/^@/, '')
+      end
+    end
+
+    module HasTags
+      #
+      # @return [Array] Array of Tag
+      #
+      def tags
+        @tags ||= @raw[:tags].map do |tag|
+          Tag.new(tag)
+        end
+      end
+
+      #
+      # Convert for hash to be used in RSpec
+      #
+      # @return  [Hash]
+      #
+      def metadata_hash
+        Hash[tags.map { |t| [t.name.to_sym, true] }]
+      end
+    end
+  end
+end

data/lib/turnip/version.rb

@@ -1,3 +1,3 @@
 module Turnip
-  VERSION = '3.0.0-beta.1'
+  VERSION = '3.0.0-beta.2'
 end

data/spec/builder_spec.rb

@@ -66,10 +66,10 @@ describe Turnip::Builder do
         "I attack the monster and do 13 points damage",
         "the monster should be dead"
       ])
-      table = feature.scenarios[0].steps[0].extra_args.find {|a| a.instance_of?(Turnip::Table)}
-      table.hashes[0]['hit_points'].should == '10'
-      table = feature.scenarios[1].steps[0].extra_args.find {|a| a.instance_of?(Turnip::Table)}
-      table.hashes[0]['hit_points'].should == '8'
+      table = feature.scenarios[0].steps[0].argument
+      table.hashes[0]['hit_points'].should eq '10'
+      table = feature.scenarios[1].steps[0].argument
+      table.hashes[0]['hit_points'].should eq '8'
     end
   end
 
@@ -83,7 +83,7 @@ describe Turnip::Builder do
         'the monster introduced himself:'
       ])
 
-      multiline = steps[1].extra_args.first
+      multiline = steps[1].argument
       multiline.should eq %q(Ahhhhhhh! i'm "John Smith"!)
     end
   end

data/spec/define_and_execute_spec.rb

@@ -41,13 +41,13 @@ describe Turnip::Execute do
   end
 
   it "can be executed with a builder step" do
-    builder_step = double(:description => "a cool step", :extra_args => [])
+    builder_step = double(:description => "a cool step", :argument => nil)
     mod.step("a :test step") { |test| test.upcase }
     obj.step(builder_step).should == "COOL"
   end
 
   it "sends in extra arg from a builder step" do
-    builder_step = double(:description => "a cool step", :extra_args => ["foo"])
+    builder_step = double(:description => "a cool step", :argument => "foo")
     mod.step("a :test step") { |test, foo| test.upcase + foo }
     obj.step(builder_step).should == "COOLfoo"
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turnip
 version: !ruby/object:Gem::Version
-  version: 3.0.0.pre.beta.1
+  version: 3.0.0.pre.beta.2
 platform: ruby
 authors:
 - Jonas Nicklas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2016-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -122,6 +122,16 @@ files:
 - lib/turnip/define.rb
 - lib/turnip/dsl.rb
 - lib/turnip/execute.rb
+- lib/turnip/node/background.rb
+- lib/turnip/node/base.rb
+- lib/turnip/node/example.rb
+- lib/turnip/node/feature.rb
+- lib/turnip/node/location.rb
+- lib/turnip/node/scenario.rb
+- lib/turnip/node/scenario_definition.rb
+- lib/turnip/node/scenario_outline.rb
+- lib/turnip/node/step.rb
+- lib/turnip/node/tag.rb
 - lib/turnip/placeholder.rb
 - lib/turnip/rspec.rb
 - lib/turnip/step_definition.rb