bundler 1.3.6 → 1.4.0.pre.1

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

@@ -1,6 +1,6 @@
 require 'fileutils'
 require 'uri'
-require 'thor/core_ext/file_binary_read'
+require 'thor/core_ext/io_binary_read'
 require 'thor/actions/create_file'
 require 'thor/actions/create_link'
 require 'thor/actions/directory'
@@ -73,13 +73,13 @@ class Thor
     #
     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
+      when "force", "skip"
+        _cleanup_options_and_set(options, config[:behavior])
+        :invoke
+      when "revoke"
+        :revoke
+      else
+        :invoke
       end
 
       super
@@ -227,7 +227,7 @@ class Thor
     # ==== 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.
+    #                to append an executable to command execution.
     #
     # ==== Example
     #
@@ -268,8 +268,8 @@ class Thor
     # switches.
     #
     # ==== Parameters
-    # task<String>:: the task to be invoked
-    # args<Array>:: arguments to the task
+    # command<String>:: the command to be invoked
+    # args<Array>:: arguments to the command
     # config<Hash>:: give :verbose => false to not log the status, :capture => true to hide to output.
     #                Other options are given as parameter to Thor.
     #
@@ -282,13 +282,13 @@ class Thor
     #   thor :list, :all => true, :substring => 'rails'
     #   #=> thor list --all --substring=rails
     #
-    def thor(task, *args)
+    def thor(command, *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.unshift(command)
       args.push Thor::Options.to_switches(config)
       command = args.join(' ').strip
 
@@ -305,12 +305,12 @@ class Thor
 
       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)
+        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
 

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

@@ -52,6 +52,9 @@ class Thor
         given_destination
       end
 
+      def exists?
+        super || File.symlink?(destination)
+      end
     end
   end
 end

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

@@ -39,6 +39,7 @@ class Thor
     # config<Hash>:: give :verbose => false to not log the status.
     #                If :recursive => false, does not look for paths recursively.
     #                If :mode => :preserve, preserve the file mode from the source.
+    #                If :exclude_pattern => /regexp/, prevents copying files that match that regexp.
     #
     # ==== Examples
     #
@@ -74,26 +75,45 @@ class Thor
         def execute!
           lookup = Util.escape_globs(source)
           lookup = config[:recursive] ? File.join(lookup, '**') : lookup
-          lookup = File.join(lookup, '{*,.[a-z]*}')
+          lookup = file_level_lookup(lookup)
 
-          Dir[lookup].sort.each do |file_source|
+          files(lookup).sort.each do |file_source|
             next if File.directory?(file_source)
+            next if config[:exclude_pattern] && file_source.match(config[:exclude_pattern])
             file_destination = File.join(given_destination, file_source.gsub(source, '.'))
             file_destination.gsub!('/./', '/')
 
             case file_source
-              when /\.empty_directory$/
-                dirname = File.dirname(file_destination).gsub(/\/\.$/, '')
-                next if dirname == given_destination
-                base.empty_directory(dirname, config)
-              when /\.tt$/
-                destination = base.template(file_source, file_destination[0..-4], config, &@block)
-              else
-                destination = base.copy_file(file_source, file_destination, config, &@block)
+            when /\.empty_directory$/
+              dirname = File.dirname(file_destination).gsub(/\/\.$/, '')
+              next if dirname == given_destination
+              base.empty_directory(dirname, config)
+            when /\.tt$/
+              destination = base.template(file_source, file_destination[0..-4], config, &@block)
+            else
+              destination = base.copy_file(file_source, file_destination, config, &@block)
             end
           end
         end
 
+        if RUBY_VERSION < '2.0'
+          def file_level_lookup(previous_lookup)
+            File.join(previous_lookup, '{*,.[a-z]*}')
+          end
+
+          def files(lookup)
+            Dir[lookup]
+          end
+        else
+          def file_level_lookup(previous_lookup)
+            File.join(previous_lookup, '*')
+          end
+
+          def files(lookup)
+            Dir.glob(lookup, File::FNM_DOTMATCH)
+          end
+        end
+
     end
   end
 end

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

@@ -97,28 +97,12 @@ class Thor
         #
         #   user.rb
         #
-        # The method referenced by %-string SHOULD be public. Otherwise you
-        # get the exception with the corresponding error message.
+        # The method referenced can be either public or private.
         #
         def convert_encoded_instructions(filename)
           filename.gsub(/%(.*?)%/) do |initial_string|
-            call_public_method($1.strip) or initial_string
-          end
-        end
-
-        # Calls `base`'s public method `sym`.
-        # Returns:: result of `base.sym` or `nil` if `sym` wasn't found in
-        #  `base`
-        # Raises::  Thor::PrivateMethodEncodedError if `sym` references
-        #  a private method.
-        def call_public_method(sym)
-          if base.respond_to?(sym)
-            base.send(sym)
-          elsif base.respond_to?(sym, true)
-            raise Thor::PrivateMethodEncodedError,
-              "Method #{base.class}##{sym} should be public, not private"
-          else
-            nil
+            method = $1.strip
+            base.respond_to?(method, true) ? base.send(method) : initial_string
           end
         end
 

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

@@ -129,7 +129,7 @@ class Thor
     #
     # ==== Example
     #
-    #   chmod "script/*", 0755
+    #   chmod "script/server", 0755
     #
     def chmod(path, mode, config={})
       return unless behavior == :invoke
@@ -251,7 +251,7 @@ class Thor
     def uncomment_lines(path, flag, *args)
       flag = flag.respond_to?(:source) ? flag.source : flag
 
-      gsub_file(path, /^(\s*)#\s*(.*#{flag})/, '\1\2', *args)
+      gsub_file(path, /^(\s*)#[[:blank:]]*(.*#{flag})/, '\1\2', *args)
     end
 
     # Comment all lines matching a given regex.  It will leave the space
@@ -293,8 +293,11 @@ class Thor
     end
     alias :remove_dir :remove_file
 
-    attr_accessor :output_buffer
+  attr_accessor :output_buffer
+  private :output_buffer, :output_buffer=
+
   private
+
     def concat(string)
       @output_buffer.concat(string)
     end

data/lib/bundler/vendor/thor/base.rb

@@ -1,10 +1,10 @@
+require 'thor/command'
 require 'thor/core_ext/hash_with_indifferent_access'
 require 'thor/core_ext/ordered_hash'
 require 'thor/error'
-require 'thor/shell'
 require 'thor/invocation'
 require 'thor/parser'
-require 'thor/task'
+require 'thor/shell'
 require 'thor/util'
 
 class Thor
@@ -47,8 +47,8 @@ class Thor
       # first two parameters.
 
       if options.is_a?(Array)
-        task_options  = config.delete(:task_options) # hook for start
-        parse_options = parse_options.merge(task_options) if task_options
+        command_options = config.delete(:command_options) # hook for start
+        parse_options = parse_options.merge(command_options) if command_options
         array_options, hash_options = options, {}
       else
         # Handle the case where the class was explicitly instantiated
@@ -59,9 +59,10 @@ class Thor
       # Let Thor::Options parse the options first, so it can remove
       # declared options from the array. This will leave us with
       # a list of arguments that weren't declared.
-      stop_on_unknown = self.class.stop_on_unknown_option? config[:current_task]
+      stop_on_unknown = self.class.stop_on_unknown_option? config[:current_command]
       opts = Thor::Options.new(parse_options, hash_options, stop_on_unknown)
       self.options = opts.parse(array_options)
+      self.options = config[:class_options].merge(self.options) if config[:class_options]
 
       # If unknown options are disallowed, make sure that none of the
       # remaining arguments looks like an option.
@@ -119,15 +120,15 @@ class Thor
 
     module ClassMethods
       def attr_reader(*) #:nodoc:
-        no_tasks { super }
+        no_commands { super }
       end
 
       def attr_writer(*) #:nodoc:
-        no_tasks { super }
+        no_commands { super }
       end
 
       def attr_accessor(*) #:nodoc:
-        no_tasks { super }
+        no_commands { super }
       end
 
       # If you want to raise an error for unknown options, call check_unknown_options!
@@ -146,8 +147,8 @@ class Thor
 
       # If true, option parsing is suspended as soon as an unknown option or a
       # regular argument is encountered.  All remaining arguments are passed to
-      # the task as regular arguments.
-      def stop_on_unknown_option?(task_name) #:nodoc:
+      # the command as regular arguments.
+      def stop_on_unknown_option?(command_name) #:nodoc:
         false
       end
 
@@ -172,11 +173,11 @@ class Thor
       # is how they are parsed from the command line, arguments are retrieved
       # from position:
       #
-      #   thor task NAME
+      #   thor command NAME
       #
       # Instead of:
       #
-      #   thor task --name=NAME
+      #   thor command --name=NAME
       #
       # Besides, arguments are used inside your code as an accessor (self.argument),
       # while options are all kept in a hash (self.options).
@@ -203,7 +204,7 @@ class Thor
       #
       def argument(name, options={})
         is_thor_reserved_word?(name, :argument)
-        no_tasks { attr_accessor name }
+        no_commands { attr_accessor name }
 
         required = if options.key?(:optional)
           !options[:optional]
@@ -307,88 +308,92 @@ class Thor
       end
 
       # Defines the group. This is used when thor list is invoked so you can specify
-      # that only tasks from a pre-defined group will be shown. Defaults to standard.
+      # that only commands from a pre-defined group will be shown. Defaults to standard.
       #
       # ==== Parameters
       # name<String|Symbol>
       #
       def group(name=nil)
-        case name
-          when nil
-            @group ||= from_superclass(:group, 'standard')
-          else
-            @group = name.to_s
+        @group = case name
+        when nil
+          @group || from_superclass(:group, 'standard')
+        else
+          name.to_s
         end
       end
 
-      # Returns the tasks for this Thor class.
+      # Returns the commands for this Thor class.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with tasks names as keys and Thor::Task
+      # OrderedHash:: An ordered hash with commands names as keys and Thor::Command
       #               objects as values.
       #
-      def tasks
-        @tasks ||= Thor::CoreExt::OrderedHash.new
+      def commands
+        @commands ||= Thor::CoreExt::OrderedHash.new
       end
+      alias tasks commands
 
-      # Returns the tasks for this Thor class and all subclasses.
+      # Returns the commands for this Thor class and all subclasses.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with tasks names as keys and Thor::Task
+      # OrderedHash:: An ordered hash with commands names as keys and Thor::Command
       #               objects as values.
       #
-      def all_tasks
-        @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
-        @all_tasks.merge(tasks)
+      def all_commands
+        @all_commands ||= from_superclass(:all_commands, Thor::CoreExt::OrderedHash.new)
+        @all_commands.merge(commands)
       end
+      alias all_tasks all_commands
 
-      # Removes a given task from this Thor class. This is usually done if you
+      # Removes a given command from this Thor class. This is usually done if you
       # are inheriting from another class and don't want it to be available
       # anymore.
       #
-      # By default it only remove the mapping to the task. But you can supply
+      # By default it only remove the mapping to the command. But you can supply
       # :undefine => true to undefine the method from the class as well.
       #
       # ==== Parameters
-      # name<Symbol|String>:: The name of the task to be removed
-      # options<Hash>:: You can give :undefine => true if you want tasks the method
+      # name<Symbol|String>:: The name of the command to be removed
+      # options<Hash>:: You can give :undefine => true if you want commands the method
       #                 to be undefined from the class as well.
       #
-      def remove_task(*names)
+      def remove_command(*names)
         options = names.last.is_a?(Hash) ? names.pop : {}
 
         names.each do |name|
-          tasks.delete(name.to_s)
-          all_tasks.delete(name.to_s)
+          commands.delete(name.to_s)
+          all_commands.delete(name.to_s)
           undef_method name if options[:undefine]
         end
       end
+      alias remove_task remove_command
 
-      # All methods defined inside the given block are not added as tasks.
+      # All methods defined inside the given block are not added as commands.
       #
       # So you can do:
       #
       #   class MyScript < Thor
-      #     no_tasks do
-      #       def this_is_not_a_task
+      #     no_commands do
+      #       def this_is_not_a_command
       #       end
       #     end
       #   end
       #
-      # You can also add the method and remove it from the task list:
+      # You can also add the method and remove it from the command list:
       #
       #   class MyScript < Thor
-      #     def this_is_not_a_task
+      #     def this_is_not_a_command
       #     end
-      #     remove_task :this_is_not_a_task
+      #     remove_command :this_is_not_a_command
       #   end
       #
-      def no_tasks
-        @no_tasks = true
+      def no_commands
+        @no_commands = true
         yield
       ensure
-        @no_tasks = false
+        @no_commands = false
       end
+      alias no_tasks no_commands
 
       # Sets the namespace for the Thor or Thor::Group class. By default the
       # namespace is retrieved from the class name. If your Thor class is named
@@ -400,7 +405,7 @@ class Thor
       #
       #   namespace :my_scripts
       #
-      # You change how your tasks are invoked:
+      # You change how your commands are invoked:
       #
       #   thor my_scripts -h
       #
@@ -408,26 +413,25 @@ class Thor
       #
       #   namespace :default
       #
-      # Your tasks can be invoked with a shortcut. Instead of:
+      # Your commands can be invoked with a shortcut. Instead of:
       #
-      #   thor :my_task
+      #   thor :my_command
       #
       def namespace(name=nil)
-        case name
-        when nil
-          @namespace ||= Thor::Util.namespace_from_thor_class(self)
-        else
+        if name
           @namespace = name.to_s
+        else
+          @namespace ||= Thor::Util.namespace_from_thor_class(self)
         end
       end
 
-      # Parses the task and options from the given args, instantiate the class
-      # and invoke the task. This method is used when the arguments must be parsed
+      # Parses the command and options from the given args, instantiate the class
+      # and invoke the command. This method is used when the arguments must be parsed
       # from an array. If you are inside Ruby and want to use a Thor class, you
       # can simply initialize it:
       #
       #   script = MyScript.new(args, options, config)
-      #   script.invoke(:task, first_arg, second_arg, third_arg)
+      #   script.invoke(:command, first_arg, second_arg, third_arg)
       #
       def start(given_args=ARGV, config={})
         config[:shell] ||= Thor::Base.shell.new
@@ -436,48 +440,44 @@ class Thor
         ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
         exit(1) if exit_on_failure?
       rescue Errno::EPIPE
-        # This happens if a thor task is piped to something like `head`,
+        # This happens if a thor command is piped to something like `head`,
         # which closes the pipe when it's done reading. This will also
         # mean that if the pipe is closed, further unnecessary
         # computation will not occur.
         exit(0)
       end
 
-      # Allows to use private methods from parent in child classes as tasks.
+      # Allows to use private methods from parent in child classes as commands.
       #
       # ==== Parameters
-      #   names<Array>:: Method names to be used as tasks
+      #   names<Array>:: Method names to be used as commands
       #
       # ==== Examples
       #
-      #   public_task :foo
-      #   public_task :foo, :bar, :baz
+      #   public_command :foo
+      #   public_command :foo, :bar, :baz
       #
-      def public_task(*names)
+      def public_command(*names)
         names.each do |name|
           class_eval "def #{name}(*); super end"
         end
       end
+      alias public_task public_command
 
-      def handle_no_task_error(task, has_namespace = $thor_runner) #:nodoc:
+      def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
         if has_namespace
-          raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
+          raise UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace."
         else
-          raise UndefinedTaskError, "Could not find task #{task.inspect}."
+          raise UndefinedCommandError, "Could not find command #{command.inspect}."
         end
       end
+      alias handle_no_task_error handle_no_command_error
 
-      def handle_argument_error(task, error, arity=nil) #:nodoc:
-        msg = "#{basename} #{task.name}"
-        if arity
-          required = arity < 0 ? (-1 - arity) : arity
-          msg << " requires at least #{required} argument"
-          msg << "s" if required > 1
-        else
-          msg = "call #{msg} as"
-        end
-
-        msg << ": #{self.banner(task).inspect}."
+      def handle_argument_error(command, error, args, arity) #:nodoc:
+        msg = "ERROR: \"#{basename} #{command.name}\" was called with "
+        msg << 'no arguments'               if  args.empty?
+        msg << 'arguments ' << args.inspect if !args.empty?
+        msg << "\nUsage: #{self.banner(command).inspect}"
         raise InvocationError, msg
       end
 
@@ -555,28 +555,29 @@ class Thor
           end
         end
 
-        # Finds a task with the given name. If the task belongs to the current
+        # Finds a command with the given name. If the command belongs to the current
         # class, just return it, otherwise dup it and add the fresh copy to the
-        # current task hash.
-        def find_and_refresh_task(name) #:nodoc:
-          task = if task = tasks[name.to_s]
-            task
-          elsif task = all_tasks[name.to_s]
-            tasks[name.to_s] = task.clone
+        # current command hash.
+        def find_and_refresh_command(name) #:nodoc:
+          command = if command = commands[name.to_s]
+            command
+          elsif command = all_commands[name.to_s]
+            commands[name.to_s] = command.clone
           else
-            raise ArgumentError, "You supplied :for => #{name.inspect}, but the task #{name.inspect} could not be found."
+            raise ArgumentError, "You supplied :for => #{name.inspect}, but the command #{name.inspect} could not be found."
           end
         end
+        alias find_and_refresh_task find_and_refresh_command
 
         # Everytime someone inherits from a Thor class, register the klass
         # and file into baseclass.
         def inherited(klass)
           Thor::Base.register_klass_file(klass)
-          klass.instance_variable_set(:@no_tasks, false)
+          klass.instance_variable_set(:@no_commands, false)
         end
 
         # Fire this callback whenever a method is added. Added methods are
-        # tracked as tasks by invoking the create_task method.
+        # tracked as commands by invoking the create_command method.
         def method_added(meth)
           meth = meth.to_s
 
@@ -586,12 +587,11 @@ class Thor
           end
 
           # Return if it's not a public instance method
-          return unless public_instance_methods.include?(meth) ||
-                        public_instance_methods.include?(meth.to_sym)
+          return unless public_method_defined?(meth.to_sym)
 
-          return if (defined?(@no_tasks) && @no_tasks) || !create_task(meth)
+          return if @no_commands || !create_command(meth)
 
-          is_thor_reserved_word?(meth, :task)
+          is_thor_reserved_word?(meth, :command)
           Thor::Base.register_klass_file(self)
         end
 
@@ -603,13 +603,16 @@ class Thor
           else
             value = superclass.send(method)
 
-            if value
-              if value.is_a?(TrueClass) || value.is_a?(Symbol)
-                value
-              else
-                value.dup
-              end
+            # Ruby implements `dup` on Object, but raises a `TypeError`
+            # if the method is called on immediates. As a result, we
+            # don't have a good way to check whether dup will succeed
+            # without calling it and rescuing the TypeError.
+            begin
+              value.dup
+            rescue TypeError
+              value
             end
+
           end
         end
 
@@ -630,10 +633,11 @@ class Thor
         def baseclass #:nodoc:
         end
 
-        # SIGNATURE: Creates a new task if valid_task? is true. This method is
+        # SIGNATURE: Creates a new command if valid_command? is true. This method is
         # called when a new method is added to the class.
-        def create_task(meth) #:nodoc:
+        def create_command(meth) #:nodoc:
         end
+        alias create_task create_command
 
         # SIGNATURE: Defines behavior when the initialize method is added to the
         # class.
@@ -641,7 +645,7 @@ class Thor
         end
 
         # SIGNATURE: The hook invoked by start.
-        def dispatch(task, given_args, given_opts, config) #:nodoc:
+        def dispatch(command, given_args, given_opts, config) #:nodoc:
           raise NotImplementedError
         end