Class: Bundler::Index

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/bundler/index.rb

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Index) initialize

Returns a new instance of Index



16
17
18
19
20
# File 'lib/bundler/index.rb', line 16

def initialize
  @sources = []
  @cache = {}
  @specs = Hash.new { |h,k| h[k] = [] }
end

Instance Attribute Details

- (Object) sources (readonly)

Returns the value of attribute sources



13
14
15
# File 'lib/bundler/index.rb', line 13

def sources
  @sources
end

Class Method Details

+ (Object) build {|i| ... }

Yields:

  • (i)


7
8
9
10
11
# File 'lib/bundler/index.rb', line 7

def self.build
  i = new
  yield i
  i
end

Instance Method Details

- (Object) <<(spec)



77
78
79
80
81
82
83
84
85
86
# File 'lib/bundler/index.rb', line 77

def <<(spec)
  arr = specs_by_name(spec.name)

  arr.delete_if do |s|
    same_version?(s.version, spec.version) && s.platform == spec.platform
  end

  arr << spec
  spec
end

- (Object) ==(o)



122
123
124
125
126
127
# File 'lib/bundler/index.rb', line 122

def ==(o)
  all? do |spec|
    other_spec = o[spec].first
    (spec.dependencies & other_spec.dependencies).empty? && spec.source == other_spec.source
  end
end

- (Object) add_source(index)



129
130
131
132
133
134
135
136
# File 'lib/bundler/index.rb', line 129

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

- (Object) each(&blk)



88
89
90
91
92
# File 'lib/bundler/index.rb', line 88

def each(&blk)
  specs.values.each do |specs|
    specs.each(&blk)
  end
end

- (Boolean) empty?

Returns:

  • (Boolean)


37
38
39
40
# File 'lib/bundler/index.rb', line 37

def empty?
  each { return false }
  true
end

- (Object) initialize_copy(o)



22
23
24
25
26
27
28
29
30
31
# File 'lib/bundler/index.rb', line 22

def initialize_copy(o)
  super
  @sources = @sources.dup
  @cache = {}
  @specs = Hash.new { |h,k| h[k] = [] }

  o.specs.each do |name, array|
    @specs[name] = array.dup
  end
end

- (Object) inspect



33
34
35
# File 'lib/bundler/index.rb', line 33

def inspect
  "#<#{self.class}:0x#{object_id} sources=#{sources.map{|s| s.inspect}} specs.size=#{specs.size}>"
end

- (Object) local_search(query, base = nil)



61
62
63
64
65
66
67
68
69
# File 'lib/bundler/index.rb', line 61

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

- (Object) search(query, base = nil) Also known as: []

Search this index's specs, and any source indexes that this index knows about, returning all of the results.



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# File 'lib/bundler/index.rb', line 44

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
end

- (Object) size



116
117
118
119
120
# File 'lib/bundler/index.rb', line 116

def size
  @sources.inject(@specs.size) do |size, source|
    size += source.size
  end
end

- (Object) source_types



71
72
73
# File 'lib/bundler/index.rb', line 71

def source_types
  sources.map{|s| s.class }.uniq
end

- (Object) unmet_dependency_names

returns a list of the dependencies



95
96
97
98
99
100
101
102
# File 'lib/bundler/index.rb', line 95

def unmet_dependency_names
  dependency_names = specs.values.map do |array_of_s|
    array_of_s.map do |s|
      s.dependencies.map{|d| d.name }
    end
  end.flatten.uniq
  dependency_names.select{|name| name != 'bundler' && specs_by_name(name).empty? }
end

- (Object) use(other, override_dupes = false)



104
105
106
107
108
109
110
111
112
113
114
# File 'lib/bundler/index.rb', line 104

def use(other, override_dupes = false)
  return unless other
  other.each do |s|
    if (dupes = search_by_spec(s)) && dupes.any?
      next unless override_dupes
      @specs[s.name] -= dupes
    end
    @specs[s.name] << s
  end
  self
end