pezra-cucumber 0.3.94.1

data/lib/cucumber/ast/tags.rb

@@ -0,0 +1,42 @@
+module Cucumber
+  module Ast
+    # Holds the names of tags parsed from a feature file:
+    #
+    #   @invoice @release_2
+    #
+    # This gets stored internally as <tt>["invoice", "release_2"]</tt>
+    #
+    class Tags
+      def self.strip_prefix(tag_name)
+        tag_name =~ /^@(.*)/ ? $1 : tag_name
+      end
+
+      def initialize(line, tag_names)
+        @line, @tag_names = line, tag_names
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        @tag_names.each do |tag_name|
+          visitor.visit_tag_name(tag_name)
+        end
+      end
+
+      def accept_hook?(hook)
+        hook.matches_tag_names?(@tag_names)
+      end
+
+      def count(tag)
+        if @tag_names.respond_to?(:count)
+          @tag_names.count(tag) # 1.9
+        else
+          @tag_names.select{|t| t == tag}.length  # 1.8
+        end
+      end
+
+      def to_sexp
+        @tag_names.map{|tag_name| [:tag, tag_name]}
+      end
+    end
+  end
+end

data/lib/cucumber/ast/visitor.rb

@@ -0,0 +1,117 @@
+module Cucumber
+  module Ast
+    # A dumb visitor that implements the whole Visitor API and just walks the tree.
+    class Visitor
+      attr_accessor :options
+      attr_reader :step_mother
+
+      def initialize(step_mother)
+        @options = {}
+        @step_mother = step_mother
+      end
+
+      def matches_scenario_names?(node)
+        scenario_name_regexps = options[:name_regexps] || []
+        scenario_name_regexps.empty? || node.matches_scenario_names?(scenario_name_regexps)
+      end
+
+      def visit_features(features)
+        features.accept(self)
+      end
+
+      def visit_feature(feature)
+        feature.accept(self)
+      end
+
+      def visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+      end
+
+      def visit_tags(tags)
+        tags.accept(self)
+      end
+
+      def visit_tag_name(tag_name)
+      end
+
+      def visit_feature_name(name)
+      end
+
+      # +feature_element+ is either Scenario or ScenarioOutline
+      def visit_feature_element(feature_element)
+        feature_element.accept(self)
+      end
+
+      def visit_background(background)
+        background.accept(self)
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        examples_array.accept(self)
+      end
+
+      def visit_examples(examples)
+        examples.accept(self)
+      end
+
+      def visit_examples_name(keyword, name)
+      end
+
+      def visit_outline_table(outline_table)
+        @table = outline_table
+        outline_table.accept(self)
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_steps(steps)
+        steps.accept(self)
+      end
+
+      def visit_step(step)
+        step.accept(self)
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        visit_step_name(keyword, step_match, status, source_indent, background)
+        visit_multiline_arg(multiline_arg) if multiline_arg
+        visit_exception(exception, status) if exception
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background) #:nodoc:
+      end
+
+      def visit_multiline_arg(multiline_arg) #:nodoc:
+        multiline_arg.accept(self)
+      end
+
+      def visit_exception(exception, status) #:nodoc:
+      end
+
+      def visit_py_string(string)
+      end
+
+      def visit_table_row(table_row)
+        table_row.accept(self)
+      end
+
+      def visit_table_cell(table_cell)
+        table_cell.accept(self)
+      end
+
+      def visit_table_cell_value(value, status)
+      end
+
+      def announce(announcement)
+      end
+
+    end
+  end
+end

data/lib/cucumber/broadcaster.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  class Broadcaster
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.map do |receiver|
+        receiver.__send__(method_name, *args)
+      end
+    end
+  end
+end

data/lib/cucumber/cli/configuration.rb

@@ -0,0 +1,175 @@
+require 'cucumber/cli/options'
+
+module Cucumber
+  module Cli
+    class YmlLoadError < StandardError; end
+    class ProfilesNotDefinedError < YmlLoadError; end
+    class ProfileNotFound < StandardError; end
+
+    class Configuration
+      attr_reader :options
+
+      def initialize(out_stream = STDOUT, error_stream = STDERR)
+        @out_stream   = out_stream
+        @error_stream = error_stream
+        @options = Options.new(@out_stream, @error_stream, :default_profile => 'default')
+      end
+
+      def parse!(args)
+        @args = args
+        @options.parse!(args)
+        arrange_formats
+        raise("You can't use both --strict and --wip") if strict? && wip?
+
+        return @args.replace(@options.expanded_args_without_drb) if drb?
+
+        set_environment_variables
+      end
+
+      def verbose?
+        @options[:verbose]
+      end
+
+      def strict?
+        @options[:strict]
+      end
+
+      def wip?
+        @options[:wip]
+      end
+
+      def guess?
+        @options[:guess]
+      end
+
+      def diff_enabled?
+        @options[:diff_enabled]
+      end
+
+      def drb?
+        @options[:drb]
+      end
+
+      def build_formatter_broadcaster(step_mother)
+        return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
+        formatters = @options[:formats].map do |format_and_out|
+          format = format_and_out[0]
+          out    = format_and_out[1]
+          if String === out # file name
+            unless File.directory?(out)
+              out = File.open(out, Cucumber.file_mode('w'))
+              at_exit do
+                out.flush
+                out.close
+              end
+            end
+          end
+
+          begin
+            formatter_class = formatter_class(format)
+            formatter_class.new(step_mother, out, @options)
+          rescue Exception => e
+            e.message << "\nError creating formatter: #{format}"
+            raise e
+          end
+        end
+
+        broadcaster = Broadcaster.new(formatters)
+        broadcaster.options = @options
+        return broadcaster
+      end
+
+      def formatter_class(format)
+        if(builtin = Options::BUILTIN_FORMATS[format])
+          constantize(builtin[0])
+        else
+          constantize(format)
+        end
+      end
+
+      def files_to_require
+        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.
+          File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
+        end.flatten.uniq
+        sorted_files = files.sort { |a,b| (b =~ %r{/support/} || -1) <=>  (a =~ %r{/support/} || -1) }.reject{|f| f =~ /^http/}
+        env_files = sorted_files.select {|f| f =~ %r{/support/env.rb} }
+        files = env_files + sorted_files.reject {|f| f =~ %r{/support/env.rb} }
+        remove_excluded_files_from(files)
+        files.reject! {|f| f =~ %r{/support/env.rb} } if @options[:dry_run]
+        files
+      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
+        remove_excluded_files_from(potential_feature_files)
+        potential_feature_files
+      end
+
+    private
+
+      def paths
+        @options[:paths].empty? ? ['features'] : @options[:paths]
+      end
+
+      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?
+        @options[:formats] = @options[:formats].sort_by{|f| f[1] == @out_stream ? -1 : 1}
+        if @options[:formats].length > 1 && @options[:formats][1][1] == @out_stream
+          raise "All but one formatter must use --out, only one can print to STDOUT"
+        end
+      end
+
+      def remove_excluded_files_from(files)
+        files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
+      end
+
+      def feature_dirs
+        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)
+        begin
+          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
+          require underscore(camel_cased_word)
+          retry
+        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
+end

data/lib/cucumber/cli/drb_client.rb

@@ -0,0 +1,22 @@
+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
+      def self.run(args, error_stream, out_stream)
+        # 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")
+        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
+    end
+  end
+end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -0,0 +1,61 @@
+require 'cucumber/formatter/pretty'
+require 'cucumber/parser/i18n/language'
+
+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
+}
+
+      def self.list_languages(io)
+        raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
+          [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)
+      end
+
+      def self.list_keywords(io, lang)
+        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 => language.incomplete?}).visit_multiline_arg(table)
+      end
+
+      def visit_multiline_arg(table)
+        if @options[:incomplete]
+          @io.puts(format_string(INCOMPLETE, :failed))
+        end
+        super
+      end
+
+      def visit_table_row(table_row)
+        @col = 1
+        super
+      end
+
+      def visit_table_cell_value(value, status)
+        if @col == 1
+          if(@options[:check_lang])
+            @incomplete = Parser::I18n::Language[value].incomplete?
+          end
+          status = :comment 
+        elsif @incomplete
+          status = :undefined
+        end
+        
+        @col += 1
+        super(value, status)
+      end
+    end
+  end
+end

data/lib/cucumber/cli/main.rb

@@ -0,0 +1,167 @@
+require 'optparse'
+require 'cucumber'
+require 'ostruct'
+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'
+
+module Cucumber
+  module Cli
+    class Main
+      FAILURE = 1
+
+      class << self
+        def step_mother
+          @step_mother
+        end
+
+        def step_mother=(step_mother)
+          @step_mother = step_mother
+          @step_mother.extend(StepMother)
+          @step_mother.snippet_generator = StepDefinition
+        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
+      end
+
+      def execute!(step_mother)
+        trap_interrupt
+        if configuration.drb?
+          begin
+            return DRbClient.run(@args, @error_stream, @out_stream)
+          rescue DRbClientError => e
+            @error_stream.puts "WARNING: #{e.message} Running features locally:"
+          end
+        end
+        step_mother.options = configuration.options
+
+        # Feature files must be loaded before files are required.
+        # This is because i18n step methods are only aliased when
+        # features are loaded. If we swap the order, the requires
+        # will fail.
+        features = load_plain_text_features
+        require_files
+        enable_diffing
+
+        visitor = configuration.build_formatter_broadcaster(step_mother)
+        step_mother.visitor = visitor # Needed to support World#announce
+        visitor.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?)
+          end
+      rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
+        @error_stream.puts e.message
+        true
+      end
+
+      def exceeded_tag_limts?(features)
+        exceeded = false
+        configuration.options[:include_tags].each do |tag, limit|
+          unless limit.nil?
+            tag_count = features.tag_count(tag)
+            if tag_count > limit.to_i
+              exceeded = true
+            end
+          end
+        end
+        exceeded
+      end
+
+      def load_plain_text_features
+        features = Ast::Features.new
+
+        verbose_log("Features:")
+        configuration.feature_files.each do |f|
+          feature_file = FeatureFile.new(f)
+          feature = feature_file.parse(configuration.options)
+          if feature
+            features.add_feature(feature)
+            verbose_log("  * #{f}")
+          end
+        end
+        verbose_log("\n"*2)
+        features
+      end
+
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = Configuration.new(@out_stream, @error_stream)
+        @configuration.parse!(@args)
+        @configuration
+      end
+
+      def load_files
+        each_lib{|lib| load(lib)}
+      end
+
+      private
+
+      def require_files
+        each_lib{|lib| require lib}
+      end
+
+      def each_lib
+        requires = configuration.files_to_require
+        verbose_log("Ruby files required:")
+        verbose_log(requires.map{|lib| "  * #{lib}"}.join("\n"))
+        requires.each do |lib|
+          begin
+            yield lib
+          rescue LoadError => e
+            e.message << "\nFailed to load #{lib}"
+            raise e
+          end
+        end
+        verbose_log("\n")
+      end
+
+      def verbose_log(string)
+        @out_stream.puts(string) if configuration.verbose?
+      end
+
+      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_interrupted
+          $cucumber_interrupted = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
+      end
+    end
+  end
+end
+
+Cucumber::Cli::Main.step_mother = self