vim-jar 0.0.3 → 0.1.0

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/ast/tree_walker.rb

@@ -0,0 +1,222 @@
+module Cucumber
+  module Ast
+    # Walks the AST, executing steps and notifying listeners
+    class TreeWalker
+      attr_accessor :configuration #:nodoc:
+      attr_reader   :step_mother #:nodoc:
+
+      def initialize(step_mother, listeners = [], configuration = Cucumber::Configuration.default)
+        @step_mother, @listeners, @configuration = step_mother, listeners, configuration
+      end
+
+      def visit_features(features)
+        broadcast(features) do
+          features.accept(self)
+        end
+      end
+
+      def visit_feature(feature)
+        broadcast(feature) do
+          feature.accept(self)
+        end
+      end
+
+      def visit_comment(comment)
+        broadcast(comment) do
+          comment.accept(self)
+        end
+      end
+
+      def visit_comment_line(comment_line)
+        broadcast(comment_line)
+      end
+
+      def visit_tags(tags)
+        broadcast(tags) do
+          tags.accept(self)
+        end
+      end
+
+      def visit_tag_name(tag_name)
+        broadcast(tag_name)
+      end
+
+      def visit_feature_name(keyword, name)
+        broadcast(keyword, name)
+      end
+
+      # +feature_element+ is either Scenario or ScenarioOutline
+      def visit_feature_element(feature_element)
+        broadcast(feature_element) do
+          feature_element.accept(self)
+        end
+      end
+
+      def visit_background(background)
+        broadcast(background) do
+          background.accept(self)
+        end
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        broadcast(examples_array) do
+          examples_array.accept(self)
+        end
+      end
+
+      def visit_examples(examples)
+        broadcast(examples) do
+          examples.accept(self)
+        end
+      end
+
+      def visit_examples_name(keyword, name)
+        broadcast(keyword, name)
+      end
+
+      def visit_outline_table(outline_table)
+        broadcast(outline_table) do
+          outline_table.accept(self)
+        end
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_steps(steps)
+        broadcast(steps) do
+          steps.accept(self)
+        end
+      end
+
+      def visit_step(step)
+        broadcast(step) do
+          step.accept(self)
+        end
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        broadcast(keyword, step_match, multiline_arg, status, exception, source_indent, background) do
+          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
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background) #:nodoc:
+        broadcast(keyword, step_match, status, source_indent, background)
+      end
+
+      def visit_multiline_arg(multiline_arg) #:nodoc:
+        broadcast(multiline_arg) do
+          multiline_arg.accept(self)
+        end
+      end
+
+      def visit_exception(exception, status) #:nodoc:
+        broadcast(exception, status)
+      end
+
+      def visit_py_string(string)
+        broadcast(string)
+      end
+
+      def visit_table_row(table_row)
+        broadcast(table_row) do
+          table_row.accept(self)
+        end
+      end
+
+      def visit_table_cell(table_cell)
+        broadcast(table_cell) do
+          table_cell.accept(self)
+        end
+      end
+
+      def visit_table_cell_value(value, status)
+        broadcast(value, status)
+      end
+
+      # Print +announcement+. This method can be called from within StepDefinitions.
+      def announce(announcement)
+        broadcast(announcement)
+      end
+
+      # Embed +file+ of +mime_type+ in the formatter. This method can be called from within StepDefinitions.
+      # For most formatters this is a no-op.
+      def embed(file, mime_type)
+        broadcast(file, mime_type)
+      end
+      
+      private
+      
+      def broadcast(*args, &block)
+        message = extract_method_name_from(caller)
+        message.gsub!('visit_', '')
+        
+        if block_given?
+          send_to_all("before_#{message}", *args)
+          yield if block_given?
+          send_to_all("after_#{message}", *args)
+        else
+          send_to_all(message, *args)
+        end
+      end
+      
+      def send_to_all(message, *args)
+        @listeners.each do |listener|
+          if listener.respond_to?(message)
+            if legacy_listener?(listener)
+              warn_legacy(listener)
+              legacy_invoke(listener, message, *args)
+            else
+              listener.__send__(message, *args)
+            end
+          end
+        end
+      end
+
+      def legacy_listener?(listener)
+        listener.respond_to?(:feature_name) && 
+        (listener.method(:feature_name) rescue false) && 
+        listener.method(:feature_name).arity == 1
+      end
+
+      def warn_legacy(listener)
+        @warned_listeners ||= []
+        unless @warned_listeners.index(listener)
+          warn("#{listener.class} is using a deprecated formatter API. Starting with Cucumber 0.7.0 the signatures\n" + 
+          "that have changed are:\n" +
+          "  feature_name(keyword, name)  # Two arguments. The keyword argument will not contain a colon.\n" +
+          "  scenario_name(keyword, name, file_colon_line, source_indent)  # The keyword argument will not contain a colon.\n" +
+          "  examples_name(keyword, name)  # The keyword argument will not contain a colon.\n"
+          )
+        end
+        @warned_listeners << listener
+      end
+
+      def legacy_invoke(listener, message, *args)
+        case message.to_sym
+        when :feature_name
+          listener.feature_name("#{args[0]}: #{args[1]}")
+        when :scenario_name, :examples_name
+          args_with_colon = args.dup
+          args_with_colon[0] += ':'
+          listener.__send__(message, *args_with_colon)
+        else
+          listener.__send__(message, *args)
+        end
+      end
+
+      def extract_method_name_from(call_stack)
+        call_stack[0].match(/in `(.*)'/).captures[0]
+      end
+      
+    end
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/ast/visitor.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  module Ast
+    class Visitor
+      DEPRECATION_WARNING = "Cucumber::Ast::Visitor is deprecated and will be removed. You no longer need to inherit from this class."
+
+      def initialize(step_mother)
+        raise(DEPRECATION_WARNING)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/ast.rb

@@ -0,0 +1,30 @@
+require 'cucumber/ast/comment'
+require 'cucumber/ast/features'
+require 'cucumber/ast/feature'
+require 'cucumber/ast/background'
+require 'cucumber/ast/scenario'
+require 'cucumber/ast/scenario_outline'
+require 'cucumber/ast/step_invocation'
+require 'cucumber/ast/step_collection'
+require 'cucumber/ast/step'
+require 'cucumber/ast/table'
+require 'cucumber/ast/tags'
+require 'cucumber/ast/py_string'
+require 'cucumber/ast/outline_table'
+require 'cucumber/ast/examples'
+require 'cucumber/ast/visitor'
+require 'cucumber/ast/tree_walker'
+
+module Cucumber
+  # Classes in this module represent the Abstract Syntax Tree (AST)
+  # that gets built when feature files are parsed.
+  #
+  # AST classes don't expose any internal data directly. This is
+  # in order to encourage a less coupled design in the classes
+  # that operate on the AST. The only public method is #accept.
+  #
+  # The AST can be traversed with a visitor. See Cucumber::Format::Pretty
+  # for an example.
+  module Ast
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/broadcaster.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  class Broadcaster #:nodoc:
+    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/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/cli/configuration.rb

@@ -0,0 +1,209 @@
+require 'logger'
+require 'cucumber/cli/options'
+require 'cucumber/constantize'
+require 'gherkin/tag_expression'
+
+module Cucumber
+  module Cli
+    class YmlLoadError < StandardError; end
+    class ProfilesNotDefinedError < YmlLoadError; end
+    class ProfileNotFound < StandardError; end
+
+    class Configuration
+      include Constantize
+
+      attr_reader :out_stream
+
+      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?
+
+        @options[:tag_expression] = Gherkin::TagExpression.new(@options[:tag_expressions])
+        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 drb?
+        @options[:drb]
+      end
+
+      def drb_port
+        @options[:drb_port].to_i if @options[:drb_port]
+      end
+
+      def dry_run?
+        @options[:dry_run]
+      end
+
+      def expand?
+        @options[:expand]
+      end
+
+      def build_tree_walker(step_mother)
+        Ast::TreeWalker.new(step_mother, formatters(step_mother), self)
+      end
+
+      def formatter_class(format)
+        if(builtin = Options::BUILTIN_FORMATS[format])
+          constantize(builtin[0])
+        else
+          constantize(format)
+        end
+      end
+
+      def all_files_to_load
+        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}/**/*"] : path
+        end.flatten.uniq
+        remove_excluded_files_from(files)
+        files.reject! {|f| !File.file?(f)}
+        files.reject! {|f| File.extname(f) == '.feature' }
+        files.reject! {|f| f =~ /^http/}
+        files.sort
+      end
+
+      def step_defs_to_load
+        all_files_to_load.reject {|f| f =~ %r{/support/} }
+      end
+
+      def support_to_load
+        support_files = all_files_to_load.select {|f| f =~ %r{/support/} }
+        env_files = support_files.select {|f| f =~ %r{/support/env\..*} }
+        other_files = support_files - env_files
+        @options[:dry_run] ? other_files : env_files + other_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('/')
+          if File.directory?(path)
+            Dir["#{path}/**/*.feature"]
+          elsif path[0..0] == '@' and # @listfile.txt
+              File.file?(path[1..-1]) # listfile.txt is a file
+            IO.read(path[1..-1]).split
+          else
+            path
+          end
+        end.flatten.uniq
+        remove_excluded_files_from(potential_feature_files)
+        potential_feature_files
+      end
+
+      def feature_dirs
+        paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+      end
+
+      def log
+        logger = Logger.new(@out_stream)
+        logger.formatter = LogFormatter.new
+        logger.level = Logger::INFO
+        logger.level = Logger::DEBUG if self.verbose?
+        logger
+      end
+      
+      def tag_expression
+        Gherkin::TagExpression.new(@options[:tag_expressions])
+      end
+      
+      def filters
+        @options.filters
+      end
+      
+      def formats
+        @options[:formats]
+      end
+      
+      def options
+        warn("Deprecated: Configuration#options will be removed from the next release of Cucumber. Please use the configuration object directly instead.")
+        @options
+      end
+      
+      def paths
+        @options[:paths].empty? ? ['features'] : @options[:paths]
+      end
+    private
+
+      def formatters(step_mother)
+        # TODO: We should remove the autoformat functionality. That
+        # can be done with the gherkin CLI.
+        if @options[:autoformat]
+          require 'cucumber/formatter/pretty'
+          return [Formatter::Pretty.new(step_mother, nil, @options)]
+        end
+
+        @options[:formats].map do |format_and_out|
+          format = format_and_out[0]
+          path_or_io = format_and_out[1]
+          begin
+            formatter_class = formatter_class(format)
+            formatter_class.new(step_mother, path_or_io, @options)
+          rescue Exception => e
+            e.message << "\nError creating formatter: #{format}"
+            raise e
+          end
+        end
+      end
+
+      class LogFormatter < ::Logger::Formatter
+        def call(severity, time, progname, msg)
+          msg
+        end
+      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}
+        streams = @options[:formats].map { |(_, stream)| stream }
+        if streams != streams.uniq
+          raise "All but one formatter must use --out, only one can print to each stream (or STDOUT)"
+        end
+      end
+
+      def remove_excluded_files_from(files)
+        files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
+      end
+
+      def require_dirs
+        feature_dirs + Dir['vendor/{gems,plugins}/*/cucumber']
+      end
+
+    end
+
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/cli/drb_client.rb

@@ -0,0 +1,43 @@
+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
+
+      class << self
+
+        def run(args, error_stream, out_stream, port = nil)
+          port ||= ENV["CUCUMBER_DRB"] || DEFAULT_PORT
+
+          setup_support_for_io_streams_over_drb
+
+          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
+
+        private
+        def setup_support_for_io_streams_over_drb
+          # 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, Errno::EADDRNOTAVAIL
+            # 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
+        end
+
+      end
+
+    end
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/cli/main.rb

@@ -0,0 +1,83 @@
+begin
+  require 'gherkin'
+rescue LoadError
+  require 'rubygems'
+  require 'gherkin'
+end
+require 'optparse'
+require 'cucumber'
+require 'logger'
+require 'cucumber/parser'
+require 'cucumber/feature_file'
+require 'cucumber/formatter/color_io'
+require 'cucumber/cli/configuration'
+require 'cucumber/cli/drb_client'
+
+module Cucumber
+  module Cli
+    class Main
+      class << self
+        def execute(args)
+          new(args).execute!
+        end
+      end
+
+      def initialize(args, out_stream = STDOUT, error_stream = STDERR)
+        @args         = args
+        if Cucumber::WINDOWS_MRI
+          @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new(Kernel, STDOUT) : out_stream
+        else
+          @out_stream   = out_stream
+        end
+
+        @error_stream = error_stream
+        @configuration = nil
+      end
+
+      def execute!(existing_runtime = nil)
+        trap_interrupt
+        return @drb_output if run_drb_client
+        
+        runtime = if existing_runtime
+          existing_runtime.configure(configuration)
+          existing_runtime
+        else
+          Runtime.new(configuration)
+        end
+
+        runtime.run!
+        runtime.results.failure?
+      rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
+        @error_stream.puts e.message
+        true
+      end
+
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = Configuration.new(@out_stream, @error_stream)
+        @configuration.parse!(@args)
+        Cucumber.logger = @configuration.log
+        @configuration
+      end
+
+      private
+      
+      def run_drb_client
+        return false unless configuration.drb?
+        @drb_output = DRbClient.run(@args, @error_stream, @out_stream, configuration.drb_port)
+        true
+      rescue DRbClientError => e
+        @error_stream.puts "WARNING: #{e.message} Running features locally:"
+      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