bundler-maglev- 1.0.21

data/lib/bundler/spec_set.rb

@@ -0,0 +1,135 @@
+require 'tsort'
+require 'forwardable'
+
+module Bundler
+  class SpecSet
+    extend Forwardable
+    include TSort, Enumerable
+
+    def_delegators :@specs, :<<, :length, :add, :remove
+    def_delegators :sorted, :each
+
+    def initialize(specs)
+      @specs = specs.sort_by { |s| s.name }
+    end
+
+    def for(dependencies, skip = [], check = false, match_current_platform = false)
+      handled, deps, specs = {}, dependencies.dup, []
+      skip << 'bundler'
+
+      until deps.empty?
+        dep = deps.shift
+        next if handled[dep] || skip.include?(dep.name)
+
+        spec = lookup[dep.name].find do |s|
+          match_current_platform ?
+            Gem::Platform.match(s.platform) :
+            s.match_platform(dep.__platform)
+        end
+
+        handled[dep] = true
+
+        if spec
+          specs << spec
+
+          spec.dependencies.each do |d|
+            next if d.type == :development
+            d = DepProxy.new(d, dep.__platform) unless match_current_platform
+            deps << d
+          end
+        elsif check
+          return false
+        end
+      end
+
+      if spec = lookup['bundler'].first
+        specs << spec
+      end
+
+      check ? true : SpecSet.new(specs)
+    end
+
+    def valid_for?(deps)
+      self.for(deps, [], true)
+    end
+
+    def [](key)
+      key = key.name if key.respond_to?(:name)
+      lookup[key].reverse
+    end
+
+    def []=(key, value)
+      @specs << value
+      @lookup = nil
+      @sorted = nil
+      value
+    end
+
+    def sort!
+      self
+    end
+
+    def to_a
+      sorted.dup
+    end
+
+    def to_hash
+      lookup.dup
+    end
+
+    def materialize(deps, missing_specs = nil)
+      materialized = self.for(deps, [], false, true).to_a
+      materialized.map! do |s|
+        next s unless s.is_a?(LazySpecification)
+        spec = s.__materialize__
+        if missing_specs
+          missing_specs << s unless spec
+        else
+          raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
+        end
+        spec if spec
+      end
+      SpecSet.new(materialized.compact)
+    end
+
+    def merge(set)
+      arr = sorted.dup
+      set.each do |s|
+        next if arr.any? { |s2| s2.name == s.name && s2.version == s.version && s2.platform == s.platform }
+        arr << s
+      end
+      SpecSet.new(arr)
+    end
+
+  private
+
+    def sorted
+      rake = @specs.find { |s| s.name == 'rake' }
+      @sorted ||= ([rake] + tsort).compact.uniq
+    end
+
+    def lookup
+      @lookup ||= begin
+        lookup = Hash.new { |h,k| h[k] = [] }
+        specs = @specs.sort_by do |s|
+          s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s
+        end
+        specs.reverse_each do |s|
+          lookup[s.name] << s
+        end
+        lookup
+      end
+    end
+
+    def tsort_each_node
+      @specs.each { |s| yield s }
+    end
+
+    def tsort_each_child(s)
+      s.dependencies.sort_by { |d| d.name }.each do |d|
+        next if d.type == :development
+        lookup[d.name].each { |s2| yield s2 }
+      end
+    end
+  end
+end

data/lib/bundler/templates/Executable

@@ -0,0 +1,16 @@
+#!/usr/bin/env <%= RbConfig::CONFIG['ruby_install_name'] %>
+#
+# This file was generated by Bundler.
+#
+# The application '<%= executable %>' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../<%= relative_gemfile_path %>",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('<%= spec.name %>', '<%= executable %>')

data/lib/bundler/templates/Gemfile

@@ -0,0 +1,4 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+# gem "rails"

data/lib/bundler/templates/newgem/Gemfile.tt

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in <%=config[:name]%>.gemspec
+gemspec

data/lib/bundler/templates/newgem/Rakefile.tt

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/bundler/templates/newgem/bin/newgem.tt

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "<%= config[:name] %>"

data/lib/bundler/templates/newgem/gitignore.tt

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/lib/bundler/templates/newgem/lib/newgem.rb.tt

@@ -0,0 +1,9 @@
+require "<%=config[:name]%>/version"
+
+<%- config[:constant_array].each_with_index do |c,i| -%>
+<%= '  '*i %>module <%= c %>
+<%- end -%>
+<%= '  '*config[:constant_array].size %># Your code goes here...
+<%- (config[:constant_array].size-1).downto(0) do |i| -%>
+<%= '  '*i %>end
+<%- end -%>

data/lib/bundler/templates/newgem/lib/newgem/version.rb.tt

@@ -0,0 +1,7 @@
+<%- config[:constant_array].each_with_index do |c,i| -%>
+<%= '  '*i %>module <%= c %>
+<%- end -%>
+<%= '  '*config[:constant_array].size %>VERSION = "0.0.1"
+<%- (config[:constant_array].size-1).downto(0) do |i| -%>
+<%= '  '*i %>end
+<%- end -%>

data/lib/bundler/templates/newgem/newgem.gemspec.tt

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "<%=config[:name]%>/version"
+
+Gem::Specification.new do |s|
+  s.name        = <%=config[:name].inspect%>
+  s.version     = <%=config[:constant_name]%>::VERSION
+  s.authors     = ["<%= config[:author_name] %>"]
+  s.email       = ["<%= config[:author_email] %>"]
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = <%=config[:name].inspect%>
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/bundler/ui.rb

@@ -0,0 +1,73 @@
+require 'rubygems/user_interaction'
+
+module Bundler
+  class UI
+    def warn(message)
+    end
+
+    def debug(message)
+    end
+
+    def error(message)
+    end
+
+    def info(message)
+    end
+
+    def confirm(message)
+    end
+
+    class Shell < UI
+      attr_writer :shell
+
+      def initialize(shell)
+        @shell = shell
+        @quiet = false
+        @debug = ENV['DEBUG']
+      end
+
+      def debug(msg)
+        @shell.say(msg) if @debug && !@quiet
+      end
+
+      def info(msg)
+        @shell.say(msg) if !@quiet
+      end
+
+      def confirm(msg)
+        @shell.say(msg, :green) if !@quiet
+      end
+
+      def warn(msg)
+        @shell.say(msg, :yellow)
+      end
+
+      def error(msg)
+        @shell.say(msg, :red)
+      end
+
+      def be_quiet!
+        @quiet = true
+      end
+
+      def debug!
+        @debug = true
+      end
+    end
+
+    class RGProxy < ::Gem::SilentUI
+      def initialize(ui)
+        @ui = ui
+        super()
+      end
+
+      def say(message)
+        if message =~ /native extensions/
+          @ui.info "with native extensions "
+        else
+          @ui.debug(message)
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendor/thor.rb

@@ -0,0 +1,358 @@
+require 'thor/base'
+
+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
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options={})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { invoke klass }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<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, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next task.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.long_description = long_description if long_description
+      else
+        @long_desc = long_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
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      if task.long_description
+        shell.say "Description:"
+        shell.print_wrapped(task.long_description, :ident => 2)
+      else
+        shell.say task.description
+      end
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    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
+      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, subcommand = false)
+      (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
+        item = []
+        item << banner(task, false, subcommand)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end.compact
+    end
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      self.subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(meth, given_args, given_opts, config) #:nodoc:
+        meth ||= retrieve_task_name(given_args)
+        task = all_tasks[normalize_task_name(meth)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        trailing = args[Range.new(arguments.size, -1)]
+        new(args, opts, config).invoke_task(task, trailing || [])
+      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. 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, namespace = nil, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          @usage, @desc, @long_desc, @method_options, @hide = nil
+          true
+        elsif self.all_tasks[meth] || meth == "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
+
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      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:
+        meth = map[meth.to_s] || find_subcommand_and_update_argv(meth) || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+
+      # terrible hack that overwrites ARGV
+      def find_subcommand_and_update_argv(subcmd_name) #:nodoc:
+        return unless subcmd_name
+        cmd = find_subcommand(subcmd_name)
+        ARGV[0] = cmd if cmd
+        cmd
+      end
+
+      def find_subcommand(subcmd_name)
+        possibilities = find_subcommand_possibilities subcmd_name
+        if possibilities.size > 1
+          raise "Ambiguous subcommand #{subcmd_name} matches [#{possibilities.join(', ')}]"
+        elsif possibilities.size < 1
+          return nil
+        end
+
+        possibilities.first
+      end
+
+      def find_subcommand_possibilities(subcmd_name)
+        len = subcmd_name.length
+        all_tasks.map {|t| t.first}.select { |n| subcmd_name == n[0, len] }
+      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
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task = nil, subcommand = false)
+    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
+  end
+end