squirrel-cucumber 0.3.12

data/lib/cucumber/cli/drb_client.rb

@@ -0,0 +1,20 @@
+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")
+        feature_server.run(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,59 @@
+require 'cucumber/formatter/pretty'
+
+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)
+        raw = Cucumber::KEYWORD_KEYS.map do |key|
+          [key, Cucumber::LANGUAGES[lang][key]]
+        end
+        table = Ast::Table.new(raw)
+        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').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, width, status)
+        if @col == 1
+          if(@options[:check_lang])
+            @incomplete = Cucumber.language_incomplete?(value)
+          end
+          status = :comment 
+        elsif @incomplete
+          status = :undefined
+        end
+        
+        @col += 1
+        super(value, width, status)
+      end
+    end
+  end
+end

data/lib/cucumber/cli/main.rb

@@ -0,0 +1,136 @@
+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
+      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)
+        if configuration.drb?
+          begin
+            return DRbClient.run(@args, @error_stream, @out_stream)
+          rescue DRbClientError => e
+            @error_stream.puts "WARNING: #{e.message} Running features locally:"
+            configuration.parse!(@args)
+          end
+        end
+        step_mother.options = configuration.options
+
+        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 configuration.wip?
+          step_mother.scenarios(:passed).any?
+        else
+          step_mother.scenarios(:failed).any? || 
+          (configuration.strict? && step_mother.steps(:undefined).any?)
+        end
+      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
+    
+    end
+  end
+end
+
+Cucumber::Cli::Main.step_mother = self

data/lib/cucumber/core_ext/exception.rb

@@ -0,0 +1,53 @@
+# 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|bin\/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

@@ -0,0 +1,67 @@
+require 'cucumber/platform'
+
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+end
+
+class Object
+  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
+          s1 = cucumber_arity(block) == 1 ? "" : "s"
+          s2 = args.length == 1 ? "" : "s"
+          raise Cucumber::ArityMismatchError.new(
+            "Your block takes #{cucumber_arity(block)} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
+          )
+        end
+      else
+        instance_exec(*args, &block)
+      end
+    end
+  end
+  
+  def cucumber_arity(block)
+    a = block.arity
+    Cucumber::RUBY_1_9 ? a : (a == -1 ? 0 : a)
+  end
+  
+  def cucumber_compatible_arity?(args, block)
+    a = cucumber_arity(block)
+    return true if (a == -1) && Cucumber::RUBY_1_9
+    a == args.length
+  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

@@ -0,0 +1,29 @@
+# Proc extension to get more location info out of a proc
+class Proc
+  PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
+  
+  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 = 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 file_colon_line
+      "UNKNOWN:-1"
+    end
+  end
+end 

data/lib/cucumber/core_ext/string.rb

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

data/lib/cucumber/feature_file.rb

@@ -0,0 +1,47 @@
+require 'cucumber/parser/i18n/language'
+require 'cucumber/filter'
+
+module Cucumber
+  class FeatureFile
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+    LANGUAGE_PATTERN = /language:\s*(.*)/
+
+    # The +uri+ argument can ba a path or a path:line1:line2 etc.
+    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 +options+ contains tags, the result will
+    # be filtered.
+    def parse(options={})
+      filter = Filter.new(@lines, options)
+      language = Parser::I18n::Language[lang || options[:lang] || 'en']
+      language.parse(source, @path, filter)
+    end
+    
+    def source
+      @source ||= if @path =~ /^http/
+        require 'open-uri'
+        open(@path).read
+      else
+        File.open(@path, Cucumber.file_mode('r')).read 
+      end
+    end
+    
+    def lang
+      line_one = source.split(/\n/)[0]
+      if line_one =~ LANGUAGE_PATTERN
+        $1.strip
+      else
+        nil
+      end
+    end
+  end
+end