shopify-bundler 1.10.7

data/lib/bundler/gem_helpers.rb

@@ -0,0 +1,26 @@
+module Bundler
+  module GemHelpers
+
+    GENERIC_CACHE = {}
+    GENERICS = [
+      [Gem::Platform.new("java"), Gem::Platform.new("java")],
+      [Gem::Platform.new("mswin32"), Gem::Platform.new("mswin32")],
+      [Gem::Platform.new("mswin64"), Gem::Platform.new("mswin64")],
+      [Gem::Platform.new("universal-mingw32"), Gem::Platform.new("universal-mingw32")],
+      [Gem::Platform.new("x64-mingw32"), Gem::Platform.new("x64-mingw32")],
+      [Gem::Platform.new("x86_64-mingw32"), Gem::Platform.new("x64-mingw32")],
+      [Gem::Platform.new("mingw32"), Gem::Platform.new("x86-mingw32")]
+    ]
+
+    def generic(p)
+      return p if p == Gem::Platform::RUBY
+
+      GENERIC_CACHE[p] ||= begin
+        _, found = GENERICS.find do |match, _generic|
+          p.os == match.os && (!match.cpu || p.cpu == match.cpu)
+        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_path_manipulation.rb

@@ -0,0 +1,8 @@
+module Bundler
+  def self.preserve_gem_path
+    original_gem_path = ENV["_ORIGINAL_GEM_PATH"]
+    gem_path          = ENV["GEM_PATH"]
+    ENV["_ORIGINAL_GEM_PATH"] = gem_path          if original_gem_path.nil? || original_gem_path == ""
+    ENV["GEM_PATH"]           = original_gem_path if gem_path.nil? || gem_path == ""
+  end
+end

data/lib/bundler/gem_tasks.rb

@@ -0,0 +1,5 @@
+require "rake/clean"
+CLOBBER.include "pkg"
+
+require "bundler/gem_helper"
+Bundler::GemHelper.install_tasks

data/lib/bundler/graph.rb

@@ -0,0 +1,173 @@
+require "set"
+module Bundler
+  class Graph
+    GRAPH_NAME = :Gemfile
+
+    def initialize(env, output_file, show_version = false, show_requirements = false, output_format = "png", without = [])
+      @env               = env
+      @output_file       = output_file
+      @show_version      = show_version
+      @show_requirements = show_requirements
+      @output_format     = output_format
+      @without_groups    = without.map(&:to_sym)
+
+      @groups            = []
+      @relations         = Hash.new {|h, k| h[k] = Set.new }
+      @node_options      = {}
+      @edge_options      = {}
+
+      _patching_gem_dependency_class
+      _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
+      parent_dependencies = _groups.values.to_set.flatten
+      loop do
+        if parent_dependencies.empty?
+          break
+        else
+          tmp = Set.new
+          parent_dependencies.each do |dependency|
+            # if the dependency is a prerelease, allow to_spec to be non-nil
+            dependency.prerelease = true
+
+            child_dependencies = dependency.to_spec.runtime_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
+    end
+
+    def _groups
+      relations = Hash.new {|h, k| h[k] = Set.new }
+      @env.current_dependencies.each do |dependency|
+        dependency.groups.each do |group|
+          next if @without_groups.include?(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}" 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
+
+    def _patching_gem_dependency_class
+      # method borrow from rubygems/dependency.rb
+      # redefinition of matching_specs will also redefine to_spec and to_specs
+      Gem::Dependency.class_eval do
+        def matching_specs(platform_only = false)
+          matches = Bundler.load.specs.select { |spec|
+            self.name == spec.name and
+              requirement.satisfied_by? spec.version
+          }
+
+          if platform_only
+            matches.select! { |spec|
+              Gem::Platform.match spec.platform
+            }
+          end
+
+          matches = matches.sort_by(&:sort_obj) # HACK: shouldn't be needed
+        end
+      end
+    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
+        @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,199 @@
+require "set"
+
+module Bundler
+  class Index
+    include Enumerable
+
+    def self.build
+      i = new
+      yield i
+      i
+    end
+
+    attr_reader :specs, :all_specs, :sources
+    protected :specs, :all_specs
+
+    RUBY = "ruby".freeze
+    NULL = "\0".freeze
+
+    def initialize
+      @sources = []
+      @cache = {}
+      @specs = Hash.new {|h, k| h[k] = {} }
+      @all_specs = Hash.new {|h, k| h[k] = [] }
+    end
+
+    def initialize_copy(o)
+      super
+      @sources = @sources.dup
+      @cache = {}
+      @specs = Hash.new {|h, k| h[k] = {} }
+      @all_specs = Hash.new {|h, k| h[k] = [] }
+
+      o.specs.each do |name, hash|
+        @specs[name] = hash.dup
+      end
+      o.all_specs.each do |name, array|
+        @all_specs[name] = array.dup
+      end
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{object_id} sources=#{sources.map(&:inspect)} specs.size=#{specs.size}>"
+    end
+
+    def empty?
+      each { return false }
+      true
+    end
+
+    def search_all(name)
+      all_matches = @all_specs[name] + local_search(name)
+      @sources.each do |source|
+        all_matches.concat(source.search_all(name))
+      end
+      all_matches
+    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|
+          lookup = [spec.name, spec.version, spec.platform]
+          unless seen.include?(lookup)
+            results << spec
+            seen << lookup
+          end
+        end
+      end
+
+      results.sort_by {|s| [s.version, s.platform.to_s == RUBY ? NULL : s.platform.to_s] }
+    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
+
+    alias_method :[], :search
+
+    def <<(spec)
+      @specs[spec.name]["#{spec.version}-#{spec.platform}"] = spec
+
+      spec
+    end
+
+    def each(&blk)
+      specs.values.each do |spec_sets|
+        spec_sets.values.each(&blk)
+      end
+    end
+
+    # returns a list of the dependencies
+    def unmet_dependency_names
+      names = dependency_names
+      names.delete_if {|n| n == "bundler" }
+      names.select {|n| search(n).empty? }
+    end
+
+    def dependency_names
+      names = []
+      each {|s| names.push(*s.dependencies.map(&:name)) }
+      names.uniq
+    end
+
+    def use(other, override_dupes = false)
+      return unless other
+      other.each do |s|
+        if (dupes = search_by_spec(s)) && dupes.any?
+          @all_specs[s.name] = [s] + dupes
+          next unless override_dupes
+          self << s
+        end
+        self << s
+      end
+      self
+    end
+
+    def size
+      @sources.inject(@specs.size) do |size, source|
+        size += source.size
+      end
+    end
+
+    def ==(other)
+      all? do |spec|
+        other_spec = other[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].values
+    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
+      end
+    end
+
+    def search_by_spec(spec)
+      spec = @specs[spec.name]["#{spec.version}-#{spec.platform}"]
+      spec ? [spec] : []
+    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/injector.rb

@@ -0,0 +1,62 @@
+module Bundler
+  class Injector
+    def self.inject(new_deps)
+      injector = new(new_deps)
+      injector.inject(Bundler.default_gemfile, Bundler.default_lockfile)
+    end
+
+    def initialize(new_deps)
+      @new_deps = new_deps
+    end
+
+    def inject(gemfile_path, lockfile_path)
+      if Bundler.settings[:frozen]
+        # ensure the lock and Gemfile are synced
+        Bundler.definition.ensure_equivalent_gemfile_and_lockfile(true)
+        # temporarily remove frozen while we inject
+        frozen = Bundler.settings.delete(:frozen)
+      end
+
+      # evaluate the Gemfile we have now
+      builder = Dsl.new
+      builder.eval_gemfile(gemfile_path)
+
+      # don't inject any gems that are already in the Gemfile
+      @new_deps -= builder.dependencies
+
+      # add new deps to the end of the in-memory Gemfile
+      builder.eval_gemfile("injected gems", new_gem_lines) if @new_deps.any?
+
+      # resolve to see if the new deps broke anything
+      definition = builder.to_definition(lockfile_path, {})
+      definition.resolve_remotely!
+
+      # since nothing broke, we can add those gems to the gemfile
+      append_to(gemfile_path) if @new_deps.any?
+
+      # since we resolved successfully, write out the lockfile
+      definition.lock(Bundler.default_lockfile)
+
+      # return an array of the deps that we added
+      return @new_deps
+    ensure
+      Bundler.settings[:frozen] = "1" if frozen
+    end
+
+  private
+
+    def new_gem_lines
+      @new_deps.map do |d|
+        %|gem '#{d.name}', '#{d.requirement}'|
+      end.join("\n")
+    end
+
+    def append_to(gemfile_path)
+      gemfile_path.open("a") do |f|
+        f.puts
+        f.puts "# Added at #{Time.now} by #{`whoami`.chomp}:"
+        f.puts new_gem_lines
+      end
+    end
+  end
+end