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
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/gemirro/utils.rb', line 15

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.



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

def gems_collection
  @gems_collection
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
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/gemirro/utils.rb', line 15

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.



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
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/gemirro/utils.rb', line 15

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:



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:



107
108
109
 
# File 'lib/gemirro/utils.rb', line 107

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
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/gemirro/utils.rb', line 38

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:



122
123
124
125
 
# File 'lib/gemirro/utils.rb', line 122

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

.logger ⇒ Logger

Returns:

  • (Logger)

See Also:



100
101
102
 
# File 'lib/gemirro/utils.rb', line 100

def self.logger
  configuration.logger
end

.specs_file_types ⇒ Array

Return specs fils types

Returns:

  • (Array) 


92
93
94
 
# File 'lib/gemirro/utils.rb', line 92

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) 


77
78
79
80
81
82
83
84
85
 
# File 'lib/gemirro/utils.rb', line 77

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:



133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/gemirro/utils.rb', line 133

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


114
115
116
117
 
# File 'lib/gemirro/utils.rb', line 114

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