vim-jar 0.0.2 → 0.0.3

data/bundler/ruby/1.8/gems/thor-0.14.6/lib/thor/shell/html.rb

@@ -0,0 +1,121 @@
+require 'thor/shell/basic'
+
+class Thor
+  module Shell
+    # Inherit from Thor::Shell::Basic and add set_color behavior. Check
+    # Thor::Shell::Basic to see all available methods.
+    #
+    class HTML < Basic
+      # The start of an HTML bold sequence.
+      BOLD       = "<strong>"
+      # The end of an HTML bold sequence.
+      END_BOLD   = "</strong>"
+
+      # Embed in a String to clear previous color selection.
+      CLEAR      = "</span>"
+
+      # Set the terminal's foreground HTML color to black.
+      BLACK      = '<span style="color: black;">'
+      # Set the terminal's foreground HTML color to red.
+      RED        = '<span style="color: red;">'
+      # Set the terminal's foreground HTML color to green.
+      GREEN      = '<span style="color: green;">'
+      # Set the terminal's foreground HTML color to yellow.
+      YELLOW     = '<span style="color: yellow;">'
+      # Set the terminal's foreground HTML color to blue.
+      BLUE       = '<span style="color: blue;">'
+      # Set the terminal's foreground HTML color to magenta.
+      MAGENTA    = '<span style="color: magenta;">'
+      # Set the terminal's foreground HTML color to cyan.
+      CYAN       = '<span style="color: cyan;">'
+      # Set the terminal's foreground HTML color to white.
+      WHITE      = '<span style="color: white;">'
+
+      # Set the terminal's background HTML color to black.
+      ON_BLACK   = '<span style="background-color: black">'
+      # Set the terminal's background HTML color to red.
+      ON_RED     = '<span style="background-color: red">'
+      # Set the terminal's background HTML color to green.
+      ON_GREEN   = '<span style="background-color: green">'
+      # Set the terminal's background HTML color to yellow.
+      ON_YELLOW  = '<span style="background-color: yellow">'
+      # Set the terminal's background HTML color to blue.
+      ON_BLUE    = '<span style="background-color: blue">'
+      # Set the terminal's background HTML color to magenta.
+      ON_MAGENTA = '<span style="background-color: magenta">'
+      # Set the terminal's background HTML color to cyan.
+      ON_CYAN    = '<span style="background-color: cyan">'
+      # Set the terminal's background HTML color to white.
+      ON_WHITE   = '<span style="background-color: white">'
+
+      # Set color by using a string or one of the defined constants. If a third
+      # option is set to true, it also adds bold to the string. This is based
+      # on Highline implementation and it automatically appends CLEAR to the end
+      # of the returned String.
+      #
+      def set_color(string, color, bold=false)
+        color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+        bold, end_bold = bold ? [BOLD, END_BOLD] : ['', '']
+        "#{bold}#{color}#{string}#{CLEAR}#{end_bold}"
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      # ask("What is your name?")
+      #
+      # TODO: Implement #ask for Thor::Shell::HTML
+      def ask(statement, color=nil)
+        raise NotImplementedError, "Implement #ask for Thor::Shell::HTML"
+      end
+
+      protected
+
+        # Overwrite show_diff to show diff with colors if Diff::LCS is
+        # available.
+        #
+        def show_diff(destination, content) #:nodoc:
+          if diff_lcs_loaded? && ENV['THOR_DIFF'].nil? && ENV['RAILS_DIFF'].nil?
+            actual  = File.binread(destination).to_s.split("\n")
+            content = content.to_s.split("\n")
+
+            Diff::LCS.sdiff(actual, content).each do |diff|
+              output_diff_line(diff)
+            end
+          else
+            super
+          end
+        end
+
+        def output_diff_line(diff) #:nodoc:
+          case diff.action
+            when '-'
+              say "- #{diff.old_element.chomp}", :red, true
+            when '+'
+              say "+ #{diff.new_element.chomp}", :green, true
+            when '!'
+              say "- #{diff.old_element.chomp}", :red, true
+              say "+ #{diff.new_element.chomp}", :green, true
+            else
+              say "  #{diff.old_element.chomp}", nil, true
+          end
+        end
+
+        # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+        # for diff.
+        #
+        def diff_lcs_loaded? #:nodoc:
+          return true  if defined?(Diff::LCS)
+          return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
+
+          @diff_lcs_loaded = begin
+            require 'diff/lcs'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+    end
+  end
+end

data/bundler/ruby/1.8/gems/thor-0.14.6/lib/thor/shell.rb

@@ -0,0 +1,88 @@
+require 'rbconfig'
+
+class Thor
+  module Base
+    # Returns the shell used in all Thor classes. If you are in a Unix platform
+    # it will use a colored log, otherwise it will use a basic one without color.
+    #
+    def self.shell
+      @shell ||= if ENV['THOR_SHELL'] && ENV['THOR_SHELL'].size > 0
+        Thor::Shell.const_get(ENV['THOR_SHELL'])
+      elsif RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+        Thor::Shell::Basic
+      else
+        Thor::Shell::Color
+      end
+    end
+
+    # Sets the shell used in all Thor classes.
+    #
+    def self.shell=(klass)
+      @shell = klass
+    end
+  end
+
+  module Shell
+    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_table]
+
+    autoload :Basic, 'thor/shell/basic'
+    autoload :Color, 'thor/shell/color'
+    autoload :HTML,  'thor/shell/html'
+
+    # Add shell to initialize config values.
+    #
+    # ==== Configuration
+    # shell<Object>:: An instance of the shell to be used.
+    #
+    # ==== Examples
+    #
+    #   class MyScript < Thor
+    #     argument :first, :type => :numeric
+    #   end
+    #
+    #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+    #
+    def initialize(args=[], options={}, config={})
+      super
+      self.shell = config[:shell]
+      self.shell.base ||= self if self.shell.respond_to?(:base)
+    end
+
+    # Holds the shell for the given Thor instance. If no shell is given,
+    # it gets a default shell from Thor::Base.shell.
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    # Sets the shell for this thor class.
+    def shell=(shell)
+      @shell = shell
+    end
+
+    # Common methods that are delegated to the shell.
+    SHELL_DELEGATED_METHODS.each do |method|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{method}(*args)
+          shell.#{method}(*args)
+        end
+      METHOD
+    end
+
+    # Yields the given block with padding.
+    def with_padding
+      shell.padding += 1
+      yield
+    ensure
+      shell.padding -= 1
+    end
+
+    protected
+
+      # Allow shell to be shared between invocations.
+      #
+      def _shared_configuration #:nodoc:
+        super.merge!(:shell => self.shell)
+      end
+
+  end
+end

data/bundler/ruby/1.8/gems/thor-0.14.6/lib/thor/task.rb

@@ -0,0 +1,114 @@
+class Thor
+  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
+    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
+
+    def initialize(name, description, long_description, usage, options=nil)
+      super(name.to_s, description, long_description, usage, options || {})
+    end
+
+    def initialize_copy(other) #:nodoc:
+      super(other)
+      self.options = other.options.dup if other.options
+    end
+
+    def hidden?
+      false
+    end
+
+    # By default, a task invokes a method in the thor class. You can change this
+    # implementation to create custom tasks.
+    def run(instance, args=[])
+      public_method?(instance) ?
+        instance.send(name, *args) : instance.class.handle_no_task_error(name)
+    rescue ArgumentError => e
+      handle_argument_error?(instance, e, caller) ?
+        instance.class.handle_argument_error(self, e) : (raise e)
+    rescue NoMethodError => e
+      handle_no_method_error?(instance, e, caller) ?
+        instance.class.handle_no_task_error(name) : (raise e)
+    end
+
+    # Returns the formatted usage by injecting given required arguments
+    # and required options into the given usage.
+    def formatted_usage(klass, namespace = true, subcommand = false)
+      if namespace
+        namespace = klass.namespace
+        formatted = "#{namespace.gsub(/^(default)/,'')}:"
+        formatted.sub!(/.$/, ' ') if subcommand
+      end
+
+      formatted ||= ""
+
+      # Add usage with required arguments
+      formatted << if klass && !klass.arguments.empty?
+        usage.to_s.gsub(/^#{name}/) do |match|
+          match << " " << klass.arguments.map{ |a| a.usage }.compact.join(' ')
+        end
+      else
+        usage.to_s
+      end
+
+      # Add required options
+      formatted << " #{required_options}"
+
+      # Strip and go!
+      formatted.strip
+    end
+
+  protected
+
+    def not_debugging?(instance)
+      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
+    end
+
+    def required_options
+      @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
+    end
+
+    # Given a target, checks if this class name is not a private/protected method.
+    def public_method?(instance) #:nodoc:
+      collection = instance.private_methods + instance.protected_methods
+      (collection & [name.to_s, name.to_sym]).empty?
+    end
+
+    def sans_backtrace(backtrace, caller) #:nodoc:
+      saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP }
+      saned -= caller
+    end
+
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && error.message =~ /wrong number of arguments/ && begin
+        saned = sans_backtrace(error.backtrace, caller)
+        # Ruby 1.9 always include the called method in the backtrace
+        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
+      end
+    end
+
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) &&
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
+    end
+  end
+
+  # A task that is hidden in help messages but still invocable.
+  class HiddenTask < Task
+    def hidden?
+      true
+    end
+  end
+
+  # A dynamic task that handles method missing scenarios.
+  class DynamicTask < Task
+    def initialize(name, options=nil)
+      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
+    end
+
+    def run(instance, args=[])
+      if (instance.methods & [name.to_s, name.to_sym]).empty?
+        super
+      else
+        instance.class.handle_no_task_error(name)
+      end
+    end
+  end
+end

data/bundler/ruby/1.8/gems/thor-0.14.6/lib/thor/util.rb

@@ -0,0 +1,229 @@
+require 'rbconfig'
+
+class Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Utils.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Thor::Utils.load_thorfile("~/.thor/foo")
+  #
+  module Util
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    #
+    def self.find_by_namespace(namespace)
+      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
+    end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor tasks
+    # can be added to a sandbox, this method is also responsable for removing
+    # the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    #
+    def self.namespace_from_thor_class(constant)
+      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+      constant = snake_case(constant).squeeze(":")
+      constant
+    end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    def self.namespaces_in_content(contents, file=__FILE__)
+      old_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.clear
+
+      load_thorfile(file, contents)
+
+      new_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.replace(old_constants)
+
+      new_constants.map!{ |c| c.namespace }
+      new_constants.compact!
+      new_constants
+    end
+
+    # Returns the thor classes declared inside the given class.
+    #
+    def self.thor_classes_in(klass)
+      stringfied_constants = klass.constants.map { |c| c.to_s }
+      Thor::Base.subclasses.select do |subclass|
+        next unless subclass.name
+        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+      end
+    end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end
+
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+      str.split('_').map { |i| i.capitalize }.join
+    end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default task
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    def self.find_class_and_task_by_namespace(namespace, fallback = true)
+      if namespace.include?(?:) # look for a namespaced task
+        pieces = namespace.split(":")
+        task   = pieces.pop
+        klass  = Thor::Util.find_by_namespace(pieces.join(":"))
+      end
+      unless klass # look for a Thor::Group with the right name
+        klass, task = Thor::Util.find_by_namespace(namespace), nil
+      end
+      if !klass && fallback # try a task in the default namespace
+        task = namespace
+        klass = Thor::Util.find_by_namespace('')
+      end
+      return klass, task
+    end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    #
+    def self.load_thorfile(path, content=nil, debug=false)
+      content ||= File.binread(path)
+
+      begin
+        Thor::Sandbox.class_eval(content, path)
+      rescue Exception => e
+        $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+        if debug
+          $stderr.puts *e.backtrace
+        else
+          $stderr.puts e.backtrace.first
+        end
+      end
+    end
+
+    def self.user_home
+      @@user_home ||= if ENV["HOME"]
+        ENV["HOME"]
+      elsif ENV["USERPROFILE"]
+        ENV["USERPROFILE"]
+      elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
+      elsif ENV["APPDATA"]
+        ENV["APPDATA"]
+      else
+        begin
+          File.expand_path("~")
+        rescue
+          if File::ALT_SEPARATOR
+            "C:/"
+          else
+            "/"
+          end
+        end
+      end
+    end
+
+    # Returns the root where thor files are located, dependending on the OS.
+    #
+    def self.thor_root
+      File.join(user_home, ".thor").gsub(/\\/, '/')
+    end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    #
+    def self.thor_root_glob
+      files = Dir["#{thor_root}/*"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
+      end
+    end
+
+    # Where to look for Thor files.
+    #
+    def self.globs_for(path)
+      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+    end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    def self.ruby_command
+      @ruby_command ||= begin
+        ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+        ruby << RbConfig::CONFIG['EXEEXT']
+
+        # escape string in case path to ruby executable contain spaces.
+        ruby.sub!(/.*\s.*/m, '"\&"')
+        ruby
+      end
+    end
+
+  end
+end

data/bundler/ruby/1.8/gems/thor-0.14.6/lib/thor/version.rb

@@ -0,0 +1,3 @@
+class Thor
+  VERSION = "0.14.6".freeze
+end