ugly_face 0.1

data/lib/ugly_face/formatter/html.rb

@@ -0,0 +1,289 @@
+require 'action_view'
+require 'fileutils'
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/duration'
+require 'cucumber/formatter/console'
+require 'cucumber/ast/scenario'
+require 'cucumber/ast/table'
+require 'cucumber/ast/outline_table'
+require File.join(File.dirname(__FILE__), 'view_helper')
+require File.join(File.dirname(__FILE__), 'report')
+
+# Starting with ActionPack 4.1.1, the module Mime doesn't get initialized before it's needed by UglyFace and so
+# it would blow up with errors about uninitialized constants. We need to explicitly load it to prevent this problem.
+require 'action_dispatch/http/mime_type'
+
+module UglyFace
+  module Formatter
+
+    class Html
+      include Cucumber::Formatter::Io
+      include Cucumber::Formatter::Duration
+      include Cucumber::Formatter::Console
+      include ViewHelper
+
+      attr_reader :report, :logo
+
+      def initialize(step_mother, path_or_io, options)
+        @path = path_or_io
+        set_path_and_file(path_or_io)
+        @path_to_erb = File.join(File.dirname(__FILE__), '..', 'templates')
+        @step_mother = step_mother
+        @options = options
+        # The expand option is set to true by RubyMine and cannot be turned off using the IDE. This option causes
+        # a test run while using this gem to terminate.
+        @options[:expand] = false unless @options.nil?
+        @report = Report.new
+        @img_id = 0
+        @logo = 'logo.png'
+        @delayed_messages = []
+      end
+
+      def set_path_and_file(path_or_io)
+        return if path_or_io.nil?
+        dir = File.dirname(path_or_io)
+        FileUtils.mkdir_p dir unless File.directory? dir
+        @io = ensure_io(path_or_io, 'html')
+      end
+      
+      def embed(src, mime_type, label)
+        case(mime_type)
+        when /^image\/(png|gif|jpg|jpeg)/
+          embed_image(src, label)
+        end
+      end
+
+      def embed_image(src, label)
+        @report.current_scenario.image << src.split(separator).last
+        @report.current_scenario.image_label << label
+        @report.current_scenario.image_id << "img_#{@img_id}"
+        @img_id += 1
+        filename = "#{File.dirname(@path)}#{separator}images"
+        FileUtils.cp src, filename
+      end
+
+      def before_features(features)
+        make_output_directories
+        @tests_started = Time.now
+      end
+
+      def features_summary_file
+        parts = @io.path.split(separator)
+        parts[parts.length - 1]
+      end
+
+      def before_feature(feature)
+        @report.add_feature ReportFeature.new(feature, features_summary_file)
+      end
+
+      def after_feature(feature)
+        @report.current_feature.close(feature)
+      end
+
+      def before_background(background)
+        @report.begin_background
+      end
+
+      def after_background(background)
+        @report.end_background
+        @report.current_feature.background << ReportStep.new(background)
+      end
+
+      def before_feature_element(feature_element)
+        unless scenario_outline? feature_element
+          @report.add_scenario  ReportScenario.new(feature_element)
+        end
+      end
+
+      def after_feature_element(feature_element)
+        unless scenario_outline?(feature_element)
+          process_scenario(feature_element)
+        end
+      end
+
+      def before_table_row(example_row)
+        @report.add_scenario ReportScenario.new(example_row) unless info_row?(example_row)
+      end
+
+      def after_table_row(example_row)
+        unless info_row?(example_row)
+          @report.current_scenario.populate(example_row)
+          build_scenario_outline_steps(example_row)
+        end
+        populate_cells(example_row) if example_row.instance_of? Cucumber::Ast::Table::Cells
+      end
+
+      def before_step(step)
+        @step_timer = Time.now
+      end
+
+      def after_step(step)
+        step = process_step(step) unless step_belongs_to_outline? step
+        if @cells
+          step.table = @cells
+          @cells = nil
+        end
+      end
+
+      def after_features(features)
+        @features = features
+        @duration = format_duration(Time.now - @tests_started)
+        copy_images
+        copy_stylesheets
+        generate_report
+      end
+
+      def features
+        @report.features
+      end
+
+      def custom_suite_header?
+        return false unless customization_directory
+
+        Dir.foreach(customization_directory) do |file|
+          return true if file == '_suite_header.erb'
+        end
+        false
+      end
+
+      def custom_feature_header?
+        return false unless customization_directory
+
+        Dir.foreach(customization_directory) do |file|
+          return true if file == '_feature_header.erb'
+        end
+        false
+      end
+
+      private
+
+      def generate_report
+        paths = [@path_to_erb, customization_directory.to_s]
+        renderer = ActionView::Base.new(paths)
+        filename = File.join(@path_to_erb, 'main')
+        @io.puts renderer.render(:file => filename, :locals => {:report => self, :logo => @logo})
+        features.each do |feature|
+          write_feature_file(feature)
+        end
+      end
+
+      def write_feature_file(feature)
+        paths = [@path_to_erb, customization_directory.to_s]
+        renderer = ActionView::Base.new(paths)
+        filename = File.join(@path_to_erb, 'feature')
+        output_file = "#{File.dirname(@path)}#{separator}#{feature.file}"
+        to_cut = output_file.split(separator).last
+        directory = output_file.sub("#{separator}#{to_cut}", '')
+        FileUtils.mkdir_p directory unless File.directory? directory
+        file = File.new(output_file, Cucumber.file_mode('w'))
+        file.puts renderer.render(:file => filename, :locals => {:feature => feature, :logo => @logo, :customize => custom_feature_header?})
+        file.flush
+        file.close
+      end
+
+      def make_output_directories
+        make_directory 'images'
+        make_directory 'stylesheets'
+      end
+
+      def make_directory(dir)
+        path = "#{File.dirname(@path)}#{separator}#{dir}"
+        FileUtils.mkdir_p path unless File.directory? path
+      end
+
+      def copy_directory(dir, file_names, file_extension)
+        path = "#{File.dirname(@path)}#{separator}#{dir}"
+        file_names.each do |file|
+          copy_file File.join(File.dirname(__FILE__), '..', 'templates', "#{file}.#{file_extension}"), path
+        end
+      end
+
+      def copy_file(source, destination)
+        FileUtils.cp source, destination
+      end
+
+      def copy_images
+        copy_directory 'images', %w(debug screenshot failed passed pending undefined skipped table_failed table_passed table_pending table_undefined table_skipped), "png"
+        logo = logo_file
+        copy_file logo, "#{File.join(File.dirname(@path), 'images')}" if logo
+        copy_directory 'images', ['custom_logo'], 'png' unless logo
+      end
+
+      def copy_stylesheets
+        copy_directory 'stylesheets', ['style'], 'css'
+      end
+
+      def logo_file
+        dir = customization_directory
+        Dir.foreach(dir) do |file|
+          if file =~ /^logo\.(png|gif|jpg|jpeg)$/
+            @logo = file
+            return File.join(dir, file)
+          end
+        end if dir
+      end
+
+      def customization_directory
+        dir = File.join(File.expand_path('features'), 'support', 'ugly_face')
+        return dir if File.exists? dir
+      end
+
+      def process_scenario(scenario)
+        @report.current_scenario.populate(scenario)
+      end
+
+      def process_step(step, status=nil)
+        duration =  Time.now - @step_timer
+        report_step = ReportStep.new(step)
+        report_step.duration = duration
+        report_step.status = status unless status.nil?
+        if step.background?
+          @report.current_feature.background << report_step if @report.processing_background_steps?
+        else
+          @report.add_step report_step
+        end
+        report_step
+      end
+
+      def scenario_outline?(feature_element)
+        feature_element.is_a? Cucumber::Ast::ScenarioOutline
+      end
+
+      def info_row?(example_row)
+        return example_row.scenario_outline.nil? if example_row.respond_to? :scenario_outline
+        return true if example_row.instance_of? Cucumber::Ast::Table::Cells
+        false
+      end
+
+      def step_belongs_to_outline?(step)
+        scenario = step.instance_variable_get "@feature_element"
+        not scenario.nil?
+      end
+
+      def build_scenario_outline_steps(example_row)
+        si = example_row.instance_variable_get :@step_invocations
+        si.each do |row|
+          process_step(row, row.status)
+        end
+      end
+
+      def step_error(exception)
+        return nil if exception.nil?
+        exception.backtrace[-1] =~ /^#{step.file_colon_line}/ ? exception : nil
+      end
+
+      def populate_cells(example_row)
+        @cells ||= []
+        values = []
+        example_row.to_a.each do |cell|
+          values << cell.value
+        end
+        @cells << values
+      end
+
+      def separator
+        File::ALT_SEPARATOR || File::SEPARATOR
+      end
+    end
+  end
+end

data/lib/ugly_face/formatter/report.rb

@@ -0,0 +1,285 @@
+module UglyFace
+  module Formatter
+
+    module Formatting
+      def summary_percent(number, total)
+        percent = (number.to_f / total) * 100
+        "#{number} <span class=\"percentage\">(#{'%.1f' % percent}%)</span>"
+      end
+
+      def formatted_duration(duration)
+        m, s = duration.divmod(60)
+        "#{m}m#{'%.3f' % s}s"
+      rescue
+        "N m Ns"
+      end
+
+      def image_tag_for(status, source=nil)
+        dir = "#{directory_prefix_for(source)}images"
+        "<img src=\"#{dir}/#{status}.png\" alt=\"#{status}\" title=\"#{status}\">"
+      end
+
+      def table_image_for(status, source=nil)
+        dir = "#{directory_prefix_for(source)}images"
+        "<img src=\"#{dir}/table_#{status}.png\" alt=\"#{status}\" title=\"#{status}\">"
+
+      end
+
+      def directory_prefix_for(source=nil)
+        dir = ''
+        back_dir = source.count(separator) if source
+        back_dir.times do
+          dir += "..#{separator}"
+        end
+        dir
+      end
+
+      def separator
+        File::ALT_SEPARATOR || File::SEPARATOR
+      end
+    end
+
+
+    class Report
+      attr_reader :features
+
+      def initialize
+        @features = []
+      end
+
+      def current_feature
+        @features.last
+      end
+
+      def current_scenario
+        current_feature.scenarios.last
+      end
+
+      def add_feature(feature)
+        @features << feature
+      end
+
+      def add_scenario(scenario)
+        current_feature.scenarios << scenario
+      end
+
+      def begin_background
+        @processing_background = true
+      end
+
+      def end_background
+        @processing_background = false
+      end
+
+      def processing_background_steps?
+        @processing_background
+      end
+
+      def add_step(step)
+        current_scenario.steps << step
+      end
+    end
+
+    class ReportFeature
+      include Formatting
+      attr_accessor :scenarios, :background, :description
+      attr_reader :title, :file, :start_time, :duration, :parent_filename
+
+      def initialize(feature, parent_filename)
+        @scenarios = []
+        @background = []
+        @start_time = Time.now
+        @description = feature.description
+        @parent_filename = parent_filename
+      end
+
+      def close(feature)
+        @title = feature.title
+        @duration = Time.now - start_time
+        a_file = feature.file.sub(/\.feature/, '.html')
+        to_cut = a_file.split(separator).first
+        @file = a_file.sub("#{to_cut}#{separator}", '')
+      end
+
+      def steps
+        steps = []
+        scenarios.each { |scenario| steps += scenario.steps }
+        steps
+      end
+
+      def background_title
+        title = @background.find { |step| step.keyword.nil? }
+      end
+
+      def background_steps
+        @background.find_all { |step| step.keyword }
+      end
+
+      def scenarios_for(status)
+        scenarios.find_all { |scenario| scenario.status == status }
+      end
+
+      def scenario_summary_for(status)
+        scenarios_with_status = scenarios_for(status)
+        summary_percent(scenarios_with_status.length, scenarios.length)
+      end
+
+      def step_summary_for(status)
+        steps_with_status = steps.find_all { |step| step.status == status }
+        summary_percent(steps_with_status.length, steps.length)
+      end
+
+      def scenario_average_duration
+        durations = scenarios.collect { |scenario| scenario.duration }
+        formatted_duration(durations.reduce(:+).to_f / durations.size)
+      end
+
+      def step_average_duration
+        steps = scenarios.collect { |scenario| scenario.steps }
+        durations = steps.flatten.collect { |step| step.duration }
+        formatted_duration(durations.reduce(:+).to_f / durations.size)
+      end
+
+      def get_binding
+        binding
+      end
+
+      def description?
+        !description.nil?  && !description.empty?
+      end
+
+      def has_background?
+        background.length > 0
+      end
+
+      def file
+        @file.split("features#{separator}").last
+      end
+
+      def parent_filename
+        @parent_filename.split(separator).last
+      end
+    end
+
+    class ReportScenario
+      attr_accessor :name, :file_colon_line, :status, :steps, :duration, :image, :image_label, :image_id
+
+      def initialize(scenario)
+        @steps = []
+        @image = []
+        @image_label = []
+        @image_id = []
+        @start = Time.now
+      end
+
+      def populate(scenario)
+        @duration = Time.now - @start
+        if scenario.instance_of? Cucumber::Ast::Scenario
+          @name = scenario.name
+          @file_colon_line = scenario.file_colon_line
+        elsif scenario.instance_of? Cucumber::Ast::OutlineTable::ExampleRow
+          @name = scenario.scenario_outline.name
+          @file_colon_line = scenario.backtrace_line
+        end
+        @status = scenario.status
+      end
+
+      def has_image?
+        not image.nil?
+      end
+    end
+
+    class ReportStep
+      attr_accessor :name, :keyword, :file_colon_line, :status, :duration, :table, :multiline_arg, :error
+
+      def initialize(step)
+        @name = step.name
+        @file_colon_line = step.file_colon_line
+        unless step.instance_of? Cucumber::Ast::Background
+          if step.respond_to? :actual_keyword
+            @keyword = step.actual_keyword
+          else
+            @keyword = step.keyword
+          end
+          @status = step.status
+          @multiline_arg = step.multiline_arg
+          @error = step.exception
+        end
+      end
+
+      def failed_with_error?
+        status == :failed && !error.nil?
+      end
+
+      def has_table?
+        not table.nil?
+      end
+
+      def has_multiline_arg?
+        !multiline_arg.nil? && !has_table?
+      end
+
+      def file_with_error(file_colon_line)
+        @snippet_extractor ||= SnippetExtractor.new
+        file, line = @snippet_extractor.file_name_and_line(file_colon_line)
+        file
+      end
+
+      #from cucumber ===================
+      def extra_failure_content(file_colon_line)
+        @snippet_extractor ||= SnippetExtractor.new
+        @snippet_extractor.snippet(file_colon_line)
+      end
+
+      class SnippetExtractor
+        require 'syntax/convertors/html';
+        @@converter = Syntax::Convertors::HTML.for_syntax "ruby"
+
+        def file_name_and_line(error_line)
+          if error_line =~ /(.*):(\d+)/
+            [$1, $2.to_i]
+          end
+        end
+
+        def snippet(error)
+          raw_code, line, file = snippet_for(error[0])
+          highlighted = @@converter.convert(raw_code, false)
+
+          "<pre class=\"ruby\"><strong>#{file + "\n"}</strong><code>#{post_process(highlighted, line)}</code></pre>"
+        end
+
+        def snippet_for(error_line)
+            file, line = file_name_and_line(error_line)
+          if file
+            [lines_around(file, line), line, file]
+          else
+            ["# Couldn't get snippet for #{error_line}", 1, 'File Unknown']
+          end
+        end
+
+        def lines_around(file, line)
+          if File.file?(file)
+            # lines = File.open(file).read.split("\n")
+            lines = File.readlines(file)
+            min = [0, line-3].max
+            max = [line+1, lines.length-1].min
+            # lines[min..max].join("\n")
+            lines[min..max].join
+          else
+            "# Couldn't get snippet for #{file}"
+          end
+        end
+
+        def post_process(highlighted, offending_line)
+          new_lines = []
+          highlighted.split("\n").each_with_index do |line, i|
+            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
+            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
+            new_lines << new_line
+          end
+          new_lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/ugly_face/formatter/view_helper.rb

@@ -0,0 +1,61 @@
+require 'cucumber/ast/scenario_outline'
+
+module UglyFace
+  module Formatter
+    module ViewHelper
+
+      def start_time
+        @tests_started.strftime("%a %B %-d, %Y at %H:%M:%S")
+      end
+
+      def step_count
+        @step_mother.steps.length
+      end
+
+      def scenario_count
+        @step_mother.scenarios.length
+      end
+
+      def total_duration
+        @duration
+      end
+
+      def step_average_duration(features)
+        scenarios = features.collect { |feature| feature.scenarios }
+        steps = scenarios.flatten.collect { |scenario| scenario.steps }
+        durations = steps.flatten.collect { |step| step.duration }
+        format_duration get_average_from_float_array durations
+      end
+
+      def scenario_average_duration(features)
+        scenarios = features.collect { |feature| feature.scenarios }
+        durations = scenarios.flatten.collect { |scenario| scenario.duration }
+        format_duration get_average_from_float_array durations
+      end
+
+      def scenarios_summary_for(status)
+        summary_percent(@step_mother.scenarios(status).length, scenario_count)
+      end
+
+      def steps_summary_for(status)
+        summary_percent(@step_mother.steps(status).length, step_count)
+      end
+
+      def failed_scenario?(scenario)
+        scenario.status == :failed
+      end
+
+
+      private
+
+      def get_average_from_float_array(arr)
+        arr.reduce(:+).to_f / arr.size
+      end
+
+      def summary_percent(number, total)
+        percent = (number.to_f / total) * 100
+        "#{number} <span class=\"percentage\">(#{'%.1f' % percent}%)</span>"
+      end
+    end
+  end
+end

data/lib/ugly_face/templates/_main_header.erb

@@ -0,0 +1 @@
+<h2 class="results">Run Results</h2>

data/lib/ugly_face/templates/_page_header.erb

@@ -0,0 +1,2 @@
+<h2 class="results">Feature Results:  <%= feature.title %></h2>
+<br />

data/lib/ugly_face/templates/_step.erb

@@ -0,0 +1,39 @@
+<%= "#{step.keyword} #{step.name}" %>
+<% if step.has_table? %>
+	<br />
+	<table border="1" class="param_table">
+		<% step.table.each do |row| %>
+			<tr>
+				<% row.each_with_index do |column, index| %>
+				<% if index == 0 %>
+					<th><%= column %></th>
+				<% else %>	
+					<td><%= column %></td>
+				<% end %>		
+				<% end %>
+			</tr>
+		<% end %>
+	</table>
+<% end %>
+<% if step.has_multiline_arg? %>
+	<br />
+	<table border="1" class="multiline_arg">
+		<tr>
+		 <td><pre><%= step.multiline_arg %></pre></td>
+		</tr>
+	</table>
+<% end %>
+<% if step.failed_with_error? %>
+	<table>
+	  <tr class="error">
+		<td class="message">
+		  <strong><pre><%= "#{step.error.message} (#{step.error.class})" %></pre></strong>
+		</td>
+	  </tr>
+	  <tr>
+		<td>
+		  <%= raw(step.extra_failure_content(step.error.backtrace)) %>
+		</td>
+	  </tr>
+	</table>
+<% end %>