rkh-bundler 1.2.0.pre

data/lib/bundler/gem_helpers.rb

@@ -0,0 +1,23 @@
+module Bundler
+  module GemHelpers
+
+    GENERIC_CACHE = {}
+    GENERICS = [
+      Gem::Platform.new('java'),
+      Gem::Platform.new('mswin32'),
+      Gem::Platform.new('x86-mingw32'),
+      Gem::Platform::RUBY
+    ]
+
+    def generic(p)
+      return p if p == Gem::Platform::RUBY
+
+      GENERIC_CACHE[p] ||= begin
+        found = GENERICS.find do |p2|
+          p2.is_a?(Gem::Platform) && p.os == p2.os
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+  end
+end

data/lib/bundler/gem_installer.rb

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

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

data/lib/bundler/graph.rb

@@ -0,0 +1,148 @@
+require 'set'
+module Bundler
+  class Graph
+    GRAPH_NAME = :Gemfile
+
+    def initialize(env, output_file, show_version = false, show_requirements = false, output_format = "png")
+      @env               = env
+      @output_file       = output_file
+      @show_version      = show_version
+      @show_requirements = show_requirements
+      @output_format     = output_format
+
+      @groups            = []
+      @relations         = Hash.new {|h, k| h[k] = Set.new}
+      @node_options      = {}
+      @edge_options      = {}
+
+      _populate_relations
+    end
+
+    attr_reader :groups, :relations, :node_options, :edge_options, :output_file, :output_format
+
+    def viz
+      GraphVizClient.new(self).run
+    end
+
+    private
+
+    def _populate_relations
+      relations = Hash.new {|h, k| h[k] = Set.new}
+      parent_dependencies = _groups.values.to_set.flatten
+      while true
+        if parent_dependencies.empty?
+          break
+        else
+          tmp = Set.new
+          parent_dependencies.each do |dependency|
+            child_dependencies = dependency.to_spec.runtime_dependencies.to_set
+            relations[dependency.name] += child_dependencies.to_set
+            @relations[dependency.name] += child_dependencies.map(&:name).to_set
+            tmp += child_dependencies
+
+            @node_options[dependency.name] = _make_label(dependency, :node)
+            child_dependencies.each do |c_dependency|
+              @edge_options["#{dependency.name}_#{c_dependency.name}"] = _make_label(c_dependency, :edge)
+            end
+          end
+          parent_dependencies = tmp
+        end
+      end
+      @relations
+    end
+
+    def _groups
+      relations = Hash.new {|h, k| h[k] = Set.new}
+      @env.current_dependencies.each do |dependency|
+        dependency.groups.each do |group|
+          relations[group.to_s].add(dependency)
+          @relations[group.to_s].add(dependency.name)
+
+          @node_options[group.to_s] ||= _make_label(group, :node)
+          @edge_options["#{group}_#{dependency.name}"] = _make_label(dependency, :edge)
+        end
+      end
+      @groups = relations.keys
+      relations
+    end
+
+    def _make_label(symbol_or_string_or_dependency, element_type)
+      case element_type.to_sym
+      when :node
+        if symbol_or_string_or_dependency.is_a?(Gem::Dependency)
+          label = symbol_or_string_or_dependency.name.dup
+          label << "\n#{symbol_or_string_or_dependency.to_spec.version.to_s}" if @show_version
+        else
+          label = symbol_or_string_or_dependency.to_s
+        end
+      when :edge
+        label = nil
+        if symbol_or_string_or_dependency.respond_to?(:requirements_list) && @show_requirements
+          tmp = symbol_or_string_or_dependency.requirements_list.join(", ")
+          label = tmp if tmp != ">= 0"
+        end
+      else
+        raise ArgumentError, "2nd argument is invalid"
+      end
+      label.nil? ? {} : { :label => label }
+    end
+
+    class GraphVizClient
+      def initialize(graph_instance)
+        @graph_name    = graph_instance.class::GRAPH_NAME
+        @groups        = graph_instance.groups
+        @relations     = graph_instance.relations
+        @node_options  = graph_instance.node_options
+        @edge_options  = graph_instance.edge_options
+        @output_file   = graph_instance.output_file
+        @output_format = graph_instance.output_format
+      end
+
+      def g
+        require 'graphviz'
+        @g ||= ::GraphViz.digraph(@graph_name, {:concentrate => true, :normalize => true, :nodesep => 0.55}) do |g|
+          g.edge[:weight]   = 2
+          g.edge[:fontname] = g.node[:fontname] = 'Arial, Helvetica, SansSerif'
+          g.edge[:fontsize] = 12
+        end
+      end
+
+      def run
+        @groups.each do |group|
+          g.add_nodes(
+            group,
+            {:style     => 'filled',
+             :fillcolor => '#B9B9D5',
+             :shape     => "box3d",
+             :fontsize  => 16}.merge(@node_options[group])
+          )
+        end
+
+        @relations.each do |parent, children|
+          children.each do |child|
+            if @groups.include?(parent)
+              g.add_nodes(child, {:style => 'filled', :fillcolor => '#B9B9D5'}.merge(@node_options[child]))
+              g.add_edges(parent, child, {:constraint => false}.merge(@edge_options["#{parent}_#{child}"]))
+            else
+              g.add_nodes(child, @node_options[child])
+              g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
+            end
+          end
+        end
+
+        if @output_format.to_s == "debug"
+          $stdout.puts g.output :none => String
+          Bundler.ui.info "debugging bundle viz..."
+        else
+          begin
+            g.output @output_format.to_sym => "#{@output_file}.#{@output_format}"
+            Bundler.ui.info "#{@output_file}.#{@output_format}"
+          rescue ArgumentError => e
+            $stderr.puts "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bundler/index.rb

@@ -0,0 +1,187 @@
+require "set"
+
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    attr_reader :specs, :sources
+    protected   :specs
+
+    def initialize
+      @sources = []
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @sources = @sources.dup
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+
+      o.specs.each do |name, array|
+        @specs[name] = array.dup
+      end
+    end
+
+    def inspect
+      "<Index sources=#{sources.map{|s| s.inspect}} specs.size=#{specs.size}>"
+    end
+
+    def empty?
+      each { return false }
+      true
+    end
+
+    # Search this index's specs, and any source indexes that this index knows
+    # about, returning all of the results.
+    def search(query, base = nil)
+      results = local_search(query, base)
+      seen = Set.new(results.map { |spec| [spec.name, spec.version, spec.platform] })
+
+      @sources.each do |source|
+        source.search(query, base).each do |spec|
+          results << spec unless seen.include?([spec.name, spec.version, spec.platform])
+          seen << [spec.name, spec.version, spec.platform]
+        end
+      end
+
+      results
+    end
+
+    def local_search(query, base = nil)
+      case query
+      when Gem::Specification, RemoteSpecification, LazySpecification, EndpointSpecification then search_by_spec(query)
+      when String then specs_by_name(query)
+      when Gem::Dependency then search_by_dependency(query, base)
+      else
+        raise "You can't search for a #{query.inspect}."
+      end
+    end
+
+    def source_types
+      sources.map{|s| s.class }.uniq
+    end
+
+    alias [] search
+
+    def <<(spec)
+      arr = specs_by_name(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
+
+    # returns a list of the dependencies
+    def unmet_dependency_names
+      dependency_names = specs.values.map do |array_of_s|
+        array_of_s.map do |s|
+          s.dependencies.map{|d| d.name }
+        end
+      end.flatten.uniq
+      dependency_names.select{|name| specs_by_name(name).empty? }
+    end
+
+    def use(other, override_dupes = false)
+      return unless other
+      other.each do |s|
+        if (dupes = search_by_spec(s)) && dupes.any?
+          next unless override_dupes
+          @specs[s.name] -= dupes
+        end
+        @specs[s.name] << s
+      end
+      self
+    end
+
+    def size
+      @sources.inject(@specs.size) do |size, source|
+        size += source.size
+      end
+    end
+
+    def ==(o)
+      all? do |spec|
+        other_spec = o[spec].first
+        (spec.dependencies & other_spec.dependencies).empty? && spec.source == other_spec.source
+      end
+    end
+
+    def add_source(index)
+      if index.is_a?(Index)
+        @sources << index
+        @sources.uniq! # need to use uniq! here instead of checking for the item before adding
+      else
+        raise ArgumentError, "Source must be an index, not #{index.class}"
+      end
+    end
+
+  private
+
+    def specs_by_name(name)
+      @specs[name]
+    end
+
+    def search_by_dependency(dependency, base = nil)
+      @cache[base || false] ||= {}
+      @cache[base || false][dependency] ||= begin
+        specs = specs_by_name(dependency.name) + (base || [])
+        found = specs.select do |spec|
+          if base # allow all platforms when searching from a lockfile
+            dependency.matches_spec?(spec)
+          else
+            dependency.matches_spec?(spec) && Gem::Platform.match(spec.platform)
+          end
+        end
+
+        wants_prerelease = dependency.requirement.prerelease?
+        only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
+
+        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
+
+    def search_by_spec(spec)
+      specs_by_name(spec.name).select do |s|
+        same_version?(s.version, spec.version) && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
+      end
+    end
+
+    if RUBY_VERSION < '1.9'
+      def same_version?(a, b)
+        regex = /^(.*?)(?:\.0)*$/
+        a.to_s[regex, 1] == b.to_s[regex, 1]
+      end
+    else
+      def same_version?(a, b)
+        a == b
+      end
+    end
+
+    def spec_satisfies_dependency?(spec, dep)
+      return false unless dep.name === spec.name
+      dep.requirement.satisfied_by?(spec.version)
+    end
+
+  end
+end

data/lib/bundler/installer.rb

@@ -0,0 +1,190 @@
+require 'erb'
+require 'rubygems/dependency_installer'
+
+module Bundler
+  class Installer < Environment
+    class << self
+      attr_accessor :post_install_messages
+    end
+
+    # Begins the installation process for Bundler.
+    # For more information see the #run method on this class.
+    def self.install(root, definition, options = {})
+      installer = new(root, definition)
+      installer.run(options)
+      installer
+    end
+
+    # Runs the install procedures for a specific Gemfile.
+    #
+    # Firstly, this method will check to see if Bundler.bundle_path exists 
+    # and if not then will create it. This is usually the location of gems
+    # on the system, be it RVM or at a system path.
+    # 
+    # Secondly, it checks if Bundler has been configured to be "frozen"
+    # Frozen ensures that the Gemfile and the Gemfile.lock file are matching.
+    # This stops a situation where a developer may update the Gemfile but may not run
+    # `bundle install`, which leads to the Gemfile.lock file not being correctly updated.
+    # If this file is not correctly updated then any other developer running
+    # `bundle install` will potentially not install the correct gems.
+    #
+    # Thirdly, Bundler checks if there are any dependencies specified in the Gemfile using 
+    # Bundler::Environment#dependencies. If there are no dependencies specified then
+    # Bundler returns a warning message stating so and this method returns.
+    #
+    # Fourthly, Bundler checks if the default lockfile (Gemfile.lock) exists, and if so
+    # then proceeds to set up a defintion based on the default gemfile (Gemfile) and the
+    # default lock file (Gemfile.lock). However, this is not the case if the platform is different
+    # to that which is specified in Gemfile.lock, or if there are any missing specs for the gems.
+    #
+    # Fifthly, Bundler resolves the dependencies either through a cache of gems or by remote.
+    # This then leads into the gems being installed, along with stubs for their executables,
+    # but only if the --binstubs option has been passed or Bundler.options[:bin] has been set
+    # earlier. 
+    # 
+    # Sixthly, a new Gemfile.lock is created from the installed gems to ensure that the next time
+    # that a user runs `bundle install` they will receive any updates from this process.
+    # 
+    # Finally: TODO add documentation for how the standalone process works.
+    def run(options)
+      # Create the BUNDLE_PATH directory
+      begin
+        Bundler.bundle_path.mkpath unless Bundler.bundle_path.exist?
+      rescue Errno::EEXIST
+        raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " +
+          "because of an invalid symlink. Remove the symlink so the directory can be created."
+      end
+
+      if Bundler.settings[:frozen]
+        @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
+      end
+
+      if dependencies.empty?
+        Bundler.ui.warn "The Gemfile specifies no dependencies"
+        lock
+        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
+
+      # Must install gems in the order that the resolver provides
+      # as dependencies might actually affect the installation of
+      # the gem.
+      Installer.post_install_messages = {}
+      specs.each do |spec|
+        install_gem_from_spec(spec, options[:standalone])
+      end
+
+      lock
+      generate_standalone(options[:standalone]) if options[:standalone]
+    end
+
+  private
+
+    def install_gem_from_spec(spec, standalone = false)
+      # Download the gem to get the spec, because some specs that are returned
+      # by rubygems.org are broken and wrong.
+      Bundler::Fetcher.fetch(spec) if spec.source.is_a?(Bundler::Source::Rubygems)
+
+      # Fetch the build settings, if there are any
+      settings = Bundler.settings["build.#{spec.name}"]
+      Bundler.rubygems.with_build_args [settings] do
+        spec.source.install(spec)
+        Bundler.ui.debug "from #{spec.loaded_from} "
+      end
+
+      # newline comes after installing, some gems say "with native extensions"
+      Bundler.ui.info ""
+      if Bundler.settings[:bin]
+        standalone ? generate_standalone_bundler_executable_stubs(spec) : generate_bundler_executable_stubs(spec)
+      end
+
+      FileUtils.rm_rf(Bundler.tmp)
+    rescue Exception => e
+      # install hook failed
+      raise e if e.is_a?(Bundler::InstallHookError)
+
+      # other failure, likely a native extension build failure
+      Bundler.ui.info ""
+      Bundler.ui.warn "#{e.class}: #{e.message}"
+      msg = "An error occurred while installing #{spec.name} (#{spec.version}),"
+      msg << " and Bundler cannot continue.\nMake sure that `gem install"
+      msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+      raise Bundler::InstallError, msg
+    end
+
+    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_bundler_executable_stubs(spec)
+      bin_path = Bundler.bin_path
+      template = File.read(File.expand_path('../templates/Executable.standalone', __FILE__))
+      ruby_command = Thor::Util.ruby_command
+
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+        standalone_path = Pathname(Bundler.settings[:path]).expand_path.relative_path_from(bin_path)
+        executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
+        File.open "#{bin_path}/#{executable}", 'w', 0755 do |f|
+          f.puts ERB.new(template, nil, '-').result(binding)
+        end
+      end
+    end
+
+    def generate_standalone(groups)
+      standalone_path = Bundler.settings[:path]
+      bundler_path = File.join(standalone_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(bundler_path))
+        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