mobiusloop 0.1.2

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Spec #:nodoc:
+  module Runner #:nodoc:
+    # Neuters RSpec's option parser.
+    # (RSpec's option parser tries to parse ARGV, which
+    # will fail when running cucumber)
+    class OptionParser < ::OptionParser #:nodoc:
+      NEUTERED_RSPEC = Object.new
+      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+
+      def self.method_added(m)
+        unless @__neutering_rspec
+          @__neutering_rspec = true
+          define_method(m) do |*a|
+            NEUTERED_RSPEC
+          end
+          @__neutering_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rspec/doubles.rb

@@ -0,0 +1,19 @@
+require 'rspec/mocks'
+
+World(RSpec::Mocks::ExampleMethods)
+
+Before do
+  if RSpec::Mocks::Version::STRING >= "2.9.9"
+    RSpec::Mocks.setup
+  else
+    RSpec::Mocks.setup(self)
+  end
+end
+
+After do
+  begin
+    RSpec::Mocks.verify
+  ensure
+    RSpec::Mocks.teardown
+  end
+end

data/lib/cucumber/running_test_case.rb

@@ -0,0 +1,134 @@
+require 'delegate'
+require 'cucumber/deprecate'
+
+module Cucumber
+  # Represents the current status of a running test case.
+  #
+  # This wraps a `Cucumber::Core::Test::Case` and delegates
+  # many methods to that object.
+  #
+  # We decorete the core object with the current result.
+  # In the first Before hook of a scenario, this will be an
+  # instance of `Cucumber::Core::Test::Result::Unknown`
+  # but as the scenario runs, it will be updated to reflect
+  # the passed / failed / undefined / skipped status of
+  # the test case.
+  #
+  # The test case might come from a regular Scenario or
+  # a Scenario outline. You can call the `#outline?`
+  # predicate to find out. If it's from an outline,
+  # you get a couple of extra methods.
+  module RunningTestCase
+    def self.new(test_case)
+      Builder.new(test_case).running_test_case
+    end
+
+    class Builder
+      def initialize(test_case)
+        @test_case = test_case
+        test_case.describe_source_to(self)
+      end
+
+      def feature(feature)
+      end
+
+      def scenario(scenario)
+        @factory = Scenario
+      end
+
+      def scenario_outline(scenario)
+        @factory = ScenarioOutlineExample
+      end
+
+      def examples_table(examples_table)
+      end
+
+      def examples_table_row(row)
+      end
+
+      def running_test_case
+        @factory.new(@test_case)
+      end
+    end
+    private_constant :Builder
+
+    class Scenario < SimpleDelegator
+      def initialize(test_case, result = Core::Test::Result::Unknown.new)
+        @test_case = test_case
+        @result = result
+        super test_case
+      end
+
+      def accept_hook?(hook)
+        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
+      end
+
+      def exception
+        return unless @result.failed?
+        @result.exception
+      end
+
+      def status
+        @result.to_sym
+      end
+
+      def failed?
+        @result.failed?
+      end
+
+      def passed?
+        !failed?
+      end
+
+      def title
+        Cucumber.deprecate(
+          "Call #name instead",
+          "RunningTestCase#title",
+          "2.9.9")
+        name
+      end
+
+      def source_tags
+        Cucumber.deprecate(
+          "Call #tags instead",
+          "RunningTestCase#source_tags",
+          "2.9.9")
+        tags
+      end
+
+      def source_tag_names
+        tags.map &:name
+      end
+
+      def skip_invoke!
+        Cucumber.deprecate(
+          "Call #skip_this_scenario directly (not on any object)",
+          "RunningTestCase#skip_invoke!",
+          "2.9.9")
+        raise Cucumber::Core::Test::Result::Skipped
+      end
+
+      def outline?
+        false
+      end
+
+      def with_result(result)
+        self.class.new(@test_case, result)
+      end
+    end
+
+    class ScenarioOutlineExample < Scenario
+      def outline?
+        true
+      end
+
+      def scenario_outline
+        self
+      end
+
+      def cell_values
+        source.last.values
+      end
+    end
+  end
+end

data/lib/cucumber/runtime.rb

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+require 'fileutils'
+require 'multi_json'
+require 'cucumber/configuration'
+require 'cucumber/load_path'
+require 'cucumber/formatter/duration'
+require 'cucumber/file_specs'
+require 'cucumber/filters'
+require 'cucumber/formatter/fanout'
+require 'cucumber/formatter/event_bus_report'
+require 'cucumber/gherkin/i18n'
+require 'cucumber/step_match_search'
+
+module Cucumber
+  module FixRuby21Bug9285
+    def message
+      String(super).gsub("@ rb_sysopen ", "")
+    end
+  end
+
+  class FileException < Exception
+    attr :path
+
+    def initialize(original_exception, path)
+      super(original_exception)
+      @path = path
+    end
+  end
+
+  class FileNotFoundException < FileException
+  end
+
+  class FeatureFolderNotFoundException < FileException
+    include FixRuby21Bug9285 if Cucumber::RUBY_2_1 || Cucumber::RUBY_2_2 || Cucumber::RUBY_2_3
+  end
+
+  require 'cucumber/core'
+  require 'cucumber/runtime/user_interface'
+  require 'cucumber/runtime/support_code'
+  class Runtime
+    attr_reader :results, :support_code, :configuration
+
+    include Cucumber::Core
+    include Formatter::Duration
+    include Runtime::UserInterface
+
+    def initialize(configuration = Configuration.default)
+      @configuration = Configuration.new(configuration)
+      @support_code = SupportCode.new(self, @configuration)
+      @results = Formatter::LegacyApi::Results.new
+    end
+
+    # Allows you to take an existing runtime and change its configuration
+    def configure(new_configuration)
+      @configuration = Configuration.new(new_configuration)
+      @support_code.configure(@configuration)
+    end
+
+    require 'cucumber/wire/plugin'
+    def run!
+      load_step_definitions
+      install_wire_plugin
+      fire_after_configuration_hook
+      self.visitor = report
+
+      receiver = Test::Runner.new(report)
+      compile features, receiver, filters
+    end
+
+    def features_paths
+      @configuration.paths
+    end
+
+    def dry_run?
+      @configuration.dry_run?
+    end
+
+    def scenarios(status = nil)
+      @results.scenarios(status)
+    end
+
+    def steps(status = nil)
+      @results.steps(status)
+    end
+
+    def unmatched_step_definitions
+      @support_code.unmatched_step_definitions
+    end
+
+    def begin_scenario(scenario)
+      @support_code.fire_hook(:begin_scenario, scenario)
+    end
+
+    def end_scenario(scenario)
+      @support_code.fire_hook(:end_scenario)
+    end
+
+    # Returns Ast::DocString for +string_without_triple_quotes+.
+    #
+    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+      location = Core::Ast::Location.of_caller
+      Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
+    end
+
+  private
+
+    def fire_after_configuration_hook #:nodoc
+      @support_code.fire_hook(:after_configuration, @configuration)
+    end
+
+    require 'cucumber/core/gherkin/document'
+    def features
+      @features ||= feature_files.map do |path|
+        source = NormalisedEncodingFile.read(path)
+        Cucumber::Core::Gherkin::Document.new(path, source)
+      end
+    end
+
+    def feature_files
+      filespecs.files
+    end
+
+    def filespecs
+      @filespecs ||= FileSpecs.new(@configuration.feature_files)
+    end
+
+    class NormalisedEncodingFile
+      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
+      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+
+      def self.read(path)
+        new(path).read
+      end
+
+      def initialize(path)
+        begin
+          @file = File.new(path)
+          set_encoding
+        rescue Errno::EACCES => e
+          raise FileNotFoundException.new(e, File.expand_path(path))
+        rescue Errno::ENOENT => e
+          raise FeatureFolderNotFoundException.new(e, path)
+        end
+      end
+
+      def read
+        @file.read.encode("UTF-8")
+      end
+
+      private
+
+      def set_encoding
+        @file.each do |line|
+          if ENCODING_PATTERN =~ line
+            @file.set_encoding $1
+            break
+          end
+          break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
+        end
+        @file.rewind
+      end
+    end
+
+    require 'cucumber/formatter/legacy_api/adapter'
+    require 'cucumber/formatter/legacy_api/runtime_facade'
+    require 'cucumber/formatter/legacy_api/results'
+    require 'cucumber/formatter/ignore_missing_messages'
+    require 'cucumber/formatter/fail_fast'
+    require 'cucumber/core/report/summary'
+    def report
+      return @report if @report
+      reports = [summary_report, event_bus_report] + formatters
+      reports << fail_fast_report if @configuration.fail_fast?
+      @report ||= Formatter::Fanout.new(reports)
+    end
+
+    def summary_report
+      @summary_report ||= Core::Report::Summary.new
+    end
+
+    def event_bus_report
+      @event_bus_report ||= Formatter::EventBusReport.new(@configuration)
+    end
+
+    def fail_fast_report
+      @fail_fast_report ||= Formatter::FailFast.new(@configuration)
+    end
+
+    def formatters
+      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
+        create_formatter(factory, path_or_io, options)
+      }
+    end
+
+    def create_formatter(factory, path_or_io, options)
+      if !legacy_formatter?(factory)
+        return factory.new(@configuration) if path_or_io.nil?
+        return factory.new(@configuration.with_options(out_stream: path_or_io))
+      end
+      results = Formatter::LegacyApi::Results.new
+      runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
+      formatter = factory.new(runtime_facade, path_or_io, options)
+      Formatter::LegacyApi::Adapter.new(
+        Formatter::IgnoreMissingMessages.new(formatter),
+        results, @configuration)
+    end
+
+    def legacy_formatter?(factory)
+      factory.instance_method(:initialize).arity > 1
+    end
+
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed > 0
+      else
+        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
+          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_pending > 0))
+      end
+    end
+    public :failure?
+
+    require 'cucumber/core/test/filters'
+    def filters
+      tag_expressions = @configuration.tag_expressions
+      name_regexps = @configuration.name_regexps
+      tag_limits = @configuration.tag_limits
+      [].tap do |filters|
+        filters << Filters::TagLimits.new(tag_limits) if tag_limits.any?
+        filters << Cucumber::Core::Test::TagFilter.new(tag_expressions)
+        filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
+        filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
+        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
+        filters << Filters::Quit.new
+        # TODO: can we just use RbLanguages's step definitions directly?
+        step_match_search = StepMatchSearch.new(@support_code.ruby.method(:step_matches), @configuration)
+        filters << Filters::ActivateSteps.new(step_match_search, @configuration)
+        @configuration.filters.each do |filter|
+          filters << filter
+        end
+        unless configuration.dry_run?
+          filters << Filters::ApplyAfterStepHooks.new(@support_code)
+          filters << Filters::ApplyBeforeHooks.new(@support_code)
+          filters << Filters::ApplyAfterHooks.new(@support_code)
+          filters << Filters::ApplyAroundHooks.new(@support_code)
+          # need to do this last so it becomes the first test step
+          filters << Filters::PrepareWorld.new(self)
+        end
+      end
+    end
+
+    def load_step_definitions
+      files = @configuration.support_to_load + @configuration.step_defs_to_load
+      @support_code.load_files!(files)
+    end
+
+    def install_wire_plugin
+      Cucumber::Wire::Plugin.new(@configuration).install if @configuration.all_files_to_load.any? {|f| f =~ %r{\.wire$} }
+    end
+
+    def log
+      Cucumber.logger
+    end
+
+  end
+
+end

data/lib/cucumber/runtime/after_hooks.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  class Runtime
+    class AfterHooks
+      def initialize(hooks, scenario)
+        @hooks = hooks
+        @scenario = scenario
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          test_case.test_steps + after_hooks(test_case.source).reverse
+        )
+      end
+
+      private
+
+      def after_hooks(source)
+        @hooks.map do |hook|
+          action = ->(result) { hook.invoke('After', @scenario.with_result(result)) }
+          Hooks.after_hook(source, hook.location, &action)
+        end          
+      end
+    end
+  end
+end