vim-jar 0.0.3 → 0.1.0

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

@@ -0,0 +1,49 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format steps</tt>
+    class Steps
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "steps")
+        @options = options
+        @step_definition_files = collect_steps(step_mother)
+      end
+
+      def after_features(features)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+          
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp_source|
+            @io.print regexp_source.indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp_source.unpack('U*').length)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(step_mother)
+        step_mother.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp_source ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    module Summary
+
+      def scenario_summary(step_mother, &block)
+        scenarios_proc = lambda{|status| step_mother.scenarios(status)}
+        dump_count(step_mother.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(step_mother, &block)
+        steps_proc = lambda{|status| step_mother.steps(status)}
+        dump_count(step_mother.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/pretty'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format tag_cloud</tt>
+    # Custom formatter that prints a tag cloud as a table.
+    class TagCloud
+      include Io
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "tag_cloud")
+        @options = options
+        @counts = Hash.new{|h,k| h[k] = 0}
+      end
+
+      def after_features(features)
+        print_summary(features)
+      end
+
+      def tag_name(tag_name)
+        @counts[tag_name] += 1
+      end
+      
+      private
+  
+      def print_summary(features)
+        matrix = @counts.to_a.sort{|paira, pairb| paira[0] <=> pairb[0]}.transpose
+        table = Cucumber::Ast::Table.new(matrix)
+        formatter = Cucumber::Formatter::Pretty.new(@step_mother, @io, {})
+        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter]).visit_multiline_arg(table)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# Require this file if you need Unicode support.
+# Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
+require 'cucumber/platform'
+require 'cucumber/formatter/ansicolor'
+$KCODE='u' unless Cucumber::RUBY_1_9
+
+if Cucumber::WINDOWS
+  require 'iconv'
+
+  if ENV['CUCUMBER_OUTPUT_ENCODING']
+    Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
+  elsif Cucumber::WINDOWS_MRI
+    Cucumber::CODEPAGE = "cp#{Win32::Console::OutputCP()}"
+  elsif `cmd /c chcp` =~ /(\d+)/
+    Cucumber::CODEPAGE = "cp#{$1.to_i}"
+  else
+    Cucumber::CODEPAGE = "cp1252"
+    STDERR.puts("WARNING: Couldn't detect your output codepage. Assuming it is 1252. You may have to chcp 1252 or SET CUCUMBER_OUTPUT_ENCODING=cp1252.")
+  end
+
+  module Cucumber
+    module WindowsOutput #:nodoc:
+      def self.extended(o)
+        o.instance_eval do
+          alias cucumber_print print
+          def print(*a)
+            begin
+              cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+            rescue Iconv::InvalidEncoding => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              cucumber_print(*a)
+            rescue Iconv::IllegalSequence => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              cucumber_print(*a)
+            end
+          end
+
+          alias cucumber_puts puts
+          def puts(*a)
+            begin
+              cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+            rescue Iconv::InvalidEncoding => e
+              STDERR.cucumber_print("WARNING: #{e.message}")
+              cucumber_print(*a)
+            rescue Iconv::IllegalSequence => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              cucumber_puts(*a)
+            end
+          end
+        end
+      end
+
+      Kernel.extend(self)
+      STDOUT.extend(self)
+      STDERR.extend(self)
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+require 'cucumber/formatter/progress'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module Formatter
+    class Usage < Progress
+      include Console
+
+      class StepDefKey < StepDefinitionLight
+        attr_accessor :mean_duration, :status
+      end
+
+      def initialize(step_mother, path_or_io, options)
+        @step_mother = step_mother
+        @io = ensure_io(path_or_io, "usage")
+        @options = options
+        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
+      end
+
+      def before_step(step)
+        @step = step
+        @start_time = Time.now
+      end
+
+      def before_step_result(*args)
+        @duration = Time.now - @start_time
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        if step_match.name.nil? # nil if it's from a scenario outline
+          stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
+
+          @stepdef_to_match[stepdef_key] << {
+            :keyword => keyword, 
+            :step_match => step_match, 
+            :status => status, 
+            :file_colon_line => @step.file_colon_line,
+            :duration => @duration
+          }
+        end
+        super
+      end
+
+      def print_summary(features)
+        add_unused_stepdefs
+        aggregate_info
+
+        if @options[:dry_run]
+          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
+        else
+          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+        end
+
+        keys.each do |stepdef_key|
+          print_step_definition(stepdef_key)
+
+          if @stepdef_to_match[stepdef_key].any?
+            print_steps(stepdef_key)
+          else
+            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
+          end
+        end
+        @io.puts
+        super
+      end
+
+      def print_step_definition(stepdef_key)
+        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[:dry_run]
+        @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
+        if @options[:source]
+          indent = max_length - stepdef_key.regexp_source.unpack('U*').length
+          line_comment = "   # #{stepdef_key.file_colon_line}".indent(indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+      end
+
+      def print_steps(stepdef_key)
+        @stepdef_to_match[stepdef_key].each do |step|
+          @io.print "  "
+          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
+          if @options[:source]
+            indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
+            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            @io.print(format_string(line_comment, :comment))
+          end
+          @io.puts
+        end
+      end
+
+      def max_length
+        [max_stepdef_length, max_step_length].compact.max
+      end
+
+      def max_stepdef_length
+        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.unpack('U*').length}.max
+      end
+
+      def max_step_length
+        @stepdef_to_match.values.to_a.flatten.map do |step|
+          step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length
+        end.max
+      end
+
+      def aggregate_info
+        @stepdef_to_match.each do |key, steps|
+          if steps.empty?
+            key.status = :skipped
+            key.mean_duration = 0
+          else
+            key.status = Ast::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.mean_duration = total_duration / steps.length
+          end
+        end
+      end
+
+      def add_unused_stepdefs
+        @step_mother.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/js_support/js_dsl.js

@@ -0,0 +1,57 @@
+var CucumberJsDsl = {
+  registerStepDefinition: function(regexp, func) {
+    if(func == null) {
+      jsLanguage.execute_step_definition(regexp);
+    }
+    else{
+      jsLanguage.add_step_definition(regexp, func);
+    }
+  },
+
+  registerTransform: function(regexp, func) {
+    jsLanguage.register_js_transform(regexp, func);
+  },
+
+  beforeHook: function(tag_expressions_or_func, func) {
+    CucumberJsDsl.__registerJsHook('before', tag_expressions_or_func, func);
+  },
+
+  afterHook: function(tag_expressions_or_func, func) {
+    CucumberJsDsl.__registerJsHook('after', tag_expressions_or_func, func);
+  },
+
+  steps: function(step_names) {
+    jsLanguage.steps(step_names, "UNKNOWN:0");
+  },
+
+  Table: function(raw_table) {
+    //TODO: Create a ruby table and send it back for use in js world
+  },
+
+  world: function(files) {
+    jsLanguage.world(files);
+  },
+
+  __registerJsHook: function(label, tag_expressions_or_func, func) {
+    if(func != null) {
+      var hook_func = func;
+      var tag_expressions = tag_expressions_or_func;
+    } else {
+      var hook_func = tag_expressions_or_func;
+      var tag_expressions = [];
+    }
+    jsLanguage.register_js_hook(label, tag_expressions, hook_func);
+  }
+}
+
+var Given = CucumberJsDsl.registerStepDefinition;
+var When = CucumberJsDsl.registerStepDefinition;
+var Then = CucumberJsDsl.registerStepDefinition;
+
+var Before = CucumberJsDsl.beforeHook;
+var After = CucumberJsDsl.afterHook;
+var Transform = CucumberJsDsl.registerTransform;
+
+var World = CucumberJsDsl.world;
+
+var steps = CucumberJsDsl.steps;

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

@@ -0,0 +1,185 @@
+begin
+  require 'v8'
+rescue LoadError
+  gem 'therubyracer', '~> 0.7.1'
+  require 'v8'
+end
+
+require 'cucumber/js_support/js_snippets'
+
+module Cucumber
+  module JsSupport
+
+    def self.argument_safe_string(string)
+      arg_string = string.to_s.gsub(/[']/, '\\\\\'')
+      arg_string.gsub("\n", '\n')
+    end
+
+    class JsWorld
+      def initialize
+        @world = V8::Context.new
+      end
+
+      def execute(js_function, args=[])
+        js_function.call(*args)
+      end
+
+      def method_missing(method_name, *args)
+        @world.send(method_name, *args)
+      end
+    end
+
+    class JsStepDefinition
+      def initialize(js_language, regexp, js_function)
+        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
+      end
+
+      def invoke(args)
+        args = @js_language.execute_transforms(args)
+        @js_language.current_world.execute(@js_function, args)
+      end
+
+      def regexp_source
+        @regexp.inspect
+      end
+
+      def arguments_from(step_name)
+        matches = eval_js "#{@regexp}.exec('#{step_name}')"
+        if matches
+          matches.to_a[1..-1].map do |match|
+            JsArg.new(match)
+          end
+        end
+      end
+
+      def file_colon_line
+        # Not possible yet to get file/line of js function with V8/therubyracer
+        ""
+      end
+    end
+
+    class JsHook
+      def initialize(js_language, tag_expressions, js_function)
+        @js_language, @tag_expressions, @js_function = js_language, tag_expressions, js_function
+      end
+
+      def tag_expressions
+        @tag_expressions
+      end
+
+      def invoke(location, scenario)
+        @js_language.current_world.execute(@js_function)
+      end
+    end
+
+    class JsTransform
+      def initialize(js_language, regexp, js_function)
+        @js_language, @regexp, @js_function = js_language, regexp.to_s, js_function
+      end
+
+      def match(arg)
+        arg = JsSupport.argument_safe_string(arg)
+        matches = (eval_js "#{@regexp}.exec('#{arg}');").to_a
+        matches.empty? ? nil : matches[1..-1]
+      end
+
+      def invoke(arg)
+        @js_function.call([arg])
+      end
+    end
+
+    class JsArg
+      def initialize(arg)
+        @arg = arg
+      end
+
+      def val
+        @arg
+      end
+
+      def byte_offset
+      end
+    end
+
+    class JsLanguage
+      include LanguageSupport::LanguageMethods
+      include JsSnippets
+
+      def initialize(runtime)
+        @step_definitions = []
+        @world = JsWorld.new
+        @runtime = runtime
+
+        @world["jsLanguage"] = self
+        @world.load(File.dirname(__FILE__) + '/js_dsl.js')
+      end
+
+      def load_code_file(js_file)
+        @world.load(js_file)
+      end
+
+      def world(js_files)
+        js_files.each do |js_file|
+          load_code_file("#{path_to_load_js_from}#{js_file}")
+        end
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def begin_scenario(scenario)
+        @language = scenario.language
+      end
+
+      def end_scenario
+      end
+
+      def step_matches(name_to_match, name_to_format)
+        @step_definitions.map do |step_definition|
+          if(arguments = step_definition.arguments_from(name_to_match))
+            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      def add_step_definition(regexp, js_function)
+        @step_definitions << JsStepDefinition.new(self, regexp, js_function)
+      end
+
+      #TODO: support multiline arguments when calling steps from within steps
+      def execute_step_definition(name, multiline_argument = nil)
+        @runtime.step_match(name).invoke(multiline_argument)
+      end
+
+      def register_js_hook(phase, tag_expressions, js_function)
+        add_hook(phase, JsHook.new(self, tag_expressions, js_function))
+      end
+
+      def register_js_transform(regexp, js_function)
+        add_transform(JsTransform.new(self, regexp, js_function))
+      end
+
+      def current_world
+        @world
+      end
+
+      def steps(steps_text, file_colon_line)
+        @runtime.invoke_steps(steps_text, @language, file_colon_line)
+      end
+
+      private
+      def path_to_load_js_from
+        paths = @runtime.features_paths
+        if paths.empty?
+          '' # Using rake
+        else
+          path = paths[0][/(^.*\/?features)/, 0]
+          path ? "#{path}/../" : '../'
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Cucumber
+  module JsSupport
+    module JsSnippets
+      PARAM_PATTERN = /"([^"]*)"/
+      ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
+
+        n = 0
+        block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
+          n += 1
+          "arg#{n}"
+        end
+        block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
+        block_arg_string = block_args.empty? ? "" : "#{block_args.join(", ")}"
+        multiline_class_comment = ""
+        if(multiline_arg_class == Ast::Table)
+          multiline_class_comment = "//#{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n"
+        end
+
+        "#{code_keyword}(/^#{escaped}$/, function(#{block_arg_string}){\n  #{multiline_class_comment}  //express the regexp above with the code you wish you had\n});"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'cucumber/step_match'
+require 'cucumber/step_definition_light'
+
+module Cucumber
+  module LanguageSupport
+    module LanguageMethods
+      def create_step_match(step_definition, step_name, name_to_report, step_arguments)
+        StepMatch.new(step_definition, step_name, name_to_report, step_arguments)
+      end
+
+      def around(scenario)
+        execute_around(scenario) do
+          yield
+        end
+      end
+
+      def before(scenario)
+        begin_scenario(scenario)
+        execute_before(scenario)
+      end
+
+      def after(scenario)
+        execute_after(scenario)
+        end_scenario
+      end
+
+      def after_configuration(configuration)
+        hooks[:after_configuration].each do |hook|
+          hook.invoke('AfterConfiguration', configuration)
+        end
+      end
+
+      def execute_after_step(scenario)
+        hooks_for(:after_step, scenario).each do |hook|
+          invoke(hook, 'AfterStep', scenario, false)
+        end
+      end
+
+      def execute_transforms(args)
+        args.map do |arg|
+          matching_transform = transforms.detect {|transform| transform.match(arg) }
+          matching_transform ? matching_transform.invoke(arg) : arg
+        end
+      end
+
+      def add_hook(phase, hook)
+        hooks[phase.to_sym] << hook
+        hook
+      end
+
+      def clear_hooks
+        @hooks = nil
+      end
+
+      def add_transform(transform)
+        transforms.unshift transform
+        transform
+      end
+
+      def hooks_for(phase, scenario) #:nodoc:
+        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
+      end
+
+      def unmatched_step_definitions
+        available_step_definition_hash.keys - invoked_step_definition_hash.keys
+      end
+
+      def available_step_definition(regexp_source, file_colon_line)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      def invoked_step_definition(regexp_source, file_colon_line)
+        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      end
+
+      private
+
+      def available_step_definition_hash
+        @available_step_definition_hash ||= {}
+      end
+
+      def invoked_step_definition_hash
+        @invoked_step_definition_hash ||= {}
+      end
+
+      def hooks
+        @hooks ||= Hash.new{|h,k| h[k] = []}
+      end
+
+      def transforms
+        @transforms ||= []
+      end
+
+      def execute_around(scenario, &block)
+        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
+          proc do
+            invoke(hook, 'Around', scenario, true) do
+              blk.call(scenario)
+            end
+          end
+        end.call
+      end
+
+      def execute_before(scenario)
+        hooks_for(:before, scenario).each do |hook|
+          invoke(hook, 'Before', scenario, true)
+        end
+      end
+
+      def execute_after(scenario)
+        hooks_for(:after, scenario).reverse_each do |hook|
+          invoke(hook, 'After', scenario, true)
+        end
+      end
+
+      def invoke(hook, location, scenario, exception_fails_scenario, &block)
+        begin
+          hook.invoke(location, scenario, &block)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end