Class: Gemirro::Utils

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

Overview

The Utils class is responsible for executing specific traitments that are located at least on two other files

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Attribute Details

#cache ⇒ Object (readonly)

Returns the value of attribute cache.



16
17
18
 
# File 'lib/gemirro/utils.rb', line 16

def cache
  @cache
end

#client ⇒ HTTPClient (readonly)

Returns:

  • (HTTPClient) 


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
 
# File 'lib/gemirro/utils.rb', line 15

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_orig_collection,
              :gems_source_collection,
              :stored_gems)
  ##
  # Cache class to store marshal and data into files
  #
  # @return [Gemirro::Cache]
  #
  def self.cache
    @cache ||= Gemirro::Cache
               .new(File.join(configuration.destination, '.cache'))
  end

  ##
  # Generate Gems collection from Marshal dump
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Gemirro::GemVersionCollection]
  #
  def self.gems_collection(orig = true)
    return @gems_orig_collection if orig && !@gems_orig_collection.nil?
    return @gems_source_collection if !orig && !@gems_source_collection.nil?

    gems = []
    specs_files_paths(orig).pmap do |specs_file_path|
      next unless File.exist?(specs_file_path)
      spec_gems = cache.cache(File.basename(specs_file_path)) do
        Marshal.load(Zlib::GzipReader.open(specs_file_path).read)
      end
      gems.concat(spec_gems)
    end

    collection = GemVersionCollection.new(gems)
    @gems_source_collection = collection unless orig
    @gems_orig_collection = collection if orig

    collection
  end

  ##
  # Return specs fils paths
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Array]
  #
  def self.specs_files_paths(orig = true)
    marshal_version = Gemirro::Configuration.marshal_version
    specs_file_types.pmap do |specs_file_type|
      File.join(configuration.destination,
                [specs_file_type,
                 marshal_version,
                 'gz' + (orig ? '.orig' : '')
                ].join('.'))
    end
  end

  ##
  # Return specs fils types
  #
  # @return [Array]
  #
  def self.specs_file_types
    [:specs, :prerelease_specs]
  end

  ##
  # @see Gemirro::Configuration#logger
  # @return [Logger]
  #
  def self.logger
    configuration.logger
  end

  ##
  # @see Gemirro.configuration
  #
  def self.configuration
    Gemirro.configuration
  end

  ##
  # @see Gemirro::VersionsFetcher.fetch
  #
  def self.versions_fetcher
    @versions_fetcher ||= Gemirro::VersionsFetcher
                          .new(configuration.source).fetch
  end

  ##
  # @return [Gemirro::GemsFetcher]
  #
  def self.gems_fetcher
    @gems_fetcher ||= Gemirro::GemsFetcher.new(
      configuration.source, versions_fetcher)
  end

  ##
  # Try to cache gem classes
  #
  # @param [String] gem_name Gem name
  # @return [Gem]
  #
  def self.stored_gem(gem_name, gem_version, platform = 'ruby')
    @stored_gems ||= {}
    # rubocop:disable Metrics/LineLength
    @stored_gems[gem_name] = {} unless @stored_gems.key?(gem_name)
    @stored_gems[gem_name][gem_version] = {} unless @stored_gems[gem_name].key?(gem_version)
    @stored_gems[gem_name][gem_version][platform] ||= Gem.new(gem_name, gem_version, platform) unless @stored_gems[gem_name][gem_version].key?(platform)
    # rubocop:enable Metrics/LineLength

    @stored_gems[gem_name][gem_version][platform]
  end
end

#gems_fetcher ⇒ Gemirro::GemsFetcher (readonly)

Returns:



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
 
# File 'lib/gemirro/utils.rb', line 15

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_orig_collection,
              :gems_source_collection,
              :stored_gems)
  ##
  # Cache class to store marshal and data into files
  #
  # @return [Gemirro::Cache]
  #
  def self.cache
    @cache ||= Gemirro::Cache
               .new(File.join(configuration.destination, '.cache'))
  end

  ##
  # Generate Gems collection from Marshal dump
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Gemirro::GemVersionCollection]
  #
  def self.gems_collection(orig = true)
    return @gems_orig_collection if orig && !@gems_orig_collection.nil?
    return @gems_source_collection if !orig && !@gems_source_collection.nil?

    gems = []
    specs_files_paths(orig).pmap do |specs_file_path|
      next unless File.exist?(specs_file_path)
      spec_gems = cache.cache(File.basename(specs_file_path)) do
        Marshal.load(Zlib::GzipReader.open(specs_file_path).read)
      end
      gems.concat(spec_gems)
    end

    collection = GemVersionCollection.new(gems)
    @gems_source_collection = collection unless orig
    @gems_orig_collection = collection if orig

    collection
  end

  ##
  # Return specs fils paths
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Array]
  #
  def self.specs_files_paths(orig = true)
    marshal_version = Gemirro::Configuration.marshal_version
    specs_file_types.pmap do |specs_file_type|
      File.join(configuration.destination,
                [specs_file_type,
                 marshal_version,
                 'gz' + (orig ? '.orig' : '')
                ].join('.'))
    end
  end

  ##
  # Return specs fils types
  #
  # @return [Array]
  #
  def self.specs_file_types
    [:specs, :prerelease_specs]
  end

  ##
  # @see Gemirro::Configuration#logger
  # @return [Logger]
  #
  def self.logger
    configuration.logger
  end

  ##
  # @see Gemirro.configuration
  #
  def self.configuration
    Gemirro.configuration
  end

  ##
  # @see Gemirro::VersionsFetcher.fetch
  #
  def self.versions_fetcher
    @versions_fetcher ||= Gemirro::VersionsFetcher
                          .new(configuration.source).fetch
  end

  ##
  # @return [Gemirro::GemsFetcher]
  #
  def self.gems_fetcher
    @gems_fetcher ||= Gemirro::GemsFetcher.new(
      configuration.source, versions_fetcher)
  end

  ##
  # Try to cache gem classes
  #
  # @param [String] gem_name Gem name
  # @return [Gem]
  #
  def self.stored_gem(gem_name, gem_version, platform = 'ruby')
    @stored_gems ||= {}
    # rubocop:disable Metrics/LineLength
    @stored_gems[gem_name] = {} unless @stored_gems.key?(gem_name)
    @stored_gems[gem_name][gem_version] = {} unless @stored_gems[gem_name].key?(gem_version)
    @stored_gems[gem_name][gem_version][platform] ||= Gem.new(gem_name, gem_version, platform) unless @stored_gems[gem_name][gem_version].key?(platform)
    # rubocop:enable Metrics/LineLength

    @stored_gems[gem_name][gem_version][platform]
  end
end

#gems_orig_collection ⇒ Object (readonly)

Returns the value of attribute gems_orig_collection.



16
17
18
 
# File 'lib/gemirro/utils.rb', line 16

def gems_orig_collection
  @gems_orig_collection
end

#gems_source_collection ⇒ Object (readonly)

Returns the value of attribute gems_source_collection.



16
17
18
 
# File 'lib/gemirro/utils.rb', line 16

def gems_source_collection
  @gems_source_collection
end

#stored_gems ⇒ Object (readonly)

Returns the value of attribute stored_gems.



16
17
18
 
# File 'lib/gemirro/utils.rb', line 16

def stored_gems
  @stored_gems
end

#versions_fetcher ⇒ VersionsFetcher (readonly)

Returns:



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
 
# File 'lib/gemirro/utils.rb', line 15

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_orig_collection,
              :gems_source_collection,
              :stored_gems)
  ##
  # Cache class to store marshal and data into files
  #
  # @return [Gemirro::Cache]
  #
  def self.cache
    @cache ||= Gemirro::Cache
               .new(File.join(configuration.destination, '.cache'))
  end

  ##
  # Generate Gems collection from Marshal dump
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Gemirro::GemVersionCollection]
  #
  def self.gems_collection(orig = true)
    return @gems_orig_collection if orig && !@gems_orig_collection.nil?
    return @gems_source_collection if !orig && !@gems_source_collection.nil?

    gems = []
    specs_files_paths(orig).pmap do |specs_file_path|
      next unless File.exist?(specs_file_path)
      spec_gems = cache.cache(File.basename(specs_file_path)) do
        Marshal.load(Zlib::GzipReader.open(specs_file_path).read)
      end
      gems.concat(spec_gems)
    end

    collection = GemVersionCollection.new(gems)
    @gems_source_collection = collection unless orig
    @gems_orig_collection = collection if orig

    collection
  end

  ##
  # Return specs fils paths
  #
  # @param [TrueClass|FalseClass] orig Fetch orig files
  # @return [Array]
  #
  def self.specs_files_paths(orig = true)
    marshal_version = Gemirro::Configuration.marshal_version
    specs_file_types.pmap do |specs_file_type|
      File.join(configuration.destination,
                [specs_file_type,
                 marshal_version,
                 'gz' + (orig ? '.orig' : '')
                ].join('.'))
    end
  end

  ##
  # Return specs fils types
  #
  # @return [Array]
  #
  def self.specs_file_types
    [:specs, :prerelease_specs]
  end

  ##
  # @see Gemirro::Configuration#logger
  # @return [Logger]
  #
  def self.logger
    configuration.logger
  end

  ##
  # @see Gemirro.configuration
  #
  def self.configuration
    Gemirro.configuration
  end

  ##
  # @see Gemirro::VersionsFetcher.fetch
  #
  def self.versions_fetcher
    @versions_fetcher ||= Gemirro::VersionsFetcher
                          .new(configuration.source).fetch
  end

  ##
  # @return [Gemirro::GemsFetcher]
  #
  def self.gems_fetcher
    @gems_fetcher ||= Gemirro::GemsFetcher.new(
      configuration.source, versions_fetcher)
  end

  ##
  # Try to cache gem classes
  #
  # @param [String] gem_name Gem name
  # @return [Gem]
  #
  def self.stored_gem(gem_name, gem_version, platform = 'ruby')
    @stored_gems ||= {}
    # rubocop:disable Metrics/LineLength
    @stored_gems[gem_name] = {} unless @stored_gems.key?(gem_name)
    @stored_gems[gem_name][gem_version] = {} unless @stored_gems[gem_name].key?(gem_version)
    @stored_gems[gem_name][gem_version][platform] ||= Gem.new(gem_name, gem_version, platform) unless @stored_gems[gem_name][gem_version].key?(platform)
    # rubocop:enable Metrics/LineLength

    @stored_gems[gem_name][gem_version][platform]
  end
end

Class Method Details

.cache ⇒ Gemirro::Cache

Cache class to store marshal and data into files

Returns:



27
28
29
30
 
# File 'lib/gemirro/utils.rb', line 27

def self.cache
  @cache ||= Gemirro::Cache
             .new(File.join(configuration.destination, '.cache'))
end

.configuration ⇒ Object

See Also:



95
96
97
 
# File 'lib/gemirro/utils.rb', line 95

def self.configuration
  Gemirro.configuration
end

.gems_collection(orig = true) ⇒ Gemirro::GemVersionCollection

Generate Gems collection from Marshal dump

Parameters:

  • orig (TrueClass|FalseClass) (defaults to: true) —

    Fetch orig files

Returns:



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/gemirro/utils.rb', line 38

def self.gems_collection(orig = true)
  return @gems_orig_collection if orig && !@gems_orig_collection.nil?
  return @gems_source_collection if !orig && !@gems_source_collection.nil?

  gems = []
  specs_files_paths(orig).pmap do |specs_file_path|
    next unless File.exist?(specs_file_path)
    spec_gems = cache.cache(File.basename(specs_file_path)) do
      Marshal.load(Zlib::GzipReader.open(specs_file_path).read)
    end
    gems.concat(spec_gems)
  end

  collection = GemVersionCollection.new(gems)
  @gems_source_collection = collection unless orig
  @gems_orig_collection = collection if orig

  collection
end

.gems_fetcher ⇒ Gemirro::GemsFetcher

Returns:



110
111
112
113
 
# File 'lib/gemirro/utils.rb', line 110

def self.gems_fetcher
  @gems_fetcher ||= Gemirro::GemsFetcher.new(
    configuration.source, versions_fetcher)
end

.logger ⇒ Logger

Returns:

  • (Logger)

See Also:



88
89
90
 
# File 'lib/gemirro/utils.rb', line 88

def self.logger
  configuration.logger
end

.specs_file_types ⇒ Array

Return specs fils types

Returns:

  • (Array) 


80
81
82
 
# File 'lib/gemirro/utils.rb', line 80

def self.specs_file_types
  [:specs, :prerelease_specs]
end

.specs_files_paths(orig = true) ⇒ Array

Return specs fils paths

Parameters:

  • orig (TrueClass|FalseClass) (defaults to: true) —

    Fetch orig files

Returns:

  • (Array) 


64
65
66
67
68
69
70
71
72
73
 
# File 'lib/gemirro/utils.rb', line 64

def self.specs_files_paths(orig = true)
  marshal_version = Gemirro::Configuration.marshal_version
  specs_file_types.pmap do |specs_file_type|
    File.join(configuration.destination,
              [specs_file_type,
               marshal_version,
               'gz' + (orig ? '.orig' : '')
              ].join('.'))
  end
end

.stored_gem(gem_name, gem_version, platform = 'ruby') ⇒ Gem

Try to cache gem classes

Parameters:

  • gem_name (String) —

    Gem name

Returns:



121
122
123
124
125
126
127
128
129
130
 
# File 'lib/gemirro/utils.rb', line 121

def self.stored_gem(gem_name, gem_version, platform = 'ruby')
  @stored_gems ||= {}
  # rubocop:disable Metrics/LineLength
  @stored_gems[gem_name] = {} unless @stored_gems.key?(gem_name)
  @stored_gems[gem_name][gem_version] = {} unless @stored_gems[gem_name].key?(gem_version)
  @stored_gems[gem_name][gem_version][platform] ||= Gem.new(gem_name, gem_version, platform) unless @stored_gems[gem_name][gem_version].key?(platform)
  # rubocop:enable Metrics/LineLength

  @stored_gems[gem_name][gem_version][platform]
end

.versions_fetcher ⇒ Object

See Also:

  • VersionsFetcher.fetch


102
103
104
105
 
# File 'lib/gemirro/utils.rb', line 102

def self.versions_fetcher
  @versions_fetcher ||= Gemirro::VersionsFetcher
                        .new(configuration.source).fetch
end