casecumber 1.0.2.1

data/lib/cucumber/cli/profile_loader.rb

@@ -0,0 +1,91 @@
+require 'yaml'
+
+module Cucumber
+  module Cli
+
+    class ProfileLoader
+
+      def initialize
+        @cucumber_yml = nil
+      end
+
+      def args_from(profile)
+        unless cucumber_yml.has_key?(profile)
+          raise(ProfileNotFound, <<-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] || ''
+
+        case(args_from_yml)
+          when String
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml =~ /^\s*$/
+            if(Cucumber::WINDOWS)
+              #Shellwords treats backslash as an escape character so here's a rudimentary approximation of the same code
+              args_from_yml = args_from_yml.split
+              args_from_yml = args_from_yml.collect {|x| x.gsub(/^\"(.*)\"/,'\1') }
+            else
+              require 'shellwords'
+              args_from_yml = Shellwords.shellwords(args_from_yml)
+            end
+          when Array
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was empty.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml.empty?
+          else
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was a #{args_from_yml.class}. It must be a String or Array"
+        end
+        args_from_yml
+      end
+
+      def has_profile?(profile)
+        cucumber_yml.has_key?(profile)
+      end
+
+      def cucumber_yml_defined?
+        cucumber_file && File.exist?(cucumber_file)
+      end
+
+    private
+
+      # Loads the profile, processing it through ERB and YAML, and returns it as a hash.
+      def cucumber_yml
+        return @cucumber_yml if @cucumber_yml
+        unless cucumber_yml_defined?
+          raise(ProfilesNotDefinedError,"cucumber.yml was not found.  Current directory is #{Dir.pwd}.  Please refer to cucumber's documentation 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 'erb'
+        require 'yaml'
+        begin
+          @cucumber_erb = ERB.new(IO.read(cucumber_file)).result(binding)
+        rescue Exception => e
+          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$!.inspect}")
+        end
+
+        begin
+          @cucumber_yml = YAML::load(@cucumber_erb)
+        rescue StandardError => e
+          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation 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 documentation on correct profile usage.\n")
+        end
+
+        return @cucumber_yml
+      end
+
+      # Locates cucumber.yml file. The file can end in .yml or .yaml,
+      # and be located in the current directory (eg. project root) or
+      # in a .config/ or config/ subdirectory of the current directory.
+      def cucumber_file
+        @cucumber_file ||= Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
+      end
+
+    end
+  end
+end
+

data/lib/cucumber/configuration.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  # The base class for configuring settings for a Cucumber run.
+  class Configuration
+    def self.default
+      new
+    end
+    
+    def self.parse(argument)
+      return new(argument) if argument.is_a?(Hash)
+      argument
+    end
+    
+    def initialize(user_options = {})
+      @options = default_options.merge(user_options)
+    end
+    
+    def dry_run?
+      @options[:dry_run]
+    end
+    
+    def guess?
+      @options[:guess]
+    end
+    
+    def strict?
+      @options[:strict]
+    end
+    
+    def expand? 
+      @options[:expand]
+    end
+    
+    def paths
+      @options[:paths]
+    end
+    
+    def autoload_code_paths
+      @options[:autoload_code_paths]
+    end
+  
+  private
+  
+    def default_options
+      {
+        :autoload_code_paths => ['features/support', 'features/step_definitions']
+      }
+    end
+  end
+end

data/lib/cucumber/constantize.rb

@@ -0,0 +1,34 @@
+module Cucumber
+  module Constantize #:nodoc:
+    def constantize(camel_cased_word)
+      try = 0
+      begin
+        try += 1
+        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
+      rescue NameError => e
+        require underscore(camel_cased_word)
+        if try < 2
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    # Snagged from active_support
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/cucumber/core_ext/disable_mini_and_test_unit_autorun.rb

@@ -0,0 +1,25 @@
+# Why: http://groups.google.com/group/cukes/browse_thread/thread/5682d41436e235d7
+begin
+  require 'minitest/unit'
+  class MiniTest::Unit
+    class << self
+      @@installed_at_exit = true
+    end
+
+    def run(*)
+      0
+    end
+  end
+rescue LoadError => ignore
+end
+
+# Do the same for Test::Unit
+begin
+  require 'test/unit'
+  module Test::Unit
+    def self.run?
+      true
+    end
+  end
+rescue LoadError => ignore
+end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -0,0 +1,98 @@
+require 'cucumber/platform'
+
+module Cucumber
+  # Raised if the number of a StepDefinition's Regexp match groups
+  # is different from the number of Proc arguments.
+  class ArityMismatchError < StandardError
+  end
+end
+
+class Object #:nodoc:
+  unless defined? instance_exec # 1.9
+    # http://eigenclass.org/hiki/bounded+space+instance_exec
+    module InstanceExecHelper #:nodoc:
+    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
+
+  # TODO: Move most of this stuff out to an InstanceExecutor class.
+  def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
+    cucumber_run_with_backtrace_filtering(pseudo_method) do
+      if check_arity && !cucumber_compatible_arity?(args, block)
+        instance_exec do
+          ari = cucumber_arity(block)
+          ari = ari < 0 ? (ari.abs-1).to_s+"+" : ari
+          s1 = ari == 1 ? "" : "s"
+          s2 = args.length == 1 ? "" : "s"
+          raise Cucumber::ArityMismatchError.new(
+            "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
+          )
+        end
+      else
+        instance_exec(*args, &block)
+      end
+    end
+  end
+
+  private
+
+  def cucumber_arity(block)
+    a = block.arity
+    Cucumber::RUBY_1_9 ? a : (a == -1 ? 0 : a)
+  end
+  
+  def cucumber_compatible_arity?(args, block)
+    ari = cucumber_arity(block)
+    len = args.length
+    return true if ari == len or ari < 0 && len >= ari.abs-1
+    false
+  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'"
+      replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+      raise e
+    end
+  end
+
+  INSTANCE_EXEC_OFFSET = (Cucumber::RUBY_1_9 || Cucumber::RUBY_1_8_7 || Cucumber::JRUBY) ? -3 : -4
+
+  def replace_instance_exec_invocation_line!(backtrace, instance_exec_invocation_line, pseudo_method)
+    return if Cucumber.use_full_backtrace
+
+    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
+    if instance_exec_pos
+      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+      if Cucumber::RUBY_1_8_7
+        backtrace[replacement_line] += ":in `#{pseudo_method}'" if pseudo_method
+      else
+        backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+      end
+      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
+  end
+end

data/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,34 @@
+# Proc extension to get more location info out of a proc
+class Proc #:nodoc:
+  PROC_PATTERN = /[\d\w]+@(.+):(\d+).*>/
+  PWD = Dir.pwd
+  
+  def to_comment_line
+    "# #{file_colon_line}"
+  end
+
+  def backtrace_line(name)
+    "#{file_colon_line}:in `#{name}'"
+  end
+
+  if Proc.new{}.to_s =~ PROC_PATTERN
+    def file_colon_line
+      path, line = *to_s.match(PROC_PATTERN)[1..2]
+      path = File.expand_path(path)
+      pwd = File.expand_path(PWD)
+      if path.index(pwd)
+        path = path[pwd.length+1..-1]
+      elsif path =~ /.*\/gems\/(.*\.rb)$/
+        path = $1
+      end
+      "#{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 file_colon_line
+      "UNKNOWN:-1"
+    end
+  end
+end 

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String #:nodoc:
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+end

data/lib/cucumber/errors.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  # Raised when there is no matching StepDefinition for a step.
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < StandardError
+  end
+
+  # Raised when a step matches 2 or more StepDefinitions
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
+      super(message)
+    end
+  end
+
+  class TagExcess < StandardError
+    def initialize(messages)
+      super(messages.join("\n"))
+    end
+  end
+end

data/lib/cucumber/feature_file.rb

@@ -0,0 +1,101 @@
+require 'cucumber/parser/gherkin_builder'
+require 'gherkin/formatter/filter_formatter'
+require 'gherkin/formatter/tag_count_formatter'
+require 'gherkin/parser/parser'
+
+module Cucumber
+  class FeatureFile
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/ #:nodoc:
+    DEFAULT_ENCODING = "UTF-8" #:nodoc:
+    COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
+    ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+
+    # The +uri+ argument is the location of the source. It can be a path
+    # or a path:line1:line2 etc. If +source+ is passed, +uri+ is ignored.
+    def initialize(uri, source=nil)
+      @source = source
+      _, @path, @lines = *FILE_COLON_LINE_PATTERN.match(uri)
+      if @path
+        @lines = @lines.split(':').map { |line| line.to_i }
+      else
+        @path = uri
+      end
+    end
+
+    # Parses a file and returns a Cucumber::Ast
+    # If +configuration_filters+ contains any filters, the result will
+    # be filtered.
+    def parse(configuration_filters, tag_counts)
+      filters = @lines || configuration_filters
+
+      builder             = Cucumber::Parser::GherkinBuilder.new
+      filter_formatter    = filters.empty? ? builder : Gherkin::Formatter::FilterFormatter.new(builder, filters)
+      tag_count_formatter = Gherkin::Formatter::TagCountFormatter.new(filter_formatter, tag_counts)
+      parser              = Gherkin::Parser::Parser.new(tag_count_formatter, true, "root", false)
+
+      begin
+        parser.parse(source, @path, 0)
+        ast = builder.ast
+        return nil if ast.nil? # Filter caused nothing to match
+        ast.language = parser.i18n_language
+        ast.file = @path
+        ast
+      rescue Gherkin::Lexer::LexingError, Gherkin::Parser::ParseError => e
+        e.message.insert(0, "#{@path}: ")
+        raise e
+      end
+    end
+
+    def source
+      @source ||= if @path =~ /^http/
+        require 'open-uri'
+        open(@path).read
+      else
+        begin
+          source = File.open(@path, Cucumber.file_mode('r', DEFAULT_ENCODING)).read
+          encoding = encoding_for(source)
+          if(DEFAULT_ENCODING.downcase != encoding.downcase)
+            # Read the file again - it's explicitly declaring a different encoding
+            source = File.open(@path, Cucumber.file_mode('r', encoding)).read
+            source = to_default_encoding(source, encoding)
+          end
+          source
+        rescue Errno::EACCES => e
+          e.message << "\nCouldn't open #{File.expand_path(@path)}"
+          raise e
+        rescue Errno::ENOENT => e
+          # special-case opening features, because this could be a new user:
+          if(@path == 'features')
+            STDERR.puts("You don't have a 'features' directory.  Please create one to get started.",
+                        "See http://cukes.info/ for more information.")
+            exit 1
+          end
+          raise e
+        end
+      end
+    end
+
+    private
+    
+    def encoding_for(source)
+      encoding = DEFAULT_ENCODING
+      source.each_line do |line|
+        break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
+        if ENCODING_PATTERN =~ line
+          encoding = $1
+          break
+        end
+      end
+      encoding
+    end
+
+    def to_default_encoding(string, encoding)
+      if string.respond_to?(:encode)
+        string.encode(DEFAULT_ENCODING)
+      else
+        require 'iconv'
+        Iconv.new(DEFAULT_ENCODING, encoding).iconv(string)
+      end
+    end
+  end
+end