jeffrafter-cucumber 0.1.10

data/lib/autotest/cucumber_mixin.rb

@@ -0,0 +1,109 @@
+require 'autotest'
+require 'tempfile'
+
+module Autotest::CucumberMixin
+  def self.included(receiver)
+    receiver::ALL_HOOKS << [:run_features, :ran_features]
+  end
+  
+  attr_accessor :scenarios_to_run
+  
+  def initialize
+    super
+    reset_features
+  end
+  
+  def run
+    hook :initialize
+    reset
+    reset_features
+    add_sigint_handler
+
+    self.last_mtime = Time.now if $f
+
+    loop do # ^c handler
+      begin
+        get_to_green
+        if self.tainted then
+          rerun_all_tests
+          rerun_all_features if all_good
+        else
+          hook :all_good
+        end
+        wait_for_changes
+        # Once tests and features are green, reset features every
+        # time a file is changed to see if anything breaks.
+        reset_features
+      rescue Interrupt
+        break if self.wants_to_quit
+        reset
+        reset_features
+      end
+    end
+    hook :quit
+  end
+  
+  def all_features_good
+    scenarios_to_run == []
+  end
+  
+  def get_to_green
+    begin
+      super
+      run_features
+      wait_for_changes unless all_features_good
+    end until all_features_good
+  end
+  
+  def rerun_all_features
+    reset_features
+    run_features
+  end
+  
+  def reset_features
+    self.scenarios_to_run = :all
+  end
+    
+  def run_features
+    hook :run_features
+    Tempfile.open('autotest-cucumber') do |dirty_scenarios_file|
+      cmd = self.make_cucumber_cmd self.scenarios_to_run, dirty_scenarios_file.path
+      return if cmd.empty?
+      puts cmd unless $q
+      system cmd
+      self.scenarios_to_run = dirty_scenarios_file.readlines.map { |l| l.chomp }
+      self.tainted = true unless self.scenarios_to_run == []
+    end
+    hook :ran_features
+  end
+  
+  def make_cucumber_cmd(scenarios_to_run, dirty_scenarios_filename)
+    return '' if scenarios_to_run == []
+    
+    profiles = YAML.load_file("cucumber.yml").keys rescue []
+    
+    profile ||= "autotest-all" if profiles.include?("autotest-all") and scenarios_to_run == :all
+    profile ||= "autotest"     if profiles.include?("autotest")
+    profile ||= nil
+    
+    if profile
+      args = ["--profile", profile]
+    else
+      args = %w{features --format} << (scenarios_to_run == :all ? "progress" : "pretty")
+    end
+    args += %w{--format autotest --out} << dirty_scenarios_filename
+    args = args.join(' ')
+    
+    if scenarios_to_run == :all
+      scenario_args = nil
+    else
+      scenario_args = scenarios_to_run.map { |s| "-s '#{s}'" }.join(' ')
+    end
+    
+    return "#{cucumber} #{args} #{scenario_args}"
+  end
+  
+  def cucumber
+    File.exist?("script/cucumber") ? "script/cucumber" : "cucumber"
+  end
+end

data/lib/autotest/cucumber_rails.rb

@@ -0,0 +1,6 @@
+require 'autotest/rails'
+require 'autotest/cucumber_mixin'
+
+class Autotest::CucumberRails < Autotest::Rails
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rails_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec'
+
+class Autotest::CucumberRailsRspec < Autotest::RailsRspec
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec'
+
+class Autotest::CucumberRspec < Autotest::Rspec
+  include CucumberMixin
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,9 @@
+Autotest.add_discovery do
+  if File.directory?('features')
+    if ENV['AUTOFEATURE'] =~ /true/i
+      "cucumber"
+    else
+      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
+    end
+  end
+end

data/lib/cucumber/broadcaster.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  class Broadcaster
+
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def register(receiver)
+      @receivers << receiver
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.each  do |receiver|
+        r = (receiver == STDOUT) ? Kernel: receiver # Needed to make colors work on Windows
+        r.__send__(method_name, *args) if receiver.respond_to?(method_name)
+      end
+    end
+
+  end
+end

data/lib/cucumber/cli.rb

@@ -0,0 +1,303 @@
+require 'optparse'
+require 'cucumber'
+
+module Cucumber
+  class CLI
+    class << self
+      attr_writer :step_mother, :executor, :features
+
+      def execute
+        @execute_called = true
+        parse(ARGV).execute!(@step_mother, @executor, @features)
+      end
+
+      def execute_called?
+        @execute_called
+      end
+
+      def parse(args)
+        cli = new
+        cli.parse_options!(args)
+        cli
+      end
+    end
+
+    attr_reader :options, :paths
+    FORMATS = %w{pretty profile progress html autotest}
+    DEFAULT_FORMAT = 'pretty'
+
+    def initialize(out_stream = STDOUT, error_stream = STDERR)
+      @out_stream = out_stream
+      @error_stream = error_stream
+      @paths = []
+      @options = {
+        :require => nil,
+        :lang    => 'en',
+        :dry_run => false,
+        :source  => true,
+        :snippets => true,
+        :formats => {},
+        :excludes => [],
+        :scenario_names => nil
+      }
+      @active_format = DEFAULT_FORMAT
+    end
+
+    def parse_options!(args)
+      return parse_args_from_profile('default') if args.empty?
+      args.extend(OptionParser::Arguable)
+
+      args.options do |opts|
+        opts.banner = "Usage: cucumber [options] FILES|DIRS"
+        opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR", "Require files before executing the features.",
+          "If this option is not specified, all *.rb files that",
+          "are siblings or below the features will be autorequired",
+          "This option can be specified multiple times.") do |v|
+          @options[:require] ||= []
+          @options[:require] << v
+        end
+        opts.on("-s SCENARIO", "--scenario SCENARIO", "Only execute the scenario with the given name.",
+                                                      "If this option is given more than once, run all",
+                                                      "the specified scenarios.") do |v|
+          @options[:scenario_names] ||= []
+          @options[:scenario_names] << v
+        end
+        opts.on("-a LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
+          "Available languages: #{Cucumber.languages.join(", ")}",
+          "Look at #{Cucumber::LANGUAGE_FILE} for keywords") do |v|
+          @options[:lang] = v
+        end
+        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{DEFAULT_FORMAT})",
+          "Available formats: #{FORMATS.join(", ")}",
+          "You can also provide your own formatter classes as long as they have been",
+          "previously required using --require or if they are in the folder",
+          "structure such that cucumber will require them automatically.",
+          "This option can be specified multiple times.") do |v|
+  
+          @options[:formats][v] ||= []
+          @options[:formats][v] << @out_stream
+          @active_format = v
+        end
+        opts.on("-o", "--out FILE", "Write output to a file instead of @out_stream.",
+          "This option can be specified multiple times, and applies to the previously",
+          "specified --format.") do |v|
+          @options[:formats][@active_format] ||= []
+          if @options[:formats][@active_format].last == @out_stream
+            @options[:formats][@active_format][-1] = File.open(v, 'w')
+          else
+            @options[:formats][@active_format] << File.open(v, 'w')
+          end
+        end
+        opts.on("-c", "--[no-]color", "Use ANSI color in the output, if formatters use it.  If",
+                                      "these options are given multiple times, the last one is",
+                                      "used.  If neither --color or --no-color is given cucumber",
+                                      "decides based on your platform and the output destination") do |v|
+          @options[:color] = v
+        end
+        opts.on("-e", "--exclude PATTERN", "Don't run features matching a pattern") do |v|
+          @options[:excludes] << v
+        end
+        opts.on("-p", "--profile PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
+          parse_args_from_profile(v)
+        end
+        opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.") do
+          @options[:dry_run] = true
+        end
+        opts.on("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
+          @options[:source] = false
+        end
+        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
+          @options[:snippets] = false
+        end
+        opts.on("-q", "--quiet", "Don't show any development aid information") do
+          @options[:snippets] = false
+          @options[:source] = false
+        end
+        opts.on("-v", "--verbose", "Show the files and features loaded") do
+          @options[:verbose] = true
+        end
+        opts.on_tail("--version", "Show version") do
+          @out_stream.puts VERSION::STRING
+          Kernel.exit
+        end
+        opts.on_tail("--help", "You're looking at it") do
+          @out_stream.puts opts.help
+          Kernel.exit
+        end
+      end.parse!
+
+      if @options[:formats].empty?
+        @options[:formats][DEFAULT_FORMAT] = [@out_stream]
+      end
+      
+      # Whatever is left after option parsing is the FILE arguments
+      args = extract_and_store_line_numbers(args)
+      @paths += args
+    end
+
+    def parse_args_from_profile(profile)
+      unless File.exist?('cucumber.yml')
+        return exit_with_error("cucumber.yml was not found.  Please define your '#{profile}' and other profiles in cucumber.yml.\n"+
+                               "Type 'cucumber --help' for usage.\n")
+      end
+      
+      require 'yaml'
+      cucumber_yml = YAML::load(IO.read('cucumber.yml'))
+      args_from_yml = cucumber_yml[profile]
+      if args_from_yml.nil?
+        exit_with_error <<-END_OF_ERROR
+Could not find profile: '#{profile}'
+
+Defined profiles in cucumber.yml:
+  * #{cucumber_yml.keys.join("\n  * ")}
+        END_OF_ERROR
+      elsif !args_from_yml.is_a?(String)
+        exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
+      else
+        parse_options!(args_from_yml.split(' '))
+      end
+    end
+
+    def execute!(step_mother, executor, features)
+      Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
+      Cucumber.load_language(@options[:lang])
+      require_files
+      executor.formatters = build_formatter_broadcaster(step_mother)
+      load_plain_text_features(features)
+      executor.lines_for_features = @options[:lines_for_features]
+      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
+      executor.visit_features(features)
+      exit 1 if executor.failed
+    end
+
+    private
+
+    def extract_and_store_line_numbers(file_arguments)
+      @options[:lines_for_features] = Hash.new{|k,v| k[v] = []}
+      file_arguments.map do |arg|
+        _, file, lines = */^([\w\W]*?):([\d:]+)$/.match(arg)
+        unless file.nil?
+          @options[:lines_for_features][file] += lines.split(':').map { |line| line.to_i }
+          arg = file          
+        end
+        arg
+      end
+    end
+    
+    # Requires files - typically step files and ruby feature files.
+    def require_files
+      ARGV.clear # Shut up RSpec
+      require "cucumber/treetop_parser/feature_#{@options[:lang]}"
+      require "cucumber/treetop_parser/feature_parser"
+
+      verbose_log("Ruby files required:")
+      requires = @options[:require] || feature_dirs
+      libs = requires.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
+      end.flatten.uniq
+      libs.each do |lib|
+        begin
+          require lib
+          verbose_log("  * #{lib}")
+        rescue LoadError => e
+          e.message << "\nFailed to load #{lib}"
+          raise e
+        end
+      end
+      verbose_log("\n")
+    end
+
+    def feature_files
+      potential_feature_files = @paths.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.chomp('/')
+        File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
+      end.flatten.uniq
+
+      @options[:excludes].each do |exclude|
+        potential_feature_files.reject! do |path|
+          path =~ /#{Regexp.escape(exclude)}/
+        end
+      end
+
+      potential_feature_files
+    end
+
+    def feature_dirs
+      feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
+    end
+
+    def load_plain_text_features(features)
+      parser = TreetopParser::FeatureParser.new
+
+      verbose_log("Features:")
+      feature_files.each do |f|
+        features << parser.parse_feature(f)
+        verbose_log("  * #{f}")
+      end
+      verbose_log("\n"*2)
+    end
+
+    def build_formatter_broadcaster(step_mother)
+      formatter_broadcaster = Broadcaster.new
+      @options[:formats].each do |format, output_list|
+        output_broadcaster = build_output_broadcaster(output_list)
+        case format
+        when 'pretty'
+          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
+        when 'progress'
+          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
+        when 'profile'
+          formatter_broadcaster.register(Formatters::ProfileFormatter.new(output_broadcaster, step_mother))
+        when 'html'
+          formatter_broadcaster.register(Formatters::HtmlFormatter.new(output_broadcaster, step_mother))
+        when 'autotest'
+          formatter_broadcaster.register(Formatters::AutotestFormatter.new(output_broadcaster))
+        else
+          begin
+            formatter_class = Kernel.const_get(format)
+            formatter_broadcaster.register(formatter_class.new(output_broadcaster, step_mother, @options))
+          rescue NameError => e
+            @error_stream.puts "Invalid format: #{format}\n"
+            exit_with_help
+          rescue Exception => e
+            exit_with_error("Error creating formatter: #{format}\n#{e}")
+          end
+        end
+      end
+      formatter_broadcaster
+    end
+
+    def build_output_broadcaster(output_list)
+      output_broadcaster = Broadcaster.new
+      output_list.each do |output|
+        output_broadcaster.register(output)
+      end
+      output_broadcaster
+    end
+    
+  private
+
+    def verbose_log(string)
+      @out_stream.puts(string) if @options[:verbose]
+    end
+
+    def exit_with_help
+      parse_options!(%w{--help})
+    end
+
+    def exit_with_error(error_message)
+      @error_stream << error_message
+      Kernel.exit 1
+    end
+
+  end
+end
+
+extend Cucumber::StepMethods
+Cucumber::CLI.step_mother = step_mother
+Cucumber::CLI.executor = executor
+
+extend Cucumber::Tree
+Cucumber::CLI.features = features

data/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,69 @@
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+
+  module CoreExt
+    # Proc extension that allows a proc to be called in the context of any object.
+    # Also makes it possible to tack a name onto a Proc.
+    module CallIn
+      PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
+      
+      if Proc.new{}.to_s =~ PROC_PATTERN
+        def to_backtrace_line
+          "#{file_colon_line}:in `#{name}'"
+        end
+
+        def to_comment_line
+          "# #{file_colon_line}"
+        end
+
+        def file_colon_line
+          path, line = *to_s.match(PROC_PATTERN)[1..2]
+          path = File.expand_path(path)
+          pwd = Dir.pwd
+          path = path[pwd.length+1..-1]
+          "#{path}:#{line}"
+        end
+      else
+        # This Ruby implementation doesn't implement Proc#to_s correctly
+        STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
+        
+        def to_backtrace_line
+          nil
+        end
+
+        def to_comment_line
+          ""
+        end
+      end
+      
+      attr_accessor :name
+      
+      def call_in(obj, *args)
+        obj.extend(mod)
+        if self != StepMother::PENDING && args.length != arity2
+          # We have to manually raise when the block has arity -1 (no pipes)
+          raise ArityMismatchError.new("expected #{arity2} block argument(s), got #{args.length}")
+        else
+          obj.__send__(meth, *args)
+        end
+      end
+
+      def arity2
+        arity == -1 ? 0 : arity
+      end
+
+      def meth
+        @meth ||= "__cucumber_#{object_id}"
+      end
+
+      def mod
+        p = self
+        m = meth
+        @mod ||= Module.new do
+          define_method(m, &p)
+        end
+      end
+    end 
+  end
+end

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,28 @@
+class String
+  def gzub(regexp, format=nil, &proc)
+    md = match(regexp)
+    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
+    
+    s = dup
+    pos = 0
+    md.captures.each_with_index do |m, n|
+      replacement = if block_given?
+        proc.call(m)
+      else
+        format % m
+      end
+      
+      if md.offset(n+1)[0]
+        s[md.offset(n+1)[0] + pos, m.length] = replacement
+        pos += replacement.length - m.length
+      end
+    end
+    s
+  end
+
+  if ENV['CUCUMBER_NO_JCODE']
+    alias jlength length
+  else
+    require 'jcode'
+  end
+end