aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber/executor.rb

@@ -1,205 +0,0 @@
-module Cucumber
-  class Executor
-    attr_reader :failed
-    attr_accessor :formatters
-    attr_writer :scenario_names, :lines_for_features, :dry_run
-
-    def initialize(step_mother)
-      @world_procs = []
-      @before_scenario_procs = []
-      @after_scenario_procs = []
-      @after_step_procs = []
-      @step_mother = step_mother
-
-      @executed_scenarios = {}
-      @regular_scenario_cache = {}
-    end
-
-    def register_world_proc(&proc)
-      @world_procs << proc
-    end
-
-    def register_before_scenario_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @before_scenario_procs << proc
-    end
-
-    def register_after_scenario_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @after_scenario_procs << proc
-    end
-
-    def register_after_step_proc(&proc)
-      proc.extend(CoreExt::CallIn)
-      @after_step_procs << proc
-    end
-
-    def visit_features(features)
-      formatters.visit_features(features)
-      features.accept(self)
-      formatters.dump
-    end
-
-    def visit_feature(feature)
-      @feature_file = feature.file
-            
-      if accept_feature?(feature)
-        formatters.feature_executing(feature)
-        feature.accept(self)
-        @executed_scenarios = {}
-        @regular_scenario_cache = {}
-      end
-    end
-
-    def visit_header(header)
-      formatters.header_executing(header)
-    end
-
-    def visit_row_scenario(scenario)
-      execute_scenario(@regular_scenario_cache[scenario.name]) if executing_unprepared_row_scenario?(scenario)
-      visit_scenario(scenario)
-    end
-
-    def visit_regular_scenario(scenario)
-      @regular_scenario_cache[scenario.name] = scenario
-      visit_scenario(scenario)
-    end
-
-    def visit_scenario_outline(scenario)
-      visit_regular_scenario(scenario)
-    end
-
-    def visit_scenario(scenario)
-      if accept_scenario?(scenario)
-        @executed_scenarios[scenario.name] = true
-        execute_scenario(scenario)
-      end
-    end
-
-    def execute_scenario(scenario)
-      @error = nil
-      @pending = nil
-
-      @world = create_world
-
-      formatters.scenario_executing(scenario)
-      @before_scenario_procs.each{|p| p.call_in(@world, *[])} unless @dry_run
-      scenario.accept(self)
-      @after_scenario_procs.each{|p| p.call_in(@world, *[])} unless @dry_run
-      formatters.scenario_executed(scenario)
-    end
-    
-    def accept_scenario?(scenario)
-      scenario_at_specified_line?(scenario) &&
-      scenario_has_specified_name?(scenario)
-    end
-
-    def accept_feature?(feature)
-      feature.scenarios.any? { |s| accept_scenario?(s) }
-    end
-
-    def visit_row_step(step)
-      visit_step(step)
-    end
-
-    def visit_regular_step(step)
-      visit_step(step)
-    end
-
-    def visit_step_outline(step)
-      regexp, args, proc = step.regexp_args_proc(@step_mother)
-      formatters.step_traced(step, regexp, args)
-    end
-
-    def visit_step(step)
-      unless @pending || @error
-        begin
-          regexp, args, proc = step.regexp_args_proc(@step_mother)
-          formatters.step_executing(step, regexp, args)
-          step.execute_in(@world, regexp, args, proc) unless @dry_run
-          @after_step_procs.each{|p| p.call_in(@world, *[])}
-          formatters.step_passed(step, regexp, args)
-        rescue ForcedPending => e
-          step.error = e
-          record_pending_step(step, regexp, args)
-        rescue Pending
-          record_pending_step(step, regexp, args)
-        rescue => e
-          @failed = true
-          @error = step.error = e
-          formatters.step_failed(step, regexp, args)
-        end
-      else
-        begin
-          regexp, args, proc = step.regexp_args_proc(@step_mother)
-          step.execute_in(@world, regexp, args, proc)
-          formatters.step_skipped(step, regexp, args)
-        rescue ForcedPending => e
-          step.error = e
-          record_pending_step(step, regexp, args)
-        rescue Pending
-          record_pending_step(step, regexp, args)
-        rescue Exception
-          formatters.step_skipped(step, regexp, args)
-        end
-      end
-    end
-
-    def record_pending_step(step, regexp, args)
-      @pending = true
-      formatters.step_pending(step, regexp, args)
-    end
-
-    def executing_unprepared_row_scenario?(scenario)
-      accept_scenario?(scenario) && !@executed_scenarios[scenario.name]
-    end
-    
-    def scenario_at_specified_line?(scenario)
-      if lines_defined_for_current_feature?
-        @lines_for_features[@feature_file].inject(false) { |at_line, line| at_line || scenario.at_line?(line) }
-      else
-        true
-      end
-    end
-    
-    def scenario_has_specified_name?(scenario)
-      if @scenario_names && !@scenario_names.empty?
-        @scenario_names.include?(scenario.name)
-      else
-        true
-      end
-    end
-    
-    def lines_defined_for_current_feature?
-      @lines_for_features && !@lines_for_features[@feature_file].nil? && !@lines_for_features[@feature_file].empty?
-    end
-    
-    def create_world
-      world = Object.new
-      @world_procs.each do |world_proc|
-        world = world_proc.call(world)
-      end
-
-      world.extend(World::Pending)
-      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
-      define_step_call_methods(world)
-      world
-    end
-
-    def define_step_call_methods(world)
-      world.instance_variable_set('@__executor', self)
-      world.instance_eval do
-        class << self
-          def run_step(name)
-            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
-            proc.call_in(self, *args)
-          end
-
-          %w{given when then and but}.each do |keyword|
-            alias_method Cucumber.language[keyword], :run_step
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/formatters/profile_formatter.rb

@@ -1,92 +0,0 @@
-module Cucumber
-  module Formatters
-    class ProfileFormatter < ProgressFormatter
-      NUMBER_OF_STEP_DEFINITONS_TO_SHOW = 10
-      NUMBER_OF_STEP_INVOCATIONS_TO_SHOW = 5
-
-      def initialize(io, step_mother)
-        super(io)
-        @step_mother = step_mother
-        @step_times = Hash.new { |k,v| k[v] = [] }
-        @step_keywords = {}
-      end
-
-      def visit_features(features)
-        @io.puts "Profiling enabled.\n"
-      end
-
-      def step_executing(step, regexp, args)
-        @step_time = Time.now
-      end
-
-      def step_passed(step, regexp, args)
-        execution_time = Time.now - @step_time
-        super
-        @step_keywords[regexp] ||= step.actual_keyword unless step.row?
-        invocation_comment = ''
-        definition_comment = ''
-
-        if step.row?
-          description = ''
-          args.each do |arg|
-            description +=  %{|#{arg}|}
-          end
-        else
-          description = "#{step.keyword} #{step.format(regexp){|param| underline(param)}}"
-          definition_comment = source(step)
-        end
-        invocation_comment = "# #{step.file}:#{step.line}"
-        @step_times["#{@step_keywords[regexp]} #{regexp.inspect}"] << [description, invocation_comment, definition_comment, execution_time]
-      end
-
-      def dump
-        super
-        @io.puts "\n\nTop #{NUMBER_OF_STEP_DEFINITONS_TO_SHOW} average slowest steps with #{NUMBER_OF_STEP_INVOCATIONS_TO_SHOW} slowest matches:\n"
-
-        mean_times = map_to_mean_times(@step_times)
-        mean_times = mean_times.sort_by { |step_profiles, keyword_regexp, mean_execution_time| mean_execution_time }.reverse
-
-        mean_times[0...NUMBER_OF_STEP_DEFINITONS_TO_SHOW].each do |step_profiles, keyword_regexp, mean_execution_time|
-          print_step_definition(step_profiles, keyword_regexp, mean_execution_time)
-          step_profiles = step_profiles.sort_by { |description, invocation_comment, definition_comment, execution_time| execution_time }.reverse
-          print_step_invocations(step_profiles, keyword_regexp)
-        end
-      end
-
-      private
-      def map_to_mean_times(step_times)
-        mean_times = []
-        step_times.each do |regexp, step_profiles|
-          mean_execution_time = (step_profiles.inject(0) { |sum, step_details| step_details[3] + sum } / step_profiles.length)
-          mean_times << [step_profiles, regexp, mean_execution_time]
-        end
-        mean_times
-      end
-
-      def print_step_definition(step_profiles, keyword_regexp, mean_execution_time)
-        unless step_profiles.empty?
-          _, _, definition_comment, _ = step_profiles.first
-          @io.print red(sprintf("%.7f",  mean_execution_time))
-          @io.print "  #{keyword_regexp}"
-          @io.print "  #{comment(definition_comment)}"
-          @io.puts
-        end
-      end
-
-      def print_step_invocations(step_profiles, keyword_regexp)
-        step_profiles[0...NUMBER_OF_STEP_INVOCATIONS_TO_SHOW].each do |description, invocation_comment, definition_comment, execution_time|
-          @io.print "  #{yellow(sprintf("%.7f", execution_time))}"
-          @io.print "  #{description}"
-          @io.print "  #{comment(invocation_comment)}"
-          @io.puts
-        end
-      end
-
-      def source(step)
-        _, _, proc = step.regexp_args_proc(@step_mother)
-        proc.to_comment_line
-      end
-
-    end
-  end
-end

data/lib/cucumber/formatters/progress_formatter.rb

@@ -1,61 +0,0 @@
-require 'cucumber/formatters/ansicolor'
-
-module Cucumber
-  module Formatters
-    class ProgressFormatter
-      include ANSIColor
-
-      def initialize(io)
-        @io = (io == STDOUT) ? Kernel : io
-        @errors             = []
-        @pending_scenarios  = []
-      end
-
-      def scenario_executing(scenario)
-        if scenario.pending?
-          @pending_scenarios << scenario
-          @io.print pending("P")
-        end
-      end
-
-      def step_passed(step, regexp, args)
-        @io.print passed('.')
-      end
-
-      def step_failed(step, regexp, args)
-        @errors << step.error
-        @io.print failed('F')
-      end
-
-      def step_pending(step, regexp, args)
-        @pending_scenarios << step.scenario
-        @io.print pending('P')
-      end
-
-      def step_skipped(step, regexp, args)
-        @io.print skipped('_')
-      end
-
-      def step_traced(step, regexp, args)
-      end
-
-      def dump
-        @io.puts pending
-        @io.puts "\nPending Scenarios:\n\n" if @pending_scenarios.any?
-        @pending_scenarios.uniq.each_with_index do |scenario, n|
-          @io.puts "#{n+1}) #{scenario.feature.header.split("\n").first.gsub(/^(Feature|Story):/, '')} (#{scenario.name})"
-        end
-
-        @io.puts failed
-        @io.puts "\nFailed:" if @errors.any?
-        @errors.each_with_index do |error,n|
-          @io.puts
-          @io.puts "#{n+1})"
-          @io.puts error.message
-          @io.puts error.backtrace.join("\n")
-        end
-        @io.print reset
-      end
-    end
-  end
-end

data/lib/cucumber/formatters.rb

@@ -1 +0,0 @@
-%w{html pretty progress profile autotest}.each{|n| require "cucumber/formatters/#{n}_formatter"}

data/lib/cucumber/model/table.rb

@@ -1,32 +0,0 @@
-module Cucumber
-  module Model
-    class Table
-      attr_accessor :raw
-      
-      # Creates a new table. The +raw+ argument should be an array
-      # of arrays
-      def initialize(raw)
-        @raw = raw
-      end
-      
-      # Turn the table into an array of Hash where each Hash
-      # has keys corresponding to the table header (first line)
-      # and the values are the individual row cells.
-      def hashes
-        header = @raw[0]
-        rows.map do |row|
-          h = {}
-          row.each_with_index do |v,n|
-            key = header[n]
-            h[key] = v
-          end
-          h
-        end
-      end
-      
-      def rows
-        @raw[1..-1]
-      end
-    end
-  end
-end

data/lib/cucumber/model.rb

@@ -1 +0,0 @@
-%w{table}.each{|f| require "cucumber/model/#{f}"}

data/lib/cucumber/step_methods.rb

@@ -1,49 +0,0 @@
-require 'cucumber/step_mother'
-
-module Cucumber
-  # Defines "global" methods that may be used in *_steps.rb files.
-  module StepMethods
-    # Each scenario will execute in the context of what the supplied block returns.
-    def World(&proc)
-      executor.register_world_proc(&proc)
-    end
-
-    def Before(&proc)
-      executor.register_before_scenario_proc(&proc)
-    end
-    
-    def After(&proc)
-      executor.register_after_scenario_proc(&proc)
-    end
-
-    def AfterStep(&proc)
-      executor.register_after_step_proc(&proc)
-    end
-
-    def Given(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def When(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-
-    def Then(key, &proc)
-      step_mother.register_step_proc(key, &proc)
-    end
-    
-    # Simple workaround for old skool steps
-    def steps_for(*_)
-      STDERR.puts "WARNING: In Cucumber the steps_for method is obsolete"
-      yield
-    end
-    
-    def step_mother #:nodoc:
-      @step_mother ||= StepMother.new
-    end
-    
-    def executor
-      @executor ||= Executor.new(step_mother)
-    end
-  end
-end

data/lib/cucumber/tree/feature.rb

@@ -1,105 +0,0 @@
-module Cucumber
-  module Tree
-    class Feature
-      attr_reader :header
-      attr_reader :scenarios
-      MIN_PADDING = 2
-
-      attr_accessor :file
-
-      def initialize(header, &proc)
-        @header = header
-        @scenarios = []
-        instance_eval(&proc) if block_given?
-      end
-
-      def add_scenario(name, line, &proc)
-        scenario = Scenario.new(self, name, line, &proc)
-        @scenarios << scenario
-        scenario
-      end
-
-      def add_scenario_outline(name, line, &proc)
-        scenario = ScenarioOutline.new(self, name, line, &proc)
-        @scenarios << scenario
-        scenario
-      end
-
-      def add_row_scenario(template_scenario, values, line)
-        scenario = RowScenario.new(self, template_scenario, values, line)
-        @scenarios << scenario
-        scenario
-      end
-            
-      def add_row_scenario_outline(template_scenario, values, line)
-        scenario = RowScenarioOutline.new(self, template_scenario, values, line)
-        @scenarios << scenario
-        scenario
-      end
-
-      def scenario_named(name)
-        @scenarios.find {|s| s.name == name}
-      end
-
-      def padding_length
-        MIN_PADDING
-      end
-
-      def Scenario(name, &proc)
-        line = caller[0] =~ /:(\d+)$/ ? $1 : nil
-        add_scenario(name, line, &proc)
-      end
-
-      def ScenarioOutline(name, &proc)
-        line = caller[0] =~ /:(\d+)$/ ? $1 : nil
-        add_scenario_outline(name, line, &proc)
-      end
-
-      def Table(matrix = [], &proc)
-        table = Table.new(matrix)
-        proc.call(table)
-  
-        template_scenario = @scenarios.last
-        template_scenario.table_header = matrix[0]
-
-        matrix[1..-1].each do |row|
-          if template_scenario.outline?
-            add_row_scenario_outline(template_scenario, row, row.line)
-          else
-            add_row_scenario(template_scenario, row, row.line)
-          end
-        end
-      end
-
-      def accept(visitor)
-        visitor.visit_header(@header)
-        @scenarios.each do |scenario|
-          if scenario.outline? && !scenario.row?
-            visitor.visit_scenario_outline(scenario)
-          elsif scenario.row?
-            visitor.visit_row_scenario(scenario)
-          else
-            visitor.visit_regular_scenario(scenario)
-          end
-        end
-      end
-      
-      def last_line(scenario)
-        next_scenario = next_scenario(scenario) 
-        next_scenario ? next_scenario.line - 1 : lines
-      end
-      
-      protected
-      
-      def next_scenario(scenario)
-        index = @scenarios.index(scenario)
-        @scenarios[index + 1]
-      end
-      
-      def lines
-        @lines ||= File.readlines(file).size
-      end
-      
-    end
-  end
-end

data/lib/cucumber/tree/features.rb

@@ -1,21 +0,0 @@
-module Cucumber
-  module Tree
-    class Features
-      def initialize
-        @features = []
-      end
-      
-      def length
-        @features.length
-      end
-
-      def <<(feature)
-        @features << feature
-      end
-
-      def accept(visitor)
-        @features.each{|feature| visitor.visit_feature(feature)}
-      end
-    end
-  end
-end

data/lib/cucumber/tree/given_scenario.rb

@@ -1,13 +0,0 @@
-module Cucumber
-  module Tree
-    class GivenScenario
-      def initialize(scenario, name, line)
-        @scenario, @name, @line = scenario, name, line
-      end
-      
-      def steps
-        @scenario.given_scenario_steps(@name)
-      end
-    end
-  end
-end