Class: Gem::SpecFetcher

Inherits:
Object
  • Object
show all
Includes:
Text, UserInteraction
Defined in:
lib/rubygems/spec_fetcher.rb

Overview

SpecFetcher handles metadata updates from remote gem repositories.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Text

#format_text, #levenshtein_distance

Methods included from UserInteraction

#alert, #alert_error, #alert_warning, #ask, #ask_for_password, #ask_yes_no, #choose_from_list, #say, #terminate_interaction

Methods included from DefaultUserInteraction

ui, #ui, ui=, #ui=, use_ui, #use_ui

Constructor Details

#initialize ⇒ SpecFetcher

Returns a new instance of SpecFetcher.



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/rubygems/spec_fetcher.rb', line 40

def initialize
  @dir = File.join Gem.user_home, '.gem', 'specs'
  @update_cache = File.stat(Gem.user_home).uid == Process.uid

  @specs = {}
  @latest_specs = {}
  @prerelease_specs = {}

  @caches = {
    :latest => @latest_specs,
    :prerelease => @prerelease_specs,
    :released => @specs,
  }

  @fetcher = Gem::RemoteFetcher.fetcher
end

Instance Attribute Details

#latest_specs ⇒ Object (readonly)

Cache of latest specs



18
19
20
 
# File 'lib/rubygems/spec_fetcher.rb', line 18

def latest_specs
  @latest_specs
end

#prerelease_specs ⇒ Object (readonly)

Cache of prerelease specs



28
29
30
 
# File 'lib/rubygems/spec_fetcher.rb', line 28

def prerelease_specs
  @prerelease_specs
end

#specs ⇒ Object (readonly)

Cache of all released specs



23
24
25
 
# File 'lib/rubygems/spec_fetcher.rb', line 23

def specs
  @specs
end

Class Method Details

.fetcher ⇒ Object 



32
33
34
 
# File 'lib/rubygems/spec_fetcher.rb', line 32

def self.fetcher
  @fetcher ||= new
end

.fetcher=(fetcher) ⇒ Object

:nodoc:



36
37
38
 
# File 'lib/rubygems/spec_fetcher.rb', line 36

def self.fetcher=(fetcher) # :nodoc:
  @fetcher = fetcher
end

Instance Method Details

#available_specs(type) ⇒ Object

Returns a list of gems available for each source in Gem::sources.

type can be one of 3 values: :released => Return the list of all released specs :complete => Return the list of all specs :latest => Return the list of only the highest version of each gem :prerelease => Return the list of all prerelease only specs



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/rubygems/spec_fetcher.rb', line 186

def available_specs(type)
  errors = []
  list = {}

  Gem.sources.each_source do |source|
    begin
      names = case type
              when :latest
                tuples_for source, :latest
              when :released
                tuples_for source, :released
              when :complete
                tuples_for(source, :prerelease, true) +
                  tuples_for(source, :released)
              when :prerelease
                tuples_for(source, :prerelease)
              else
                raise Gem::Exception, "Unknown type - :#{type}"
              end
    rescue Gem::RemoteFetcher::FetchError => e
      errors << Gem::SourceFetchProblem.new(source, e)
    else
      list[source] = names
    end
  end

  [list, errors]
end

#detect(type = :complete) ⇒ Object

Return all gem name tuples who’s names match obj



112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/rubygems/spec_fetcher.rb', line 112

def detect(type=:complete)
  tuples = []

  list, _ = available_specs(type)
  list.each do |source, specs|
    specs.each do |tup|
      if yield(tup)
        tuples << [tup, source]
      end
    end
  end

  tuples
end

#search_for_dependency(dependency, matching_platform = true) ⇒ Object

Find and fetch gem name tuples that match dependency.

If matching_platform is false, gems for all platforms are returned.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rubygems/spec_fetcher.rb', line 63

def search_for_dependency(dependency, matching_platform=true)
  found = {}

  rejected_specs = {}

  if dependency.prerelease?
    type = :complete
  elsif dependency.latest_version?
    type = :latest
  else
    type = :released
  end

  list, errors = available_specs(type)
  list.each do |source, specs|
    found[source] = specs.select do |tup|
      if dependency.match?(tup)
        if matching_platform and !Gem::Platform.match(tup.platform)
          pm = (
            rejected_specs[dependency] ||= \
              Gem::PlatformMismatch.new(tup.name, tup.version))
          pm.add_platform tup.platform
          false
        else
          true
        end
      end
    end
  end

  errors += rejected_specs.values

  tuples = []

  found.each do |source, specs|
    specs.each do |s|
      tuples << [s, source]
    end
  end

  tuples = tuples.sort_by { |x| x[0] }

  return [tuples, errors]
end

#spec_for_dependency(dependency, matching_platform = true) ⇒ Object

Find and fetch specs that match dependency.

If matching_platform is false, gems for all platforms are returned.



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/rubygems/spec_fetcher.rb', line 133

def spec_for_dependency(dependency, matching_platform=true)
  tuples, errors = search_for_dependency(dependency, matching_platform)

  specs = []
  tuples.each do |tup, source|
    begin
      spec = source.fetch_spec(tup)
    rescue Gem::RemoteFetcher::FetchError => e
      errors << Gem::SourceFetchProblem.new(source, e)
    else
      specs << [spec, source]
    end
  end

  return [specs, errors]
end

#suggest_gems_from_name(gem_name) ⇒ Object

Suggests gems based on the supplied gem_name. Returns an array of alternative gem names.



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/rubygems/spec_fetcher.rb', line 154

def suggest_gems_from_name gem_name
  gem_name        = gem_name.downcase.tr('_-', '')
  max             = gem_name.size / 2
  names           = available_specs(:complete).first.values.flatten(1)

  matches = names.map { |n|
    next unless n.match_platform?

    distance = levenshtein_distance gem_name, n.name.downcase.tr('_-', '')

    next if distance >= max

    return [n.name] if distance == 0

    [n.name, distance]
  }.compact

  matches = matches.uniq.sort_by { |name, dist| dist }

  matches.first(5).map { |name, dist| name }
end

#tuples_for(source, type, gracefully_ignore = false) ⇒ Object 



215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/rubygems/spec_fetcher.rb', line 215

def tuples_for(source, type, gracefully_ignore=false)
  cache = @caches[type]

  if gracefully_ignore
    begin
      cache[source.uri] ||= source.load_specs(type)
    rescue Gem::RemoteFetcher::FetchError
      []
    end
  else
    cache[source.uri] ||= source.load_specs(type)
  end
end