kbaum-cucumber 0.4.5.pre

data/lib/cucumber/cli/drb_client.rb

@@ -0,0 +1,32 @@
+require "drb/drb"
+# This code was taken from the RSpec project and slightly modified.
+
+module Cucumber
+  module Cli
+    class DRbClientError < StandardError
+    end
+    # Runs features on a DRB server, originally created with Spork compatibility in mind.
+    class DRbClient
+      DEFAULT_PORT = 8990
+
+      def self.run(args, error_stream, out_stream, port = nil)
+        port ||= ENV["CUCUMBER_DRB"] || DEFAULT_PORT
+
+        # See http://redmine.ruby-lang.org/issues/show/496 as to why we specify localhost:0
+        begin
+          DRb.start_service("druby://localhost:0")
+        rescue SocketError
+        # Ruby-1.8.7 on snow leopard doesn't like localhost:0 - but just :0
+        # seems to work just fine
+          DRb.start_service("druby://:0")
+        end
+        feature_server = DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
+        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 => e
+        raise DRbClientError, "No DRb server is running."
+      end
+    end
+  end
+end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -0,0 +1,72 @@
+require 'cucumber/formatter/pretty'
+require 'cucumber/parser/natural_language'
+require 'cucumber/formatter/unicode'
+
+module Cucumber
+  module Cli
+    class LanguageHelpFormatter < Formatter::Pretty
+      INCOMPLETE = %{
+The Cucumber grammar has evolved since this translation was written.
+Please help us complete the translation by translating the missing words in
+
+#{Cucumber::LANGUAGE_FILE}
+
+Then contribute back to the Cucumber project. Details here:
+http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
+}
+      
+      class << self
+        def list_languages(io)
+          raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
+            [
+              lang, 
+              Cucumber::LANGUAGES[lang]['name'], 
+              Cucumber::LANGUAGES[lang]['native']
+            ]
+          end
+
+          print_table io, raw, :check_lang => true
+        end
+
+        def list_keywords(io, lang)
+          language = Parser::NaturalLanguage.get(nil, lang)
+          raw = Parser::NaturalLanguage::KEYWORD_KEYS.map do |key|
+            [key, language.keywords(key).join(" / ")]
+          end
+          
+          print_table io, raw, :incomplete => language.incomplete?
+        end
+      
+        private
+          def print_table(io, raw, options)
+            table = Ast::Table.new(raw)
+            formatter = new(nil, io, options)
+            Ast::TreeWalker.new(nil, [formatter]).visit_multiline_arg(table)
+          end
+      end
+      
+      def before_visit_multiline_arg(table)
+        if @options[:incomplete]
+          @io.puts(format_string(INCOMPLETE, :failed))
+        end
+      end
+
+      def before_visit_table_row(table_row)
+        @col = 1
+      end
+
+      def before_visit_table_cell_value(value, status)
+        if @col == 1
+          if(@options[:check_lang])
+            @incomplete = Parser::NaturalLanguage.get(nil, value).incomplete?
+          end
+          status = :comment 
+        elsif @incomplete
+          status = :undefined
+        end
+        
+        @col += 1
+      end
+    end
+  end
+end

data/lib/cucumber/cli/main.rb

@@ -0,0 +1,121 @@
+require 'optparse'
+require 'cucumber'
+require 'ostruct'
+require 'logger'
+require 'cucumber/parser'
+require 'cucumber/feature_file'
+require 'cucumber/formatter/color_io'
+require 'cucumber/cli/language_help_formatter'
+require 'cucumber/cli/configuration'
+require 'cucumber/cli/drb_client'
+require 'cucumber/ast/tags'
+
+module Cucumber
+  module Cli
+    class Main
+      FAILURE = 1
+
+      class << self
+        def step_mother
+          @step_mother ||= StepMother.new
+        end
+
+        def execute(args)
+          new(args).execute!(step_mother)
+        end
+      end
+
+      def initialize(args, out_stream = STDOUT, error_stream = STDERR)
+        @args         = args
+        @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new : out_stream
+        @error_stream = error_stream
+        @configuration = nil
+      end
+
+      def execute!(step_mother)
+        trap_interrupt
+        if configuration.drb?
+          begin
+            return DRbClient.run(@args, @error_stream, @out_stream, configuration.drb_port)
+          rescue DRbClientError => e
+            @error_stream.puts "WARNING: #{e.message} Running features locally:"
+          end
+        end
+        step_mother.options = configuration.options
+        step_mother.log = configuration.log
+
+        step_mother.load_code_files(configuration.support_to_load)
+        step_mother.after_configuration(configuration)
+        features = step_mother.load_plain_text_features(configuration.feature_files)
+        step_mother.load_code_files(configuration.step_defs_to_load)
+
+        enable_diffing
+
+        runner = configuration.build_runner(step_mother, @out_stream)
+        step_mother.visitor = runner # Needed to support World#announce
+        runner.visit_features(features)
+
+        failure = if exceeded_tag_limts?(features)
+            FAILURE
+          elsif configuration.wip?
+            step_mother.scenarios(:passed).any?
+          else
+            step_mother.scenarios(:failed).any? ||
+            (configuration.strict? && (step_mother.steps(:undefined).any? || step_mother.steps(:pending).any?))
+          end
+      rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
+        @error_stream.puts e.message
+        true
+      end
+
+      def exceeded_tag_limts?(features)
+        exceeded = false
+        configuration.options[:tag_names].each do |tag_list|
+          tag_list.each do |tag_name, limit|
+            if !Ast::Tags.exclude_tag?(tag_name) && limit
+              tag_count = features.tag_count(tag_name)
+              if tag_count > limit.to_i
+                exceeded = true
+              end
+            end
+          end
+        end
+        exceeded
+      end
+
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = Configuration.new(@out_stream, @error_stream)
+        @configuration.parse!(@args)
+        @configuration
+      end
+
+      private
+
+      def enable_diffing
+        if configuration.diff_enabled?
+          begin
+            require 'spec/expectations'
+            begin
+              require 'spec/runner/differs/default' # RSpec >=1.2.4
+            rescue ::LoadError
+              require 'spec/expectations/differs/default' # RSpec <=1.2.3
+            end
+            options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
+            ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
+          rescue ::LoadError => ignore
+          end
+        end
+      end
+
+      def trap_interrupt
+        trap('INT') do
+          exit!(1) if Cucumber.wants_to_quit
+          Cucumber.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/cli/options.rb

@@ -0,0 +1,404 @@
+require 'cucumber/cli/profile_loader'
+module Cucumber
+  module Cli
+
+    class Options
+      BUILTIN_FORMATS = {
+        'html'      => ['Cucumber::Formatter::Html',     'Generates a nice looking HTML report.'],
+        'pretty'    => ['Cucumber::Formatter::Pretty',   'Prints the feature as is - in colours.'],
+        'pdf'       => ['Cucumber::Formatter::Pdf',      "Generates a PDF report. You need to have the\n" +
+                                                         "#{' ' * 51}prawn gem installed. Will pick up logo from\n" +
+                                                         "#{' ' * 51}features/support/logo.png or\n" +
+                                                         "#{' ' * 51}features/support/logo.jpg if present."],
+        'progress'  => ['Cucumber::Formatter::Progress', 'Prints one character per scenario.'],
+        'rerun'     => ['Cucumber::Formatter::Rerun',    'Prints failing files with line numbers.'],
+        'usage'     => ['Cucumber::Formatter::Usage',    "Prints where step definitions are used.\n" +
+                                                         "#{' ' * 51}The slowest step definitions (with duration) are\n" +
+                                                         "#{' ' * 51}listed first. If --dry-run is used the duration\n" +
+                                                         "#{' ' * 51}is not shown, and step definitions are sorted by\n" +
+                                                         "#{' ' * 51}filename instead."],
+        'stepdefs'  => ['Cucumber::Formatter::Stepdefs', "Prints All step definitions with their locations. Same as\n" +
+                                                         "#{' ' * 51}the usage formatter, except that steps are not printed."],
+        'junit'     => ['Cucumber::Formatter::Junit',    'Generates a report similar to Ant+JUnit.'],
+        'tag_cloud' => ['Cucumber::Formatter::TagCloud', 'Prints a tag cloud of tag usage.'],
+        'debug'     => ['Cucumber::Formatter::Debug',    'For developing formatters - prints the calls made to the listeners.']
+      }
+      max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
+      FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
+        "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
+      end) + ["Use --format rerun --out features.txt to write out failing",
+        "features. You can rerun them with cucumber @features.txt.",
+        "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."
+      ]
+      DRB_FLAG = '--drb'
+      PROFILE_SHORT_FLAG = '-p'
+      NO_PROFILE_SHORT_FLAG = '-P'
+      PROFILE_LONG_FLAG = '--profile'
+      NO_PROFILE_LONG_FLAG = '--no-profile'
+
+
+      def self.parse(args, out_stream, error_stream, options = {})
+        new(out_stream, error_stream, options).parse!(args)
+      end
+
+      def initialize(out_stream = STDOUT, error_stream = STDERR, options = {})
+        @out_stream   = out_stream
+        @error_stream = error_stream
+
+        @default_profile = options[:default_profile]
+        @skip_profile_information = options[:skip_profile_information]
+        @profiles = []
+        @overridden_paths = []
+        @options = default_options
+        
+        @quiet = @disable_profile_loading = nil
+      end
+
+      def [](key)
+        @options[key]
+      end
+
+      def []=(key, value)
+        @options[key] = value
+      end
+
+      def expanded_args_without_drb
+        return @expanded_args_without_drb  if @expanded_args_without_drb
+        @expanded_args_without_drb = (
+          previous_flag_was_profile = false
+          @expanded_args.reject do |arg|
+            if previous_flag_was_profile
+              previous_flag_was_profile = false
+              next true
+            end
+            if [PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG].include?(arg)
+              previous_flag_was_profile = true
+              next true
+            end
+            arg == DRB_FLAG || @overridden_paths.include?(arg)
+          end
+        )
+
+        @expanded_args_without_drb.push("--no-profile") unless @expanded_args_without_drb.include?(NO_PROFILE_LONG_FLAG) || @expanded_args_without_drb.include?(NO_PROFILE_SHORT_FLAG)
+        @expanded_args_without_drb
+      end
+
+      def parse!(args)
+        @args = args
+        @expanded_args = @args.dup
+
+        @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 @features.txt (See --format rerun)",
+            "cucumber 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] << v
+          end
+          opts.on("-l LANG", "--language LANG (DEPRECATED)",
+            "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
+              warn("\nWARNING: --language is deprecated and will be removed in version 0.5.\nSee http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages")
+              @options[:lang] = v
+            end
+          end
+          opts.on("-f FORMAT", "--format FORMAT",
+            "How to format features (Default: pretty). Available formats:",
+            *FORMAT_HELP) do |v|
+            @options[:formats] << [v, @out_stream]
+          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. Example: --tags @dev\n",
+            "You can select tags using logical AND or logical OR:",
+            "To execute anything that is tagged with both @dev AND @prod\n",
+            "Example: --tags @dev,@prod",
+            "To execute anything that is tagged with @dev OR @prod\n",
+            "Example: --tags @dev --tags @prod\n",
+            "Negative tags: Prefix tags with ~ to exclude features or scenarios",
+            "having that tag. Example: --tags ~@slow\n",
+            "Limit WIP: Positive tags can be given a threshold to limit the",
+            "number of occurrences. Example: --tags @qa:3 will fail if there",
+            "are more than 3 occurrences of the @qa tag.") do |v|
+            tag_names = parse_tags(v)
+            @options[:tag_names] << tag_names
+          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 which can be defined as",
+              "strings or arrays.  When a 'default' profile is defined and no profile",
+              "is specified it is always used. (Unless disabled, see -P below.)",
+              "When feature files are defined in a profile and on the command line",
+              "then only the ones from the command line are used.") do |v|
+            @profiles << v
+          end
+          opts.on(NO_PROFILE_SHORT_FLAG, NO_PROFILE_LONG_FLAG,
+            "Disables all profile laoding to avoid using the 'default' profile.") do |v|
+            @disable_profile_loading = true
+          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 --no-snippets.") do
+            @options[:dry_run] = true
+            @options[:snippets] = false
+          end
+          opts.on("-a", "--autoformat DIR",
+            "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
+            Cucumber.use_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
+            @options[:drb] = true
+          end
+          opts.on("--port PORT", "Specify DRb port.  Ignored without --drb") do |port|
+            @options[:drb_port] = port
+          end
+          opts.on_tail("--version", "Show version.") do
+            @out_stream.puts Cucumber::VERSION
+            Kernel.exit(0)
+          end
+          opts.on_tail("-h", "--help", "You're looking at it.") do
+            @out_stream.puts opts.help
+            Kernel.exit(0)
+          end
+        end.parse!
+
+        if @quiet
+          @options[:snippets] = @options[:source] = false
+        else
+          @options[:snippets] = true if @options[:snippets].nil?
+          @options[:source]   = true if @options[:source].nil?
+        end
+
+        extract_environment_variables
+        @options[:paths] = @args.dup #whatver is left over
+
+        merge_profiles
+        print_profile_information
+
+        self
+      end
+
+    protected
+
+      attr_reader :options, :profiles, :expanded_args
+      protected :options, :profiles, :expanded_args
+
+    private
+
+    def non_stdout_formats
+      @options[:formats].select {|format, output| output != @out_stream }
+    end
+
+    def stdout_formats
+      @options[:formats].select {|format, output| output == @out_stream }
+    end
+
+     def extract_environment_variables
+        @args.delete_if do |arg|
+          if arg =~ /^(\w+)=(.*)$/
+            @options[:env_vars][$1] = $2
+            true
+          end
+        end
+      end
+
+      def parse_tags(tag_string)
+        tag_names = Ast::Tags.parse_tags(tag_string)
+        parse_tag_limits(tag_names)
+      end
+
+      def parse_tag_limits(tag_names)
+        tag_names.inject({}) do |dict, tag|
+          tag, limit = tag.split(':')
+          dict[tag] = limit.nil? ? limit : limit.to_i
+          dict
+        end
+      end
+
+      def disable_profile_loading?
+        @disable_profile_loading
+      end
+
+      def merge_profiles
+        if @disable_profile_loading
+          @out_stream.puts "Disabling profiles..."
+          return
+        end
+
+        @profiles << @default_profile if default_profile_should_be_used?
+
+        @profiles.each do |profile|
+          profile_args = profile_loader.args_from(profile)
+          reverse_merge(
+            Options.parse(profile_args, @out_stream, @error_stream, :skip_profile_information  => true)
+          )
+        end
+
+      end
+
+      def default_profile_should_be_used?
+        @profiles.empty? &&
+          profile_loader.cucumber_yml_defined? &&
+          profile_loader.has_profile?(@default_profile)
+      end
+
+      def profile_loader
+        @profile_loader ||= ProfileLoader.new
+      end
+
+      def reverse_merge(other_options)
+        @options = other_options.options.merge(@options)
+        @options[:require] += other_options[:require]
+        @options[:excludes] += other_options[:excludes]
+        @options[:name_regexps] += other_options[:name_regexps]
+        @options[:tag_names] += other_options[:tag_names]
+        @options[:env_vars] = other_options[:env_vars].merge(@options[:env_vars])
+        if @options[:paths].empty?
+          @options[:paths] = other_options[:paths]
+        else
+          @overridden_paths += (other_options[:paths] - @options[:paths])
+        end
+        @options[:source] &= other_options[:source]
+        @options[:snippets] &= other_options[:snippets]
+
+        @profiles += other_options.profiles
+        @expanded_args += other_options.expanded_args
+
+        if @options[:formats].empty?
+          @options[:formats] = other_options[:formats]
+        else
+          @options[:formats] += other_options[:formats]
+          @options[:formats] = stdout_formats[0..0] + non_stdout_formats
+        end
+
+        self
+      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(0)
+      end
+
+      def list_languages_and_exit
+        LanguageHelpFormatter.list_languages(@out_stream)
+        Kernel.exit(0)
+      end
+
+      def print_profile_information
+        return if @skip_profile_information || @profiles.empty?
+        profiles_sentence = ''
+        profiles_sentence = @profiles.size == 1 ? @profiles.first :
+          "#{@profiles[0...-1].join(', ')} and #{@profiles.last}"
+
+        @out_stream.puts "Using the #{profiles_sentence} profile#{'s' if @profiles.size> 1}..."
+      end
+
+      def default_options
+        {
+          :strict       => false,
+          :require      => [],
+          :dry_run      => false,
+          :formats      => [],
+          :excludes     => [],
+          :tag_names    => [],
+          :name_regexps => [],
+          :env_vars     => {},
+          :diff_enabled => true
+        }
+      end
+    end
+
+  end
+end