RubyGems - rackjour - Versions diffs - 0.1.8 - Mend

rackjour 0.1.8

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 (1497) hide show

data/vendor/gems/gems/cucumber-0.4.4/lib/cucumber/formatter/debug.rb ADDED

@@ -0,0 +1,33 @@
+require 'cucumber/formatter/progress'
+require 'cucumber/step_definition_light'
+module Cucumber
+  module Formatter
+    class Debug
+      def initialize(step_mother, io, options)
+        @io = io
+        @indent = 0
+      end
+      def respond_to?(*args)
+        true
+      end
+      def method_missing(name, *args)
+        @indent -= 2 if name.to_s =~ /^after/
+        print(name)
+        @indent += 2 if name.to_s =~ /^before/
+      end
+    private
+      def print(text)
+        @io.puts "#{indent}#{text}"
+      end
+      def indent
+        (' ' * @indent)
+      end
+    end
+  end
+end

data/vendor/gems/gems/cucumber-0.4.4/lib/cucumber/formatter/duration.rb ADDED

@@ -0,0 +1,13 @@
+module Cucumber
+  module Formatter
+    module Duration
+      # Helper method for formatters that need to
+      # format a duration in seconds to the UNIX
+      # <tt>time</tt> format.
+      def format_duration(seconds)
+        m, s = seconds.divmod(60)
+        "#{m}m#{'%.3f' % s}s"
+      end
+    end
+  end
+end

data/vendor/gems/gems/cucumber-0.4.4/lib/cucumber/formatter/html.rb ADDED

@@ -0,0 +1,369 @@
+require 'cucumber/formatter/ordered_xml_markup'
+require 'cucumber/formatter/duration'
+require 'cucumber/formatter/summary'
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format html</tt>
+    class Html
+      include ERB::Util # for the #h method
+      include Duration
+      include Summary
+      def initialize(step_mother, io, options)
+        @io = io
+        @options = options
+        @buffer = {}
+        @step_mother = step_mother
+        @current_builder = create_builder(@io)
+      end
+      def before_features(features)
+        start_buffering :features
+      end
+      def after_features(features)
+        stop_buffering :features
+        # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+        builder.declare!(
+          :DOCTYPE,
+          :html,
+          :PUBLIC,
+          '-//W3C//DTD XHTML 1.0 Strict//EN',
+          'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
+        )
+        builder.html(:xmlns => 'http://www.w3.org/1999/xhtml') do
+          builder.head do
+            builder.meta(:content => 'text/html;charset=utf-8')
+            builder.title 'Cucumber'
+            inline_css
+          end
+          builder.body do
+            builder.div(:class => 'cucumber') do
+              builder << buffer(:features)
+              builder.div(scenario_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
+              builder.div(step_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
+              builder.div(format_duration(features.duration), :class => 'duration')
+            end
+          end
+        end
+      end
+      def before_feature(feature)
+        start_buffering :feature
+        @exceptions = []
+      end
+      def after_feature(feature)
+        stop_buffering :feature
+        builder.div(:class => 'feature') do
+          builder << buffer(:feature)
+        end
+      end
+      def before_comment(comment)
+        start_buffering :comment
+      end
+      def after_comment(comment)
+        stop_buffering :comment
+        builder.pre(:class => 'comment') do
+          builder << buffer(:comment)
+        end
+      end
+      def comment_line(comment_line)
+        builder.text!(comment_line)
+        builder.br
+      end
+      def after_tags(tags)
+        @tag_spacer = nil
+      end
+      def tag_name(tag_name)
+        builder.text!(@tag_spacer) if @tag_spacer
+        @tag_spacer = ' '
+        builder.span(tag_name, :class => 'tag')
+      end
+      def feature_name(name)
+        lines = name.split(/\r?\n/)
+        return if lines.empty?
+        builder.h2 do |h2|
+          builder.span(lines[0], :class => 'val')
+        end
+        builder.p(:class => 'narrative') do
+          lines[1..-1].each do |line|
+            builder.text!(line.strip)
+            builder.br
+          end
+        end
+      end
+      def before_background(background)
+        @in_background = true
+        start_buffering :background
+      end
+      def after_background(background)
+        stop_buffering :background
+        @in_background = nil
+        builder.div(:class => 'background') do
+          builder << buffer(:background)
+        end
+      end
+      def background_name(keyword, name, file_colon_line, source_indent)
+        @listing_background = true
+        builder.h3 do |h3|
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
+        end
+      end
+      def before_feature_element(feature_element)
+        start_buffering :feature_element
+      end
+      def after_feature_element(feature_element)
+        stop_buffering :feature_element
+        css_class = {
+          Ast::Scenario        => 'scenario',
+          Ast::ScenarioOutline => 'scenario outline'
+        }[feature_element.class]
+        builder.div(:class => css_class) do
+          builder << buffer(:feature_element)
+        end
+        @open_step_list = true
+      end
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        @listing_background = false
+        builder.h3 do
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
+        end
+      end
+      def before_outline_table(outline_table)
+        @outline_row = 0
+        start_buffering :outline_table
+      end
+      def after_outline_table(outline_table)
+        stop_buffering :outline_table
+        builder.table do
+          builder << buffer(:outline_table)
+        end
+        @outline_row = nil
+      end
+      def before_examples(examples)
+        start_buffering :examples
+      end
+      def after_examples(examples)
+        stop_buffering :examples
+        builder.div(:class => 'examples') do
+          builder << buffer(:examples)
+        end
+      end
+      def examples_name(keyword, name)
+        builder.h4 do
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
+        end
+      end
+      def before_steps(steps)
+        start_buffering :steps
+      end
+      def after_steps(steps)
+        stop_buffering :steps
+        builder.ol do
+          builder << buffer(:steps)
+        end
+      end
+      def before_step(step)
+        @step_id = step.dom_id
+      end
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        start_buffering :step_result
+        @hide_this_step = false
+        if exception
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
+          @exceptions << exception
+        end
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
+        end
+        @status = status
+      end
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        stop_buffering :step_result
+        return if @hide_this_step
+        builder.li(:id => @step_id, :class => "step #{status}") do
+          builder << buffer(:step_result)
+        end
+      end
+      def step_name(keyword, step_match, status, source_indent, background)
+        @step_matches ||= []
+        background_in_scenario = background && !@listing_background
+        @skip_step = @step_matches.index(step_match) || background_in_scenario
+        @step_matches << step_match
+        unless @skip_step
+          build_step(keyword, step_match, status)
+        end
+      end
+      def exception(exception, status)
+        return if @hide_this_step
+        builder.pre(format_exception(exception), :class => status)
+      end
+      def before_multiline_arg(multiline_arg)
+        start_buffering :multiline_arg
+      end
+      def after_multiline_arg(multiline_arg)
+        stop_buffering :multiline_arg
+        return if @hide_this_step || @skip_step
+        if Ast::Table === multiline_arg
+          builder.table do
+            builder << buffer(:multiline_arg)
+          end
+        else
+          builder << buffer(:multiline_arg)
+        end
+      end
+      def py_string(string)
+        return if @hide_this_step
+        builder.pre(:class => 'val') do |pre|
+          builder << string.gsub("\n", '&#x000A;')
+        end
+      end
+      def before_table_row(table_row)
+        @row_id = table_row.dom_id
+        @col_index = 0
+        start_buffering :table_row
+      end
+      def after_table_row(table_row)
+        stop_buffering :table_row
+        return if @hide_this_step
+        builder.tr(:id => @row_id) do
+          builder << buffer(:table_row)
+        end
+        if table_row.exception
+          builder.tr do
+            builder.td(:colspan => @col_index.to_s, :class => 'failed') do
+              builder.pre do |pre|
+                pre << format_exception(table_row.exception)
+              end
+            end
+          end
+        end
+        @outline_row += 1 if @outline_row
+      end
+      def table_cell_value(value, status)
+        return if @hide_this_step
+        cell_type = @outline_row == 0 ? :th : :td
+        attributes = {:id => "#{@row_id}_#{@col_index}", :class => 'val'}
+        attributes[:class] += " #{status}" if status
+        build_cell(cell_type, value, attributes)
+        @col_index += 1
+      end
+      def announce(announcement)
+        builder.pre(announcement, :class => 'announcement')
+      end
+      def embed(file, mime_type)
+        case(mime_type)
+        when /^image\/(png|gif|jpg)/
+          embed_image(file)
+        end
+      end
+      private
+      def embed_image(file)
+        id = file.hash
+        builder.pre(:class => 'embed') do |pre|
+          pre << %{<a href="#" onclick="img=document.getElementById('#{id}'); img.style.display = (img.style.display == 'none' ? 'block' : 'none');">Screenshot</a>
+          <img id="#{id}" style="display: none" src="#{file}" />}
+        end
+      end
+      def build_step(keyword, step_match, status)
+        step_name = step_match.format_args(lambda{|param| %{<span class="param">#{param}</span>}})
+        builder.div do |div|
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(:class => 'step val') do |name|
+            name << h(step_name).gsub(/&lt;span class=&quot;(.*?)&quot;&gt;/, '<span class="\1">').gsub(/&lt;\/span&gt;/, '</span>')
+          end
+        end
+      end
+      def build_cell(cell_type, value, attributes)
+        builder.__send__(cell_type, value, attributes)
+      end
+      def inline_css
+        builder.style(:type => 'text/css') do
+          builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
+        end
+      end
+      def format_exception(exception)
+        h((["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n"))
+      end
+      def builder
+        @current_builder
+      end
+      def buffer(label)
+        result = @buffer[label]
+        @buffer[label] = ''
+        result
+      end
+      def start_buffering(label)
+        @buffer[label] ||= ''
+        @parent_builder ||= {}
+        @parent_builder[label] = @current_builder
+        @current_builder = create_builder(@buffer[label])
+      end
+      def stop_buffering(label)
+        @current_builder = @parent_builder[label]
+      end
+      def create_builder(io)
+        OrderedXmlMarkup.new(:target => io, :indent => 0)
+      end
+    end
+  end
+end

data/vendor/gems/gems/cucumber-0.4.4/lib/cucumber/formatter/junit.rb ADDED

@@ -0,0 +1,140 @@
+require 'cucumber/formatter/ordered_xml_markup'
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format junit</tt>
+    class Junit
+      class UnNamedFeatureError < StandardError
+        def initialize(feature_file)
+          super("The feature in '#{feature_file}' does not have a name. The JUnit XML format requires a name for the testsuite element.")
+        end
+      end
+      def initialize(step_mother, io, options)
+        raise "You *must* specify --out DIR for the junit formatter" unless String === io && File.directory?(io)
+        @reportdir = io
+        @options = options
+      end
+      def before_feature(feature)
+        @current_feature = feature
+        @failures = @errors = @tests = 0
+        @builder = OrderedXmlMarkup.new( :indent => 2 )
+        @time = 0
+      end
+      def after_feature(feature)
+        @testsuite = OrderedXmlMarkup.new( :indent => 2 )
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          :failures => @failures,
+          :errors => @errors,
+          :tests => @tests,
+          :time => "%.6f" % @time,
+          :name => @feature_name ) do
+          @testsuite << @builder.target!
+        end
+        write_file(feature_result_filename(feature.file), @testsuite.target!)
+      end
+      def before_background(*args)
+        @in_background = true
+      end
+      def after_background(*args)
+        @in_background = false
+      end
+      def feature_name(name)
+        raise UnNamedFeatureError.new(@current_feature.file) if name.empty?
+        lines = name.split(/\r?\n/)
+        @feature_name = lines[0].sub(/Feature\:/, '').strip
+      end
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        scenario_name = name.strip.delete(".\r\n")
+        scenario_name = "Unnamed scenario" if name.blank?
+        @scenario = scenario_name
+        @outline = keyword.include?('Scenario Outline')
+        @output = "Scenario#{ " outline" if @outline}: #{@scenario}\n\n"
+      end
+      def before_steps(steps)
+        @steps_start = Time.now
+      end
+      def after_steps(steps)
+        return if @in_background || @outline
+        duration = Time.now - @steps_start
+        if steps.failed?
+          steps.each { |step| @output += "#{step.keyword} #{step.name}\n" }
+          @output += "\nMessage:\n"
+        end
+        build_testcase(duration, steps.status, steps.exception)
+      end
+      def before_examples(*args)
+        @header_row = true
+      end
+      def before_table_row(table_row)
+        return unless @outline
+        @table_start = Time.now
+      end
+      def after_table_row(table_row)
+        return unless @outline
+        duration = Time.now - @table_start
+        unless @header_row
+          name_suffix = " (outline example : #{table_row.name})"
+          if table_row.failed?
+            @output += "Example row: #{table_row.name}\n"
+            @output += "\nMessage:\n"
+          end
+          build_testcase(duration, table_row.status, table_row.exception, name_suffix)
+        end
+        @header_row = false if @header_row
+      end
+      private
+      def build_testcase(duration, status, exception = nil, suffix = "")
+        @time += duration
+        classname = "#{@feature_name}.#{@scenario}"
+        name = "#{@scenario}#{suffix}"
+        failed = (status == :failed || (status == :pending && @options[:strict]))
+        #puts "FAILED:!!#{failed}"
+        if status == :passed || failed
+          @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
+            if failed
+              @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
+                @builder.text! @output
+                @builder.text!(format_exception(exception)) if exception
+              end
+              @failures += 1
+            end
+          end
+          @tests += 1
+        end
+      end
+      def format_exception(exception)
+        (["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n")
+      end
+      def feature_result_filename(feature_file)
+        ext_length = File.extname(feature_file).length
+        basename = File.basename(feature_file)[0...-ext_length]
+        File.join(@reportdir, "TEST-#{basename}.xml")
+      end
+      def write_file(feature_filename, data)
+        File.open(feature_filename, 'w') { |file| file.write(data) }
+      end
+    end
+  end
+end