Class: Gem::Source

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

Overview

bundler dependency API and so-forth.

Direct Known Subclasses

Git, Installed, Local, Lock, SpecificFile

Defined Under Namespace

Classes: Git, Installed, Local, Lock, SpecificFile, Vendor

Constant Summary collapse

FILES =

:nodoc:

{ # :nodoc:
  released: "specs",
  latest: "latest_specs",
  prerelease: "prerelease_specs",
}.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Text

#clean_text, #format_text, #levenshtein_distance, #min3, #truncate_text

Constructor Details

#initialize(uri) ⇒ Source

Creates a new Source which will use the index located at uri.



28
29
30
31
32
 
# File 'lib/rubygems/source.rb', line 28

def initialize(uri)
  require_relative "uri"
  @uri = Gem::Uri.parse!(uri)
  @update_cache = nil
end

Instance Attribute Details

#uri ⇒ Object (readonly)

The URI this source will fetch gems from.



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

def uri
  @uri
end

Instance Method Details

#<=>(other) ⇒ Object

Sources are ordered by installation preference.



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/rubygems/source.rb', line 37

def <=>(other)
  case other
  when Gem::Source::Installed,
       Gem::Source::Local,
       Gem::Source::Lock,
       Gem::Source::SpecificFile,
       Gem::Source::Git,
       Gem::Source::Vendor then
    -1
  when Gem::Source then
    unless @uri
      return 0 unless other.uri
      return 1
    end

    return -1 unless other.uri

    # Returning 1 here ensures that when sorting a list of sources, the
    # original ordering of sources supplied by the user is preserved.
    return 1 unless @uri.to_s == other.uri.to_s

    0
  end
end

#==(other) ⇒ Object Also known as: eql?

:nodoc:



62
63
64
 
# File 'lib/rubygems/source.rb', line 62

def ==(other) # :nodoc:
  self.class === other && @uri == other.uri
end

#cache_dir(uri) ⇒ Object

Returns the local directory to write uri to.



101
102
103
104
105
106
 
# File 'lib/rubygems/source.rb', line 101

def cache_dir(uri)
  # Correct for windows paths
  escaped_path = uri.path.sub(%r{^/([a-z]):/}i, '/\\1-/')

  File.join Gem.spec_cache_dir, "#{uri.host}%#{uri.port}", File.dirname(escaped_path)
end

#dependency_resolver_set ⇒ Object

Returns a Set that can fetch specifications from this source.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/rubygems/source.rb', line 71

def dependency_resolver_set # :nodoc:
  return Gem::Resolver::IndexSet.new self if uri.scheme == "file"

  fetch_uri = if uri.host == "rubygems.org"
    index_uri = uri.dup
    index_uri.host = "index.rubygems.org"
    index_uri
  else
    uri
  end

  bundler_api_uri = enforce_trailing_slash(fetch_uri) + "versions"

  begin
    fetcher = Gem::RemoteFetcher.fetcher
    response = fetcher.fetch_path bundler_api_uri, nil, true
  rescue Gem::RemoteFetcher::FetchError
    Gem::Resolver::IndexSet.new self
  else
    Gem::Resolver::APISet.new response.uri + "./info/"
  end
end

#download(spec, dir = Dir.pwd) ⇒ Object

Downloads spec and writes it to dir. See also Gem::RemoteFetcher#download.



210
211
212
213
 
# File 'lib/rubygems/source.rb', line 210

def download(spec, dir=Dir.pwd)
  fetcher = Gem::RemoteFetcher.fetcher
  fetcher.download spec, uri.to_s, dir
end

#fetch_spec(name_tuple) ⇒ Object

Fetches a specification for the given name_tuple.



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/rubygems/source.rb', line 124

def fetch_spec(name_tuple)
  fetcher = Gem::RemoteFetcher.fetcher

  spec_file_name = name_tuple.spec_name

  source_uri = enforce_trailing_slash(uri) + "#{Gem::MARSHAL_SPEC_DIR}#{spec_file_name}"

  cache_dir = cache_dir source_uri

  local_spec = File.join cache_dir, spec_file_name

  if File.exist? local_spec
    spec = Gem.read_binary local_spec
    Gem.load_safe_marshal
    spec = begin
             Gem::SafeMarshal.safe_load(spec)
           rescue StandardError
             nil
           end
    return spec if spec
  end

  source_uri.path << ".rz"

  spec = fetcher.fetch_path source_uri
  spec = Gem::Util.inflate spec

  if update_cache?
    require "fileutils"
    FileUtils.mkdir_p cache_dir

    File.open local_spec, "wb" do |io|
      io.write spec
    end
  end

  Gem.load_safe_marshal
  # TODO: Investigate setting Gem::Specification#loaded_from to a URI
  Gem::SafeMarshal.safe_load spec
end

#hash ⇒ Object

:nodoc:



94
95
96
 
# File 'lib/rubygems/source.rb', line 94

def hash # :nodoc:
  @uri.hash
end

#load_specs(type) ⇒ Object

Loads type kind of specs fetching from @uri if the on-disk cache is out of date.

type is one of the following:

:released => Return the list of all released specs :latest => Return the list of only the highest version of each gem :prerelease => Return the list of all prerelease only specs



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/rubygems/source.rb', line 176

def load_specs(type)
  file       = FILES[type]
  fetcher    = Gem::RemoteFetcher.fetcher
  file_name  = "#{file}.#{Gem.marshal_version}"
  spec_path  = enforce_trailing_slash(uri) + "#{file_name}.gz"
  cache_dir  = cache_dir spec_path
  local_file = File.join(cache_dir, file_name)
  retried    = false

  if update_cache?
    require "fileutils"
    FileUtils.mkdir_p cache_dir
  end

  spec_dump = fetcher.cache_update_path spec_path, local_file, update_cache?

  Gem.load_safe_marshal
  begin
    Gem::NameTuple.from_list Gem::SafeMarshal.safe_load(spec_dump)
  rescue ArgumentError
    if update_cache? && !retried
      FileUtils.rm local_file
      retried = true
      retry
    else
      raise Gem::Exception.new("Invalid spec cache file in #{local_file}")
    end
  end
end

#pretty_print(q) ⇒ Object

:nodoc:



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

def pretty_print(q) # :nodoc:
  q.object_group(self) do
    q.group 2, "[Remote:", "]" do
      q.breakable
      q.text @uri.to_s

      if api = uri
        q.breakable
        q.text "API URI: "
        q.text api.to_s
      end
    end
  end
end

#typo_squatting?(host, distance_threshold = 4) ⇒ Boolean

Returns:

  • (Boolean) 


230
231
232
233
 
# File 'lib/rubygems/source.rb', line 230

def typo_squatting?(host, distance_threshold=4)
  return if @uri.host.nil?
  levenshtein_distance(@uri.host, host).between? 1, distance_threshold
end

#update_cache? ⇒ Boolean

Returns true when it is possible and safe to update the cache directory.

Returns:

  • (Boolean) 


111
112
113
114
115
116
117
118
119
 
# File 'lib/rubygems/source.rb', line 111

def update_cache?
  return @update_cache unless @update_cache.nil?
  @update_cache =
    begin
      File.stat(Gem.user_home).uid == Process.uid
    rescue Errno::ENOENT
      false
    end
end