aslakhellesoy-cucumber 0.1.99.3 → 0.1.99.4

data/lib/cucumber/cli.rb

@@ -1,410 +0,0 @@
-require 'optparse'
-require 'cucumber'
-require 'ostruct'
-require 'cucumber/parser'
-require 'cucumber/formatter'
-
-module Cucumber
-  class YmlLoadError < StandardError; end
-
-  class CLI
-    class << self
-      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)
-      end
-
-      def parse(args)
-        cli = new
-        cli.parse_options!(args)
-        cli
-      end
-    end
-
-    attr_reader :options, :paths
-    FORMATS = %w{pretty profile progress rerun}
-    DEFAULT_FORMAT = 'pretty'
-
-    def initialize(out_stream = STDOUT, error_stream = STDERR)
-      @out_stream = out_stream
-
-      @error_stream = error_stream
-      @paths = []
-      @options = {
-        :strict   => false,
-        :require  => nil,
-        :lang     => 'en',
-        :dry_run  => false,
-        :formats  => {},
-        :excludes => [],
-        :tags     => [],
-        :scenario_names => []
-      }
-      @active_format = DEFAULT_FORMAT
-    end
-
-    def parse_options!(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[:LINE[:LINE]*]] | [FILES|DIRS]]", "",
-          "Examples:",
-          "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 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("-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 |v|
-          @options[:snippets] = v
-        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 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
-          @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 execute!(step_mother)
-      Cucumber.load_language(@options[:lang])
-      require_files
-      enable_diffing
-      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 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 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_options!(args_from_yml.split(' '))
-      end
-
-    rescue YmlLoadError => e
-      exit_with_error(e.message)
-    end
-
-    # Requires files - typically step files and ruby feature files.
-    def require_files
-      verbose_log("Ruby files required:")
-      files_to_require.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 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) }
-    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
-      filter = Ast::Filter.new(@options)
-      features = Ast::Features.new(filter)
-      parser = Parser::FeatureParser.new
-
-      verbose_log("Features:")
-      feature_files.each do |f|
-        features.add_feature(parser.parse_file(f))
-        verbose_log("  * #{f}")
-      end
-      verbose_log("\n"*2)
-      features
-    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
-
-        case format
-        when 'pretty'
-          Formatter::Pretty.new(step_mother, out, @options)
-        when 'progress'
-          Formatter::Progress.new(step_mother, out, @options)
-        when 'profile'
-          Formatter::Profile.new(step_mother, out, @options)
-        when 'rerun'
-          Formatter::Rerun.new(step_mother, out, @options)
-        else
-          begin
-            formatter_class = constantize(format)
-            formatter_class.new(step_mother, out, @options)
-          rescue Exception => e
-            exit_with_error("Error creating formatter: #{format}", e)
-          end
-        end
-      end
-      Broadcaster.new(formatters)
-    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 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, 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
-
-    def enable_diffing
-      if defined?(::Spec)
-        require 'spec/expectations/differs/default'
-        options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
-        ::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_lang_table(raw, {:check_lang=>true})
-    end
-
-    def list_keywords(lang)
-      unless Cucumber::LANGUAGES[lang]
-        exit_with_error("No language with key #{v}")
-      end
-      raw = Cucumber::KEYWORD_KEYS.map do |key|
-        [key, Cucumber::LANGUAGES[lang][key]]
-      end
-      print_lang_table(raw, {})
-    end
-    
-    def print_lang_table(raw, options)
-      table = Ast::Table.new(raw)
-      formatter = Formatter::Pretty.new(nil, @out_stream, options, '')
-
-      def formatter.visit_table_row(table_row, status)
-        @col = 1
-        super
-      end
-
-      def formatter.visit_table_cell_value(value, width, status)
-        if @col == 1
-          if(@options[:check_lang])
-            @incomplete = Cucumber.language_complete?(value)
-          end
-          status = :comment 
-        elsif @incomplete
-          status = :failed
-        end
-        
-        @col += 1
-        super(value, width, status)
-      end
-
-      formatter.indent = 0
-      formatter.visit_multiline_arg(table, :passed)
-      Kernel.exit
-    end
-  end
-end
-
-Cucumber::CLI.step_mother = self

data/lib/cucumber/core_ext/exception.rb

@@ -1,53 +0,0 @@
-# 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|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
-
-  # 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
-  end
-end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -1,54 +0,0 @@
-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

data/lib/cucumber/core_ext/proc.rb

@@ -1,33 +0,0 @@
-# Proc extension to get more location info out of a proc
-class Proc
-  PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
-  
-  if Proc.new{}.to_s =~ PROC_PATTERN
-    def to_backtrace_line(name)
-      "#{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
-end 

data/lib/cucumber/core_ext/string.rb

@@ -1,48 +0,0 @@
-class String
-  def indent(n)
-    if n >= 0
-      gsub(/^/, ' ' * n)
-    else
-      gsub(/^ {0,#{-n}}/, "")
-    end
-  end
-  
-  # re.source.gsub(/\([^)]*\)/, '$var')
-  # Cumulative #sub
-  def subs(re, *args)
-    args.inject(self) do |s,arg|
-      s.sub(re, arg)
-    end
-  end
-
-  # TODO: Use subs instead...
-  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)
-      elsif Proc === format
-        format.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 (Cucumber::JRUBY && Cucumber::RAILS) || Cucumber::RUBY_1_9
-    # Workaround for http://tinyurl.com/55uu3u 
-    alias jlength length
-  else
-    require 'jcode'
-  end
-end