engineyard 2.0.0.pre1 → 2.0.0.pre2

data/lib/vendor/thor/LICENSE.md

@@ -1,20 +0,0 @@
-Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/vendor/thor/README.md

@@ -1,26 +0,0 @@
-Thor
-====
-
-Description
------------
-Thor is a simple and efficient tool for building self-documenting command line
-utilities.  It removes the pain of parsing command line options, writing
-"USAGE:" banners, and can also be used as an alternative to the [Rake][rake]
-build tool.  The syntax is Rake-like, so it should be familiar to most Rake
-users.
-
-[rake]: https://github.com/jimweirich/rake
-
-Installation
-------------
-    gem install thor
-
-Usage and documentation
------------------------
-Please see [the wiki](https://github.com/wycats/thor/wiki) for basic usage and other documentation on using Thor.
-
-License
--------
-Released under the MIT License.  See the [LICENSE][license] file for further details.
-
-[license]: https://github.com/wycats/thor/blob/master/LICENSE.md

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

@@ -1,379 +0,0 @@
-require 'thor/base'
-
-class Thor
-  class << self
-    # Sets the default task when thor is executed without an explicit task to be called.
-    #
-    # ==== Parameters
-    # meth<Symbol>:: name of the default task
-    #
-    def default_task(meth=nil)
-      case meth
-        when :none
-          @default_task = 'help'
-        when nil
-          @default_task ||= from_superclass(:default_task, 'help')
-        else
-          @default_task = meth.to_s
-      end
-    end
-
-    # Registers another Thor subclass as a command.
-    #
-    # ==== Parameters
-    # klass<Class>:: Thor subclass to register
-    # command<String>:: Subcommand name to use
-    # usage<String>:: Short usage for the subcommand
-    # description<String>:: Description for the subcommand
-    def register(klass, subcommand_name, usage, description, options={})
-      if klass <= Thor::Group
-        desc usage, description, options
-        define_method(subcommand_name) { |*args| invoke(klass, args) }
-      else
-        desc usage, description, options
-        subcommand subcommand_name, klass
-      end
-    end
-
-    # Defines the usage and the description of the next task.
-    #
-    # ==== Parameters
-    # usage<String>
-    # description<String>
-    # options<String>
-    #
-    def desc(usage, description, options={})
-      if options[:for]
-        task = find_and_refresh_task(options[:for])
-        task.usage = usage             if usage
-        task.description = description if description
-      else
-        @usage, @desc, @hide = usage, description, options[:hide] || false
-      end
-    end
-
-    # Defines the long description of the next task.
-    #
-    # ==== Parameters
-    # long description<String>
-    #
-    def long_desc(long_description, options={})
-      if options[:for]
-        task = find_and_refresh_task(options[:for])
-        task.long_description = long_description if long_description
-      else
-        @long_desc = long_description
-      end
-    end
-
-    # Maps an input to a task. If you define:
-    #
-    #   map "-T" => "list"
-    #
-    # Running:
-    #
-    #   thor -T
-    #
-    # Will invoke the list task.
-    #
-    # ==== Parameters
-    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
-    #
-    def map(mappings=nil)
-      @map ||= from_superclass(:map, {})
-
-      if mappings
-        mappings.each do |key, value|
-          if key.respond_to?(:each)
-            key.each {|subkey| @map[subkey] = value}
-          else
-            @map[key] = value
-          end
-        end
-      end
-
-      @map
-    end
-
-    # Declares the options for the next task to be declared.
-    #
-    # ==== Parameters
-    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
-    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
-    # or :required (string). If you give a value, the type of the value is used.
-    #
-    def method_options(options=nil)
-      @method_options ||= {}
-      build_options(options, @method_options) if options
-      @method_options
-    end
-
-    alias options method_options
-
-    # Adds an option to the set of method options. If :for is given as option,
-    # it allows you to change the options from a previous defined task.
-    #
-    #   def previous_task
-    #     # magic
-    #   end
-    #
-    #   method_option :foo => :bar, :for => :previous_task
-    #
-    #   def next_task
-    #     # magic
-    #   end
-    #
-    # ==== Parameters
-    # name<Symbol>:: The name of the argument.
-    # options<Hash>:: Described below.
-    #
-    # ==== Options
-    # :desc     - Description for the argument.
-    # :required - If the argument is required or not.
-    # :default  - Default value for this argument. It cannot be required and have default values.
-    # :aliases  - Aliases for this option.
-    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
-    # :banner   - String to show on usage notes.
-    # :hide     - If you want to hide this option from the help.
-    #
-    def method_option(name, options={})
-      scope = if options[:for]
-        find_and_refresh_task(options[:for]).options
-      else
-        method_options
-      end
-
-      build_option(name, options, scope)
-    end
-
-    alias option method_option
-
-    # Prints help information for the given task.
-    #
-    # ==== Parameters
-    # shell<Thor::Shell>
-    # task_name<String>
-    #
-    def task_help(shell, task_name)
-      meth = normalize_task_name(task_name)
-      task = all_tasks[meth]
-      handle_no_task_error(meth) unless task
-
-      shell.say "Usage:"
-      shell.say "  #{banner(task)}"
-      shell.say
-      class_options_help(shell, nil => task.options.map { |_, o| o })
-      if task.long_description
-        shell.say "Description:"
-        shell.print_wrapped(task.long_description, :indent => 2)
-      else
-        shell.say task.description
-      end
-    end
-
-    # Prints help information for this class.
-    #
-    # ==== Parameters
-    # shell<Thor::Shell>
-    #
-    def help(shell, subcommand = false)
-      list = printable_tasks(true, subcommand)
-      Thor::Util.thor_classes_in(self).each do |klass|
-        list += klass.printable_tasks(false)
-      end
-      list.sort!{ |a,b| a[0] <=> b[0] }
-
-      shell.say "Tasks:"
-      shell.print_table(list, :indent => 2, :truncate => true)
-      shell.say
-      class_options_help(shell)
-    end
-
-    # Returns tasks ready to be printed.
-    def printable_tasks(all = true, subcommand = false)
-      (all ? all_tasks : tasks).map do |_, task|
-        next if task.hidden?
-        item = []
-        item << banner(task, false, subcommand)
-        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
-        item
-      end.compact
-    end
-
-    def subcommands
-      @subcommands ||= from_superclass(:subcommands, [])
-    end
-
-    def subcommand(subcommand, subcommand_class)
-      self.subcommands << subcommand.to_s
-      subcommand_class.subcommand_help subcommand
-
-      define_method(subcommand) do |*args|
-        args, opts = Thor::Arguments.split(args)
-        invoke subcommand_class, args, opts
-      end
-    end
-
-    # Extend check unknown options to accept a hash of conditions.
-    #
-    # === Parameters
-    # options<Hash>: A hash containing :only and/or :except keys
-    def check_unknown_options!(options={})
-      @check_unknown_options ||= Hash.new
-      options.each do |key, value|
-        if value
-          @check_unknown_options[key] = Array(value)
-        else
-          @check_unknown_options.delete(key)
-        end
-      end
-      @check_unknown_options
-    end
-
-    # Overwrite check_unknown_options? to take subcommands and options into account.
-    def check_unknown_options?(config) #:nodoc:
-      options = check_unknown_options
-      return false unless options
-
-      task = config[:current_task]
-      return true unless task
-
-      name = task.name
-
-      if subcommands.include?(name)
-        false
-      elsif options[:except]
-        !options[:except].include?(name.to_sym)
-      elsif options[:only]
-        options[:only].include?(name.to_sym)
-      else
-        true
-      end
-    end
-
-    protected
-
-      # The method responsible for dispatching given the args.
-      def dispatch(meth, given_args, given_opts, config) #:nodoc:
-        meth ||= retrieve_task_name(given_args)
-        task = all_tasks[normalize_task_name(meth)]
-
-        if task
-          args, opts = Thor::Options.split(given_args)
-        else
-          args, opts = given_args, nil
-          task = Thor::DynamicTask.new(meth)
-        end
-
-        opts = given_opts || opts || []
-        config.merge!(:current_task => task, :task_options => task.options)
-
-        instance = new(args, opts, config)
-        yield instance if block_given?
-        args = instance.args
-        trailing = args[Range.new(arguments.size, -1)]
-        instance.invoke_task(task, trailing || [])
-      end
-
-      # The banner for this class. You can customize it if you are invoking the
-      # thor class by another ways which is not the Thor::Runner. It receives
-      # the task that is going to be invoked and a boolean which indicates if
-      # the namespace should be displayed as arguments.
-      #
-      def banner(task, namespace = nil, subcommand = false)
-        "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
-      end
-
-      def baseclass #:nodoc:
-        Thor
-      end
-
-      def create_task(meth) #:nodoc:
-        if @usage && @desc
-          base_class = @hide ? Thor::HiddenTask : Thor::Task
-          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
-          @usage, @desc, @long_desc, @method_options, @hide = nil
-          true
-        elsif self.all_tasks[meth] || meth == "method_missing"
-          true
-        else
-          puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
-               "Call desc if you want this method to be available as task or declare it inside a " <<
-               "no_tasks{} block. Invoked from #{caller[1].inspect}."
-          false
-        end
-      end
-
-      def initialize_added #:nodoc:
-        class_options.merge!(method_options)
-        @method_options = nil
-      end
-
-      # Retrieve the task name from given args.
-      def retrieve_task_name(args) #:nodoc:
-        meth = args.first.to_s unless args.empty?
-        if meth && (map[meth] || meth !~ /^\-/)
-          args.shift
-        else
-          nil
-        end
-      end
-
-      # receives a (possibly nil) task name and returns a name that is in
-      # the tasks hash. In addition to normalizing aliases, this logic
-      # will determine if a shortened command is an unambiguous prefix of
-      # a task or alias.
-      #
-      # +normalize_task_name+ also converts names like +animal-prison+
-      # into +animal_prison+.
-      def normalize_task_name(meth) #:nodoc:
-        return default_task.to_s.gsub('-', '_') unless meth
-
-        possibilities = find_task_possibilities(meth)
-        if possibilities.size > 1
-          raise ArgumentError, "Ambiguous task #{meth} matches [#{possibilities.join(', ')}]"
-        elsif possibilities.size < 1
-          meth = meth || default_task
-        elsif map[meth]
-          meth = map[meth]
-        else
-          meth = possibilities.first
-        end
-
-        meth.to_s.gsub('-','_') # treat foo-bar as foo_bar
-      end
-
-      # this is the logic that takes the task name passed in by the user
-      # and determines whether it is an unambiguous prefix of a task or
-      # alias name.
-      def find_task_possibilities(meth)
-        len = meth.to_s.length
-        possibilities = all_tasks.merge(map).keys.select { |n| meth == n[0, len] }.sort
-        unique_possibilities = possibilities.map { |k| map[k] || k }.uniq
-
-        if possibilities.include?(meth)
-          [meth]
-        elsif unique_possibilities.size == 1
-          unique_possibilities
-        else
-          possibilities
-        end
-      end
-
-      def subcommand_help(cmd)
-        desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
-        class_eval <<-RUBY
-          def help(task = nil, subcommand = true); super; end
-        RUBY
-      end
-  end
-
-  include Thor::Base
-
-  map HELP_MAPPINGS => :help
-
-  desc "help [TASK]", "Describe available tasks or one specific task"
-  def help(task = nil, subcommand = false)
-    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
-  end
-end

data/lib/vendor/thor/lib/thor/actions.rb

@@ -1,318 +0,0 @@
-require 'fileutils'
-require 'uri'
-require 'thor/core_ext/file_binary_read'
-require 'thor/actions/create_file'
-require 'thor/actions/create_link'
-require 'thor/actions/directory'
-require 'thor/actions/empty_directory'
-require 'thor/actions/file_manipulation'
-require 'thor/actions/inject_into_file'
-
-class Thor
-  module Actions
-    attr_accessor :behavior
-
-    def self.included(base) #:nodoc:
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Hold source paths for one Thor instance. source_paths_for_search is the
-      # method responsible to gather source_paths from this current class,
-      # inherited paths and the source root.
-      #
-      def source_paths
-        @_source_paths ||= []
-      end
-
-      # Stores and return the source root for this class
-      def source_root(path=nil)
-        @_source_root = path if path
-        @_source_root
-      end
-
-      # Returns the source paths in the following order:
-      #
-      #   1) This class source paths
-      #   2) Source root
-      #   3) Parents source paths
-      #
-      def source_paths_for_search
-        paths = []
-        paths += self.source_paths
-        paths << self.source_root if self.source_root
-        paths += from_superclass(:source_paths, [])
-        paths
-      end
-
-      # Add runtime options that help actions execution.
-      #
-      def add_runtime_options!
-        class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
-                             :desc => "Overwrite files that already exist"
-
-        class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
-                               :desc => "Run but do not make any changes"
-
-        class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
-                             :desc => "Supress status output"
-
-        class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
-                            :desc => "Skip files that already exist"
-      end
-    end
-
-    # Extends initializer to add more configuration options.
-    #
-    # ==== Configuration
-    # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
-    #                    It also accepts :force, :skip and :pretend to set the behavior
-    #                    and the respective option.
-    #
-    # destination_root<String>:: The root directory needed for some actions.
-    #
-    def initialize(args=[], options={}, config={})
-      self.behavior = case config[:behavior].to_s
-        when "force", "skip"
-          _cleanup_options_and_set(options, config[:behavior])
-          :invoke
-        when "revoke"
-          :revoke
-        else
-          :invoke
-      end
-
-      super
-      self.destination_root = config[:destination_root]
-    end
-
-    # Wraps an action object and call it accordingly to the thor class behavior.
-    #
-    def action(instance) #:nodoc:
-      if behavior == :revoke
-        instance.revoke!
-      else
-        instance.invoke!
-      end
-    end
-
-    # Returns the root for this thor class (also aliased as destination root).
-    #
-    def destination_root
-      @destination_stack.last
-    end
-
-    # Sets the root for this thor class. Relatives path are added to the
-    # directory where the script was invoked and expanded.
-    #
-    def destination_root=(root)
-      @destination_stack ||= []
-      @destination_stack[0] = File.expand_path(root || '')
-    end
-
-    # Returns the given path relative to the absolute root (ie, root where
-    # the script started).
-    #
-    def relative_to_original_destination_root(path, remove_dot=true)
-      if path =~ /^#{@destination_stack[0]}/
-        path = path.gsub(@destination_stack[0], '.')
-        path = remove_dot ? (path[2..-1] || '') : path
-      end
-
-      path
-    end
-
-    # Holds source paths in instance so they can be manipulated.
-    #
-    def source_paths
-      @source_paths ||= self.class.source_paths_for_search
-    end
-
-    # Receives a file or directory and search for it in the source paths.
-    #
-    def find_in_source_paths(file)
-      relative_root = relative_to_original_destination_root(destination_root, false)
-
-      source_paths.each do |source|
-        source_file = File.expand_path(file, File.join(source, relative_root))
-        return source_file if File.exists?(source_file)
-      end
-
-      message = "Could not find #{file.inspect} in any of your source paths. "
-
-      unless self.class.source_root
-        message << "Please invoke #{self.class.name}.source_root(PATH) with the PATH containing your templates. "
-      end
-
-      if source_paths.empty?
-        message << "Currently you have no source paths."
-      else
-        message << "Your current source paths are: \n#{source_paths.join("\n")}"
-      end
-
-      raise Error, message
-    end
-
-    # Do something in the root or on a provided subfolder. If a relative path
-    # is given it's referenced from the current root. The full path is yielded
-    # to the block you provide. The path is set back to the previous path when
-    # the method exits.
-    #
-    # ==== Parameters
-    # dir<String>:: the directory to move to.
-    # config<Hash>:: give :verbose => true to log and use padding.
-    #
-    def inside(dir='', config={}, &block)
-      verbose = config.fetch(:verbose, false)
-      pretend = options[:pretend]
-
-      say_status :inside, dir, verbose
-      shell.padding += 1 if verbose
-      @destination_stack.push File.expand_path(dir, destination_root)
-
-      # If the directory doesnt exist and we're not pretending
-      if !File.exist?(destination_root) && !pretend
-        FileUtils.mkdir_p(destination_root)
-      end
-
-      if pretend
-        # In pretend mode, just yield down to the block
-        block.arity == 1 ? yield(destination_root) : yield
-      else
-        FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
-      end
-
-      @destination_stack.pop
-      shell.padding -= 1 if verbose
-    end
-
-    # Goes to the root and execute the given block.
-    #
-    def in_root
-      inside(@destination_stack.first) { yield }
-    end
-
-    # Loads an external file and execute it in the instance binding.
-    #
-    # ==== Parameters
-    # path<String>:: The path to the file to execute. Can be a web address or
-    #                a relative path from the source root.
-    #
-    # ==== Examples
-    #
-    #   apply "http://gist.github.com/103208"
-    #
-    #   apply "recipes/jquery.rb"
-    #
-    def apply(path, config={})
-      verbose = config.fetch(:verbose, true)
-      is_uri  = path =~ /^https?\:\/\//
-      path    = find_in_source_paths(path) unless is_uri
-
-      say_status :apply, path, verbose
-      shell.padding += 1 if verbose
-
-      if is_uri
-        contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
-      else
-        contents = open(path) {|io| io.read }
-      end
-
-      instance_eval(contents, path)
-      shell.padding -= 1 if verbose
-    end
-
-    # Executes a command returning the contents of the command.
-    #
-    # ==== Parameters
-    # command<String>:: the command to be executed.
-    # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output. Specify :with
-    #                to append an executable to command executation.
-    #
-    # ==== Example
-    #
-    #   inside('vendor') do
-    #     run('ln -s ~/edge rails')
-    #   end
-    #
-    def run(command, config={})
-      return unless behavior == :invoke
-
-      destination = relative_to_original_destination_root(destination_root, false)
-      desc = "#{command} from #{destination.inspect}"
-
-      if config[:with]
-        desc = "#{File.basename(config[:with].to_s)} #{desc}"
-        command = "#{config[:with]} #{command}"
-      end
-
-      say_status :run, desc, config.fetch(:verbose, true)
-
-      unless options[:pretend]
-        config[:capture] ? `#{command}` : system("#{command}")
-      end
-    end
-
-    # Executes a ruby script (taking into account WIN32 platform quirks).
-    #
-    # ==== Parameters
-    # command<String>:: the command to be executed.
-    # config<Hash>:: give :verbose => false to not log the status.
-    #
-    def run_ruby_script(command, config={})
-      return unless behavior == :invoke
-      run command, config.merge(:with => Thor::Util.ruby_command)
-    end
-
-    # Run a thor command. A hash of options can be given and it's converted to
-    # switches.
-    #
-    # ==== Parameters
-    # task<String>:: the task to be invoked
-    # args<Array>:: arguments to the task
-    # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
-    #                Other options are given as parameter to Thor.
-    #
-    #
-    # ==== Examples
-    #
-    #   thor :install, "http://gist.github.com/103208"
-    #   #=> thor install http://gist.github.com/103208
-    #
-    #   thor :list, :all => true, :substring => 'rails'
-    #   #=> thor list --all --substring=rails
-    #
-    def thor(task, *args)
-      config  = args.last.is_a?(Hash) ? args.pop : {}
-      verbose = config.key?(:verbose) ? config.delete(:verbose) : true
-      pretend = config.key?(:pretend) ? config.delete(:pretend) : false
-      capture = config.key?(:capture) ? config.delete(:capture) : false
-
-      args.unshift task
-      args.push Thor::Options.to_switches(config)
-      command = args.join(' ').strip
-
-      run command, :with => :thor, :verbose => verbose, :pretend => pretend, :capture => capture
-    end
-
-    protected
-
-      # Allow current root to be shared between invocations.
-      #
-      def _shared_configuration #:nodoc:
-        super.merge!(:destination_root => self.destination_root)
-      end
-
-      def _cleanup_options_and_set(options, key) #:nodoc:
-        case options
-          when Array
-            %w(--force -f --skip -s).each { |i| options.delete(i) }
-            options << "--#{key}"
-          when Hash
-            [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
-            options.merge!(key => true)
-        end
-      end
-
-  end
-end