mack 0.8.2 → 0.8.3

data/lib/gems/cucumber-0.1.15/lib/cucumber/core_ext/exception.rb

@@ -0,0 +1,20 @@
+class Exception
+  CUCUMBER_FILTER_PATTERNS = [
+    /vendor\/rails/, 
+    /vendor\/plugins\/cucumber/, 
+    /vendor\/plugins\/rspec/,
+    /gems\/rspec/
+  ]
+
+  def self.cucumber_full_backtrace=(v)
+    @@cucumber_full_backtrace = v
+  end
+  self.cucumber_full_backtrace = false
+
+  def cucumber_backtrace
+    return (backtrace || []) if @@cucumber_full_backtrace
+    (backtrace || []).map {|b| b.split("\n") }.flatten.reject do |line|
+      CUCUMBER_FILTER_PATTERNS.detect{|p| line =~ p}
+    end.map { |line| line.strip }
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,69 @@
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+
+  module CoreExt
+    # Proc extension that allows a proc to be called in the context of any object.
+    # Also makes it possible to tack a name onto a Proc.
+    module CallIn
+      PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
+      
+      if Proc.new{}.to_s =~ PROC_PATTERN
+        def to_backtrace_line
+          "#{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
+      
+      attr_accessor :name
+      
+      def call_in(obj, *args)
+        obj.extend(mod)
+        if self != StepMother::PENDING && args.length != arity2
+          # We have to manually raise when the block has arity -1 (no pipes)
+          raise ArityMismatchError.new("expected #{arity2} block argument(s), got #{args.length}")
+        else
+          obj.__send__(meth, *args)
+        end
+      end
+
+      def arity2
+        arity == -1 ? 0 : arity
+      end
+
+      def meth
+        @meth ||= "__cucumber_#{object_id}"
+      end
+
+      def mod
+        p = self
+        m = meth
+        @mod ||= Module.new do
+          define_method(m, &p)
+        end
+      end
+    end 
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,29 @@
+class String
+  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)
+      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/gems/cucumber-0.1.15/lib/cucumber/executor.rb

@@ -0,0 +1,205 @@
+module Cucumber
+  class Executor
+    attr_reader :failed
+    attr_accessor :formatters
+    attr_writer :scenario_names, :lines_for_features
+
+    def initialize(step_mother)
+      @world_procs = []
+      @before_scenario_procs = []
+      @after_scenario_procs = []
+      @after_step_procs = []
+      @step_mother = step_mother
+
+      @executed_scenarios = {}
+      @regular_scenario_cache = {}
+    end
+
+    def register_world_proc(&proc)
+      @world_procs << proc
+    end
+
+    def register_before_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @before_scenario_procs << proc
+    end
+
+    def register_after_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_scenario_procs << proc
+    end
+
+    def register_after_step_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_step_procs << proc
+    end
+
+    def visit_features(features)
+      formatters.visit_features(features)
+      features.accept(self)
+      formatters.dump
+    end
+
+    def visit_feature(feature)
+      @feature_file = feature.file
+            
+      if accept_feature?(feature)
+        formatters.feature_executing(feature)
+        feature.accept(self)
+        @executed_scenarios = {}
+        @regular_scenario_cache = {}
+      end
+    end
+
+    def visit_header(header)
+      formatters.header_executing(header)
+    end
+
+    def visit_row_scenario(scenario)
+      execute_scenario(@regular_scenario_cache[scenario.name]) if executing_unprepared_row_scenario?(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_regular_scenario(scenario)
+      @regular_scenario_cache[scenario.name] = scenario
+      visit_scenario(scenario)
+    end
+
+    def visit_scenario_outline(scenario)
+      visit_regular_scenario(scenario)
+    end
+
+    def visit_scenario(scenario)
+      if accept_scenario?(scenario)
+        @executed_scenarios[scenario.name] = true
+        execute_scenario(scenario)
+      end
+    end
+
+    def execute_scenario(scenario)
+      @error = nil
+      @pending = nil
+
+      @world = create_world
+
+      formatters.scenario_executing(scenario)
+      @before_scenario_procs.each{|p| p.call_in(@world, *[])}
+      scenario.accept(self)
+      @after_scenario_procs.each{|p| p.call_in(@world, *[])}
+      formatters.scenario_executed(scenario)
+    end
+    
+    def accept_scenario?(scenario)
+      scenario_at_specified_line?(scenario) &&
+      scenario_has_specified_name?(scenario)
+    end
+
+    def accept_feature?(feature)
+      feature.scenarios.any? { |s| accept_scenario?(s) }
+    end
+
+    def visit_row_step(step)
+      visit_step(step)
+    end
+
+    def visit_regular_step(step)
+      visit_step(step)
+    end
+
+    def visit_step_outline(step)
+      regexp, args, proc = step.regexp_args_proc(@step_mother)
+      formatters.step_traced(step, regexp, args)
+    end
+
+    def visit_step(step)
+      unless @pending || @error
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          formatters.step_executing(step, regexp, args)
+          step.execute_in(@world, regexp, args, proc)
+          @after_step_procs.each{|p| p.call_in(@world, *[])}
+          formatters.step_passed(step, regexp, args)
+        rescue ForcedPending => e
+          step.error = e
+          record_pending_step(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue => e
+          @failed = true
+          @error = step.error = e
+          formatters.step_failed(step, regexp, args)
+        end
+      else
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          step.execute_in(@world, regexp, args, proc)
+          formatters.step_skipped(step, regexp, args)
+        rescue ForcedPending => e
+          step.error = e
+          record_pending_step(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue Exception
+          formatters.step_skipped(step, regexp, args)
+        end
+      end
+    end
+
+    def record_pending_step(step, regexp, args)
+      @pending = true
+      formatters.step_pending(step, regexp, args)
+    end
+
+    def executing_unprepared_row_scenario?(scenario)
+      accept_scenario?(scenario) && !@executed_scenarios[scenario.name]
+    end
+    
+    def scenario_at_specified_line?(scenario)
+      if lines_defined_for_current_feature?
+        @lines_for_features[@feature_file].inject(false) { |at_line, line| at_line || scenario.at_line?(line) }
+      else
+        true
+      end
+    end
+    
+    def scenario_has_specified_name?(scenario)
+      if @scenario_names && !@scenario_names.empty?
+        @scenario_names.include?(scenario.name)
+      else
+        true
+      end
+    end
+    
+    def lines_defined_for_current_feature?
+      @lines_for_features && !@lines_for_features[@feature_file].nil? && !@lines_for_features[@feature_file].empty?
+    end
+    
+    def create_world
+      world = Object.new
+      @world_procs.each do |world_proc|
+        world = world_proc.call(world)
+      end
+
+      world.extend(World::Pending)
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      define_step_call_methods(world)
+      world
+    end
+
+    def define_step_call_methods(world)
+      world.instance_variable_set('@__executor', self)
+      world.instance_eval do
+        class << self
+          def run_step(name)
+            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
+            proc.call_in(self, *args)
+          end
+
+          %w{given when then and but}.each do |keyword|
+            alias_method Cucumber.language[keyword], :run_step
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gems/cucumber-0.1.15/lib/cucumber/formatters.rb

@@ -0,0 +1 @@
+%w{html pretty progress profile autotest}.each{|n| require "cucumber/formatters/#{n}_formatter"}

data/lib/gems/cucumber-0.1.15/lib/cucumber/formatters/ansicolor.rb

@@ -0,0 +1,105 @@
+# Hack to work around Win32/Console, which bundles a licence-violating, outdated
+# copy of term/ansicolor that doesn't implement Term::ANSIColor#coloring=.
+# We want the official one!
+gem 'term-ansicolor'
+$LOAD_PATH.each{|path| $LOAD_PATH.unshift($LOAD_PATH.delete(path)) if path =~ /term-ansicolor/}
+require 'term/ansicolor'
+
+if Cucumber::WINDOWS_MRI
+  begin
+    require 'Win32/Console/ANSI'
+  rescue LoadError
+    STDERR.puts "You must gem install win32console 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 Formatters
+    # 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>missing</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>blue</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({
+        'missing' => 'yellow',
+        'pending' => 'yellow',
+        'failed'  => 'red',
+        'passed'  => 'green',
+        'outline' => 'cyan',
+        'skipped' => 'cyan',
+        'comment' => 'grey',
+        'tag'     => 'blue'
+      })
+
+      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/gems/cucumber-0.1.15/lib/cucumber/formatters/autotest_formatter.rb

@@ -0,0 +1,23 @@
+require 'cucumber/formatters/ansicolor'
+
+module Cucumber
+  module Formatters
+    class AutotestFormatter
+      def initialize(io)
+        @io = io
+        @failed_scenarios = []
+      end
+      
+      def step_didnt_pass(step, regexp, args)
+        unless @failed_scenarios.include? step.scenario.name
+          @failed_scenarios << step.scenario.name
+          @io.puts step.scenario.name
+        end
+      end
+      
+      alias step_failed  step_didnt_pass
+      alias step_pending step_didnt_pass
+      alias step_skipped step_didnt_pass
+    end
+  end
+end