cucumber 1.3.10 → 2.0.0

data/spec/cucumber/{ast/table_spec.rb → multiline_argument/data_table_spec.rb}

@@ -1,213 +1,202 @@
 # encoding: utf-8
 require 'spec_helper'
-require 'cucumber/ast/table'
+require 'cucumber/multiline_argument/data_table'
 
 module Cucumber
-  module Ast
-    describe Table do
+  module MultilineArgument
+    describe DataTable do
       before do
-        @table = Table.new([
+        @table = DataTable.from([
           %w{one four seven},
           %w{4444 55555 666666}
         ])
-        def @table.cells_rows; super; end
-        def @table.columns; super; end
       end
 
       it "should have rows" do
-        @table.cells_rows[0].map{|cell| cell.value}.should == %w{one four seven}
+        expect( @table.cells_rows[0].map{|cell| cell.value} ).to eq %w{one four seven}
       end
 
       it "should have columns" do
-        @table.columns[1].map{|cell| cell.value}.should == %w{four 55555}
-      end
-
-      it "should have headers" do
-        @table.headers.should == %w{one four seven}
+        expect( @table.columns[1].map{|cell| cell.value} ).to eq %w{four 55555}
       end
 
       it "should have same cell objects in rows and columns" do
         # 666666
-        @table.cells_rows[1].__send__(:[], 2).should equal(@table.columns[2].__send__(:[], 1))
-      end
-
-      it "should know about max width of a row" do
-        @table.columns[1].__send__(:width).should == 5
+        expect( @table.cells_rows[1][2] ).to equal(@table.columns[2][1])
       end
 
       it "should be convertible to an array of hashes" do
-        @table.hashes.should == [
+        expect( @table.hashes ).to eq [
           {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
         ]
       end
 
       it "should accept symbols as keys for the hashes" do
-        @table.hashes.first[:one].should == '4444'
+        expect( @table.hashes.first[:one] ).to eq '4444'
       end
 
       it "should return the row values in order" do
-        @table.rows.first.should == %w{4444 55555 666666}
+        expect( @table.rows.first ).to eq %w{4444 55555 666666}
       end
 
       describe '#map_column!' do
         it "should allow mapping columns" do
           @table.map_column!('one') { |v| v.to_i }
-          @table.hashes.first['one'].should == 4444
+          expect( @table.hashes.first['one'] ).to eq 4444
         end
 
         it "applies the block once to each value" do
           headers = ['header']
           rows = ['value']
-          table = Table.new [headers, rows]
+          table = DataTable.from [headers, rows]
           count = 0
           table.map_column!('header') { |value| count +=1 }
           table.rows
-          count.should eq rows.size
+          expect( count ).to eq rows.size
         end
 
         it "should allow mapping columns and take a symbol as the column name" do
           @table.map_column!(:one) { |v| v.to_i }
-          @table.hashes.first['one'].should == 4444
+          expect( @table.hashes.first['one'] ).to eq 4444
         end
 
         it "should allow mapping columns and modify the rows as well" do
           @table.map_column!(:one) { |v| v.to_i }
-          @table.rows.first.should include(4444)
-          @table.rows.first.should_not include('4444')
+          expect( @table.rows.first ).to include(4444)
+          expect( @table.rows.first ).to_not include('4444')
         end
 
         it "should pass silently if a mapped column does not exist in non-strict mode" do
-          lambda {
+          expect {
             @table.map_column!('two', false) { |v| v.to_i }
             @table.hashes
-          }.should_not raise_error
+          }.not_to raise_error
         end
 
         it "should fail if a mapped column does not exist in strict mode" do
-          lambda {
+          expect {
             @table.map_column!('two', true) { |v| v.to_i }
             @table.hashes
-          }.should raise_error('The column named "two" does not exist')
+          }.to raise_error('The column named "two" does not exist')
         end
 
         it "should return the table" do
-          (@table.map_column!(:one) { |v| v.to_i }).should == @table
+          expect( (@table.map_column!(:one) { |v| v.to_i }) ).to eq @table
         end
       end
 
       describe '#map_column' do
         it "should allow mapping columns" do
           new_table = @table.map_column('one') { |v| v.to_i }
-          new_table.hashes.first['one'].should == 4444
+          expect( new_table.hashes.first['one'] ).to eq 4444
         end
 
         it "applies the block once to each value" do
           headers = ['header']
           rows = ['value']
-          table = Table.new [headers, rows]
+          table = DataTable.from [headers, rows]
           count = 0
           new_table = table.map_column('header') { |value| count +=1 }
           new_table.rows
-          count.should eq rows.size
+          expect( count ).to eq rows.size
         end
 
         it "should allow mapping columns and take a symbol as the column name" do
           new_table = @table.map_column(:one) { |v| v.to_i }
-          new_table.hashes.first['one'].should == 4444
+          expect( new_table.hashes.first['one'] ).to eq 4444
         end
 
         it "should allow mapping columns and modify the rows as well" do
           new_table = @table.map_column(:one) { |v| v.to_i }
-          new_table.rows.first.should include(4444)
-          new_table.rows.first.should_not include('4444')
+          expect( new_table.rows.first ).to include(4444)
+          expect( new_table.rows.first ).to_not include('4444')
         end
 
         it "should pass silently if a mapped column does not exist in non-strict mode" do
-          lambda {
+          expect {
             new_table = @table.map_column('two', false) { |v| v.to_i }
             new_table.hashes
-          }.should_not raise_error
+          }.not_to raise_error
         end
 
         it "should fail if a mapped column does not exist in strict mode" do
-          lambda {
+          expect {
             new_table = @table.map_column('two', true) { |v| v.to_i }
             new_table.hashes
-          }.should raise_error('The column named "two" does not exist')
+          }.to raise_error('The column named "two" does not exist')
         end
 
         it "should return a new table" do
-          (@table.map_column(:one) { |v| v.to_i }).should_not == @table
+          expect( (@table.map_column(:one) { |v| v.to_i }) ).to_not eq @table
         end
       end
 
-
       describe "#match" do
         before(:each) do
-          @table = Table.new([
+          @table = DataTable.from([
             %w{one four seven},
             %w{4444 55555 666666}
           ])
         end
 
         it "returns nil if headers do not match" do
-          @table.match('does,not,match').should be_nil
+          expect( @table.match('does,not,match') ).to be_nil
         end
         it "requires a table: prefix on match" do
-          @table.match('table:one,four,seven').should_not be_nil
+          expect( @table.match('table:one,four,seven') ).to_not be_nil
         end
         it "does not match if no table: prefix on match" do
-          @table.match('one,four,seven').should be_nil
+          expect( @table.match('one,four,seven') ).to be_nil
         end
       end
 
       describe "#transpose" do
         before(:each) do
-          @table = Table.new([
+          @table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
         end
 
         it "should be convertible in to an array where each row is a hash" do
-          @table.transpose.hashes[0].should == {'one' => '1111', 'two' => '22222'}
+          expect( @table.transpose.hashes[0] ).to eq('one' => '1111', 'two' => '22222')
         end
       end
 
       describe "#rows_hash" do
 
         it "should return a hash of the rows" do
-          table = Table.new([
+          table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
-          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
+          expect( table.rows_hash ).to eq( 'one' => '1111', 'two' => '22222' )
         end
 
         it "should fail if the table doesn't have two columns" do
-          faulty_table = Table.new([
+          faulty_table = DataTable.from([
             %w{one 1111 abc},
             %w{two 22222 def}
           ])
-          lambda {
+          expect {
             faulty_table.rows_hash
-          }.should raise_error('The table must have exactly 2 columns')
+          }.to raise_error('The table must have exactly 2 columns')
         end
 
         it "should support header and column mapping" do
-          table = Table.new([
+          table = DataTable.from([
             %w{one 1111},
             %w{two 22222}
           ])
-          table.map_headers!({ 'two' => 'Two' }) { |header| header.upcase }
-          table.map_column!('two', false) { |val| val.to_i }
-          table.rows_hash.should == { 'ONE' => '1111', 'Two' => 22222 }
+          t2 = table.map_headers({ 'two' => 'Two' }) { |header| header.upcase }.
+                     map_column('two', false) { |val| val.to_i }
+          expect( t2.rows_hash ).to eq( 'ONE' => '1111', 'Two' => 22222 )
         end
       end
 
       describe '#map_headers!' do
         let(:table) do
-          Table.new([
+          DataTable.from([
           %w{HELLO WORLD},
           %w{4444 55555}
           ])
@@ -215,25 +204,25 @@ module Cucumber
 
         it "renames the columns to the specified values in the provided hash" do
           @table.map_headers!('one' => :three)
-          @table.hashes.first[:three].should == '4444'
+          expect( @table.hashes.first[:three] ).to eq '4444'
         end
 
         it "allows renaming columns using regexp" do
           @table.map_headers!(/one|uno/ => :three)
-          @table.hashes.first[:three].should == '4444'
+          expect( @table.hashes.first[:three] ).to eq '4444'
         end
 
         it "copies column mappings" do
           @table.map_column!('one') { |v| v.to_i }
           @table.map_headers!('one' => 'three')
-          @table.hashes.first['three'].should == 4444
+          expect( @table.hashes.first['three'] ).to eq 4444
         end
 
         it "takes a block and operates on all the headers with it" do
           table.map_headers! do |header|
             header.downcase
           end
-          table.hashes.first.keys.should =~ %w[hello world]
+          expect( table.hashes.first.keys ).to match %w[hello world]
         end
 
         it "treats the mappings in the provided hash as overrides when used with a block" do
@@ -241,13 +230,13 @@ module Cucumber
             header.downcase
           end
 
-          table.hashes.first.keys.should =~ %w[hello foo]
+          expect( table.hashes.first.keys ).to match %w[hello foo]
         end
       end
 
       describe '#map_headers' do
         let(:table) do
-           Table.new([
+           DataTable.from([
           %w{HELLO WORLD},
           %w{4444 55555}
           ])
@@ -255,18 +244,18 @@ module Cucumber
 
         it "renames the columns to the specified values in the provided hash" do
           table2 = @table.map_headers('one' => :three)
-          table2.hashes.first[:three].should == '4444'
+          expect( table2.hashes.first[:three] ).to eq '4444'
         end
 
         it "allows renaming columns using regexp" do
           table2 = @table.map_headers(/one|uno/ => :three)
-          table2.hashes.first[:three].should == '4444'
+          expect( table2.hashes.first[:three] ).to eq '4444'
         end
 
         it "copies column mappings" do
           @table.map_column!('one') { |v| v.to_i }
           table2 = @table.map_headers('one' => 'three')
-          table2.hashes.first['three'].should == 4444
+          expect( table2.hashes.first['three'] ).to eq 4444
         end
 
         it "takes a block and operates on all the headers with it" do
@@ -274,7 +263,7 @@ module Cucumber
             header.downcase
           end
 
-          table2.hashes.first.keys.should =~ %w[hello world]
+          expect( table2.hashes.first.keys ).to match %w[hello world]
         end
 
         it "treats the mappings in the provided hash as overrides when used with a block" do
@@ -282,89 +271,28 @@ module Cucumber
             header.downcase
           end
 
-          table2.hashes.first.keys.should =~ %w[hello foo]
-        end
-      end
-
-      describe "replacing arguments" do
-
-        before(:each) do
-          @table = Table.new([
-            %w{qty book},
-            %w{<qty> <book>}
-          ])
-        end
-
-        it "should return a new table with arguments replaced with values" do
-          table_with_replaced_args = @table.arguments_replaced({'<book>' => 'Unbearable lightness of being', '<qty>' => '5'})
-
-          table_with_replaced_args.hashes[0]['book'].should == 'Unbearable lightness of being'
-          table_with_replaced_args.hashes[0]['qty'].should == '5'
-        end
-
-        it "should recognise when entire cell is delimited" do
-          @table.should have_text('<book>')
-        end
-
-        it "should recognise when just a subset of a cell is delimited" do
-          table = Table.new([
-            %w{qty book},
-            [nil, "This is <who>'s book"]
-          ])
-          table.should have_text('<who>')
-        end
-
-        it "should replace nil values with nil" do
-          table_with_replaced_args = @table.arguments_replaced({'<book>' => nil})
-
-          table_with_replaced_args.hashes[0]['book'].should == nil
-        end
-
-        it "should preserve values which don't match a placeholder when replacing with nil" do
-          table = Table.new([
-                              %w{book},
-                              %w{cat}
-                            ])
-          table_with_replaced_args = table.arguments_replaced({'<book>' => nil})
-
-          table_with_replaced_args.hashes[0]['book'].should == 'cat'
-        end
-
-        it "should not change the original table" do
-          @table.arguments_replaced({'<book>' => 'Unbearable lightness of being'})
-
-          @table.hashes[0]['book'].should_not == 'Unbearable lightness of being'
-        end
-
-        it "should not raise an error when there are nil values in the table" do
-          table = Table.new([
-                              ['book', 'qty'],
-                              ['<book>', nil],
-                            ])
-          lambda{
-            table.arguments_replaced({'<book>' => nil, '<qty>' => '5'})
-          }.should_not raise_error
+          expect( table2.hashes.first.keys ).to match %w[hello foo]
         end
       end
 
       describe "diff!" do
         it "should detect a complex diff" do
-          t1 = table(%{
+          t1 = DataTable.from(%{
             | 1         | 22          | 333         | 4444         |
             | 55555     | 666666      | 7777777     | 88888888     |
             | 999999999 | 0000000000  | 01010101010 | 121212121212 |
             | 4000      | ABC         | DEF         | 50000        |
-          }, __FILE__, __LINE__)
+          })
 
-          t2 = table(%{
+          t2 = DataTable.from(%{
             | a     | 4444     | 1         |
             | bb    | 88888888 | 55555     |
             | ccc   | xxxxxxxx | 999999999 |
             | dddd  | 4000     | 300       |
             | e     | 50000    | 4000      |
-          }, __FILE__, __LINE__)
-          lambda{t1.diff!(t2)}.should raise_error
-          t1.to_s(:indent => 12, :color => false).should == %{
+          })
+          expect { t1.diff!(t2) }.to raise_error
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
             |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
             | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
@@ -375,13 +303,13 @@ module Cucumber
         end
 
         it "should not change table when diffed with identical" do
-          t = table(%{
+          t = DataTable.from(%{
             |a|b|c|
             |d|e|f|
             |g|h|i|
-          }, __FILE__, __LINE__)
+          })
           t.diff!(t.dup)
-          t.to_s(:indent => 12, :color => false).should == %{
+          expect( t.to_s(:indent => 12, :color => false) ).to eq %{
             |     a |     b |     c |
             |     d |     e |     f |
             |     g |     h |     i |
@@ -389,17 +317,17 @@ module Cucumber
         end
 
         it "should inspect missing and surplus cells" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['name',  'male', 'lastname', 'swedish'],
             ['aslak', 'true', 'hellesøy', 'false']
           ])
-          t2 = Table.new([
+          t2 = DataTable.from([
             ['name',  'male', 'lastname', 'swedish'],
             ['aslak', true,   'hellesøy', false]
           ])
-          lambda{t1.diff!(t2)}.should raise_error
+          expect { t1.diff!(t2) }.to raise_error
 
-          t1.to_s(:indent => 12, :color => false).should == %{
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     name  |     male       |     lastname |     swedish     |
             | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
             | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
@@ -407,70 +335,70 @@ module Cucumber
         end
 
         it "should allow column mapping of target before diffing" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['name',  'male'],
             ['aslak', 'true']
           ])
           t1.map_column!('male') { |m| m == 'true' }
-          t2 = Table.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
           t1.diff!(t2)
-          t1.to_s(:indent => 12, :color => false).should == %{
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     name  |     male |
             |     aslak |     true |
           }
         end
 
         it "should allow column mapping of argument before diffing" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
           t1.map_column!('male') {
             'true'
           }
-          t2 = Table.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', 'true']
           ])
           t2.diff!(t1)
-          t1.to_s(:indent => 12, :color => false).should == %{
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     name  |     male |
             |     aslak |     true |
           }
         end
 
         it "should allow header mapping before diffing" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['Name',  'Male'],
             ['aslak', 'true']
           ])
           t1.map_headers!('Name' => 'name', 'Male' => 'male')
           t1.map_column!('male') { |m| m == 'true' }
-          t2 = Table.new([
+          t2 = DataTable.from([
             ['name',  'male'],
             ['aslak', true]
           ])
           t1.diff!(t2)
-          t1.to_s(:indent => 12, :color => false).should == %{
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     name  |     male |
             |     aslak |     true |
           }
         end
 
         it "should detect seemingly identical tables as different" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['X',  'Y'],
             ['2', '1']
           ])
-          t2 = Table.new([
+          t2 = DataTable.from([
             ['X',  'Y'],
             [2, 1]
           ])
-          lambda{t1.diff!(t2)}.should raise_error
-          t1.to_s(:indent => 12, :color => false).should == %{
+          expect { t1.diff!(t2) }.to raise_error
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     X       |     Y       |
             | (-) (i) "2" | (-) (i) "1" |
             | (+) (i) 2   | (+) (i) 1   |
@@ -478,117 +406,109 @@ module Cucumber
         end
 
         it "should not allow mappings that match more than 1 column" do
-          t1 = Table.new([
+          t1 = DataTable.from([
             ['Cuke',  'Duke'],
             ['Foo', 'Bar']
           ])
-          lambda do
+          expect do
             t1.map_headers!(/uk/ => 'u')
             t1.hashes
-          end.should raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
+          end.to raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
         end
 
         describe "raising" do
           before do
-            @t = table(%{
+            @t = DataTable.from(%{
               | a | b |
               | c | d |
-            }, __FILE__, __LINE__)
-            @t.should_not == nil
+            })
+            expect( @t ).not_to eq nil
           end
 
           it "should raise on missing rows" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b |
-            }, __FILE__, __LINE__)
-            lambda { @t.dup.diff!(t) }.should raise_error
-            lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
+            })
+            expect( lambda { @t.dup.diff!(t) } ).to raise_error
+            expect { @t.dup.diff!(t, :missing_row => false) }.not_to raise_error
           end
 
           it "should not raise on surplus rows when surplus is at the end" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b |
               | c | d |
               | e | f |
-            }, __FILE__, __LINE__)
-            lambda { @t.dup.diff!(t) }.should raise_error
-            lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
+            })
+            expect { @t.dup.diff!(t) }.to raise_error
+            expect { @t.dup.diff!(t, :surplus_row => false) }.not_to raise_error
           end
 
           it "should not raise on surplus rows when surplus is interleaved" do
-            t1 = table(%{
+            t1 = DataTable.from(%{
               | row_1 | row_2 |
               | four  | 4     |
-            }, __FILE__, __LINE__)
-            t2 = table(%{
+            })
+            t2 = DataTable.from(%{
               | row_1 | row_2 |
               | one   | 1     |
               | two   | 2     |
               | three | 3     |
               | four  | 4     |
               | five  | 5     |
-            }, __FILE__, __LINE__)
-            lambda { t1.dup.diff!(t2) }.should raise_error
+            })
+            expect { t1.dup.diff!(t2) }.to raise_error
 
-            lambda { t1.dup.diff!(t2, :surplus_row => false) }.should_not raise_error
+            expect { t1.dup.diff!(t2, :surplus_row => false) }.not_to raise_error
           end
 
           it "should raise on missing columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | a |
               | c |
-            }, __FILE__, __LINE__)
-            lambda { @t.dup.diff!(t) }.should raise_error
-            lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
+            })
+            expect { @t.dup.diff!(t) }.to raise_error
+            expect { @t.dup.diff!(t, :missing_col => false) }.not_to raise_error
           end
 
           it "should not raise on surplus columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | a | b | x |
               | c | d | y |
-            }, __FILE__, __LINE__)
-            lambda { @t.dup.diff!(t) }.should_not raise_error
-            lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
+            })
+            expect { @t.dup.diff!(t) }.not_to raise_error
+            expect { @t.dup.diff!(t, :surplus_col => true) }.to raise_error
           end
 
           it "should not raise on misplaced columns" do
-            t = table(%{
+            t = DataTable.from(%{
               | b | a |
               | d | c |
-            }, __FILE__, __LINE__)
-            lambda { @t.dup.diff!(t) }.should_not raise_error
-            lambda { @t.dup.diff!(t, :misplaced_col => true) }.should raise_error
+            })
+            expect { @t.dup.diff!(t) }.not_to raise_error
+            expect { @t.dup.diff!(t, :misplaced_col => true) }.to raise_error
           end
         end
 
-        def table(text, file, offset)
-          Table.parse(text, file, offset)
+        it "can compare to an Array" do
+          t = DataTable.from(%{
+            | b | a |
+            | d | c |
+          })
+          other = [ %w{b a}, %w{d c} ]
+
+          expect { t.diff!(other) }.not_to raise_error
         end
       end
 
-      describe "#new" do
+      describe "#from" do
         it "should allow Array of Hash" do
-          t1 = Table.new([{'name' => 'aslak', 'male' => 'true'}])
-          t1.to_s(:indent => 12, :color => false).should == %{
+          t1 = DataTable.from([{'name' => 'aslak', 'male' => 'true'}])
+          expect( t1.to_s(:indent => 12, :color => false) ).to eq %{
             |     male |     name  |
             |     true |     aslak |
           }
         end
       end
-
-      it "should convert to sexp" do
-        @table.to_sexp.should ==
-          [:table,
-            [:row, -1,
-              [:cell, "one"],
-              [:cell, "four"],
-              [:cell, "seven"]
-            ],
-            [:row, -1,
-              [:cell, "4444"],
-              [:cell, "55555"],
-              [:cell, "666666"]]]
-      end
     end
   end
 end