RubyGems - butternut - Versions diffs - 0.0.0 - Mend

butternut 0.0.0

Files changed (25) hide show

data/.document +5 -0
data/.gitignore +22 -0
data/LICENSE +20 -0
data/README.rdoc +18 -0
data/Rakefile +53 -0
data/VERSION +1 -0
data/butternut.gemspec +79 -0
data/lib/butternut/cucumber.css +112 -0
data/lib/butternut/cucumber.sass +152 -0
data/lib/butternut/formatter.rb +465 -0
data/lib/butternut/helpers.rb +51 -0
data/lib/butternut/scenario_extensions.rb +7 -0
data/lib/butternut.rb +32 -0
data/spec/butternut/formatter_spec.rb +288 -0
data/spec/butternut/helpers_spec.rb +128 -0
data/spec/butternut_spec.rb +53 -0
data/spec/fixtures/foo.css +3 -0
data/spec/fixtures/foo.html +20 -0
data/spec/fixtures/foo.js +3 -0
data/spec/fixtures/picard.jpg +0 -0
data/spec/spec.opts +1 -0
data/spec/spec_helper.rb +78 -0
data/tmp/features/.gitignore +2 -0
data/tmp/main/.gitignore +2 -0
metadata +121 -0

data/lib/butternut/formatter.rb ADDED Viewed

@@ -0,0 +1,465 @@
+require 'cucumber/formatter/ordered_xml_markup'
+require 'cucumber/formatter/duration'
+require 'tmpdir'
+require 'fileutils'
+require 'nokogiri'
+require 'uri'
+require 'open-uri'
+module Butternut
+  class Formatter
+    include ERB::Util # for the #h method
+    include Cucumber::Formatter::Duration
+    # FIXME: this is obviously not nominal, but I have no way of
+    #        accepting additional options from Cucumber at present
+    FEATURES_DIR_PARTS  = %w{.. features}
+    FEATURES_HTML_PREFIX = "/features"
+    def initialize(step_mother, io, options)
+      @io = io
+      @options = options
+      @buffer = {}
+      @current_builder = create_builder(@io)
+      if @options && @options[:formats]
+        format = @options[:formats].detect { |(name, _)| underscore(name) == "butternut/formatter" }
+        if format && format[1].is_a?(String)
+          base_dir = File.dirname(File.expand_path(format[1]))
+          features_dir = File.expand_path(File.join(base_dir, *FEATURES_DIR_PARTS))
+          if File.exist?(features_dir)
+            today = Date.today.to_s
+            @source_output_dir = File.join(features_dir, today)
+            @source_html_path  = FEATURES_HTML_PREFIX + "/" + today
+            if !File.exist?(@source_output_dir)
+              FileUtils.mkdir(@source_output_dir)
+            end
+          else
+            $stderr.puts "Directory not found: #{features_dir}"
+          end
+        end
+      end
+      @source_output_dir ||= Dir.tmpdir
+      @source_html_path  ||= "file://" + Dir.tmpdir
+    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(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
+      @feature_element = feature_element
+    end
+    def after_feature_element(feature_element)
+      stop_buffering :feature_element
+      css_class = {
+        Cucumber::Ast::Scenario        => 'scenario',
+        Cucumber::Ast::ScenarioOutline => 'scenario outline'
+      }[feature_element.class]
+      builder.div(:class => css_class) do
+        builder << buffer(:feature_element)
+      end
+      @open_step_list = true
+      @feature_element = nil
+    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.div do
+          builder << buffer(:step_result)
+        end
+        builder.div(:class => "page") do
+          if @feature_element.respond_to?(:last_page_source)
+            page_source = @feature_element.last_page_source
+            if page_source
+              page_url = @feature_element.last_page_url
+              page_source = transform_page_source(page_source, page_url)
+              path = source_file_name
+              File.open(path, "w") { |f| f.print(page_source) }
+              builder.a({:target => "_blank", :href => "#{@source_html_path}/#{File.basename(path)}"}) do
+                builder.span(:class => "icon-show") { builder << "" }
+              end
+            end
+          end
+        end
+      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 Cucumber::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.table(: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
+    private
+    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)
+      (["#{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)
+      Cucumber::Formatter::OrderedXmlMarkup.new(:target => io, :indent => 0)
+    end
+    def source_file_name
+      t = Time.now.strftime("%Y%m%d")
+      path = nil
+      while path.nil?
+        path = File.join(@source_output_dir, "butternut#{t}-#{$$}-#{rand(0x100000000).to_s(36)}.html")
+        path = nil if File.exist?(path)
+      end
+      path
+    end
+    # Snagged from active_support
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+    def transform_page_source(page_source, page_url)
+      page_uri = URI.parse(page_url)
+      page_uri.query = nil
+      page_uri.path = File.dirname(page_uri.path)
+      page_url = page_uri.to_s
+      collected_files = []
+      doc = Nokogiri.HTML(page_source)
+      { 'img' => 'src',
+        'link[rel=stylesheet]' => 'href'
+      }.each_pair do |selector, attr|
+        doc.css(selector).each do |elt|
+          elt_url = elt[attr]
+          next  if elt_url.nil?
+          elt_url.gsub!('\\"', "")
+          next  if elt_url.empty?
+          next  if collected_files.index(elt_url)
+          basename    = File.basename(elt_url)
+          local_file  = File.join(@source_output_dir, basename)
+          remote_file = case elt_url
+                        when %r{^\w+://} then elt_url
+                        else
+                          elt_url.sub!(/^\//, "")
+                          page_url + "/" + elt_url
+                        end
+          File.open(local_file, "w") { |f| f.write open(remote_file).read }
+          collected_files << elt_url
+          elt[attr] = basename
+        end
+      end
+      # disable links
+      doc.css('a').each do |link|
+        link['href'] = "#"
+      end
+      # turn off scripts
+      doc.css('script').each { |s| s.unlink }
+      # disable form elements
+      doc.css('input, select, textarea').each { |x| x['disabled'] = 'disabled' }
+      doc.to_s
+    end
+  end
+end

data/lib/butternut/helpers.rb ADDED Viewed

@@ -0,0 +1,51 @@
+module Butternut
+  module Helpers
+    def browser
+      @browser ||= Celerity::Browser.new
+    end
+    def visit(url)
+      browser.goto(url)
+      @page_changed = true
+    end
+    def current_url
+      browser.page.getWebResponse.getRequestUrl.toString
+    end
+    def current_page_source
+      browser.page ? browser.page.as_xml : nil
+    end
+    # Fill in a text field with a value
+    def fill_in(label_or_name, options = {})
+      elt = find_element_by_label_or_name(:text_field, label_or_name)
+      if elt.exist?
+        elt.value = options[:with]
+        @page_changed = true
+      end
+    end
+    def select(option_text, options = {})
+      elt = find_element_by_label_or_name(:select_list, options[:from])
+      if elt.exist?
+        elt.select(option_text)
+        @page_changed = true
+      end
+    end
+    def click_button(button_value)
+      browser.button(button_value).click
+      @page_changed = true
+    end
+    def page_changed?
+      @page_changed
+    end
+    def find_element_by_label_or_name(type, label_or_name)
+      elt = browser.send(type, :label, label_or_name)
+      elt.exist? ? elt : browser.send(type, :name, label_or_name)
+    end
+  end
+end

data/lib/butternut/scenario_extensions.rb ADDED Viewed

@@ -0,0 +1,7 @@
+module Butternut
+  module ScenarioExtensions
+    attr_accessor :last_page_source, :last_page_url
+  end
+end
+Cucumber::Ast::Scenario.send(:include, Butternut::ScenarioExtensions)

data/lib/butternut.rb ADDED Viewed

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'cucumber'
+require 'celerity'
+module Butternut
+  def self.setup_hooks(obj)
+    obj.instance_exec do
+      AfterStep do |object|
+        begin
+          if object.is_a?(Cucumber::Ast::Scenario)
+            if page_changed?
+              object.last_page_source = current_page_source
+              object.last_page_url    = current_url
+            else
+              object.last_page_source = nil
+              object.last_page_url    = nil
+            end
+            @page_changed = false
+          end
+        rescue Exception => e
+          p e
+          pp caller
+        end
+      end
+    end
+  end
+end
+require File.dirname(__FILE__) + "/butternut/scenario_extensions"
+require File.dirname(__FILE__) + "/butternut/helpers"
+require File.dirname(__FILE__) + "/butternut/formatter"