bundler 1.1.pre.5 → 1.1.pre.7

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

@@ -18,7 +18,7 @@ class Thor
     #     "vhost.name = #{hostname}"
     #   end
     #
-    #   create_file "config/apach.conf", "your apache config"
+    #   create_file "config/apache.conf", "your apache config"
     #
     def create_file(destination, *args, &block)
       config = args.last.is_a?(Hash) ? args.pop : {}
@@ -27,7 +27,7 @@ class Thor
     end
     alias :add_file :create_file
 
-    # AddFile is a subset of Template, which instead of rendering a file with
+    # CreateFile is a subset of Template, which instead of rendering a file with
     # ERB, it gets the content from the user.
     #
     class CreateFile < EmptyDirectory #:nodoc:

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

@@ -0,0 +1,57 @@
+require 'thor/actions/create_file'
+
+class Thor
+  module Actions
+
+    # Create a new file relative to the destination root from the given source.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # source<String|NilClass>:: the relative path to the source root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #   :: give :symbolic => false for hard link.
+    #
+    # ==== Examples
+    #
+    #   create_link "config/apache.conf", "/etc/apache.conf"
+    #
+    def create_link(destination, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      source = args.first
+      action CreateLink.new(self, destination, source, config)
+    end
+    alias :add_link :create_link
+
+    # CreateLink is a subset of CreateFile, which instead of taking a block of
+    # data, just takes a source string from the user.
+    #
+    class CreateLink < CreateFile #:nodoc:
+      attr_reader :data
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.identical?(render, destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          # Create a symlink by default
+          config[:symbolic] ||= true
+          File.unlink(destination) if exists?
+          if config[:symbolic]
+            File.symlink(render, destination)
+          else
+            File.link(render, destination)
+          end
+        end
+        given_destination
+      end
+
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ class Thor
     #   directory "doc"
     #
     # It will create a doc directory in the destination with the following
-    # files (assuming that the app_name is "blog"):
+    # files (assuming that the `app_name` method returns the value "blog"):
     #
     #   doc/
     #     components/
@@ -70,7 +70,7 @@ class Thor
           lookup = config[:recursive] ? File.join(source, '**') : source
           lookup = File.join(lookup, '{*,.[a-z]*}')
 
-          Dir[lookup].each do |file_source|
+          Dir[lookup].sort.each do |file_source|
             next if File.directory?(file_source)
             file_destination = File.join(given_destination, file_source.gsub(source, '.'))
             file_destination.gsub!('/./', '/')

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

@@ -30,6 +30,28 @@ class Thor
       end
     end
 
+    # Links the file from the relative source to the relative destination. If
+    # the destination is not given it's assumed to be equal to the source.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   link_file "README", "doc/README"
+    #
+    #   link_file "doc/README"
+    #
+    def link_file(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source
+      source = File.expand_path(find_in_source_paths(source.to_s))
+
+      create_link destination, source, config
+    end
+
     # Gets the content at the given address and places it at the given relative
     # destination. If a block is given instead of destination, the content of
     # the url is yielded and used as location.
@@ -51,7 +73,7 @@ class Thor
       config = args.last.is_a?(Hash) ? args.pop : {}
       destination = args.first
 
-      source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ /^http\:\/\//
+      source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ /^https?\:\/\//
       render = open(source) {|input| input.binmode.read }
 
       destination ||= if block_given?
@@ -80,13 +102,13 @@ class Thor
     #
     def template(source, *args, &block)
       config = args.last.is_a?(Hash) ? args.pop : {}
-      destination = args.first || source
+      destination = args.first || source.sub(/\.tt$/, '')
 
       source  = File.expand_path(find_in_source_paths(source.to_s))
       context = instance_eval('binding')
 
       create_file destination, nil, config do
-        content = ERB.new(::File.binread(source), nil, '-').result(context)
+        content = ERB.new(::File.binread(source), nil, '-', '@output_buffer').result(context)
         content = block.call(content) if block
         content
       end
@@ -110,7 +132,7 @@ class Thor
       FileUtils.chmod_R(mode, path) unless options[:pretend]
     end
 
-    # Prepend text to a file. Since it depends on inject_into_file, it's reversible.
+    # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
     #
     # ==== Parameters
     # path<String>:: path of the file to be changed
@@ -119,19 +141,20 @@ class Thor
     #
     # ==== Example
     #
-    #   prepend_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
     #
-    #   prepend_file 'config/environments/test.rb' do
+    #   prepend_to_file 'config/environments/test.rb' do
     #     'config.gem "rspec"'
     #   end
     #
-    def prepend_file(path, *args, &block)
+    def prepend_to_file(path, *args, &block)
       config = args.last.is_a?(Hash) ? args.pop : {}
       config.merge!(:after => /\A/)
-      inject_into_file(path, *(args << config), &block)
+      insert_into_file(path, *(args << config), &block)
     end
+    alias_method :prepend_file, :prepend_to_file
 
-    # Append text to a file. Since it depends on inject_into_file, it's reversible.
+    # Append text to a file. Since it depends on insert_into_file, it's reversible.
     #
     # ==== Parameters
     # path<String>:: path of the file to be changed
@@ -140,20 +163,21 @@ class Thor
     #
     # ==== Example
     #
-    #   append_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
     #
-    #   append_file 'config/environments/test.rb' do
+    #   append_to_file 'config/environments/test.rb' do
     #     'config.gem "rspec"'
     #   end
     #
-    def append_file(path, *args, &block)
+    def append_to_file(path, *args, &block)
       config = args.last.is_a?(Hash) ? args.pop : {}
       config.merge!(:before => /\z/)
-      inject_into_file(path, *(args << config), &block)
+      insert_into_file(path, *(args << config), &block)
     end
+    alias_method :append_file, :append_to_file
 
     # Injects text right after the class definition. Since it depends on
-    # inject_into_file, it's reversible.
+    # insert_into_file, it's reversible.
     #
     # ==== Parameters
     # path<String>:: path of the file to be changed
@@ -172,7 +196,7 @@ class Thor
     def inject_into_class(path, klass, *args, &block)
       config = args.last.is_a?(Hash) ? args.pop : {}
       config.merge!(:after => /class #{klass}\n|class #{klass} .*\n/)
-      inject_into_file(path, *(args << config), &block)
+      insert_into_file(path, *(args << config), &block)
     end
 
     # Run a regular expression replacement on a file.
@@ -225,5 +249,22 @@ class Thor
     end
     alias :remove_dir :remove_file
 
+  private
+    attr_accessor :output_buffer
+    def concat(string)
+      @output_buffer.concat(string)
+    end
+
+    def capture(*args, &block)
+      with_output_buffer { block.call(*args) }
+    end
+
+    def with_output_buffer(buf = '') #:nodoc:
+      self.output_buffer, old_buffer = buf, output_buffer
+      yield
+      output_buffer
+    ensure
+      self.output_buffer = old_buffer
+    end
   end
 end

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

@@ -15,14 +15,14 @@ class Thor
     #
     # ==== Examples
     #
-    #   inject_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
+    #   insert_into_file "config/environment.rb", "config.gem :thor", :after => "Rails::Initializer.run do |config|\n"
     #
-    #   inject_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+    #   insert_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
     #     gems = ask "Which gems would you like to add?"
     #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
     #   end
     #
-    def inject_into_file(destination, *args, &block)
+    def insert_into_file(destination, *args, &block)
       if block_given?
         data, config = block, args.shift
       else
@@ -30,6 +30,7 @@ class Thor
       end
       action InjectIntoFile.new(self, destination, data, config)
     end
+    alias_method :inject_into_file, :insert_into_file
 
     class InjectIntoFile < EmptyDirectory #:nodoc:
       attr_reader :replacement, :flag, :behavior
@@ -76,12 +77,16 @@ class Thor
       protected
 
         def say_status(behavior)
-          status = if flag == /\A/
-            behavior == :invoke ? :prepend : :unprepend
-          elsif flag == /\z/
-            behavior == :invoke ? :append : :unappend
+          status = if behavior == :invoke
+            if flag == /\A/
+               :prepend
+            elsif flag == /\z/
+              :append
+            else
+              :insert
+            end
           else
-            behavior == :invoke ? :inject : :deinject
+            :subtract
           end
 
           super(status, config[:verbose])

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

@@ -94,8 +94,6 @@ class Thor
     end
 
     module ClassMethods
-      attr_accessor :debugging
-
       def attr_reader(*) #:nodoc:
         no_tasks { super }
       end
@@ -384,14 +382,29 @@ class Thor
       #   script.invoke(:task, first_arg, second_arg, third_arg)
       #
       def start(given_args=ARGV, config={})
-        self.debugging = given_args.delete("--debug")
         config[:shell] ||= Thor::Base.shell.new
         dispatch(nil, given_args.dup, nil, config)
       rescue Thor::Error => e
-        debugging ? (raise e) : config[:shell].error(e.message)
+        ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
         exit(1) if exit_on_failure?
       end
 
+      # Allows to use private methods from parent in child classes as tasks.
+      #
+      # ==== Paremeters
+      #   names<Array>:: Method names to be used as tasks
+      #
+      # ==== Examples
+      #
+      #   public_task :foo
+      #   public_task :foo, :bar, :baz
+      #
+      def public_task(*names)
+        names.each do |name|
+          class_eval "def #{name}(*); super end"
+        end
+      end
+
       def handle_no_task_error(task) #:nodoc:
         if $thor_runner
           raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
@@ -531,6 +544,13 @@ class Thor
           false
         end
 
+        #
+        # The basename of the program invoking the thor class.
+        #
+        def basename
+          File.basename($0).split(' ').first
+        end
+
         # SIGNATURE: Sets the baseclass. This is where the superclass lookup
         # finishes.
         def baseclass #:nodoc:

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

@@ -0,0 +1,273 @@
+require 'thor/base'
+
+# Thor has a special class called Thor::Group. The main difference to Thor class
+# is that it invokes all tasks at once. It also include some methods that allows
+# invocations to be done at the class method, which are not available to Thor
+# tasks.
+class Thor::Group
+  class << self
+    # The description for this Thor::Group. If none is provided, but a source root
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Thor::Group.
+    #
+    def desc(description=nil)
+      case description
+        when nil
+          @desc ||= from_superclass(:desc, nil)
+        else
+          @desc = description
+      end
+    end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    def help(shell)
+      shell.say "Usage:"
+      shell.say "  #{banner}\n"
+      shell.say
+      class_options_help(shell)
+      shell.say self.desc if self.desc
+    end
+
+    # Stores invocations for this class merging with superclass values.
+    #
+    def invocations #:nodoc:
+      @invocations ||= from_superclass(:invocations, {})
+    end
+
+    # Stores invocation blocks used on invoke_from_option.
+    #
+    def invocation_blocks #:nodoc:
+      @invocation_blocks ||= from_superclass(:invocation_blocks, {})
+    end
+
+    # Invoke the given namespace or class given. It adds an instance
+    # method that will invoke the klass and task. You can give a block to
+    # configure how it will be invoked.
+    #
+    # The namespace/class given will have its options showed on the help
+    # usage. Check invoke_from_option for more information.
+    #
+    def invoke(*names, &block)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, true)
+
+      names.each do |name|
+        invocations[name] = false
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_#{name.to_s.gsub(/\W/, '_')}
+            klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
+
+            if klass
+              say_status :invoke, #{name.inspect}, #{verbose.inspect}
+              block = self.class.invocation_blocks[#{name.inspect}]
+              _invoke_for_class_method klass, task, &block
+            else
+              say_status :error, %(#{name.inspect} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Invoke a thor class based on the value supplied by the user to the
+    # given option named "name". A class option must be created before this
+    # method is invoked for each name given.
+    #
+    # ==== Examples
+    #
+    #   class GemGenerator < Thor::Group
+    #     class_option :test_framework, :type => :string
+    #     invoke_from_option :test_framework
+    #   end
+    #
+    # ==== Boolean options
+    #
+    # In some cases, you want to invoke a thor class if some option is true or
+    # false. This is automatically handled by invoke_from_option. Then the
+    # option name is used to invoke the generator.
+    #
+    # ==== Preparing for invocation
+    #
+    # In some cases you want to customize how a specified hook is going to be
+    # invoked. You can do that by overwriting the class method
+    # prepare_for_invocation. The class method must necessarily return a klass
+    # and an optional task.
+    #
+    # ==== Custom invocations
+    #
+    # You can also supply a block to customize how the option is giong to be
+    # invoked. The block receives two parameters, an instance of the current
+    # class and the klass to be invoked.
+    #
+    def invoke_from_option(*names, &block)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, :white)
+
+      names.each do |name|
+        unless class_options.key?(name)
+          raise ArgumentError, "You have to define the option #{name.inspect} " <<
+                               "before setting invoke_from_option."
+        end
+
+        invocations[name] = true
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
+            return unless options[#{name.inspect}]
+
+            value = options[#{name.inspect}]
+            value = #{name.inspect} if TrueClass === value
+            klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
+
+            if klass
+              say_status :invoke, value, #{verbose.inspect}
+              block = self.class.invocation_blocks[#{name.inspect}]
+              _invoke_for_class_method klass, task, &block
+            else
+              say_status :error, %(\#{value} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Remove a previously added invocation.
+    #
+    # ==== Examples
+    #
+    #   remove_invocation :test_framework
+    #
+    def remove_invocation(*names)
+      names.each do |name|
+        remove_task(name)
+        remove_class_option(name)
+        invocations.delete(name)
+        invocation_blocks.delete(name)
+      end
+    end
+
+    # Overwrite class options help to allow invoked generators options to be
+    # shown recursively when invoking a generator.
+    #
+    def class_options_help(shell, groups={}) #:nodoc:
+      get_options_from_invocations(groups, class_options) do |klass|
+        klass.send(:get_options_from_invocations, groups, class_options)
+      end
+      super(shell, groups)
+    end
+
+    # Get invocations array and merge options from invocations. Those
+    # options are added to group_options hash. Options that already exists
+    # in base_options are not added twice.
+    #
+    def get_options_from_invocations(group_options, base_options) #:nodoc:
+      invocations.each do |name, from_option|
+        value = if from_option
+          option = class_options[name]
+          option.type == :boolean ? name : option.default
+        else
+          name
+        end
+        next unless value
+
+        klass, task = prepare_for_invocation(name, value)
+        next unless klass && klass.respond_to?(:class_options)
+
+        value = value.to_s
+        human_name = value.respond_to?(:classify) ? value.classify : value
+
+        group_options[human_name] ||= []
+        group_options[human_name] += klass.class_options.values.select do |option|
+          base_options[option.name.to_sym].nil? && option.group.nil? &&
+          !group_options.values.flatten.any? { |i| i.name == option.name }
+        end
+
+        yield klass if block_given?
+      end
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(*)
+      item = []
+      item << banner
+      item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
+      [item]
+    end
+
+    def handle_argument_error(task, error) #:nodoc:
+      raise error, "#{task.name.inspect} was called incorrectly. Are you sure it has arity equals to 0?"
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(task, given_args, given_opts, config) #:nodoc:
+        if Thor::HELP_MAPPINGS.include?(given_args.first)
+          help(config[:shell])
+          return
+        end
+
+        args, opts = Thor::Options.split(given_args)
+        opts = given_opts || opts
+
+        if task
+          new(args, opts, config).invoke_task(all_tasks[task])
+        else
+          new(args, opts, config).invoke_all
+        end
+      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.
+      def banner
+        "#{basename} #{self_task.formatted_usage(self, false)}"
+      end
+
+      # Represents the whole class as a task.
+      def self_task #:nodoc:
+        Thor::DynamicTask.new(self.namespace, class_options)
+      end
+
+      def baseclass #:nodoc:
+        Thor::Group
+      end
+
+      def create_task(meth) #:nodoc:
+        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
+        true
+      end
+  end
+
+  include Thor::Base
+
+  protected
+
+  # Shortcut to invoke with padding and block handling. Use internally by
+  # invoke and invoke_from_option class methods.
+  def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
+    with_padding do
+      if block
+        case block.arity
+        when 3
+          block.call(self, klass, task)
+        when 2
+          block.call(self, klass)
+        when 1
+          instance_exec(klass, &block)
+        end
+      else
+        invoke klass, task, *args
+      end
+    end
+  end
+end