RubyGems - butternut - Versions diffs - 0.1.0 → 0.2.0 - Mend

butternut 0.1.0 → 0.2.0

Files changed (12) hide show

data/Rakefile +2 -1
data/VERSION +1 -1
data/butternut.gemspec +3 -4
data/lib/butternut/formatter.rb +87 -420
data/lib/butternut.rb +8 -13
data/spec/butternut/formatter_spec.rb +84 -256
data/spec/fixtures/foo.html +1 -0
data/spec/spec.opts +0 -1
data/spec/spec_helper.rb +20 -1
data/tmp/{features/.gitignore → .gitignore} +0 -0
metadata +3 -4
data/tmp/main/.gitignore +0 -2

data/Rakefile CHANGED Viewed

@@ -23,6 +23,7 @@ end
 require 'spec/rake/spectask'
 Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.ruby_opts = %w{-X+O}
   spec.libs << 'lib' << 'spec'
   spec.spec_files = FileList['spec/**/*_spec.rb']
 end
@@ -56,6 +57,6 @@ namespace :tmp do
   desc 'Delete temporary files'
   task :clear do
     require 'fileutils'
-    FileUtils.rm_rf(Dir.glob(File.dirname(__FILE__) + "/tmp/features/*"), :verbose => true)
+    FileUtils.rm_rf(Dir.glob(File.dirname(__FILE__) + "/tmp/*"))
   end
 end

data/VERSION CHANGED Viewed

	@@ -1 +1 @@
1	- 0.1.0
1	+ 0.2.0

data/butternut.gemspec CHANGED Viewed

@@ -5,11 +5,11 @@
 Gem::Specification.new do |s|
   s.name = %q{butternut}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeremy Stephens"]
-  s.date = %q{2009-11-10}
+  s.date = %q{2009-12-14}
   s.description = %q{Based on Cucumber's HTML formatter, Butternut uses Celerity to capture page sources after each step.}
   s.email = %q{viking415@gmail.com}
   s.extra_rdoc_files = [
@@ -41,8 +41,7 @@ Gem::Specification.new do |s|
      "spec/fixtures/picard.jpg",
      "spec/spec.opts",
      "spec/spec_helper.rb",
-     "tmp/features/.gitignore",
-     "tmp/main/.gitignore"
+     "tmp/.gitignore"
   ]
   s.homepage = %q{http://github.com/viking/butternut}
   s.rdoc_options = ["--charset=UTF-8"]

data/lib/butternut/formatter.rb CHANGED Viewed

@@ -1,7 +1,5 @@
-require 'cucumber/formatter/ordered_xml_markup'
-require 'cucumber/formatter/duration'
+require 'cucumber/formatter/html'
-require 'tmpdir'
 require 'fileutils'
 require 'nokogiri'
 require 'uri'
@@ -9,467 +7,136 @@ require 'open-uri'
 require 'net/ftp'   # For Net::FTPPermError
 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"
+  class Formatter < Cucumber::Formatter::Html
     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
+      # find the format options
+      format = options[:formats].detect { |(name, _)| name == "Butternut::Formatter" }
+      if !format || !format[1].is_a?(String)
+        raise "Butternut::Formatter cannot output to STDOUT"
       end
-    end
-    def before_feature(feature)
-      start_buffering :feature
-      @exceptions = []
-    end
+      out = format[1]
-    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
+      super
+      if File.directory?(out)
+        #@assets_dir = out
+        #@assets_url = "."
+      else
+        basename = File.basename(out).sub(/\..*$/, "")
+        @assets_dir = File.join(File.dirname(out), basename)
+        @assets_url = basename
+        if !File.exist?(@assets_dir)
+          FileUtils.mkdir(@assets_dir)
         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
+      super
       @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
+        add_page_source_link(builder)
+        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 Cucumber::Ast::Table === multiline_arg
-        builder.table do
-          builder << buffer(:multiline_arg)
+    private
+      def add_page_source_link(builder)
+        if !@feature_element.respond_to?(:last_page_source) || @feature_element.last_page_source.nil?
+          # don't add a link of we haven't interacted with a webpage
+          return
         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
+        page_source = @feature_element.last_page_source
+        page_url = @feature_element.last_page_url
+        @feature_element.last_page_source = nil
+        @feature_element.last_page_url = nil
-    def before_table_row(table_row)
-      @row_id = table_row.dom_id
-      @col_index = 0
-      start_buffering :table_row
-    end
+        page_source = transform_page_source(page_source, page_url)
+        path = source_file_name
+        File.open(path, "w") { |f| f.print(page_source) }
-    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
+        builder.div(:style => "float: right") do
+          builder.a({:target => "_blank", :href => "#{@assets_url}/#{File.basename(path)}"}) do
+            builder << "Source"
           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>')
+      def source_file_name
+        t = Time.now.strftime("%Y%m%d")
+        path = nil
+        while path.nil?
+          path = File.join(@assets_dir, "butternut#{t}-#{$$}-#{rand(0x100000000).to_s(36)}.html")
+          path = nil if File.exist?(path)
         end
+        path
       end
-    end
-    def build_cell(cell_type, value, attributes)
-      builder.__send__(cell_type, value, attributes)
-    end
+      def transform_page_source(page_source, page_url)
+        base_uri = URI.parse(page_url)
+        base_uri.query = nil
+        @already_collected = []
-    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
+        doc = Nokogiri.HTML(page_source)
+        { :image      => ['img', 'src'],
+          :stylesheet => ['link[rel=stylesheet]', 'href']
+        }.each_pair do |type, (selector, attr)|
+          doc.css(selector).each do |elt|
+            elt_url = elt[attr]
+            next  if elt_url.nil? || elt_url.empty?
-    def builder
-      @current_builder
-    end
-    def buffer(label)
-      result = @buffer[label]
-      @buffer[label] = ''
-      result
-    end
+            result = save_remote_file(base_uri, type, elt_url)
+            elt[attr] = result  if result
+          end
+        end
-    def start_buffering(label)
-      @buffer[label] ||= ''
-      @parent_builder ||= {}
-      @parent_builder[label] = @current_builder
-      @current_builder = create_builder(@buffer[label])
-    end
+        # disable links
+        doc.css('a').each { |link| link['href'] = "#" }
-    def stop_buffering(label)
-      @current_builder = @parent_builder[label]
-    end
+        # turn off scripts
+        doc.css('script').each { |s| s.unlink }
-    def create_builder(io)
-      Cucumber::Formatter::OrderedXmlMarkup.new(:target => io, :indent => 0)
-    end
+        # disable form elements
+        doc.css('input, select, textarea').each { |x| x['disabled'] = 'disabled' }
-    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)
+        doc.to_s
       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)
-      base_uri = URI.parse(page_url)
-      base_uri.query = nil
-      @already_collected = []
-      doc = Nokogiri.HTML(page_source)
-      { :image      => ['img', 'src'],
-        :stylesheet => ['link[rel=stylesheet]', 'href']
-      }.each_pair do |type, (selector, attr)|
-        doc.css(selector).each do |elt|
-          elt_url = elt[attr]
-          next  if elt_url.nil? || elt_url.empty?
-          result = save_remote_file(base_uri, type, elt_url)
-          elt[attr] = result  if result
+      def transform_stylesheet(stylesheet_uri, content)
+        content.gsub(%r{url\(([^\)]+)\)}) do |_|
+          result = save_remote_file(stylesheet_uri, :image, $1)
+          "url(#{result || $1})"
         end
       end
-      # disable links
-      doc.css('a').each { |link| link['href'] = "#" }
-      # 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
-    def transform_stylesheet(stylesheet_uri, content)
-      content.gsub(%r{url\(([^\)]+)\)}) do |_|
-        result = save_remote_file(stylesheet_uri, :image, $1)
-        "url(#{result || $1})"
-      end
-    end
-    def save_remote_file(base_uri, type, url)
-      # FIXME: two different files could have the same basename :)
-      uri = URI.parse(url)
-      remote_uri = uri.absolute? ? uri : base_uri.merge(uri)
-      basename   = File.basename(uri.path)
-      unless @already_collected.include?(remote_uri)
+      def save_remote_file(base_uri, type, url)
+        # FIXME: two different files could have the same basename :)
         begin
-          content = open(remote_uri.to_s).read
-          content = transform_stylesheet(remote_uri, content) if type == :stylesheet
-          local_path = File.join(@source_output_dir, basename)
-          File.open(local_path, "w") { |f| f.write(content) }
-          @already_collected << remote_uri
-        rescue Errno::ENOENT, OpenURI::HTTPError, Net::FTPPermError
+          uri = URI.parse(url)
+        rescue URI::InvalidURIError
           return nil
         end
+        remote_uri = uri.absolute? ? uri : base_uri.merge(uri)
+        basename   = File.basename(uri.path)
+        unless @already_collected.include?(remote_uri)
+          begin
+            content = open(remote_uri.to_s).read
+            content = transform_stylesheet(remote_uri, content) if type == :stylesheet
+            local_path = File.join(@assets_dir, basename)
+            File.open(local_path, "w") { |f| f.write(content) }
+            @already_collected << remote_uri
+          rescue IOError, Errno::ENOENT, OpenURI::HTTPError, Net::FTPPermError
+            return nil
+          end
+        end
+        basename
       end
-      basename
-    end
   end
 end

data/lib/butternut.rb CHANGED Viewed

@@ -6,20 +6,15 @@ 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
+        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
-        rescue Exception => e
-          p e
-          pp caller
+          @page_changed = false
         end
       end
     end

data/spec/butternut/formatter_spec.rb CHANGED Viewed

@@ -5,19 +5,6 @@ module Butternut
     extend SpecHelperDsl
     include SpecHelper
-    Spec::Matchers.define :have_css_node do |css, regexp|
-      match do |doc|
-        nodes = doc.css(css)
-        nodes.detect{ |node| node.text =~ regexp }
-      end
-    end
-    Spec::Matchers.define :be_an_existing_file do
-      match do |filename|
-        File.exist?(filename)
-      end
-    end
     def setup_formatter(options = {})
       @out = StringIO.new
       @formatter = Butternut::Formatter.new(step_mother, @out, options)
@@ -33,191 +20,11 @@ module Butternut
       files.detect { |f| f.to_s =~ /\.html$/ }
     end
-    describe "visiting blank feature name" do
-      before(:each) do
-        setup_formatter
-      end
-      it "should not raise an error when visiting a blank feature name" do
-        lambda { @formatter.feature_name("") }.should_not raise_error
-      end
-    end
-    describe "given a single feature" do
-      before(:each) do
-        setup_formatter
-        run_defined_feature
-        @doc = Nokogiri.HTML(@out.string)
-      end
-      describe "with a comment" do
-        define_feature <<-FEATURE
-          # Healthy
-        FEATURE
-        it { @out.string.should =~ /^\<!DOCTYPE/ }
-        it { @out.string.should =~ /\<\/html\>$/ }
-        it { @doc.should have_css_node('.feature .comment', /Healthy/) }
-      end
-      describe "with a tag" do
-        define_feature <<-FEATURE
-          @foo
-        FEATURE
-        it { @doc.should have_css_node('.feature .tag', /foo/) }
-      end
-      describe "with a narrative" do
-        define_feature <<-FEATURE
-          Feature: Bananas
-            In order to find my inner monkey
-            As a human
-            I must eat bananas
-        FEATURE
-        it { @doc.should have_css_node('.feature h2', /Bananas/) }
-        it { @doc.should have_css_node('.feature .narrative', /must eat bananas/) }
-      end
-      describe "with a background" do
-        define_feature <<-FEATURE
-          Feature: Bananas
-          Background:
-            Given there are bananas
-        FEATURE
-        it { @doc.should have_css_node('.feature .background', /there are bananas/) }
-      end
-      describe "with a scenario" do
-        define_feature <<-FEATURE
-          Scenario: Monkey eats banana
-            Given there are bananas
-        FEATURE
-        it { @doc.should have_css_node('.feature h3', /Monkey eats banana/) }
-        it { @doc.should have_css_node('.feature .scenario .step', /there are bananas/) }
-      end
-      describe "with a scenario outline" do
-        define_feature <<-FEATURE
-          Scenario Outline: Monkey eats a balanced diet
-            Given there are <Things>
-            Examples: Fruit
-             | Things  |
-             | apples  |
-             | bananas |
-            Examples: Vegetables
-             | Things   |
-             | broccoli |
-             | carrots  |
-        FEATURE
-        it { @doc.should have_css_node('.feature .scenario.outline h4', /Fruit/) }
-        it { @doc.should have_css_node('.feature .scenario.outline h4', /Vegetables/) }
-        it { @doc.css('.feature .scenario.outline h4').length.should == 2}
-        it { @doc.should have_css_node('.feature .scenario.outline table', //) }
-        it { @doc.should have_css_node('.feature .scenario.outline table td', /carrots/) }
-      end
-      describe "with a step with a py string" do
-        define_feature <<-FEATURE
-          Scenario: Monkey goes to town
-            Given there is a monkey called:
-             """
-             foo
-             """
-        FEATURE
-        it { @doc.should have_css_node('.feature .scenario .val', /foo/) }
-      end
-      describe "with a multiline step arg" do
-        define_feature <<-FEATURE
-          Scenario: Monkey goes to town
-            Given there are monkeys:
-             | name |
-             | foo  |
-             | bar  |
-        FEATURE
-        it { @doc.should have_css_node('.feature .scenario table td', /foo/) }
-      end
-      describe "with a table in the background and the scenario" do
-        define_feature <<-FEATURE
-          Background:
-            Given table:
-              | a | b |
-              | c | d |
-          Scenario:
-            Given another table:
-             | e | f |
-             | g | h |
-        FEATURE
-        it { @doc.css('td').length.should == 8 }
-      end
-      describe "with a py string in the background and the scenario" do
-        define_feature <<-FEATURE
-          Background:
-            Given stuff:
-              """
-              foo
-              """
-          Scenario:
-            Given more stuff:
-              """
-              bar
-              """
-        FEATURE
-        it { @doc.css('.feature .background pre.val').length.should == 1 }
-        it { @doc.css('.feature .scenario pre.val').length.should == 1 }
-      end
-      describe "with a step that fails in the scenario" do
-        define_steps do
-          Given(/boo/) { raise 'eek' }
-        end
-        define_feature(<<-FEATURE)
-          Scenario: Monkey gets a fright
-            Given boo
-        FEATURE
-        it { @doc.should have_css_node('.feature .scenario .step.failed', /eek/) }
-      end
-      describe "with a step that fails in the backgound" do
-        define_steps do
-          Given(/boo/) { raise 'eek' }
-        end
-        define_feature(<<-FEATURE)
-          Background:
-            Given boo
-          Scenario:
-            Given yay
-          FEATURE
-        it { @doc.should have_css_node('.feature .background .step.failed', /eek/) }
-        it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
-        it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
-      end
+    it "should be a subclass of the html formatter" do
+      Butternut::Formatter.superclass.should == Cucumber::Formatter::Html
     end
-    describe "displaying page source to stdout" do
-      before(:each) do
-        setup_formatter
-        run_defined_feature
-        @doc = Nokogiri.HTML(@out.string)
-      end
+    describe "running without the --out option" do
       define_steps do
         Given(/foo/) do
           visit("file://" + File.expand_path(File.dirname(__FILE__) + "/../fixtures/foo.html"))
@@ -229,89 +36,110 @@ module Butternut
           Given foo
       FEATURE
-      it do
-        step = @doc.at('.feature .scenario .step.passed')
-        link = step.at('a[href^="file:///tmp/"]')
-        link.should_not be_nil
+      it "should raise an error" do
+        lambda {
+          setup_formatter
+          run_defined_feature
+        }.should raise_error
       end
     end
-    describe "displaying page source to file" do
+    describe "running with the --out option" do
       before(:each) do
         dir = File.join(File.dirname(__FILE__), "..", "..", "tmp")
-        setup_formatter({:formats => [
-          ['Butternut::Formatter', File.join(dir, "main", "huge.html")]
-        ]})
-        run_defined_feature
-        @doc = Nokogiri.HTML(@out.string)
+        @tmp_dir = File.join(dir, "#{Time.now.to_i}-#{rand(1000)}")
+        FileUtils.mkdir(@tmp_dir)
-        @tmp_dir = File.join(dir, "features", Date.today.to_s)
-        file = most_recent_html_file(@tmp_dir)
-        @page_doc = Nokogiri.HTML(open(file).read)
+        #@tmp_dir = File.join(dir, "features", Date.today.to_s)
+        #file = most_recent_html_file(@tmp_dir)
+        #@page_doc = Nokogiri.HTML(open(file).read)
       end
-      define_steps do
-        Given(/foo/) do
-          visit("file://" + File.expand_path(File.dirname(__FILE__) + "/../fixtures/foo.html"))
+      describe "with a filename specified" do
+        define_steps do
+          Given(/foo/) do
+            visit("file://" + File.join(FIXTURE_DIR, "foo.html"))
+          end
         end
-      end
-      define_feature(<<-FEATURE)
-        Scenario: Monkey goes to the zoo
-          Given foo
-      FEATURE
+        define_feature(<<-FEATURE)
+          Scenario: Monkey goes to the zoo
+            Given foo
+            Then bar
+        FEATURE
-      it "links to the page source" do
-        step = @doc.at('.feature .scenario .step.passed')
-        link = step.at("a")
-        link.should_not be_nil
-        file = link['href']
-        file.should match(%r{^/features/#{Date.today.to_s}/butternut.+\.html})
-      end
+        before(:each) do
+          setup_formatter({
+            :formats => [
+              ['Butternut::Formatter', File.join(@tmp_dir, "output.html")]
+            ]
+          })
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
+          file = most_recent_html_file(File.join(@tmp_dir, "output"))
+          @page_doc = Nokogiri.HTML(open(file).read)
+        end
-      it "saves images and stylesheets and rewrites urls in page source" do
-        @page_doc.at('img:nth(1)')['src'].should == "picard.jpg"
-        File.join(@tmp_dir, "picard.jpg").should be_an_existing_file
+        it "creates assets directory" do
+          File.join(@tmp_dir, "output").should be_an_existing_directory
+        end
-        @page_doc.at('link:nth(1)[rel="stylesheet"]')['href'].should == "foo.css"
-        File.join(@tmp_dir, "foo.css").should be_an_existing_file
+        it "links to the page source" do
+          step = @doc.at('.feature .scenario .step.passed')
+          link = step.at("a")
+          link.should_not be_nil
+          file = link['href']
+          file.should match(%r{^output/butternut.+\.html})
+        end
-        @page_doc.at('link:nth(2)[rel="stylesheet"]')['href'].should == "bar.css"
-        File.join(@tmp_dir, "bar.css").should be_an_existing_file
-      end
+        it "saves images and stylesheets and rewrites urls in page source" do
+          @page_doc.at('img:nth(1)')['src'].should == "picard.jpg"
+          File.join(@tmp_dir, "output", "picard.jpg").should be_an_existing_file
-      it "saves assets and rewrites urls referred to by stylesheets" do
-        foo = open(File.join(@tmp_dir, "foo.css")).read
-        foo.should include("url(facepalm.jpg)")
-        File.join(@tmp_dir, "facepalm.jpg").should be_an_existing_file
-      end
+          @page_doc.at('link:nth(1)[rel="stylesheet"]')['href'].should == "foo.css"
+          File.join(@tmp_dir, "output", "foo.css").should be_an_existing_file
-      it "turns off links" do
-        @page_doc.css('a').each do |link|
-          link['href'].should == "#"
+          @page_doc.at('link:nth(2)[rel="stylesheet"]')['href'].should == "bar.css"
+          File.join(@tmp_dir, "output", "bar.css").should be_an_existing_file
         end
-      end
-      it "turns off scripts" do
-        @page_doc.css('script').length.should == 0
-      end
+        it "saves assets and rewrites urls referred to by stylesheets" do
+          foo = open(File.join(@tmp_dir, "output", "foo.css")).read
+          foo.should include("url(facepalm.jpg)")
+          File.join(@tmp_dir, "output", "facepalm.jpg").should be_an_existing_file
+        end
-      it "disables form elements" do
-        @page_doc.css('input, select, textarea').each do |elt|
-          elt['disabled'].should == "disabled"
+        it "turns off links" do
+          @page_doc.css('a').each do |link|
+            link['href'].should == "#"
+          end
         end
-      end
-      it "handles Errno::ENOENT" do
-        @page_doc.at('img:nth(2)')['src'].should == "/roflpwnage/missing_file_omg.gif"
-      end
+        it "turns off scripts" do
+          @page_doc.css('script').length.should == 0
+        end
-      it "handles OpenURI::HTTPError" do
-        @page_doc.at('img:nth(3)')['src'].should == "http://google.com/missing_file_omg.gif"
-      end
+        it "disables form elements" do
+          @page_doc.css('input, select, textarea').each do |elt|
+            elt['disabled'].should == "disabled"
+          end
+        end
-      it "handles Net::FTPPermError" do
-        @page_doc.at('img:nth(4)')['src'].should == "ftp://mirror.anl.gov/missing_file_omg.gif"
+        it "handles Errno::ENOENT" do
+          @page_doc.at('img:nth(2)')['src'].should == "/roflpwnage/missing_file_omg.gif"
+        end
+        it "handles OpenURI::HTTPError" do
+          @page_doc.at('img:nth(3)')['src'].should == "http://google.com/missing_file_omg.gif"
+        end
+        it "handles Net::FTPPermError" do
+          @page_doc.at('img:nth(4)')['src'].should == "ftp://mirror.anl.gov/missing_file_omg.gif"
+        end
+        it "handles badly formed URI's" do
+        end
       end
     end
   end

data/spec/fixtures/foo.html CHANGED Viewed

@@ -20,6 +20,7 @@
     <img src="/roflpwnage/missing_file_omg.gif"/>
     <img src="http://google.com/missing_file_omg.gif"/>
     <img src="ftp://mirror.anl.gov/missing_file_omg.gif"/>
+    <img src="//baduri/pants.png"/>
     <div class="facepalm">&nbsp;</div>
   </body>

data/spec/spec.opts CHANGED Viewed

	@@ -1,2 +1 @@
1 1	--color
2	- --backtrace

data/spec/spec_helper.rb CHANGED Viewed

@@ -2,7 +2,7 @@ require 'rubygems'
 gem 'rspec'
 require 'spec'
 require 'spec/autorun'
-require 'ruby-debug'
+require 'fileutils'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -71,6 +71,25 @@ module SpecHelper
   end
 end
+FIXTURE_DIR = File.expand_path(File.join(File.dirname(__FILE__), "fixtures"))
+Spec::Matchers.define :be_an_existing_file do
+  match { |filename| File.exist?(filename) }
+end
+Spec::Matchers.define :be_an_existing_directory do
+  match { |filename| File.directory?(filename) }
+end
+Spec::Matchers.define :match_content_of do |expected|
+  match do |actual|
+    raise "expected file doesn't exist" unless File.exist?(expected)
+    raise "actual file doesn't exist"   unless File.exist?(actual)
+    open(expected).read == open(actual).read
+  end
+end
 Spec::Runner.configure do |config|
   config.before(:each) do
     Cucumber::Parser::NaturalLanguage.instance_variable_set(:@languages, nil)

data/tmp/{features/.gitignore → .gitignore} RENAMED Viewed

File without changes

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: butternut
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
   - Jeremy Stephens
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2009-11-10 00:00:00 Z
+date: 2009-12-14 00:00:00 Z
 default_executable:
 dependencies:
   - !ruby/object:Gem::Dependency
@@ -86,8 +86,7 @@ files:
   - spec/fixtures/picard.jpg
   - spec/spec.opts
   - spec/spec_helper.rb
-  - tmp/features/.gitignore
-  - tmp/main/.gitignore
+  - tmp/.gitignore
 has_rdoc: true
 homepage: http://github.com/viking/butternut
 licenses: []

data/tmp/main/.gitignore DELETED Viewed

	@@ -1,2 +0,0 @@
1	- *
2	- !.gitignore