lucid 0.3.3 → 0.4.0

data/spec/lucid/ast/scenario_outline_spec.rb

@@ -1,16 +1,16 @@
 require 'spec_helper'
 
 require 'lucid/ast'
-require 'lucid/core_ext/string'
+require 'lucid/lang_extend'
 require 'lucid/interface_rb/rb_language'
 
 module Lucid
   module AST
-    
+
     describe ScenarioOutline do
-      
+
       before do
-        @runtime = Lucid::Runtime.new
+        @runtime = Lucid::ContextLoader.new
         @runtime.load_code_language('rb')
         @dsl = Object.new
         @dsl.extend(Lucid::InterfaceRb::RbLucid)
@@ -26,7 +26,7 @@ module Lucid
         @dsl.Then(/^there should be (\d+) tests$/) do |n|
           (@initial - @tested).should == n.to_i
         end
-        
+
         @dsl.Then(/^there should be (\d+) tests completed$/) do |n|
           @tested.should == n.to_i
         end
@@ -69,13 +69,13 @@ module Lucid
       end
 
       it 'should replace all variables and call outline once for each table row' do
-        visitor = TDLWalker.new(@runtime)
+        visitor = Walker.new(@runtime)
         visitor.should_receive(:visit_table_row).exactly(3).times
         @scenario_outline.feature = double.as_null_object
         @scenario_outline.accept(visitor)
       end
-      
+
     end
-    
+
   end
-end
+end

data/spec/lucid/ast/specs_spec.rb

@@ -2,19 +2,19 @@ require 'spec_helper'
 
 module Lucid
   module AST
-    describe Specs do
-      let(:specs) { Specs.new }
-      
+    describe Spec do
+      let(:spec) { Spec.new }
+
       def parse_feature(gherkin)
         path    = 'specs/test.spec'
-        builder = Lucid::Parser::TDLBuilder.new(path)
+        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
-        specs.add_feature(feature)
+        spec.add_feature(feature)
       end
-      
+
       it 'has a step_count' do
         parse_feature(<<-GHERKIN)
 Feature:
@@ -41,8 +41,8 @@ Feature:
       | 8 |
         GHERKIN
 
-        specs.step_count.should == (2 + 3) + (3 * (2 + 2))
+        spec.step_count.should == (2 + 3) + (3 * (2 + 2))
       end
     end
   end
-end
+end

data/spec/lucid/ast/step_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 require 'lucid/ast'
-require 'lucid/core_ext/string'
+require 'lucid/lang_extend'
 
 module Lucid
   module AST
-    
+
     describe Step do
       let(:language) { double }
 
@@ -25,7 +25,7 @@ module Lucid
 
       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]
@@ -66,7 +66,7 @@ module Lucid
 
         step_invocation.instance_variable_get('@multiline_arg').to_step_definition_arg.should == 'status_passing type_regression'
       end
-      
+
     end
   end
-end
+end

data/spec/lucid/ast/tdl_walker_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 module Lucid::AST
-  
-  describe TDLWalker do
+
+  describe Walker do
     let(:tdl_walker) do
-      TDLWalker.new(nil, [double('listener', :before_visit_features => nil)])
+      Walker.new(nil, [double('listener', :before_visit_features => nil)])
     end
     let(:features) { double('features', :accept => nil) }
 
@@ -17,5 +17,5 @@ module Lucid::AST
       tdl_walker.visit_features(features).should == tdl_walker
     end
   end
-  
-end
+
+end

data/spec/lucid/{configuration_spec.rb → context_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 module Lucid
-  describe Configuration do
+  describe Context do
     describe '.default' do
-      subject { Configuration.default }
+      subject { Context.default }
 
       it 'has an autoload_code_paths containing default Lucid folders' do
         subject.autoload_code_paths.should include 'common'
@@ -14,33 +14,33 @@ module Lucid
 
     describe 'supports custom user options' do
       let(:user_options) { { :autoload_code_paths => ['library/common'] } }
-      subject { Configuration.new(user_options) }
+      subject { Context.new(user_options) }
 
       it 'should allow the defaults to be overridden' do
         subject.autoload_code_paths.should == ['library/common']
       end
     end
   end
-  
+
   module CLI
-    describe Configuration do
+    describe Context do
 
       attr_reader :out, :error
-      
+
       module ExposeOptions
         attr_reader :options
       end
-      
+
       def config
-        @config ||= Configuration.new(@out = StringIO.new, @error = StringIO.new).extend(ExposeOptions)
+        @config ||= Context.new(@out = StringIO.new, @error = StringIO.new).extend(ExposeOptions)
       end
-      
+
       def with_these_files(*files)
         File.stub(:directory?).and_return(true)
         File.stub(:file?).and_return(true)
         Dir.stub(:[]).and_return(files)
       end
-      
+
       def with_this_configuration(info)
         Dir.stub(:glob).with('{,.config/,config/}lucid{.yml,.yaml}').and_return(['lucid.yml'])
         File.stub(:exist?).and_return(true)
@@ -50,27 +50,27 @@ module Lucid
 
       it 'should require driver.rb files first' do
         with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
-        config.parse(%w{--require /common})
-        
+        config.parse_options(%w{--require /common})
+
         config.library_context.should == %w(
             /common/support/driver.rb
             /common/support/browser.rb
         )
       end
-      
+
       it 'should not require driver.rb files when a dry run is attempted' do
         with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
-        config.parse(%w{--require /common --dry-run})
+        config.parse_options(%w{--require /common --dry-run})
 
         config.library_context.should == %w(
           /common/support/browser.rb
         )
       end
-      
+
       it 'should require files in default definition locations' do
         with_these_files('/pages/page.rb', '/steps/steps.rb')
-        config.parse(%w{--require /specs})
-        
+        config.parse_options(%w{--require /specs})
+
         config.definition_context.should == %w(
           /pages/page.rb
           /steps/steps.rb
@@ -82,17 +82,17 @@ module Lucid
         Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.spec'])
         Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.spec'])
         Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.spec'])
-        config.parse(%w{})
-        config.spec_files.should == ['lucid.spec']
+        config.parse_options(%w{})
+        config.spec_context.should == ['lucid.spec']
       end
-      
+
       it 'should search for all specs in the specified directory' do
         File.stub(:directory?).and_return(true)
         Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.spec'])
         Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.spec'])
         Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.spec'])
-        config.parse(%w{specs/})
-        config.spec_files.should == ['lucid.spec']
+        config.parse_options(%w{specs/})
+        config.spec_context.should == ['lucid.spec']
       end
 
       it 'should return the correct spec file type for feature file' do
@@ -100,8 +100,8 @@ module Lucid
         Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.feature'])
         Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.feature'])
         Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.feature'])
-        config.parse(%w{specs/})
-        config.spec_files.should == ['lucid.feature']
+        config.parse_options(%w{specs/})
+        config.spec_context.should == ['lucid.feature']
       end
 
       it 'should return the correct spec file type for story file' do
@@ -109,27 +109,27 @@ module Lucid
         Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.story'])
         Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.story'])
         Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.story'])
-        config.parse(%w{specs/})
-        config.spec_files.should == ['lucid.story']
+        config.parse_options(%w{specs/})
+        config.spec_context.should == ['lucid.story']
       end
 
       it 'should preserve the order of the spec files' do
-        config.parse(%w{test_b.spec test_c.spec test_a.spec})
-        config.spec_files.should == %w[test_b.spec test_c.spec test_a.spec]
+        config.parse_options(%w{test_b.spec test_c.spec test_a.spec})
+        config.spec_context.should == %w[test_b.spec test_c.spec test_a.spec]
       end
-      
+
       it 'should be able to exclude files based on a specific reference' do
         with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
-        config.parse(%w{--require /common --exclude browser.rb})
-        
+        config.parse_options(%w{--require /common --exclude browser.rb})
+
         config.spec_requires.should == %w(
           /common/support/driver.rb
         )
       end
-      
+
       it 'should be able to exclude files based on a general pattern' do
         with_these_files('/steps/tester.rb', '/steps/tested.rb', '/steps/testing.rb', '/steps/quality.rb')
-        config.parse(%w{--require /steps --exclude test(er|ed) --exclude quality})
+        config.parse_options(%w{--require /steps --exclude test(er|ed) --exclude quality})
 
         config.spec_requires.should == %w(
           /steps/testing.rb
@@ -137,114 +137,114 @@ module Lucid
       end
 
       it 'should allow specifying environment variables on the command line' do
-        config.parse(['test=this'])
+        config.parse_options(['test=this'])
         ENV['test'].should == 'this'
-        config.spec_files.should_not include('test=this')
+        config.spec_context.should_not include('test=this')
       end
-      
+
       it 'should be able to use a --dry-run option' do
-        config.parse(%w{--dry-run})
+        config.parse_options(%w{--dry-run})
         config.options[:dry_run].should be_true
       end
-      
+
       it 'should be able to use a --no-source option' do
-        config.parse(%w{--no-source})
+        config.parse_options(%w{--no-source})
         config.options[:source].should be_false
       end
-      
+
       it 'should be able to use a --no-matchers option' do
-        config.parse(%w{--no-matchers})
+        config.parse_options(%w{--no-matchers})
         config.options[:matchers].should be_false
       end
-      
+
       it 'should be able to use a --quiet option' do
-        config.parse(%w{--quiet})
+        config.parse_options(%w{--quiet})
         config.options[:source].should be_false
         config.options[:matchers].should be_false
       end
-      
+
       it 'should be able to use a --verbose option' do
-        config.parse(%w{--verbose})
+        config.parse_options(%w{--verbose})
         config.options[:verbose].should be_true
       end
 
       it 'uses the default profile when no profile is defined' do
         with_this_configuration({'default' => '--require test_file'})
-        config.parse(%w{--format progress})
+        config.parse_options(%w{--format progress})
         config.options[:require].should include('test_file')
       end
-      
+
       describe 'generating output' do
-      
+
         it 'should be able to use an --out option' do
-          config.parse(%w{--out report.txt})
+          config.parse_options(%w{--out report.txt})
           config.formats.should == [%w(standard report.txt)]
         end
-        
+
         it 'should be able to use multiple --out options' do
-          config.parse(%w{--format standard --out report1.txt --out report2.txt})
+          config.parse_options(%w{--format standard --out report1.txt --out report2.txt})
           config.formats.should == [%w(standard report2.txt)]
         end
-      
+
       end
 
       it 'should be able to use a --color option' do
         Lucid::Term::ANSIColor.should_receive(:coloring=).with(true)
-        config.parse(['--color'])
+        config.parse_options(['--color'])
       end
 
       it 'should accept --no-color option' do
         Lucid::Term::ANSIColor.should_receive(:coloring=).with(false)
-        config = Configuration.new(StringIO.new)
-        config.parse(['--no-color'])
+        config = Context.new(StringIO.new)
+        config.parse_options(['--no-color'])
       end
 
       it 'should accept multiple --format options and put the STDOUT one first so progress is seen' do
-        config.parse(%w{--format standard --out output.txt --format progress})
+        config.parse_options(%w{--format standard --out output.txt --format progress})
         config.formats.should == [['progress', out], ['standard', 'output.txt']]
       end
 
       it 'should not accept multiple --format options when both use implicit STDOUT' do
         lambda do
-          config.parse(%w{--format pretty --format progress})
+          config.parse_options(%w{--format pretty --format progress})
         end.should raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
       end
 
       it 'should accept same --format options with implicit STDOUT, and keep only one' do
-        config.parse(%w{--format standard --format standard})
+        config.parse_options(%w{--format standard --format standard})
         config.formats.should == [['standard', out]]
       end
 
       it 'should not accept multiple --out streams pointing to the same place' do
         lambda do
-          config.parse(%w{--format standard --out file1 --format progress --out file1})
+          config.parse_options(%w{--format standard --out file1 --format progress --out file1})
         end.should raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
       end
 
       it 'should associate --out to previous --format' do
-        config.parse(%w{--format progress --out file1 --format profile --out file2})
+        config.parse_options(%w{--format progress --out file1 --format profile --out file2})
         config.formats.should == [['progress', 'file1'], ['profile', 'file2']]
       end
 
       it 'should accept same --format options with same --out streams and keep only one' do
-        config.parse(%w{--format html --out file --format standard --format html --out file})
+        config.parse_options(%w{--format html --out file --format standard --format html --out file})
         config.formats.should == [['standard', out], ['html', 'file']]
       end
 
       it 'should accept same --format options with different --out streams' do
-        config.parse(%w{--format html --out file1 --format html --out file2})
+        config.parse_options(%w{--format html --out file1 --format html --out file2})
         config.formats.should == [['html', 'file1'], ['html', 'file2']]
       end
 
       it 'should accept multiple --name options' do
-        config.parse(['--name', 'User logs in', '--name', 'User signs up'])
+        config.parse_options(['--name', 'User logs in', '--name', 'User signs up'])
 
         config.options[:name_regexps].should include(/User logs in/)
         config.options[:name_regexps].should include(/User signs up/)
       end
 
       it 'should accept multiple -n options' do
-        config.parse(['-n', 'User logs in', '-n', 'User signs up'])
+        config.parse_options(['-n', 'User logs in', '-n', 'User signs up'])
 
         config.options[:name_regexps].should include(/User logs in/)
         config.options[:name_regexps].should include(/User signs up/)
@@ -252,54 +252,54 @@ module Lucid
 
       it 'should allow specifying environment variables in profiles' do
         with_this_configuration({'selenium' => 'DRIVER=selenium'})
-        config.parse(['--profile', 'selenium'])
+        config.parse_options(['--profile', 'selenium'])
         ENV['DRIVER'].should == 'selenium'
-        config.spec_files.should_not include('DRIVER=selenium')
+        config.spec_context.should_not include('DRIVER=selenium')
       end
 
       describe 'Dry run execution' do
         it 'returns true when --dry-run was specified on in the arguments' do
-          config.parse(['--dry-run'])
+          config.parse_options(['--dry-run'])
           config.dry_run?.should be_true
         end
 
         it 'returns true when --dry-run was specified in a profile' do
           with_this_configuration({'default' => '--dry-run'})
-          config.parse([])
+          config.parse_options([])
           config.dry_run?.should be_true
         end
 
         it 'returns false by default' do
-          config.parse([])
+          config.parse_options([])
           config.dry_run?.should be_false
         end
       end
-      
+
       describe 'Specifying matcher type' do
         it 'returns the matcher type when it was set' do
-          config.parse(['--matcher-type', 'classic'])
+          config.parse_options(['--matcher-type', 'classic'])
           config.matcher_type.should eql :classic
         end
 
         it 'returns the matcher type when it was set with shorthand option' do
-          config.parse(['-I', 'classic'])
+          config.parse_options(['-I', 'classic'])
           config.matcher_type.should eql :classic
         end
 
         it 'returns the default matcher type if it was not set' do
-          config.parse([])
+          config.parse_options([])
           config.matcher_type.should eql :regexp
         end
       end
 
       describe 'handling tags' do
         it 'returns an empty expression when no tags are specified' do
-          config.parse([])
+          config.parse_options([])
           config.tag_expression.should be_empty
         end
 
         it 'returns an expression when tags are specified' do
-          config.parse(['--tags','@smoke'])
+          config.parse_options(['--tags','@smoke'])
           config.tag_expression.should_not be_empty
         end
       end
@@ -317,12 +317,12 @@ module Lucid
             e.backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
           end
         end
-        
+
         after do
           Lucid.use_full_backtrace = false
         end
       end
-      
+
     end
   end
-end
+end