RubyGems - butternut - Versions diffs - 0.0.0 - Mend

butternut 0.0.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 (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"