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

turnip_formatter 0.1.2 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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