mobiusloop 0.1.2

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String #:nodoc:
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+end

data/lib/cucumber/deprecate.rb

@@ -0,0 +1,29 @@
+require 'cucumber/platform'
+require 'cucumber/gherkin/formatter/ansi_escapes'
+
+module Cucumber
+  module Deprecate
+    module ForUsers
+      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
+
+      def self.call(message, method, remove_after_version)
+        STDERR.puts AnsiEscapes.failed + "\nWARNING: ##{method} is deprecated and will be removed after version #{remove_after_version}. #{message}.\n(Called from #{caller[2]})" + AnsiEscapes.reset
+      end
+    end
+
+    module ForDevelopers
+      def self.call(message, method, remove_after_version)
+        if Cucumber::VERSION > remove_after_version
+          raise "This method is due for removal after version #{remove_after_version}"
+        end
+      end
+    end
+
+    Strategy = $0.match(/rspec$/) ? ForDevelopers : ForUsers
+  end
+
+  def self.deprecate(*args)
+    Deprecate::Strategy.call(*args)
+  end
+
+end

data/lib/cucumber/encoding.rb

@@ -0,0 +1,5 @@
+# See https://github.com/cucumber/cucumber/issues/693
+if defined? Encoding
+  Encoding.default_external = 'utf-8'
+  Encoding.default_internal = 'utf-8'
+end

data/lib/cucumber/errors.rb

@@ -0,0 +1,51 @@
+require 'cucumber/core/test/result'
+
+module Cucumber
+  # Raised when there is no matching StepDefinition for a step.
+  class Undefined < Core::Test::Result::Undefined
+    def self.from(result, step_name)
+      if result.is_a?(self)
+        return result.with_message(with_prefix(result.message))
+      end
+
+      begin
+        raise self.new(with_prefix(step_name))
+      rescue => exception
+        return exception
+      end
+    end
+
+    def self.with_prefix(step_name)
+      %(Undefined step: "#{step_name}")
+    end
+  end
+
+  # Raised when there is no matching StepDefinition for a step called
+  # from within another step definition.
+  class UndefinedDynamicStep < StandardError
+    def initialize(step_name)
+      super %(Undefined dynamic step: "#{step_name}")
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < Core::Test::Result::Pending
+  end
+
+  # Raised when a step matches 2 or more StepDefinitions
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
+      super(message)
+    end
+  end
+
+  class TagExcess < StandardError
+    def initialize(messages)
+      super(messages.join("\n"))
+    end
+  end
+end

data/lib/cucumber/events.rb

@@ -0,0 +1,20 @@
+module Cucumber
+
+  # Events tell you what's happening while Cucumber runs your features.
+  #
+  # They're designed to be read-only, appropriate for writing formatters and other
+  # output tools. If you need to be able to influence the result of a scenario, use a hook instead.
+  #
+  # To subscribe to an event, use {Cucumber::Configuration#on_event}
+  #
+  # @example
+  #   AfterConfiguration do |config|
+  #     config.on_event :after_test_step do |event|
+  #       puts event.result
+  #     end
+  #   end
+  module Events
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/events/*.rb'].map(&method(:require))

data/lib/cucumber/events/after_test_case.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module Events
+
+    # Event fired after a test case has finished executing
+    class AfterTestCase
+
+      # The test case that was just executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The result of executing the test case.
+      #
+      # @return [Cucumber::Core::Test::Result]
+      attr_reader :result
+
+      # @private
+      def initialize(test_case, result)
+        @test_case, @result = test_case, result
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/events/after_test_step.rb

@@ -0,0 +1,30 @@
+module Cucumber
+  module Events
+
+    # Event fired after each test step has been executed
+    class AfterTestStep
+
+      # The test case currently being executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The test step that was just executed.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # The result of executing the test step.
+      #
+      # @return [Cucumber::Core::Test::Result]
+      attr_reader :result
+
+      # @private
+      def initialize(test_case, test_step, result)
+        @test_case, @test_step, @result = test_case, test_step, result
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/events/before_test_case.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module Events
+
+    # Event fired before a test case is executed
+    class BeforeTestCase
+
+      # The test case about to be executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # @private
+      def initialize(test_case)
+        @test_case = test_case
+      end
+    end
+  end
+end

data/lib/cucumber/events/before_test_step.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Events
+
+    # Event fired before a test step is executed
+    class BeforeTestStep
+
+      # The test case currently being executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The test step about to be executed.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # @private
+      def initialize(test_case, test_step)
+        @test_case, @test_step = test_case, test_step
+      end
+    end
+  end
+end

data/lib/cucumber/events/bus.rb

@@ -0,0 +1,86 @@
+module Cucumber
+  module Events
+
+    # Event bus
+    #
+    # Implements and in-process pub-sub events broadcaster allowing multiple observers
+    # to subscribe to different events that fire as your tests are executed.
+    #
+    # @private
+    class Bus
+
+      def initialize(default_namespace)
+        @default_namespace = default_namespace.to_s
+        @handlers = {}
+      end
+
+      # Register for an event
+      def register(event_id, handler_object = nil, &handler_proc)
+        handler = handler_proc || handler_object
+        raise ArgumentError.new("Please pass either an object or a handler block") unless handler
+        event_class = parse_event_id(event_id)
+        handlers_for(event_class) << handler
+      end
+
+      # Broadcast an event
+      def notify(event)
+        handlers_for(event.class).each { |handler| handler.call(event) }
+      end
+
+      private
+
+      def handlers_for(event_class)
+        @handlers[event_class.to_s] ||= []
+      end
+
+      def parse_event_id(event_id)
+        case event_id
+        when Class
+          return event_id
+        when String
+          constantize(event_id)
+        else
+          constantize("#{@default_namespace}::#{camel_case(event_id)}")
+        end
+      end
+
+      def camel_case(underscored_name)
+        underscored_name.to_s.split("_").map { |word| word.upcase[0] + word[1..-1] }.join
+      end
+
+      # Thanks ActiveSupport
+      # (Only needed to support Ruby 1.9.3 and JRuby)
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/events/finished_testing.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Events
+
+    # Event fired after aall test cases have finished executing
+    class FinishedTesting
+    end
+
+  end
+end

data/lib/cucumber/events/step_match.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Events
+
+    # Event fired when a step is matched to a definition
+    class StepMatch
+
+      # The test step that was matched.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # Information about the matching definition.
+      #
+      # @return [Cucumber::StepMatch]
+      attr_reader :step_match
+
+      # @private
+      def initialize(test_step, step_match)
+        @test_step, @step_match = test_step, step_match
+      end
+    end
+  end
+end

data/lib/cucumber/file_specs.rb

@@ -0,0 +1,37 @@
+require 'cucumber'
+require 'cucumber/core/ast/location'
+
+module Cucumber
+  class FileSpecs
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?)(?::([\d:]+))?$/ #:nodoc:
+
+    def initialize(file_specs)
+      Cucumber.logger.debug("Objectives:\n")
+      @file_specs = file_specs.map { |s| FileSpec.new(s) }
+      Cucumber.logger.debug("\n")
+    end
+
+    def locations
+      @file_specs.map(&:locations).flatten
+    end
+
+    def files
+      @file_specs.map(&:file).uniq
+    end
+
+    class FileSpec
+      def initialize(s)
+        @file, @lines = *FILE_COLON_LINE_PATTERN.match(s).captures
+        Cucumber.logger.debug("  * #{@file}\n")
+        @lines = String(@lines).split(':').map { |line| Integer(line) }
+      end
+
+      attr_reader :file
+
+      def locations
+        return [ Core::Ast::Location.new(@file) ] if @lines.empty?
+        @lines.map { |line| Core::Ast::Location.new(@file, line) }
+      end
+    end
+  end
+end

data/lib/cucumber/filters.rb

@@ -0,0 +1,9 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/filters/apply_after_step_hooks'
+require 'cucumber/filters/apply_before_hooks'
+require 'cucumber/filters/apply_after_hooks'
+require 'cucumber/filters/apply_around_hooks'
+require 'cucumber/filters/prepare_world'
+require 'cucumber/filters/quit'
+require 'cucumber/filters/randomizer'
+require 'cucumber/filters/tag_limits'

data/lib/cucumber/filters/activate_steps.rb

@@ -0,0 +1,67 @@
+require 'cucumber/core/filter'
+require 'cucumber/step_match'
+require 'cucumber/events'
+require 'cucumber/errors'
+
+module Cucumber
+  module Filters
+    class ActivateSteps < Core::Filter.new(:step_match_search, :configuration)
+
+      def test_case(test_case)
+        CaseFilter.new(test_case, step_match_search, configuration).test_case.describe_to receiver
+      end
+
+      class CaseFilter
+        def initialize(test_case, step_match_search, configuration)
+          @original_test_case = test_case
+          @step_match_search = step_match_search
+          @configuration = configuration
+        end
+
+        def test_case
+          @original_test_case.with_steps(new_test_steps)
+        end
+
+        private
+
+        def new_test_steps
+          @original_test_case.test_steps.map(&self.method(:attempt_to_activate))
+        end
+
+        def attempt_to_activate(test_step)
+          find_match(test_step).activate(test_step)
+        end
+
+        def find_match(test_step)
+          FindMatch.new(@step_match_search, @configuration, test_step).result
+        end
+
+        class FindMatch
+          def initialize(step_match_search, configuration, test_step)
+            @step_match_search, @configuration, @test_step = step_match_search, configuration, test_step
+          end
+
+          def result
+            return NoStepMatch.new(test_step.source.last, test_step.name) unless matches.any?
+            configuration.notify Events::StepMatch.new(test_step, match)
+            return SkippingStepMatch.new if configuration.dry_run?
+            match
+          end
+
+          private
+
+          attr_reader :step_match_search, :configuration, :test_step
+          private :step_match_search, :configuration, :test_step
+
+          def match
+            matches.first
+          end
+
+          def matches
+            step_match_search.call(test_step.name)
+          end
+        end
+      end
+    end
+  end
+end