vim-jar 0.0.3 → 0.1.0

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

@@ -0,0 +1,30 @@
+module Cucumber
+  # This module defines the API for programming language support in Cucumber.
+  # While Cucumber itself is written in Ruby, any programming language can
+  # be supported by implementing this API.
+  #
+  # For the sake of illustration we'll consider an imaginary language called
+  # _why. _why files have the .why extension, so we need to put support for
+  # this language in the <tt>Cucumber::WhySupport::WhyLanguage</tt>. This
+  # class must be defined in a file called <tt>cucumber/why_support/why_language.rb</tt>
+  # and be available on Ruby's <tt>$LOAD_PATH</tt>:
+  #
+  #   module Cucumber
+  #     module WhySupport
+  #       class WhyLanguage
+  #
+  #         # Uses whatever available language bridge to load
+  #         # +why_file+ and returns an Array of StepDefinition.
+  #         def load_code_file(why_file)
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # Each language implementation manages its own hooks, and must execute them
+  # at appropriate times.
+  #   
+  #
+  module LanguageSupport
+  end
+end

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

@@ -0,0 +1,124 @@
+require 'cucumber/ast'
+require 'gherkin/rubify'
+
+module Cucumber
+  module Parser
+    # This class conforms to the Gherkin event API and builds the
+    # "legacy" AST. It will be replaced later when we have a new "clean"
+    # AST.
+    class GherkinBuilder
+      include Gherkin::Rubify
+
+      def ast
+        @feature || @multiline_arg
+      end
+
+      def feature(feature)
+        @feature = Ast::Feature.new(
+          nil, 
+          Ast::Comment.new(feature.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, feature.tags.map{|tag| tag.name}),
+          feature.keyword,
+          legacy_name_for(feature.name, feature.description),
+          []
+        )
+      end
+
+      def background(background)
+        @background = Ast::Background.new(
+          Ast::Comment.new(background.comments.map{|comment| comment.value}.join("\n")), 
+          background.line, 
+          background.keyword, 
+          legacy_name_for(background.name, background.description), 
+          steps=[]
+        )
+        @feature.background = @background
+        @background.feature = @feature
+        @step_container = @background
+      end
+
+      def scenario(statement)
+        scenario = Ast::Scenario.new(
+          @background, 
+          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
+          statement.line, 
+          statement.keyword, 
+          legacy_name_for(statement.name, statement.description), 
+          steps=[]
+        )
+        @feature.add_feature_element(scenario)
+        @background.feature_elements << scenario if @background
+        @step_container = scenario
+      end
+
+      def scenario_outline(statement)
+        scenario_outline = Ast::ScenarioOutline.new(
+          @background, 
+          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
+          statement.line, 
+          statement.keyword, 
+          legacy_name_for(statement.name, statement.description), 
+          steps=[],
+          example_sections=[]
+        )
+        @feature.add_feature_element(scenario_outline)
+        if @background
+          @background = @background.dup
+          @background.feature_elements << scenario_outline
+        end
+        @step_container = scenario_outline
+      end
+
+      def examples(examples)
+        examples_fields = [
+          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")), 
+          examples.line, 
+          examples.keyword, 
+          legacy_name_for(examples.name, examples.description), 
+          matrix(examples.rows)
+        ]
+        @step_container.add_examples(examples_fields)
+      end
+
+      def step(step)
+        @table_owner = Ast::Step.new(step.line, step.keyword, step.name)
+        multiline_arg = rubify(step.multiline_arg)
+        case(multiline_arg)
+        when Gherkin::Formatter::Model::PyString
+          @table_owner.multiline_arg = Ast::PyString.new(multiline_arg.value)
+        when Array
+          @table_owner.multiline_arg = Ast::Table.new(matrix(multiline_arg))
+        end
+        @step_container.add_step(@table_owner)
+      end
+
+      def eof
+      end
+
+      def syntax_error(state, event, legal_events, line)
+        # raise "SYNTAX ERROR"
+      end
+      
+    private
+    
+      def legacy_name_for(name, description)
+        s = name
+        s += "\n#{description}" if description != ""
+        s
+      end
+
+      def matrix(gherkin_table)
+        gherkin_table.map do |gherkin_row|
+          row = gherkin_row.cells
+          class << row
+            attr_accessor :line
+          end
+          row.line = gherkin_row.line
+          row
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+require 'cucumber/platform'
+require 'cucumber/ast'

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

@@ -0,0 +1,29 @@
+# Detect the platform we're running on so we can tweak behaviour
+# in various places.
+require 'rbconfig'
+
+module Cucumber
+unless defined?(Cucumber::VERSION)
+  VERSION       = '0.9.4'
+  BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
+  LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
+  JRUBY         = defined?(JRUBY_VERSION)
+  IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
+  WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+  WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+  RAILS         = defined?(Rails)
+  RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
+  RUBY_1_8_7    = RUBY_VERSION =~ /^1\.8\.7/
+
+  class << self
+    attr_accessor :use_full_backtrace
+
+    def file_mode(m) #:nodoc:
+      RUBY_1_9 ? "#{m}:UTF-8" : m
+    end
+  end
+  self.use_full_backtrace = false
+end
+end

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/py_support/py_dsl.py

@@ -0,0 +1,10 @@
+import py_language
+
+class Given(object):
+  def __init__(self, regexp):
+    self.regexp = regexp
+    
+  def __call__(self, f):
+    py_language.register_step_def(self.regexp, f)
+    return f
+  

data/bundler/ruby/1.8/gems/cucumber-0.9.4/lib/cucumber/py_support/py_language.py

@@ -0,0 +1,10 @@
+import py_dsl
+
+step_defs = {}
+
+def register_step_def(regexp, f):
+  print "Got a step def: ", regexp
+  step_defs[regexp] = f
+  
+def step_matches(step_name, name_to_report):
+  print "WTF: " + step_name

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

@@ -0,0 +1,84 @@
+require 'rubypython'
+
+module Cucumber
+  module PySupport
+    class PyLanguage
+      include LanguageSupport::LanguageMethods
+
+      def initialize(step_mother)
+        @step_def_files = []
+        #
+        # @python_path = ENV['PYTHONPATH'] ? ENV['PYTHONPATH'].split(':') : []
+        # add_to_python_path(File.dirname(__FILE__))
+        #
+        # RubyPython.start
+        # at_exit{RubyPython.stop}
+        #
+        # import(File.dirname(__FILE__) + '/py_language.py')
+      end
+
+      def load_code_file(py_file)
+        @step_def_files << py_file
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def step_definitions_for(py_file)
+        mod = import(py_file)
+      end
+
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        "python snippet: #{code_keyword}, #{step_name}"
+      end
+
+      def begin_scenario(scenario)
+        @python_path = []
+        add_to_python_path(File.dirname(__FILE__))
+        @step_def_files.each{|f| add_to_python_path(File.dirname(f))}
+
+        RubyPython.start
+
+        @delegate = import(File.dirname(__FILE__) + '/py_language.py')
+        @step_def_files.each{|f| import(f)}
+      end
+
+      def end_scenario
+      end
+
+      def step_matches(step_name, name_to_report)
+        @delegate.step_matches(step_name, name_to_report)
+      end
+
+      private
+
+      def import(path)
+        modname = File.basename(path)[0...-File.extname(path).length]
+        begin
+          mod = RubyPython.import(modname)
+        rescue PythonError => e
+#          e.message << "Couldn't load #{path}\nConsider adding #{File.expand_path(File.dirname(path))} to your PYTHONPATH"
+          raise e
+        end
+      end
+
+      def add_to_python_path(dir)
+        dir = File.expand_path(dir)
+        @python_path.unshift(dir)
+        @python_path.uniq!
+        ENV['PYTHONPATH'] = @python_path.join(':')
+      end
+    end
+  end
+end
+
+class String #:nodoc:
+  # RubyPython incorrectly to expects String#end_with? to exist.
+  unless defined? end_with? # 1.9
+    def end_with?(str) #:nodoc:
+      str = str.to_str
+      tail = self[-str.length, str.length]
+      tail == str
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+require 'cucumber/platform'
+
+module Cucumber
+  module Rake
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'. 
+    # It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
+    #
+    # To further configure the task, you can pass a block:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.cucumber_opts = %w{--format progress}
+    #   end
+    #
+    # This task can also be configured to be run with RCov:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.rcov = true
+    #   end
+    # 
+    # See the attributes for additional configuration possibilities.
+    class Task
+      class InProcessCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_opts, feature_files)
+          raise "libs must be an Array when running in-process" unless Array === libs
+          libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
+          @args = (
+            cucumber_opts + 
+            feature_files
+          ).flatten.compact
+        end
+        
+        def run
+          require 'cucumber/cli/main'
+          failure = Cucumber::Cli::Main.execute(args)
+          raise "Cucumber failed" if failure
+        end
+      end
+      
+      class ForkedCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            quoted_binary(cucumber_bin) + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+
+        def load_path(libs)
+          ['"%s"' % libs.join(File::PATH_SEPARATOR)]
+        end
+
+        def quoted_binary(cucumber_bin)
+          ['"%s"' % cucumber_bin]
+        end
+
+        def runner
+          File.exist?("./Gemfile") && Gem.available?("bundler") ? ["bundle", "exec", RUBY] : [RUBY]
+        end
+
+        def run
+          sh((runner + args).join(" "))
+        end
+      end
+
+      class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files, rcov_opts)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            ['-S', 'rcov'] + rcov_opts +
+            quoted_binary(cucumber_bin) + 
+            ['--'] + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+      end
+
+      LIB = File.expand_path(File.dirname(__FILE__) + '/../..') #:nodoc:
+
+      # Directories to add to the Ruby $LOAD_PATH
+      attr_accessor :libs
+
+      # Name of the cucumber binary to use for running features. Defaults to Cucumber::BINARY
+      attr_accessor :binary
+
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :cucumber_opts
+      def cucumber_opts=(opts) #:nodoc:
+        @cucumber_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Run cucumber with RCov? Defaults to false. If you set this to
+      # true, +fork+ is implicit.
+      attr_accessor :rcov
+
+      # Extra options to pass to rcov.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :rcov_opts
+      def rcov_opts=(opts) #:nodoc:
+        @rcov_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
+      # some startup speed if you set it to false, but this may also cause issues with
+      # your load path and gems.
+      attr_accessor :fork
+
+      # Define what profile to be used.  When used with cucumber_opts it is simply appended 
+      # to it. Will be ignored when CUCUMBER_OPTS is used.
+      attr_accessor :profile
+
+      # Define Cucumber Rake task
+      def initialize(task_name = "cucumber", desc = "Run Cucumber features")
+        @task_name, @desc = task_name, desc
+        @fork = true
+        @libs = ['lib']
+        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+
+        yield self if block_given?
+
+        @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
+        @libs.insert(0, LIB) if binary == Cucumber::BINARY
+
+        define_task
+      end
+
+      def define_task #:nodoc:
+        desc @desc
+        task @task_name do
+          runner.run
+        end
+      end
+
+      def runner(task_args = nil) #:nodoc:
+        cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
+        if(@rcov)
+          RCovCucumberRunner.new(libs, binary, cucumber_opts, feature_files, rcov_opts)
+        elsif(@fork)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files)
+        else
+          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
+        end
+      end
+
+      def cucumber_opts_with_profile #:nodoc:
+        @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
+      end
+
+      def feature_files #:nodoc:
+        make_command_line_safe(FileList[ ENV['FEATURE'] || [] ])
+      end
+
+      def make_command_line_safe(list)
+        list.map{|string| string.gsub(' ', '\ ')}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Cucumber
+  module RbSupport
+    # This module defines the methods you can use to define pure Ruby
+    # Step Definitions and Hooks. This module is mixed into the toplevel
+    # object.
+    module RbDsl
+      class << self
+        attr_writer :rb_language
+        
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        end
+
+        def build_rb_world_factory(world_modules, proc)
+          @rb_language.build_rb_world_factory(world_modules, proc)
+        end
+
+        def register_rb_hook(phase, tag_names, proc)
+          @rb_language.register_rb_hook(phase, tag_names, proc)
+        end
+
+        def register_rb_transform(regexp, proc)
+          @rb_language.register_rb_transform(regexp, proc)          
+        end
+
+        def register_rb_step_definition(regexp, proc)
+          @rb_language.register_rb_step_definition(regexp, proc)
+        end
+      end
+
+      # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+      # The +proc+ will be executed once before each scenario to create an
+      # Object that the scenario's steps will run within. Any +world_modules+
+      # will be mixed into this Object (via Object#extend).
+      #
+      # This method is typically called from one or more Ruby scripts under 
+      # <tt>features/support</tt>. You can call this method as many times as you 
+      # like (to register more modules), but if you try to register more than 
+      # one Proc you will get an error.
+      #
+      # Cucumber will not yield anything to the +proc+. Examples:
+      #
+      #    World do
+      #      MyClass.new
+      #    end
+      #
+      #    World(MyModule)
+      #
+      def World(*world_modules, &proc)
+        RbDsl.build_rb_world_factory(world_modules, proc)
+      end
+
+      # Registers a proc that will run before each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Before(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('before', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Scenario. You can register as many
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def After(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be wrapped around each scenario. The proc
+      # should accept two arguments: two arguments: the scenario and a "block"
+      # argument (but passed as a regular argument, since blocks cannot accept
+      # blocks in 1.8), on which it should call the .call method. You can register
+      # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Around(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('around', tag_expressions, proc)
+      end
+
+      # Registers a proc that will run after each Step. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def AfterStep(*tag_expressions, &proc)
+        RbDsl.register_rb_hook('after_step', tag_expressions, proc)
+      end
+
+      # Registers a proc that will be called with a step definition argument if it 
+      # matches the pattern passed as the first argument to Transform. Alternatively, if
+      # the pattern contains captures then they will be yielded as arguments to the
+      # provided proc. The return value of the proc is consequently yielded to the
+      # step definition.
+      def Transform(regexp, &proc)
+        RbDsl.register_rb_transform(regexp, proc)
+      end
+      
+      # Registers a proc that will run after Cucumber is configured. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      # TODO: Deprecate this
+      def AfterConfiguration(&proc)
+        RbDsl.register_rb_hook('after_configuration', [], proc)
+      end      
+
+      # Registers a new Ruby StepDefinition. This method is aliased
+      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
+      # also to the i18n translations whenever a feature of a
+      # new language is loaded.
+      #
+      # The +&proc+ gets executed in the context of a <tt>World</tt>
+      # object, which is defined by #World. A new <tt>World</tt>
+      # object is created for each scenario and is shared across
+      # step definitions within that scenario.
+      def register_rb_step_definition(regexp, &proc)
+        RbDsl.register_rb_step_definition(regexp, proc)
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

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

@@ -0,0 +1,18 @@
+module Cucumber
+  module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_reader :tag_expressions
+
+      def initialize(rb_language, tag_expressions, proc)
+        @rb_language = rb_language
+        @tag_expressions = tag_expressions
+        @proc = proc
+      end
+
+      def invoke(location, argument, &block)
+        @rb_language.current_world.cucumber_instance_exec(false, location, *[argument, block].compact, &@proc)
+      end
+    end
+  end
+end