cucumber 0.8.7 → 0.9.0

data/lib/cucumber/cli/profile_loader.rb

@@ -1,3 +1,5 @@
+require 'yaml'
+
 module Cucumber
   module Cli
 

data/lib/cucumber/configuration.rb

@@ -0,0 +1,37 @@
+module Cucumber
+  # The base class for configuring settings for a Cucumber run.
+  class Configuration
+    def self.default
+      new
+    end
+    
+    def self.parse(argument)
+      return new(argument) if argument.is_a?(Hash)
+      argument
+    end
+    
+    def initialize(options = {})
+      @options = options
+    end
+    
+    def dry_run?
+      @options[:dry_run]
+    end
+    
+    def guess?
+      @options[:guess]
+    end
+    
+    def strict?
+      @options[:strict]
+    end
+    
+    def expand? 
+      @options[:expand]
+    end
+    
+    def paths
+      @options[:paths]
+    end
+  end
+end

data/lib/cucumber/errors.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  # Raised when there is no matching StepDefinition for a step.
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < StandardError
+  end
+
+  # Raised when a step matches 2 or more StepDefinitions
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
+      super(message)
+    end
+  end
+
+  class TagExcess < StandardError
+    def initialize(messages)
+      super(messages.join("\n"))
+    end
+  end
+end

data/lib/cucumber/feature_file.rb

@@ -2,14 +2,13 @@ require 'cucumber/parser/gherkin_builder'
 require 'gherkin/formatter/filter_formatter'
 require 'gherkin/formatter/tag_count_formatter'
 require 'gherkin/parser/parser'
-require 'gherkin/i18n_lexer'
 
 module Cucumber
   class FeatureFile
     FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/ #:nodoc:
     LANGUAGE_PATTERN = /language:\s*(.*)/ #:nodoc:
 
-    # The +uri+ argument is the location of the source. It can ba a path 
+    # The +uri+ argument is the location of the source. It can be a path 
     # or a path:line1:line2 etc. If +source+ is passed, +uri+ is ignored.
     def initialize(uri, source=nil)
       @source = source
@@ -22,10 +21,10 @@ module Cucumber
     end
     
     # Parses a file and returns a Cucumber::Ast
-    # If +options+ contains tags, the result will
+    # If +configuration_filters+ contains any filters, the result will
     # be filtered.
-    def parse(options, tag_counts)
-      filters = @lines || options.filters
+    def parse(configuration_filters, tag_counts)
+      filters = @lines || configuration_filters
 
       builder             = Cucumber::Parser::GherkinBuilder.new
       filter_formatter    = filters.empty? ? builder : Gherkin::Formatter::FilterFormatter.new(builder, filters)
@@ -39,7 +38,7 @@ module Cucumber
         ast.language = parser.i18n_language
         ast.file = @path
         ast
-      rescue Gherkin::LexingError, Gherkin::Parser::ParseError => e
+      rescue Gherkin::Lexer::LexingError, Gherkin::Parser::ParseError => e
         e.message.insert(0, "#{@path}: ")
         raise e
       end
@@ -59,11 +58,5 @@ module Cucumber
         end
       end
     end
-    
-    private
-    
-    # Special PML markup that we want to filter out.
-    CO = %{\\s*<(label|callout)\s+id=".*?"\s*/>\\s*}
-    C_CALLOUT = %r{/\*#{CO}\*/|//#{CO}}o
   end
 end

data/lib/cucumber/formatter/junit.rb

@@ -122,8 +122,8 @@ module Cucumber
           @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
             if failed
               @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
-                @builder.text! @output
-                @builder.text!(format_exception(exception)) if exception
+                @builder.cdata! @output
+                @builder.cdata!(format_exception(exception)) if exception
               end
               @failures += 1
             end

data/lib/cucumber/formatter/tag_cloud.rb

@@ -28,7 +28,7 @@ module Cucumber
         matrix = @counts.to_a.sort{|paira, pairb| paira[0] <=> pairb[0]}.transpose
         table = Cucumber::Ast::Table.new(matrix)
         formatter = Cucumber::Formatter::Pretty.new(@step_mother, @io, {})
-        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter], {}).visit_multiline_arg(table)
+        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter]).visit_multiline_arg(table)
       end
     end
   end

data/lib/cucumber/js_support/js_dsl.js

@@ -1,15 +1,15 @@
 var CucumberJsDsl = {
   registerStepDefinition: function(regexp, func) {
     if(func == null) {
-      jsLanguage.executeStepDefinition(regexp);
+      jsLanguage.execute_step_definition(regexp);
     }
     else{
-      jsLanguage.addStepDefinition(regexp, func);
+      jsLanguage.add_step_definition(regexp, func);
     }
   },
 
   registerTransform: function(regexp, func) {
-    jsLanguage.registerJsTransform(regexp, func);
+    jsLanguage.register_js_transform(regexp, func);
   },
 
   beforeHook: function(tag_expressions_or_func, func) {
@@ -40,7 +40,7 @@ var CucumberJsDsl = {
       var hook_func = tag_expressions_or_func;
       var tag_expressions = [];
     }
-    jsLanguage.registerJsHook(label, tag_expressions, hook_func);
+    jsLanguage.register_js_hook(label, tag_expressions, hook_func);
   }
 }
 

data/lib/cucumber/js_support/js_language.rb

@@ -39,6 +39,10 @@ module Cucumber
         @js_language.current_world.execute(@js_function, args)
       end
 
+      def regexp_source
+        @regexp.inspect
+      end
+
       def arguments_from(step_name)
         matches = eval_js "#{@regexp}.exec('#{step_name}')"
         if matches
@@ -101,10 +105,10 @@ module Cucumber
       include LanguageSupport::LanguageMethods
       include JsSnippets
 
-      def initialize(step_mother)
+      def initialize(runtime)
         @step_definitions = []
         @world = JsWorld.new
-        @step_mother = step_mother
+        @runtime = runtime
 
         @world["jsLanguage"] = self
         @world.load(File.dirname(__FILE__) + '/js_dsl.js')
@@ -146,7 +150,7 @@ module Cucumber
 
       #TODO: support multiline arguments when calling steps from within steps
       def execute_step_definition(name, multiline_argument = nil)
-        @step_mother.step_match(name).invoke(multiline_argument)
+        @runtime.step_match(name).invoke(multiline_argument)
       end
 
       def register_js_hook(phase, tag_expressions, js_function)
@@ -162,12 +166,12 @@ module Cucumber
       end
 
       def steps(steps_text, file_colon_line)
-        @step_mother.invoke_steps(steps_text, @language, file_colon_line)
+        @runtime.invoke_steps(steps_text, @language, file_colon_line)
       end
 
       private
       def path_to_load_js_from
-        paths = @step_mother.options[:paths]
+        paths = @runtime.features_paths
         if paths.empty?
           '' # Using rake
         else

data/lib/cucumber/language_support.rb

@@ -1,5 +1,5 @@
 module Cucumber
-  # This module defines the API for programming panguage support in Cucumber.
+  # This module defines the API for programming language support in Cucumber.
   # While Cucumber itself is written in Ruby, any programming language can
   # be supported by implementing this API.
   #
@@ -27,4 +27,4 @@ module Cucumber
   #
   module LanguageSupport
   end
-end
+end

data/lib/cucumber/parser/gherkin_builder.rb

@@ -13,23 +13,23 @@ module Cucumber
         @feature || @multiline_arg
       end
 
-      def feature(statement, uri)
+      def feature(feature)
         @feature = Ast::Feature.new(
           nil, 
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}),
-          statement.keyword,
-          legacy_name_for(statement.name, statement.description),
+          Ast::Comment.new(feature.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, feature.tags.map{|tag| tag.name}),
+          feature.keyword,
+          legacy_name_for(feature.name, feature.description),
           []
         )
       end
 
-      def background(statement)
+      def background(background)
         @background = Ast::Background.new(
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          statement.line, 
-          statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
+          Ast::Comment.new(background.comments.map{|comment| comment.value}.join("\n")), 
+          background.line, 
+          background.keyword, 
+          legacy_name_for(background.name, background.description), 
           steps=[]
         )
         @feature.background = @background
@@ -71,20 +71,20 @@ module Cucumber
         @step_container = scenario_outline
       end
 
-      def examples(statement, examples_rows)
+      def examples(examples)
         examples_fields = [
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          statement.line, 
-          statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
-          matrix(examples_rows)
+          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")), 
+          examples.line, 
+          examples.keyword, 
+          legacy_name_for(examples.name, examples.description), 
+          matrix(examples.rows)
         ]
         @step_container.add_examples(examples_fields)
       end
 
-      def step(statement, multiline_arg, result)
-        @table_owner = Ast::Step.new(statement.line, statement.keyword, statement.name)
-        multiline_arg = rubify(multiline_arg)
+      def step(step)
+        @table_owner = Ast::Step.new(step.line, step.keyword, step.name)
+        multiline_arg = rubify(step.multiline_arg)
         case(multiline_arg)
         when Gherkin::Formatter::Model::PyString
           @table_owner.multiline_arg = Ast::PyString.new(multiline_arg.value)

data/lib/cucumber/platform.rb

@@ -1,11 +1,9 @@
 # Detect the platform we're running on so we can tweak behaviour
 # in various places.
-require 'rbconfig'
-require 'yaml'
 
 module Cucumber
-  version       = YAML.load_file(File.dirname(__FILE__) + '/../../VERSION.yml')
-  VERSION       = [version[:major], version[:minor], version[:patch], version[:build]].compact.join('.')
+unless defined?(Cucumber::VERSION)
+  VERSION       = '0.9.0'
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)
@@ -27,3 +25,4 @@ module Cucumber
   end
   self.use_full_backtrace = false
 end
+end

data/lib/cucumber/rake/task.rb

@@ -1,11 +1,5 @@
 require 'cucumber/platform'
 
-begin
-  # Support Rake > 0.8.7
-  require 'rake/dsl_definition'
-  include Rake::DSL
-rescue LoadError
-end
 module Cucumber
   module Rake
     # Defines a Rake task for running features.
@@ -71,7 +65,7 @@ module Cucumber
         end
 
         def runner
-          File.exist?("./Gemfile") ? ["bundle", "exec", RUBY] : [RUBY]
+          File.exist?("./Gemfile") && Gem.available?("bundler") ? ["bundle", "exec", RUBY] : [RUBY]
         end
 
         def run

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -88,6 +88,7 @@ module Cucumber
       
       # Registers a proc that will run after Cucumber is configured. You can register as 
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      # TODO: Deprecate this
       def AfterConfiguration(&proc)
         RbDsl.register_rb_hook('after_configuration', [], proc)
       end      

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,3 +1,4 @@
+require 'cucumber/core_ext/instance_exec'
 require 'cucumber/rb_support/rb_dsl'
 require 'cucumber/rb_support/rb_world'
 require 'cucumber/rb_support/rb_step_definition'

data/lib/cucumber/rspec/doubles.rb

@@ -4,13 +4,13 @@ RSpec.configuration.configure_mock_framework
 World(RSpec::Core::MockFrameworkAdapter)
 
 Before do
-  _setup_mocks
+  RSpec::Mocks::setup(self)
 end
 
 After do
   begin
-    _verify_mocks
+    RSpec::Mocks::verify
   ensure
-    _teardown_mocks
+    RSpec::Mocks::teardown
   end
 end

data/lib/cucumber/runtime.rb

@@ -0,0 +1,192 @@
+require 'cucumber/configuration'
+require 'cucumber/language_support/language_methods'
+require 'cucumber/formatter/duration'
+require 'gherkin/rubify'
+require 'cucumber/runtime/user_interface'
+require 'cucumber/runtime/features_loader'
+require 'cucumber/runtime/results'
+require 'cucumber/runtime/support_code'
+
+module Cucumber
+  # This is the meaty part of Cucumber that ties everything together.
+  class Runtime
+    attr_reader :results
+    
+    include Formatter::Duration
+    include Runtime::UserInterface
+
+    def initialize(configuration = Configuration.default)
+      @current_scenario = nil
+      @configuration = Configuration.parse(configuration)
+      @support_code = SupportCode.new(self, @configuration.guess?)
+      @results = Results.new(@configuration)
+    end
+    
+    def run!
+      load_step_definitions
+      fire_after_configuration_hook
+
+      tree_walker = @configuration.build_tree_walker(self)
+      self.visitor = tree_walker # Ugly circular dependency, but needed to support World#announce
+      
+      tree_walker.visit_features(features)
+    end
+    
+    def features_paths
+      @configuration.paths
+    end
+
+    def step_visited(step) #:nodoc:
+      @results.step_visited(step)
+    end
+
+    def scenarios(status = nil)
+      @results.scenarios(status)
+    end
+
+    def steps(status = nil)
+      @results.steps(status)
+    end
+
+    # Loads and registers programming language implementation.
+    # Instances are cached, so calling with the same argument
+    # twice will return the same instance.
+    #
+    def load_programming_language(ext)
+      @support_code.load_programming_language!(ext)
+    end
+
+    def invoke(step_name, multiline_argument)
+      @support_code.invoke(step_name, multiline_argument)
+    end
+
+    # Invokes a series of steps +steps_text+. Example:
+    #
+    #   invoke(%Q{
+    #     Given I have 8 cukes in my belly
+    #     Then I should not be thirsty
+    #   })
+    def invoke_steps(steps_text, i18n, file_colon_line)
+      @support_code.invoke_steps(steps_text, i18n, file_colon_line)
+    end
+
+    # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+    # be a String:
+    #
+    #   table(%{
+    #     | account | description | amount |
+    #     | INT-100 | Taxi        | 114    |
+    #     | CUC-101 | Peeler      | 22     |
+    #   })
+    #
+    # or a 2D Array:
+    #
+    #   table([
+    #     %w{ account description amount },
+    #     %w{ INT-100 Taxi        114    },
+    #     %w{ CUC-101 Peeler      22     }
+    #   ])
+    #
+    def table(text_or_table, file=nil, line_offset=0)
+      if Array === text_or_table
+        Ast::Table.new(text_or_table)
+      else
+        Ast::Table.parse(text_or_table, file, line_offset)
+      end
+    end
+
+    # Returns a regular String for +string_with_triple_quotes+. Example:
+    #
+    #   """
+    #    hello
+    #   world
+    #   """
+    #
+    # Is retured as: " hello\nworld"
+    #
+    def py_string(string_with_triple_quotes, file=nil, line_offset=0)
+      Ast::PyString.parse(string_with_triple_quotes)
+    end
+
+    def step_match(step_name, name_to_report=nil) #:nodoc:
+      @support_code.step_match(step_name, name_to_report)
+    end
+
+    def unmatched_step_definitions
+      @support_code.unmatched_step_definitions
+    end
+
+    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      @support_code.snippet_text(step_keyword, step_name, multiline_arg_class)
+    end
+
+    def with_hooks(scenario, skip_hooks=false)
+      around(scenario, skip_hooks) do
+        before_and_after(scenario, skip_hooks) do
+          yield scenario
+        end
+      end
+    end
+
+    def around(scenario, skip_hooks=false, &block) #:nodoc:
+      if skip_hooks
+        yield
+        return
+      end
+
+      @support_code.around(scenario, block)
+    end
+
+    def before_and_after(scenario, skip_hooks=false) #:nodoc:
+      before(scenario) unless skip_hooks
+      yield scenario
+      after(scenario) unless skip_hooks
+      @results.scenario_visited(scenario)
+    end
+
+    def before(scenario) #:nodoc:
+      return if @configuration.dry_run? || @current_scenario
+      @current_scenario = scenario
+      @support_code.fire_hook(:before, scenario)
+    end
+
+    def after(scenario) #:nodoc:
+      @current_scenario = nil
+      return if @configuration.dry_run?
+      @support_code.fire_hook(:after, scenario)
+    end
+
+    def after_step #:nodoc:
+      return if @configuration.dry_run?
+      @support_code.fire_hook(:execute_after_step, @current_scenario)
+    end
+
+    def unknown_programming_language?
+      @support_code.unknown_programming_language?
+    end
+
+  private
+
+    def fire_after_configuration_hook #:nodoc
+      @support_code.fire_hook(:after_configuration, @configuration)
+    end
+
+    def features
+      loader = Runtime::FeaturesLoader.new(
+        @configuration.feature_files, 
+        @configuration.filters, 
+        @configuration.tag_expression)
+      loader.features
+    end
+
+    def load_step_definitions
+      files = @configuration.support_to_load + @configuration.step_defs_to_load
+      @support_code.load_files!(files)
+    end
+
+    def log
+      Cucumber.logger
+    end
+  end
+
+end