cucumber-core 0.1.0

data/lib/cucumber/core/test/timer.rb

@@ -0,0 +1,31 @@
+module Cucumber
+  module Core
+    module Test
+      class Timer
+        def start
+          @start_time = time_in_nanoseconds
+          self
+        end
+
+        def duration
+          nsec
+        end
+
+        def nsec
+          time_in_nanoseconds - @start_time
+        end
+
+        def sec
+          nsec / 10 ** 9.0
+        end
+
+        private
+
+        def time_in_nanoseconds
+          t = Time.now
+          t.to_i * 10 ** 9 + t.nsec
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/core/version.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module Core
+    class Version
+      def self.to_s
+        "0.1.0"
+      end
+    end
+  end
+end

data/lib/cucumber/initializer.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  def self.initializer(*attributes)
+    Module.new do
+      attr_reader(*attributes)
+      private(*attributes)
+
+      define_method(:initialize) do |*arguments|
+        if attributes.size != arguments.size
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{attributes.size})"
+        end
+
+        attributes.zip(arguments) do |attribute, argument|
+          instance_variable_set("@#{attribute}", argument)
+        end
+      end
+    end
+  end
+end

data/spec/capture_warnings.rb

@@ -0,0 +1,68 @@
+# With thanks to @myronmarston
+# https://github.com/vcr/vcr/blob/master/spec/capture_warnings.rb
+
+module CaptureWarnings
+  def report_warnings(&block)
+    current_dir = Dir.pwd
+    warnings, errors = capture_error(&block).partition { |line| line.include?('warning') }
+    project_warnings, other_warnings = warnings.uniq.partition { |line| line.include?(current_dir) }
+
+    if errors.any?
+      puts errors.join("\n")
+    end
+
+    if other_warnings.any?
+      puts "#{ other_warnings.count } non-cucumber-core warnings detected, set VIEW_OTHER_WARNINGS=true to see them."
+      print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
+    end
+
+    if project_warnings.any?
+      puts "#{ project_warnings.count } cucumber-core warnings detected" 
+      print_warnings('cucumber-core', project_warnings)
+      fail "Please remove all cucumber-core warnings."
+    end
+
+    ensure_system_exit_if_required
+  end
+
+  def capture_error(&block)
+    old_stderr = STDERR.clone
+    pipe_r, pipe_w = IO.pipe
+    pipe_r.sync    = true
+    error         = ""
+    reader = Thread.new do
+      begin
+        loop do
+          error << pipe_r.readpartial(1024)
+        end
+      rescue EOFError
+      end
+    end
+    STDERR.reopen(pipe_w)
+    block.call
+  ensure
+    capture_system_exit
+    STDERR.reopen(old_stderr)
+    pipe_w.close
+    reader.join
+    return error.split("\n")
+  end
+
+  def print_warnings(type, warnings)
+    puts
+    puts "-" * 30 + " #{type} warnings: " + "-" * 30
+    puts
+    puts warnings.join("\n")
+    puts
+    puts "-" * 75
+    puts
+  end
+
+  def ensure_system_exit_if_required
+    raise @system_exit if @system_exit
+  end
+
+  def capture_system_exit
+    @system_exit = $!
+  end
+end

data/spec/coverage.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+formatters = [ SimpleCov::Formatter::HTMLFormatter ]
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  formatters << Coveralls::SimpleCov::Formatter
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[*formatters]
+SimpleCov.start

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+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)
+          def @table.cells_rows; super; end
+          def @table.columns; super; end
+        end
+
+        it "should have rows" do
+          expect( @table.cells_rows[0].map{|cell| cell.value} ).to eq %w{one four seven}
+        end
+
+        it "should have columns" do
+          expect( @table.columns[1].map{|cell| cell.value} ).to eq %w{four 55555}
+        end
+
+        it "should have headers" do
+          expect( @table.headers ).to eq %w{one four seven}
+        end
+
+        it "should have same cell objects in rows and columns" do
+          # 666666
+          expect( @table.cells_rows[1].__send__(:[], 2) ).to eq @table.columns[2].__send__(:[], 1)
+        end
+
+        it "should know about max width of a row" do
+          expect( @table.columns[1].__send__(:width) ).to eq 5
+        end
+
+        it "should be convertible to an array of hashes" do
+          expect( @table.hashes ).to eq [
+            {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
+          ]
+        end
+
+        it "should accept symbols as keys for the hashes" do
+          expect( @table.hashes.first[:one] ).to eq '4444'
+        end
+
+        it "should return the row values in order" do
+          expect( @table.rows.first ).to eq %w{4444 55555 666666}
+        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 "#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 be convertible in to an array where each row is a hash" do
+            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 = DataTable.new([
+              %w{one 1111},
+              %w{two 22222}
+            ], location)
+            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 = DataTable.new([
+              %w{one 1111 abc},
+              %w{two 22222 def}
+            ], location)
+            expect { faulty_table.rows_hash }.to raise_error('The table must have exactly 2 columns')
+          end
+        end
+
+        describe "#new" do
+          it "should allow Array of Hash" do
+            t1 = DataTable.new([{'name' => 'aslak', 'male' => 'true'}], location)
+            expect( t1.hashes ).to eq [{'name' => 'aslak', 'male' => 'true'}]
+          end
+        end
+
+        it "should convert to sexp" do
+          sexp_value =      
+            [:table,
+              [:row, -1,
+                [:cell, "one"],
+                [:cell, "four"],
+                [:cell, "seven"]
+              ],
+              [:row, -1,
+                [:cell, "4444"],
+                [:cell, "55555"],
+                [:cell, "666666"]
+              ]
+            ]
+          expect( @table.to_sexp ).to eq sexp_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'cucumber/core/ast/location'
+require 'cucumber/core/ast/doc_string'
+
+module Cucumber
+  module Core
+    module Ast
+      describe DocString do
+        let(:location) { double }
+        let(:doc_string) { DocString.new(content, content_type, location) }
+
+        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 'raises an error when compared with something odd' do
+            expect { doc_string == 5 }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'quacking like a String' do
+          let(:content) { '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 convertion to a String' do
+            expect( 'expected content' ).to include(doc_string)
+          end
+
+          it 'allows explicit convertion 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'cucumber/core/ast/examples_table'
+
+module Cucumber::Core::Ast
+  describe ExamplesTable do
+    let(:location) { double(:to_s => 'file.feature:8') }
+
+    describe ExamplesTable::Header do
+      let(:header) { ExamplesTable::Header.new(%w{foo bar baz}, location) }
+
+      describe 'location' do
+        it 'knows the file and line number' do
+          expect( header.file_colon_line ).to eq 'file.feature:8'
+        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) ).to eq ExamplesTable::Row.new({'foo' => '1', 'bar' => '2', 'baz' => '3'}, 1, location)
+        end
+      end
+    end
+    describe ExamplesTable::Row do
+
+      describe 'location' do
+        it 'knows the file and line number' do
+          row = ExamplesTable::Row.new({}, 1, location)
+          expect( row.file_colon_line ).to eq 'file.feature:8'
+        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)
+            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)
+            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)
+            text = 'foo <x> bar <z>'
+            expect( row.expand(text) ).to eq 'foo 1 bar <z>'
+          end
+        end
+      end
+
+      describe 'accesing the values' do
+        it 'returns the actual row values' do
+          row = ExamplesTable::Row.new({'x' => '1', 'y' => '2'}, 1, location)
+          expect( row.values ).to eq ['1', '2']
+        end
+      end
+
+      describe 'equality' do
+        let(:data) { {} }
+        let(:number) { double }
+        let(:location) { double }
+        let(:original) { ExamplesTable::Row.new(data, number, location) }
+
+        it 'is equal to another instance with the same data, number and location' do
+          expect( original ).to eq ExamplesTable::Row.new(data, number, location)
+        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)
+          expect( original ).not_to eq ExamplesTable::Row.new(data, double, location)
+          expect( original ).not_to eq ExamplesTable::Row.new(data, number, double)
+        end
+
+        it 'is not equal to another type of object' do
+          expect( original ).not_to eq double(data: data, number: number, location: location)
+        end
+
+      end
+    end
+  end
+end