dwaite-cucumber 0.3.101

data/lib/cucumber/feature_file.rb

@@ -0,0 +1,54 @@
+require 'cucumber/parser/natural_language'
+require 'cucumber/filter'
+
+module Cucumber
+  class FeatureFile
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/ #:nodoc:
+    LANGUAGE_PATTERN = /language:\s*(.*)/ #:nodoc:
+
+    # The +uri+ argument is the location of the source. It can ba a path 
+    # or a path:line1:line2 etc. If +source+ is passed, +uri+ is ignored.
+    def initialize(uri, source=nil)
+      @source = source
+      _, @path, @lines = *FILE_COLON_LINE_PATTERN.match(uri)
+      if @path
+        @lines = @lines.split(':').map { |line| line.to_i }
+      else
+        @path = uri
+      end
+    end
+    
+    # Parses a file and returns a Cucumber::Ast
+    # If +options+ contains tags, the result will
+    # be filtered.
+    def parse(step_mother, options)
+      filter = Filter.new(@lines, options)
+      language = Parser::NaturalLanguage.get(step_mother, (lang || options[:lang] || 'en'))
+      language.parse(source, @path, filter)
+    end
+    
+    def source
+      @source ||= if @path =~ /^http/
+        require 'open-uri'
+        open(@path).read
+      else
+        begin
+          File.open(@path, Cucumber.file_mode('r')).read 
+        rescue Errno::EACCES => e
+          p = File.expand_path(@path)
+          e.message << "\nCouldn't open #{p}"
+          raise e
+        end
+      end
+    end
+    
+    def lang
+      line_one = source.split(/\n/)[0]
+      if line_one =~ LANGUAGE_PATTERN
+        $1.strip
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/cucumber/filter.rb

@@ -0,0 +1,52 @@
+module Cucumber
+  # Filters the AST based on --tags and --name
+  class Filter #:nodoc:
+    def initialize(lines, options)
+      @lines = lines
+
+      @include_tags = options[:include_tags] ? options[:include_tags].keys : []
+      @exclude_tags = options[:exclude_tags] ? options[:exclude_tags].keys : []
+      @name_regexps = options[:name_regexps] || []
+    end
+
+    def accept?(syntax_node)
+      at_line?(syntax_node) &&
+      matches_tags?(syntax_node) &&
+      matches_names?(syntax_node)
+    end
+
+    def accept_example?(syntax_node, outline)
+      (at_line?(syntax_node) || outline_at_line?(outline)) &&
+      (matches_names?(syntax_node) || outline_matches_names?(outline))
+    end
+    
+    def at_line?(syntax_node)
+      @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.at_line?(line)}
+    end
+
+    def outline_at_line?(syntax_node)
+       @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.outline_at_line?(line)}
+    end
+
+    def matches_tags?(syntax_node)
+      !excluded_by_tags?(syntax_node) &&
+      included_by_tags?(syntax_node)
+    end
+
+    def included_by_tags?(syntax_node)
+      @include_tags.empty? || syntax_node.has_all_tags?(@include_tags)
+    end
+
+    def excluded_by_tags?(syntax_node)
+      @exclude_tags.any? && syntax_node.has_tags?(@exclude_tags)
+    end
+    
+    def outline_matches_names?(syntax_node)
+      @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.outline_matches_name?(name_regexp)}
+    end
+    
+    def matches_names?(syntax_node)
+      @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.matches_name?(name_regexp)}
+    end
+  end
+end

data/lib/cucumber/formatter/ansicolor.rb

@@ -0,0 +1,143 @@
+gem 'term-ansicolor'
+require 'term/ansicolor'
+
+if Cucumber::WINDOWS_MRI
+  begin
+    gem 'win32console', '>= 1.2.0'
+    require 'Win32/Console/ANSI'
+  rescue LoadError
+    STDERR.puts %{*** WARNING: You must "gem install win32console" (1.2.0 or higher) to get coloured output on MRI/Windows}
+    Term::ANSIColor.coloring = false
+  end
+elsif Cucumber::WINDOWS && Cucumber::JRUBY
+  begin
+    gem 'aslakhellesoy-ansicolor', '>= 1.0'
+    require 'ansicolor'
+  rescue LoadError
+    STDERR.puts %{*** WARNING: You must "gem install aslakhellesoy-ansicolor --source http://gems.github.com" (1.0 or higher) to get coloured output on JRuby/Windows}
+    Term::ANSIColor.coloring = false
+  end
+end
+
+Term::ANSIColor.coloring = false if !STDOUT.tty? and not ENV.has_key?("AUTOTEST")
+
+module Cucumber
+  module Formatter
+    # Defines aliases for coloured output. You don't invoke any methods from this
+    # module directly, but you can change the output colours by defining
+    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export CUCUMBER_COLORS="passed=white"
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module ANSIColor
+      include Term::ANSIColor
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comment'   => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, &proc)
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, &proc)
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+      
+      def self.define_grey #:nodoc:
+        begin
+          gem 'genki-ruby-terminfo'
+          require 'terminfo'
+          case TermInfo.default_object.tigetnum("colors")
+          when 0
+            raise "Your terminal doesn't support colours"
+          when 1
+            ::Term::ANSIColor.coloring = false
+            alias grey white
+          when 2..8
+            alias grey white
+          else
+            define_real_grey
+          end
+        rescue Exception => e
+          if e.class.name == 'TermInfo::TermInfoError'
+            STDERR.puts "*** WARNING ***"
+            STDERR.puts "You have the genki-ruby-terminfo gem installed, but you haven't set your TERM variable."
+            STDERR.puts "Try setting it to TERM=xterm-256color to get grey colour in output"
+            STDERR.puts "\n"
+            alias grey white
+          else
+            define_real_grey
+          end
+        end
+      end
+      
+      def self.define_real_grey #:nodoc:
+        def grey(m) #:nodoc:
+          if ::Term::ANSIColor.coloring?
+            "\e[90m#{m}\e[0m"
+          else
+            m
+          end
+        end
+      end
+      
+      define_grey
+      
+    end
+  end
+end

data/lib/cucumber/formatter/color_io.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+
+module Cucumber
+  module Formatter
+    # Adapter to make #puts/#print/#flush work with colours on Windows
+    class ColorIO #:nodoc:
+      extend Forwardable
+      def_delegators :@kernel, :puts, :print # win32console colours only work when sent to Kernel
+      def_delegators :@stdout, :flush, :tty?, :write, :close
+
+      def initialize
+        @kernel = Kernel
+        @stdout = STDOUT
+      end
+
+      # Ensure using << still gets colours in win32console
+      def <<(output)
+        print(output)
+        self
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -0,0 +1,185 @@
+require 'cucumber/formatter/ansicolor'
+require 'cucumber/formatter/duration'
+
+module Cucumber
+  module Formatter
+    # This module contains helper methods that are used by formatters
+    # that print output to the terminal.
+    module Console
+      extend ANSIColor
+      include Duration
+
+      FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
+
+      def format_step(keyword, step_match, status, source_indent)
+        comment = if source_indent
+          c = (' # ' + step_match.file_colon_line).indent(source_indent)
+          format_string(c, :comment)
+        else
+          ''
+        end
+
+        format = format_for(status, :param)
+        line = keyword + " " + step_match.format_args(format) + comment
+        format_string(line, status)
+      end
+
+      def format_string(string, status)
+        fmt = format_for(status)
+        if Proc === fmt
+          fmt.call(string)
+        else
+          fmt % string
+        end
+      end
+
+      def print_steps(status)
+        print_elements(step_mother.steps(status), status, 'steps')
+      end
+
+      def print_elements(elements, status, kind)
+        if elements.any?
+          @io.puts(format_string("(::) #{status} #{kind} (::)", status))
+          @io.puts
+          @io.flush
+        end
+
+        elements.each_with_index do |element, i|
+          if status == :failed
+            print_exception(element.exception, status, 0)
+          else
+            @io.puts(format_string(element.backtrace_line, status))
+          end
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def print_counts
+        STDERR.puts("The #print_counts method is deprecated and will be removed in 0.4. Use #print_stats instead")
+        print_stats(nil)
+      end
+
+      def print_stats(features)
+
+        @failures = step_mother.scenarios(:failed).select { |s| s.is_a?(Cucumber::Ast::Scenario) }
+
+        if !@failures.empty?
+          @io.puts format_string("Failing Scenarios:", :failed)
+          @failures.each do |failure|
+            @io.puts format_string("cucumber " + failure.file_colon_line, :failed) +
+            format_string(" # Scenario: " + failure.name, :comment)
+          end
+          @io.puts
+        end
+
+        @io.print dump_count(step_mother.scenarios.length, "scenario")
+        print_status_counts{|status| step_mother.scenarios(status)}
+
+        @io.print dump_count(step_mother.steps.length, "step")
+        print_status_counts{|status| step_mother.steps(status)}
+
+        @io.puts(format_duration(features.duration)) if features && features.duration
+
+        @io.flush
+      end
+
+      def print_exception(e, status, indent)
+        @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
+      end
+
+      def print_snippets(options)
+        return unless options[:snippets]
+        undefined = step_mother.steps(:undefined)
+        return if undefined.empty?
+        snippets = undefined.map do |step|
+          step_name = Undefined === step.exception ? step.exception.step_name : step.name
+          step_multiline_class = step.multiline_arg ? step.multiline_arg.class : nil
+          snippet = @step_mother.snippet_text(step.actual_keyword, step_name, step_multiline_class)
+          snippet
+        end.compact.uniq
+
+        text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
+        text += snippets.join("\n\n")
+
+        @io.puts format_string(text, :undefined)
+        @io.puts
+        @io.flush
+      end
+
+      def print_passing_wip(options)
+        return unless options[:wip]
+        passed = step_mother.scenarios(:passed)
+        if passed.any?
+          @io.puts format_string("\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:", :failed)
+          print_elements(passed, :passed, "scenarios")
+        else
+          @io.puts format_string("\nThe --wip switch was used, so the failures were expected. All is good.\n", :passed)
+        end
+      end
+
+      def print_tag_limit_warnings(options)
+        return unless tag_limit_breached?(options, @tag_occurences)
+        @io.puts
+        @io.puts format_string("Failed due to exceeding the tag limit", :failed)
+        options[:include_tags].each do |tag_name, limit|
+          tag_frequnecy = @tag_occurences[tag_name].size
+          if limit && tag_frequnecy > limit
+            @io.puts format_string("@#{tag_name} occurred:#{tag_frequnecy} limit:#{limit}", :failed)
+            @tag_occurences[tag_name].each {|location| @io.puts format_string("  #{location}", :failed)}
+            @io.flush
+          end
+        end
+      end
+
+      def record_tag_occurrences(feature_element, options)
+        @tag_occurences ||= Hash.new{|k,v| k[v] = []}
+        options[:include_tags].each do |tag_name, limit|
+          if feature_element.tag_count(tag_name) > 0
+            @tag_occurences[tag_name] << feature_element.file_colon_line
+          end
+        end
+      end
+
+      def announce(announcement)
+        @io.puts
+        @io.puts(format_string(announcement, :tag))
+        @io.flush
+      end
+
+    private
+
+      def print_status_counts
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = yield status
+          elements.any? ? format_string("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          @io.puts(" (#{counts.join(', ')})")
+        else
+          @io.puts
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+      def format_for(*keys)
+        key = keys.join('_').to_sym
+        fmt = FORMATS[key]
+        raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
+        fmt
+      end
+
+      def tag_limit_breached?(options, tag_occurences)
+        return if tag_occurences.nil?
+        tag_limit_breached = false
+        options[:include_tags].each do |tag_name, limit|
+          tag_limit_breached ||= limit && (tag_occurences[tag_name].size > limit)
+        end
+        tag_limit_breached
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/cucumber.css

@@ -0,0 +1,132 @@
+
+
+.cucumber {
+  font-family: "Lucida Grande", Helvetica, sans-serif;
+  font-size: 0.7em;
+  background: white;
+  padding: 1em;
+}
+.cucumber h1, .cucumber h2, .cucumber h3, .cucumber h4, .cucumber ol, .cucumber li, .cucumber pre, .cucumber p {
+  font-size: 1em;
+  padding: 0px;
+  margin: 0px;
+}
+.cucumber div.feature {
+  border: 1px solid;
+  padding: 2px;
+  margin: 4px;
+}
+.cucumber div.feature div.background, .cucumber div.feature div.scenario, .cucumber div.feature p {
+  padding: 0em 0em 0em 1em;
+}
+.cucumber div.feature div.background div.examples, .cucumber div.feature div.scenario div.examples, .cucumber div.feature p div.examples {
+  padding: 0em 0em 0em 1em;
+}
+.cucumber .stats {
+  margin: 2em;
+}
+.cucumber .summary ul.features li {
+  display: inline;
+}
+.cucumber .backtrace {
+  margin-top: 0;
+  margin-bottom: 0;
+  margin-left: 1em;
+}
+.cucumber a {
+  text-decoration: none;
+  color: inherit;
+}
+.cucumber a:hover {
+  text-decoration: underline;
+}
+.cucumber a:visited {
+  font-weight: normal;
+}
+.cucumber a div.examples {
+  border: 1px solid;
+  padding: 2px;
+  margin: 4px;
+}
+.cucumber table {
+  border-collapse: collapse;
+}
+.cucumber table td, .cucumber table th {
+  font-size: 0.7em;
+  border: 1px solid #AAAAAA;
+}
+.cucumber table td.failed {
+  background: #FFC0CB;
+  color: #8B0000;
+}
+.cucumber table td.passed {
+  background: #98FB98;
+  color: #001111;
+}
+.cucumber table td.skipped {
+  background: #e0ffff;
+  color: #001111;
+}
+.cucumber table td.pending {
+  background: #FFFFE0;
+  color: #111100;
+}
+.cucumber table td.undefined {
+  background: #FFFFE0;
+  color: #111100;
+}
+.cucumber ol {
+  list-style: none;
+}
+.cucumber ol li {
+  margin: 0em 0em 0em 1em;
+  padding: 0em 0em 0em 0.2em;
+}
+.cucumber ol li span.param {
+  font-weight: bold;
+}
+.cucumber ol li.failed {
+  border-left: 5px solid #ff0000;
+  border-bottom: 1px solid #ff0000;
+  background: #ffc0cb;
+  color: #8b0000;
+}
+.cucumber ol li.failed span.param {
+  background: !failed_dark;
+}
+.cucumber ol li.passed {
+  border-left: 5px solid #00ff00;
+  border-bottom: 1px solid #00ff00;
+  background: #98fb98;
+  color: #001111;
+}
+.cucumber ol li.passed span.param {
+  background: #00ff00;
+}
+.cucumber ol li.skipped {
+  border-left: 5px solid #00ffff;
+  border-bottom: 1px solid #00ffff;
+  background: #e0ffff;
+  color: #001111;
+}
+.cucumber ol li.skipped span.param {
+  background: #00ffff;
+}
+.cucumber ol li.pending {
+  border-left: 5px solid #ff8000;
+  border-bottom: 1px solid #ff8000;
+  background: #ffff00;
+  color: #2a1b0a;
+}
+.cucumber ol li.pending span.param {
+  background: #ff8000;
+}
+.cucumber ol li.undefined {
+  border-left: 5px solid #ff8000;
+  border-bottom: 1px solid #ff8000;
+  background: #ffff00;
+  color: #2a1b0a;
+}
+.cucumber ol li.undefined span.param {
+  background: #ff8000;
+}