bundler 0.9.26 → 1.0.0.beta.1

data/lib/bundler/environment.rb

@@ -1,5 +1,3 @@
-require 'erb'
-
 module Bundler
   class Environment
     attr_reader :root
@@ -9,130 +7,36 @@ module Bundler
       @definition = definition
     end
 
+    # TODO: Remove this method. It's used in cli.rb still
     def index
-      @index ||= Index.build do |idx|
-        idx.use runtime_gems
-        idx.use Index.cached_gems
-      end
+      @definition.index
     end
 
     def requested_specs
-      @requested_specs ||= begin
-        groups = @definition.groups - Bundler.settings.without
-        groups.map! { |g| g.to_sym }
-        groups.any? ? specs_for(groups) : []
-      end
+      @definition.requested_specs
     end
 
     def specs
-      @specs ||= resolve_locally || resolve_remotely
+      @definition.specs
     end
 
-  private
-
-    def sources
-      @definition.sources
+    def dependencies
+      @definition.dependencies
     end
 
-    def runtime_gems
-      @runtime_gems ||= Index.build do |i|
-        sources.each do |s|
-          i.use s.local_specs if s.respond_to?(:local_specs)
-        end
-
-        i.use Index.installed_gems
-      end
+    def current_dependencies
+      @definition.current_dependencies
     end
 
-    def resolve(type, index)
-      source_requirements = {}
-      actual_dependencies.each do |dep|
-        next unless dep.source && dep.source.respond_to?(type)
-        source_requirements[dep.name] = dep.source.send(type)
+    def lock
+      File.open(root.join('Gemfile.lock'), 'w') do |f|
+        f.puts @definition.to_lock
       end
-
-      # Run a resolve against the locally available gems
-      Resolver.resolve(actual_dependencies, index, source_requirements)
     end
 
-    def resolve_locally
-      resolve(:local_specs, index)
+    def update(*gems)
+      # Nothing
     end
 
-    def resolve_remotely
-      raise NotImplementedError
-    end
-
-    def specs_for(groups)
-      deps = dependencies.select { |d| (d.groups & groups).any? }
-      # deps.any? ? specs.for(deps) : specs
-      specs.for(deps)
-    end
-
-    # ==== Locking
-
-    def locked?
-      File.exist?("#{root}/Gemfile.lock")
-    end
-
-    def write_rb_lock
-      shared_helpers = File.read(File.expand_path("../shared_helpers.rb", __FILE__))
-      template = File.read(File.expand_path("../templates/environment.erb", __FILE__))
-      erb = ERB.new(template, nil, '-')
-      Bundler.env_file.dirname.mkpath
-      File.open(Bundler.env_file, 'w') do |f|
-        f.puts erb.result(binding)
-      end
-    end
-
-    def gemfile_fingerprint
-      Digest::SHA1.hexdigest(File.read("#{root}/Gemfile"))
-    end
-
-    def specs_for_lock_file
-      requested_specs.map do |s|
-        hash = {
-          :name => s.name,
-          :load_paths => s.load_paths
-        }
-        if s.respond_to?(:relative_loaded_from) && s.relative_loaded_from
-          hash[:virtual_spec] = s.to_ruby
-        end
-        hash[:loaded_from] = s.loaded_from.to_s
-        hash
-      end
-    end
-
-    def autorequires_for_groups(*groups)
-      groups.map! { |g| g.to_sym }
-      autorequires = Hash.new { |h,k| h[k] = [] }
-
-      ordered_deps = []
-      specs = groups.any? ? specs_for(groups) : requested_specs
-      specs.each do |g|
-        dep = @definition.dependencies.find{|d| d.name == g.name }
-        ordered_deps << dep if dep && !ordered_deps.include?(dep)
-      end
-
-      ordered_deps.each do |dep|
-        dep.groups.each do |group|
-          # If there is no autorequire, then rescue from
-          # autorequiring the gems name
-          if dep.autorequire
-            dep.autorequire.each do |file|
-              autorequires[group] << [file, true]
-            end
-          else
-            autorequires[group] << [dep.name, false]
-          end
-        end
-      end
-
-      if groups.empty?
-        autorequires
-      else
-        groups.inject({}) { |h,g| h[g] = autorequires[g]; h }
-      end
-    end
   end
 end

data/lib/bundler/graph.rb

@@ -0,0 +1,130 @@
+module Bundler
+  class Graph
+
+    USER_OPTIONS = {:style => 'filled, bold', :fillcolor => '#cccccc'}.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, :dpi => 65 } )
+      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 => 'folder', :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

@@ -6,43 +6,6 @@ module Bundler
       i
     end
 
-    def self.installed_gems
-      build do |idx|
-        idx.use bundler_gems
-        idx.use system_gems
-      end
-    end
-
-    def self.bundler_gems
-      Source::BundlerGems.new.specs
-    end
-
-    def self.system_gems
-      Source::SystemGems.new.specs
-    end
-
-    def self.cached_gems
-      build do |idx|
-        idx.use application_cached_gems
-        idx.use system_cached_gems
-      end
-    end
-
-    def self.application_cached_gems
-      path = "#{Bundler.root}/vendor/cache"
-      if File.directory?(path)
-        from_cached_specs(path)
-      end
-    end
-
-    def self.system_cached_gems
-      from_cached_specs("#{Bundler.bundle_path}/cache")
-    end
-
-    def self.from_cached_specs(path)
-      Source::GemCache.new("path" => path).specs
-    end
-
     def initialize
       @cache = {}
       @specs = Hash.new { |h,k| h[k] = [] }
@@ -62,12 +25,26 @@ module Bundler
 
     def search(query)
       case query
-      when Gem::Specification, RemoteSpecification then search_by_spec(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)
+      specs = @specs[dependency.name]
+
+      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 }
@@ -105,7 +82,9 @@ module Bundler
   private
 
     def search_by_spec(spec)
-      @specs[spec.name].select { |s| s.version == spec.version && s.platform == spec.platform }
+      @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)
@@ -114,7 +93,7 @@ module Bundler
 
         wants_prerelease = dependency.requirement.prerelease?
         only_prerelease  = specs.all? {|spec| spec.version.prerelease? }
-        found = specs.select { |spec| dependency =~ spec }
+        found = specs.select { |spec| dependency =~ spec && Gem::Platform.match(spec.platform) }
 
         unless wants_prerelease || only_prerelease
           found.reject! { |spec| spec.version.prerelease? }
@@ -123,6 +102,5 @@ module Bundler
         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

@@ -2,16 +2,22 @@ require 'rubygems/dependency_installer'
 
 module Bundler
   class Installer < Environment
-    def self.install(root, definition, options)
-      new(root, definition).run(options)
+    def self.install(root, definition, options = {})
+      installer = new(root, definition)
+      installer.run(options)
+      installer
     end
 
     def run(options)
-      if actual_dependencies.empty?
+      if dependencies.empty?
         Bundler.ui.warn "The Gemfile specifies no dependencies"
         return
       end
 
+      # Since we are installing, we can resolve the definition
+      # using remote specs
+      @definition.resolve_remotely!
+
       # Ensure that BUNDLE_PATH exists
       FileUtils.mkdir_p(Bundler.bundle_path)
 
@@ -21,72 +27,30 @@ module Bundler
       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
+        # unless requested_specs.include?(spec)
+        #   Bundler.ui.debug "  * Not in requested group; skipping."
+        #   next
+        # end
 
-        if [Source::Rubygems, Source::GemCache].include?(spec.source.class)
-          Bundler.ui.info "Installing #{spec.name} (#{spec.version}) from #{spec.source} "
-        else
-          Bundler.ui.info "Using #{spec.name} (#{spec.version}) from #{spec.source} "
-        end
         spec.source.install(spec)
         Bundler.ui.info ""
+        generate_bundler_executable_stubs(spec)
+        FileUtils.rm_rf(Bundler.tmp)
       end
 
-      if locked?
-        write_rb_lock
-      end
-    end
-
-    def dependencies
-      @definition.dependencies
-    end
-
-    def actual_dependencies
-      @definition.actual_dependencies
+      lock
     end
 
   private
 
-    def resolve_locally
-      # Return unless all the dependencies have = version requirements
-      return if actual_dependencies.any? { |d| ambiguous?(d) }
-
-      specs = super
-
-      # Simple logic for now. Can improve later.
-      specs.length == actual_dependencies.length && specs
-    rescue GemNotFound, PathError => e
-      nil
-    end
-
-    def resolve_remotely
-      resolve(:specs, remote_index)
-    end
-
-    def ambiguous?(dep)
-      dep.requirement.requirements.any? { |op,_| op != '=' }
-    end
-
-    def remote_index
-      @remote_index ||= Index.build do |idx|
-        rubygems, other = sources.partition { |s| Source::Rubygems === s }
-
-        other.each do |source|
-          Bundler.ui.debug "Source: Processing index"
-          idx.use source.specs
-        end
-
-        idx.use Index.installed_gems
-        idx.use Index.cached_gems
-
-        rubygems.each do |source|
-          Bundler.ui.debug "Source: Processing index"
-          idx.use source.specs
+    def generate_bundler_executable_stubs(spec)
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+        File.open "#{Bundler.bin_path}/#{executable}", 'w', 0755 do |f|
+          f.puts File.read(File.expand_path('../templates/Executable', __FILE__))
         end
       end
     end
+
   end
 end