kosmas58-cucumber 0.1.99.21 → 0.1.99.22

data/lib/cucumber/core_ext/exception.rb

@@ -1,53 +0,0 @@
-# Exception extension that tweaks Exception backtraces:
-#
-# * The line of the failing .feature line is appended to the backtrace
-# * The line that calls #cucumber_instance_exec is replaced with the StepDefinition's regexp
-# * Non intersting lines are stripped out
-#
-# The result is that backtraces look like this:
-#
-#   features/step_definitions/the_step_definition.rb:in `/some step/'
-#   features/the_feature_file.feature:41:in `Given some step'
-#
-# or if the exception is raised in the tested code:
-#
-#   lib/myapp/some_file.rb:in `/some_method/'
-#   lib/myapp/some_other_file.rb:in `/some_other_method/'
-#   features/step_definitions/the_step_definition.rb:in `/some step/'
-#   features/the_feature_file.feature:41:in `Given some step'
-#
-# All backtrace munging can be turned off with the <tt>--backtrace</tt> switch
-#
-class Exception
-  CUCUMBER_FILTER_PATTERNS = [
-    /vendor\/rails|lib\/cucumber|lib\/rspec|gems\//
-  ]
-
-  INSTANCE_EXEC_OFFSET = (Cucumber::RUBY_1_9 || Cucumber::JRUBY) ? -3 : -4
-
-  def self.cucumber_full_backtrace=(v)
-    @@cucumber_full_backtrace = v
-  end
-  self.cucumber_full_backtrace = false
-
-  # Strips the backtrace from +line+ and down
-  def self.cucumber_strip_backtrace!(backtrace, instance_exec_invocation_line, pseudo_method)
-    return if @@cucumber_full_backtrace
-
-    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
-    if instance_exec_pos
-      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
-      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
-      backtrace[replacement_line+1..-1] = nil
-
-      backtrace.compact!
-    else
-      # This happens with rails, because they screw up the backtrace
-      # before we get here (injecting erb stacktrace and such)
-    end
-
-    backtrace.reject! do |line|
-      CUCUMBER_FILTER_PATTERNS.detect{|p| line =~ p}
-    end
-  end
-end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -1,54 +0,0 @@
-require 'cucumber/platform'
-
-module Cucumber
-  class ArityMismatchError < StandardError
-  end
-end
-
-class Object
-  def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
-    arity = block.arity
-    arity = 0 if arity == -1
-    cucumber_run_with_backtrace_filtering(pseudo_method) do
-      if check_arity && args.length != arity
-        instance_exec do
-          raise Cucumber::ArityMismatchError.new("expected #{arity} block argument(s), got #{args.length}")
-        end
-      else
-        instance_exec(*args, &block)
-      end
-    end
-  end
-  
-  def cucumber_run_with_backtrace_filtering(pseudo_method)
-    begin
-      yield
-    rescue Exception => e
-      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
-      Exception.cucumber_strip_backtrace!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
-      raise e
-    end
-  end
-  
-  unless defined? instance_exec # 1.9
-    # http://eigenclass.org/hiki/bounded+space+instance_exec
-    module InstanceExecHelper; end
-    include InstanceExecHelper
-    def instance_exec(*args, &block)
-      begin
-        old_critical, Thread.critical = Thread.critical, true
-        n = 0
-        n += 1 while respond_to?(mname="__instance_exec#{n}")
-        InstanceExecHelper.module_eval{ define_method(mname, &block) }
-      ensure
-        Thread.critical = old_critical
-      end
-      begin
-        ret = send(mname, *args)
-      ensure
-        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-      end
-      ret
-    end
-  end
-end

data/lib/cucumber/core_ext/proc.rb

@@ -1,33 +0,0 @@
-# Proc extension to get more location info out of a proc
-class Proc
-  PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
-  
-  if Proc.new{}.to_s =~ PROC_PATTERN
-    def to_backtrace_line(name)
-      "#{file_colon_line}:in `#{name}'"
-    end
-
-    def to_comment_line
-      "# #{file_colon_line}"
-    end
-
-    def file_colon_line
-      path, line = *to_s.match(PROC_PATTERN)[1..2]
-      path = File.expand_path(path)
-      pwd = Dir.pwd
-      path = path[pwd.length+1..-1]
-      "#{path}:#{line}"
-    end
-  else
-    # This Ruby implementation doesn't implement Proc#to_s correctly
-    STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
-    
-    def to_backtrace_line
-      nil
-    end
-
-    def to_comment_line
-      ""
-    end
-  end
-end 

data/lib/cucumber/core_ext/string.rb

@@ -1,48 +0,0 @@
-class String
-  def indent(n)
-    if n >= 0
-      gsub(/^/, ' ' * n)
-    else
-      gsub(/^ {0,#{-n}}/, "")
-    end
-  end
-  
-  # re.source.gsub(/\([^)]*\)/, '$var')
-  # Cumulative #sub
-  def subs(re, *args)
-    args.inject(self) do |s,arg|
-      s.sub(re, arg)
-    end
-  end
-
-  # TODO: Use subs instead...
-  def gzub(regexp, format=nil, &proc)
-    md = match(regexp)
-    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
-    
-    s = dup
-    pos = 0
-    md.captures.each_with_index do |m, n|
-      replacement = if block_given?
-        proc.call(m)
-      elsif Proc === format
-        format.call(m)
-      else
-        format % m
-      end
-      
-      if md.offset(n+1)[0]
-        s[md.offset(n+1)[0] + pos, m.length] = replacement
-        pos += replacement.length - m.length
-      end
-    end
-    s
-  end
-
-  if (Cucumber::JRUBY && Cucumber::RAILS) || Cucumber::RUBY_1_9
-    # Workaround for http://tinyurl.com/55uu3u 
-    alias jlength length
-  else
-    require 'jcode'
-  end
-end

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,103 +0,0 @@
-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
-end
-
-Term::ANSIColor.coloring = false if !STDOUT.tty? || (Cucumber::WINDOWS && !Cucumber::WINDOWS_MRI)
-
-module Cucumber
-  module Formatter
-    # Defines aliases for coloured output. You can tweak the colours by defining
-    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like 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
-
-      # Not supported in Term::ANSIColor
-      def grey(m)
-        if ::Term::ANSIColor.coloring?
-          "\e[90m#{m}\e[0m"
-        else
-          m
-        end
-      end
-
-      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',
-        'thead'     => 'cyan',
-        '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
-    end
-  end
-end

data/lib/cucumber/formatter/color_io.rb

@@ -1,17 +0,0 @@
-require 'forwardable'
-
-module Cucumber
-  module Formatter
-    # Adapter to make #puts/#print/#flush work with colours on Windows
-    class ColorIO
-      extend Forwardable
-      def_delegators :@kernel, :puts, :print # win32console colours only work when sent to Kernel
-      def_delegators :@stdout, :flush, :tty?
-
-      def initialize
-        @kernel = Kernel
-        @stdout = STDOUT
-      end
-    end
-  end
-end

data/lib/cucumber/formatter/console.rb

@@ -1,119 +0,0 @@
-require 'cucumber/formatter/ansicolor'
-
-module Cucumber
-  module Formatter
-    module Console
-      extend ANSIColor
-      FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
-
-      def format_step(keyword, step_name, status, step_definition, source_indent)
-        comment = if source_indent && step_definition
-          c = (' # ' + step_definition.file_colon_line).indent(source_indent)
-          format_string(c, :comment)
-        else
-          ''
-        end
-
-        begin
-          line = keyword + " " + step_definition.format_args(step_name, format_for(status, :param)) + comment
-        rescue
-          # It didn't match. This often happens for :outline steps
-          line = keyword + " " + step_name + comment
-        end
-
-        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_undefined_scenarios(features)
-        elements = features.scenarios.select{|scenario| scenario.undefined?}
-        print_elements(elements, :undefined, 'scenarios')
-      end
-
-      def print_steps(features, status)
-        print_elements(features.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, 0)
-          else
-            @io.puts(format_string(element.backtrace_line, status))
-          end
-          @io.puts
-          @io.flush
-        end
-      end
-
-      def print_counts(features)
-        @io.puts dump_count(features.scenarios.length, "scenario")
-
-        [:failed, :skipped, :undefined, :pending, :passed].each do |status|
-          if features.steps[status].any?
-            count_string = dump_count(features.steps[status].length, "step", status.to_s)
-            @io.puts format_string(count_string, status)
-            @io.flush
-          end
-        end
-      end
-
-      def print_exception(e, indent)
-        status = Cucumber::EXCEPTION_STATUS[e.class]
-        @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
-      end
-
-      def print_snippets(features, options)
-        return unless options[:snippets]
-        undefined = features.steps[:undefined]
-        return if undefined.empty?
-        snippets = undefined.map do |step|
-          step_name = Undefined === step.exception ? step.exception.step_name : step.name
-          snippet = @step_mother.snippet_text(step.actual_keyword, step_name)
-          snippet
-        end.compact.uniq
-
-        text = "\nYou can implement step definitions for missing steps with these snippets:\n\n"
-        text += snippets.join("\n\n")
-
-        @io.puts format_string(text, :undefined)
-        @io.puts
-        @io.flush
-      end
-
-    private
-
-      def with_color
-        c = Term::ANSIColor.coloring?
-        Term::ANSIColor.coloring = @io.tty?
-        yield
-        Term::ANSIColor.coloring = c
-      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
-    end
-  end
-end

data/lib/cucumber/formatter/cucumber.css

@@ -1,55 +0,0 @@
-
-
-
-
-
-.cucumber {
-  background: black;
-  color: white;
-  padding: 1em;
-}
-.cucumber .passed {
-  color: green;
-}
-.cucumber .undefined {
-  color: yellow;
-}
-.cucumber .pending {
-  color: yellow;
-}
-.cucumber .failed {
-  color: red;
-}
-.cucumber .skipped {
-  color: cyan;
-}
-.cucumber .outline {
-  color: cyan;
-}
-.cucumber .param {
-  font-weight: bold;
-}
-.cucumber a {
-  text-decoration: none;
-  color: inherit;
-}
-.cucumber a:hover {
-  text-decoration: underline;
-}
-.cucumber a:visited {
-  font-weight: normal;
-}
-.cucumber ol {
-  list-style: none;
-}
-.cucumber .stats {
-  margin: 2em;
-}
-.cucumber .summary ul.features li {
-  display: inline;
-}
-.cucumber .backtrace {
-  margin-top: 0;
-  margin-bottom: 0;
-  margin-left: 1em;
-}

data/lib/cucumber/formatter/cucumber.sass

@@ -1,49 +0,0 @@
-# cucumber.css is generated from cucumber.sass
-# Regenerate with the following command:
-#
-#   sass -t expanded lib/cucumber/formatter/cucumber.sass > lib/cucumber/formatter/cucumber.css
-#
-.cucumber
-  :background black
-  :color white
-  :padding 1em
-
-  .passed
-    :color green
-  .undefined
-    :color yellow
-  .pending
-    :color yellow
-  .failed
-    :color red
-  .skipped
-    :color cyan
-  .outline
-    :color cyan
-  .param
-    :font-weight bold
-
-  a
-    :text-decoration none
-    :color inherit
-
-    &:hover
-      :text-decoration underline
-    &:visited
-      :font-weight normal
-
-  ol
-    :list-style none
-
-  .stats
-    :margin 2em
-
-  .summary
-    ul.features
-      li
-        :display inline
-
-  .backtrace
-    :margin-top 0
-    :margin-bottom 0
-    :margin-left 1em

data/lib/cucumber/formatter/html.rb

@@ -1,121 +0,0 @@
-require 'builder'
-
-module Cucumber
-  module Formatter
-    class Html < Ast::Visitor
-      def initialize(step_mother, io, options)
-        super(step_mother)
-        @builder = Builder::XmlMarkup.new(:target => io, :indent => 2)
-      end
-      
-      def visit_features(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.title 'Cucumber'
-            inline_css
-          end
-          @builder.body do
-            @builder.div(:class => 'cucumber') do
-              super
-            end
-          end
-        end
-      end
-
-      def visit_feature(feature)
-        @builder.div(:class => 'feature') do
-          super
-        end
-      end
-
-      def visit_feature_name(name)
-        lines = name.split(/\r?\n/)
-        @builder.h2(lines[0])
-        @builder.p do
-          lines[1..-1].each do |line|
-            @builder.text!(line.strip)
-            @builder.br
-          end
-        end
-      end
-
-      def visit_background(background)
-        @builder.div(:class => 'background') do
-          @builder.ol do
-            super
-          end
-        end
-      end
-
-      def visit_feature_element(feature_element)
-        @builder.div(:class => 'scenario') do
-          super
-        end
-        @open_step_list = true
-      end
-      
-      def visit_scenario_name(keyword, name, file_line, source_indent)
-        @builder.h3("#{keyword} #{name}")
-      end
-
-      def visit_outline_table(outline_table)
-        @builder.table do
-          super(outline_table)
-        end
-      end
-
-      def visit_examples_name(keyword, name)
-        @builder.h4("#{keyword} #{name}")
-      end
-
-      def visit_steps(scenarios)
-        @builder.ol do
-          super
-        end
-      end
-
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
-        @builder.li("#{keyword} #{step_name}", :class => status)
-      end
-
-      def visit_multiline_arg(multiline_arg, status)
-        if Ast::Table === multiline_arg
-          @builder.table do
-            super(multiline_arg, status)
-          end
-        else
-          @builder.p do
-            super(multiline_arg, status)
-          end
-        end
-      end
-
-      def visit_table_row(table_row, status)
-        @builder.tr do
-          super(table_row, status)
-        end
-      end
-
-      def visit_table_cell_value(value, width, status)
-        @builder.td(value, :class => status)
-      end
-
-      private
-
-      def inline_css
-        @builder.style(:type => 'text/css') do
-          @builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
-        end
-      end
-
-    end
-  end
-end