Class: Bundler::SpecSet

Inherits:
Object
  • Object
show all
Includes:
TSort, Enumerable
Defined in:
lib/bundler/spec_set.rb

Instance Method Summary collapse

Methods included from TSort

#each_strongly_connected_component, each_strongly_connected_component, #each_strongly_connected_component_from, each_strongly_connected_component_from, #strongly_connected_components, strongly_connected_components, #tsort, tsort, #tsort_each, tsort_each

Constructor Details

#initialize(specs) ⇒ SpecSet

Returns a new instance of SpecSet.



10
11
12
 
# File 'lib/bundler/spec_set.rb', line 10

def initialize(specs)
  @specs = specs
end

Instance Method Details

#<<(spec) ⇒ Object 



118
119
120
 
# File 'lib/bundler/spec_set.rb', line 118

def <<(spec)
  @specs << spec
end

#[](key) ⇒ Object 



43
44
45
46
 
# File 'lib/bundler/spec_set.rb', line 43

def [](key)
  key = key.name if key.respond_to?(:name)
  lookup[key].reverse
end

#[]=(key, value) ⇒ Object 



48
49
50
51
52
 
# File 'lib/bundler/spec_set.rb', line 48

def []=(key, value)
  @specs << value
  @lookup = nil
  @sorted = nil
end

#each(&b) ⇒ Object 



134
135
136
 
# File 'lib/bundler/spec_set.rb', line 134

def each(&b)
  sorted.each(&b)
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
 
# File 'lib/bundler/spec_set.rb', line 130

def empty?
  @specs.empty?
end

#find_by_name_and_platform(name, platform) ⇒ Object 



107
108
109
 
# File 'lib/bundler/spec_set.rb', line 107

def find_by_name_and_platform(name, platform)
  @specs.detect {|spec| spec.name == name && spec.match_platform(platform) }
end

#for(dependencies, check = false, platforms = [nil]) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/bundler/spec_set.rb', line 14

def for(dependencies, check = false, platforms = [nil])
  handled = ["bundler"].product(platforms).map {|k| [k, true] }.to_h
  deps = dependencies.product(platforms)
  specs = []

  loop do
    break unless dep = deps.shift

    key = [dep[0].name, dep[1]]
    next if handled.key?(key)

    handled[key] = true

    specs_for_dep = specs_for_dependency(*dep)
    if specs_for_dep.any?
      specs.concat(specs_for_dep)

      specs_for_dep.first.dependencies.each do |d|
        next if d.type == :development
        deps << [d, dep[1]]
      end
    elsif check
      specs << IncompleteSpecification.new(*key)
    end
  end

  specs
end

#incomplete_ruby_specs?(deps) ⇒ Boolean

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/bundler/spec_set.rb', line 85

def incomplete_ruby_specs?(deps)
  self.class.new(self.for(deps, true, [Gem::Platform::RUBY])).incomplete_specs.any?
end

#incomplete_specs ⇒ Object 



93
94
95
 
# File 'lib/bundler/spec_set.rb', line 93

def incomplete_specs
  @specs.select {|s| s.is_a?(IncompleteSpecification) }
end

#length ⇒ Object 



122
123
124
 
# File 'lib/bundler/spec_set.rb', line 122

def length
  @specs.length
end

#materialize(deps) ⇒ Object 



66
67
68
69
70
 
# File 'lib/bundler/spec_set.rb', line 66

def materialize(deps)
  materialized = self.for(deps, true)

  SpecSet.new(materialized)
end

#materialized_for_all_platforms ⇒ Array<Gem::Specification>

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)

Returns:



75
76
77
78
79
80
81
82
83
 
# File 'lib/bundler/spec_set.rb', line 75

def materialized_for_all_platforms
  @specs.map do |s|
    next s unless s.is_a?(LazySpecification)
    s.source.remote!
    spec = s.materialize_for_installation
    raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
    spec
  end
end

#merge(set) ⇒ Object 



97
98
99
100
101
102
103
104
105
 
# File 'lib/bundler/spec_set.rb', line 97

def merge(set)
  arr = sorted.dup
  set.each do |set_spec|
    full_name = set_spec.full_name
    next if arr.any? {|spec| spec.full_name == full_name }
    arr << set_spec
  end
  SpecSet.new(arr)
end

#missing_specs ⇒ Object 



89
90
91
 
# File 'lib/bundler/spec_set.rb', line 89

def missing_specs
  @specs.select {|s| s.is_a?(LazySpecification) }
end

#size ⇒ Object 



126
127
128
 
# File 'lib/bundler/spec_set.rb', line 126

def size
  @specs.size
end

#sort! ⇒ Object 



54
55
56
 
# File 'lib/bundler/spec_set.rb', line 54

def sort!
  self
end

#to_a ⇒ Object 



58
59
60
 
# File 'lib/bundler/spec_set.rb', line 58

def to_a
  sorted.dup
end

#to_hash ⇒ Object 



62
63
64
 
# File 'lib/bundler/spec_set.rb', line 62

def to_hash
  lookup.dup
end

#what_required(spec) ⇒ Object 



111
112
113
114
115
116
 
# File 'lib/bundler/spec_set.rb', line 111

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