bundler_package_git 1.1.pre.1

data/lib/bundler/graph.rb

@@ -0,0 +1,130 @@
+module Bundler
+  class Graph
+
+    USER_OPTIONS = {:style => 'filled', :fillcolor => '#B9B9D5'}.freeze
+
+    def initialize(env)
+      @env = env
+    end
+
+    def nodes
+      populate
+      @nodes
+    end
+
+    def groups
+      populate
+      @groups
+    end
+
+    def viz(output_file, show_gem_versions = false, show_dependency_requirements = false)
+      require 'graphviz'
+      populate
+
+      graph_viz = GraphViz::new('Gemfile', {:concentrate => true, :normalize => true, :nodesep => 0.55})
+      graph_viz.edge[:fontname] = graph_viz.node[:fontname] = 'Arial, Helvetica, SansSerif'
+      graph_viz.edge[:fontsize] = 12
+
+      viz_nodes = {}
+
+      # populate all of the nodes
+      nodes.each do |name, node|
+        label = name.dup
+        label << "\n#{node.version}" if show_gem_versions
+        options = { :label => label }
+        options.merge!( USER_OPTIONS ) if node.is_user
+        viz_nodes[name] = graph_viz.add_node( name, options )
+      end
+
+      group_nodes = {}
+      @groups.each do |name, dependencies|
+        group_nodes[name] = graph_viz.add_node(name.to_s, { :shape => 'box3d', :fontsize => 16 }.merge(USER_OPTIONS))
+        dependencies.each do |dependency|
+          options = { :weight => 2 }
+          if show_dependency_requirements && (dependency.requirement.to_s != ">= 0")
+            options[:label] = dependency.requirement.to_s
+          end
+          graph_viz.add_edge( group_nodes[name], viz_nodes[dependency.name], options )
+        end
+      end
+
+      @groups.keys.select { |group| group != :default }.each do |group|
+        graph_viz.add_edge( group_nodes[group], group_nodes[:default], { :weight => 2 } )
+      end
+
+      viz_nodes.each do |name, node|
+        nodes[name].dependencies.each do |dependency|
+          options = { }
+          if nodes[dependency.name].is_user
+            options[:constraint] = false
+          end
+          if show_dependency_requirements && (dependency.requirement.to_s != ">= 0")
+            options[:label] = dependency.requirement.to_s
+          end
+
+          graph_viz.add_edge( node, viz_nodes[dependency.name], options )
+        end
+      end
+
+      graph_viz.output( :png => output_file )
+    end
+
+    private
+
+    def populate
+      return if @populated
+
+      # hash of name => GraphNode
+      @nodes = {}
+      @groups = {}
+
+      # Populate @nodes
+      @env.specs.each { |spec| @nodes[spec.name] = GraphNode.new(spec.name, spec.version) }
+
+      # For gems in Gemfile, add details
+      @env.current_dependencies.each do |dependency|
+        next unless node = @nodes[dependency.name]
+        node.is_user = true
+
+        dependency.groups.each do |group|
+          if @groups.has_key? group
+            group = @groups[group]
+          else
+            group = @groups[group] = []
+          end
+          group << dependency
+        end
+      end
+
+      # walk though a final time and add edges
+      @env.specs.each do |spec|
+
+        from = @nodes[spec.name]
+        spec.runtime_dependencies.each do |dependency|
+          from.dependencies << dependency
+        end
+
+      end
+
+      @nodes.freeze
+      @groups.freeze
+      @populated = true
+    end
+
+  end
+
+  # Add version info
+  class GraphNode
+
+    def initialize(name, version)
+      @name = name
+      @version = version
+      @is_user = false
+      @dependencies = []
+    end
+
+    attr_reader :name, :dependencies, :version
+    attr_accessor :is_user
+
+  end
+end

data/lib/bundler/index.rb

@@ -0,0 +1,131 @@
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    attr_reader :specs
+    protected   :specs
+
+    def initialize
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+
+      o.specs.each do |name, array|
+        @specs[name] = array.dup
+      end
+    end
+
+    def empty?
+      each { return false }
+      true
+    end
+
+    def search(query)
+      case query
+      when Gem::Specification, RemoteSpecification, LazySpecification then search_by_spec(query)
+      when String then @specs[query]
+      else search_by_dependency(query)
+      end
+    end
+
+    def search_for_all_platforms(dependency, base = [])
+      specs = @specs[dependency.name] + base
+
+      wants_prerelease = dependency.requirement.prerelease?
+      only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+      found = specs.select { |spec| dependency.matches_spec?(spec) }
+
+      unless wants_prerelease || only_prerelease
+        found.reject! { |spec| spec.version.prerelease? }
+      end
+
+      found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+    end
+
+    def sources
+      @specs.values.map do |specs|
+        specs.map{|s| s.source.class }
+      end.flatten.uniq
+    end
+
+    alias [] search
+
+    def <<(spec)
+      arr = @specs[spec.name]
+
+      arr.delete_if do |s|
+        same_version?(s.version, spec.version) && s.platform == spec.platform
+      end
+
+      arr << spec
+      spec
+    end
+
+    def each(&blk)
+      @specs.values.each do |specs|
+        specs.each(&blk)
+      end
+    end
+
+    def use(other)
+      return unless other
+      other.each do |s|
+        next if search_by_spec(s).any?
+        @specs[s.name] << s
+      end
+      self
+    end
+
+    def ==(o)
+      all? do |s|
+        s2 = o[s].first and (s.dependencies & s2.dependencies).empty?
+      end
+    end
+
+  private
+
+    def search_by_spec(spec)
+      @specs[spec.name].select do |s|
+        same_version?(s.version, spec.version) && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
+      end
+    end
+
+    def same_version?(a, b)
+      regex = /^(.*?)(?:\.0)*$/
+
+      a.to_s[regex, 1] == b.to_s[regex, 1]
+    end
+
+    def spec_satisfies_dependency?(spec, dep)
+      return false unless dep.name === spec.name
+      dep.requirement.satisfied_by?(spec.version)
+    end
+
+    def search_by_dependency(dependency)
+      @cache[dependency.hash] ||= begin
+        specs = @specs[dependency.name]
+
+        wants_prerelease = dependency.requirement.prerelease?
+        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+        found = specs.select { |spec| dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform) }
+
+        unless wants_prerelease || only_prerelease
+          found.reject! { |spec| spec.version.prerelease? }
+        end
+
+        found.sort_by {|s| [s.version, s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s] }
+      end
+    end
+  end
+end

data/lib/bundler/installer.rb

@@ -0,0 +1,117 @@
+require 'erb'
+require 'rubygems/dependency_installer'
+
+module Bundler
+  class Installer < Environment
+    def self.install(root, definition, options = {})
+      installer = new(root, definition)
+      installer.run(options)
+      installer
+    end
+
+    def run(options)
+      if Bundler.settings[:frozen]
+        @definition.ensure_equivalent_gemfile_and_lockfile
+      end
+
+      if dependencies.empty?
+        Bundler.ui.warn "The Gemfile specifies no dependencies"
+        return
+      end
+
+      if Bundler.default_lockfile.exist? && !options["update"]
+        begin
+          tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
+          local = true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
+        rescue BundlerError
+        end
+      end
+
+      # Since we are installing, we can resolve the definition
+      # using remote specs
+      unless local
+        options["local"] ?
+          @definition.resolve_with_cache! :
+          @definition.resolve_remotely!
+      end
+
+      # Ensure that BUNDLE_PATH exists
+      Bundler.mkdir_p(Bundler.bundle_path) unless File.exist?(Bundler.bundle_path)
+
+      # Must install gems in the order that the resolver provides
+      # as dependencies might actually affect the installation of
+      # the gem.
+      specs.each do |spec|
+        spec.source.fetch(spec) if spec.source.respond_to?(:fetch)
+
+        # unless requested_specs.include?(spec)
+        #   Bundler.ui.debug "  * Not in requested group; skipping."
+        #   next
+        # end
+
+        begin
+          old_args = Gem::Command.build_args
+          Gem::Command.build_args = [Bundler.settings["build.#{spec.name}"]]
+          spec.source.install(spec)
+          Bundler.ui.debug "from #{spec.loaded_from} "
+        ensure
+          Gem::Command.build_args = old_args
+        end
+
+        Bundler.ui.info ""
+        generate_bundler_executable_stubs(spec) if Bundler.settings[:bin]
+        FileUtils.rm_rf(Bundler.tmp)
+      end
+
+      lock
+      generate_standalone(options[:standalone]) if options[:standalone]
+    end
+
+  private
+
+    def generate_bundler_executable_stubs(spec)
+      bin_path = Bundler.bin_path
+      template = File.read(File.expand_path('../templates/Executable', __FILE__))
+      relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)
+      ruby_command = Thor::Util.ruby_command
+
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+        File.open "#{bin_path}/#{executable}", 'w', 0755 do |f|
+          f.puts ERB.new(template, nil, '-').result(binding)
+        end
+      end
+    end
+
+    def generate_standalone(groups)
+      path = Bundler.settings[:path]
+      bundler_path = File.join(path, "bundler")
+      FileUtils.mkdir_p(bundler_path)
+
+      paths = []
+
+      if groups.empty?
+        specs = Bundler.definition.requested_specs
+      else
+        specs = Bundler.definition.specs_for groups.map { |g| g.to_sym }
+      end
+
+      specs.each do |spec|
+        next if spec.name == "bundler"
+
+        spec.require_paths.each do |path|
+          full_path = File.join(spec.full_gem_path, path)
+          paths << Pathname.new(full_path).relative_path_from(Bundler.root.join("bundle/bundler"))
+        end
+      end
+
+
+      File.open File.join(bundler_path, "setup.rb"), "w" do |file|
+        file.puts "path = File.expand_path('..', __FILE__)"
+        paths.each do |path|
+          file.puts %{$:.unshift File.expand_path("\#{path}/#{path}")}
+        end
+      end
+    end
+  end
+end

data/lib/bundler/lazy_specification.rb

@@ -0,0 +1,71 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Bundler
+  class LazySpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :dependencies, :platform
+    attr_accessor :source
+
+    def initialize(name, version, platform, source = nil)
+      @name          = name
+      @version       = version
+      @dependencies  = []
+      @platform      = platform
+      @source        = source
+      @specification = nil
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    def satisfies?(dependency)
+      @name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))
+    end
+
+    def to_lock
+      if platform == Gem::Platform::RUBY or platform.nil?
+        out = "    #{name} (#{version})\n"
+      else
+        out = "    #{name} (#{version}-#{platform})\n"
+      end
+
+      dependencies.sort_by {|d| d.name }.each do |dep|
+        next if dep.type == :development
+        out << "    #{dep.to_lock}\n"
+      end
+
+      out
+    end
+
+    def __materialize__
+      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+    end
+
+    def respond_to?(*args)
+      super || @specification.respond_to?(*args)
+    end
+
+    def to_s
+      "#{name} (#{version})"
+    end
+
+  private
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+        @specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+
+  end
+end