mobiusloop 0.1.2

data/lib/cucumber/filters/apply_after_hooks.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Filters
+    class ApplyAfterHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        hooks.apply_after_hooks(test_case).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_after_step_hooks.rb

@@ -0,0 +1,12 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Filters
+    class ApplyAfterStepHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        test_steps = hooks.find_after_step_hooks(test_case).apply(test_case.test_steps)
+        test_case.with_steps(test_steps).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_around_hooks.rb

@@ -0,0 +1,12 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Filters
+    class ApplyAroundHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        around_hooks = hooks.find_around_hooks(test_case)
+        test_case.with_around_hooks(around_hooks).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/apply_before_hooks.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Filters
+    class ApplyBeforeHooks < Core::Filter.new(:hooks)
+      def test_case(test_case)
+        hooks.apply_before_hooks(test_case).describe_to(receiver)
+      end
+    end
+  end
+end

data/lib/cucumber/filters/gated_receiver.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module Filters
+
+    class GatedReceiver
+      def initialize(receiver)
+        @receiver = receiver
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        @test_cases.map do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+        self
+      end
+    end
+
+  end
+end

data/lib/cucumber/filters/prepare_world.rb

@@ -0,0 +1,45 @@
+require 'cucumber/core/filter'
+require 'cucumber/core/ast/location'
+require 'cucumber/running_test_case'
+
+module Cucumber
+  module Filters
+
+    class PrepareWorld < Core::Filter.new(:runtime)
+
+      def test_case(test_case)
+        CaseFilter.new(runtime, test_case).test_case.describe_to receiver
+      end
+
+      class CaseFilter
+        def initialize(runtime, original_test_case)
+          @runtime, @original_test_case = runtime, original_test_case
+        end
+
+        def test_case
+          init_scenario = Cucumber::Hooks.around_hook(@original_test_case.source) do |continue|
+            @runtime.begin_scenario(scenario)
+            continue.call
+            @runtime.end_scenario(scenario)
+          end
+          around_hooks = [init_scenario] + @original_test_case.around_hooks
+
+          empty_hook = proc {} #no op - legacy format adapter expects a before hooks
+          empty_hook_location = Cucumber::Core::Ast::Location.from_source_location(*empty_hook.source_location)
+          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source, empty_hook_location, &empty_hook)
+          steps = [default_hook] + @original_test_case.test_steps
+
+          @original_test_case.with_around_hooks(around_hooks).with_steps(steps)
+        end
+
+        private
+
+        def scenario
+          @scenario ||= RunningTestCase.new(test_case)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/filters/quit.rb

@@ -0,0 +1,28 @@
+module Cucumber
+  module Filters
+
+    class Quit
+      def initialize(receiver=nil)
+        @receiver = receiver
+      end
+
+      def test_case(test_case)
+        unless Cucumber.wants_to_quit
+          test_case.describe_to @receiver
+        end
+        self
+      end
+
+      def done
+        @receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(receiver)
+      end
+    end
+
+  end
+end
+

data/lib/cucumber/filters/randomizer.rb

@@ -0,0 +1,45 @@
+require 'digest/sha2'
+
+module Cucumber
+  module Filters
+
+    # Batches up all test cases, randomizes them, and then sends them on
+    class Randomizer
+      def initialize(seed, receiver=nil)
+        @receiver = receiver
+        @test_cases = []
+        @seed = seed
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+        self
+      end
+
+      def done
+        shuffled_test_cases.each do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(@seed, receiver)
+      end
+
+      private
+
+      def shuffled_test_cases
+        digester = Digest::SHA2.new(256)
+        @test_cases.map.with_index.
+          sort_by { |_, index| digester.digest((@seed + index).to_s) }.
+          map { |test_case, _| test_case }
+      end
+
+      attr_reader :seed
+      private :seed
+    end
+
+  end
+end

data/lib/cucumber/filters/retry.rb

@@ -0,0 +1,32 @@
+require 'cucumber/core/filter'
+require 'cucumber/running_test_case'
+require 'cucumber/events/bus'
+require 'cucumber/events/after_test_case'
+
+module Cucumber
+  module Filters
+    class Retry < Core::Filter.new(:configuration)
+
+      def test_case(test_case)
+        configuration.on_event(:after_test_case) do |event|
+          next unless retry_required?(test_case, event)
+
+          test_case_counts[test_case] += 1
+          event.test_case.describe_to(receiver)
+        end
+
+        super
+      end
+
+      private
+
+      def retry_required?(test_case, event)
+        event.test_case == test_case && event.result.failed? && test_case_counts[test_case] < configuration.retry_attempts
+      end
+
+      def test_case_counts
+        @test_case_counts ||= Hash.new {|h,k| h[k] = 0 }
+      end
+    end
+  end
+end

data/lib/cucumber/filters/tag_limits.rb

@@ -0,0 +1,45 @@
+require "cucumber/filters/gated_receiver"
+require "cucumber/filters/tag_limits/test_case_index"
+require "cucumber/filters/tag_limits/verifier"
+
+module Cucumber
+  module Filters
+    class TagLimitExceededError < StandardError
+      def initialize(*limit_breaches)
+        super(limit_breaches.map(&:to_s).join("\n"))
+      end
+    end
+
+    class TagLimits
+      def initialize(tag_limits, receiver=nil)
+        @tag_limits = tag_limits
+        @gated_receiver = GatedReceiver.new(receiver)
+        @test_case_index = TestCaseIndex.new
+        @verifier = Verifier.new(@tag_limits)
+      end
+
+      def test_case(test_case)
+        gated_receiver.test_case(test_case)
+        test_case_index.add(test_case)
+        self
+      end
+
+      def done
+        verifier.verify!(test_case_index)
+        gated_receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(@tag_limits, receiver)
+      end
+
+      private
+
+      attr_reader :gated_receiver
+      attr_reader :test_case_index
+      attr_reader :verifier
+    end
+
+  end
+end

data/lib/cucumber/filters/tag_limits/test_case_index.rb

@@ -0,0 +1,31 @@
+module Cucumber
+  module Filters
+    class TagLimits
+
+      class TestCaseIndex
+        def initialize
+          @index = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def add(test_case)
+          test_case.tags.map(&:name).each do |tag_name|
+            index[tag_name] << test_case
+          end
+        end
+
+        def count_by_tag_name(tag_name)
+          index[tag_name].count
+        end
+
+        def locations_of_tag_name(tag_name)
+          index[tag_name].map(&:location)
+        end
+
+        private
+
+        attr_accessor :index
+      end
+
+    end
+  end
+end

data/lib/cucumber/filters/tag_limits/verifier.rb

@@ -0,0 +1,59 @@
+module Cucumber
+  module Filters
+    class TagLimits
+
+      class Verifier
+        def initialize(tag_limits)
+          @tag_limits = tag_limits
+        end
+
+        def verify!(test_case_index)
+          breaches = collect_breaches(test_case_index)
+          raise TagLimitExceededError.new(*breaches) unless breaches.empty?
+        end
+
+        private
+
+        def collect_breaches(test_case_index)
+          tag_limits.reduce([]) do |breaches, (tag_name, limit)|
+            breaches.tap do |breaches|
+              if test_case_index.count_by_tag_name(tag_name) > limit
+                breaches << Breach.new(tag_name, limit, test_case_index.locations_of_tag_name(tag_name))
+              end
+            end
+          end
+        end
+
+        attr_reader :tag_limits
+
+        class Breach
+          INDENT = (" " * 2).freeze
+
+          def initialize(tag_name, limit, locations)
+            @tag_name = tag_name
+            @limit = limit
+            @locations = locations
+          end
+
+          def to_s
+            [
+              "#{tag_name} occurred #{tag_count} times, but the limit was set to #{limit}",
+              *locations.map(&:to_s)
+            ].join("\n#{INDENT}")
+          end
+
+          private
+
+          def tag_count
+            locations.count
+          end
+
+          attr_reader :tag_name
+          attr_reader :limit
+          attr_reader :locations
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/ansicolor.rb

@@ -0,0 +1,160 @@
+require 'cucumber/platform'
+require 'cucumber/term/ansicolor'
+
+if Cucumber::WINDOWS_MRI
+  unless ENV['ANSICON']
+    STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get coloured output on Windows}
+    Cucumber::Term::ANSIColor.coloring = false
+  end
+end
+
+Cucumber::Term::ANSIColor.coloring = false if !STDOUT.tty? && !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.
+    #
+    # Although not listed, you can also use <tt>grey</tt>.
+    #
+    # Examples: (On Windows, use SET instead of export.)
+    #
+    #   export CUCUMBER_COLORS="passed=white"
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Cucumber::Term::ANSIColor.attributes"
+    #
+    module ANSIColor
+      include Cucumber::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
+
+      # Eval to define the color-named methods required by Term::ANSIColor.
+      #
+      # Examples:
+      #
+      #   def failed(string=nil, &proc)
+      #     red(string, &proc)
+      #   end
+      #
+      #   def failed_param(string=nil, &proc)
+      #     red(bold(string, &proc)) + red
+      #   end
+      ALIASES.each_key do |method_name|
+        unless method_name =~ /.*_param/
+          code = <<-EOF
+          def #{method_name}(string=nil, &proc)
+            #{ALIASES[method_name].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method_name}_param(string=nil, &proc)
+            #{ALIASES[method_name+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method_name+'_param'].split(",").length} + #{ALIASES[method_name].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
+            ::Cucumber::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(string) #:nodoc:
+          if ::Cucumber::Term::ANSIColor.coloring?
+            "\e[90m#{string}\e[0m"
+          else
+            string
+          end
+        end
+      end
+
+      define_grey
+
+      def cukes(n)
+        ("(::) " * n).strip
+      end
+
+      def green_cukes(n)
+        blink(green(cukes(n)))
+      end
+
+      def red_cukes(n)
+        blink(red(cukes(n)))
+      end
+
+      def yellow_cukes(n)
+        blink(yellow(cukes(n)))
+      end
+    end
+  end
+end