turnip_formatter 0.0.1 → 0.0.2

data/lib/turnip_formatter/ext/turnip/rspec.rb

@@ -17,21 +17,20 @@ module Turnip
       end
 
       def initialize_scenario_metadata
-        example.metadata[:steps] = {
-          descriptions: [],
-          docstrings: [],
-          keywords: [],
-          tags: [],
-        }
+        example.metadata[:turnip] = { steps: [] }
       end
 
       def push_scenario_metadata(scenario)
         steps = scenario.steps
-        example.metadata[:steps].tap do |meta|
-          meta[:descriptions] += steps.map(&:description)
-          meta[:docstrings]   += steps.map(&:extra_args)
-          meta[:keywords]     += steps.map(&:keyword)
-          meta[:tags]          = scenario.tags if scenario.respond_to?(:tags)
+        example.metadata[:turnip].tap do |turnip|
+          steps.each do |step|
+            turnip[:steps] << {
+              name: step.description,
+              extra_args: step.extra_args,
+              keyword: step.keyword
+            }
+          end
+          turnip[:tags] = scenario.tags if scenario.respond_to?(:tags)
         end
       end
     end

data/lib/turnip_formatter/scenario/failure.rb

@@ -11,19 +11,15 @@ module TurnipFormatter
 
     class Failure
       include TurnipFormatter::Scenario
-      include RSpec::Core::BacktraceFormatter
 
       def steps
         steps = super
-        steps[offending_line].tap do |step|
-          step.extend TurnipFormatter::Step::Failure
-          step.attention(exception, backtrace)
-        end
+        steps[offending_line].extend TurnipFormatter::Step::Failure
         steps
       end
 
       def validation
-        raise NotFailedScenarioError if (status != 'failed')
+        raise NotFailedScenarioError if status != 'failed'
         offending_line
         super
       end
@@ -31,17 +27,11 @@ module TurnipFormatter
       private
 
       def offending_line
-        unless backtrace.last =~ /:in step:(?<stepno>\d+) `/
+        unless example.exception.backtrace.last =~ /:in step:(?<stepno>\d+) `/
           raise NoExistFailedStepInformationError
         end
         $~[:stepno].to_i
       end
-
-      def backtrace
-        @backtrace ||= format_backtrace(exception.backtrace, scenario.metadata).map do |b|
-          backtrace_line(b)
-        end.compact
-      end
     end
   end
 end

data/lib/turnip_formatter/scenario/pending.rb

@@ -13,10 +13,7 @@ module TurnipFormatter
 
       def steps
         steps = super
-        steps[offending_line].tap do |step|
-          step.extend TurnipFormatter::Step::Pending
-          step.attention(pending_message, scenario.location)
-        end
+        steps[offending_line].extend TurnipFormatter::Step::Pending
         steps
       end
 
@@ -29,9 +26,15 @@ module TurnipFormatter
       private
 
       def offending_line
-        raise NoExistPendingStepInformationError unless pending_message =~ /^No such step\((?<stepno>\d+)\): /
+        unless pending_message =~ /^No such step\((?<stepno>\d+)\): /
+          raise NoExistPendingStepInformationError
+        end
         $~[:stepno].to_i
       end
+
+      def pending_message
+        example.execution_result[:pending_message]
+      end
     end
   end
 end

data/lib/turnip_formatter/scenario.rb

@@ -4,6 +4,8 @@ require 'turnip_formatter/step'
 
 module TurnipFormatter
   module Scenario
+    include RSpec::Core::BacktraceFormatter
+
     class NotExistStepsInformationError < ::StandardError; end
     class NoFeatureFileError < ::StandardError; end
 
@@ -11,53 +13,62 @@ module TurnipFormatter
     # @param  [RSpec::Core::Example]  example
     #
     def initialize(example)
-      @scenario = example
+      @example = example
+      clean_backtrace
     end
 
     def validation
-      raise NotExistStepsInformationError unless scenario.metadata.member?(:steps)
+      raise NotExistStepsInformationError unless example.metadata.member?(:turnip)
       raise NoFeatureFileError unless feature_file_path.end_with?('.feature')
     end
 
     def steps
-      descriptions.map { |desc| TurnipFormatter::Step.new(desc) }
-    end
-
-    def method_missing(name, *args, &block)
-      if scenario.execution_result.member?(name.to_sym)
-        scenario.execution_result[name.to_sym]
-      else
-        super
+      @steps ||= descriptions.map do |desc|
+        TurnipFormatter::Step.new(example, desc)
       end
     end
-
+    
+    #
+    # @return  [String] scenario name
+    #
     def name
-      scenario.example_group.description
+      example.example_group.description
+    end
+
+    #
+    # @return  [String] scenario status ('passed', 'failed' or 'pending')
+    #
+    def status
+      example.execution_result[:status]
     end
 
     def feature_name
-      @scenario.example_group.metadata[:example_group][:example_group][:description]
+      example.example_group.metadata[:example_group][:example_group][:description]
     end
 
     def feature_file_path
-      scenario.metadata[:file_path]
+      example.metadata[:file_path]
     end
 
     def tags
-      scenario.metadata[:steps][:tags]
+      example.metadata[:turnip][:tags]
+    end
+
+    def example
+      @example
     end
 
     private
 
-    def scenario
-      @scenario
+    def descriptions
+      example.metadata[:turnip][:steps]
     end
 
-    def descriptions
-      descriptions = scenario.metadata[:steps][:descriptions]
-      keywords = scenario.metadata[:steps][:keywords]
-      docstrings = scenario.metadata[:steps][:docstrings]
-      descriptions.zip(keywords, docstrings)
+    def clean_backtrace
+      return if example.exception.nil?
+      formatted = format_backtrace(example.exception.backtrace, example.metadata)
+      new_backtrace = formatted.map { |b| backtrace_line(b) }.compact
+      example.exception.set_backtrace(new_backtrace)
     end
   end
 end

data/lib/turnip_formatter/step/dsl.rb

@@ -0,0 +1,18 @@
+module TurnipFormatter
+  class Step
+    module DSL
+      #
+      # @param [TurnipFormatter::Step]  step
+      #
+      def extended(step)
+        ::TurnipFormatter::Step.templates[status].each do |style, block|
+          step.docs[style] = step.instance_eval(&block)
+        end
+      end
+
+      def add_template(style, &block)
+        ::TurnipFormatter::Step.add_template(status, style, &block)
+      end
+    end
+  end
+end

data/lib/turnip_formatter/step/failure.rb

@@ -1,21 +1,27 @@
 # -*- coding: utf-8 -*-
+require 'turnip_formatter/step'
+require 'turnip_formatter/step/dsl'
 
 module TurnipFormatter
   class Step
     module Failure
-      def attention?
-        true
-      end
-
-      def attention(exception, backtrace)
-        exception.set_backtrace(backtrace)
-        docs[:source]    = backtrace.first
-        docs[:exception] = exception
+      extend DSL
+      
+      def self.status
+        :failure
       end
 
       def status
-        'failure'
+        Failure.status
       end
     end
   end
 end
+
+TurnipFormatter::Step::Failure.add_template :source do
+  example.exception.backtrace.first
+end
+
+TurnipFormatter::Step::Failure.add_template :exception do
+  example.exception
+end

data/lib/turnip_formatter/step/pending.rb

@@ -1,21 +1,26 @@
 # -*- coding: utf-8 -*-
+require 'turnip_formatter/step'
+require 'turnip_formatter/step/dsl'
 
 module TurnipFormatter
   class Step
     module Pending
-      def attention?
-        true
-      end
+      extend DSL
 
-      def attention(message, location)
-        exception = RSpec::Core::Pending::PendingDeclaredInExample.new(message)
-        exception.set_backtrace(location)
-        docs[:exception] = exception
+      def self.status
+        :pending
       end
 
       def status
-        'pending'
+        Pending.status
       end
     end
   end
 end
+
+TurnipFormatter::Step::Pending.add_template :exception do
+  message = example.execution_result[:pending_message]
+  exception = RSpec::Core::Pending::PendingDeclaredInExample.new(message)
+  exception.set_backtrace(example.location)
+  exception
+end

data/lib/turnip_formatter/step.rb

@@ -2,17 +2,39 @@
 
 module TurnipFormatter
   class Step
-    attr_reader :name, :docs
+    attr_reader :name, :docs, :example
 
-    def initialize(description)
-      step_name, keyword, docstring = description
-      @name = keyword + step_name
-      @docs = {}
-      @docs[:extra_args] = docstring unless docstring.empty?
+    class << self
+      def templates
+        @templates ||= {}
+      end
+
+      def add_template(status, style, &block)
+        templates[status] ||= {}
+        templates[status][style] = block
+      end
+
+      def status
+        ''
+      end
+    end
+
+    #
+    # @param  [RSpec::Core::Example]  example
+    # @param  [Hash]  description
+    #
+    def initialize(example, description)
+      @example = example
+      @name = description[:keyword] + description[:name]
+      @docs = { extra_args: description[:extra_args] }
     end
 
     def attention?
-      false
+      !status.empty?
+    end
+
+    def status
+      self.class.status
     end
   end
 end

data/lib/turnip_formatter/template/step_exception.rb

@@ -0,0 +1,28 @@
+require 'erb'
+
+module TurnipFormatter
+  class Template
+    module StepException
+      def self.build(exception)
+        template_step_exception.result(binding)
+      end
+
+    private
+
+      def self.template_step_exception
+        @template_step_exception ||= ERB.new(<<-EOS)
+          <div class="step_exception">
+            <span>Failure:</span>
+            <pre><%= ERB::Util.h(exception.to_s) %></pre>
+            <span>Backtrace:</span>
+            <ol>
+              <% exception.backtrace.each do |line| %>
+              <li><%= ERB::Util.h(line) %></li>
+              <% end %>
+            </ol>
+          </div>
+        EOS
+      end
+    end
+  end
+end

data/lib/turnip_formatter/template/step_multiline.rb

@@ -0,0 +1,11 @@
+require 'erb'
+
+module TurnipFormatter
+  class Template
+    module StepMultiline
+      def self.build(lines)
+        '<pre class="multiline">' + ERB::Util.h(lines) + '</pre>'
+      end
+    end
+  end
+end

data/lib/turnip_formatter/template/step_outline.rb

@@ -0,0 +1,27 @@
+require 'erb'
+
+module TurnipFormatter
+  class Template
+    module StepOutline
+      def self.build(table)
+        template_step_outline.result(binding)
+      end
+
+    private
+
+      def self.template_step_outline
+        @template_step_outline ||= ERB.new(<<-EOS)
+        <table class="step_outline">
+        <% table.each do |tr| %>
+          <tr>
+            <% tr.each do |td| %>
+            <td><%= ERB::Util.h(td) %></td>
+            <% end %>
+          </tr>
+        <% end %>
+        </table>
+        EOS
+      end
+    end
+  end
+end

data/lib/turnip_formatter/template/step_source.rb

@@ -0,0 +1,12 @@
+require 'erb'
+
+module TurnipFormatter
+  class Template
+    module StepSource
+      def self.build(location)
+        @snippet_extractor ||= ::RSpec::Core::Formatters::SnippetExtractor.new
+        '<pre class="source"><code class="ruby">' + @snippet_extractor.snippet([location]) + '</code></pre>'
+      end
+    end
+  end
+end

data/lib/turnip_formatter/template.rb

@@ -8,6 +8,11 @@ module TurnipFormatter
     include ERB::Util
     include RSpec::Core::BacktraceFormatter
 
+    autoload :StepOutline,   'turnip_formatter/template/step_outline'
+    autoload :StepMultiline, 'turnip_formatter/template/step_multiline'
+    autoload :StepSource,    'turnip_formatter/template/step_source'
+    autoload :StepException, 'turnip_formatter/template/step_exception'
+
     def print_header
       <<-EOS
         <!DOCTYPE html>
@@ -59,7 +64,6 @@ module TurnipFormatter
     end
 
     def print_runtime_error(example, exception)
-      
       if example.exception
         example_backtrace = format_backtrace(example.exception.backtrace[0..14], example.metadata).map do |l|
           RSpec::Core::Metadata::relative_path(l)
@@ -89,38 +93,26 @@ module TurnipFormatter
     end
 
     def step_args(step)
-      args = []
-      [:extra_args, :source, :exception].each do |k|
-        args << send("step_#{k}", step.docs[k]) unless step.docs[k].nil?
-      end
-      args.join("\n")
-    end
+      output = []
 
-    def step_extra_args(extra_args)
-      extra_args.map do |arg|
-        if arg.instance_of?(Turnip::Table)
-          step_outline(arg)
+      step.docs.each do |style, value|
+        if style == :extra_args
+          output << step_extra_args(value)
         else
-          step_multiline(arg)
+          # call StepException, StepSource, etc...
+          klass = ['step', style.to_s].map(&:capitalize).join
+          output << self.class.const_get(klass).build(value)
         end
-      end.join("\n")
-    end
-
-    def step_outline(table)
-      template_step_outline.result(binding)
-    end
-
-    def step_multiline(lines)
-      '<pre class="multiline">' + h(lines) + '</pre>'
-    end
+      end
 
-    def step_source(location)
-      @snippet_extractor ||= ::RSpec::Core::Formatters::SnippetExtractor.new
-      '<pre class="source"><code class="ruby">' + @snippet_extractor.snippet([location]) + '</code></pre>'
+      output.join("\n")
     end
 
-    def step_exception(exception)
-      template_step_exception.result(binding)
+    def step_extra_args(extra_args)
+      extra_args.map do |arg|
+        klass = arg.instance_of?(Turnip::Table) ? StepOutline : StepMultiline
+        klass.build(arg)
+      end.join("\n")
     end
 
     def report_area
@@ -177,35 +169,6 @@ module TurnipFormatter
       EOS
     end
 
-    def template_step_outline
-      @template_step_outline ||= ERB.new(<<-EOS)
-        <table class="step_outline">
-          <% table.each do |tr| %>
-          <tr>
-            <% tr.each do |td| %>
-            <td><%= h(td) %></td>
-            <% end %>
-          </tr>
-          <% end %>
-        </table>
-      EOS
-    end
-
-    def template_step_exception
-      @template_step_exception ||= ERB.new(<<-EOS)
-        <div class="step_exception">
-          <span>Failure:</span>
-          <pre><%= h(exception.to_s) %></pre>
-          <span>Backtrace:</span>
-          <ol>
-            <% exception.backtrace.each do |line| %>
-            <li><%= h(line) %></li>
-            <% end %>
-          </ol>
-        </div>
-      EOS
-    end
-
     def template_exception
       @template_exception ||= ERB.new(<<-EOS)
         <section class="exception">

data/lib/turnip_formatter/version.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 
 module TurnipFormatter
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/examples/README.md

@@ -60,7 +60,9 @@ Scenario: strong monster
       And Fanfare
 ```
 
-![Pending step](https://github.com/gongo/turnip_formatter/raw/master/spec/examples/images/pending_and_tagged_step.png)
+![Pending step](https://github.com/gongo/turnip_formatter/raw/master/spec/examples/images/pending_step.png)
+
+![Tag step](https://github.com/gongo/turnip_formatter/raw/master/spec/examples/images/tag_step.png)
 
 ### Background
 

data/spec/rspec/core/formatters/turnip_formatter_spec.rb

@@ -3,16 +3,10 @@ require 'stringio'
 
 module RSpec::Core::Formatters
   describe TurnipFormatter do
+    include_context 'turnip_formatter passed scenario metadata'
+
     let(:feature) { RSpec::Core::ExampleGroup.describe('Feature') }
     let(:scenario) { feature.describe('Scenario') }
-
-    let(:scenario_metadata) do
-      {
-        steps: { descriptions: [], docstrings: [[]], keywords: ['When'], tags: [] },
-        file_path: '/path/to/hoge.feature'
-      }
-    end
-
     let(:output) { StringIO.new }
     let(:formatter) { TurnipFormatter.new(output) }
 
@@ -26,7 +20,7 @@ module RSpec::Core::Formatters
 
     describe '#example_passed' do
       it 'should be output passed scenario section' do
-        scenario.example('passed', scenario_metadata) { expect(true).to be_true }
+        scenario.example('passed', metadata) { expect(true).to be_true }
         feature.run(formatter)
 
         string = output.string
@@ -36,11 +30,14 @@ module RSpec::Core::Formatters
 
     describe '#example_failed' do
       let(:failed_metadata) do
-        scenario_metadata.dup.tap do |metadata|
-          metadata[:steps][:descriptions] << 'this step is error'
-          metadata[:steps][:docstrings] << []
-          metadata[:steps][:keywords] << 'Given'
+        metadata[:turnip][:steps].tap do |steps|
+          steps << {
+            name: 'this step is error',
+            extra_args: [],
+            keyword: 'Given'
+          }
         end
+        metadata
       end
 
       it 'should be output failed scenario section' do
@@ -52,6 +49,7 @@ module RSpec::Core::Formatters
             raise e
           end
         end
+
         feature.run(formatter)
         expect(output.string).to match 'class="scenario failed"'
       end
@@ -59,11 +57,14 @@ module RSpec::Core::Formatters
 
     describe '#example_pending' do
       let(:pending_metadata) do
-        scenario_metadata.dup.tap do |metadata|
-          metadata[:steps][:descriptions] << 'this step is unimplement'
-          metadata[:steps][:docstrings] << []
-          metadata[:steps][:keywords] << 'Given'
+        metadata[:turnip][:steps].tap do |steps|
+          steps << {
+            name: 'this step is unimplement',
+            extra_args: [],
+            keyword: 'Given'
+          }
         end
+        metadata
       end
 
       it 'should be output pending scenario section' do

data/spec/support/shared_context_examples.rb

@@ -10,8 +10,17 @@ end
 shared_context 'turnip_formatter passed scenario metadata' do
   let(:metadata) do
     {
-      steps: { descriptions: ['Step 1'], docstrings: [[]], keywords: ['When'], tags: [] },
+      turnip: {
+        steps: [ { name: 'Step 1', extra_args: [], keyword: 'When' } ],
+        tags: []
+      },
       file_path: '/path/to/hoge.feature'
     }
   end
 end
+
+shared_context 'turnip_formatter standard step parameters' do
+  let(:description) do
+    { name: 'StepName', keyword: 'Keyword', extra_args: ['Docstring'] }
+  end
+end

data/spec/turnip_formatter/scenario/pass_spec.rb

@@ -8,31 +8,18 @@ module TurnipFormatter::Scenario
       expect(true).to be_true
     }
 
-    context 'Turnip example' do
-      let(:metadata) do
-        {
-          steps: { descriptions: ['Step 1'], docstrings: [[]], keywords: ['When'], tags: [] },
-          file_path: '/path/to/hoge.feature'
-        }
-      end
+    include_context 'turnip_formatter passed scenario metadata'
 
+    context 'Turnip example' do
       describe '#validation' do
         it 'should not raise exception' do
           expect { scenario.validation }.not_to raise_error
         end
       end
-
     end
 
     context 'Not Turnip example' do
       context 'Not passed example' do
-        let(:metadata) do
-          {
-            steps: { descriptions: ['Step 1'], docstrings: [[]], keywords: ['When'], tags: [] },
-            file_path: '/path/to/hoge.feature'
-          }
-        end
-
         include_context 'turnip_formatter scenario setup', proc {
           expect(true).to be_false
         }
@@ -46,10 +33,9 @@ module TurnipFormatter::Scenario
 
       context 'not exist feature file' do
         let(:metadata) do
-          {
-            steps: { descriptions: ['Step 1'], docstrings: [[]], keywords: ['When'], tags: [] },
-            file_path: '/path/to/hoge.rb'
-          }
+          metadata = super()
+          metadata[:file_path] = '/path/to/hoge.rb'
+          metadata
         end
 
         describe '#validation' do

data/spec/turnip_formatter/step/failure_spec.rb

@@ -3,38 +3,26 @@ require 'spec_helper'
 module TurnipFormatter
   class Step
     describe Failure do
-      let(:description) { ['StepName', 'Keyword', ['Docstring']] }
-      let(:step) { ::TurnipFormatter::Step.new(description) }
-      let(:failure_step) { step.dup.extend TurnipFormatter::Step::Failure }      
+      include_context 'turnip_formatter standard step parameters'
+      include_context 'turnip_formatter scenario setup', proc {
+        expect(true).to be_false
+      }
+      include_context 'turnip_formatter passed scenario metadata'
+
+      let(:step) do
+        step = ::TurnipFormatter::Step.new(example, description)
+        step.extend TurnipFormatter::Step::Failure
+        step
+      end
 
       describe '#attention?' do
-        subject { failure_step.attention? }
+        subject { step.attention? }
         it { should be_true }
       end
 
       describe '#status' do
-        subject { failure_step.status }
-        it { should eq 'failure' }
-      end
-
-      describe '#attention' do
-        it 'should have been implemented' do
-          expect(step).not_to respond_to(:attention)
-          expect(failure_step).to respond_to(:attention)
-        end
-
-        it 'should set exception informaton' do
-          exception = StandardError.new
-          expect(exception.backtrace).to be_nil
-
-          failure_step.attention(exception, ['/path/to/error.rb: 10'])
-
-          expect(failure_step.docs[:source]).to eq '/path/to/error.rb: 10'
-          failure_step.docs[:exception].tap do |e|
-            expect(e).to eql(exception)
-            expect(e.backtrace.first).to eq '/path/to/error.rb: 10'
-          end
-        end
+        subject { step.status }
+        it { should eq :failure }
       end
     end
   end

data/spec/turnip_formatter/step/pending_spec.rb

@@ -3,25 +3,24 @@ require 'spec_helper'
 module TurnipFormatter
   class Step
     describe Failure do
-      let(:description) { ['StepName', 'Keyword', ['Docstring']] }
-      let(:step) { ::TurnipFormatter::Step.new(description) }
-      let(:pending_step) { step.dup.extend TurnipFormatter::Step::Pending }
+      include_context 'turnip_formatter standard step parameters'
+      include_context 'turnip_formatter scenario setup'
+      include_context 'turnip_formatter passed scenario metadata'
+
+      let(:step) do
+        step = ::TurnipFormatter::Step.new(example, description)
+        step.extend TurnipFormatter::Step::Pending
+        step
+      end
 
       describe '#attention?' do
-        subject { pending_step.attention? }
+        subject { step.attention? }
         it { should be_true }
       end
 
       describe '#status' do
-        subject { pending_step.status }
-        it { should eq 'pending' }
-      end
-
-      describe '#attention' do
-        it 'should have been implemented' do
-          expect(step).not_to respond_to(:attention)
-          expect(pending_step).to respond_to(:attention)
-        end
+        subject { step.status }
+        it { should eq :pending }
       end
     end
   end

data/spec/turnip_formatter/step_spec.rb

@@ -2,8 +2,10 @@ require 'spec_helper'
 
 module TurnipFormatter
   describe Step do
-    let(:step) { ::TurnipFormatter::Step.new(description) }
-    let(:description) { ['StepName', 'Keyword', ['Docstring']] }
+    include_context 'turnip_formatter standard step parameters'
+    include_context 'turnip_formatter scenario setup'
+    include_context 'turnip_formatter passed scenario metadata'
+    let(:step) { ::TurnipFormatter::Step.new(example, description) }
 
     describe '#attention?' do
       subject { step.attention? }
@@ -19,14 +21,5 @@ module TurnipFormatter
       subject { step.docs }
       it { should include :extra_args }
     end
-
-    context 'No docstring' do
-      let(:description) { ['StepName', 'Keyword', []] }
-
-      describe '#docs' do
-        subject { step.docs }
-        it { should_not include :extra_args }
-      end      
-    end
   end
 end

data/spec/turnip_formatter/template/step_exception_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'turnip_formatter/template/step_exception'
+
+module TurnipFormatter
+  class Template
+    describe StepException do
+      let(:template) { ::TurnipFormatter::Template::StepException }
+      let(:exception) do
+        StandardError.new('StepExceptionError').tap do |e|
+          e.set_backtrace('/path/to/error.rb: 10')
+        end
+      end
+
+      describe '.build' do
+        subject { template.build(exception) }
+        it do
+          should match %r{div class="step_exception"}
+          should match %r{<pre>.*#{exception.message}.*</pre>}
+          should match %r{<li>/path/to/error.rb: 10</li>}
+        end
+      end
+    end
+  end
+end

data/spec/turnip_formatter/template/step_multiline_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'turnip_formatter/template/step_multiline'
+
+module TurnipFormatter
+  class Template
+    describe StepMultiline do
+      let(:template) { ::TurnipFormatter::Template::StepMultiline }
+      let(:string) { 'a<a>a' }
+
+      describe '.build' do
+        subject { template.build(string) }
+        it { should eq '<pre class="multiline">a&lt;a&gt;a</pre>' }
+      end
+    end
+  end
+end

data/spec/turnip_formatter/template/step_outline_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'turnip/table'
+require 'turnip_formatter/template/step_outline'
+
+module TurnipFormatter
+  class Template
+    describe StepOutline do
+      let(:template) { ::TurnipFormatter::Template::StepOutline }
+
+      let(:string) do
+        ::Turnip::Table.new([
+            ["State", "Money"],
+            ["<Tokushima>", "555"],
+            ["<Okinawa>", "368"]
+          ])
+      end
+
+      describe '.build' do
+        subject { template.build(string) }
+
+        it do
+          should match %r{<td>State</td>[[:space:]]+<td>Money</td>}
+          should match %r{<td>&lt;Tokushima&gt;</td>[[:space:]]+<td>555</td>}
+          should match %r{<td>&lt;Okinawa&gt;</td>[[:space:]]+<td>368</td>}
+        end
+      end
+    end
+  end
+end

data/spec/turnip_formatter/template/step_source_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'turnip_formatter/template/step_source'
+
+module TurnipFormatter
+  class Template
+    describe StepSource do
+      let(:template) { ::TurnipFormatter::Template::StepSource }
+      let(:source) { __FILE__ + ':1' }
+
+      describe '.build' do
+        subject { template.build(source) }
+        it do
+          should match '<pre class="source"><code class="ruby">'
+          should match "require 'turnip_formatter/template/step_source'"
+        end
+      end
+    end
+  end
+end

data/spec/turnip_formatter/template_spec.rb

@@ -57,34 +57,29 @@ module TurnipFormatter
     
     context 'Step has arguments' do
       describe '#step_args' do
-        let(:template_stub) do
-          template.stub(:step_extra_args).and_return('extra_args')
-          template.stub(:step_source).and_return('source')
-          template.stub(:step_exception).and_return('exception')
-          template
-        end
+        let(:table) { Turnip::Table.new [] }
 
         let(:step) do
           step = double
-          step.stub(:docs).and_return(extra_args: 'a', source: 'b', exception: 'c')
+          step.stub(:docs).and_return(
+            extra_args: ['a', table], source: 'b', exception: 'c'
+          )
           step
         end
         
         it 'should call corresponding method in step' do
-          expect(template_stub.send(:step_args, step)).to eq("extra_args\nsource\nexception")
+          Template::StepMultiline.should_receive(:build).with('a').and_return('extra_args1')
+          Template::StepOutline.should_receive(:build).with(table).and_return('extra_args2')
+          Template::StepSource.should_receive(:build).with('b').and_return('source')
+          Template::StepException.should_receive(:build).with('c').and_return('exception')
+
+          expect(template.send(:step_args, step)).to eq("extra_args1\nextra_args2\nsource\nexception")
         end
       end
     end
 
     context 'Step has no argument' do
       describe '#step_args' do
-        let(:template_stub) do
-          template.should_not_receive(:step_extra_args)
-          template.should_not_receive(:step_source)
-          template.should_not_receive(:step_exception)
-          template
-        end
-
         let(:step) do
           step = double
           step.stub(:docs).and_return({})
@@ -92,7 +87,12 @@ module TurnipFormatter
         end
 
         it 'should get null string' do
-          expect(template_stub.send(:step_args, step)).to be_empty
+          Template::StepOutline.should_not_receive(:build)
+          Template::StepMultiline.should_not_receive(:build)
+          Template::StepSource.should_not_receive(:build)
+          Template::StepException.should_not_receive(:build)
+
+          expect(template.send(:step_args, step)).to be_empty
         end
       end
     end
@@ -105,56 +105,17 @@ module TurnipFormatter
         end
       end
 
-      let(:extra_args_1) do
+      let(:extra_args) do
         [::Turnip::Table.new([['a']]), 'b']
       end
 
-      let(:extra_args_2) do
-        []
+      before do
+        Template::StepOutline.should_receive(:build).and_return('outline')
+        Template::StepMultiline.should_receive(:build).and_return('multiline')
       end
 
       it 'should get string converted from extra_args' do
-        expect(template_stub.send(:step_extra_args, extra_args_1)).to eq("outline\nmultiline")
-        expect(template_stub.send(:step_extra_args, extra_args_2)).to be_empty
-      end
-    end
-
-    describe '#step_outline' do
-      let(:outline) {
-        ::Turnip::Table.new([
-            ["State", "Money"],
-            ["<Tokushima>", "555"],
-            ["<Okinawa>", "368"]
-          ])
-      }
-
-      it 'should get string converted to <table>' do
-        html = template.send(:step_outline, outline)
-        expect(html).to match %r{<td>State</td>[[:space:]]+<td>Money</td>}
-        expect(html).to match %r{<td>&lt;Tokushima&gt;</td>[[:space:]]+<td>555</td>}
-        expect(html).to match %r{<td>&lt;Okinawa&gt;</td>[[:space:]]+<td>368</td>}
-      end
-    end
-
-    describe '#step_multiline' do
-      it 'should get escaped string enclosed in <pre>' do
-        html = template.send(:step_multiline, 'a<a>a')
-        expect(html).to eq('<pre class="multiline">a&lt;a&gt;a</pre>')
-      end
-    end
-
-    describe '#step_exception' do
-      let(:exception) do
-        StandardError.new('StepExceptionError').tap do |e|
-          e.set_backtrace('/path/to/error.rb: 10')
-        end
-      end
-
-      it 'should get string Exception class name and backtrace' do
-        html = template.send(:step_exception, exception)
-        expect(html).to match %r{div class="step_exception"}
-        expect(html).to match %r{<pre>.*#{exception.message}.*</pre>}
-        expect(html).to match %r{<li>/path/to/error.rb: 10</li>}
+        expect(template_stub.send(:step_extra_args, extra_args)).to eq("outline\nmultiline")
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turnip_formatter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2013-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: turnip
@@ -117,9 +117,14 @@ files:
 - lib/turnip_formatter/scenario/pass.rb
 - lib/turnip_formatter/scenario/pending.rb
 - lib/turnip_formatter/step.rb
+- lib/turnip_formatter/step/dsl.rb
 - lib/turnip_formatter/step/failure.rb
 - lib/turnip_formatter/step/pending.rb
 - lib/turnip_formatter/template.rb
+- lib/turnip_formatter/template/step_exception.rb
+- lib/turnip_formatter/template/step_multiline.rb
+- lib/turnip_formatter/template/step_outline.rb
+- lib/turnip_formatter/template/step_source.rb
 - lib/turnip_formatter/version.rb
 - spec/examples/README.md
 - spec/examples/features/battle.feature
@@ -131,7 +136,8 @@ files:
 - spec/examples/images/failed_step.png
 - spec/examples/images/multiline.png
 - spec/examples/images/outline.png
-- spec/examples/images/pending_and_tagged_step.png
+- spec/examples/images/pending_step.png
+- spec/examples/images/tag_step.png
 - spec/examples/spec_helper.rb
 - spec/examples/steps/spell_steps.rb
 - spec/examples/steps/steps.rb
@@ -145,6 +151,10 @@ files:
 - spec/turnip_formatter/step/failure_spec.rb
 - spec/turnip_formatter/step/pending_spec.rb
 - spec/turnip_formatter/step_spec.rb
+- spec/turnip_formatter/template/step_exception_spec.rb
+- spec/turnip_formatter/template/step_multiline_spec.rb
+- spec/turnip_formatter/template/step_outline_spec.rb
+- spec/turnip_formatter/template/step_source_spec.rb
 - spec/turnip_formatter/template_spec.rb
 - turnip_formatter.gemspec
 homepage: https://github.com/gongo/turnip_formatter
@@ -162,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 420008365
+      hash: -3424310081992899473
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -171,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 420008365
+      hash: -3424310081992899473
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -189,7 +199,8 @@ test_files:
 - spec/examples/images/failed_step.png
 - spec/examples/images/multiline.png
 - spec/examples/images/outline.png
-- spec/examples/images/pending_and_tagged_step.png
+- spec/examples/images/pending_step.png
+- spec/examples/images/tag_step.png
 - spec/examples/spec_helper.rb
 - spec/examples/steps/spell_steps.rb
 - spec/examples/steps/steps.rb
@@ -203,4 +214,8 @@ test_files:
 - spec/turnip_formatter/step/failure_spec.rb
 - spec/turnip_formatter/step/pending_spec.rb
 - spec/turnip_formatter/step_spec.rb
+- spec/turnip_formatter/template/step_exception_spec.rb
+- spec/turnip_formatter/template/step_multiline_spec.rb
+- spec/turnip_formatter/template/step_outline_spec.rb
+- spec/turnip_formatter/template/step_source_spec.rb
 - spec/turnip_formatter/template_spec.rb