RubyGems - turnip_formatter - Versions diffs - 0.1.2 → 0.2.0 - Mend

turnip_formatter 0.1.2 → 0.2.0

Files changed (50) hide show

data/lib/turnip_formatter/template.rb CHANGED Viewed

@@ -5,16 +5,42 @@ require 'rspec/core/formatters/helpers'
 require 'turnip_formatter/template/tab/speed_statistics'
 require 'turnip_formatter/template/tab/feature_statistics'
 require 'turnip_formatter/template/tab/tag_statistics'
+require 'sass'
 module TurnipFormatter
   class Template
     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'
+    class << self
+      def add_js(js_string)
+        js_list << js_string
+      end
+      def js_render
+        js_list.join("\n")
+      end
+      def css_render
+        css_list.join("\n")
+      end
+      def add_scss(scss_string)
+        css_list << scss_compile(scss_string)
+      end
+      def js_list
+        @js_list ||= []
+      end
+      def css_list
+        @css_list ||= []
+      end
+      def scss_compile(scss)
+        Sass::Engine.new(scss, syntax: :scss).render
+      end
+    end
     def print_header
       <<-EOS
@@ -29,7 +55,8 @@ module TurnipFormatter
             <link rel="stylesheet" href="http://ajax.googleapis.com/ajax/libs/jqueryui/1.10.2/themes/smoothness/jquery-ui.css">
             <style>
-            #{File.read(File.dirname(__FILE__) + '/formatter.css')}
+              #{File.read(File.dirname(__FILE__) + '/formatter.css')}
+              #{self.class.css_render}
             </style>
             <script>
@@ -83,11 +110,13 @@ module TurnipFormatter
                            1: { sorter: false }
                        }
                    });
+                   #{self.class.js_render}
               });
             </script>
           </head>
           <body>
-            #{report_area}
+            #{print_section_report}
             <div id="main" role="main">
               <ul>
                 <li><a href="#steps-statistics">Steps</a></li>
@@ -159,27 +188,50 @@ module TurnipFormatter
     end
     def print_scenario(scenario)
-      template_scenario.result(binding)
+      render_template(:scenario, { scenario: scenario })
     end
     def print_runtime_error(example, exception)
       exception.set_backtrace(format_backtrace(exception.backtrace))
-      template_exception.result(binding)
+      render_template(:exception, { example: example, exception: exception })
     end
-    private
+    def print_exception_backtrace(e)
+      render_template(:exception_backtrace, { backtrace: e.backtrace })
+    end
+    def print_scenario_tags(scenario)
+      if scenario.tags.empty?
+        ''
+      else
+        render_template(:scenario_tags, { tags: scenario.tags })
+      end
+    end
+    def print_step_extra_args(extra_args)
+      extra_args.map do |arg|
+        if arg.instance_of?(Turnip::Table)
+          print_step_outline(arg)
+        else
+          print_step_multiline(arg)
+        end
+      end.join("\n")
+    end
-    def feature_name(scenario)
-      path = RSpec::Core::Metadata::relative_path(scenario.feature_file_path)
-      name = scenario.feature_name
-      "\"#{name}\" in #{path}"
+    def print_step_outline(table)
+      render_template(:step_outline, { table: table.to_a })
     end
-    def scenario_tags(scenario)
-      return '' if scenario.tags.empty?
-      template_scenario_tags.result(binding)
+    def print_step_multiline(lines)
+      render_template(:step_multiline, { lines: lines })
     end
+    def print_section_report
+      render_template(:section_report)
+    end
+    private
     def step_attr(step)
       attr = 'step'
       attr += " #{step.status}" if step.attention?
@@ -191,129 +243,40 @@ module TurnipFormatter
       step.docs.each do |style, template|
         if style == :extra_args
-          output << step_extra_args(template[:value])
+          output << print_step_extra_args(template[:value])
         else
-          output << step_template(style, template[:klass]).build(template[:value])
+          output << template[:klass].build(template[:value])
         end
       end
       output.join("\n")
     end
-    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 step_template(style, klass)
-      return klass if !!klass
-      # call Built-in template (StepException, StepSource, etc...)
-      klass = ['step', style.to_s].map(&:capitalize).join
-      self.class.const_get(klass)
+    #
+    # @example
+    #   render_template(:main, { name: 'user' })
+    #     # => ERB.new('/path/to/main.erb') render { name: 'user' }
+    #
+    def render_template(name, params = {})
+      render_template_list(name).result(template_params_binding(params))
     end
-    def report_area
-      <<-EOS
-        <div id="report">
-          <h1>Turnip Report</h1>
-          <section class="checkbox">
-            <label for="passed_check">Passed</label><input type="checkbox" checked id="passed_check">
-            <label for="failed_check">Failed</label><input type="checkbox" checked id="failed_check">
-            <label for="pending_check">Pending</label><input type="checkbox" checked id="pending_check">
-          </section>
-          <section class="result">
-            <p>
-              <span id="total_count"></span> Scenario (<span id="failed_count"></span> failed <span id="pending_count"></span> pending).
-            </p>
-            <p>Finished in <span id="total_time"></span></p>
-          </section>
-        </div>
-      EOS
-    end
-    def template_scenario
-      @template_scenario ||= ERB.new(<<-EOS)
-        <section class="scenario <%= h(scenario.status) %>">
-          <header>
-            <span class="permalink">
-              <a href="#<%= scenario.id %>">&para;</a>
-            </span>
-            <span class="scenario_name" id="<%= scenario.id %>">
-              Scenario: <%= h(scenario.name) %>
-            </span>
-            <span class="feature_name">
-              (Feature: <%= h(feature_name(scenario)) %>)
-              at <%= h(scenario.run_time) %> sec
-            </span>
-          </header>
-          <%= scenario_tags(scenario) %>
-          <ul class="steps">
-            <% scenario.steps.each do |step| %>
-            <li <%= step_attr(step) %>><span><%= h(step.name) %></span>
-              <div class="args"><%= step_args(step) %></div>
-            </li>
-            <% end %>
-          </ul>
-        </section>
-      EOS
-    end
+    def render_template_list(name)
+      if templates[name].nil?
+        path = File.dirname(__FILE__) + "/template/#{name.to_s}.erb"
+        templates[name] = ERB.new(File.read(path))
+      end
-    def template_scenario_tags
-      @template_scenario_tags ||= ERB.new(<<-EOS)
-        <ul class="tags">
-          <% scenario.tags.each do |tag| %>
-          <li>@<%= h(tag) %></li>
-          <% end %>
-       </ul>
-      EOS
+      templates[name]
     end
-    def template_exception
-      @template_exception ||= ERB.new(<<-EOS)
-        <section class="exception">
-          <h1>TurnipFormatter RuntimeError</h1>
-          <dl>
-            <dt>Runtime Exception</dt>
-            <dd><%= h(exception.to_s) %></dd>
-            <dt>Runtime Exception Backtrace</dt>
-            <%= template_exception_backtrace(exception) %>
-            <dt>Example Full Description</dt>
-            <dd><%= h(example.metadata[:full_description]) %></dd>
-            <% if example.exception %>
-              <dt>Example Exception</dt>
-              <dd><%= h(example.exception.to_s) %></dd>
-              <dt>Example Backtrace</dt>
-              <%= template_exception_backtrace(example.exception) %>
-            <% end %>
-            <% if example.pending %>
-              <dt>Example Pending description</dt>
-              <dd><%= h(example.metadata[:description]) %></dd>
-            <% end %>
-          </dl>
-        </section>
-      EOS
+    def template_params_binding(params)
+      code = params.keys.map { |k| "#{k} = params[#{k.inspect}];" }.join
+      eval(code + ";binding")
     end
-    def template_exception_backtrace(exception)
-      @template_exception_backtrace ||= ERB.new(<<-EOS)
-        <dd>
-          <ol>
-            <% exception.backtrace.each do |line| %>
-            <li><%= h(line) %></li>
-            <% end %>
-          </ol>
-        </dd>
-      EOS
-      @template_exception_backtrace.result(binding)
+    def templates
+      @templates ||= {}
     end
   end
 end

data/lib/turnip_formatter/version.rb CHANGED Viewed

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

data/lib/turnip_formatter.rb CHANGED Viewed

@@ -6,6 +6,7 @@ require 'turnip'
 module TurnipFormatter
   require 'rspec/core/formatters/turnip_formatter'
   require 'turnip_formatter/template'
+  require 'turnip_formatter/step_template'
   require 'turnip_formatter/ext/turnip/rspec'
   require 'turnip_formatter/ext/turnip/builder'
 end

data/spec/turnip_formatter/step/failure_spec.rb CHANGED Viewed

@@ -13,25 +13,40 @@ module TurnipFormatter
         step
       end
+      let(:klasses) do
+        builtin_klass1 = ::TurnipFormatter::StepTemplate::Source
+        builtin_klass2 = ::TurnipFormatter::StepTemplate::Exception
+        [builtin_klass1, builtin_klass2]
+      end
       it 'exists built-in step template' do
         templates = TurnipFormatter::Step::Failure.templates
-        expect(templates.keys).to eq([:source, :exception])
+        expect(templates.keys).to include(*klasses)
       end
       context 'add custom step template' do
+        let :custom_template do
+          Module.new do
+            def self.build(message)
+              '[error] ' + message
+            end
+          end
+        end
         before do
-          TurnipFormatter::Step::Failure.add_template :custom do
+          TurnipFormatter::Step::Failure.add_template(custom_template) do
             example.example_group.description
           end
         end
         after do
-          TurnipFormatter::Step::Failure.remove_template :custom
+          TurnipFormatter::Step::Failure.remove_template(custom_template)
         end
         it 'should get custom step template' do
           templates = TurnipFormatter::Step::Failure.templates
-          expect(templates.keys).to eq([:source, :exception, :custom])
+          klasses << custom_template
+          expect(templates.keys).to include(*klasses)
         end
       end

data/spec/turnip_formatter/step/pending_spec.rb CHANGED Viewed

@@ -13,25 +13,39 @@ module TurnipFormatter
         step
       end
+      let(:klasses) do
+        builtin_klass = ::TurnipFormatter::StepTemplate::Exception
+        [builtin_klass]
+      end
       it 'exists built-in step template' do
         templates = TurnipFormatter::Step::Pending.templates
-        expect(templates.keys).to eq([:exception])
+        expect(templates.keys).to include(*klasses)
       end
       context 'add custom step template' do
+        let :custom_template do
+          Module.new do
+            def self.build(message)
+              '[pending] ' + message
+            end
+          end
+        end
         before do
-          TurnipFormatter::Step::Pending.add_template :custom do
+          TurnipFormatter::Step::Pending.add_template custom_template do
             example.example_group.description
           end
         end
         after do
-          TurnipFormatter::Step::Failure.remove_template :custom
+          TurnipFormatter::Step::Failure.remove_template custom_template
         end
         it 'should get custom step template' do
           templates = TurnipFormatter::Step::Pending.templates
-          expect(templates.keys).to eq([:exception, :custom])
+          klasses << custom_template
+          expect(templates.keys).to include(*klasses)
         end
       end

data/spec/turnip_formatter/step_spec.rb CHANGED Viewed

@@ -22,8 +22,8 @@ module TurnipFormatter
       it { should include :extra_args }
     end
-    describe '#add_template' do
-      let :custom_template do
+    context 'using template' do
+      let :custom_template1 do
         Module.new do
           def self.build(hoge)
             hoge * 3
@@ -31,42 +31,55 @@ module TurnipFormatter
         end
       end
-      before do
-        TurnipFormatter::Step.add_template :hoge, :source1 do
-          'aiueo'
+      let :custom_template2 do
+        Module.new do
+          def self.build(hoge)
+            'aiueo' + hoge
+          end
         end
+      end
-        TurnipFormatter::Step.add_template :hoge, :source2, custom_template do
+      before do
+        TurnipFormatter::Step.add_template :hoge, custom_template1 do
           '12345'
         end
+        TurnipFormatter::Step.add_template :hoge, custom_template2 do
+          'abcde'
+        end
       end
       after do
-        TurnipFormatter::Step.remove_template(:hoge, :source1)
-        TurnipFormatter::Step.remove_template(:hoge, :source2)
+        TurnipFormatter::Step.remove_template(:hoge, custom_template1)
+        TurnipFormatter::Step.remove_template(:hoge, custom_template2)
       end
-      it 'can add step template' do
-        style = TurnipFormatter::Step.templates[:hoge][:source1]
-        expect(style[:block].call).to eq('aiueo')
+      describe '#add_template' do
+        it 'can add step template' do
+          style1 = TurnipFormatter::Step.templates[:hoge][custom_template1]
+          klass1 = style1[:klass]
+          block1 = style1[:block]
+          expect(klass1.build(block1.call)).to eq('123451234512345')
-        style = TurnipFormatter::Step.templates[:hoge][:source2]
-        expect(style[:klass].build(style[:block].call)).to eq('123451234512345')
+          style2 = TurnipFormatter::Step.templates[:hoge][custom_template2]
+          klass2 = style2[:klass]
+          block2 = style2[:block]
+          expect(klass2.build(block2.call)).to eq('aiueoabcde')
+        end
       end
-    end
-    describe '#remove_template' do
-      it 'can remove step template' do
-        TurnipFormatter::Step.add_template :hoge, :style1 do ; 'aiueo' end
-        TurnipFormatter::Step.add_template :hoge, :style2 do ; '12345' end
-        expect(TurnipFormatter::Step.templates[:hoge]).to have_key :style1
-        expect(TurnipFormatter::Step.templates[:hoge]).to have_key :style2
+      describe '#remove_template' do
+        it 'can remove step template' do
+          expect(TurnipFormatter::Step.templates[:hoge]).to have_key custom_template1
+          expect(TurnipFormatter::Step.templates[:hoge]).to have_key custom_template2
-        TurnipFormatter::Step.remove_template(:hoge, :style1)
-        expect(TurnipFormatter::Step.templates[:hoge]).to have_key :style2
+          TurnipFormatter::Step.remove_template(:hoge, custom_template1)
+          expect(TurnipFormatter::Step.templates[:hoge]).not_to have_key custom_template1
+          expect(TurnipFormatter::Step.templates[:hoge]).to have_key custom_template2
-        TurnipFormatter::Step.remove_template(:hoge, :style2)
-        expect(TurnipFormatter::Step.templates).not_to have_key(:hoge)
+          TurnipFormatter::Step.remove_template(:hoge, custom_template2)
+          expect(TurnipFormatter::Step.templates).not_to have_key custom_template2
+        end
       end
     end
   end

data/spec/turnip_formatter/{template/step_exception_spec.rb → step_template/exception_spec.rb} RENAMED Viewed

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
-require 'turnip_formatter/template/step_exception'
+require 'turnip_formatter/step_template/exception'
 module TurnipFormatter
-  class Template
-    describe StepException do
-      let(:template) { ::TurnipFormatter::Template::StepException }
+  module StepTemplate
+    describe Exception do
+      let(:template) { ::TurnipFormatter::StepTemplate::Exception }
       let(:exception) do
         StandardError.new('StepExceptionError').tap do |e|
           e.set_backtrace('/path/to/error.rb: 10')

data/spec/turnip_formatter/{template/step_source_spec.rb → step_template/source_spec.rb} RENAMED Viewed

@@ -1,19 +1,19 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
-require 'turnip_formatter/template/step_source'
+require 'turnip_formatter/step_template/source'
 module TurnipFormatter
-  class Template
-    describe StepSource do
-      let(:template) { ::TurnipFormatter::Template::StepSource }
+  module StepTemplate
+    describe Source do
+      let(:template) { ::TurnipFormatter::StepTemplate::Source }
       let(:source) { __FILE__ + ':3' }
       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'"
+          should match "require 'turnip_formatter/step_template/source'"
         end
       end
     end