stefl-cucumber 0.10.1

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -0,0 +1,82 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+require 'cucumber/rb_support/regexp_argument_matcher'
+
+module Cucumber
+  module RbSupport
+    # A Ruby Step Definition holds a Regexp and a Proc, and is created
+    # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
+    # in the <tt>step_definitions</tt> ruby files. See also RbDsl.
+    #
+    # Example:
+    #
+    #   Given /I have (\d+) cucumbers in my belly/ do
+    #     # some code here
+    #   end
+    #
+    class RbStepDefinition
+
+      class MissingProc < StandardError
+        def message
+          "Step definitions must always have a proc"
+        end
+      end
+
+      def initialize(rb_language, regexp, proc)
+        raise MissingProc if proc.nil?
+        if String === regexp
+          p = Regexp.escape(regexp)
+          p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
+          regexp = Regexp.new("^#{p}$") 
+        end
+        @rb_language, @regexp, @proc = rb_language, regexp, proc
+        @rb_language.available_step_definition(regexp_source, file_colon_line)
+      end
+
+      def regexp_source
+        @regexp.inspect
+      end
+
+      def to_hash
+        flags = ''
+        flags += 'm' if (@regexp.options & Regexp::MULTILINE) != 0
+        flags += 'i' if (@regexp.options & Regexp::IGNORECASE) != 0
+        flags += 'x' if (@regexp.options & Regexp::EXTENDED) != 0
+        {'source' => @regexp.source, 'flags' => flags}
+      end
+
+      def ==(step_definition)
+        regexp_source == step_definition.regexp_source
+      end
+
+      def arguments_from(step_name)
+        args = RegexpArgumentMatcher.arguments_from(@regexp, step_name)
+        @rb_language.invoked_step_definition(regexp_source, file_colon_line) if args
+        args
+      end
+
+      def invoke(args)
+        begin
+          args = @rb_language.execute_transforms(args)
+          @rb_language.current_world.cucumber_instance_exec(true, regexp_source, *args, &@proc)
+        rescue Cucumber::ArityMismatchError => e
+          e.backtrace.unshift(self.backtrace_line)
+          raise e
+        end
+      end
+
+      def backtrace_line
+        @proc.backtrace_line(regexp_source)
+      end
+
+      def file_colon_line
+        @proc.file_colon_line
+      end
+    
+      def file
+        @file ||= file_colon_line.split(':')[0]
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_transform.rb

@@ -0,0 +1,37 @@
+module Cucumber
+  module RbSupport
+    # A Ruby Transform holds a Regexp and a Proc, and is created
+    # by calling <tt>Transform in the <tt>support</tt> ruby files.
+    # See also RbDsl.
+    #
+    # Example:
+    #
+    #   Transform /^(\d+) cucumbers$/ do |cucumbers_string|
+    #     cucumbers_string.to_i
+    #   end
+    #
+    class RbTransform
+      class MissingProc < StandardError
+        def message
+          "Transforms must always have a proc with at least one argument"
+        end
+      end
+
+      def initialize(rb_language, pattern, proc)
+        raise MissingProc if proc.nil? || proc.arity < 1
+        @rb_language, @regexp, @proc = rb_language, Regexp.new(pattern), proc
+      end
+
+      def match(arg)
+        arg ? arg.match(@regexp) : nil
+      end
+
+      def invoke(arg)
+        if matched = match(arg)
+          args = matched.captures.empty? ? [arg] : matched.captures
+          @rb_language.current_world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_world.rb

@@ -0,0 +1,95 @@
+module Cucumber
+  module RbSupport
+    # All steps are run in the context of an object that extends this module.
+    module RbWorld
+      class << self
+        def alias_adverb(adverb)
+          alias_method adverb, :__cucumber_invoke
+        end
+      end
+
+      # Call a Transform with a string from another Transform definition
+      def Transform(arg)
+        rb = @__cucumber_step_mother.load_programming_language('rb')
+        rb.execute_transforms([arg]).first
+      end
+    
+      attr_writer :__cucumber_step_mother, :__natural_language
+
+      # Call a step from within a step definition. This method is aliased to
+      # the same i18n as RbDsl.
+      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+        @__cucumber_step_mother.invoke(name, multiline_argument)
+      end
+
+      # See StepMother#invoke_steps
+      def steps(steps_text)
+        @__cucumber_step_mother.invoke_steps(steps_text, @__natural_language, caller[0])
+      end
+
+      # See StepMother#table
+      def table(text_or_table, file=nil, line_offset=0)
+        @__cucumber_step_mother.table(text_or_table, file, line_offset)
+      end
+
+      # See StepMother#py_string
+      def py_string(string_with_triple_quotes, file=nil, line_offset=0)
+        @__cucumber_step_mother.py_string(string_with_triple_quotes, file, line_offset)
+      end
+
+      # See StepMother#announce
+      def announce(announcement)
+        @__cucumber_step_mother.announce(announcement)
+      end
+
+      # See StepMother#ask
+      def ask(question, timeout_seconds=60)
+        @__cucumber_step_mother.ask(question, timeout_seconds)
+      end
+
+      # See StepMother#embed
+      def embed(file, mime_type)
+        @__cucumber_step_mother.embed(file, mime_type)
+      end
+
+      # Prints out the world class, followed by all included modules.
+      def announce_world
+        announce "WORLD:\n  #{self.class}"
+        world = self
+        (class << self; self; end).instance_eval do
+          world.announce "  #{included_modules.join("\n  ")}"
+        end
+      end
+
+      # Mark the matched step as pending.
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Pending.new(message)
+          end
+          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+        else
+          raise Pending.new(message)
+        end
+      end
+
+      # The default implementation of Object#inspect recursively
+      # traverses all instance variables and invokes inspect. 
+      # This can be time consuming if the object graph is large.
+      #
+      # This can cause unnecessary delays when certain exceptions 
+      # occur. For example, MRI internally invokes #inspect on an 
+      # object that raises a NoMethodError. (JRuby does not do this).
+      #
+      # A World object can have many references created by the user
+      # or frameworks (Rails), so to avoid long waiting times on
+      # such errors in World we define it to just return a simple String.
+      #
+      def inspect #:nodoc:
+        sprintf("#<%s:0x%x>", self.class, self.object_id)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -0,0 +1,21 @@
+require 'cucumber/step_argument'
+
+module Cucumber
+  module RbSupport
+    class RegexpArgumentMatcher
+      def self.arguments_from(regexp, step_name)
+        match = regexp.match(step_name)
+        if match
+          n = 0
+          match.captures.map do |val|
+            n += 1
+            start = match.offset(n)[0]
+            StepArgument.new(val, start)
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Spec #:nodoc:
+  module Runner #:nodoc:
+    # Neuters RSpec's option parser.
+    # (RSpec's option parser tries to parse ARGV, which
+    # will fail when running cucumber)
+    class OptionParser < ::OptionParser #:nodoc:
+      NEUTERED_RSPEC = Object.new
+      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+      
+      def self.method_added(m)
+        unless @__neutering_rspec
+          @__neutering_rspec = true
+          define_method(m) do |*a|
+            NEUTERED_RSPEC
+          end
+          @__neutering_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rspec/doubles.rb

@@ -0,0 +1,16 @@
+require 'rspec/core'
+
+RSpec.configuration.configure_mock_framework
+World(RSpec::Core::MockFrameworkAdapter)
+
+Before do
+  RSpec::Mocks::setup(self)
+end
+
+After do
+  begin
+    RSpec::Mocks::verify
+  ensure
+    RSpec::Mocks::teardown
+  end
+end

data/lib/cucumber/runtime.rb

@@ -0,0 +1,145 @@
+require 'gherkin/rubify'
+require 'gherkin/i18n'
+require 'cucumber/configuration'
+require 'cucumber/language_support/language_methods'
+require 'cucumber/formatter/duration'
+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)
+      require 'cucumber/core_ext/disable_mini_unit_autorun'
+      @current_scenario = nil
+      @configuration = Configuration.parse(configuration)
+      @support_code = SupportCode.new(self, @configuration)
+      @results = Results.new(@configuration)
+    end
+    
+    # Allows you to take an existing runtime and change it's configuration
+    def configure(new_configuration)
+      @configuration = Configuration.parse(new_configuration)
+      @support_code.configure(@configuration)
+      @results.configure(@configuration)
+    end
+    
+    def load_programming_language(language)
+      @support_code.load_programming_language(language)
+    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
+
+    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(Gherkin::I18n.code_keyword_for(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

data/lib/cucumber/runtime/features_loader.rb

@@ -0,0 +1,62 @@
+require 'cucumber/errors'
+
+module Cucumber
+  class Runtime
+    
+    class FeaturesLoader
+      include Formatter::Duration
+
+      def initialize(feature_files, filters, tag_expression)
+        @feature_files, @filters, @tag_expression = feature_files, filters, tag_expression
+      end
+      
+      def features
+        load unless @features
+        @features
+      end
+      
+    private
+    
+      def load
+        features = Ast::Features.new
+
+        tag_counts = {}
+        start = Time.new
+        log.debug("Features:\n")
+        @feature_files.each do |f|
+          feature_file = FeatureFile.new(f)
+          feature = feature_file.parse(@filters, tag_counts)
+          if feature
+            features.add_feature(feature)
+            log.debug("  * #{f}\n")
+          end
+        end
+        duration = Time.now - start
+        log.debug("Parsing feature files took #{format_duration(duration)}\n\n")
+
+        check_tag_limits(tag_counts)
+
+        @features = features
+      end
+
+      def check_tag_limits(tag_counts)
+        error_messages = []
+        @tag_expression.limits.each do |tag_name, tag_limit|
+          tag_locations = (tag_counts[tag_name] || [])
+          tag_count = tag_locations.length
+          if tag_count > tag_limit
+            error = "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
+              tag_locations.join("\n  ")
+            error_messages << error
+          end
+        end
+        raise TagExcess.new(error_messages) if error_messages.any?
+      end
+      
+      def log
+        Cucumber.logger
+      end
+    end
+
+  end
+end