cucumber 2.0.2 → 2.1.0

data/lib/cucumber/step_definition_light.rb

@@ -3,18 +3,18 @@ module Cucumber
   # in a way that also works for other programming languages (i.e. cuke4duke)
   # Used for reporting purposes only (usage formatter).
   class StepDefinitionLight
-    attr_reader :regexp_source, :file_colon_line
+    attr_reader :regexp_source, :location
 
-    def initialize(regexp_source, file_colon_line)
-      @regexp_source, @file_colon_line = regexp_source, file_colon_line
+    def initialize(regexp_source, location)
+      @regexp_source, @location = regexp_source, location
     end
 
     def eql?(o)
-      regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+      regexp_source == o.regexp_source && location == o.location
     end
 
     def hash
-      regexp_source.hash + 31*file_colon_line.hash
+      regexp_source.hash + 31*location.to_s.hash
     end
   end
 end

data/lib/cucumber/step_definitions.rb

@@ -1,8 +1,8 @@
 module Cucumber
   class StepDefinitions
     def initialize(configuration = Configuration.default)
-      configuration = Configuration.parse(configuration)
-      @support_code = Runtime::SupportCode.new(nil, false)
+      configuration = Configuration.new(configuration)
+      @support_code = Runtime::SupportCode.new(nil, configuration)
       @support_code.load_files_from_paths(configuration.autoload_code_paths)
     end
 

data/lib/cucumber/step_match.rb

@@ -22,7 +22,7 @@ module Cucumber
     end
 
     def activate(test_step)
-      test_step.with_action(@step_definition.file_colon_line) do
+      test_step.with_action(@step_definition.location) do
         invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
       end
     end
@@ -52,8 +52,12 @@ module Cucumber
       @name_to_report || replace_arguments(@name_to_match, @step_arguments, format, &proc)
     end
 
+    def location
+      @step_definition.location
+    end
+
     def file_colon_line
-      @step_definition.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
@@ -113,6 +117,11 @@ module Cucumber
       @name
     end
 
+    def location
+      raise "No location for #{@step}" unless @step.location
+      @step.location
+    end
+
     def file_colon_line
       raise "No file:line for #{@step}" unless @step.file_colon_line
       @step.file_colon_line

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -1,5 +1,5 @@
 require 'cucumber/wire_support/request_handler'
-require 'gherkin/formatter/argument'
+require 'cucumber/gherkin/formatter/argument'
 
 module Cucumber
   module WireSupport
@@ -27,7 +27,7 @@ module Cucumber
           def create_step_match(raw_step_match)
             step_definition = WireStepDefinition.new(@connection, raw_step_match)
             step_args = raw_step_match['args'].map do |raw_arg|
-              Gherkin::Formatter::Argument.new(raw_arg['pos'], raw_arg['val'])
+              Cucumber::Gherkin::Formatter::Argument.new(raw_arg['pos'], raw_arg['val'])
             end
             step_match(step_definition, step_args)
           end

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -1,13 +1,15 @@
+require 'cucumber/core/ast/location'
+
 module Cucumber
   module WireSupport
     class WireStepDefinition
-      attr_reader :regexp_source, :file_colon_line
+      attr_reader :regexp_source, :location
 
       def initialize(connection, data)
         @connection = connection
         @id              = data['id']
         @regexp_source   = data['regexp'] || "Unknown"
-        @file_colon_line = data['source'] || "Unknown"
+        @location = data['source'] ? Cucumber::Core::Ast::Location.from_file_colon_line(data['source']) : Cucumber::Core::Ast::Location.new("Unknown")
       end
 
       def invoke(args)

data/spec/cucumber/cli/configuration_spec.rb

@@ -37,65 +37,6 @@ module Cli
 
     attr_reader :out, :error
 
-    it "requires env.rb files first" do
-      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-      config.parse!(%w{--require /features})
-
-      expect(config.support_to_load).to eq [
-        "/features/support/env.rb",
-        "/features/support/a_file.rb"
-      ]
-    end
-
-    it "does not require env.rb files when --dry-run" do
-      given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-      config.parse!(%w{--require /features --dry-run})
-
-      expect(config.support_to_load).to eq [
-        "/features/support/a_file.rb"
-      ]
-    end
-
-    it "requires files in vendor/{plugins,gems}/*/cucumber/*.rb" do
-      given_the_following_files("/vendor/gems/gem_a/cucumber/bar.rb",
-                                "/vendor/plugins/plugin_a/cucumber/foo.rb")
-
-      config.parse!(%w{--require /features})
-
-      expect(config.step_defs_to_load).to eq [
-        "/vendor/gems/gem_a/cucumber/bar.rb",
-        "/vendor/plugins/plugin_a/cucumber/foo.rb"
-      ]
-    end
-
-    describe "--exclude" do
-
-      it "excludes a ruby file from requiring when the name matches exactly" do
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
-
-        config.parse!(%w{--require /features --exclude a_file.rb})
-
-        expect(config.all_files_to_load).to eq [
-          "/features/support/env.rb"
-        ]
-      end
-
-      it "excludes all ruby files that match the provided patterns from requiring" do
-        given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
-                                  "/features/support/food.rb","/features/blah.rb",
-                                  "/features/support/fooz.rb")
-
-        config.parse!(%w{--require /features --exclude foo[df] --exclude blah})
-
-        expect(config.all_files_to_load).to eq [
-          "/features/support/bar.rb",
-          "/features/support/fooz.rb"
-        ]
-      end
-    end
-
     it "uses the default profile when no profile is defined" do
       given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
@@ -397,54 +338,11 @@ END_OF_MESSAGE
       expect(config.options[:name_regexps]).to include(/User signs up/)
     end
 
-    it "preserves the order of the feature files" do
-      config.parse!(%w{b.feature c.feature a.feature})
-
-      expect(config.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
-    end
-
-    it "searchs for all features in the specified directory" do
-      allow(File).to receive(:directory?) { true }
-      allow(Dir).to receive(:[]).with("feature_directory/**/*.feature") { ["cucumber.feature"] }
-
-      config.parse!(%w{feature_directory/})
-
-      expect(config.feature_files).to eq ["cucumber.feature"]
-    end
-
-    it "defaults to the features directory when no feature file are provided" do
-      allow(File).to receive(:directory?) { true }
-      allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
-
-      config.parse!(%w{})
-
-      expect(config.feature_files).to eq ["cucumber.feature"]
-    end
-
-    it "gets the feature files from the rerun file" do
-      allow(File).to receive(:directory?).and_return(false)
-      allow(File).to receive(:file?).and_return(true)
-      allow(IO).to receive(:read).and_return(
-        "cucumber.feature:1:3\ncucumber.feature:5 cucumber.feature:10\n"\
-        "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
-        "domain folder/different cuke.feature:4:5 bar.feature")
-      config.parse!(%w{@rerun.txt})
-
-      expect(config.feature_files).to eq [
-        "cucumber.feature:1:3",
-        "cucumber.feature:5",
-        "cucumber.feature:10",
-        "domain folder/different cuke.feature:134",
-        "domain folder/cuke.feature:1",
-        "domain folder/different cuke.feature:4:5",
-        "bar.feature"]
-    end
-
     it "should allow specifying environment variables on the command line" do
       config.parse!(["foo=bar"])
 
       expect(ENV["foo"]).to eq "bar"
-      expect(config.feature_files).not_to include('foo=bar')
+      expect(config.paths).not_to include('foo=bar')
     end
 
     it "allows specifying environment variables in profiles" do
@@ -452,7 +350,7 @@ END_OF_MESSAGE
       config.parse!(["--profile", "selenium"])
 
       expect(ENV["RAILS_ENV"]).to eq "selenium"
-      expect(config.feature_files).not_to include('RAILS_ENV=selenium')
+      expect(config.paths).not_to include('RAILS_ENV=selenium')
     end
 
     describe "#tag_expression" do

data/spec/cucumber/cli/main_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'yaml'
-require 'gherkin/formatter/model'
 
 module Cucumber
   module Cli
@@ -66,27 +65,6 @@ module Cucumber
         end
       end
 
-      describe "--format with class" do
-        describe "in module" do
-          let(:double_module) { double('module') }
-          let(:formatter) { double('formatter') }
-
-          it "resolves each module until it gets Formatter class" do
-            cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, stdin, stdout, stderr, kernel)
-
-            allow(Object).to receive(:const_defined?) { true }
-            allow(double_module).to receive(:const_defined?) { true }
-
-            expect(Object).to receive(:const_get).with('ZooModule', false) { double_module }
-            expect(double_module).to receive(:const_get).with('MonkeyFormatterClass', false) { double('formatter class', :new => formatter) }
-
-            expect(kernel).to receive(:exit).with(0)
-
-            cli.execute!
-          end
-        end
-      end
-
       [ProfilesNotDefinedError, YmlLoadError, ProfileNotFound].each do |exception_klass|
         it "rescues #{exception_klass}, prints the message to the error stream" do
           configuration = double('configuration')

data/spec/cucumber/cli/options_spec.rb

@@ -87,7 +87,9 @@ module Cucumber
 
             it "displays the language table" do 
               after_parsing '--i18n foo' do 
-                expect(@output_stream.string).to include(Gherkin::I18n.language_table);
+                ::Gherkin3::DIALECTS.keys.map do |key|
+                  expect(@output_stream.string).to include("#{key}");
+                end
               end
             end
           end

data/spec/cucumber/configuration_spec.rb

@@ -19,5 +19,128 @@ module Cucumber
         expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
       end
     end
+
+    context "selecting files to load" do
+
+      def given_the_following_files(*files)
+        allow(File).to receive(:directory?) { true }
+        allow(File).to receive(:file?) { true }
+        allow(Dir).to receive(:[]) { files }
+      end
+
+      it "requires env.rb files first" do
+        configuration = Configuration.new
+        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+        expect(configuration.support_to_load).to eq [
+          "/features/support/env.rb",
+          "/features/support/a_file.rb"
+        ]
+      end
+
+      it "does not require env.rb files when dry run" do
+        configuration = Configuration.new(dry_run: true)
+        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+        expect(configuration.support_to_load).to eq [
+          "/features/support/a_file.rb"
+        ]
+      end
+
+      it "requires step defs in vendor/{plugins,gems}/*/cucumber/*.rb" do
+        given_the_following_files("/vendor/gems/gem_a/cucumber/bar.rb",
+                                  "/vendor/plugins/plugin_a/cucumber/foo.rb")
+
+        configuration = Configuration.new
+
+        expect(configuration.step_defs_to_load).to eq [
+          "/vendor/gems/gem_a/cucumber/bar.rb",
+          "/vendor/plugins/plugin_a/cucumber/foo.rb"
+        ]
+      end
+
+      describe "--exclude" do
+
+        it "excludes a ruby file from requiring when the name matches exactly" do
+          given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+
+          configuration = Configuration.new(excludes: [/a_file.rb/])
+
+          expect(configuration.all_files_to_load).to eq [
+            "/features/support/env.rb"
+          ]
+        end
+
+        it "excludes all ruby files that match the provided patterns from requiring" do
+          given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
+                                    "/features/support/food.rb","/features/blah.rb",
+                                    "/features/support/fooz.rb")
+
+          configuration = Configuration.new(excludes: [/foo[df]/, /blah/])
+
+          expect(configuration.all_files_to_load).to eq [
+            "/features/support/bar.rb",
+            "/features/support/fooz.rb"
+          ]
+        end
+      end
+
+    end
+
+    context "selecting feature files" do
+
+      it "preserves the order of the feature files" do
+        configuration = Configuration.new(paths: %w{b.feature c.feature a.feature})
+
+        expect(configuration.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
+      end
+
+      it "searchs for all features in the specified directory" do
+        allow(File).to receive(:directory?) { true }
+        allow(Dir).to receive(:[]).with("feature_directory/**/*.feature") { ["cucumber.feature"] }
+
+        configuration = Configuration.new(paths: %w{feature_directory/})
+
+        expect(configuration.feature_files).to eq ["cucumber.feature"]
+      end
+
+      it "defaults to the features directory when no feature file are provided" do
+        allow(File).to receive(:directory?) { true }
+        allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
+
+        configuration = Configuration.new(paths: [])
+
+        expect(configuration.feature_files).to eq ["cucumber.feature"]
+      end
+
+      it "gets the feature files from the rerun file" do
+        allow(File).to receive(:directory?).and_return(false)
+        allow(File).to receive(:file?).and_return(true)
+        allow(IO).to receive(:read).and_return(
+          "cucumber.feature:1:3\ncucumber.feature:5 cucumber.feature:10\n"\
+          "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
+          "domain folder/different cuke.feature:4:5 bar.feature")
+
+        configuration = Configuration.new(paths: %w{@rerun.txt})
+
+        expect(configuration.feature_files).to eq [
+          "cucumber.feature:1:3",
+          "cucumber.feature:5",
+          "cucumber.feature:10",
+          "domain folder/different cuke.feature:134",
+          "domain folder/cuke.feature:1",
+          "domain folder/different cuke.feature:4:5",
+          "bar.feature"]
+      end
+    end
+
+    describe "#with_options" do
+      it "returns a copy of the configuration with new options" do
+        new_out_stream = double
+        config = Configuration.new.with_options(out_stream: new_out_stream)
+        expect(config.out_stream).to eq new_out_stream
+      end
+    end
+
   end
 end

data/spec/cucumber/events/bus_spec.rb

@@ -0,0 +1,94 @@
+require "cucumber/events/bus"
+
+module Cucumber
+  module Events
+    class TestEvent
+    end
+
+    class AnotherTestEvent
+    end
+
+    describe Bus do
+      let(:bus) { Bus.new(Cucumber::Events) }
+      let(:test_event) { TestEvent.new }
+      let(:another_test_event) { AnotherTestEvent.new }
+
+      it "calls subscriber with event payload" do
+        received_payload = nil
+        bus.register(TestEvent) do |event|
+          received_payload = event
+        end
+
+        bus.notify test_event
+
+        expect(received_payload).to eq(test_event)
+      end
+
+      it "does not call subscribers for other events" do
+        handler_called = false
+        bus.register(TestEvent) do |event|
+          handler_called = true
+        end
+
+        bus.notify another_test_event
+
+        expect(handler_called).to eq(false)
+      end
+
+      it "broadcasts to multiple subscribers" do
+        received_events = []
+        bus.register(TestEvent) do |event|
+          received_events << event
+        end
+        bus.register(TestEvent) do |event|
+          received_events << event
+        end
+
+        bus.notify test_event
+
+        expect(received_events.length).to eq 2
+        expect(received_events).to all eq test_event
+      end
+
+      it "allows subscription by string" do
+        received_payload = nil
+        bus.register('Cucumber::Events::TestEvent') do |event|
+          received_payload = event
+        end
+
+        bus.notify test_event
+
+        expect(received_payload).to eq(test_event)
+      end
+
+      it "allows subscription by symbol (for events in the Cucumber::Events namespace)" do
+        received_payload = nil
+        bus.register(:test_event) do |event|
+          received_payload = event
+        end
+
+        bus.notify test_event
+
+        expect(received_payload).to eq(test_event)
+      end
+
+      it "allows handlers that are objects with a `call` method" do
+        class MyHandler
+          attr_reader :received_payload
+
+          def call(event)
+            @received_payload = event
+          end
+        end
+
+        handler = MyHandler.new
+        bus.register(TestEvent, handler)
+
+        bus.notify test_event
+
+        expect(handler.received_payload).to eq test_event
+      end
+
+    end
+  end
+end