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.



14
15
16
 
# File 'lib/gemirro/utils.rb', line 14

def cache
  @cache
end

#client ⇒ HTTPClient (readonly)

Returns:

  • (HTTPClient) 


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

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_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)
    @gems_collection = {} if @gems_collection.nil?

    is_orig = orig ? 1 : 0
    data = @gems_collection[is_orig]
    data = { files: {}, values: nil } if data.nil?

    file_paths = specs_files_paths(orig)
    has_file_changed = false
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next if data[:files].key?(file_path) &&
              data[:files][file_path] == File.mtime(file_path)
      has_file_changed = true
    end

    # Return result if no file changed
    return data[:values] if !has_file_changed && !data[:values].nil?

    gems = []
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next unless File.exist?(file_path)
      gems.concat(Marshal.load(Zlib::GzipReader.open(file_path).read))
      data[:files][file_path] = File.mtime(file_path)
    end

    collection = GemVersionCollection.new(gems)
    data[:values] = collection

    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
    Parallel.map(specs_file_types, in_threads: 4) 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
    %i[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')
    platform = 'ruby' if platform.nil?
    @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_collection ⇒ Object (readonly)

Returns the value of attribute gems_collection.



14
15
16
 
# File 'lib/gemirro/utils.rb', line 14

def gems_collection
  @gems_collection
end

#gems_fetcher ⇒ Gemirro::GemsFetcher (readonly)

Returns:



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

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_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)
    @gems_collection = {} if @gems_collection.nil?

    is_orig = orig ? 1 : 0
    data = @gems_collection[is_orig]
    data = { files: {}, values: nil } if data.nil?

    file_paths = specs_files_paths(orig)
    has_file_changed = false
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next if data[:files].key?(file_path) &&
              data[:files][file_path] == File.mtime(file_path)
      has_file_changed = true
    end

    # Return result if no file changed
    return data[:values] if !has_file_changed && !data[:values].nil?

    gems = []
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next unless File.exist?(file_path)
      gems.concat(Marshal.load(Zlib::GzipReader.open(file_path).read))
      data[:files][file_path] = File.mtime(file_path)
    end

    collection = GemVersionCollection.new(gems)
    data[:values] = collection

    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
    Parallel.map(specs_file_types, in_threads: 4) 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
    %i[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')
    platform = 'ruby' if platform.nil?
    @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

#stored_gems ⇒ Object (readonly)

Returns the value of attribute stored_gems.



14
15
16
 
# File 'lib/gemirro/utils.rb', line 14

def stored_gems
  @stored_gems
end

#versions_fetcher ⇒ VersionsFetcher (readonly)

Returns:



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

class Utils
  attr_reader(:cache,
              :versions_fetcher,
              :gems_fetcher,
              :gems_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)
    @gems_collection = {} if @gems_collection.nil?

    is_orig = orig ? 1 : 0
    data = @gems_collection[is_orig]
    data = { files: {}, values: nil } if data.nil?

    file_paths = specs_files_paths(orig)
    has_file_changed = false
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next if data[:files].key?(file_path) &&
              data[:files][file_path] == File.mtime(file_path)
      has_file_changed = true
    end

    # Return result if no file changed
    return data[:values] if !has_file_changed && !data[:values].nil?

    gems = []
    Parallel.map(file_paths, in_threads: 4) do |file_path|
      next unless File.exist?(file_path)
      gems.concat(Marshal.load(Zlib::GzipReader.open(file_path).read))
      data[:files][file_path] = File.mtime(file_path)
    end

    collection = GemVersionCollection.new(gems)
    data[:values] = collection

    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
    Parallel.map(specs_file_types, in_threads: 4) 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
    %i[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')
    platform = 'ruby' if platform.nil?
    @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:



24
25
26
27
 
# File 'lib/gemirro/utils.rb', line 24

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

.configuration ⇒ Object

See Also:



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

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:



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

def self.gems_collection(orig = true)
  @gems_collection = {} if @gems_collection.nil?

  is_orig = orig ? 1 : 0
  data = @gems_collection[is_orig]
  data = { files: {}, values: nil } if data.nil?

  file_paths = specs_files_paths(orig)
  has_file_changed = false
  Parallel.map(file_paths, in_threads: 4) do |file_path|
    next if data[:files].key?(file_path) &&
            data[:files][file_path] == File.mtime(file_path)
    has_file_changed = true
  end

  # Return result if no file changed
  return data[:values] if !has_file_changed && !data[:values].nil?

  gems = []
  Parallel.map(file_paths, in_threads: 4) do |file_path|
    next unless File.exist?(file_path)
    gems.concat(Marshal.load(Zlib::GzipReader.open(file_path).read))
    data[:files][file_path] = File.mtime(file_path)
  end

  collection = GemVersionCollection.new(gems)
  data[:values] = collection

  collection
end

.gems_fetcher ⇒ Gemirro::GemsFetcher

Returns:



117
118
119
120
 
# File 'lib/gemirro/utils.rb', line 117

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

.logger ⇒ Logger

Returns:

  • (Logger)

See Also:



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

def self.logger
  configuration.logger
end

.specs_file_types ⇒ Array

Return specs fils types

Returns:

  • (Array) 


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

def self.specs_file_types
  %i[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) 


72
73
74
75
76
77
78
79
80
 
# File 'lib/gemirro/utils.rb', line 72

def self.specs_files_paths(orig = true)
  marshal_version = Gemirro::Configuration.marshal_version
  Parallel.map(specs_file_types, in_threads: 4) 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:



128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/gemirro/utils.rb', line 128

def self.stored_gem(gem_name, gem_version, platform = 'ruby')
  platform = 'ruby' if platform.nil?
  @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


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

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