honkster-bundler 1.1.pre

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|
+        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,114 @@
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    def initialize
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @cache = {}
+      @specs = Hash.new { |h,k| h[k] = [] }
+      merge!(o)
+    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 =~ 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|
+        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|
+        s.version == spec.version && Gem::Platform.new(s.platform) == Gem::Platform.new(spec.platform)
+      end
+    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 =~ 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,84 @@
+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)
+        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
+    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
+  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

data/lib/bundler/lockfile_parser.rb

@@ -0,0 +1,108 @@
+require "strscan"
+
+module Bundler
+  class LockfileParser
+    attr_reader :sources, :dependencies, :specs, :platforms
+
+    def initialize(lockfile)
+      @platforms    = []
+      @sources      = []
+      @dependencies = []
+      @specs        = []
+      @state        = :source
+
+      lockfile.split(/(\r?\n)+/).each do |line|
+        if line == "DEPENDENCIES"
+          @state = :dependency
+        elsif line == "PLATFORMS"
+          @state = :platform
+        else
+          send("parse_#{@state}", line)
+        end
+      end
+    end
+
+  private
+
+    TYPES = {
+      "GIT"  => Bundler::Source::Git,
+      "GEM"  => Bundler::Source::Rubygems,
+      "PATH" => Bundler::Source::Path
+    }
+
+    def parse_source(line)
+      case line
+      when "GIT", "GEM", "PATH"
+        @current_source = nil
+        @opts, @type = {}, line
+      when "  specs:"
+        @current_source = TYPES[@type].from_lock(@opts)
+        @sources << @current_source
+      when /^  ([a-z]+): (.*)$/i
+        value = $2
+        value = true if value == "true"
+        value = false if value == "false"
+
+        key = $1
+
+        if @opts[key]
+          @opts[key] = Array(@opts[key])
+          @opts[key] << value
+        else
+          @opts[key] = value
+        end
+      else
+        parse_spec(line)
+      end
+    end
+
+    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+
+    def parse_dependency(line)
+      if line =~ %r{^ {2}#{NAME_VERSION}(!)?$}
+        name, version, pinned = $1, $2, $4
+        version = version.split(",").map { |d| d.strip } if version
+
+        dep = Bundler::Dependency.new(name, version)
+
+        if pinned && dep.name != 'bundler'
+          spec = @specs.find { |s| s.name == dep.name }
+          dep.source = spec.source if spec
+
+          # Path sources need to know what the default name / version
+          # to use in the case that there are no gemspecs present. A fake
+          # gemspec is created based on the version set on the dependency
+          # TODO: Use the version from the spec instead of from the dependency
+          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Bundler::Source::Path)
+            dep.source.name    = name
+            dep.source.version = $1
+          end
+        end
+
+        @dependencies << dep
+      end
+    end
+
+    def parse_spec(line)
+      if line =~ %r{^ {4}#{NAME_VERSION}$}
+        name, version = $1, Gem::Version.new($2)
+        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        @current_spec = LazySpecification.new(name, version, platform)
+        @current_spec.source = @current_source
+        @specs << @current_spec
+      elsif line =~ %r{^ {6}#{NAME_VERSION}$}
+        name, version = $1, $2
+        version = version.split(',').map { |d| d.strip } if version
+        dep = Gem::Dependency.new(name, version)
+        @current_spec.dependencies << dep
+      end
+    end
+
+    def parse_platform(line)
+      if line =~ /^  (.*)$/
+        @platforms << Gem::Platform.new($1)
+      end
+    end
+
+  end
+end