aslakhellesoy-cucumber 0.1.99.15 → 0.1.99.17

data/History.txt

@@ -94,6 +94,7 @@ pure Ruby users have been enjoying for a while.
 * Run cucumber --language LANG help to see keywords for a given language. (Aslak Hellesøy)
 * Multiline arguments (tables and """ strings) are printed in the output. (Aslak Hellesøy)
 * It's no longer necessary to compile the Treetop grammar when adding a new language. Localised parser is generated at runtime. (Aslak Hellesøy)
+* New --guess option tries to guess the best step definition match instead of raising Cucumber::Multiple.  (Jake Howerton)
 
 === Removed features
 * "GivenScenario" is gone. Instead you can call Steps from Steps, or wait for "Background (#153)"

data/Manifest.txt

@@ -138,6 +138,9 @@ examples/test_unit/features/test_unit.feature
 examples/tickets/Rakefile
 examples/tickets/cucumber.yml
 examples/tickets/features/172.feature
+examples/tickets/features/177-1.feature
+examples/tickets/features/177-2.feature
+examples/tickets/features/180.feature
 examples/tickets/features/lib/eatting_machine.rb
 examples/tickets/features/lib/pantry.rb
 examples/tickets/features/scenario_outline.feature
@@ -188,6 +191,7 @@ lib/cucumber/ast/table.rb
 lib/cucumber/ast/tags.rb
 lib/cucumber/ast/visitor.rb
 lib/cucumber/broadcaster.rb
+lib/cucumber/cli/configuration.rb
 lib/cucumber/cli/language_help_formatter.rb
 lib/cucumber/cli/main.rb
 lib/cucumber/core_ext/exception.rb
@@ -240,6 +244,7 @@ spec/cucumber/ast/scenario_spec.rb
 spec/cucumber/ast/step_spec.rb
 spec/cucumber/ast/table_spec.rb
 spec/cucumber/broadcaster_spec.rb
+spec/cucumber/cli/configuration_spec.rb
 spec/cucumber/cli/main_spec.rb
 spec/cucumber/core_ext/proc_spec.rb
 spec/cucumber/core_ext/string_spec.rb

data/examples/tickets/features/177-1.feature

@@ -0,0 +1,29 @@
+Users want to know that nobody can masquerade as them.  We want to extend trust
+only to visitors who present the appropriate credentials.  Everyone wants this
+identity verification to be as secure and convenient as possible.
+
+Feature: Logging in
+  As an anonymous user with an account
+  I want to log in to my account
+  So that I can be myself
+
+  #
+  # Log in: get form
+  #
+  Scenario: Anonymous user can get a login form.
+    Given I am logged out
+    When  I go to "/login"
+    Then  I should be at the "sessions/new" page
+
+  #
+  # Log in successfully, but don't remember me
+  #
+  Scenario: Anonymous user can log in
+    Given an "activated" user named "reggie" exists
+     And  I am logged out
+    When  I go to "/login"
+     And  I fill in "Login" with "reggie"
+     And  I fill in "Password" with "password"
+     And  I press "Log in"
+    Then  I should be at the "dashboard/index" page
+

data/examples/tickets/features/177-2.feature

@@ -0,0 +1,21 @@
+Visitors may create an account, but for those who are not already in the 
+system an someone must activate the account for them before it can be used.
+
+Feature: Activating an account
+  As a registered, but not yet activated, user
+  I want to be able to activate my account
+  So that I can log in to the site
+  
+  Scenario: Not-yet-activated user can activate her account
+    Given a registered user named 'Reggie' # need to rewrite
+  #    And  the user has activation_code: 'activate_me', activated_at: nil! 
+  #    And  we try hard to remember the user's updated_at, and created_at
+  #   When  she goes to /activate/activate_me
+  #   Then  she should be redirected to 'login'
+  #   When  she follows that redirect!
+  #   Then  she should see a notice message 'Signup complete!'
+  #    And  a user with login: 'reggie' should exist
+  #    And  the user should have login: 'reggie', and email: 'registered@example.com'
+  #    And  the user's activation_code should     be nil
+  #    And  the user's activated_at    should not be nil
+  #    And  she should not be logged in

data/examples/tickets/features/180.feature

@@ -0,0 +1,7 @@
+Feature: Cucumber command line
+  In order to write better software
+  Developers should be able to execute requirements as tests
+
+  
+  Scenario: Pending Scenario at the end of a file with whitespace after it
+  

data/features/cucumber_cli.feature

@@ -28,7 +28,7 @@ Feature: Cucumber command line
         @two @three
         Scenario: Missing
           Given missing
-            Undefined step: "missing" (Cucumber::StepMother::Undefined)
+            Undefined step: "missing" (Cucumber::Undefined)
             features/sample.feature:6:in `Given missing'
 
       1 scenario

data/features/report_called_undefined_steps.feature

@@ -10,12 +10,12 @@ Feature: Cucumber command line
 
         Scenario: Call directly                                # features/call_undefined_step_from_step_def.feature:3
           Given a step definition that calls an undefined step # features/step_definitions/sample_steps.rb:19
-            Undefined step: "this does not exist" (Cucumber::StepMother::Undefined)
+            Undefined step: "this does not exist" (Cucumber::Undefined)
             ./features/step_definitions/sample_steps.rb:20:in `/^a step definition that calls an undefined step$/'
 
         Scenario: Call via another                                         # features/call_undefined_step_from_step_def.feature:6
           Given call step "a step definition that calls an undefined step" # features/step_definitions/sample_steps.rb:23
-            Undefined step: "this does not exist" (Cucumber::StepMother::Undefined)
+            Undefined step: "this does not exist" (Cucumber::Undefined)
             ./features/step_definitions/sample_steps.rb:20:in `/^a step definition that calls an undefined step$/'
 
       2 scenarios

data/features/support/env.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'spec/expectations'
 require 'fileutils'
 

data/gem_tasks/jar.rake

@@ -0,0 +1,67 @@
+# http://blog.nicksieger.com/articles/2009/01/10/jruby-1-1-6-gems-in-a-jar
+
+USE_JRUBY_VERSION    = '1.1.6'
+USE_JBEHAVE_VERSION  = '2.1'
+USE_JUNIT_VERSION    = '4.5'
+USE_HAMCREST_VERSION = '1.1'
+CUCUMBER_VERSIONED   = "cucumber-#{Cucumber::VERSION::STRING}"
+
+task :jar => [
+  :clean,
+  'jar:download_jruby',
+  'jar:install_gems',
+  'jar:bundle_gems',
+  'jar:download_jars_deps',
+  'jar:unpack_jar_deps',
+  'jar:bundle_jars',
+  'jar:fix_gem_binaries',
+  'jar:test_jar'
+]
+
+namespace :jar do
+  task :download_jruby do
+    sh "wget http://dist.codehaus.org/jruby/#{USE_JRUBY_VERSION}/jruby-complete-#{USE_JRUBY_VERSION}.jar -O #{CUCUMBER_VERSIONED}.jar"
+  end
+
+  task :install_gems => :gem do
+    mkdir 'pkg/jar_gems'
+    sh "java -jar #{CUCUMBER_VERSIONED}.jar -S gem install -i ./pkg/jar_gems pkg/#{CUCUMBER_VERSIONED}.gem --no-ri --no-rdoc"
+  end
+
+  task :bundle_gems do
+    sh "jar uf #{CUCUMBER_VERSIONED}.jar -C pkg/jar_gems ."
+  end
+
+  task :download_jars_deps do
+    mkdir 'pkg/jar_deps'
+    sh "wget http://repository.codehaus.org/org/jbehave/jbehave-core/#{USE_JBEHAVE_VERSION}/jbehave-core-#{USE_JBEHAVE_VERSION}.jar -O pkg/jar_deps/jbehave-core-#{USE_JBEHAVE_VERSION}.jar"
+    sh "wget http://mirrors.ibiblio.org/pub/mirrors/maven2/junit/junit/#{USE_JUNIT_VERSION}/junit-#{USE_JUNIT_VERSION}.jar -O pkg/jar_deps/junit-#{USE_JUNIT_VERSION}.jar"
+    sh "wget http://hamcrest.googlecode.com/files/hamcrest-all-#{USE_HAMCREST_VERSION}.jar -O pkg/jar_deps/hamcrest-all-#{USE_HAMCREST_VERSION}.jar"
+  end
+
+  task :unpack_jar_deps do
+    Dir.chdir 'pkg/jar_deps' do
+      Dir['*.jar'].each do |jar|
+        sh "jar xvf #{jar}"
+        rm_rf jar
+        rm_rf 'META-INF'
+      end
+    end
+  end
+
+  task :bundle_jars do
+    sh "jar uf #{CUCUMBER_VERSIONED}.jar -C pkg/jar_deps ."
+  end
+  
+  task :fix_gem_binaries do
+    mkdir_p 'pkg/gem_binaries/META-INF/jruby.home'
+    Dir.chdir 'pkg/gem_binaries/META-INF/jruby.home' do
+      sh "jar xvf ../../../../#{CUCUMBER_VERSIONED}.jar bin"
+    end
+    sh "jar uf #{CUCUMBER_VERSIONED}.jar -C pkg/gem_binaries ."
+  end
+
+  task :test_jar do
+    sh "java -cp examples/jbehave/target/classes -jar #{CUCUMBER_VERSIONED}.jar -S cucumber examples/jbehave/features"
+  end
+end

data/lib/cucumber.rb

@@ -3,7 +3,6 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 require 'yaml'
 require 'cucumber/platform'
-require 'rubygems'
 require 'cucumber/parser'
 require 'cucumber/version'
 require 'cucumber/step_mother'

data/lib/cucumber/ast/step.rb

@@ -104,14 +104,14 @@ module Cucumber
             else
               @status = :skipped
             end
-          rescue StepMother::Undefined => exception
+          rescue Undefined => exception
             if visitor.options[:strict]
               exception.set_backtrace([])
               failed(exception)
             else
               @status = :undefined
             end
-          rescue StepMother::Pending => exception
+          rescue Pending => exception
             visitor.options[:strict] ? failed(exception) : @status = :pending
           rescue Exception => exception
             failed(exception)

data/lib/cucumber/cli/configuration.rb

@@ -0,0 +1,336 @@
+module Cucumber
+  module Cli
+    class YmlLoadError < StandardError; end
+  
+    class Configuration
+      FORMATS = %w{pretty profile progress rerun}
+      DEFAULT_FORMAT = 'pretty'
+    
+      attr_reader :paths
+      attr_reader :options
+    
+      def initialize(out_stream = STDOUT, error_stream = STDERR)
+        @out_stream   = out_stream
+        @error_stream = error_stream
+      
+        @paths          = []
+        @options        = default_options
+        @active_format  = DEFAULT_FORMAT
+      end
+    
+      def parse!(args)
+        @args = args
+        return parse_args_from_profile('default') if @args.empty?
+        @args.extend(::OptionParser::Arguable)
+      
+        @args.options do |opts|
+          opts.banner = ["Usage: cucumber [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]+", "",
+            "Examples:",
+            "cucumber examples/i18n/en/features",
+            "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113",
+            "cucumber -n -i http://rubyurl.com/eeCl", "", "",
+          ].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 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("-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(v)
+            else
+              @options[:lang] = v
+            end
+          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] = @out_stream
+            @active_format = v
+          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("-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 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("-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("-m", "--no-multiline", 
+            "Don't print multiline strings and tables under steps.") do
+            @options[:no_multiline] = true
+          end
+          opts.on("-n", "--no-source", 
+            "Don't print the file and line of the step definition with the steps.") do
+            @options[:source] = false
+          end
+          opts.on("-i", "--no-snippets", "Don't print snippets for pending steps.") do
+            @options[:snippets] = false
+          end
+          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
+            Exception.cucumber_full_backtrace = true
+          end
+          opts.on("--strict", "Fail if there are any undefined steps.") do
+            @options[:strict] = true
+          end
+          opts.on("-v", "--verbose", "Show the files and features loaded.") do
+            @options[:verbose] = true
+          end
+          opts.on("-g", "--guess", "Guess best match for Ambiguous steps.") do
+            @options[:guess] = 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!
+
+        @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
+        @paths += args
+      end
+    
+      def ast_filter
+        Ast::Filter.new(@options)
+      end
+    
+      def verbose?
+        @options[:verbose]
+      end
+    
+      def strict?
+        @options[:strict]
+      end
+      
+      def guess?
+        !!@options[:guess]
+      end
+    
+      def load_language
+        Cucumber.load_language(@options[:lang])
+      
+        if Cucumber.language_incomplete?
+          list_keywords(Cucumber.lang)
+        end
+      end
+    
+      def build_formatter_broadcaster(step_mother)
+        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
+        
+          begin
+            formatter_class = formatter_class(format)
+            formatter_class.new(step_mother, out, @options)
+          rescue Exception => e
+            exit_with_error("Error creating formatter: #{format}", e)
+          end
+        end
+      
+        broadcaster = Broadcaster.new(formatters)
+        broadcaster.options = @options
+        return broadcaster
+      end
+    
+      def formatter_class(format)
+        case format
+        when 'pretty'   then Formatter::Pretty
+        when 'progress' then Formatter::Progress
+        when 'profile'  then Formatter::Profile
+        when 'rerun'    then Formatter::Rerun
+        else
+          constantize(format)
+        end
+      end
+    
+      def files_to_require
+        requires = @options[:require] || feature_dirs
+        files = 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
+        files.sort { |a,b| (b =~ %r{/support/} || -1) <=>  (a =~ %r{/support/} || -1) }.reject{|f| f =~ /^http/}
+      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
+    
+    protected
+  
+      def feature_dirs
+        feature_files.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+      end
+    
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    
+      def parse_args_from_profile(profile)
+        unless cucumber_yml.has_key?(profile)
+          return(exit_with_error <<-END_OF_ERROR)
+Could not find profile: '#{profile}'
+
+Defined profiles in cucumber.yml:
+  * #{cucumber_yml.keys.join("\n  * ")}
+        END_OF_ERROR
+        end
+
+        args_from_yml = cucumber_yml[profile] || ''
+
+        if !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"
+        elsif args_from_yml =~ /^\s*$/
+          exit_with_error "The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml.\n"
+        else
+          parse!(args_from_yml.split(' '))
+        end
+
+      rescue YmlLoadError => e
+        exit_with_error(e.message)
+      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
+
+        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
+    
+      def list_keywords(lang)
+        unless Cucumber::LANGUAGES[lang]
+          exit_with_error("No language with key #{lang}")
+        end
+        LanguageHelpFormatter.list_keywords(@out_stream, lang)
+        Kernel.exit
+      end
+    
+      def list_languages
+        LanguageHelpFormatter.list_languages(@out_stream)
+        Kernel.exit
+      end
+    
+      def default_options
+        {
+          :strict   => false,
+          :require  => nil,
+          :lang     => 'en',
+          :dry_run  => false,
+          :formats  => {},
+          :excludes => [],
+          :tags     => [],
+          :scenario_names => []
+        }
+      end
+    
+      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
+    end
+  
+  end
+end