cucumber-core 3.0.0 → 3.1.0

data/spec/coverage.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require 'simplecov'
-formatters = [ SimpleCov::Formatter::HTMLFormatter ]
-
-if ENV['TRAVIS']
-  require 'coveralls'
-  formatters << Coveralls::SimpleCov::Formatter
-end
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatters)
-SimpleCov.start

data/spec/cucumber/core/ast/background_spec.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/background'
-module Cucumber::Core::Ast
-  describe Background do
-    it "has a useful inspect" do
-      location = Location.new("features/a_feature.feature", 3)
-      background = Background.new(location, double, "Background", "the name", double, [])
-      expect(background.inspect).to eq(%{#<Cucumber::Core::Ast::Background "Background: the name" (#{location})>})
-    end
-  end
-end

data/spec/cucumber/core/ast/data_table_spec.rb

@@ -1,81 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'cucumber/core/ast/data_table'
-
-module Cucumber
-  module Core
-    module Ast
-      describe DataTable do
-        let(:location) { Location.new('foo.feature', 9..12) }
-
-        before do
-          @table = DataTable.new([
-            %w{one four seven},
-            %w{4444 55555 666666}
-          ], location)
-        end
-
-        describe "equality" do
-          it "is equal to another table with the same data" do
-            expect( DataTable.new([[1,2],[3,4]], location) ).to eq DataTable.new([[1,2],[3,4]], location)
-          end
-
-          it "is not equal to another table with different data" do
-            expect( DataTable.new([[1,2],[3,4]], location) ).not_to eq DataTable.new([[1,2]], location)
-          end
-
-          it "is not equal to a non table" do
-            expect( DataTable.new([[1,2],[3,4]], location) ).not_to eq Object.new
-          end
-        end
-
-        describe "#data_table?" do
-          let(:table) { DataTable.new([[1,2],[3,4]], location) }
-
-          it "returns true" do
-            expect(table).to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:table) { DataTable.new([[1,2],[3,4]], location) }
-
-          it "returns false" do
-            expect(table).not_to be_doc_string
-          end
-        end
-
-        describe "#map" do
-          let(:table) { DataTable.new([ %w{foo bar}, %w{1 2} ], location) }
-
-          it 'yields the contents of each cell to the block' do
-
-            expect { |b| table.map(&b) }.to yield_successive_args('foo', 'bar', '1', '2')
-          end
-
-          it 'returns a new table with the cells modified by the block' do
-            expect( table.map { |cell| "*#{cell}*" } ).to eq  DataTable.new([%w{*foo* *bar*}, %w{*1* *2*}], location)
-          end
-        end
-
-        describe "#transpose" do
-          before(:each) do
-            @table = DataTable.new([
-              %w{one 1111},
-              %w{two 22222}
-            ], location)
-          end
-
-          it "should transpose the table" do
-            transposed = DataTable.new([
-              %w{one two},
-              %w{1111 22222}
-            ], location)
-            expect( @table.transpose ).to eq( transposed )
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/cucumber/core/ast/doc_string_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/doc_string'
-require 'unindent'
-
-module Cucumber
-  module Core
-    module Ast
-      describe DocString do
-        let(:location) { double }
-        let(:doc_string) { DocString.new(content, content_type, location) }
-
-        describe "#data_table?" do
-          let(:doc_string) { DocString.new("test", "text/plain" , location) }
-
-          it "returns false" do
-            expect(doc_string).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:doc_string) { DocString.new("test", "text/plain" , location) }
-
-          it "returns true" do
-            expect(doc_string).to be_doc_string
-          end
-        end
-
-        context '#map' do
-          let(:content) { 'original content' }
-          let(:content_type) { double }
-
-          it 'yields with the content' do
-            expect { |b| doc_string.map(&b) }.to yield_with_args(content)
-          end
-
-          it 'returns a new docstring with new content' do
-            expect( doc_string.map { 'foo' }.content ).to eq 'foo'
-          end
-
-          it 'raises an error if no block is given' do
-            expect { doc_string.map }.to raise_error ArgumentError
-          end
-        end
-
-        context 'equality' do
-          let(:content) { 'foo' }
-          let(:content_type) { 'text/plain' }
-
-          it 'is equal to another DocString with the same content and content_type' do
-            expect( doc_string ).to eq DocString.new(content, content_type, location)
-          end
-
-          it 'is not equal to another DocString with different content' do
-            expect( doc_string ).not_to eq DocString.new('bar', content_type, location)
-          end
-
-          it 'is not equal to another DocString with different content_type' do
-            expect( doc_string ).not_to eq DocString.new(content, 'text/html', location)
-          end
-
-          it 'is equal to a string with the same content' do
-            expect( doc_string ).to eq 'foo'
-          end
-
-          it 'returns false when compared with something odd' do
-            expect( doc_string ).not_to eq 5
-          end
-        end
-
-        context 'quacking like a String' do
-          let(:content) { String.new('content') }
-          let(:content_type) { 'text/plain' }
-
-          it 'delegates #encoding to the content string' do
-            content.force_encoding('us-ascii')
-            expect( doc_string.encoding ).to eq Encoding.find('US-ASCII')
-          end
-
-          it 'allows implicit conversion to a String' do
-            expect( 'expected content' ).to include(doc_string)
-          end
-
-          it 'allows explicit conversion to a String' do
-            expect( doc_string.to_s ).to eq 'content'
-          end
-
-          it 'delegates #gsub to the content string' do
-            expect( doc_string.gsub(/n/, '_') ).to eq 'co_te_t'
-          end
-
-          it 'delegates #split to the content string' do
-            expect(doc_string.split('n')).to eq ['co', 'te', 't']
-          end
-        end
-      end
-
-      context "inspect" do
-        let(:location) { Location.new("features/feature.feature", 8) }
-        let(:content_type) { 'text/plain' }
-
-        it "provides a useful inspect method" do
-          doc_string = DocString.new("some text", content_type, location)
-          expect(doc_string.inspect).to eq <<-END.chomp.unindent
-          #<Cucumber::Core::Ast::DocString (features/feature.feature:8)
-            """text/plain
-            some text
-            """>
-          END
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/core/ast/empty_multiline_argument_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/location'
-require 'cucumber/core/ast/empty_multiline_argument'
-
-module Cucumber
-  module Core
-    module Ast
-      describe EmptyMultilineArgument do
-
-        let(:location) { double }
-        let(:arg) { EmptyMultilineArgument.new }
-
-        describe "#data_table?" do
-          it "returns false" do
-            expect(arg).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          it "returns false" do
-            expect(arg).not_to be_doc_string
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/cucumber/core/ast/examples_table_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/examples_table'
-
-module Cucumber::Core::Ast
-  describe ExamplesTable do
-    let(:location) { double(:to_s => 'file.feature:8') }
-    let(:language) { double }
-    let(:comments) { double }
-
-    describe ExamplesTable::Header do
-      let(:header) { ExamplesTable::Header.new(%w{foo bar baz}, location, comments) }
-
-      describe 'location' do
-        it 'knows the file and line number' do
-          expect( header.file_colon_line ).to eq 'file.feature:8'
-        end
-      end
-
-      describe 'comments' do
-        it "has comments" do
-          expect( header ).to respond_to(:comments)
-        end
-      end
-
-      context 'building a row' do
-        it 'includes the header values as keys' do
-          expect( header.build_row(%w{1 2 3}, 1, location, language, comments) ).to eq ExamplesTable::Row.new({'foo' => '1', 'bar' => '2', 'baz' => '3'}, 1, location, language, comments)
-        end
-      end
-    end
-    describe ExamplesTable::Row do
-
-      describe 'location' do
-        it 'knows the file and line number' do
-          row = ExamplesTable::Row.new({}, 1, location, language, comments)
-          expect( row.file_colon_line ).to eq 'file.feature:8'
-        end
-      end
-
-      describe 'language' do
-        it "has a language" do
-          expect( ExamplesTable::Row.new({}, 1, location, language, comments) ).to respond_to(:language)
-        end
-      end
-
-      describe 'comments' do
-        it "has comments" do
-          expect( ExamplesTable::Row.new({}, 1, location, language, comments) ).to respond_to(:comments)
-        end
-      end
-
-      describe "expanding a string" do
-        context "when an argument matches" do
-          it "replaces the argument with the value from the row" do
-            row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
-            text = 'this <arg> a test'
-            expect( row.expand(text) ).to eq 'this replacement a test'
-          end
-        end
-
-        context "when the replacement value is nil" do
-          it "uses an empty string for the replacement" do
-            row = ExamplesTable::Row.new({'color' => nil}, 1, location, language, comments)
-            text = 'a <color> cucumber'
-            expect( row.expand(text) ).to eq 'a  cucumber'
-          end
-        end
-
-        context "when an argument does not match" do
-          it "ignores the arguments that do not match" do
-            row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language, comments)
-            text = 'foo <x> bar <z>'
-            expect( row.expand(text) ).to eq 'foo 1 bar <z>'
-          end
-        end
-      end
-
-      describe 'accessing the values' do
-        it 'returns the actual row values' do
-          row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language, comments)
-          expect( row.values ).to eq ['1', '2']
-        end
-
-        it "can access a row value by it's parameter name" do
-          row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location, language, comments)
-          expect( row['x']).to eq '1'
-        end
-      end
-
-      describe 'equality' do
-        let(:data) { {} }
-        let(:number) { double }
-        let(:location) { double }
-        let(:original) { ExamplesTable::Row.new(data, number, location, language, comments) }
-
-        it 'is equal to another instance with the same data, number and location' do
-          expect( original ).to eq ExamplesTable::Row.new(data, number, location, language, comments)
-        end
-
-        it 'is not equal to another instance with different data, number or location' do
-          expect( original ).not_to eq ExamplesTable::Row.new({'x' => 'y'}, number, location, language, comments)
-          expect( original ).not_to eq ExamplesTable::Row.new(data, double, location, language, comments)
-          expect( original ).not_to eq ExamplesTable::Row.new(data, number, double, double, double)
-        end
-
-        it 'is not equal to another type of object' do
-          expect( original ).not_to eq double(data: data, number: number, location: location, language: language)
-        end
-
-      end
-    end
-  end
-end

data/spec/cucumber/core/ast/location_spec.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/location'
-
-module Cucumber::Core::Ast
-  RSpec::Matchers.define :be_included_in do |expected|
-    match do |actual|
-      expected.include? actual
-    end
-  end  
-
-  describe Location do
-    let(:line) { 12 }
-    let(:file) { "foo.feature" }
-
-    describe "equality" do
-      it "is equal to another Location on the same line of the same file" do
-        one_location = Location.new(file, line)
-        another_location = Location.new(file, line)
-        expect( one_location ).to eq another_location
-      end
-
-       it "is not equal to a wild card of the same file" do
-         expect( Location.new(file, line) ).not_to eq Location.new(file)
-       end
-
-      context "collections of locations" do
-        it "behave as expected with uniq" do
-          unique_collection = [Location.new(file, line), Location.new(file, line)].uniq
-          expect( unique_collection ).to eq [Location.new(file, line)]
-        end
-      end
-    end
-
-    describe "to_s" do
-      it "is file:line for a precise location" do
-        expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"
-      end
-
-      it "is file for a wildcard location" do
-        expect( Location.new("foo.feature").to_s ).to eq "foo.feature"
-      end
-
-      it "is file:first_line..last_line for a ranged location" do
-        expect( Location.new("foo.feature", 13..19).to_s ).to eq "foo.feature:13..19"
-      end
-
-      it "is file:line:line:line for an arbitrary set of lines" do
-        expect( Location.new("foo.feature", [1,3,5]).to_s ).to eq "foo.feature:1:3:5"
-      end
-    end
-
-    describe "matches" do
-      let(:matching) { Location.new(file, line) }
-      let(:same_file_other_line) { Location.new(file, double) }
-      let(:not_matching) { Location.new(other_file, line) }
-      let(:other_file) { double }
-
-      context 'a precise location' do
-        let(:precise) { Location.new(file, line) }
-
-        it "matches a precise location of the same file and line" do
-          expect( matching ).to be_match(precise)
-        end
-
-        it "does not match a precise location on a different line in the same file" do
-          expect( matching ).not_to be_match(same_file_other_line)
-        end
-
-      end
-
-      context 'a wildcard' do
-        let(:wildcard) { Location.new(file) }
-
-        it "matches any location with the same filename" do
-          expect( wildcard ).to be_match(matching)
-        end
-
-        it "is matched by any location of the same file" do
-          expect( matching ).to be_match(wildcard)
-        end
-
-        it "does not match a location in a different file" do
-          expect( wildcard ).not_to be_match(not_matching)
-        end
-      end
-
-      context 'a range wildcard' do
-        let(:range) { Location.new("foo.feature", 13..17) }
-
-        it "matches the first line in the same file" do
-          other = Location.new("foo.feature", 13)
-          expect( range ).to be_match(other)
-        end
-
-        it "matches a line within the docstring in the same file" do
-          other = Location.new("foo.feature", 15)
-          expect( range ).to be_match(other)
-        end
-
-        it "is matched by a line within the docstring in the same file" do
-          other = Location.new("foo.feature", 15)
-          expect( other ).to be_match(range)
-        end
-
-        it "matches a wildcard in the same file" do
-          wildcard = Location.new("foo.feature")
-          expect( range ).to be_match(wildcard)
-        end
-
-        it "does not match a location outside of the range" do
-          other = Location.new("foo.feature", 18)
-          expect( range ).not_to be_match(other)
-        end
-
-        it "does not match a location in another file" do
-          other = Location.new("bar.feature", 13)
-          expect( range ).not_to be_match(other)
-        end
-      end
-
-      context "an arbitrary list of lines" do
-        let(:location) { Location.new("foo.feature", [1,5,6,7]) }
-
-        it "matches any of the given lines" do
-          [1,5,6,7].each do |line|
-            other = Location.new("foo.feature", line)
-            expect(location).to be_match(other)
-          end
-        end
-
-        it "does not match another line" do
-          other = Location.new("foo.feature", 2)
-          expect(location).not_to be_match(other)
-        end
-      end
-    end
-
-    describe "created from source location" do
-      context "when the location is in the tree below pwd" do
-        it "create a relative path from pwd" do
-          expect( Location.from_source_location(Dir.pwd + "/path/file.rb", 1).file ).to eq "path/file.rb"
-        end
-      end
-
-      context "when the location is in an installed gem" do
-        it "create a relative path from the gem directory" do
-          expect( Location.from_source_location("/path/gems/gem-name/path/file.rb", 1).file ).to eq "gem-name/path/file.rb"
-        end
-      end
-
-      context "when the location is neither below pwd nor in an installed gem" do
-        it "use the absolute path to the file" do
-          expect( Location.from_source_location("/path/file.rb", 1).file ).to eq "/path/file.rb"
-        end
-      end
-    end
-
-    describe "created from file-colon-line" do
-      it "handles also Windows paths" do
-        expect( Location.from_file_colon_line("c:\path\file.rb:123").file ).to eq "c:\path\file.rb"
-      end
-    end
-
-    describe "created of caller" do
-      it "use the location of the caller" do
-        expect( Location.of_caller.to_s ).to be_included_in caller[0]
-      end
-
-      context "when specifying additional caller depth"do      
-        it "use the location of the n:th caller" do
-          expect( Location.of_caller(1).to_s ).to be_included_in caller[1]
-        end
-      end
-    end
-
-    describe ".merge" do
-      it "merges locations from the same file" do
-        file = "test.feature"
-        location = Location.merge(
-          Location.new(file, 1),
-          Location.new(file, 6),
-          Location.new(file, 7)
-        )
-        expect(location.to_s).to eq "test.feature:1:6:7"
-      end
-
-      it "raises an error when the locations are from different files" do
-        expect {
-          Location.merge(
-            Location.new("one.feature", 1),
-            Location.new("two.feature", 1)
-          )
-        }.to raise_error(IncompatibleLocations)
-      end
-    end
-
-  end
-end
-