Class: Gemirro::GemsFetcher

Inherits:
Object
  • Object
show all
Defined in:
lib/gemirro/gems_fetcher.rb

Overview

The GemsFetcher class is responsible for downloading Gems from an external source.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source, versions_file) ⇒ GemsFetcher

Returns a new instance of GemsFetcher.

Parameters:



18
19
20
21
 
# File 'lib/gemirro/gems_fetcher.rb', line 18

def initialize(source, versions_file)
  @source        = source
  @versions_file = versions_file
end

Instance Attribute Details

#source ⇒ Source (readonly)

Returns:



11
12
13
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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
164
165
166
167
168
 
# File 'lib/gemirro/gems_fetcher.rb', line 11

class GemsFetcher
  attr_reader :source, :versions_file

  ##
  # @param [Source] source
  # @param [Gemirro::VersionsFile] versions_file
  #
  def initialize(source, versions_file)
    @source        = source
    @versions_file = versions_file
  end

  ##
  # Fetches the Gems.
  #
  def fetch
    @source.gems.each do |gem|
      versions_for(gem).each do |versions|
        gem.platform = versions[1] if versions
        version = versions[0] if versions
        if gem.gemspec?
          gemfile = fetch_gemspec(gem, version)
          if gemfile
            Utils.configuration.mirror_gemspecs_directory
                 .add_file(gem.gemspec_filename(version), gemfile)
          end
        else
          gemfile = fetch_gem(gem, version)
          if gemfile
            Utils.configuration.mirror_gems_directory
                 .add_file(gem.filename(version), gemfile)
          end
        end
      end
    end
  end

  ##
  # Returns an Array containing the versions that should be fetched for a
  # Gem.
  #
  # @param [Gemirro::Gem] gem
  # @return [Array]
  #
  def versions_for(gem)
    available = @versions_file.versions_for(gem.name)
    return [available.last] if gem.only_latest?

    versions = available.select do |v|
      gem.requirement.satisfied_by?(v[0])
    end

    versions = [available.last] if versions.empty?

    versions
  end

  ##
  # Tries to download gemspec from a given name and version
  #
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_gemspec(gem, version)
    filename = gem.gemspec_filename(version)
    satisfied = if gem.only_latest?
                  true
                else
                  gem.requirement.satisfied_by?(version)
                end

    if gemspec_exists?(filename) || !satisfied
      Utils.logger.debug("Skipping #{filename}")
      return
    end

    Utils.logger.info("Fetching #{filename}")
    fetch_from_source(filename, gem, version, true)
  end

  ##
  # Tries to download the gem file from a given nam and version
  #
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_gem(gem, version)
    filename = gem.filename(version)
    satisfied = if gem.only_latest?
                  true
                else
                  gem.requirement.satisfied_by?(version)
                end
    name = gem.name

    if gem_exists?(filename) || ignore_gem?(name, version) || !satisfied
      Utils.logger.debug("Skipping #{filename}")
      return
    end

    Utils.configuration.ignore_gem(gem.name, version)
    Utils.logger.info("Fetching #{filename}")

    fetch_from_source(filename, gem, version)
  end

  ##
  #
  # @param [String] filename
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_from_source(filename, gem, version, gemspec = false)
    data = nil
    begin
      data = @source.fetch_gem(filename) unless gemspec
      data = @source.fetch_gemspec(filename) if gemspec
    rescue StandardError => e
      filename = gem.filename(version)
      Utils.logger.error("Failed to retrieve #{filename}: #{e.message}")
      Utils.logger.debug("Adding #{filename} to the list of ignored Gems")

      Utils.configuration.ignore_gem(gem.name, version)
    end

    data
  end

  ##
  # Checks if a given Gem has already been downloaded.
  #
  # @param [String] filename
  # @return [TrueClass|FalseClass]
  #
  def gem_exists?(filename)
    Utils.configuration.mirror_gems_directory.file_exists?(filename)
  end

  ##
  # Checks if a given Gemspec has already been downloaded.
  #
  # @param [String] filename
  # @return [TrueClass|FalseClass]
  #
  def gemspec_exists?(filename)
    Utils.configuration.mirror_gemspecs_directory.file_exists?(filename)
  end

  ##
  # @see Gemirro::Configuration#ignore_gem?
  #
  def ignore_gem?(*args)
    Utils.configuration.ignore_gem?(*args)
  end
end

#versions_file ⇒ Gemirro::VersionsFile (readonly)

Returns:



11
12
13
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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
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
164
165
166
167
168
 
# File 'lib/gemirro/gems_fetcher.rb', line 11

class GemsFetcher
  attr_reader :source, :versions_file

  ##
  # @param [Source] source
  # @param [Gemirro::VersionsFile] versions_file
  #
  def initialize(source, versions_file)
    @source        = source
    @versions_file = versions_file
  end

  ##
  # Fetches the Gems.
  #
  def fetch
    @source.gems.each do |gem|
      versions_for(gem).each do |versions|
        gem.platform = versions[1] if versions
        version = versions[0] if versions
        if gem.gemspec?
          gemfile = fetch_gemspec(gem, version)
          if gemfile
            Utils.configuration.mirror_gemspecs_directory
                 .add_file(gem.gemspec_filename(version), gemfile)
          end
        else
          gemfile = fetch_gem(gem, version)
          if gemfile
            Utils.configuration.mirror_gems_directory
                 .add_file(gem.filename(version), gemfile)
          end
        end
      end
    end
  end

  ##
  # Returns an Array containing the versions that should be fetched for a
  # Gem.
  #
  # @param [Gemirro::Gem] gem
  # @return [Array]
  #
  def versions_for(gem)
    available = @versions_file.versions_for(gem.name)
    return [available.last] if gem.only_latest?

    versions = available.select do |v|
      gem.requirement.satisfied_by?(v[0])
    end

    versions = [available.last] if versions.empty?

    versions
  end

  ##
  # Tries to download gemspec from a given name and version
  #
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_gemspec(gem, version)
    filename = gem.gemspec_filename(version)
    satisfied = if gem.only_latest?
                  true
                else
                  gem.requirement.satisfied_by?(version)
                end

    if gemspec_exists?(filename) || !satisfied
      Utils.logger.debug("Skipping #{filename}")
      return
    end

    Utils.logger.info("Fetching #{filename}")
    fetch_from_source(filename, gem, version, true)
  end

  ##
  # Tries to download the gem file from a given nam and version
  #
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_gem(gem, version)
    filename = gem.filename(version)
    satisfied = if gem.only_latest?
                  true
                else
                  gem.requirement.satisfied_by?(version)
                end
    name = gem.name

    if gem_exists?(filename) || ignore_gem?(name, version) || !satisfied
      Utils.logger.debug("Skipping #{filename}")
      return
    end

    Utils.configuration.ignore_gem(gem.name, version)
    Utils.logger.info("Fetching #{filename}")

    fetch_from_source(filename, gem, version)
  end

  ##
  #
  # @param [String] filename
  # @param [Gemirro::Gem] gem
  # @param [Gem::Version] version
  # @return [String]
  #
  def fetch_from_source(filename, gem, version, gemspec = false)
    data = nil
    begin
      data = @source.fetch_gem(filename) unless gemspec
      data = @source.fetch_gemspec(filename) if gemspec
    rescue StandardError => e
      filename = gem.filename(version)
      Utils.logger.error("Failed to retrieve #{filename}: #{e.message}")
      Utils.logger.debug("Adding #{filename} to the list of ignored Gems")

      Utils.configuration.ignore_gem(gem.name, version)
    end

    data
  end

  ##
  # Checks if a given Gem has already been downloaded.
  #
  # @param [String] filename
  # @return [TrueClass|FalseClass]
  #
  def gem_exists?(filename)
    Utils.configuration.mirror_gems_directory.file_exists?(filename)
  end

  ##
  # Checks if a given Gemspec has already been downloaded.
  #
  # @param [String] filename
  # @return [TrueClass|FalseClass]
  #
  def gemspec_exists?(filename)
    Utils.configuration.mirror_gemspecs_directory.file_exists?(filename)
  end

  ##
  # @see Gemirro::Configuration#ignore_gem?
  #
  def ignore_gem?(*args)
    Utils.configuration.ignore_gem?(*args)
  end
end

Instance Method Details

#fetch ⇒ Object

Fetches the Gems.



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/gemirro/gems_fetcher.rb', line 26

def fetch
  @source.gems.each do |gem|
    versions_for(gem).each do |versions|
      gem.platform = versions[1] if versions
      version = versions[0] if versions
      if gem.gemspec?
        gemfile = fetch_gemspec(gem, version)
        if gemfile
          Utils.configuration.mirror_gemspecs_directory
               .add_file(gem.gemspec_filename(version), gemfile)
        end
      else
        gemfile = fetch_gem(gem, version)
        if gemfile
          Utils.configuration.mirror_gems_directory
               .add_file(gem.filename(version), gemfile)
        end
      end
    end
  end
end

#fetch_from_source(filename, gem, version, gemspec = false) ⇒ String

Parameters:

  • filename (String)
  • gem (Gemirro::Gem)
  • version (Gem::Version)

Returns:

  • (String) 


126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/gemirro/gems_fetcher.rb', line 126

def fetch_from_source(filename, gem, version, gemspec = false)
  data = nil
  begin
    data = @source.fetch_gem(filename) unless gemspec
    data = @source.fetch_gemspec(filename) if gemspec
  rescue StandardError => e
    filename = gem.filename(version)
    Utils.logger.error("Failed to retrieve #{filename}: #{e.message}")
    Utils.logger.debug("Adding #{filename} to the list of ignored Gems")

    Utils.configuration.ignore_gem(gem.name, version)
  end

  data
end

#fetch_gem(gem, version) ⇒ String

Tries to download the gem file from a given nam and version

Parameters:

Returns:

  • (String) 


99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/gemirro/gems_fetcher.rb', line 99

def fetch_gem(gem, version)
  filename = gem.filename(version)
  satisfied = if gem.only_latest?
                true
              else
                gem.requirement.satisfied_by?(version)
              end
  name = gem.name

  if gem_exists?(filename) || ignore_gem?(name, version) || !satisfied
    Utils.logger.debug("Skipping #{filename}")
    return
  end

  Utils.configuration.ignore_gem(gem.name, version)
  Utils.logger.info("Fetching #{filename}")

  fetch_from_source(filename, gem, version)
end

#fetch_gemspec(gem, version) ⇒ String

Tries to download gemspec from a given name and version

Parameters:

Returns:

  • (String) 


75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/gemirro/gems_fetcher.rb', line 75

def fetch_gemspec(gem, version)
  filename = gem.gemspec_filename(version)
  satisfied = if gem.only_latest?
                true
              else
                gem.requirement.satisfied_by?(version)
              end

  if gemspec_exists?(filename) || !satisfied
    Utils.logger.debug("Skipping #{filename}")
    return
  end

  Utils.logger.info("Fetching #{filename}")
  fetch_from_source(filename, gem, version, true)
end

#gem_exists?(filename) ⇒ TrueClass|FalseClass

Checks if a given Gem has already been downloaded.

Parameters:

  • filename (String)

Returns:

  • (TrueClass|FalseClass) 


148
149
150
 
# File 'lib/gemirro/gems_fetcher.rb', line 148

def gem_exists?(filename)
  Utils.configuration.mirror_gems_directory.file_exists?(filename)
end

#gemspec_exists?(filename) ⇒ TrueClass|FalseClass

Checks if a given Gemspec has already been downloaded.

Parameters:

  • filename (String)

Returns:

  • (TrueClass|FalseClass) 


158
159
160
 
# File 'lib/gemirro/gems_fetcher.rb', line 158

def gemspec_exists?(filename)
  Utils.configuration.mirror_gemspecs_directory.file_exists?(filename)
end

#ignore_gem?(*args) ⇒ Boolean

Returns:

  • (Boolean)

See Also:



165
166
167
 
# File 'lib/gemirro/gems_fetcher.rb', line 165

def ignore_gem?(*args)
  Utils.configuration.ignore_gem?(*args)
end

#versions_for(gem) ⇒ Array

Returns an Array containing the versions that should be fetched for a Gem.

Parameters:

Returns:

  • (Array) 


55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/gemirro/gems_fetcher.rb', line 55

def versions_for(gem)
  available = @versions_file.versions_for(gem.name)
  return [available.last] if gem.only_latest?

  versions = available.select do |v|
    gem.requirement.satisfied_by?(v[0])
  end

  versions = [available.last] if versions.empty?

  versions
end