bundler 0.8.1 → 0.9.0.pre1

data/lib/bundler/specification.rb

@@ -0,0 +1,22 @@
+module Bundler
+  class Specification < Gem::Specification
+    attr_accessor :relative_loaded_from
+
+    def self.from_gemspec(gemspec)
+      spec = allocate
+      gemspec.instance_variables.each do |ivar|
+        spec.instance_variable_set(ivar, gemspec.instance_variable_get(ivar))
+      end
+      spec
+    end
+
+    def loaded_from
+      return super unless relative_loaded_from
+      source.path.join(relative_loaded_from)
+    end
+
+    def full_gem_path
+      loaded_from.dirname.expand_path
+    end
+  end
+end

data/lib/bundler/templates/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source :gemcutter
+#
+# gem "rails"

data/lib/bundler/templates/environment.erb

@@ -1,156 +1,6 @@
 # DO NOT MODIFY THIS FILE
 module Bundler
- file = File.expand_path(__FILE__)
- dir = File.dirname(file)
-
-<% unless system_gems? -%>
-  ENV["GEM_HOME"] = dir
-  ENV["GEM_PATH"] = dir
-
-  # handle 1.9 where system gems are always on the load path
-  if defined?(::Gem)
-    $LOAD_PATH.reject! do |p|
-      p != File.dirname(__FILE__) &&
-        Gem.path.any? { |gp| p.include?(gp) }
-    end
-  end
-
-<% end -%>
-  ENV["PATH"]     = "#{dir}/<%= bindir %><%= File::PATH_SEPARATOR %>#{ENV["PATH"]}"
-  ENV["RUBYOPT"]  = "-r#{file} #{ENV["RUBYOPT"]}"
-
-<% load_paths.each do |load_path| -%>
-  $LOAD_PATH.unshift File.expand_path("#{dir}/<%= load_path %>")
-<% end -%>
-
-  @gemfile = "#{dir}/<%= filename %>"
-
-<% if rubygems? -%>
-  require "rubygems" unless respond_to?(:gem) # 1.9 already has RubyGems loaded
-
-  @bundled_specs = {}
-<% specs.each do |spec| -%>
-<% if spec.no_bundle? -%>
-  gem "<%= spec.name %>", "<%= spec.version %>"
-<% else -%>
-<% path = spec_file_for(spec) -%>
-  @bundled_specs["<%= spec.name %>"] = eval(File.read("#{dir}/<%= path %>"))
-  @bundled_specs["<%= spec.name %>"].loaded_from = "#{dir}/<%= path %>"
-<% end -%>
-<% end -%>
-
-  def self.add_specs_to_loaded_specs
-    Gem.loaded_specs.merge! @bundled_specs
-  end
-
-  def self.add_specs_to_index
-    @bundled_specs.each do |name, spec|
-      Gem.source_index.add_spec spec
-    end
-  end
-
-  add_specs_to_loaded_specs
-  add_specs_to_index
-<% end -%>
-
-  def self.require_env(env = nil)
-    context = Class.new do
-      def initialize(env) @env = env && env.to_s ; end
-      def method_missing(*) ; yield if block_given? ; end
-      def only(*env)
-        old, @only = @only, _combine_only(env.flatten)
-        yield
-        @only = old
-      end
-      def except(*env)
-        old, @except = @except, _combine_except(env.flatten)
-        yield
-        @except = old
-      end
-      def gem(name, *args)
-        opt = args.last.is_a?(Hash) ? args.pop : {}
-        only = _combine_only(opt[:only] || opt["only"])
-        except = _combine_except(opt[:except] || opt["except"])
-        files = opt[:require_as] || opt["require_as"] || name
-        files = [files] unless files.respond_to?(:each)
-
-        return unless !only || only.any? {|e| e == @env }
-        return if except && except.any? {|e| e == @env }
-
-        if files = opt[:require_as] || opt["require_as"]
-          files = Array(files)
-          files.each { |f| require f }
-        else
-          begin
-            require name
-          rescue LoadError
-            # Do nothing
-          end
-        end
-        yield if block_given?
-        true
-      end
-      private
-      def _combine_only(only)
-        return @only unless only
-        only = [only].flatten.compact.uniq.map { |o| o.to_s }
-        only &= @only if @only
-        only
-      end
-      def _combine_except(except)
-        return @except unless except
-        except = [except].flatten.compact.uniq.map { |o| o.to_s }
-        except |= @except if @except
-        except
-      end
-    end
-    context.new(env && env.to_s).instance_eval(File.read(@gemfile), @gemfile, 1)
-  end
-end
-
-<% if rubygems? -%>
-module Gem
-  @loaded_stacks = Hash.new { |h,k| h[k] = [] }
-
-  def source_index.refresh!
-    super
-    Bundler.add_specs_to_index
-  end
-end
-<% else -%>
-$" << "rubygems.rb"
-
-module Kernel
-  def gem(*)
-    # Silently ignore calls to gem, since, in theory, everything
-    # is activated correctly already.
-  end
-end
-
-# Define all the Gem errors for gems that reference them.
-module Gem
-  def self.ruby ; <%= Gem.ruby.inspect %> ; end
-  def self.dir ; @dir ||= File.dirname(File.expand_path(__FILE__)) ; end
-  class << self ; alias default_dir dir; alias path dir ; end
-  class LoadError < ::LoadError; end
-  class Exception < RuntimeError; end
-  class CommandLineError < Exception; end
-  class DependencyError < Exception; end
-  class DependencyRemovalException < Exception; end
-  class GemNotInHomeException < Exception ; end
-  class DocumentError < Exception; end
-  class EndOfYAMLException < Exception; end
-  class FilePermissionError < Exception; end
-  class FormatException < Exception; end
-  class GemNotFoundException < Exception; end
-  class InstallError < Exception; end
-  class InvalidSpecificationException < Exception; end
-  class OperationNotSupportedError < Exception; end
-  class RemoteError < Exception; end
-  class RemoteInstallationCancelled < Exception; end
-  class RemoteInstallationSkipped < Exception; end
-  class RemoteSourceException < Exception; end
-  class VerificationError < Exception; end
-  class SystemExitException < SystemExit; end
-end
+<% load_paths.each do |path| -%>
+  $LOAD_PATH.unshift "<%= path %>"
 <% end -%>
+end

data/lib/bundler/ui.rb

@@ -0,0 +1,51 @@
+module Bundler
+  class UI
+    def warn(message)
+    end
+
+    def error(message)
+    end
+
+    def info(message)
+    end
+
+    def confirm(message)
+    end
+
+    class Shell < UI
+      def initialize(shell)
+        @shell = shell
+      end
+
+      def info(msg)
+        @shell.say(msg)
+      end
+
+      def confirm(msg)
+        @shell.say(msg, :green)
+      end
+
+      def warn(msg)
+        @shell.say(msg, :yellow)
+      end
+
+      def error(msg)
+        @shell.say(msg, :error)
+      end
+    end
+
+    class RGProxy < Gem::SilentUI
+      def initialize(ui)
+        @ui = ui
+      end
+
+      def say(message)
+        if message =~ /native extensions/
+          @ui.info "  * #{message}"
+        else
+          @ui.info(message)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendor/thor.rb

@@ -0,0 +1,241 @@
+require 'thor/base'
+require 'thor/group'
+require 'thor/actions'
+
+# 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.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut 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
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<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 = usage, 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
+
+    # 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.
+    #
+    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
+
+    # 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
+    # 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)
+    #
+    def start(given_args=ARGV, config={})
+      super do
+        meth = normalize_task_name(given_args.shift)
+        task = all_tasks[meth]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+          config.merge!(:task_options => task.options)
+        else
+          args, opts = given_args, {}
+        end
+
+        task ||= Thor::Task::Dynamic.new(meth)
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke(task, trailing || [])
+      end
+    end
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      task = all_tasks[task_name]
+      raise UndefinedTaskError, "task '#{task_name}' could not be found in namespace '#{self.namespace}'" unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      shell.say task.description
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell)
+      list = printable_tasks
+      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, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(all=true)
+      (all ? all_tasks : tasks).map do |_, task|
+        item = []
+        item << banner(task)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end
+    end
+
+    protected
+
+      # 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)
+        "thor " + task.formatted_usage(self)
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options)
+          @usage, @desc, @method_options = nil
+          true
+        elsif self.all_tasks[meth.to_s] || meth.to_sym == :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
+
+      # Receives a task name (can be nil), and try to get a map from it.
+      # 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.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+  end
+
+  include Thor::Base
+
+  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)
+  end
+end