lucid 0.4.1 → 0.5.1

data/spec/lucid/ast/specs_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-module Lucid
-  module AST
-    describe Spec do
-      let(:spec) { Spec.new }
-
-      def parse_feature(gherkin)
-        path    = 'specs/test.spec'
-        builder = Lucid::Parser::SpecBuilder.new(path)
-        parser  = Gherkin::Parser::Parser.new(builder, true, 'root', false)
-        parser.parse(gherkin, path, 0)
-        builder.language = parser.i18n_language
-        feature = builder.result
-        spec.add_feature(feature)
-      end
-
-      it 'has a step_count' do
-        parse_feature(<<-GHERKIN)
-Feature:
-  Background:
-    Given step 1
-    And step 2
-
-  Scenario:
-    Given step 3
-    And step 4
-    And step 5
-
-  Scenario Outline:
-    Given step <n>
-    And another step
-
-    Examples:
-      | n |
-      | 6 |
-      | 7 |
-
-    Examples:
-      | n |
-      | 8 |
-        GHERKIN
-
-        spec.step_count.should == (2 + 3) + (3 * (2 + 2))
-      end
-    end
-  end
-end

data/spec/lucid/ast/step_invocation_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-require 'lucid/ast/step_invocation'
-
-module Lucid
-  module AST
-    describe StepInvocation do
-      let(:step_invocation) do
-        matched_cells = []
-        StepInvocation.new(double, double, double, matched_cells)
-      end
-
-      describe 'filtering backtraces' do
-        context 'when enabled' do
-          before { Lucid.stub use_full_backtrace: false }
-
-          it "removes lines with 'gems' in the path" do
-            original_backtrace = ['/foo/bar/gems/baz', '/path/to/my/file.rb']
-            exception = StandardError.new
-            exception.set_backtrace(original_backtrace)
-            result = step_invocation.filter_backtrace(exception).backtrace
-            result.should == ['/path/to/my/file.rb']
-          end
-
-          it "removes lines with '.gem' in the path" do
-            original_backtrace = ['/foo/bar/.gem/baz', '/path/to/my/file.rb']
-            exception = StandardError.new
-            exception.set_backtrace(original_backtrace)
-            result = step_invocation.filter_backtrace(exception).backtrace
-            result.should == ['/path/to/my/file.rb']
-          end
-        end
-
-        context 'when disabled' do
-          before { Lucid.stub use_full_backtrace: true }
-
-          it 'return the exception unmodified' do
-            exception = double
-            step_invocation.filter_backtrace(exception).should == exception
-          end
-        end
-      end
-      
-    end
-  end
-end

data/spec/lucid/ast/step_spec.rb

@@ -1,72 +0,0 @@
-require 'spec_helper'
-
-require 'lucid/ast'
-require 'lucid/lang_extend'
-
-module Lucid
-  module AST
-
-    describe Step do
-      let(:language) { double }
-
-      it 'should replace arguments in name' do
-        step = Step.new(language, 1, 'Given', 'a <status> test')
-
-        invocation_table = Table.new([
-            %w{status build},
-            %w{passing failing}
-                                     ])
-
-        cells = invocation_table.cells_rows[1]
-        step_invocation = step.step_invocation_from_cells(cells)
-
-        step_invocation.name.should == 'a passing test'
-      end
-
-      it 'should use empty string for the replacement of arguments in name when replace value is nil' do
-        step = Step.new(language, 1, 'Given', 'a <status> test')
-
-        invocation_table = Table.new([
-            %w(status),
-            [nil]
-                                     ])
-
-        cells = invocation_table.cells_rows[1]
-        step_invocation = step.step_invocation_from_cells(cells)
-
-        step_invocation.name.should == 'a  test'
-      end
-
-      it 'should replace arguments in provided table arguments' do
-        arg_table = Table.new([%w{status_<status> type_<type>}])
-        step = Step.new(language, 1, 'Given', 'a <status> test', arg_table)
-
-        invocation_table = Table.new([
-            %w{status type},
-            %w{passing regression}
-                                     ])
-
-        cells = invocation_table.cells_rows[1]
-        step_invocation = step.step_invocation_from_cells(cells)
-
-        step_invocation.instance_variable_get('@multiline_arg').raw.should == [%w{status_passing type_regression}]
-      end
-
-      it 'should replace arguments in a doc string argument' do
-        doc_string = DocString.new('status_<status> type_<type>', '')
-        step = Step.new(language, 1, 'Given', 'a <status> test', doc_string)
-
-        invocation_table = Table.new([
-            %w{status type},
-            %w{passing regression}
-                                     ])
-
-        cells = invocation_table.cells_rows[1]
-        step_invocation = step.step_invocation_from_cells(cells)
-
-        step_invocation.instance_variable_get('@multiline_arg').to_step_definition_arg.should == 'status_passing type_regression'
-      end
-
-    end
-  end
-end

data/spec/lucid/ast/table_spec.rb

@@ -1,265 +0,0 @@
-require 'spec_helper'
-require 'lucid/ast/table'
-
-module Lucid
-  module AST
-    
-    describe Table do
-      before do
-        @table = Table.new([
-            %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}
-      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}
-      end
-
-      it 'should have same cell objects in rows and columns' do
-        @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
-      end
-
-      it 'should be convertible to an array of hashes' do
-        @table.hashes.should == [
-            {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
-        ]
-      end
-
-      it 'should accept symbols as keys for the hashes' do
-        @table.hashes.first[:one].should == '4444'
-      end
-
-      it 'should return the row values in order' do
-        @table.rows.first.should == %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
-        end
-
-        it 'applies the block once to each value' do
-          headers = ['header']
-          rows = ['value']
-          table = Table.new [headers, rows]
-          count = 0
-          table.map_column!('header') { |value| count +=1 }
-          table.rows
-          count.should 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
-        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')
-        end
-
-        it 'should pass silently if a mapped column does not exist in non-strict mode' do
-          lambda {
-            @table.map_column!('two', false) { |v| v.to_i }
-            @table.hashes
-          }.should_not raise_error
-        end
-
-        it 'should fail if a mapped column does not exist in strict mode' do
-          lambda {
-            @table.map_column!('two', true) { |v| v.to_i }
-            @table.hashes
-          }.should 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
-        end
-      end
-      
-      describe '#match' do
-        before(:each) do
-          @table = Table.new([
-              %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
-        end
-
-        it 'requires a table: prefix on match' do
-          @table.match('table:one,four,seven').should_not be_nil
-        end
-
-        it 'does not match if no table: prefix on match' do
-          @table.match('one,four,seven').should be_nil
-        end
-      end
-      
-      describe '#transpose' do
-        before(:each) do
-          @table = Table.new([
-              %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'}
-        end
-      end
-      
-      describe '#rows_hash' do
-        it 'should return a hash of the rows' do
-          table = Table.new([
-              %w{one 1111},
-              %w{two 22222}
-                            ])
-
-          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
-        end
-
-        it 'should fail if the table does not have two columns' do
-          faulty_table = Table.new([
-              %w{one 1111 abc},
-              %w{two 22222 def}
-                                   ])
-          
-          lambda {
-            faulty_table.rows_hash
-          }.should raise_error('The table must have exactly 2 columns')
-        end
-
-        it 'should support header and column mapping' do
-          table = Table.new([
-              %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 }
-        end
-      end
-
-      describe '#map_headers!' do
-        let(:table) do
-          Table.new([
-              %w{HELLO LUCID},
-              %w{4444 55555}
-                    ])
-        end
-
-        it 'renames the columns to the specified values in the provided hash' do
-          @table.map_headers!('one' => :three)
-          @table.hashes.first[:three].should == '4444'
-        end
-
-        it 'allows renaming columns using regular expressions' do
-          @table.map_headers!(/one|uno/ => :three)
-          @table.hashes.first[:three].should == '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
-        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 lucid]
-        end
-
-        it 'treats the mappings in the provided hash as overrides when used with a block' do
-          table.map_headers!('LUCID' => 'test') do |header|
-            header.downcase
-          end
-          table.hashes.first.keys.should =~ %w[hello test]
-        end
-      end
-
-      describe 'replacing arguments' do
-        before(:each) do
-          @table = Table.new([
-              %w{showings movie},
-              %w{<showings> <movie>}
-                             ])
-        end
-
-        it 'should return a new table with arguments replaced with values' do
-          table_with_replaced_args = @table.arguments_replaced({'<movie>' => 'Gravity', '<showings>' => '5'})
-          table_with_replaced_args.hashes[0]['movie'].should == 'Gravity'
-          table_with_replaced_args.hashes[0]['showings'].should == '5'
-        end
-
-        it 'should recognise when entire cell is delimited' do
-          @table.should have_text('<movie>')
-        end
-
-        it 'should recognise when just a subset of a cell is delimited' do
-          table = Table.new([
-              %w{showings movie},
-              [nil, "Seeing <director>'s movie"]
-                            ])
-
-          table.should have_text('<director>')
-        end
-
-        it 'should replace nil values with nil' do
-          table_with_replaced_args = @table.arguments_replaced({'<movie>' => nil})
-          table_with_replaced_args.hashes[0]['movie'].should == nil
-        end
-
-        it 'should preserve values which do not match a placeholder when replacing with nil' do
-          table = Table.new([
-              %w{movie},
-              %w{screenplay}
-                            ])
-          table_with_replaced_args = table.arguments_replaced({'<movie>' => nil})
-          table_with_replaced_args.hashes[0]['movie'].should == 'screenplay'
-        end
-
-        it 'should not change the original table' do
-          @table.arguments_replaced({'<movie>' => 'Gravity'})
-          @table.hashes[0]['movie'].should_not == 'Gravity'
-        end
-
-        it 'should not raise an error when there are nil values in the table' do
-          table = Table.new([
-              ['movie', 'showings'],
-              ['<movie', nil]
-                            ])
-          
-          lambda {
-            table.arguments_replaced({'<movie>' => nil, '<showings>' => '5'})
-          }.should_not raise_error
-        end
-      end
-      
-    end
-    
-  end
-end

data/spec/lucid/ast/tdl_factory.rb

@@ -1,78 +0,0 @@
-require 'lucid/ast'
-
-module Lucid
-  module AST
-    module TDLFactory
-
-      class TestDomain
-
-      end
-
-      def create_feature(dsl)
-        dsl.Given (/^a (.*) step with an inline argument:$/) do |action, table|
-        end
-
-        dsl.Given (/^a (.*) step$/) do |action|
-        end
-
-        dsl.Domain do
-          TestDomain.new
-        end
-
-        table = AST::Table.new([
-                                   %w{1 22 333},
-                                   %w{4444 55555 666666}
-                               ])
-
-        doc_string = AST::DocString.new(%{\n Testing with\nLucid tools\n}, '')
-        location = AST::Location.new('test.spec', 2)
-        language = double.as_null_object
-
-        background = AST::Background.new(
-            language,
-            location,
-            AST::Comment.new(''),
-            'Background:',
-            '',
-            '',
-            [
-                Step.new(language, location.on_line(3), 'Given', 'a passing step')
-            ]
-        )
-
-        if Lucid::WINDOWS
-          location = Location.new('specs\\test.spec', 0)
-        else
-          location = Location.new('specs/test.spec', 0)
-        end
-
-        AST::Feature.new(
-            location,
-            background,
-            AST::Comment.new("# Feature Comment Line\n"),
-            AST::Tags.new(6, [Gherkin::Formatter::Model::Tag.new('smoke', 6),
-                              Gherkin::Formatter::Model::Tag.new('critical', 6)]),
-            'Feature',
-            'Testing TDL',
-            '',
-            [AST::Scenario.new(
-                 language,
-                 location.on_line(9),
-                 background,
-                 AST::Comment.new("   # Scenario Comment Line 1 \n# Scenario Comment Line 2 \n"),
-                 AST::Tags.new(8, [Gherkin::Formatter::Model::Tag.new('regression', 8),
-                                   Gherkin::Formatter::Model::Tag.new('selenium', 8)]),
-                 AST::Tags.new(1, []),
-                 'Scenario:', 'Test Scenario', '',
-                 [
-                     Step.new(language, location.on_line(10), 'Given', 'a passing step with an inline argument:', table),
-                     Step.new(language, location.on_line(11), 'Given', 'a working step with an inline argument:', doc_string),
-                     Step.new(language, location.on_line(12), 'Given', 'a non-passing step')
-                 ]
-             )]
-        )
-      end
-      
-    end
-  end
-end