aslakhellesoy-cucumber 0.3.11.3 → 0.3.11.5

data/lib/cucumber/parser/i18n/language.rb

@@ -0,0 +1,80 @@
+module Cucumber
+  module Parser
+    module I18n
+      class Language
+        KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+
+        class << self
+          LANGUAGES = Hash.new{|h,k| h[k] = Language.new(k)}
+          
+          def [](key)
+            LANGUAGES[key]
+          end
+
+          def alias_step_definitions(keywords) #:nodoc:
+            all_keywords = %w{given when then and but}.map{|keyword| keywords[keyword].split('|')}.flatten
+            alias_steps(all_keywords)
+          end
+
+          # Sets up additional method aliases for Given, When and Then.
+          # This does *not* affect how feature files are parsed. If you
+          # want to create aliases in the parser, you have to do this in
+          # languages.yml. For example:
+          #
+          # and: And|With
+          def alias_steps(keywords)
+            keywords.each do |adverb|
+              StepMother.alias_adverb(adverb)
+              World.alias_adverb(adverb)
+            end
+          end
+        end
+
+        alias_step_definitions(Cucumber::LANGUAGES['en'])
+
+        attr_reader :parser
+
+        def initialize(lang)
+          @keywords = Cucumber::LANGUAGES[lang]
+          raise "Language not supported: #{lang.inspect}" if @keywords.nil?
+          @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+          i18n_tt = File.expand_path(File.dirname(__FILE__) + '/../i18n.tt')
+          template = File.open(i18n_tt, Cucumber.file_mode('r')).read
+          erb = ERB.new(template)
+          grammar = erb.result(binding)
+          Treetop.load_from_string(grammar)
+          @parser = Parser::I18n.const_get("#{@keywords['grammar_name']}Parser").new
+          self.class.alias_step_definitions(@keywords)
+        end
+
+        def parse(source, path, filter)
+          feature = @parser.parse_or_fail(source, path, filter)
+          feature.language = self if feature
+          feature
+        end
+
+        def keywords(key, raw=false)
+          return @keywords[key] if raw
+          values = @keywords[key].split('|')
+          values.map{|value| "'#{value}'"}.join(" / ")
+        end
+
+        def language_incomplete?
+          KEYWORD_KEYS.detect{|key| @keywords[key].nil?}
+        end
+
+        def scenario_keyword
+          @keywords['scenario'].split('|')[0] + ':'
+        end
+
+        def but_keywords
+          @keywords['but'].split('|')
+        end
+
+        def and_keywords
+          @keywords['and'].split('|')
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/parser/treetop_ext.rb

@@ -12,80 +12,19 @@ end
 
 module Cucumber
   module Parser
-    class Filter
-      def initialize(lines, options)
-        @lines = lines
-        @include_tags = options[:include_tags] || []
-        @exclude_tags = options[:exclude_tags] || []
-        @name_regexps = options[:name_regexps] || []
-      end
-
-      def accept?(syntax_node)
-        at_line?(syntax_node) &&
-        matches_tags?(syntax_node) &&
-        matches_names?(syntax_node)
-      end
-
-      def accept_example?(syntax_node, outline)
-        (at_line?(syntax_node) || outline_at_line?(outline)) && 
-        (matches_names?(syntax_node) || outline_matches_names?(outline))
-      end
-      
-      def at_line?(syntax_node)
-        @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.at_line?(line)}
-      end
-
-      def outline_at_line?(syntax_node)
-         @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.outline_at_line?(line)}
-      end
-
-      def matches_tags?(syntax_node)
-        !excluded_by_tags?(syntax_node) &&
-        included_by_tags?(syntax_node)
-      end
-
-      def included_by_tags?(syntax_node)
-        @include_tags.empty? || syntax_node.has_tags?(@include_tags)
-      end
-
-      def excluded_by_tags?(syntax_node)
-        @exclude_tags.any? && syntax_node.has_tags?(@exclude_tags)
-      end
-      
-      def outline_matches_names?(syntax_node)
-        @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.outline_matches_name?(name_regexp)}
-      end
-      
-      def matches_names?(syntax_node)
-        @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.matches_name?(name_regexp)}
+    class SyntaxError < StandardError
+      def initialize(parser, file, line_offset)
+        tf = parser.terminal_failures
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
+        line = parser.failure_line + line_offset
+        message = "#{file}:#{line}:#{parser.failure_column}: Parse error, expected #{expected}."
+        super(message)
       end
     end
-
-    module TreetopExt      
-      FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
-
-      # Parses a file and returns a Cucumber::Ast
-      def parse_file(file, options)
-        _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
-        if path
-          lines = lines.split(':').map { |line| line.to_i }
-        else
-          path = file
-        end
-        filter = Filter.new(lines, options)
-
-        loader = lambda { |io| parse_or_fail(io.read, filter, path) }
-        feature = if path =~ /^http/
-          require 'open-uri'
-          open(path, &loader)
-        else
-          File.open(path, Cucumber.file_mode('r'), &loader) 
-        end
-        feature
-      end
-
-      def parse_or_fail(string, filter=nil, file=nil, line_offset=0)
-        parse_tree = parse(string)
+    
+    module TreetopExt
+      def parse_or_fail(source, file=nil, filter=nil, line_offset=0)
+        parse_tree = parse(source)
         if parse_tree.nil?
           raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
         else
@@ -95,16 +34,6 @@ module Cucumber
         end
       end
     end
-
-    class SyntaxError < StandardError
-      def initialize(parser, file, line_offset)
-        tf = parser.terminal_failures
-        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
-        line = parser.failure_line + line_offset
-        message = "#{file}:#{line}:#{parser.failure_column}: Parse error, expected #{expected}."
-        super(message)
-      end
-    end
   end
 end
 
@@ -115,7 +44,7 @@ module Treetop
         input.line_of(interval.first)
       end
     end
-    
+
     class CompiledParser
       include Cucumber::Parser::TreetopExt
     end

data/lib/cucumber/platform.rb

@@ -4,9 +4,11 @@ require 'rbconfig'
 require 'yaml'
 
 module Cucumber
+  # TODO: Move these constants and the file to Language. Update wiki
   LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/languages.yml')
   LANGUAGES     = YAML.load_file(LANGUAGE_FILE)
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+  LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)
   IRONRUBY      = Config::CONFIG['sitedir'] =~ /IronRuby/
   WINDOWS       = Config::CONFIG['host_os'] =~ /mswin|mingw/
@@ -14,4 +16,8 @@ module Cucumber
   RAILS         = defined?(Rails)
   RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
   RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+  
+  def self.file_mode(m)
+    RUBY_1_9 ? "#{m}:UTF-8" : m
+  end
 end

data/lib/cucumber/step_mother.rb

@@ -254,12 +254,12 @@ module Cucumber
       @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
     end
 
-    def before_and_after(scenario, skip=false)
-      before(scenario) unless skip
+    def before_and_after(scenario, skip_hooks=false)
+      before(scenario) unless skip_hooks
       @current_scenario = scenario
       yield scenario
       @current_scenario = nil
-      after(scenario) unless skip
+      after(scenario) unless skip_hooks
       scenario_visited(scenario)
     end
     

data/lib/cucumber/version.rb

@@ -3,7 +3,7 @@ module Cucumber #:nodoc:
     MAJOR = 0
     MINOR = 3
     TINY  = 11
-    PATCH = 3 # Set to nil for official release
+    PATCH = 5 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -1,5 +1,7 @@
 $LOAD_PATH.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib') if File.directory?(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
 
+unless ARGV.any? {|a| a =~ /^gems/}
+
 begin
   require 'cucumber/rake/task'
 
@@ -14,3 +16,5 @@ rescue LoadError
     abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
   end
 end
+
+end

data/spec/cucumber/ast/step_collection_spec.rb

@@ -4,10 +4,11 @@ module Cucumber
   module Ast
     describe StepCollection do
       it "should convert And to Given in snippets" do
-        c = StepCollection.new([
-          Step.new(1, 'Given', 'cukes'),
-          Step.new(2, 'And', 'turnips')
-        ])
+        s1 = Step.new(1, 'Given', 'cukes')
+        s2 = Step.new(2, 'And', 'turnips')
+        s1.stub!(:language).and_return(Parser::I18n::Language['en'])
+        s2.stub!(:language).and_return(Parser::I18n::Language['en'])
+        c = StepCollection.new([s1, s2])
         actual_keywords = c.step_invocations.map{|i| i.actual_keyword}
         actual_keywords.should == %w{Given Given}
       end

data/spec/cucumber/cli/configuration_spec.rb

@@ -138,12 +138,22 @@ module Cli
 
     end
 
+    context '--drb in the default profile and no arguments specified' do
+      it "expands the profile's arguments into the args excpet for --drb" do
+        given_cucumber_yml_defined_as({'default' => '--drb features --format pretty'})
+        config = Configuration.new(StringIO.new)
+        args = []
+        config.parse!(args)
+        args.should == %w{features --format pretty}
+      end
+    end
+
     it "should expand args from YAML file" do
       given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
 
       config = Configuration.new
       config.parse!(%w{--format progress --profile bongo})
-      config.options[:formats].should == {'progress' => STDOUT}
+      config.options[:formats].should == [['progress', STDOUT]]
       config.options[:require].should == ['from/yml']
     end
 
@@ -255,26 +265,34 @@ END_OF_MESSAGE
     it "should accept --out option" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--out jalla.txt})
-      config.options[:formats]['pretty'].should == 'jalla.txt'
+      config.options[:formats].should == [['pretty', 'jalla.txt']]
     end
 
     it "should accept multiple --out options" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --out file2})
-      config.options[:formats].should == {'progress' => 'file2'}
+      config.options[:formats].should == [['progress', 'file2']]
     end
 
-    it "should accept multiple --format options" do
-      config = Configuration.new(StringIO.new)
-      config.parse!(%w{--format pretty --format progress})
-      config.options[:formats].should have_key('pretty')
-      config.options[:formats].should have_key('progress')
+    it "should accept multiple --format options and put the STDOUT one first so progress is seen" do
+      io = StringIO.new
+      config = Configuration.new(io)
+      config.parse!(%w{--format pretty --out pretty.txt --format progress})
+      config.options[:formats].should == [['progress', io], ['pretty', 'pretty.txt']]
+    end
+
+    it "should not accept multiple --format options when both use implicit STDOUT" do
+      io = StringIO.new
+      config = Configuration.new(io)
+      lambda do
+        config.parse!(%w{--format pretty --format progress})
+      end.should raise_error("All but one formatter must use --out, only one can print to STDOUT")
     end
 
     it "should associate --out to previous --format" do
       config = Configuration.new(StringIO.new)
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
-      config.options[:formats].should == {"profile"=>"file2", "progress"=>"file1"}
+      config.options[:formats].should == [["progress", "file1"], ["profile" ,"file2"]]
     end
 
     it "should accept --color option" do
@@ -358,6 +376,21 @@ END_OF_MESSAGE
       config.feature_files.should == ["cucumber.feature"]
     end
 
+    it "should allow specifying environment variables on the command line" do
+      config = Configuration.new
+      config.parse!(["foo=bar"])
+      ENV["foo"].should == "bar"
+      config.feature_files.should == []
+    end
+    
+    it "should allow specifying environment variables in profiles" do
+      given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
+      config = Configuration.new
+      config.parse!(["--profile", "selenium"])
+      ENV["RAILS_ENV"].should == "selenium"
+      config.feature_files.should == []
+    end
+
   end
 end
 end

data/spec/cucumber/cli/main_spec.rb

@@ -35,7 +35,7 @@ module Cucumber
           @cli = Main.new(%w{--verbose example.feature}, @out)
           @cli.stub!(:require)
 
-          Parser::FeatureParser.stub!(:new).and_return(mock("feature parser", :parse_file => @empty_feature))
+          FeatureFile.stub!(:new).and_return(mock("feature file", :parse => @empty_feature))
 
           @cli.execute!(Object.new.extend(StepMother))
 
@@ -115,10 +115,9 @@ module Cucumber
           @cli.execute!(@step_mother).should == 'foo'
         end
 
-
         it "ceases execution if the DrbClient is able to perform the execution" do
           DRbClient.stub!(:run).and_return(true)
-          @configuration.should_not_receive(:load_language)
+          @configuration.should_not_receive(:build_formatter_broadcaster)
           @cli.execute!(@step_mother)
         end
 
@@ -134,15 +133,8 @@ module Cucumber
             @configuration.should_receive(:parse!).exactly(:twice)
             @cli.execute!(@step_mother)
           end
-
-          it "proceeds with the execution locally" do
-            @configuration.should_receive(:load_language)
-            @cli.execute!(@step_mother)
-          end
         end
-
       end
-
     end
   end
 end

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -1,11 +1,11 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
-require 'cucumber/parser'
+require 'cucumber/parser/i18n/language'
 
 module Cucumber
   module Parser
     describe Feature do
       before do
-        @parser = FeatureParser.new
+        @parser = I18n::Language['en'].parser
       end
 
       def parse(text)
@@ -13,11 +13,11 @@ module Cucumber
       end
 
       def parse_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file, {})
+        FeatureFile.new(File.dirname(__FILE__) + "/../treetop_parser/" + file).parse
       end
 
       def parse_example_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file, {})
+        FeatureFile.new(File.dirname(__FILE__) + "/../../../examples/" + file).parse
       end
 
       describe "Comments" do
@@ -25,7 +25,7 @@ module Cucumber
           parse(%{# My comment
 Feature: hi
 }).to_sexp.should ==
-          [:feature, nil, "Feature: hi\n",
+          [:feature, nil, "Feature: hi",
             [:comment, "# My comment\n"]]
         end
 
@@ -34,13 +34,13 @@ Feature: hi
 # World
 Feature: hi
 }).to_sexp.should ==
-          [:feature, nil, "Feature: hi\n",
+          [:feature, nil, "Feature: hi",
             [:comment, "# Hello\n# World\n"]]
         end
 
         it "should parse a file with no comments" do
           parse("Feature: hi\n").to_sexp.should ==
-          [:feature, nil, "Feature: hi\n"]
+          [:feature, nil, "Feature: hi"]
         end
 
         it "should parse a file with only a multiline comment with newlines" do
@@ -61,7 +61,7 @@ Feature: hi
       describe "Tags" do
         it "should parse a file with tags on a feature" do
           parse("# My comment\n@hello @world Feature: hi\n").to_sexp.should ==
-          [:feature, nil, "Feature: hi\n",
+          [:feature, nil, "Feature: hi",
             [:comment, "# My comment\n"],
             [:tag, "hello"],
             [:tag, "world"]]
@@ -352,7 +352,9 @@ Given I am a step
 
       describe "Filtering" do
         it "should filter outline tables" do
-          f = parse_example_file('self_test/features/outline_sample.feature:12')
+          ff = FeatureFile.new(
+            File.dirname(__FILE__) + '/../../../examples/self_test/features/outline_sample.feature:12')
+          f = ff.parse({:lang => 'en'})
           f.to_sexp.should ==
           [:feature,
            "./spec/cucumber/parser/../../../examples/self_test/features/outline_sample.feature",