bundler 1.0.22 → 1.1.pre

data/.travis.yml

@@ -1,31 +0,0 @@
-before_script:
-  - sudo apt-get install groff -y
-  - rake spec:deps
-
-script: rake spec:travis
-
-rvm:
-  - 1.8.7
-  - 1.9.2
-
-env:
-  - RGV=v1.3.6
-  - RGV=v1.3.7
-  - RGV=v1.4.2
-  - RGV=v1.5.3
-  - RGV=v1.6.2
-  - RGV=v1.7.2
-  - RGV=v1.8.10
-
-matrix:
-  exclude:
-    - rvm: 1.9.2
-      env: RGV=v1.3.6
-    - rvm: 1.9.2
-      env: RGV=v1.3.7
-    - rvm: 1.9.2
-      env: RGV=v1.4.2
-
-notifications:
-  email:
-    - travis-ci@andrearko.com

data/lib/bundler/gem_installer.rb

@@ -1,9 +0,0 @@
-require 'rubygems/installer'
-
-module Bundler
-  class GemInstaller < Gem::Installer
-    def check_executable_overwrite(filename)
-      # Bundler needs to install gems regardless of binstub overwriting
-    end
-  end
-end

data/lib/bundler/gem_tasks.rb

@@ -1,2 +0,0 @@
-require 'bundler/gem_helper'
-Bundler::GemHelper.install_tasks

data/lib/bundler/rubygems_integration.rb

@@ -1,344 +0,0 @@
-module Bundler
-  class RubygemsIntegration
-    def initialize
-      # Work around a RubyGems bug
-      configuration
-    end
-
-    def loaded_specs(name)
-      Gem.loaded_specs[name]
-    end
-
-    def mark_loaded(spec)
-      Gem.loaded_specs[spec.name] = spec
-    end
-
-    def path(obj)
-      obj.to_s
-    end
-
-    def platforms
-      Gem.platforms
-    end
-
-    def configuration
-      Gem.configuration
-    end
-
-    def ruby_engine
-      Gem.ruby_engine
-    end
-
-    def read_binary(path)
-      Gem.read_binary(path)
-    end
-
-    def inflate(obj)
-      Gem.inflate(obj)
-    end
-
-    def sources=(val)
-      Gem.sources = val
-    end
-
-    def sources
-      Gem.sources
-    end
-
-    def gem_dir
-      Gem.dir
-    end
-
-    def gem_bindir
-      Gem.bindir
-    end
-
-    def user_home
-      Gem.user_home
-    end
-
-    def gem_path
-      Gem.path
-    end
-
-    def marshal_spec_dir
-      Gem::MARSHAL_SPEC_DIR
-    end
-
-    def clear_paths
-      Gem.clear_paths
-    end
-
-    def bin_path(gem, bin, ver)
-      Gem.bin_path(gem, bin, ver)
-    end
-
-    def preserve_paths
-      # this is a no-op outside of Rubygems 1.8
-      yield
-    end
-
-    def ui=(obj)
-      Gem::DefaultUserInteraction.ui = obj
-    end
-
-    def fetch_specs(all, pre, &blk)
-      Gem::SpecFetcher.new.list(all, pre).each(&blk)
-    end
-
-    def with_build_args(args)
-      old_args = Gem::Command.build_args
-      begin
-        Gem::Command.build_args = args
-        yield
-      ensure
-        Gem::Command.build_args = old_args
-      end
-    end
-
-    def spec_from_gem(path)
-      Gem::Format.from_file_by_path(path).spec
-    end
-
-    def download_gem(spec, uri, path)
-      Gem::RemoteFetcher.fetcher.download(spec, uri, path)
-    end
-
-    def reverse_rubygems_kernel_mixin
-      # Disable rubygems' gem activation system
-      ::Kernel.class_eval do
-        if private_method_defined?(:gem_original_require)
-          alias rubygems_require require
-          alias require gem_original_require
-        end
-
-        undef gem
-      end
-    end
-
-    def replace_gem(specs)
-      executables = specs.map { |s| s.executables }.flatten
-
-      ::Kernel.send(:define_method, :gem) do |dep, *reqs|
-        if executables.include? File.basename(caller.first.split(':').first)
-          return
-        end
-        reqs.pop if reqs.last.is_a?(Hash)
-
-        unless dep.respond_to?(:name) && dep.respond_to?(:requirement)
-          dep = Gem::Dependency.new(dep, reqs)
-        end
-
-        spec = specs.find  { |s| s.name == dep.name }
-
-        if spec.nil?
-
-          e = Gem::LoadError.new "#{dep.name} is not part of the bundle. Add it to Gemfile."
-          e.name = dep.name
-          if e.respond_to?(:requirement=)
-            e.requirement = dep.requirement
-          else
-            e.version_requirement = dep.requirement
-          end
-          raise e
-        elsif dep !~ spec
-          e = Gem::LoadError.new "can't activate #{dep}, already activated #{spec.full_name}. " \
-                                 "Make sure all dependencies are added to Gemfile."
-          e.name = dep.name
-          if e.respond_to?(:requirement=)
-            e.requirement = dep.requirement
-          else
-            e.version_requirement = dep.requirement
-          end
-          raise e
-        end
-
-        true
-      end
-    end
-
-    if defined? ::Deprecate
-      Deprecate = ::Deprecate
-    elsif defined? Gem::Deprecate
-      Deprecate = Gem::Deprecate
-    else
-      class Deprecate
-        def skip_during; yield; end
-      end
-    end
-
-    def stub_source_index137(specs)
-      # Rubygems versions lower than 1.7 use SourceIndex#from_gems_in
-      source_index_class = (class << Gem::SourceIndex ; self ; end)
-      source_index_class.send(:remove_method, :from_gems_in)
-      source_index_class.send(:define_method, :from_gems_in) do |*args|
-        source_index = Gem::SourceIndex.new
-        source_index.spec_dirs = *args
-        source_index.add_specs(*specs)
-        source_index
-      end
-    end
-
-    def stub_source_index170(specs)
-      Gem::SourceIndex.send(:alias_method, :old_initialize, :initialize)
-      Gem::SourceIndex.send(:define_method, :initialize) do |*args|
-        @gems = {}
-        # You're looking at this thinking: Oh! This is how I make those
-        # rubygems deprecations go away!
-        #
-        # You'd be correct BUT using of this method in production code
-        # must be approved by the rubygems team itself!
-        #
-        # This is your warning. If you use this and don't have approval
-        # we can't protect you.
-        #
-        Deprecate.skip_during do
-          self.spec_dirs = *args
-          add_specs(*specs)
-        end
-      end
-    end
-
-    # Used to make bin stubs that are not created by bundler work
-    # under bundler. The new Gem.bin_path only considers gems in
-    # +specs+
-    def replace_bin_path(specs)
-      gem_class = (class << Gem ; self ; end)
-      gem_class.send(:remove_method, :bin_path)
-      gem_class.send(:define_method, :bin_path) do |name, *args|
-        exec_name = args.first
-
-        if exec_name == 'bundle'
-          return ENV['BUNDLE_BIN_PATH']
-        end
-
-        spec = nil
-
-        if exec_name
-          spec = specs.find { |s| s.executables.include?(exec_name) }
-          spec or raise Gem::Exception, "can't find executable #{exec_name}"
-        else
-          spec = specs.find  { |s| s.name == name }
-          exec_name = spec.default_executable or raise Gem::Exception, "no default executable for #{spec.full_name}"
-        end
-
-        gem_bin = File.join(spec.full_gem_path, spec.bindir, exec_name)
-        gem_from_path_bin = File.join(File.dirname(spec.loaded_from), spec.bindir, exec_name)
-        File.exist?(gem_bin) ? gem_bin : gem_from_path_bin
-      end
-    end
-
-    # Because Bundler has a static view of what specs are available,
-    # we don't #reflesh, so stub it out.
-    def replace_refresh
-      gem_class = (class << Gem ; self ; end)
-      gem_class.send(:remove_method, :refresh)
-      gem_class.send(:define_method, :refresh) { }
-    end
-
-    # Replace or hook into Rubygems to provide a bundlerized view
-    # of the world.
-    def replace_entrypoints(specs)
-      reverse_rubygems_kernel_mixin
-
-      replace_gem(specs)
-
-      stub_rubygems(specs)
-
-      replace_bin_path(specs)
-      replace_refresh
-
-      Gem.clear_paths
-    end
-
-    # This backports the correct segment generation code from Rubygems 1.4+
-    # by monkeypatching it into the method in Rubygems 1.3.6 and 1.3.7.
-    def backport_segment_generation
-      Gem::Version.send(:define_method, :segments) do
-        @segments ||= @version.scan(/[0-9]+|[a-z]+/i).map do |s|
-          /^\d+$/ =~ s ? s.to_i : s
-        end
-      end
-    end
-
-    # Rubygems 1.4 through 1.6
-    class Legacy < RubygemsIntegration
-      def stub_rubygems(specs)
-        stub_source_index137(specs)
-      end
-
-      def all_specs
-        Gem.source_index.gems.values
-      end
-
-      def find_name(name)
-        Gem.source_index.find_name(name)
-      end
-    end
-
-    # Rubygems versions 1.3.6 and 1.3.7
-    class Ancient < Legacy
-      def initialize
-        super
-        backport_segment_generation
-      end
-    end
-
-    # Rubygems 1.7
-    class Transitional < Legacy
-      def stub_rubygems(specs)
-        stub_source_index170(specs)
-      end
-    end
-
-    # Rubygems 1.8.5
-    class Modern < RubygemsIntegration
-      def stub_rubygems(specs)
-        Gem::Specification.all = specs
-
-        Gem.post_reset {
-          Gem::Specification.all = specs
-        }
-
-        stub_source_index170(specs)
-      end
-
-      def all_specs
-        Gem::Specification.to_a
-      end
-
-      def find_name(name)
-        Gem::Specification.find_all_by_name name
-      end
-    end
-
-    # Rubygems 1.8.0 to 1.8.4
-    class AlmostModern < Modern
-      # Rubygems [>= 1.8.0, < 1.8.5] has a bug that changes Gem.dir whenever
-      # you call Gem::Installer#install with an :install_dir set. We have to
-      # change it back for our sudo mode to work.
-      def preserve_paths
-        old_dir, old_path = gem_dir, gem_path
-        yield
-        Gem.use_paths(old_dir, old_path)
-      end
-    end
-
-  end
-
-  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.5')
-    @rubygems = RubygemsIntegration::Modern.new
-  elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.8.0')
-    @rubygems = RubygemsIntegration::AlmostModern.new
-  elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.7.0')
-    @rubygems = RubygemsIntegration::Transitional.new
-  elsif Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.4.0')
-    @rubygems = RubygemsIntegration::Legacy.new
-  else # Rubygems 1.3.6 and 1.3.7
-    @rubygems = RubygemsIntegration::Ancient.new
-  end
-
-  class << self
-    attr_reader :rubygems
-  end
-end

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

@@ -1,57 +0,0 @@
-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/group.rb

@@ -1,273 +0,0 @@
-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