class Bundler::SpecSet - bundler-1.15.4 Documentation

# class Bundler::SpecSet

### Public Class Methods

new(specs) click to toggle source

    # File lib/bundler/spec_set.rb, line 13
    def initialize(specs)
      @specs = specs
    end

### Public Instance Methods

[](key) click to toggle source

    # File lib/bundler/spec_set.rb, line 53
    def [](key)
      key = key.name if key.respond_to?(:name)
      lookup[key].reverse
    end

[]=(key, value) click to toggle source

    # File lib/bundler/spec_set.rb, line 58
    def []=(key, value)
      @specs << value
      @lookup = nil
      @sorted = nil
      value
    end

find_by_name_and_platform(name, platform) click to toggle source

    # File lib/bundler/spec_set.rb, line 118
    def find_by_name_and_platform(name, platform)
      @specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
    end

for(dependencies, skip = [], check = false, match_current_platform = false, raise_on_missing = true) click to toggle source

    # File lib/bundler/spec_set.rb, line 17
    def for(dependencies, skip = [], check = false, match_current_platform = false, raise_on_missing = true)
      handled = Set.new
      deps = dependencies.dup
      specs = []
      skip += ["bundler"]

      loop do
        break unless dep = deps.shift
        next if !handled.add?(dep) || skip.include?(dep.name)

        if spec = spec_for_dependency(dep, match_current_platform)
          specs << spec

          spec.dependencies.each do |d|
            next if d.type == :development
            d = DepProxy.new(d, dep.__platform) unless match_current_platform
            deps << d
          end
        elsif check
          return false
        elsif raise_on_missing
          raise "Unable to find a spec satisfying #{dep} in the set. Perhaps the lockfile is corrupted?"
        end
      end

      if spec = lookup["bundler"].first
        specs << spec
      end

      check ? true : SpecSet.new(specs)
    end

materialize(deps, missing_specs = nil) click to toggle source

    # File lib/bundler/spec_set.rb, line 77
    def materialize(deps, missing_specs = nil)
      materialized = self.for(deps, [], false, true, missing_specs).to_a
      deps = materialized.map(&:name).uniq
      materialized.map! do |s|
        next s unless s.is_a?(LazySpecification)
        s.source.dependency_names = deps if s.source.respond_to?(:dependency_names=)
        spec = s.__materialize__
        unless spec
          unless missing_specs
            raise GemNotFound, "Could not find #{s.full_name} in any of the sources"
          end
          missing_specs << s
        end
        spec
      end
      SpecSet.new(missing_specs ? materialized.compact : materialized)
    end

materialized_for_all_platforms() click to toggle source

Materialize for all the specs in the spec set, regardless of what platform they're for This is in contrast to how for does platform filtering (and specifically different from how `materialize` calls `for` only for the current platform) @return [Array<Gem::Specification>]

    # File lib/bundler/spec_set.rb, line 98
    def materialized_for_all_platforms
      names = @specs.map(&:name).uniq
      @specs.map do |s|
        next s unless s.is_a?(LazySpecification)
        s.source.dependency_names = names if s.source.respond_to?(:dependency_names=)
        spec = s.__materialize__
        raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
        spec
      end
    end

merge(set) click to toggle source

    # File lib/bundler/spec_set.rb, line 109
    def merge(set)
      arr = sorted.dup
      set.each do |s|
        next if arr.any? {|s2| s2.name == s.name && s2.version == s.version && s2.platform == s.platform }
        arr << s
      end
      SpecSet.new(arr)
    end

sort!() click to toggle source

    # File lib/bundler/spec_set.rb, line 65
    def sort!
      self
    end

to_a() click to toggle source

    # File lib/bundler/spec_set.rb, line 69
    def to_a
      sorted.dup
    end

to_hash() click to toggle source

    # File lib/bundler/spec_set.rb, line 73
    def to_hash
      lookup.dup
    end

valid_for?(deps) click to toggle source

    # File lib/bundler/spec_set.rb, line 49
    def valid_for?(deps)
      self.for(deps, [], true)
    end

what_required(spec) click to toggle source

    # File lib/bundler/spec_set.rb, line 122
    def what_required(spec)
      unless req = find {|s| s.dependencies.any? {|d| d.type == :runtime && d.name == spec.name } }
        return [spec]
      end
      what_required(req) << spec
    end

### Private Instance Methods

extract_circular_gems(error) click to toggle source

    # File lib/bundler/spec_set.rb, line 143
    def extract_circular_gems(error)
      if Bundler.current_ruby.mri? && Bundler.current_ruby.on_19?
        error.message.scan(/(\w+) \([^)]/).flatten
      else
        error.message.scan(/@name="(.*?)"/).flatten
      end
    end

lookup() click to toggle source

    # File lib/bundler/spec_set.rb, line 151
    def lookup
      @lookup ||= begin
        lookup = Hash.new {|h, k| h[k] = [] }
        Index.sort_specs(@specs).reverse_each do |s|
          lookup[s.name] << s
        end
        lookup
      end
    end

sorted() click to toggle source

    # File lib/bundler/spec_set.rb, line 131
    def sorted
      rake = @specs.find {|s| s.name == "rake" }
      begin
        @sorted ||= ([rake] + tsort).compact.uniq
      rescue TSort::Cyclic => error
        cgems = extract_circular_gems(error)
        raise CyclicDependencyError, "Your bundle requires gems that depend"            " on each other, creating an infinite loop. Please remove either"            " gem '#{cgems[1]}' or gem '#{cgems[0]}' and try again."
      end
    end

spec_for_dependency(dep, match_current_platform) click to toggle source

    # File lib/bundler/spec_set.rb, line 166
    def spec_for_dependency(dep, match_current_platform)
      specs_for_platforms = lookup[dep.name]
      if match_current_platform
        Bundler.rubygems.platforms.reverse_each do |pl|
          match = GemHelpers.select_best_platform_match(specs_for_platforms, pl)
          return match if match
        end
        nil
      else
        GemHelpers.select_best_platform_match(specs_for_platforms, dep.__platform)
      end
    end

tsort_each_child(s) { |s2| ... } click to toggle source

    # File lib/bundler/spec_set.rb, line 179
    def tsort_each_child(s)
      s.dependencies.sort_by(&:name).each do |d|
        next if d.type == :development
        lookup[d.name].each {|s2| yield s2 }
      end
    end

tsort_each_node() { |s| ... } click to toggle source

    # File lib/bundler/spec_set.rb, line 161
    def tsort_each_node
      # MUST sort by name for backwards compatibility
      @specs.sort_by(&:name).each {|s| yield s }
    end