shopify-bundler 1.10.7

data/lib/bundler/lazy_specification.rb

@@ -0,0 +1,82 @@
+require "uri"
+require "rubygems/spec_fetcher"
+require "bundler/match_platform"
+
+module Bundler
+  class LazySpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :dependencies, :platform
+    attr_accessor :source, :remote
+
+    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?
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    def ==(other)
+      identifier == other.identifier
+    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(&:to_s).uniq.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
+      @__to_s ||= "#{name} (#{version})"
+    end
+
+    def identifier
+      @__identifier ||= [name, version, source, platform, dependencies].hash
+    end
+
+  private
+
+    def to_ary
+      nil
+    end
+
+    def method_missing(method, *args, &blk)
+      raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+
+      return super unless respond_to?(method)
+
+      @specification.send(method, *args, &blk)
+    end
+  end
+end

data/lib/bundler/lockfile_parser.rb

@@ -0,0 +1,199 @@
+require "strscan"
+
+# Some versions of the Bundler 1.1 RC series introduced corrupted
+# lockfiles. There were two major problems:
+#
+# * multiple copies of the same GIT section appeared in the lockfile
+# * when this happened, those sections got multiple copies of gems
+#   in those sections.
+#
+# As a result, Bundler 1.1 contains code that fixes the earlier
+# corruption. We will remove this fix-up code in Bundler 1.2.
+
+module Bundler
+  class LockfileParser
+    attr_reader :sources, :dependencies, :specs, :platforms, :bundler_version
+
+    BUNDLED      = "BUNDLED WITH"
+    DEPENDENCIES = "DEPENDENCIES"
+    PLATFORMS    = "PLATFORMS"
+    GIT          = "GIT"
+    GEM          = "GEM"
+    PATH         = "PATH"
+    SPECS        = "  specs:"
+    OPTIONS      = /^  ([a-z]+): (.*)$/i
+    SOURCE       = [GIT, GEM, PATH]
+
+    def initialize(lockfile)
+      @platforms    = []
+      @sources      = []
+      @dependencies = []
+      @state        = nil
+      @specs        = {}
+
+      @rubygems_aggregate = Source::Rubygems.new
+
+      if lockfile.match(/<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|/)
+        raise LockfileError, "Your #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)} contains merge conflicts.\n" \
+          "Run `git checkout HEAD -- #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}` first to get a clean lock."
+      end
+
+      lockfile.split(/(?:\r?\n)+/).each do |line|
+        if SOURCE.include?(line)
+          @state = :source
+          parse_source(line)
+        elsif line == DEPENDENCIES
+          @state = :dependency
+        elsif line == PLATFORMS
+          @state = :platform
+        elsif line == BUNDLED
+          @state = :bundled_with
+        elsif line =~ /^[^\s]/
+          @state = nil
+        elsif @state
+          send("parse_#{@state}", line)
+        end
+      end
+      @sources << @rubygems_aggregate
+      @specs = @specs.values
+      warn_for_outdated_bundler_version
+    rescue ArgumentError => e
+      Bundler.ui.debug(e)
+      raise LockfileError, "Your lockfile is unreadable. Run `rm #{Bundler.default_lockfile.relative_path_from(SharedHelpers.pwd)}` " \
+        "and then `bundle install` to generate a new lockfile."
+    end
+
+    def warn_for_outdated_bundler_version
+      return unless bundler_version
+      prerelease_text = bundler_version.prerelease? ? " --pre" : ""
+      current_version = Gem::Version.create(Bundler::VERSION)
+      case current_version.segments.first <=> bundler_version.segments.first
+      when -1
+        raise LockfileError, "You must use Bundler #{bundler_version.segments.first} or greater with this lockfile."
+      when 0
+        if current_version < bundler_version
+          Bundler.ui.warn "Warning: the running version of Bundler is older " \
+               "than the version that created the lockfile. We suggest you " \
+               "upgrade to the latest version of Bundler by running `gem " \
+               "install bundler#{prerelease_text}`.\n"
+        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
+        case @type
+        when PATH
+          @current_source = TYPES[@type].from_lock(@opts)
+          @sources << @current_source
+        when GIT
+          @current_source = TYPES[@type].from_lock(@opts)
+          # Strip out duplicate GIT sections
+          if @sources.include?(@current_source)
+            @current_source = @sources.find {|s| s == @current_source }
+          else
+            @sources << @current_source
+          end
+        when GEM
+          Array(@opts["remote"]).each do |url|
+            @rubygems_aggregate.add_remote(url)
+          end
+          @current_source = @rubygems_aggregate
+        end
+      when OPTIONS
+        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 = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+    NAME_VERSION_2 = /^ {2}#{NAME_VERSION}(!)?$/
+    NAME_VERSION_4 = /^ {4}#{NAME_VERSION}$/
+    NAME_VERSION_6 = /^ {6}#{NAME_VERSION}$/
+
+    def parse_dependency(line)
+      if line =~ NAME_VERSION_2
+        name = $1
+        version = $2
+        pinned = $4
+        version = version.split(",").map(&:strip) if version
+
+        dep = Bundler::Dependency.new(name, version)
+
+        if pinned && dep.name != "bundler"
+          spec = @specs.find {|_, v| v.name == dep.name }
+          dep.source = spec.last.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 =~ NAME_VERSION_4
+        name = $1
+        version = 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
+
+        # Avoid introducing multiple copies of the same spec (caused by
+        # duplicate GIT sections)
+        @specs[@current_spec.identifier] ||= @current_spec
+      elsif line =~ NAME_VERSION_6
+        name = $1
+        version = $2
+        version = version.split(",").map(&: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
+
+    def parse_bundled_with(line)
+      line = line.strip
+      if Gem::Version.correct?(line)
+        @bundler_version = Gem::Version.create(line)
+      end
+    end
+  end
+end

data/lib/bundler/match_platform.rb

@@ -0,0 +1,13 @@
+require "bundler/gem_helpers"
+
+module Bundler
+  module MatchPlatform
+    include GemHelpers
+
+    def match_platform(p)
+      Gem::Platform::RUBY == platform or
+      platform.nil? or p == platform or
+      generic(Gem::Platform.new(platform)) === p
+    end
+  end
+end

data/lib/bundler/psyched_yaml.rb

@@ -0,0 +1,26 @@
+# Psych could be a gem, so try to ask for it
+begin
+  gem "psych"
+rescue LoadError
+end if defined?(gem)
+
+# Psych could just be in the stdlib
+# but it's too late if Syck is already loaded
+begin
+  require "psych" unless defined?(Syck)
+rescue LoadError
+  # Apparently Psych wasn't available. Oh well.
+end
+
+# At least load the YAML stdlib, whatever that may be
+require "yaml" unless defined?(YAML.dump)
+
+module Bundler
+  # On encountering invalid YAML,
+  # Psych raises Psych::SyntaxError
+  if defined?(::Psych::SyntaxError)
+    YamlSyntaxError = ::Psych::SyntaxError
+  else # Syck raises ArgumentError
+    YamlSyntaxError = ::ArgumentError
+  end
+end

data/lib/bundler/remote_specification.rb

@@ -0,0 +1,82 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Bundler
+  # Represents a lazily loaded gem specification, where the full specification
+  # is on the source server in rubygems' "quick" index. The proxy object is to
+  # be seeded with what we're given from the source's abbreviated index - the
+  # full specification will only be fetched when necessary.
+  class RemoteSpecification
+    include MatchPlatform
+    include Comparable
+
+    attr_reader :name, :version, :platform
+    attr_accessor :source, :remote
+
+    def initialize(name, version, platform, spec_fetcher)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @spec_fetcher = spec_fetcher
+    end
+
+    # Needed before installs, since the arch matters then and quick
+    # specs don't bother to include the arch in the platform string
+    def fetch_platform
+      @platform = _remote_specification.platform
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil?
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    # Compare this specification against another object. Using sort_obj
+    # is compatible with Gem::Specification and other Bundler or RubyGems
+    # objects. Otherwise, use the default Object comparison.
+    def <=>(other)
+      if other.respond_to?(:sort_obj)
+        sort_obj <=> other.sort_obj
+      else
+        super
+      end
+    end
+
+    # Because Rubyforge cannot be trusted to provide valid specifications
+    # once the remote gem is downloaded, the backend specification will
+    # be swapped out.
+    def __swap__(spec)
+      @_remote_specification = spec
+    end
+
+    # Create a delegate used for sorting. This strategy is copied from
+    # RubyGems 2.23 and ensures that Bundler's specifications can be
+    # compared and sorted with RubyGems' own specifications.
+    #
+    # @see #<=>
+    # @see Gem::Specification#sort_obj
+    #
+    # @return [Array] an object you can use to compare and sort this
+    #   specification against other specifications
+    def sort_obj
+      [@name, @version, @platform == Gem::Platform::RUBY ? -1 : 1]
+    end
+
+  private
+
+    def _remote_specification
+      @_remote_specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
+    end
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        _remote_specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/bundler/resolver.rb

@@ -0,0 +1,350 @@
+module Bundler
+  class Resolver
+    require "bundler/vendored_molinillo"
+
+    class Molinillo::VersionConflict
+      def printable_dep(dep)
+        if dep.is_a?(Bundler::Dependency)
+          DepProxy.new(dep, dep.platforms.join(", ")).to_s.strip
+        else
+          dep.to_s
+        end
+      end
+
+      def message
+        conflicts.sort.reduce("") do |o, (name, conflict)|
+          o << %(Bundler could not find compatible versions for gem "#{name}":\n)
+          if conflict.locked_requirement
+            o << %(  In snapshot (#{Bundler.default_lockfile.basename}):\n)
+            o << %(    #{printable_dep(conflict.locked_requirement)}\n)
+            o << %(\n)
+          end
+          o << %(  In Gemfile:\n)
+          o << conflict.requirement_trees.sort_by {|t| t.reverse.map(&:name) }.map do |tree|
+            t = ""
+            depth = 2
+            tree.each do |req|
+              t << "  " * depth << req.to_s
+              unless tree.last == req
+                if spec = conflict.activated_by_name[req.name]
+                  t << %( was resolved to #{spec.version}, which)
+                end
+                t << %( depends on)
+              end
+              t << %(\n)
+              depth += 1
+            end
+            t
+          end.join("\n")
+
+          if name == "bundler"
+            o << %(\n  Current Bundler version:\n    bundler (#{Bundler::VERSION}))
+            other_bundler_required = !conflict.requirement.requirement.satisfied_by?(Gem::Version.new Bundler::VERSION)
+          end
+
+          if name == "bundler" && other_bundler_required
+            o << "\n"
+            o << "This Gemfile requires a different version of Bundler.\n"
+            o << "Perhaps you need to update Bundler by running `gem install bundler`?\n"
+          end
+          if conflict.locked_requirement
+            o << "\n"
+            o << %(Running `bundle update` will rebuild your snapshot from scratch, using only\n)
+            o << %(the gems in your Gemfile, which may resolve the conflict.\n)
+          elsif !conflict.existing
+            o << "\n"
+            if conflict.requirement_trees.first.size > 1
+              o << "Could not find gem '#{conflict.requirement}', which is required by "
+              o << "gem '#{conflict.requirement_trees.first[-2]}', in any of the sources."
+            else
+              o << "Could not find gem '#{conflict.requirement}' in any of the sources\n"
+            end
+          end
+          o
+        end
+      end
+    end
+
+    ALL = Bundler::Dependency::PLATFORM_MAP.values.uniq.freeze
+
+    class SpecGroup < Array
+      include GemHelpers
+
+      attr_reader :activated, :required_by
+
+      def initialize(a)
+        super
+        @required_by  = []
+        @activated    = []
+        @dependencies = nil
+        @specs        = {}
+
+        ALL.each do |p|
+          @specs[p] = reverse.find {|s| s.match_platform(p) }
+        end
+      end
+
+      def initialize_copy(o)
+        super
+        @required_by = o.required_by.dup
+        @activated   = o.activated.dup
+      end
+
+      def to_specs
+        specs = {}
+
+        @activated.each do |p|
+          if s = @specs[p]
+            platform = generic(Gem::Platform.new(s.platform))
+            next if specs[platform]
+
+            lazy_spec = LazySpecification.new(name, version, platform, source)
+            lazy_spec.dependencies.replace s.dependencies
+            specs[platform] = lazy_spec
+          end
+        end
+        specs.values
+      end
+
+      def activate_platform(platform)
+        unless @activated.include?(platform)
+          if for?(platform)
+            @activated << platform
+            return __dependencies[platform] || []
+          end
+        end
+        []
+      end
+
+      def name
+        @name ||= first.name
+      end
+
+      def version
+        @version ||= first.version
+      end
+
+      def source
+        @source ||= first.source
+      end
+
+      def for?(platform)
+        @specs[platform]
+      end
+
+      def to_s
+        "#{name} (#{version})"
+      end
+
+      def dependencies_for_activated_platforms
+        @activated.map {|p| __dependencies[p] }.flatten
+      end
+
+      def platforms_for_dependency_named(dependency)
+        __dependencies.select {|_, deps| deps.map(&:name).include? dependency }.keys
+      end
+
+    private
+
+      def __dependencies
+        @dependencies ||= begin
+          dependencies = {}
+          ALL.each do |p|
+            if spec = @specs[p]
+              dependencies[p] = []
+              spec.dependencies.each do |dep|
+                next if dep.type == :development
+                dependencies[p] << DepProxy.new(dep, p)
+              end
+            end
+          end
+          dependencies
+        end
+      end
+    end
+
+    # Figures out the best possible configuration of gems that satisfies
+    # the list of passed dependencies and any child dependencies without
+    # causing any gem activation errors.
+    #
+    # ==== Parameters
+    # *dependencies<Gem::Dependency>:: The list of dependencies to resolve
+    #
+    # ==== Returns
+    # <GemBundle>,nil:: If the list of dependencies can be resolved, a
+    #   collection of gemspecs is returned. Otherwise, nil is returned.
+    def self.resolve(requirements, index, source_requirements = {}, base = [])
+      base = SpecSet.new(base) unless base.is_a?(SpecSet)
+      resolver = new(index, source_requirements, base)
+      result = resolver.start(requirements)
+      SpecSet.new(result)
+    end
+
+    def initialize(index, source_requirements, base)
+      @index = index
+      @source_requirements = source_requirements
+      @base = base
+      @resolver = Molinillo::Resolver.new(self, self)
+      @search_for = {}
+      @base_dg = Molinillo::DependencyGraph.new
+      @base.each {|ls| @base_dg.add_vertex(ls.name, Dependency.new(ls.name, ls.version), true) }
+    end
+
+    def start(requirements)
+      verify_gemfile_dependencies_are_found!(requirements)
+      dg = @resolver.resolve(requirements, @base_dg)
+      dg.map(&:payload).map(&:to_specs).flatten
+    rescue Molinillo::VersionConflict => e
+      raise VersionConflict.new(e.conflicts.keys.uniq, e.message)
+    rescue Molinillo::CircularDependencyError => e
+      names = e.dependencies.sort_by(&:name).map {|d| "gem '#{d.name}'" }
+      raise CyclicDependencyError, "Your bundle requires gems that depend" \
+        " on each other, creating an infinite loop. Please remove" \
+        " #{names.count > 1 ? "either " : ""}#{names.join(" or ")}" \
+        " and try again."
+    end
+
+    include Molinillo::UI
+
+    # Conveys debug information to the user.
+    #
+    # @param [Integer] depth the current depth of the resolution process.
+    # @return [void]
+    def debug(depth = 0)
+      if debug?
+        debug_info = yield
+        debug_info = debug_info.inspect unless debug_info.is_a?(String)
+        STDERR.puts debug_info.split("\n").map {|s| "  " * depth + s }
+      end
+    end
+
+    def debug?
+      ENV["DEBUG_RESOLVER"] || ENV["DEBUG_RESOLVER_TREE"]
+    end
+
+    def before_resolution
+      Bundler.ui.info "Resolving dependencies...", false
+    end
+
+    def after_resolution
+      Bundler.ui.info ""
+    end
+
+    def indicate_progress
+      Bundler.ui.info ".", false
+    end
+
+  private
+
+    include Molinillo::SpecificationProvider
+
+    def dependencies_for(specification)
+      specification.dependencies_for_activated_platforms
+    end
+
+    def search_for(dependency)
+      platform = dependency.__platform
+      dependency = dependency.dep unless dependency.is_a? Gem::Dependency
+      search = @search_for[dependency] ||= begin
+        index = @source_requirements[dependency.name] || @index
+        results = index.search(dependency, @base[dependency.name])
+        if vertex = @base_dg.vertex_named(dependency.name)
+          locked_requirement = vertex.payload.requirement
+        end
+        if results.any?
+          version = results.first.version
+          nested  = [[]]
+          results.each do |spec|
+            if spec.version != version
+              nested << []
+              version = spec.version
+            end
+            nested.last << spec
+          end
+          groups = nested.map {|a| SpecGroup.new(a) }
+          !locked_requirement ? groups : groups.select {|sg| locked_requirement.satisfied_by? sg.version }
+        else
+          []
+        end
+      end
+      search.select {|sg| sg.for?(platform) }.each {|sg| sg.activate_platform(platform) }
+    end
+
+    def name_for(dependency)
+      dependency.name
+    end
+
+    def name_for_explicit_dependency_source
+      Bundler.default_gemfile.basename.to_s rescue "Gemfile"
+    end
+
+    def name_for_locking_dependency_source
+      Bundler.default_lockfile.basename.to_s rescue "Gemfile.lock"
+    end
+
+    def requirement_satisfied_by?(requirement, activated, spec)
+      requirement.matches_spec?(spec)
+    end
+
+    def sort_dependencies(dependencies, activated, conflicts)
+      dependencies.sort_by do |dependency|
+        name = name_for(dependency)
+        [
+          activated.vertex_named(name).payload ? 0 : 1,
+          amount_constrained(dependency),
+          conflicts[name] ? 0 : 1,
+          activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
+        ]
+      end
+    end
+
+    def amount_constrained(dependency)
+      @amount_constrained ||= {}
+      @amount_constrained[dependency.name] ||= begin
+        if base = @base[dependency.name] and !base.empty?
+          dependency.requirement.satisfied_by?(base.first.version) ? 0 : 1
+        else
+          base_dep = Dependency.new dependency.name, ">= 0.a"
+          all = search_for(DepProxy.new base_dep, dependency.__platform).size.to_f
+          if all.zero?
+            0
+          elsif (search = search_for(dependency).size.to_f) == all && all == 1
+            0
+          else
+            search / all
+          end
+        end
+      end
+    end
+
+    def verify_gemfile_dependencies_are_found!(requirements)
+      requirements.each do |requirement|
+        next if requirement.name == "bundler"
+        if search_for(requirement).empty?
+          if base = @base[requirement.name] and !base.empty?
+            version = base.first.version
+            message = "You have requested:\n" \
+              "  #{requirement.name} #{requirement.requirement}\n\n" \
+              "The bundle currently has #{requirement.name} locked at #{version}.\n" \
+              "Try running `bundle update #{requirement.name}`\n\n" \
+              "If you are updating multiple gems in your Gemfile at once,\n" \
+              "try passing them all to `bundle update`"
+          elsif requirement.source
+            name = requirement.name
+            versions = @source_requirements[name][name].map(&:version)
+            message  = "Could not find gem '#{requirement}' in #{requirement.source}.\n"
+            if versions.any?
+              message << "Source contains '#{name}' at: #{versions.join(", ")}"
+            else
+              message << "Source does not contain any versions of '#{requirement}'"
+            end
+          else
+            message = "Could not find gem '#{requirement}' in any of the gem sources " \
+              "listed in your Gemfile or available on this machine."
+          end
+          raise GemNotFound, message
+        end
+      end
+    end
+  end
+end