turnip_formatter 0.6.0.pre.beta.6 → 0.6.0.pre.beta.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 726f004501517755e0b9d76679bd329a6db43265
-  data.tar.gz: 0b024a138f3bcb88e0ca4fcc8e63d86d55b71935
+  metadata.gz: 03749d6d53a310780fc1e2595f537e7b35a9e73a
+  data.tar.gz: 1739d0a736c12f0e10b46c35192f2e0a321d1e7a
 SHA512:
-  metadata.gz: 62233a172b7fe3e78a7d7bb4c8c07ecc0773d744335c88debdfa2e8eff859e9a9b866184d7b783cbd46c537b23d6bee2cdd89949ac3d05d3de03f20eebe50364
-  data.tar.gz: bd5f739958168d28d624c6c40304f0115a3971ddf9feede29b230daa5300398ec1fb4e9fa173a9178c8b1b33888557018ff0a1c7b0e26e6e86756256b3f4e7ee
+  metadata.gz: a4b88812e427868f23695be4f9285afccf0970790521056e7f390669186a9e721ee94f033f9a5f51c9ca7ca7bdf85cb1e782c2d948c39c1a10ca6a6a72ab9a83
+  data.tar.gz: d9e4560bf2e3030a53842fa430a6e944714696a65e6ff8f0bfa1679a8e2f09a1aafcb00ef4811083b04dfb1e0892ce08a5af841f55829ed48cf933e4f2e062c0

data/.travis.yml

@@ -17,7 +17,7 @@ rvm:
   - 2.2
   - 2.3.0
   - ruby-head
-  - jruby-9.0.0.0
+  - jruby-9.0.5.0
 
 script:
   - bundle exec rake test

data/example/spec/features/basic.feature

@@ -15,6 +15,20 @@ Feature: Battle a monster
      Then it should die
       And Fanfare
 
+  @aggregate_failures
+  Scenario: [ERROR] boss monster (aggregate_failures)
+
+    Even if error occurs during steps, test will run to the end
+
+    Given there is a boss monster
+     When I attack it
+     Then it should die
+     When I attack it
+     Then it should die
+     When I attack it
+     Then it should die
+      And Fanfare
+
   Scenario: [PENDING] spell magic
 
     This scenario will not success because he can't cast spell

data/example/spec/spec_helper.rb

@@ -8,7 +8,17 @@ Dir.glob(File.dirname(__FILE__) + '/steps/**/*steps.rb') { |f| load f, true }
 
 RSpec.configure do |config|
   config.before(:example, before_hook_error: true) do
-    undefined_method # NameError
+    #
+    # Workaround for JRuby <= 9.1.7.0
+    #
+    # https://github.com/jruby/jruby/issues/4467
+    # https://github.com/rspec/rspec-core/pull/2381
+    #
+    begin
+      undefined_method # NameError
+    rescue => e
+      raise e
+    end
   end
 
   config.after(:example, after_hook_error: true) do

data/lib/turnip_formatter/renderer/html/step.rb

@@ -28,7 +28,7 @@ module TurnipFormatter
 
         def extra_information
           extra_information_templates.map do |template, method|
-            template.send(method, @resource.example)
+            template.send(method, @resource)
           end.join("\n")
         end
 

data/lib/turnip_formatter/resource/scenario/base.rb

@@ -1,5 +1,6 @@
 require 'forwardable'
-require 'turnip_formatter/resource/step'
+require 'turnip_formatter/resource/step/pass'
+require 'turnip_formatter/resource/step/unexecute'
 
 module TurnipFormatter
   module Resource
@@ -17,12 +18,6 @@ module TurnipFormatter
           @example = example
         end
 
-        def steps
-          @steps ||= (backgrounds.map(&:steps).flatten + raw.steps).map do |step|
-            TurnipFormatter::Resource::Step.new(example, step)
-          end
-        end
-
         def id
           'scenario_' + object_id.to_s
         end
@@ -58,6 +53,10 @@ module TurnipFormatter
           example.metadata[:turnip_formatter][:feature]
         end
 
+        def raw_steps
+          backgrounds.map(&:steps).flatten + raw.steps
+        end
+
         private
 
         def raw

data/lib/turnip_formatter/resource/scenario/failure.rb

@@ -1,12 +1,12 @@
 require 'turnip_formatter/resource/scenario/base'
-require 'turnip_formatter/resource/hook'
+require 'turnip_formatter/resource/step/failure'
+require 'turnip_formatter/resource/step/hook'
+require 'rspec/core/formatters/exception_presenter'
 
 module TurnipFormatter
   module Resource
     module Scenario
       class Failure < Base
-        alias :super_steps :steps
-
         #
         # Return steps
         #
@@ -17,99 +17,127 @@ module TurnipFormatter
         #    And baz  <= failed line
         #   Then piyo
         #
-        #   #<Step 'foo'>.status = :passed
-        #   #<Step 'bar'>.status = :passed
-        #   #<Step 'baz'>.status = :failed
-        #   #<Step 'piyo'>.status = :unexecute
-        #
-        # @TODO Correspond to multiple errors.
-        #
-        # example:
-        #
-        #   # foo.feature
-        #   @after_hook
-        #   When foo
-        #    And bar  <= failed line
-        #   Then baz
-        #
-        #   # spec_helper.rb
-        #   RSpec.configure do |config|
-        #     config.after(:example, after_hook: true) do
-        #       raise RuntimeError
-        #     end
-        #   end
-        #
-        # Currently, display only first error (`And bar`).
+        #   # => [
+        #   #   <Step::Pass 'foo'>
+        #   #   <Step::Pass 'bar'>
+        #   #   <Step::Failure 'baz'>
+        #   #   <Step::Unexecute 'piyo'>
+        #   # ]
         #
         def steps
-          case
-          when error_in_steps?
-            steps_with_error
-          when error_in_before_hook?
-            steps_with_error_in_before_hook
-          when error_in_after_hook?
-            steps_with_error_in_after_hook
+          exceptions = all_exception_group_by_line_number
+
+          if exceptions.has_key?(:before)
+            return steps_with_error_in_before_hook(exceptions[:before])
+          end
+
+          steps = steps_with_error(exceptions)
+
+          if exceptions.has_key?(:after)
+            return steps_with_error_in_after_hook(steps, exceptions[:after])
           end
+
+          steps
         end
 
         private
 
-        def steps_with_error
-          steps = super_steps
+        def steps_with_error(exceptions)
+          step_klass = TurnipFormatter::Resource::Step::Pass
 
-          arys = steps.group_by { |s| (s.line <=> failed_line_number).to_s }
-          arys['-1'].each { |s| s.status = :passed    } unless arys['-1'].nil?
-          arys['0'].each  { |s| s.status = :failed    } unless arys['0'].nil?
-          arys['1'].each  { |s| s.status = :unexecute } unless arys['1'].nil?
+          raw_steps.map do |rs|
+            ex = exceptions[rs.line]
+            next step_klass.new(example, rs) unless ex
 
-          steps
+            # The status of step after error step is determined by `aggregate_failures` option
+            if example.metadata[:aggregate_failures]
+              step_klass = TurnipFormatter::Resource::Step::Pass
+            else
+              step_klass = TurnipFormatter::Resource::Step::Unexecute
+            end
+
+            TurnipFormatter::Resource::Step::Failure.new(example, rs).tap do |step|
+              step.set_exceptions(ex)
+            end
+          end
         end
 
-        def steps_with_error_in_before_hook
-          steps = super_steps
+        def steps_with_error_in_before_hook(exceptions)
+          before_step = TurnipFormatter::Resource::Step::BeforeHook.new(example)
+          before_step.set_exceptions(exceptions)
+
+          after_steps = raw_steps.map do |rs|
+            TurnipFormatter::Resource::Step::Unexecute.new(example, rs)
+          end
 
-          steps.each { |s| s.status = :unexecute }
-          [TurnipFormatter::Resource::Hook.new(example, 'BeforeHook', :failed)] + steps
+          [before_step] + after_steps
         end
 
-        def steps_with_error_in_after_hook
-          super_steps + [TurnipFormatter::Resource::Hook.new(example, 'AfterHook', :failed)]
+        def steps_with_error_in_after_hook(steps, exceptions)
+          after_step = TurnipFormatter::Resource::Step::AfterHook.new(example)
+          after_step.set_exceptions(exceptions)
+
+          steps + [after_step]
         end
 
-        def error_in_steps?
-          !failed_line_number.nil?
+        def error_in_before_hook?(exceptions)
+          exceptions.has_key?(:before)
         end
 
-        def error_in_before_hook?
-          exception.backtrace.any? do |backtrace|
-            backtrace.match(/run_before_example/)
+        def error_in_after_hook?(exceptions)
+          exceptions.has_key?(:after)
+        end
+
+        def all_exception_group_by_line_number
+          all_exception(example.exception).group_by do |e|
+            line = failed_line_number(e)
+            next line unless line.nil?
+
+            case
+            when occurred_in_before_hook?(e)
+              :before
+            when occurred_in_after_hook?(e)
+              :after
+            end
           end
         end
 
-        def error_in_after_hook?
-          exception.backtrace.any? do |backtrace|
-            backtrace.match(/run_after_example/)
+        def all_exception(exception)
+          unless exception.class.include?(RSpec::Core::MultipleExceptionError::InterfaceTag)
+            return [exception]
+          end
+
+          exception.all_exceptions.flat_map do |e|
+            all_exception(e)
           end
         end
 
-        def failed_line_number
-          @failed_line_number ||= (
-            filepath = File.basename(feature_file_path)
-            line = exception.backtrace.find do |backtrace|
-              backtrace.match(/#{filepath}:(\d+)/)
-            end
-            Regexp.last_match[1].to_i if line
-          )
+        def failed_line_number(exception)
+          filepath = File.basename(feature_file_path)
+          method = if RUBY_PLATFORM == 'java'
+                     '<eval>'
+                   else
+                     'run_step'
+                   end
+          method = Regexp.escape(method)
+
+          line = exception.backtrace.find do |backtrace|
+            backtrace.match(/#{filepath}:(\d+):in `#{method}'/)
+          end
+
+          Regexp.last_match[1].to_i if line
         end
 
-        def exception
-          @exception ||= (
-            if example.exception.is_a?(RSpec::Core::MultipleExceptionError)
-              example.exception.all_exceptions.first
-            else
-              example.exception
-            end
-          )
+        def occurred_in_before_hook?(exception)
+          exception.backtrace.any? do |backtrace|
+            backtrace.match(/run_before_example/)
+          end
+        end
+
+        def occurred_in_after_hook?(exception)
+          exception.backtrace.any? do |backtrace|
+            backtrace.match(/run_after_example/)
+          end
         end
       end
     end

data/lib/turnip_formatter/resource/scenario/pass.rb

@@ -4,6 +4,11 @@ module TurnipFormatter
   module Resource
     module Scenario
       class Pass < Base
+        def steps
+          raw_steps.map do |rs|
+            TurnipFormatter::Resource::Step::Pass.new(example, rs)
+          end
+        end
       end
     end
   end

data/lib/turnip_formatter/resource/scenario/pending.rb

@@ -1,4 +1,5 @@
 require 'turnip_formatter/resource/scenario/base'
+require 'turnip_formatter/resource/step/pending'
 
 module TurnipFormatter
   module Resource
@@ -14,21 +15,25 @@ module TurnipFormatter
         #    And baz  <= pending line
         #   Then piyo
         #
-        #   #<Step 'foo'>.status = :passed
-        #   #<Step 'bar'>.status = :passed
-        #   #<Step 'baz'>.status = :pending
-        #   #<Step 'piyo'>.status = :unexecute
+        #   # => [
+        #   #   <Step::Pass 'foo'>
+        #   #   <Step::Pass 'bar'>
+        #   #   <Step::Pending 'baz'>
+        #   #   <Step::Unexecute 'piyo'>
+        #   # ]
         #
         def steps
-          steps = super
+          raw_steps.map do |rs|
+            if rs.line < pending_line_number
+              klass = TurnipFormatter::Resource::Step::Pass
+            elsif rs.line == pending_line_number
+              klass = TurnipFormatter::Resource::Step::Pending
+            else
+              klass = TurnipFormatter::Resource::Step::Unexecute
+            end
 
-          arys = steps.group_by { |s| (s.line <=> pending_line_number).to_s }
-
-          arys['-1'].each { |s| s.status = :passed    } unless arys['-1'].nil?
-          arys['0'].each  { |s| s.status = :pending   } unless arys['0'].nil?
-          arys['1'].each  { |s| s.status = :unexecute } unless arys['1'].nil?
-
-          steps
+            klass.new(example, rs)
+          end
         end
 
         private

data/lib/turnip_formatter/resource/step/base.rb

@@ -0,0 +1,24 @@
+require 'forwardable'
+
+module TurnipFormatter
+  module Resource
+    module Step
+      class Base
+        extend Forwardable
+        def_delegators :@raw, :keyword, :text, :line, :argument
+
+        attr_reader :example
+        attr_accessor :status
+
+        #
+        # @param  [RSpec::Core::Example]  example
+        # @param  [Turnip::Node::Step]    raw
+        #
+        def initialize(example, raw)
+          @example = example
+          @raw = raw
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/resource/step/failure.rb

@@ -0,0 +1,27 @@
+require 'turnip_formatter/resource/step/base'
+
+module TurnipFormatter
+  module Resource
+    module Step
+      class Failure < Base
+        attr_reader :exceptions
+
+        def initialize(example, raw)
+          super
+          @exceptions = []
+        end
+
+        def status
+          :failed
+        end
+
+        #
+        # @param  [Array<Exception>]  exceptions
+        #
+        def set_exceptions(exceptions)
+          @exceptions = exceptions
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/resource/step/hook.rb

@@ -0,0 +1,50 @@
+module TurnipFormatter
+  module Resource
+    module Step
+      class HookBase
+        attr_reader :example
+        attr_reader :exceptions
+
+        #
+        # @param  [RSpec::Core::Example]  example
+        #
+        def initialize(example)
+          @example = example
+          @exceptions = []
+        end
+
+        def set_exceptions(exceptions)
+          @exceptions = exceptions
+        end
+
+        def status
+          :failed
+        end
+
+        def text
+          ''
+        end
+
+        def line
+          -1
+        end
+
+        def argument
+          nil
+        end
+      end
+
+      class BeforeHook < HookBase
+        def keyword
+          'BeforeHook'
+        end
+      end
+
+      class AfterHook < HookBase
+        def keyword
+          'AfterHook'
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/resource/step/pass.rb

@@ -0,0 +1,13 @@
+require 'turnip_formatter/resource/step/base'
+
+module TurnipFormatter
+  module Resource
+    module Step
+      class Pass < Base
+        def status
+          :passed
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/resource/step/pending.rb

@@ -0,0 +1,21 @@
+require 'turnip_formatter/resource/step/base'
+
+module TurnipFormatter
+  module Resource
+    module Step
+      class Pending < Base
+        def status
+          :pending
+        end
+
+        def pending_message
+          example.execution_result.pending_message
+        end
+
+        def pending_location
+          example.location
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/resource/step/unexecute.rb

@@ -0,0 +1,13 @@
+require 'forwardable'
+
+module TurnipFormatter
+  module Resource
+    module Step
+      class Unexecute < Base
+        def status
+          :unexecute
+        end
+      end
+    end
+  end
+end

data/lib/turnip_formatter/step_template/base.rb

@@ -29,10 +29,6 @@ module TurnipFormatter
           ''
         end
       end
-
-      def formatted_backtrace(example, exception = nil)
-        RSpec::Core::Formatters::TurnipFormatter.formatted_backtrace(example, exception)
-      end
     end
   end
 end

data/lib/turnip_formatter/step_template/exception.html.erb

@@ -0,0 +1,21 @@
+<% exceptions.each do |e| %>
+  <div class="step_exception">
+    <dl>
+      <dt>Failure:</dt>
+      <dd>
+        <pre><%= ERB::Util.h(e[:message]) %></pre>
+      </dd>
+      <dt>Backtrace:</dt>
+      <dd>
+        <ol>
+          <% e[:backtrace].each do |line| %>
+            <li><%= ERB::Util.h(line) %></li>
+          <% end %>
+        </ol>
+      </dd>
+    </dl>
+  </div>
+  <% unless e[:code].nil? %>
+    <pre class="source"><code class="ruby"><%= e[:code] %></code></pre>
+  <% end %>
+<% end %>

data/lib/turnip_formatter/step_template/exception.rb

@@ -1,5 +1,6 @@
 require 'turnip_formatter/step_template/base'
-require 'slim'
+require 'erb'
+require 'ostruct'
 
 module TurnipFormatter
   module StepTemplate
@@ -21,37 +22,85 @@ module TurnipFormatter
               margin-top: 1em;
               margin-left: 1em;
           }
+
+          pre.source {
+              font-size: 12px;
+              font-family: monospace;
+              background-color: #073642;
+              color: #dddddd;
+          }
+
+          pre.source code.ruby {
+              padding: 0.1em 0 0.2em 0;
+          }
+
+          pre.source code.ruby .linenum {
+              width: 75px;
+              color: #fffbd3;
+              padding-right: 1em;
+          }
+
+          pre.source code.ruby .offending {
+              background-color: gray;
+          }
         EOS
       end
 
       #
-      # @param  [RSpec::Core::Example]  example
+      # @param  [TurnipFormatter::Resource::Step::Failure]  step
       #
-      def build_failed(example)
-        exception = example.exception
+      def build_failed(step)
+        datas = step.exceptions.map do |e|
+          backtrace = formatted_backtrace(step.example, e)
+          code = extractor.snippet([backtrace.first])
 
-        if example.exception.is_a?(RSpec::Core::MultipleExceptionError)
-          exception = example.exception.all_exceptions.first
+          {
+            code: code,
+            message: e.to_s,
+            backtrace: backtrace,
+          }
         end
 
-        build(exception.to_s, formatted_backtrace(example, exception))
+        render(exceptions: datas)
       end
 
       #
-      # @param  [RSpec::Core::Example]  example
+      # @param  [TurnipFormatter::Resource::Step::Pending]  step
       #
-      def build_pending(example)
-        build(example.execution_result.pending_message, [example.location])
+      def build_pending(step)
+        datas = [{
+                   code: nil,
+                   message: step.pending_message,
+                   backtrace: [step.pending_location]
+                 }]
+
+        render(exceptions: datas)
       end
 
       private
 
-      def build(message, backtrace)
-        template_step_exception.render(Object.new, { message: message, backtrace: backtrace })
+      def render(args)
+        view.result(OpenStruct.new(args).instance_eval { binding })
+      end
+
+      def view
+        @view ||= ::ERB.new(File.read(File.dirname(__FILE__) + '/exception.html.erb'))
+      end
+
+      def extractor
+        @extractor ||= begin
+                         # RSpec 3.4
+                         require 'rspec/core/formatters/html_snippet_extractor'
+                         ::RSpec::Core::Formatters::HtmlSnippetExtractor.new
+                       rescue LoadError
+                         # RSpec 3.3 or earlier
+                         require 'rspec/core/formatters/snippet_extractor'
+                         ::RSpec::Core::Formatters::SnippetExtractor.new
+                       end
       end
 
-      def template_step_exception
-        @template_step_exception ||= Slim::Template.new(File.dirname(__FILE__) + "/exception.slim")
+      def formatted_backtrace(example, exception = nil)
+        RSpec::Core::Formatters::TurnipFormatter.formatted_backtrace(example, exception)
       end
     end
   end

data/lib/turnip_formatter/version.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 
 module TurnipFormatter
-  VERSION = '0.6.0-beta.6'
+  VERSION = '0.6.0-beta.7'
 end

data/lib/turnip_formatter.rb

@@ -45,7 +45,6 @@ module TurnipFormatter
 
   require 'rspec/core/formatters/turnip_formatter'
   require 'turnip_formatter/step_template/exception'
-  require 'turnip_formatter/step_template/source'
   require 'turnip_formatter/ext/turnip/rspec'
 end
 

data/test/helper.rb

@@ -72,7 +72,17 @@ module TurnipFormatter
       rspec_context.include(ExecuteWrapper)
 
       rspec_context.before(:example, before_hook_error: true) do
-        undefined_method # NameError
+        #
+        # Workaround for JRuby <= 9.1.7.0
+        #
+        # https://github.com/jruby/jruby/issues/4467
+        # https://github.com/rspec/rspec-core/pull/2381
+        #
+        begin
+          undefined_method # NameError
+        rescue => e
+          raise e
+        end
       end
 
       rspec_context.after(:example, after_hook_error: true) do

data/test/turnip_formatter/renderer/html/test_step.rb

@@ -1,6 +1,5 @@
 require 'helper'
 require 'turnip_formatter/renderer/html/step'
-require 'turnip_formatter/resource/step'
 
 module TurnipFormatter::Renderer::Html
   class TestStep < Test::Unit::TestCase
@@ -8,7 +7,7 @@ module TurnipFormatter::Renderer::Html
 
     sub_test_case 'step without argument' do
       def setup
-        resource = TurnipFormatter::Resource::Step.new(nil, sample_step)
+        resource = TurnipFormatter::Resource::Step::Pass.new(nil, sample_step)
         @renderer = Step.new(resource)
       end
 
@@ -23,7 +22,7 @@ module TurnipFormatter::Renderer::Html
 
     sub_test_case 'step with argument' do
       def setup
-        resource = TurnipFormatter::Resource::Step.new(nil, sample_step_with_docstring)
+        resource = TurnipFormatter::Resource::Step::Pass.new(nil, sample_step_with_docstring)
         @renderer = Step.new(resource)
       end
 
@@ -37,7 +36,7 @@ module TurnipFormatter::Renderer::Html
 
     sub_test_case 'step should be escaped html style' do
       def setup
-        resource = TurnipFormatter::Resource::Step.new(nil, sample_step_should_escaping)
+        resource = TurnipFormatter::Resource::Step::Pass.new(nil, sample_step_should_escaping)
         @renderer = Step.new(resource)
       end
 

data/test/turnip_formatter/resource/scenario/test_failure.rb

@@ -6,12 +6,21 @@ module TurnipFormatter::Resource::Scenario
     include TurnipFormatter::TestHelper
 
     def test_status
-      @resource = Failure.new(scenario_example)
+      @resource = Failure.new(make_scenario(<<-EOS))
+        Scenario: This is a simple feature
+          Then [ERROR] it should die
+      EOS
+
       assert_equal(:failed, @resource.status)
     end
 
     def test_steps
-      @resource = Failure.new(scenario_example)
+      @resource = Failure.new(make_scenario(<<-EOS))
+        Scenario: This is a simple feature
+          When I attack it
+          Then [ERROR] it should die
+           And I get drop items
+      EOS
 
       expect = [:passed, :failed, :unexecute]
       actual = @resource.steps.map(&:status)
@@ -19,86 +28,78 @@ module TurnipFormatter::Resource::Scenario
       assert_equal(expect, actual)
     end
 
+    def test_steps_has_multiple_error
+      @resource = Failure.new(make_scenario(<<-EOS))
+        @aggregate_failures
+        Scenario: Error in after hook
+          When I attack it
+          Then [ERROR] it should die
+          When retry
+          Then [ERROR] it should die
+           And I get drop items
+      EOS
+
+      expect = [:passed, :failed, :passed, :failed, :passed]
+      actual = @resource.steps.map(&:status)
+
+      assert_equal(expect, actual)
+    end
+
     def test_steps_has_error_in_before_hook
-      @resource = Failure.new(scenario_error_before_hook)
+      @resource = Failure.new(make_scenario(<<-EOS))
+        @before_hook_error
+        Scenario: Error in before hook
+          When I attack it
+          Then it should die
+      EOS
 
       expect = [:failed, :unexecute, :unexecute]
       actual = @resource.steps.map(&:status)
 
       assert_equal(expect, actual)
-      assert_equal(TurnipFormatter::Resource::Hook, @resource.steps.first.class)
+      assert_equal(TurnipFormatter::Resource::Step::BeforeHook, @resource.steps.first.class)
     end
 
     def test_steps_has_error_in_after_hook
-      @resource = Failure.new(scenario_error_after_hook)
+      @resource = Failure.new(make_scenario(<<-EOS))
+        @after_hook_error
+        Scenario: Error in after hook
+          When I attack it
+          Then it should die
+      EOS
 
       expect = [:passed, :passed, :failed]
       actual = @resource.steps.map(&:status)
 
       assert_equal(expect, actual)
-      assert_equal(TurnipFormatter::Resource::Hook, @resource.steps.last.class)
+      assert_equal(TurnipFormatter::Resource::Step::AfterHook, @resource.steps.last.class)
     end
 
     def test_steps_has_error_in_steps_and_after_hook
-      @resource = Failure.new(scenario_error_step_and_after_hook)
+      @resource = Failure.new(make_scenario(<<-EOS))
+        @after_hook_error
+        Scenario: Error in after hook
+          When I attack it
+          Then [ERROR] it should die
+           And I get drop items
+      EOS
 
-      expect = [:passed, :failed, :unexecute]
+      expect = [:passed, :failed, :unexecute, :failed]
       actual = @resource.steps.map(&:status)
 
       assert_equal(expect, actual)
-      assert_equal(TurnipFormatter::Resource::Step, @resource.steps.last.class)
+      assert_equal(TurnipFormatter::Resource::Step::AfterHook, @resource.steps.last.class)
     end
 
     private
 
-    def scenario_example
-      scenario_examples[0]
-    end
-
-    def scenario_error_before_hook
-      scenario_examples[1]
-    end
-
-    def scenario_error_after_hook
-      scenario_examples[2]
-    end
-
-    def scenario_error_step_and_after_hook
-      scenario_examples[3]
-    end
-
-    def scenario_examples
-      @@scenario_examples ||= (
-        feature = feature_build(feature_text)
-        run_feature(feature, '/path/to/test.feature')
-      )
-    end
-
-    def feature_text
-      <<-EOS
+    def make_scenario(scenario_text)
+      feature_text = <<-EOS
         Feature: A simple feature
-          Scenario: This is a simple feature
-            When I attack it
-            Then [ERROR] it should die
-             And I get drop items
-
-          @before_hook_error
-          Scenario: Error in before hook
-            When I attack it
-            Then it should die
-
-          @after_hook_error
-          Scenario: Error in after hook
-            When I attack it
-            Then it should die
-
-          @after_hook_error
-          Scenario: Error in after hook
-            When I attack it
-            Then [ERROR] it should die
-             And I get drop items
-
+          #{scenario_text}
       EOS
+      feature = feature_build(feature_text)
+      run_feature(feature, '/path/to/test.feature').first
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: turnip_formatter
 version: !ruby/object:Gem::Version
-  version: 0.6.0.pre.beta.6
+  version: 0.6.0.pre.beta.7
 platform: ruby
 authors:
 - Wataru MIYAGUNI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-19 00:00:00.000000000 Z
+date: 2017-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: turnip
@@ -246,16 +246,19 @@ files:
 - lib/turnip_formatter/renderer/html/views/statistics_speed.html.erb
 - lib/turnip_formatter/renderer/html/views/statistics_tag.html.erb
 - lib/turnip_formatter/renderer/html/views/step.html.erb
-- lib/turnip_formatter/resource/hook.rb
 - lib/turnip_formatter/resource/scenario/base.rb
 - lib/turnip_formatter/resource/scenario/failure.rb
 - lib/turnip_formatter/resource/scenario/pass.rb
 - lib/turnip_formatter/resource/scenario/pending.rb
-- lib/turnip_formatter/resource/step.rb
+- lib/turnip_formatter/resource/step/base.rb
+- lib/turnip_formatter/resource/step/failure.rb
+- lib/turnip_formatter/resource/step/hook.rb
+- lib/turnip_formatter/resource/step/pass.rb
+- lib/turnip_formatter/resource/step/pending.rb
+- lib/turnip_formatter/resource/step/unexecute.rb
 - lib/turnip_formatter/step_template/base.rb
+- lib/turnip_formatter/step_template/exception.html.erb
 - lib/turnip_formatter/step_template/exception.rb
-- lib/turnip_formatter/step_template/exception.slim
-- lib/turnip_formatter/step_template/source.rb
 - lib/turnip_formatter/template.rb
 - lib/turnip_formatter/version.rb
 - spec/spec_helper.rb

data/lib/turnip_formatter/resource/hook.rb

@@ -1,30 +0,0 @@
-module TurnipFormatter
-  module Resource
-    class Hook
-      attr_reader :example
-      attr_reader :keyword
-      attr_reader :status
-
-      #
-      # @param  [RSpec::Core::Example]  example
-      #
-      def initialize(example, keyword, status)
-        @example = example
-        @keyword = keyword
-        @status = status
-      end
-
-      def text
-        ''
-      end
-
-      def line
-        -1
-      end
-
-      def argument
-        nil
-      end
-    end
-  end
-end

data/lib/turnip_formatter/resource/step.rb

@@ -1,23 +0,0 @@
-require 'forwardable'
-
-module TurnipFormatter
-  module Resource
-    class Step
-      extend Forwardable
-      def_delegators :@raw, :keyword, :text, :line, :argument
-
-      attr_reader :example
-      attr_accessor :status
-
-      #
-      # @param  [RSpec::Core::Example]  example
-      # @param  [Turnip::Node::Step]    raw
-      #
-      def initialize(example, raw)
-        @example = example
-        @raw = raw
-        @status = :passed
-      end
-    end
-  end
-end

data/lib/turnip_formatter/step_template/exception.slim

@@ -1,10 +0,0 @@
-div.step_exception
-  dl
-    dt Failure:
-    dd
-      pre= message
-    dt Backtrace:
-    dd
-      ol
-       - backtrace.each do |line|
-         li= line

data/lib/turnip_formatter/step_template/source.rb

@@ -1,63 +0,0 @@
-require 'turnip_formatter/step_template/base'
-
-module TurnipFormatter
-  module StepTemplate
-    class Source < Base
-      on_failed :build
-
-      def self.css
-        <<-EOS
-          pre.source {
-              font-size: 12px;
-              font-family: monospace;
-              background-color: #073642;
-              color: #dddddd;
-          }
-
-          pre.source code.ruby {
-              padding: 0.1em 0 0.2em 0;
-          }
-
-          pre.source code.ruby .linenum {
-              width: 75px;
-              color: #fffbd3;
-              padding-right: 1em;
-          }
-
-          pre.source code.ruby .offending {
-              background-color: gray;
-          }
-        EOS
-      end
-
-      def build(example)
-        code = extractor.snippet([location(example)])
-        '<pre class="source"><code class="ruby">' + code + '</code></pre>'
-      end
-
-      private
-
-      def location(example)
-        exception = example.exception
-
-        if example.exception.is_a?(RSpec::Core::MultipleExceptionError)
-          exception = example.exception.all_exceptions.first
-        end
-
-        formatted_backtrace(example, exception).first
-      end
-
-      def extractor
-        @extractor ||= begin
-                         # RSpec 3.4
-                         require 'rspec/core/formatters/html_snippet_extractor'
-                         ::RSpec::Core::Formatters::HtmlSnippetExtractor.new
-                       rescue LoadError
-                         # RSpec 3.3 or earlier
-                         require 'rspec/core/formatters/snippet_extractor'
-                         ::RSpec::Core::Formatters::SnippetExtractor.new
-                       end
-      end
-    end
-  end
-end