square-cucumber 0.3.12.2 → 0.3.93.1

data/lib/cucumber/ast/tags.rb

@@ -16,6 +16,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         @tag_names.each do |tag_name|
           visitor.visit_tag_name(tag_name)
         end

data/lib/cucumber/ast/visitor.rb

@@ -64,6 +64,7 @@ module Cucumber
       end
 
       def visit_outline_table(outline_table)
+        @table = outline_table
         outline_table.accept(self)
       end
 
@@ -105,7 +106,7 @@ module Cucumber
         table_cell.accept(self)
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
       end
 
       def announce(announcement)

data/lib/cucumber/cli/configuration.rb

@@ -1,198 +1,29 @@
+require 'cucumber/cli/options'
+
 module Cucumber
   module Cli
     class YmlLoadError < StandardError; end
+    class ProfilesNotDefinedError < YmlLoadError; end
+    class ProfileNotFound < StandardError; end
 
     class Configuration
-      BUILTIN_FORMATS = {
-        'html'      => 'Cucumber::Formatter::Html',
-        'pretty'    => 'Cucumber::Formatter::Pretty',
-        'profile'   => 'Cucumber::Formatter::Profile',
-        'progress'  => 'Cucumber::Formatter::Progress',
-        'rerun'     => 'Cucumber::Formatter::Rerun',
-        'usage'     => 'Cucumber::Formatter::Usage',
-        'junit'     => 'Cucumber::Formatter::Junit',
-        'tag_cloud' => 'Cucumber::Formatter::TagCloud',
-        'steps'     => 'Cucumber::Formatter::Steps'
-      }
-      DRB_FLAG = '--drb'
-      PROFILE_SHORT_FLAG = '-p'
-      PROFILE_LONG_FLAG = '--profile'
-
-      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
+        @options = Options.new(@out_stream, @error_stream, :default_profile => 'default')
       end
 
       def parse!(args)
-        args.concat(%w{--profile default}) if args.empty?
         @args = args
-        expand_profiles_into_args
-        return if parse_drb
+        @options.parse!(args)
+        raise("You can't use both --strict and --wip") if strict? && wip?
 
-        @args.each do |arg|
-          if arg =~ /^(\w+)=(.*)$/
-            ENV[$1] = $2
-            @args.delete(arg)
-          end
-        end
-
-        @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 -s -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_and_exit
-            elsif args==['help']
-              list_keywords_and_exit(v)
-            else
-              @options[:lang] = v
-            end
-          end
-          opts.on("-f FORMAT", "--format FORMAT",
-            "How to format features (Default: pretty)",
-            "Available formats: #{BUILTIN_FORMATS.keys.sort.join(", ")}",
-            "FORMAT can also be the fully qualified class name of",
-            "your own custom formatter. If the class isn't loaded,",
-            "Cucumber will attempt to require a file with a relative",
-            "file name that is the underscore name of the class name.",
-            "Example: --format Foo::BarZap -> Cucumber will look for",
-            "foo/bar_zap.rb. You can place the file with this relative",
-            "path underneath your features/support directory or anywhere",
-            "on Ruby's LOAD_PATH, for example in a Ruby gem.") do |v|
-            @options[:formats] << [v, @out_stream]
-            @active_format = v
-          end
-          opts.on("-o", "--out [FILE|DIR]",
-            "Write output to a file/directory instead of STDOUT. This option",
-            "applies to the previously specified --format, or the",
-            "default format if no format is specified. Check the specific",
-            "formatter's docs to see whether to pass a file or a dir.") do |v|
-            @options[:formats] << ['pretty', nil] if @options[:formats].empty?
-            @options[:formats][-1][1] = 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. Prefix tags with ~ to",
-            "exclude features or scenarios having that tag. Tags can be specified",
-            "with or without the @ prefix.") do |v|
-            @options[:include_tags], @options[:exclude_tags] = *parse_tags(v)
-          end
-          opts.on("-n NAME", "--name NAME",
-            "Only execute the feature elements which match part of the given name.",
-            "If this option is given more than once, it will match against all the",
-            "given names.") do |v|
-            @options[:name_regexps] << /#{v}/
-          end
-          opts.on("-e", "--exclude PATTERN", "Don't run feature files or require ruby files matching PATTERN") do |v|
-            @options[:excludes] << Regexp.new(v)
-          end
-          opts.on(PROFILE_SHORT_FLAG, "#{PROFILE_LONG_FLAG} PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
-            # Processing of this is done previsouly so that the DRb flag can be detected within profiles.
-          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.",
-            "This also omits the loading of your support/env.rb file if it exists.",
-            "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("-s", "--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("-S", "--strict", "Fail if there are any undefined steps.") do
-            @options[:strict] = true
-          end
-          opts.on("-w", "--wip", "Fail if there are any passing scenarios.") do
-            @options[:wip] = 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("-x", "--expand", "Expand Scenario Outline Tables in output.") do
-            @options[:expand] = true
-          end
-          opts.on("--no-diff", "Disable diff output on failing expectations.") do
-            @options[:diff_enabled] = false
-          end
-          opts.on(DRB_FLAG, "Run features against a DRb server. (i.e. with the spork gem)") do
-            # Processing of this is done previsouly in order to short circuit args from being lost.
-          end
-          opts.on_tail("--version", "Show version.") do
-            @out_stream.puts VERSION::STRING
-            Kernel.exit
-          end
-          opts.on_tail("-h", "--help", "You're looking at it.") do
-            @out_stream.puts opts.help
-            Kernel.exit
-          end
-        end.parse!
+        return @args.replace(@options.expanded_args_without_drb) if drb?
 
+        set_environment_variables
         arrange_formats
-
-        @options[:snippets] = true if !@quiet && @options[:snippets].nil?
-        @options[:source]   = true if !@quiet && @options[:source].nil?
-
-        raise("You can't use both --strict and --wip") if @options[:strict] && @options[:wip]
-
-        # Whatever is left after option parsing is the FILE arguments
-        @paths += @args
       end
 
       def verbose?
@@ -216,18 +47,11 @@ module Cucumber
       end
 
       def drb?
-        @drb
+        @options[:drb]
       end
 
-      def parse_tags(tag_string)
-        tag_names = tag_string.split(",")
-        excludes, includes = tag_names.partition{|tag| tag =~ /^~/}
-        excludes = excludes.map{|tag| tag[1..-1]}
-
-        # Strip @
-        includes = includes.map{|tag| Ast::Tags.strip_prefix(tag)}
-        excludes = excludes.map{|tag| Ast::Tags.strip_prefix(tag)}
-        [includes, excludes]
+      def paths
+        @options[:paths]
       end
 
       def build_formatter_broadcaster(step_mother)
@@ -260,15 +84,15 @@ module Cucumber
       end
 
       def formatter_class(format)
-        if(builtin = BUILTIN_FORMATS[format])
-          constantize(builtin)
+        if(builtin = Options::BUILTIN_FORMATS[format])
+          constantize(builtin[0])
         else
           constantize(format)
         end
       end
 
       def files_to_require
-        requires = @options[:require] || feature_dirs
+        requires = @options[:require].empty? ? require_dirs : @options[:require]
         files = requires.map do |path|
           path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
           path = path.gsub(/\/$/, '') # Strip trailing slash.
@@ -283,7 +107,7 @@ module Cucumber
       end
 
       def feature_files
-        potential_feature_files = @paths.map do |path|
+        potential_feature_files = @options[: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
@@ -292,7 +116,13 @@ module Cucumber
         potential_feature_files
       end
 
-    protected
+    private
+
+      def set_environment_variables
+        @options[:env_vars].each do |var, value|
+          ENV[var] = value
+        end
+      end
 
       def arrange_formats
         @options[:formats] << ['pretty', @out_stream] if @options[:formats].empty?
@@ -307,7 +137,11 @@ module Cucumber
       end
 
       def feature_dirs
-        @paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+        paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+      end
+
+      def require_dirs
+        feature_dirs + Dir['vendor/{gems,plugins}/*/cucumber']
       end
 
       def constantize(camel_cased_word)
@@ -335,90 +169,6 @@ module Cucumber
           downcase
       end
 
-      def expand_profiles_into_args
-        while (profile_index = @args.index(PROFILE_SHORT_FLAG) || @args.index(PROFILE_LONG_FLAG)) do
-          @args.delete_at(profile_index)
-          @args[profile_index] = args_from_profile(@args[profile_index])
-          @args.flatten!
-        end
-      end
-
-      def args_from_profile(profile)
-        unless cucumber_yml.has_key?(profile)
-          raise(<<-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 "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*$/
-            args_from_yml = args_from_yml.split(' ')
-          when Array
-            raise "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 "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 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 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 'yaml'
-        begin
-          @cucumber_yml = YAML::load(IO.read('cucumber.yml'))
-        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
-
-      # TODO: Move to Language
-      def list_keywords_and_exit(lang)
-        unless Cucumber::LANGUAGES[lang]
-          raise("No language with key #{lang}")
-        end
-        LanguageHelpFormatter.list_keywords(@out_stream, lang)
-        Kernel.exit
-      end
-
-      def list_languages_and_exit
-        LanguageHelpFormatter.list_languages(@out_stream)
-        Kernel.exit
-      end
-
-      def parse_drb
-        @drb = @args.delete(DRB_FLAG) ? true : false
-      end
-
-      def default_options
-        {
-          :strict       => false,
-          :require      => nil,
-          :lang         => nil,
-          :dry_run      => false,
-          :formats      => [],
-          :excludes     => [],
-          :include_tags => [],
-          :exclude_tags => [],
-          :name_regexps => [],
-          :diff_enabled => true
-        }
-      end
     end
 
   end

data/lib/cucumber/cli/drb_client.rb

@@ -11,7 +11,9 @@ module Cucumber
         # See http://redmine.ruby-lang.org/issues/show/496 as to why we specify localhost:0
         DRb.start_service("druby://localhost:0")
         feature_server = DRbObject.new_with_uri("druby://127.0.0.1:8990")
-        feature_server.run(args, error_stream, out_stream)
+        cloned_args = [] # I have no idea why this is needed, but if the regular args are sent then DRb magically transforms it into a DRb object - not an array
+        args.each { |arg| cloned_args << arg }
+        feature_server.run(cloned_args, error_stream, out_stream)
       rescue DRb::DRbConnError
         raise DRbClientError, "No DRb server is running."
       end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -1,4 +1,5 @@
 require 'cucumber/formatter/pretty'
+require 'cucumber/parser/i18n/language'
 
 module Cucumber
   module Cli
@@ -18,15 +19,16 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
           [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:check_lang=>true}, '').visit_multiline_arg(table)
+        new(nil, io, {:check_lang=>true}).visit_multiline_arg(table)
       end
 
       def self.list_keywords(io, lang)
-        raw = Cucumber::KEYWORD_KEYS.map do |key|
-          [key, Cucumber::LANGUAGES[lang][key]]
+        language = Parser::I18n::Language[lang]
+        raw = Parser::I18n::Language::KEYWORD_KEYS.map do |key|
+          [key, language.keywords(key)]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table)
+        new(nil, io, {:incomplete => language.incomplete?}).visit_multiline_arg(table)
       end
 
       def visit_multiline_arg(table)
@@ -41,10 +43,10 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         super
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
         if @col == 1
           if(@options[:check_lang])
-            @incomplete = Cucumber.language_incomplete?(value)
+            @incomplete = Parser::I18n::Language[value].incomplete?
           end
           status = :comment 
         elsif @incomplete
@@ -52,7 +54,7 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         end
         
         @col += 1
-        super(value, width, status)
+        super(value, status)
       end
     end
   end