acquia_toolbelt 2.0.1 → 2.1.0

data/lib/vendor/thor/lib/thor/parser/options.rb

@@ -1,218 +0,0 @@
-class Thor
-  class Options < Arguments #:nodoc:
-    LONG_RE     = /^(--\w+(?:-\w+)*)$/
-    SHORT_RE    = /^(-[a-z])$/i
-    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
-    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
-    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
-    OPTS_END    = '--'.freeze
-
-    # Receives a hash and makes it switches.
-    def self.to_switches(options)
-      options.map do |key, value|
-        case value
-        when true
-          "--#{key}"
-        when Array
-          "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
-        when Hash
-          "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
-        when nil, false
-          ""
-        else
-          "--#{key} #{value.inspect}"
-        end
-      end.join(" ")
-    end
-
-    # Takes a hash of Thor::Option and a hash with defaults.
-    #
-    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
-    # an unknown option or a regular argument.
-    def initialize(hash_options={}, defaults={}, stop_on_unknown=false)
-      @stop_on_unknown = stop_on_unknown
-      options = hash_options.values
-      super(options)
-
-      # Add defaults
-      defaults.each do |key, value|
-        @assigns[key.to_s] = value
-        @non_assigned_required.delete(hash_options[key])
-      end
-
-      @shorts, @switches, @extra = {}, {}, []
-
-      options.each do |option|
-        @switches[option.switch_name] = option
-
-        option.aliases.each do |short|
-          name = short.to_s.sub(/^(?!\-)/, '-')
-          @shorts[name] ||= option.switch_name
-        end
-      end
-    end
-
-    def remaining
-      @extra
-    end
-
-    def peek
-      return super unless @parsing_options
-
-      result = super
-      if result == OPTS_END
-        shift
-        @parsing_options = false
-        super
-      else
-        result
-      end
-    end
-
-    def parse(args)
-      @pile = args.dup
-      @parsing_options = true
-
-      while peek
-        if parsing_options?
-          match, is_switch = current_is_switch?
-          shifted = shift
-
-          if is_switch
-            case shifted
-            when SHORT_SQ_RE
-              unshift($1.split('').map { |f| "-#{f}" })
-              next
-            when EQ_RE, SHORT_NUM
-              unshift($2)
-              switch = $1
-            when LONG_RE, SHORT_RE
-              switch = $1
-            end
-
-            switch = normalize_switch(switch)
-            option = switch_option(switch)
-            @assigns[option.human_name] = parse_peek(switch, option)
-          elsif @stop_on_unknown
-            @parsing_options = false
-            @extra << shifted
-            @extra << shift while peek
-            break
-          elsif match
-            @extra << shifted
-            @extra << shift while peek && peek !~ /^-/
-          else
-            @extra << shifted
-          end
-        else
-          @extra << shift
-        end
-      end
-
-      check_requirement!
-
-      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
-      assigns.freeze
-      assigns
-    end
-
-    def check_unknown!
-      # an unknown option starts with - or -- and has no more --'s afterward.
-      unknown = @extra.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
-    end
-
-    protected
-
-      # Check if the current value in peek is a registered switch.
-      #
-      # Two booleans are returned.  The first is true if the current value
-      # starts with a hyphen; the second is true if it is a registered switch.
-      def current_is_switch?
-        case peek
-        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-          [true, switch?($1)]
-        when SHORT_SQ_RE
-          [true, $1.split('').any? { |f| switch?("-#{f}") }]
-        else
-          [false, false]
-        end
-      end
-
-      def current_is_switch_formatted?
-        case peek
-        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
-          true
-        else
-          false
-        end
-      end
-
-      def current_is_value?
-        peek && (!parsing_options? || super)
-      end
-
-      def switch?(arg)
-        switch_option(normalize_switch(arg))
-      end
-
-      def switch_option(arg)
-        if match = no_or_skip?(arg)
-          @switches[arg] || @switches["--#{match}"]
-        else
-          @switches[arg]
-        end
-      end
-
-      # Check if the given argument is actually a shortcut.
-      #
-      def normalize_switch(arg)
-        (@shorts[arg] || arg).tr('_', '-')
-      end
-
-      def parsing_options?
-        peek
-        @parsing_options
-      end
-
-      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
-      #
-      def parse_boolean(switch)
-        if current_is_value?
-          if ["true", "TRUE", "t", "T", true].include?(peek)
-            shift
-            true
-          elsif ["false", "FALSE", "f", "F", false].include?(peek)
-            shift
-            false
-          else
-            true
-          end
-        else
-          @switches.key?(switch) || !no_or_skip?(switch)
-        end
-      end
-
-      # Parse the value at the peek analyzing if it requires an input or not.
-      #
-      def parse_peek(switch, option)
-        if parsing_options? && (current_is_switch_formatted? || last?)
-          if option.boolean?
-            # No problem for boolean types
-          elsif no_or_skip?(switch)
-            return nil # User set value to nil
-          elsif option.string? && !option.required?
-            # Return the default if there is one, else the human name
-            return option.lazy_default || option.default || option.human_name
-          elsif option.lazy_default
-            return option.lazy_default
-          else
-            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
-          end
-        end
-
-        @non_assigned_required.delete(option)
-        send(:"parse_#{option.type}", switch)
-      end
-  end
-end

data/lib/vendor/thor/lib/thor/rake_compat.rb

@@ -1,72 +0,0 @@
-require 'rake'
-require 'rake/dsl_definition'
-
-class Thor
-  # Adds a compatibility layer to your Thor classes which allows you to use
-  # rake package tasks. For example, to use rspec rake tasks, one can do:
-  #
-  #   require 'thor/rake_compat'
-  #   require 'rspec/core/rake_task'
-  #
-  #   class Default < Thor
-  #     include Thor::RakeCompat
-  #
-  #     RSpec::Core::RakeTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', "./.rspec"]
-  #       t.spec_files = FileList['spec/**/*_spec.rb']
-  #     end
-  #   end
-  #
-  module RakeCompat
-    include Rake::DSL if defined?(Rake::DSL)
-
-    def self.rake_classes
-      @rake_classes ||= []
-    end
-
-    def self.included(base)
-      # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
-      rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
-      Rake.application.instance_variable_set(:@rakefile, rakefile)
-      self.rake_classes << base
-    end
-  end
-end
-
-# override task on (main), for compatibility with Rake 0.9
-self.instance_eval do
-  alias rake_namespace namespace
-
-  def task(*)
-    task = super
-
-    if klass = Thor::RakeCompat.rake_classes.last
-      non_namespaced_name = task.name.split(':').last
-
-      description = non_namespaced_name
-      description << task.arg_names.map{ |n| n.to_s.upcase }.join(' ')
-      description.strip!
-
-      klass.desc description, Rake.application.last_description || non_namespaced_name
-      Rake.application.last_description = nil
-      klass.send :define_method, non_namespaced_name do |*args|
-        Rake::Task[task.name.to_sym].invoke(*args)
-      end
-    end
-
-    task
-  end
-
-  def namespace(name)
-    if klass = Thor::RakeCompat.rake_classes.last
-      const_name = Thor::Util.camel_case(name.to_s).to_sym
-      klass.const_set(const_name, Class.new(Thor))
-      new_klass = klass.const_get(const_name)
-      Thor::RakeCompat.rake_classes << new_klass
-    end
-
-    super
-    Thor::RakeCompat.rake_classes.pop
-  end
-end
-

data/lib/vendor/thor/lib/thor/runner.rb

@@ -1,322 +0,0 @@
-require 'thor'
-require 'thor/group'
-require 'thor/core_ext/io_binary_read'
-
-require 'fileutils'
-require 'open-uri'
-require 'yaml'
-require 'digest/md5'
-require 'pathname'
-
-class Thor::Runner < Thor #:nodoc:
-  map "-T" => :list, "-i" => :install, "-u" => :update, "-v" => :version
-
-  # Override Thor#help so it can give information about any class and any method.
-  #
-  def help(meth = nil)
-    if meth && !self.respond_to?(meth)
-      initialize_thorfiles(meth)
-      klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
-      self.class.handle_no_command_error(command, false) if klass.nil?
-      klass.start(["-h", command].compact, :shell => self.shell)
-    else
-      super
-    end
-  end
-
-  # If a command is not found on Thor::Runner, method missing is invoked and
-  # Thor::Runner is then responsible for finding the command in all classes.
-  #
-  def method_missing(meth, *args)
-    meth = meth.to_s
-    initialize_thorfiles(meth)
-    klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
-    self.class.handle_no_command_error(command, false) if klass.nil?
-    args.unshift(command) if command
-    klass.start(args, :shell => self.shell)
-  end
-
-  desc "install NAME", "Install an optionally named Thor file into your system commands"
-  method_options :as => :string, :relative => :boolean, :force => :boolean
-  def install(name)
-    initialize_thorfiles
-
-    # If a directory name is provided as the argument, look for a 'main.thor'
-    # command in said directory.
-    begin
-      if File.directory?(File.expand_path(name))
-        base, package = File.join(name, "main.thor"), :directory
-        contents      = open(base) {|input| input.read }
-      else
-        base, package = name, :file
-        contents      = open(name) {|input| input.read }
-      end
-    rescue OpenURI::HTTPError
-      raise Error, "Error opening URI '#{name}'"
-    rescue Errno::ENOENT
-      raise Error, "Error opening file '#{name}'"
-    end
-
-    say "Your Thorfile contains:"
-    say contents
-
-    unless options["force"]
-      return false if no?("Do you wish to continue [y/N]?")
-    end
-
-    as = options["as"] || begin
-      first_line = contents.split("\n")[0]
-      (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
-    end
-
-    unless as
-      basename = File.basename(name)
-      as = ask("Please specify a name for #{name} in the system repository [#{basename}]:")
-      as = basename if as.empty?
-    end
-
-    location = if options[:relative] || name =~ /^https?:\/\//
-      name
-    else
-      File.expand_path(name)
-    end
-
-    thor_yaml[as] = {
-      :filename   => Digest::MD5.hexdigest(name + as),
-      :location   => location,
-      :namespaces => Thor::Util.namespaces_in_content(contents, base)
-    }
-
-    save_yaml(thor_yaml)
-    say "Storing thor file in your system repository"
-    destination = File.join(thor_root, thor_yaml[as][:filename])
-
-    if package == :file
-      File.open(destination, "w") { |f| f.puts contents }
-    else
-      FileUtils.cp_r(name, destination)
-    end
-
-    thor_yaml[as][:filename] # Indicate success
-  end
-
-  desc "version", "Show Thor version"
-  def version
-    require 'thor/version'
-    say "Thor #{Thor::VERSION}"
-  end
-
-  desc "uninstall NAME", "Uninstall a named Thor module"
-  def uninstall(name)
-    raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
-    say "Uninstalling #{name}."
-    FileUtils.rm_rf(File.join(thor_root, "#{thor_yaml[name][:filename]}"))
-
-    thor_yaml.delete(name)
-    save_yaml(thor_yaml)
-
-    puts "Done."
-  end
-
-  desc "update NAME", "Update a Thor file from its original location"
-  def update(name)
-    raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
-
-    say "Updating '#{name}' from #{thor_yaml[name][:location]}"
-
-    old_filename = thor_yaml[name][:filename]
-    self.options = self.options.merge("as" => name)
-
-    if File.directory? File.expand_path(name)
-      FileUtils.rm_rf(File.join(thor_root, old_filename))
-
-      thor_yaml.delete(old_filename)
-      save_yaml(thor_yaml)
-
-      filename = install(name)
-    else
-      filename = install(thor_yaml[name][:location])
-    end
-
-    unless filename == old_filename
-      File.delete(File.join(thor_root, old_filename))
-    end
-  end
-
-  desc "installed", "List the installed Thor modules and commands"
-  method_options :internal => :boolean
-  def installed
-    initialize_thorfiles(nil, true)
-    display_klasses(true, options["internal"])
-  end
-
-  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
-  method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
-  def list(search="")
-    initialize_thorfiles
-
-    search = ".*#{search}" if options["substring"]
-    search = /^#{search}.*/i
-    group  = options[:group] || "standard"
-
-    klasses = Thor::Base.subclasses.select do |k|
-      (options[:all] || k.group == group) && k.namespace =~ search
-    end
-
-    display_klasses(false, false, klasses)
-  end
-
-  private
-
-    def self.banner(command, all = false, subcommand = false)
-      "thor " + command.formatted_usage(self, all, subcommand)
-    end
-
-    def thor_root
-      Thor::Util.thor_root
-    end
-
-    def thor_yaml
-      @thor_yaml ||= begin
-        yaml_file = File.join(thor_root, "thor.yml")
-        yaml = YAML.load_file(yaml_file) if File.exists?(yaml_file)
-        yaml || {}
-      end
-    end
-
-    # Save the yaml file. If none exists in thor root, creates one.
-    #
-    def save_yaml(yaml)
-      yaml_file = File.join(thor_root, "thor.yml")
-
-      unless File.exists?(yaml_file)
-        FileUtils.mkdir_p(thor_root)
-        yaml_file = File.join(thor_root, "thor.yml")
-        FileUtils.touch(yaml_file)
-      end
-
-      File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
-    end
-
-    def self.exit_on_failure?
-      true
-    end
-
-    # Load the Thorfiles. If relevant_to is supplied, looks for specific files
-    # in the thor_root instead of loading them all.
-    #
-    # By default, it also traverses the current path until find Thor files, as
-    # described in thorfiles. This look up can be skipped by supplying
-    # skip_lookup true.
-    #
-    def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
-      thorfiles(relevant_to, skip_lookup).each do |f|
-        Thor::Util.load_thorfile(f, nil, options[:debug]) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
-      end
-    end
-
-    # Finds Thorfiles by traversing from your current directory down to the root
-    # directory of your system. If at any time we find a Thor file, we stop.
-    #
-    # We also ensure that system-wide Thorfiles are loaded first, so local
-    # Thorfiles can override them.
-    #
-    # ==== Example
-    #
-    # If we start at /Users/wycats/dev/thor ...
-    #
-    # 1. /Users/wycats/dev/thor
-    # 2. /Users/wycats/dev
-    # 3. /Users/wycats <-- we find a Thorfile here, so we stop
-    #
-    # Suppose we start at c:\Documents and Settings\james\dev\thor ...
-    #
-    # 1. c:\Documents and Settings\james\dev\thor
-    # 2. c:\Documents and Settings\james\dev
-    # 3. c:\Documents and Settings\james
-    # 4. c:\Documents and Settings
-    # 5. c:\ <-- no Thorfiles found!
-    #
-    def thorfiles(relevant_to=nil, skip_lookup=false)
-      thorfiles = []
-
-      unless skip_lookup
-        Pathname.pwd.ascend do |path|
-          thorfiles = Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
-          break unless thorfiles.empty?
-        end
-      end
-
-      files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Thor::Util.thor_root_glob)
-      files += thorfiles
-      files -= ["#{thor_root}/thor.yml"]
-
-      files.map! do |file|
-        File.directory?(file) ? File.join(file, "main.thor") : file
-      end
-    end
-
-    # Load Thorfiles relevant to the given method. If you provide "foo:bar" it
-    # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
-    # namespaces registered.
-    #
-    def thorfiles_relevant_to(meth)
-      lookup = [ meth, meth.split(":")[0...-1].join(":") ]
-
-      files = thor_yaml.select do |k, v|
-        v[:namespaces] && !(v[:namespaces] & lookup).empty?
-      end
-
-      files.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
-    end
-
-    # Display information about the given klasses. If with_module is given,
-    # it shows a table with information extracted from the yaml file.
-    #
-    def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
-      klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
-
-      raise Error, "No Thor commands available" if klasses.empty?
-      show_modules if with_modules && !thor_yaml.empty?
-
-      list = Hash.new { |h,k| h[k] = [] }
-      groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
-
-      # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
-
-      # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_commands(false).first }
-      list["root"] = groups
-
-      # Order namespaces with default coming first
-      list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
-    end
-
-    def display_commands(namespace, list) #:nodoc:
-      list.sort!{ |a,b| a[0] <=> b[0] }
-
-      say shell.set_color(namespace, :blue, true)
-      say "-" * namespace.size
-
-      print_table(list, :truncate => true)
-      say
-    end
-    alias display_tasks display_commands
-
-    def show_modules #:nodoc:
-      info  = []
-      labels = ["Modules", "Namespaces"]
-
-      info << labels
-      info << [ "-" * labels[0].size, "-" * labels[1].size ]
-
-      thor_yaml.each do |name, hash|
-        info << [ name, hash[:namespaces].join(", ") ]
-      end
-
-      print_table info
-      say ""
-    end
-end