bundler 1.0.0.beta.5 → 1.0.0.beta.8

data/lib/bundler/settings.rb

@@ -2,24 +2,31 @@ module Bundler
   class Settings
     def initialize(root)
       @root   = root
-      @config = File.exist?(config_file) ? YAML.load_file(config_file) : {}
+      @local_config = File.exist?(local_config_file) ? YAML.load_file(local_config_file) : {}
+      @global_config = File.exist?(global_config_file) ? YAML.load_file(global_config_file) : {}
     end
 
     def [](key)
       key = key_for(key)
-      @config[key] || ENV[key]
+      @local_config[key] || ENV[key] || @global_config[key]
     end
 
     def []=(key, value)
+      set_key(key, value, @local_config, local_config_file)
+    end
+
+    def set_global(key, value)
+      set_key(key, value, @global_config, global_config_file)
+    end
+
+    def locations(key)
       key = key_for(key)
-      unless @config[key] == value
-        @config[key] = value
-        FileUtils.mkdir_p(config_file.dirname)
-        File.open(config_file, 'w') do |f|
-          f.puts @config.to_yaml
-        end
-      end
-      value
+
+      locations = {}
+      locations[:local]  = @local_config[key]
+      locations[:env]    = ENV[key]
+      locations[:global] = @global_config[key]
+      locations
     end
 
     def without=(array)
@@ -32,11 +39,10 @@ module Bundler
       self[:without] ? self[:without].split(":").map { |w| w.to_sym } : []
     end
 
-    # @config["BUNDLE_PATH"] should be prioritized over ENV["BUNDLE_PATH"]
+    # @local_config["BUNDLE_PATH"] should be prioritized over ENV["BUNDLE_PATH"]
     def path
-      path = ENV[key_for(:path)]
-
-      return path if path && !@config.key?(key_for(:path))
+      path = ENV[key_for(:path)] || @global_config[key_for(:path)]
+      return path if path && !@local_config.key?(key_for(:path))
 
       if path = self[:path]
         "#{path}/#{Bundler.ruby_scope}"
@@ -47,12 +53,28 @@ module Bundler
 
   private
 
+    def set_key(key, value, hash, file)
+      key = key_for(key)
+
+      unless hash[key] == value
+        hash[key] = value
+        FileUtils.mkdir_p(file.dirname)
+        File.open(file, "w") { |f| f.puts hash.to_yaml }
+      end
+      value
+    end
+
     def key_for(key)
       "BUNDLE_#{key.to_s.upcase}"
     end
 
-    def config_file
+    def global_config_file
+      file = ENV["BUNDLE_CONFIG"] || File.join(Gem.user_home, ".bundle/config")
+      Pathname.new(file)
+    end
+
+    def local_config_file
       Pathname.new("#{@root}/.bundle/config")
     end
   end
-end
+end

data/lib/bundler/source.rb

@@ -258,7 +258,7 @@ module Bundler
     class Path
       attr_reader :path, :options
       # Kind of a hack, but needed for the lock file parser
-      attr_accessor :version
+      attr_accessor :name, :version
 
       DEFAULT_GLOB = "{,*/}*.gemspec"
 
@@ -523,7 +523,7 @@ module Bundler
 
       # TODO: actually cache git specs
       def specs
-        if (@allow_remote || @allow_cached) && !@update
+        if allow_git_ops? && !@update
         # Start by making sure the git cache is up to date
           cache
           checkout
@@ -537,7 +537,7 @@ module Bundler
 
         unless @installed
           Bundler.ui.debug "  * Checking out revision: #{ref}"
-          checkout
+          checkout if allow_git_ops?
           @installed = true
         end
         generate_bin(spec)
@@ -553,12 +553,18 @@ module Bundler
     private
 
       def git(command)
-        out = %x{git #{command}}
+        if allow_git_ops?
+          out = %x{git #{command}}
 
-        if $? != 0
-          raise GitError, "An error has occurred in git. Cannot complete bundling."
+          if $? != 0
+            raise GitError, "An error has occurred in git. Cannot complete bundling."
+          end
+          out
+        else
+          raise GitError, "Bundler is trying to run a `git #{command}` at runtime. You probably need to run `bundle install`. However, " \
+                          "this error message could probably be more useful. Please submit a ticket at http://github.com/carlhuda/bundler/issues " \
+                          "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"
         end
-        out
       end
 
       def base_name
@@ -595,6 +601,7 @@ module Bundler
 
       def cache
         if cached?
+          return if has_revision_cached?
           Bundler.ui.info "Updating #{uri}"
           in_cache { git %|fetch --force --quiet "#{uri}" refs/heads/*:refs/heads/*| }
         else
@@ -620,8 +627,24 @@ module Bundler
         end
       end
 
+      def has_revision_cached?
+        return unless @revision
+        in_cache { git %|cat-file -t #{@revision}| }
+        $? == 0
+      end
+
+      def allow_git_ops?
+        @allow_remote || @allow_cached
+      end
+
       def revision
-        @revision ||= in_cache { git("rev-parse #{ref}").strip }
+        @revision ||= begin
+          if allow_git_ops?
+            in_cache { git("rev-parse #{ref}").strip }
+          else
+            raise GitError, "The git source #{uri} is not yet checked out. Please run `bundle install` before trying to start your application"
+          end
+        end
       end
 
       def cached?

data/lib/bundler/spec_set.rb

@@ -127,7 +127,7 @@ module Bundler
     def tsort_each_child(s)
       s.dependencies.sort_by { |d| d.name }.each do |d|
         next if d.type == :development
-        lookup[d.name].each { |s| yield s }
+        lookup[d.name].each { |s2| yield s2 }
       end
     end
   end

data/lib/bundler/vendor/thor.rb

@@ -1,6 +1,5 @@
 require 'thor/base'
 
-# TODO: Update thor to allow for git-style CLI (git bisect run)
 class Thor
   class << self
     # Sets the default task when thor is executed without an explicit task to be called.
@@ -24,6 +23,7 @@ class Thor
     # ==== Parameters
     # usage<String>
     # description<String>
+    # options<String>
     #
     def desc(usage, description, options={})
       if options[:for]
@@ -31,7 +31,7 @@ class Thor
         task.usage = usage             if usage
         task.description = description if description
       else
-        @usage, @desc = usage, description
+        @usage, @desc, @hide = usage, description, options[:hide] || false
       end
     end
 
@@ -135,6 +135,8 @@ class Thor
     #   script.invoke(:task, first_arg, second_arg, third_arg)
     #
     def start(original_args=ARGV, config={})
+      @@original_args = original_args
+
       super do |given_args|
         meth = given_args.first.to_s
 
@@ -154,7 +156,7 @@ class Thor
           args, opts = given_args, {}
         end
 
-        task ||= Thor::Task::Dynamic.new(meth)
+        task ||= Thor::DynamicTask.new(meth)
         trailing = args[Range.new(arguments.size, -1)]
         new(args, opts, config).invoke(task, trailing || [])
       end
@@ -188,8 +190,8 @@ class Thor
     # ==== Parameters
     # shell<Thor::Shell>
     #
-    def help(shell)
-      list = printable_tasks
+    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
@@ -202,17 +204,25 @@ class Thor
     end
 
     # Returns tasks ready to be printed.
-    def printable_tasks(all=true)
+    def printable_tasks(all = true, subcommand = false)
       (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
         item = []
-        item << banner(task)
+        item << banner(task, false, subcommand)
         item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
         item
-      end
+      end.compact
     end
 
-    def handle_argument_error(task, error) #:nodoc:
-      raise InvocationError, "#{task.name.inspect} was called incorrectly. Call as #{task.formatted_usage(self, banner_base == "thor").inspect}."
+    def subcommands
+      @@subcommands ||= {}
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      subcommand = subcommand.to_s
+      subcommands[subcommand] = subcommand_class
+      subcommand_class.subcommand_help subcommand
+      define_method(subcommand) { |*_| subcommand_class.start(subcommand_args) }
     end
 
     protected
@@ -222,8 +232,8 @@ class Thor
       # the task that is going to be invoked and a boolean which indicates if
       # the namespace should be displayed as arguments.
       #
-      def banner(task)
-        "#{banner_base} #{task.formatted_usage(self, banner_base == "thor")}"
+      def banner(task, namespace = nil, subcommand = false)
+        "#{$0} #{task.formatted_usage(self, $thor_runner, subcommand)}"
       end
 
       def baseclass #:nodoc:
@@ -232,8 +242,9 @@ class Thor
 
       def create_task(meth) #:nodoc:
         if @usage && @desc
-          tasks[meth.to_s] = Thor::Task.new(meth, @desc, @long_desc, @usage, method_options)
-          @usage, @desc, @long_desc, @method_options = nil
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth.to_s] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          @usage, @desc, @long_desc, @method_options, @hide = nil
           true
         elsif self.all_tasks[meth.to_s] || meth.to_sym == :method_missing
           true
@@ -254,10 +265,21 @@ class Thor
       # If a map can't be found use the sent name or the default task.
       #
       def normalize_task_name(meth) #:nodoc:
-        mapping = map[meth.to_s]
-        meth = mapping || meth || default_task
+        meth = map[meth.to_s] || meth || default_task
         meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
       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
+
+  def subcommand_args
+    @@original_args[1..-1]
   end
 
   include Thor::Base
@@ -265,7 +287,7 @@ class Thor
   map HELP_MAPPINGS => :help
 
   desc "help [TASK]", "Describe available tasks or one specific task"
-  def help(task=nil)
-    task ? self.class.task_help(shell, task) : self.class.help(shell)
+  def help(task = nil, subcommand = false)
+    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
   end
 end

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

@@ -336,6 +336,7 @@ class Thor
       def no_tasks
         @no_tasks = true
         yield
+      ensure
         @no_tasks = false
       end
 
@@ -382,13 +383,17 @@ class Thor
       end
 
       def handle_no_task_error(task) #:nodoc:
-        if self.banner_base == "thor"
+        if $thor_runner
           raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
         else
           raise UndefinedTaskError, "Could not find task #{task.inspect}."
         end
       end
 
+      def handle_argument_error(task, error) #:nodoc:
+        raise InvocationError, "#{task.name.inspect} was called incorrectly. Call as #{self.banner(task).inspect}."
+      end
+
       protected
 
         # Prints the class options per group. If an option does not belong to
@@ -445,7 +450,7 @@ class Thor
         def build_option(name, options, scope) #:nodoc:
           scope[name] = Thor::Option.new(name, options[:desc], options[:required],
                                                options[:type], options[:default], options[:banner],
-                                               options[:group], options[:aliases])
+                                               options[:lazy_default], options[:group], options[:aliases])
         end
 
         # Receives a hash of options, parse them and add to the scope. This is a
@@ -516,11 +521,6 @@ class Thor
           false
         end
 
-        # Returns the base for banner.
-        def banner_base
-          @banner_base ||= $thor_runner ? "thor" : 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/invocation.rb

@@ -156,7 +156,7 @@ class Thor
         raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
 
         task ||= klass.default_task if klass.respond_to?(:default_task)
-        task = klass.all_tasks[task.to_s] || Thor::Task::Dynamic.new(task) if task && !task.is_a?(Thor::Task)
+        task = klass.all_tasks[task.to_s] || Thor::DynamicTask.new(task) if task && !task.is_a?(Thor::Task)
         task
       end
 

data/lib/bundler/vendor/thor/parser/argument.rb

@@ -31,10 +31,10 @@ class Thor
 
     def show_default?
       case default
-        when Array, String, Hash
-          !default.empty?
-        else
-          default
+      when Array, String, Hash
+        !default.empty?
+      else
+        default
       end
     end
 
@@ -45,21 +45,21 @@ class Thor
       end
 
       def valid_type?(type)
-        VALID_TYPES.include?(type.to_sym)
+        self.class::VALID_TYPES.include?(type.to_sym)
       end
 
       def default_banner
         case type
-          when :boolean
-            nil
-          when :string, :default
-            human_name.upcase
-          when :numeric
-            "N"
-          when :hash
-            "key:value"
-          when :array
-            "one two three"
+        when :boolean
+          nil
+        when :string, :default
+          human_name.upcase
+        when :numeric
+          "N"
+        when :hash
+          "key:value"
+        when :array
+          "one two three"
         end
       end
 

data/lib/bundler/vendor/thor/parser/option.rb

@@ -1,13 +1,14 @@
 class Thor
   class Option < Argument #:nodoc:
-    attr_reader :aliases, :group
+    attr_reader :aliases, :group, :lazy_default
 
     VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
 
-    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, group=nil, aliases=nil)
+    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, lazy_default=nil, group=nil, aliases=nil)
       super(name, description, required, type, default, banner)
-      @aliases = [*aliases].compact
-      @group   = group.to_s.capitalize if group
+      @lazy_default = lazy_default
+      @group        = group.to_s.capitalize if group
+      @aliases      = [*aliases].compact
     end
 
     # This parse quick options given as method_options. It makes several
@@ -48,23 +49,22 @@ class Thor
       default = value
 
       type = case value
-        when Symbol
-          default  = nil
-
-          if VALID_TYPES.include?(value)
-            value
-          elsif required = (value == :required)
-            :string
-          end
-        when TrueClass, FalseClass
-          :boolean
-        when Numeric
-          :numeric
-        when Hash, Array, String
-          value.class.name.downcase.to_sym
+      when Symbol
+        default = nil
+        if VALID_TYPES.include?(value)
+          value
+        elsif required = (value == :required)
+          :string
+        end
+      when TrueClass, FalseClass
+        :boolean
+      when Numeric
+        :numeric
+      when Hash, Array, String
+        value.class.name.downcase.to_sym
       end
 
-      self.new(name.to_s, nil, required, type, default, nil, nil, aliases)
+      self.new(name.to_s, nil, required, type, default, nil, nil, nil, aliases)
     end
 
     def switch_name
@@ -91,38 +91,30 @@ class Thor
       end
     end
 
-    # Allow some type predicates as: boolean?, string? and etc.
-    #
-    def method_missing(method, *args, &block)
-      given = method.to_s.sub(/\?$/, '').to_sym
-      if valid_type?(given)
-        self.type == given
-      else
-        super
-      end
+    VALID_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}?
+          self.type == #{type.inspect}
+        end
+      RUBY
     end
 
-    protected
-
-      def validate!
-        raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
-      end
-
-      def valid_type?(type)
-        VALID_TYPES.include?(type.to_sym)
-      end
+  protected
 
-      def dasherized?
-        name.index('-') == 0
-      end
+    def validate!
+      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+    end
 
-      def undasherize(str)
-        str.sub(/^-{1,2}/, '')
-      end
+    def dasherized?
+      name.index('-') == 0
+    end
 
-      def dasherize(str)
-        (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
-      end
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
 
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+    end
   end
 end