vim-jar 0.0.3 → 0.1.0

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

@@ -0,0 +1,203 @@
+require 'cucumber/constantize'
+require 'cucumber/runtime/for_programming_languages'
+
+module Cucumber
+  class Runtime
+    
+    class SupportCode
+      
+      require 'forwardable'
+      class StepInvoker
+        include Gherkin::Rubify
+
+        def initialize(support_code)
+          @support_code = support_code
+        end
+
+        def uri(uri)
+        end
+
+        def step(step)
+          cucumber_multiline_arg = case(rubify(step.multiline_arg))
+          when Gherkin::Formatter::Model::PyString
+            step.multiline_arg.value
+          when Array
+            Ast::Table.new(step.multiline_arg.map{|row| row.cells})
+          else
+            nil
+          end
+          @support_code.invoke(step.name, cucumber_multiline_arg) 
+        end
+
+        def eof
+        end
+      end
+    
+      include Constantize
+      
+      def initialize(user_interface, configuration={})
+        @configuration = Configuration.parse(configuration)
+        @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
+        @unsupported_programming_languages = []
+        @programming_languages = []
+        @language_map = {}
+      end
+      
+      def configure(new_configuration)
+        @configuration = Configuration.parse(new_configuration)
+      end
+    
+      # Invokes a series of steps +steps_text+. Example:
+      #
+      #   invoke(%Q{
+      #     Given I have 8 cukes in my belly
+      #     Then I should not be thirsty
+      #   })
+      def invoke_steps(steps_text, i18n, file_colon_line)
+        file, line = file_colon_line.split(':')
+        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps')
+        parser.parse(steps_text, file, line.to_i)
+      end
+      
+      # Loads and registers programming language implementation.
+      # Instances are cached, so calling with the same argument
+      # twice will return the same instance.
+      #
+      def load_programming_language(ext)
+        return @language_map[ext] if @language_map[ext]
+        programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
+        programming_language = programming_language_class.new(@runtime_facade)
+        @programming_languages << programming_language
+        @language_map[ext] = programming_language
+        programming_language
+      end
+    
+      def load_files!(files)
+        log.debug("Code:\n")
+        files.each do |file|
+          load_file(file)
+        end
+        log.debug("\n")
+      end
+      
+      def load_files_from_paths(paths)
+        files = paths.map { |path| Dir["#{path}/**/*"] }.flatten
+        load_files! files
+      end
+    
+      def unmatched_step_definitions
+        @programming_languages.map do |programming_language| 
+          programming_language.unmatched_step_definitions
+        end.flatten
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+        load_programming_language('rb') if unknown_programming_language?
+        @programming_languages.map do |programming_language|
+          programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
+        end.join("\n")
+      end
+    
+      def unknown_programming_language?
+        @programming_languages.empty?
+      end
+    
+      def fire_hook(name, *args)
+        @programming_languages.each do |programming_language|
+          programming_language.send(name, *args)
+        end
+      end
+    
+      def around(scenario, block)
+        @programming_languages.reverse.inject(block) do |blk, programming_language|
+          proc do
+            programming_language.around(scenario) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+      
+      def step_definitions
+        @programming_languages.map do |programming_language|
+          programming_language.step_definitions
+        end.flatten
+      end
+    
+      def step_match(step_name, name_to_report=nil) #:nodoc:
+        matches = matches(step_name, name_to_report)
+        raise Undefined.new(step_name) if matches.empty?
+        matches = best_matches(step_name, matches) if matches.size > 1 && guess_step_matches?
+        raise Ambiguous.new(step_name, matches, guess_step_matches?) if matches.size > 1
+        matches[0]
+      end
+    
+      def invoke(step_name, multiline_argument=nil)
+        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
+        begin
+          step_match(step_name).invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
+
+    private
+  
+      def guess_step_matches?
+        @configuration.guess?
+      end
+    
+      def matches(step_name, name_to_report)
+        @programming_languages.map do |programming_language| 
+          programming_language.step_matches(step_name, name_to_report).to_a
+        end.flatten
+      end
+
+      def best_matches(step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
+        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+        if no_groups.any?
+          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
+          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+        elsif top_groups.any?
+          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
+          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
+        else
+          top_groups
+        end
+      end
+    
+      def load_file(file)
+        if programming_language = programming_language_for(file)
+          log.debug("  * #{file}\n")
+          programming_language.load_code_file(file)
+        else
+          log.debug("  * #{file} [NOT SUPPORTED]\n")
+        end
+      end
+    
+      def log
+        Cucumber.logger
+      end
+    
+      def programming_language_for(step_def_file)
+        if ext = File.extname(step_def_file)[1..-1]
+          return nil if @unsupported_programming_languages.index(ext)
+          begin
+            load_programming_language(ext)
+          rescue LoadError => e
+            log.debug("Failed to load '#{ext}' programming language for file #{step_def_file}: #{e.message}\n")
+            @unsupported_programming_languages << ext
+            nil
+          end
+        else
+          nil
+        end
+      end
+    
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'timeout'
+
+module Cucumber
+  class Runtime
+
+    module UserInterface
+      attr_writer :visitor
+      
+      # Output +announcement+ alongside the formatted output.
+      # This is an alternative to using Kernel#puts - it will display
+      # nicer, and in all outputs (in case you use several formatters)
+      #
+      def announce(msg)
+        msg.respond_to?(:join) ? @visitor.announce(msg.join("\n")) : @visitor.announce(msg.to_s)
+      end
+
+      # Suspends execution and prompts +question+ to the console (STDOUT).
+      # An operator (manual tester) can then enter a line of text and hit
+      # <ENTER>. The entered text is returned, and both +question+ and
+      # the result is added to the output using #announce.
+      #
+      # If you want a beep to happen (to grab the manual tester's attention),
+      # just prepend ASCII character 7 to the question:
+      #
+      #   ask("#{7.chr}How many cukes are in the external system?")
+      #
+      # If that doesn't issue a beep, you can shell out to something else
+      # that makes a sound before invoking #ask.
+      #
+      def ask(question, timeout_seconds)
+        STDOUT.puts(question)
+        STDOUT.flush
+        announce(question)
+
+        if(Cucumber::JRUBY)
+          answer = jruby_gets(timeout_seconds)
+        else
+          answer = mri_gets(timeout_seconds)
+        end
+
+        if(answer)
+          announce(answer)
+          answer
+        else
+          raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
+        end
+      end
+
+      # Embed +file+ of MIME type +mime_type+ into the output. This may or may
+      # not be ignored, depending on what kind of formatter(s) are active.
+      #
+      def embed(file, mime_type)
+        @visitor.embed(file, mime_type)
+      end
+
+    private
+    
+      def mri_gets(timeout_seconds)
+        begin
+          Timeout.timeout(timeout_seconds) do
+            STDIN.gets
+          end
+        rescue Timeout::Error => e
+          nil
+        end
+      end
+
+      def jruby_gets(timeout_seconds)
+        answer = nil
+        t = java.lang.Thread.new do
+          answer = STDIN.gets
+        end
+        t.start
+        t.join(timeout_seconds * 1000)
+        answer
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,145 @@
+require 'gherkin/rubify'
+require 'gherkin/i18n'
+require 'cucumber/configuration'
+require 'cucumber/language_support/language_methods'
+require 'cucumber/formatter/duration'
+require 'cucumber/runtime/user_interface'
+require 'cucumber/runtime/features_loader'
+require 'cucumber/runtime/results'
+require 'cucumber/runtime/support_code'
+
+module Cucumber
+  # This is the meaty part of Cucumber that ties everything together.
+  class Runtime
+    attr_reader :results
+    
+    include Formatter::Duration
+    include Runtime::UserInterface
+
+    def initialize(configuration = Configuration.default)
+      require 'cucumber/core_ext/disable_mini_unit_autorun'
+      @current_scenario = nil
+      @configuration = Configuration.parse(configuration)
+      @support_code = SupportCode.new(self, @configuration)
+      @results = Results.new(@configuration)
+    end
+    
+    # Allows you to take an existing runtime and change it's configuration
+    def configure(new_configuration)
+      @configuration = Configuration.parse(new_configuration)
+      @support_code.configure(@configuration)
+      @results.configure(@configuration)
+    end
+    
+    def load_programming_language(language)
+      @support_code.load_programming_language(language)
+    end
+    
+    def run!
+      load_step_definitions
+      fire_after_configuration_hook
+
+      tree_walker = @configuration.build_tree_walker(self)
+      self.visitor = tree_walker # Ugly circular dependency, but needed to support World#announce
+      
+      tree_walker.visit_features(features)
+    end
+    
+    def features_paths
+      @configuration.paths
+    end
+
+    def step_visited(step) #:nodoc:
+      @results.step_visited(step)
+    end
+
+    def scenarios(status = nil)
+      @results.scenarios(status)
+    end
+
+    def steps(status = nil)
+      @results.steps(status)
+    end
+
+    def step_match(step_name, name_to_report=nil) #:nodoc:
+      @support_code.step_match(step_name, name_to_report)
+    end
+
+    def unmatched_step_definitions
+      @support_code.unmatched_step_definitions
+    end
+
+    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      @support_code.snippet_text(Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg_class)
+    end
+
+    def with_hooks(scenario, skip_hooks=false)
+      around(scenario, skip_hooks) do
+        before_and_after(scenario, skip_hooks) do
+          yield scenario
+        end
+      end
+    end
+
+    def around(scenario, skip_hooks=false, &block) #:nodoc:
+      if skip_hooks
+        yield
+        return
+      end
+
+      @support_code.around(scenario, block)
+    end
+
+    def before_and_after(scenario, skip_hooks=false) #:nodoc:
+      before(scenario) unless skip_hooks
+      yield scenario
+      after(scenario) unless skip_hooks
+      @results.scenario_visited(scenario)
+    end
+
+    def before(scenario) #:nodoc:
+      return if @configuration.dry_run? || @current_scenario
+      @current_scenario = scenario
+      @support_code.fire_hook(:before, scenario)
+    end
+
+    def after(scenario) #:nodoc:
+      @current_scenario = nil
+      return if @configuration.dry_run?
+      @support_code.fire_hook(:after, scenario)
+    end
+
+    def after_step #:nodoc:
+      return if @configuration.dry_run?
+      @support_code.fire_hook(:execute_after_step, @current_scenario)
+    end
+
+    def unknown_programming_language?
+      @support_code.unknown_programming_language?
+    end
+
+  private
+
+    def fire_after_configuration_hook #:nodoc
+      @support_code.fire_hook(:after_configuration, @configuration)
+    end
+
+    def features
+      loader = Runtime::FeaturesLoader.new(
+        @configuration.feature_files, 
+        @configuration.filters, 
+        @configuration.tag_expression)
+      loader.features
+    end
+
+    def load_step_definitions
+      files = @configuration.support_to_load + @configuration.step_defs_to_load
+      @support_code.load_files!(files)
+    end
+
+    def log
+      Cucumber.logger
+    end
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Cucumber
+  class StepArgument
+    attr_reader :val, :byte_offset
+
+    def initialize(val, byte_offset)
+      @val, @byte_offset = val, byte_offset
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Cucumber
+  # Only used for keeping track of available and invoked step definitions
+  # in a way that also works for other programming languages (i.e. cuke4duke)
+  # Used for reporting purposes only (usage formatter).
+  class StepDefinitionLight
+    attr_reader :regexp_source, :file_colon_line
+    
+    def initialize(regexp_source, file_colon_line)
+      @regexp_source, @file_colon_line = regexp_source, file_colon_line
+    end
+    
+    def eql?(o)
+      regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+    end
+    
+    def hash
+      regexp_source.hash + 31*file_colon_line.hash
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'json'
+module Cucumber
+  class StepDefinitions
+    def initialize(configuration = Configuration.default)
+      configuration = Configuration.parse(configuration)
+      @support_code = Runtime::SupportCode.new(nil, false)
+      @support_code.load_files_from_paths(configuration.autoload_code_paths)
+    end
+    
+    def to_json
+      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module Cucumber
+  class StepMatch #:nodoc:
+    attr_reader :step_definition
+
+    # Creates a new StepMatch. The +name_to_report+ argument is what's reported, unless it's is,
+    # in which case +name_to_report+ is used instead.
+    # 
+    def initialize(step_definition, name_to_match, name_to_report, step_arguments)
+      raise "name_to_match can't be nil" if name_to_match.nil?
+      raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
+      @step_definition, @name_to_match, @name_to_report, @step_arguments = step_definition, name_to_match, name_to_report, step_arguments
+    end
+
+    def args
+      @step_arguments.map{|g| g.val}
+    end
+
+    def name
+      @name_to_report
+    end
+
+    def invoke(multiline_arg)
+      multiline_arg = Ast::PyString.new(multiline_arg) if String === multiline_arg
+      all_args = args
+      all_args << multiline_arg.to_step_definition_arg if multiline_arg
+      @step_definition.invoke(all_args)
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(format = lambda{|a| a}, &proc)
+      @name_to_report || replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    end
+
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+    end
+
+    def text_length
+      @step_definition.regexp_source.unpack('U*').length
+    end
+
+    def replace_arguments(string, step_arguments, format, &proc)
+      s = string.dup
+      offset = past_offset = 0
+      step_arguments.each do |step_argument|
+        next if step_argument.byte_offset.nil? || step_argument.byte_offset < past_offset
+        
+        replacement = if block_given?
+          proc.call(step_argument.val)
+        elsif Proc === format
+          format.call(step_argument.val)
+        else
+          format % step_argument.val
+        end
+
+        s[step_argument.byte_offset + offset, step_argument.val.length] = replacement
+        offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
+        past_offset = step_argument.byte_offset + step_argument.val.length
+      end
+      s
+    end
+
+    def inspect #:nodoc:
+      sprintf("#<%s:0x%x>", self.class, self.object_id)
+    end
+  end
+  
+  class NoStepMatch #:nodoc:
+    attr_reader :step_definition, :name
+
+    def initialize(step, name)
+      @step = step
+      @name = name
+    end
+    
+    def format_args(format)
+      @name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'cucumber/runtime'
+
+module Cucumber
+  class StepMother < Runtime
+    def initialize(*args)
+      warn("StepMother has been deprecated and will be gently put to sleep at the next major release. Please use Runtime instead. #{caller[0]}")
+      super
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'yaml'
+
+module Cucumber
+  module WireSupport
+    class Configuration
+      attr_reader :host, :port
+      
+      def initialize(wire_file)
+        params = YAML.load_file(wire_file)
+        @host = params['host']
+        @port = params['port']
+        @timeouts = default_timeouts.merge(params['timeout'] || {})
+      end
+      
+      def timeout(message = nil)
+        return @timeouts[message.to_s] || 3
+      end
+      
+      private
+      
+      def default_timeouts
+        {
+          'invoke' => 120,
+          'begin_scenario' => 120,
+          'end_scenario' => 120
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'timeout'
+require 'cucumber/wire_support/wire_protocol'
+
+module Cucumber
+  module WireSupport
+    class Connection
+      class ConnectionError < StandardError; end
+        
+      include WireProtocol
+      
+      def initialize(config)
+        @config = config
+      end
+      
+      def call_remote(request_handler, message, params)
+        packet = WirePacket.new(message, params)
+
+        begin
+          send_data_to_socket(packet.to_json)
+          response = fetch_data_from_socket(@config.timeout(message))
+          response.handle_with(request_handler)
+        rescue Timeout::Error => e
+          backtrace = e.backtrace ; backtrace.shift # because Timeout puts some wierd stuff in there
+          raise Timeout::Error, "Timed out calling wire server with message '#{message}'", backtrace
+        end
+      end
+      
+      def exception(params)
+        WireException.new(params, @config.host, @config.port)
+      end
+
+      private
+      
+      def send_data_to_socket(data)
+        Timeout.timeout(@config.timeout) { socket.puts(data) }
+      end
+
+      def fetch_data_from_socket(timeout)
+        raw_response = 
+          if timeout == :never
+            socket.gets
+          else
+            Timeout.timeout(timeout) { socket.gets }
+          end
+        WirePacket.parse(raw_response)
+      end
+      
+      def socket
+        @socket ||= TCPSocket.new(@config.host, @config.port)
+      rescue Errno::ECONNREFUSED => exception
+        raise(ConnectionError, "Unable to contact the wire server at #{@config.host}:#{@config.port}. Is it up?")
+      end
+    end
+  end
+end