aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber/cli.rb

@@ -1,16 +1,22 @@
 require 'optparse'
 require 'cucumber'
 require 'ostruct'
+require 'cucumber/parser'
+require 'cucumber/formatter'
 
 module Cucumber
   class YmlLoadError < StandardError; end
 
   class CLI
     class << self
-      attr_writer :step_mother, :executor, :features
+      def step_mother=(step_mother)
+        @step_mother = step_mother
+        @step_mother.extend(StepMother)
+        @step_mother.snippet_generator = StepDefinition
+      end
 
       def execute(args)
-        parse(args).execute!(@step_mother, @executor, @features)
+        parse(args).execute!(@step_mother)
       end
 
       def parse(args)
@@ -26,17 +32,18 @@ module Cucumber
 
     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 => {},
+        :strict   => false,
+        :require  => nil,
+        :lang     => 'en',
+        :dry_run  => false,
+        :formats  => {},
         :excludes => [],
-        :scenario_names => nil
+        :tags     => [],
+        :scenario_names => []
       }
       @active_format = DEFAULT_FORMAT
     end
@@ -52,143 +59,156 @@ module Cucumber
           "cucumber examples/i18n/en/features",
           "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113", "", ""
         ].join("\n")
-        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",
+        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 loaded auto-",
+          "matically. Automatic loading is disabled when this",
+          "option is specified, and all loading becomes explicit.",
+          "Files under directories named \"support\" are always",
+          "loaded first.",
           "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("-l 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
+        opts.on("-l LANG", "--language LANG", 
+          "Specify language for features (Default: #{@options[:lang]})",
+          %{Run with "--language help" to see all languages},
+          %{Run with "--language LANG help" to list keywords for LANG}) do |v|
+          if v == 'help'
+            list_languages
+          elsif args==['help']
+            list_keywords('en', v)
+          else
+            @options[:lang] = v
+          end
         end
-        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{DEFAULT_FORMAT})",
+        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.",
+          "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
+          @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
+        opts.on("-o", "--out FILE", 
+          "Write output to a file instead of STDOUT. This option",
+          "applies to the previously specified --format, or the",
+          "default format if no format is specified.") do |v|
+          @options[:formats][@active_format] = v
+        end
+        opts.on("-t TAGS", "--tags TAGS", 
+          "Only execute the features or scenarios with the specified tags.",
+          "TAGS must be comma-separated without spaces.") do |v|
+          @options[:tags] = v.split(",")
         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
+        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] << v
         end
-        opts.on("-e", "--exclude PATTERN", "Don't run features matching a pattern") do |v|
+        opts.on("-e", "--exclude PATTERN", "Don't run feature files matching 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
+        opts.on("-c", "--[no-]color",
+          "Whether or not to use ANSI color in the output. Cucumber decides",
+          "based on your platform and the output destination if not specified.") do |v|
+          Term::ANSIColor.coloring = v
+        end
+        opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.",
+          "Implies --quiet.") do
+          @options[:dry_run] = true
+          @quiet = true
+        end
+        opts.on("-a", "--autoformat DIRECTORY", 
+          "Reformats (pretty prints) feature files and write them to DIRECTORY.",
+          "Be careful if you choose to overwrite the originals.",
+          "Implies --dry-run --formatter pretty.") do |directory|
+          @options[:autoformat] = directory
+          Term::ANSIColor.coloring = false
           @options[:dry_run] = true
+          @quiet = 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
+        opts.on("-n", "--[no-]source", 
+          "Don't show the file and line of the step definition with the steps.") do |v|
+          @options[:source] = v
         end
-        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
-          @options[:snippets] = false
+        opts.on("-i", "--[no-]snippets", "Don't show the snippets for pending steps.") do |v|
+          @options[:snippets] = v
         end
-        opts.on("-q", "--quiet", "Don't show any development aid information") do
-          @options[:snippets] = false
-          @options[:source] = false
+        opts.on("-q", "--quiet", "Alias for --no-snippets --no-source.") do
+          @quiet = true
         end
-        opts.on("-b", "--backtrace", "Show full backtrace for all errors") do
+        opts.on("-b", "--backtrace", "Show full backtrace for all errors.") do
           Exception.cucumber_full_backtrace = true
         end
-        opts.on("-v", "--verbose", "Show the files and features loaded") do
+        opts.on("--strict", "Fail if there are any undefined or pending steps.") do
+          @options[:strict] = true
+        end
+        opts.on("-v", "--verbose", "Show the files and features loaded.") do
           @options[:verbose] = true
         end
-        opts.on_tail("--version", "Show version") do
+        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
+        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
-      
+      @options[:formats]['pretty'] = @out_stream if @options[:formats].empty?
+
+      @options[:snippets] = true if !@quiet && @options[:snippets].nil?
+      @options[:source]   = true if !@quiet && @options[:source].nil?
+
       # Whatever is left after option parsing is the FILE arguments
-      args = extract_and_store_line_numbers(args)
       @paths += args
     end
 
 
-    def execute!(step_mother, executor, features)
-      Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
+    def execute!(step_mother)
       Cucumber.load_language(@options[:lang])
       require_files
       enable_diffing
-      executor.formatters = build_formatter_broadcaster(step_mother)
-      load_plain_text_features(features)
-      executor.lines_for_features = @options[:lines_for_features]
-      executor.dry_run = @options[:dry_run] if @options[:dry_run]
-      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
-      executor.visit_features(features)
-      exit 1 if executor.failed
+      features = load_plain_text_features
+
+      visitor = build_formatter_broadcaster(step_mother)
+      visitor.options = @options
+      visitor.visit_features(features)
+      exit_code = features.steps[:failed].length
+      exit_code += (features.steps[:undefined].length + features.steps[:pending].length) if @options[:strict]
+      Kernel.exit(exit_code)
     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
-   
     def cucumber_yml
       return @cucumber_yml if @cucumber_yml
       unless File.exist?('cucumber.yml')
         raise(YmlLoadError,"cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
       end
-      
+
       require 'yaml'
       begin
         @cucumber_yml = YAML::load(IO.read('cucumber.yml'))
       rescue Exception => e
         raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage.\n")
-       end
-     
+      end
+
       if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
         raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage.\n")
       end
 
       return @cucumber_yml
-    end 
+    end
 
     def parse_args_from_profile(profile)
       unless cucumber_yml.has_key?(profile)
@@ -209,7 +229,7 @@ Defined profiles in cucumber.yml:
       else
         parse_options!(args_from_yml.split(' '))
       end
-      
+
     rescue YmlLoadError => e
       exit_with_error(e.message)
     end
@@ -218,8 +238,6 @@ Defined profiles in cucumber.yml:
     # Requires files - typically step files and ruby feature files.
     def require_files
       @args.clear # Shut up RSpec
-      require "cucumber/treetop_parser/feature_#{@options[:lang]}"
-      require "cucumber/treetop_parser/feature_parser"
 
       verbose_log("Ruby files required:")
       files_to_require.each do |lib|
@@ -233,7 +251,7 @@ Defined profiles in cucumber.yml:
       end
       verbose_log("\n")
     end
-    
+
     def files_to_require
       requires = @options[:require] || feature_dirs
       files = requires.map do |path|
@@ -263,57 +281,52 @@ Defined profiles in cucumber.yml:
       feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
     end
 
-    def load_plain_text_features(features)
-      parser = TreetopParser::FeatureParser.new
+    def load_plain_text_features
+      filter = Ast::Filter.new(@options)
+      features = Ast::Features.new(filter)
+      parser = Parser::FeatureParser.new
 
       verbose_log("Features:")
       feature_files.each do |f|
-        features << parser.parse_feature(f)
+        features.add_feature(parser.parse_file(f))
         verbose_log("  * #{f}")
       end
       verbose_log("\n"*2)
+      features
     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)
+      return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
+      formatters = @options[:formats].map do |format, out|
+        if String === out # file name
+          out = File.open(out, Cucumber.file_mode('w'))
+          at_exit do
+            out.flush
+            out.close
+          end
+        end
+
         case format
         when 'pretty'
-          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
+          Formatter::Pretty.new(step_mother, out, @options)
         when 'progress'
-          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
+          Formatter::Progress.new(step_mother, out, @options)
         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))
+          Formatter::Profile.new(step_mother, out, @options)
+        when 'rerun'
+          Formatter::Rerun.new(step_mother, out, @options)
         else
           begin
             formatter_class = constantize(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
+            formatter_class.new(step_mother, out, @options)
           rescue Exception => e
-            exit_with_error("Error creating formatter: #{format}\n#{e}\n")
+            exit_with_error("Error creating formatter: #{format}", e)
           end
         end
       end
-      formatter_broadcaster
+      Broadcaster.new(formatters)
     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 constantize(camel_cased_word)
       names = camel_cased_word.split('::')
       names.shift if names.empty? || names.first.empty?
@@ -324,7 +337,7 @@ Defined profiles in cucumber.yml:
       end
       constant
     end
-    
+
     def verbose_log(string)
       @out_stream.puts(string) if @options[:verbose]
     end
@@ -333,8 +346,12 @@ Defined profiles in cucumber.yml:
       parse_options!(%w{--help})
     end
 
-    def exit_with_error(error_message)
-      @error_stream << error_message
+    def exit_with_error(error_message, e=nil)
+      @error_stream.puts(error_message)
+      if e
+        @error_stream.puts("#{e.message} (#{e.class})")
+        @error_stream.puts(e.backtrace.join("\n"))
+      end
       Kernel.exit 1
     end
 
@@ -345,12 +362,45 @@ Defined profiles in cucumber.yml:
         ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
       end
     end
+
+    def list_languages
+      raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
+        [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
+      end
+      print_table(raw)
+    end
+
+    def list_keywords(ref, lang)
+      unless Cucumber::LANGUAGES[lang]
+        exit_with_error("No language with key #{v}")
+      end
+      Cucumber.load_language(lang)
+      raw = %w{feature background scenario scenario_outline examples given when then but}.map do |key|
+        [Cucumber::LANGUAGES[ref][key], Cucumber::LANGUAGES[lang][key]]
+      end
+      print_table(raw)
+    end
+    
+    def print_table(raw)
+      table = Ast::Table.new(raw)
+      formatter = Formatter::Pretty.new(nil, @out_stream, {}, '')
+
+      def formatter.visit_table_row(table_row, status)
+        @col = 1
+        super
+      end
+
+      def formatter.visit_table_cell_value(value, width, status)
+        status = :comment if @col == 1
+        @col += 1
+        super(value, width, status)
+      end
+
+      formatter.indent = 0
+      formatter.visit_multiline_arg(table, :passed)
+      Kernel.exit
+    end
   end
 end
 
-extend Cucumber::StepMethods
-Cucumber::CLI.step_mother = step_mother
-Cucumber::CLI.executor = executor
-
-extend Cucumber::Tree
-Cucumber::CLI.features = features
+Cucumber::CLI.step_mother = self

data/lib/cucumber/core_ext/exception.rb

@@ -1,20 +1,53 @@
+# Exception extension that tweaks Exception backtraces:
+#
+# * The line of the failing .feature line is appended to the backtrace
+# * The line that calls #cucumber_instance_exec is replaced with the StepDefinition's regexp
+# * Non intersting lines are stripped out
+#
+# The result is that backtraces look like this:
+#
+#   features/step_definitions/the_step_definition.rb:in `/some step/'
+#   features/the_feature_file.feature:41:in `Given some step'
+#
+# or if the exception is raised in the tested code:
+#
+#   lib/myapp/some_file.rb:in `/some_method/'
+#   lib/myapp/some_other_file.rb:in `/some_other_method/'
+#   features/step_definitions/the_step_definition.rb:in `/some step/'
+#   features/the_feature_file.feature:41:in `Given some step'
+#
+# All backtrace munging can be turned off with the <tt>--backtrace</tt> switch
+#
 class Exception
   CUCUMBER_FILTER_PATTERNS = [
-    /vendor\/rails/, 
-    /vendor\/plugins\/cucumber/, 
-    /vendor\/plugins\/rspec/,
-    /gems\/rspec/
+    /vendor\/rails|lib\/cucumber|lib\/rspec|gems\//
   ]
 
+  INSTANCE_EXEC_OFFSET = (Cucumber::RUBY_1_9 || Cucumber::JRUBY) ? -3 : -4
+
   def self.cucumber_full_backtrace=(v)
     @@cucumber_full_backtrace = v
   end
   self.cucumber_full_backtrace = false
 
-  def cucumber_backtrace
-    return (backtrace || []) if @@cucumber_full_backtrace
-    (backtrace || []).map {|b| b.split("\n") }.flatten.reject do |line|
+  # Strips the backtrace from +line+ and down
+  def self.cucumber_strip_backtrace!(backtrace, instance_exec_invocation_line, pseudo_method)
+    return if @@cucumber_full_backtrace
+
+    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
+    if instance_exec_pos
+      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+      backtrace[replacement_line+1..-1] = nil
+
+      backtrace.compact!
+    else
+      # This happens with rails, because they screw up the backtrace
+      # before we get here (injecting erb stacktrace and such)
+    end
+
+    backtrace.reject! do |line|
       CUCUMBER_FILTER_PATTERNS.detect{|p| line =~ p}
-    end.map { |line| line.strip }
+    end
   end
 end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -0,0 +1,54 @@
+require 'cucumber/platform'
+
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+end
+
+class Object
+  def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
+    arity = block.arity
+    arity = 0 if arity == -1
+    cucumber_run_with_backtrace_filtering(pseudo_method) do
+      if check_arity && args.length != arity
+        instance_exec do
+          raise Cucumber::ArityMismatchError.new("expected #{arity} block argument(s), got #{args.length}")
+        end
+      else
+        instance_exec(*args, &block)
+      end
+    end
+  end
+  
+  def cucumber_run_with_backtrace_filtering(pseudo_method)
+    begin
+      yield
+    rescue Exception => e
+      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
+      Exception.cucumber_strip_backtrace!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+      raise e
+    end
+  end
+  
+  unless defined? instance_exec # 1.9
+    # http://eigenclass.org/hiki/bounded+space+instance_exec
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end