Class: Dependabot::Julia::RegistryClient

Inherits:
Object
  • Object
show all
Extended by:
T::Sig
Defined in:
lib/dependabot/julia/registry_client.rb

Instance Method Summary collapse

Constructor Details

#initialize(credentials:, custom_registries: []) ⇒ RegistryClient

Returns a new instance of RegistryClient.



19
20
21
22
 
# File 'lib/dependabot/julia/registry_client.rb', line 19

def initialize(credentials:, custom_registries: [])
  @credentials = credentials
  @custom_registries = custom_registries
end

Instance Method Details

#batch_fetch_available_versions(dependencies) ⇒ Object 



320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/dependabot/julia/registry_client.rb', line 320

def batch_fetch_available_versions(dependencies)
  packages = dependencies.map do |dep|
    {
      name: dep.name,
      uuid: dep.metadata[:julia_uuid] || ""
    }
  end

  call_julia_helper(
    function: "batch_get_available_versions",
    args: { packages: packages }
  )
rescue StandardError => e
  Dependabot.logger.error("Failed to batch fetch available versions: #{e.message}")
  {}
end

#batch_fetch_package_info(dependencies) ⇒ Object 



280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/dependabot/julia/registry_client.rb', line 280

def batch_fetch_package_info(dependencies)
  packages = dependencies.map do |dep|
    {
      name: dep.name,
      uuid: dep.metadata[:julia_uuid] || ""
    }
  end

  call_julia_helper(
    function: "batch_get_package_info",
    args: { packages: packages }
  )
rescue StandardError => e
  Dependabot.logger.error("Failed to batch fetch package info: #{e.message}")
  {}
end

#batch_fetch_version_release_dates(packages_versions) ⇒ Object 



302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/dependabot/julia/registry_client.rb', line 302

def batch_fetch_version_release_dates(packages_versions)
  result = call_julia_helper(
    function: "batch_get_version_release_dates",
    args: { packages_versions: packages_versions }
  )

  # Convert the result to a more Ruby-friendly format
  result.transform_values do |dates|
    next dates if dates.is_a?(Hash) && dates["error"]

    dates.is_a?(Hash) ? dates : {}
  end
rescue StandardError => e
  Dependabot.logger.error("Failed to batch fetch version release dates: #{e.message}")
  {}
end

#fetch_available_versions(package_name, package_uuid = nil) ⇒ Object 



222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/dependabot/julia/registry_client.rb', line 222

def fetch_available_versions(package_name, package_uuid = nil)
  # Use custom registries if available
  return fetch_available_versions_with_custom_registries(package_name, package_uuid) if custom_registries.any?

  args = { package_name: package_name }
  args[:package_uuid] = package_uuid if package_uuid

  result = call_julia_helper(
    function: "get_available_versions",
    args: args
  )

  # Check if the result contains an error
  return [] if result["error"]

  # Extract versions array from the result
  versions = result["versions"]
  return [] unless versions.is_a?(Array)

  versions.map(&:to_s)
rescue StandardError => e
  Dependabot.logger.warn("Failed to fetch available versions for #{package_name}: #{e.message}")
  []
end

#fetch_available_versions_with_custom_registries(package_name, package_uuid = nil) ⇒ Object 



248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
 
# File 'lib/dependabot/julia/registry_client.rb', line 248

def fetch_available_versions_with_custom_registries(package_name, package_uuid = nil)
  args = {
    package_name: package_name,
    package_uuid: package_uuid || "",
    registry_urls: custom_registry_urls
  }

  result = call_julia_helper(
    function: "get_available_versions_with_custom_registries",
    args: args
  )

  # Check if the result contains an error
  return [] if result["error"]

  # Extract versions array from the result
  versions = result["versions"]
  return [] unless versions.is_a?(Array)

  versions.map(&:to_s)
rescue StandardError => e
  Dependabot.logger.warn(
    "Failed to fetch available versions with custom registries for #{package_name}: #{e.message}"
  )
  []
end

#fetch_latest_version(package_name, package_uuid = nil) ⇒ Object 



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
 
# File 'lib/dependabot/julia/registry_client.rb', line 25

def fetch_latest_version(package_name, package_uuid = nil)
  # Use custom registries if available
  return fetch_latest_version_with_custom_registries(package_name, package_uuid) if custom_registries.any?

  args = { package_name: package_name }
  args[:package_uuid] = package_uuid if package_uuid

  result = call_julia_helper(
    function: "get_latest_version",
    args: args
  )

  # Check if the result itself contains an error (package not found)
  return nil if result["error"]

  # Extract version from the result structure
  # The Julia helper returns version directly in the result
  return nil unless result["version"]

  Gem::Version.new(result["version"])
rescue StandardError => e
  Dependabot.logger.warn(
    "Failed to fetch latest version for #{package_name}: #{e.message}"
  )
  nil
end

#fetch_latest_version_with_custom_registries(package_name, package_uuid = nil) ⇒ Object 



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
 
# File 'lib/dependabot/julia/registry_client.rb', line 53

def fetch_latest_version_with_custom_registries(package_name, package_uuid = nil)
  args = {
    package_name: package_name,
    package_uuid: package_uuid || "",
    registry_urls: custom_registry_urls
  }

  result = call_julia_helper(
    function: "get_latest_version_with_custom_registries",
    args: args
  )

  # Check if the result itself contains an error (package not found)
  return nil if result["error"]

  # Extract version from the result structure
  return nil unless result["version"]

  Gem::Version.new(result["version"])
rescue StandardError => e
  Dependabot.logger.warn(
    "Failed to fetch latest version with custom registries for #{package_name}: #{e.message}"
  )
  nil
end

#fetch_package_metadata(package_name, package_uuid) ⇒ Object 



80
81
82
83
84
85
86
87
88
 
# File 'lib/dependabot/julia/registry_client.rb', line 80

def fetch_package_metadata(package_name, package_uuid)
  call_julia_helper(
    function: "get_package_metadata",
    args: { package_name: package_name, package_uuid: package_uuid }
  )
rescue StandardError => e
  Dependabot.logger.warn("Failed to fetch metadata for #{package_name}: #{e.message}")
  nil
end

#fetch_version_release_date(package_name, version, package_uuid = nil) ⇒ Object 



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/dependabot/julia/registry_client.rb', line 199

def fetch_version_release_date(package_name, version, package_uuid = nil)
  result = call_julia_helper(
    function: "get_version_release_date",
    args: {
      package_name: package_name,
      version: version,
      package_uuid: package_uuid
    }
  )

  # Check if the result contains an error
  return nil if result["error"]

  # Parse the release date if available
  return nil unless result["release_date"]

  Time.parse(result["release_date"])
rescue StandardError => e
  Dependabot.logger.warn("Failed to fetch release date for #{package_name} v#{version}: #{e.message}")
  nil
end

#find_environment_files(directory) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/dependabot/julia/registry_client.rb', line 115

def find_environment_files(directory)
  result = call_julia_helper(
    function: "find_environment_files",
    args: { directory: directory }
  )

  return {} if result["error"]

  {
    "project_file" => result["project_file"],
    "manifest_file" => result["manifest_file"]
  }
rescue StandardError => e
  Dependabot.logger.warn("Failed to find environment files in #{directory}: #{e.message}")
  {}
end

#find_package_source_url(package_name, package_uuid = nil) ⇒ Object 



172
173
174
175
176
177
178
179
180
 
# File 'lib/dependabot/julia/registry_client.rb', line 172

def find_package_source_url(package_name, package_uuid = nil)
  args = { package_name: package_name }
  args[:package_uuid] = package_uuid if package_uuid

  call_julia_helper(
    function: "find_package_source_url",
    args: args
  )
end

#find_workspace_project_files(directory) ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/dependabot/julia/registry_client.rb', line 133

def find_workspace_project_files(directory)
  result = call_julia_helper(
    function: "find_workspace_project_files",
    args: { directory: directory }
  )

  return { "error" => result["error"] } if result["error"]

  {
    "project_files" => result["project_files"] || [],
    "manifest_file" => result["manifest_file"] || "",
    "workspace_root" => result["workspace_root"] || ""
  }
rescue StandardError => e
  Dependabot.logger.warn("Failed to find workspace project files in #{directory}: #{e.message}")
  { "error" => e.message }
end

#get_version_from_manifest(manifest_path, name, uuid) ⇒ Object 



158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/dependabot/julia/registry_client.rb', line 158

def get_version_from_manifest(manifest_path, name, uuid)
  result = call_julia_helper(
    function: "get_version_from_manifest",
    args: {
      manifest_path: manifest_path,
      name: name,
      uuid: uuid
    }
  )

  result["version"] unless result["error"]
end

#parse_manifest(manifest_path) ⇒ Object 



107
108
109
110
111
112
 
# File 'lib/dependabot/julia/registry_client.rb', line 107

def parse_manifest(manifest_path)
  call_julia_helper(
    function: "parse_manifest",
    args: { manifest_path: manifest_path }
  )
end

#parse_project(project_path:, manifest_path: nil) ⇒ Object 



96
97
98
99
100
101
102
103
104
 
# File 'lib/dependabot/julia/registry_client.rb', line 96

def parse_project(project_path:, manifest_path: nil)
  args = { project_path: project_path }
  args[:manifest_path] = manifest_path if manifest_path

  call_julia_helper(
    function: "parse_project",
    args: args
  )
end

#update_manifest(project_path:, updates:) ⇒ Object 



188
189
190
191
192
193
194
195
196
 
# File 'lib/dependabot/julia/registry_client.rb', line 188

def update_manifest(project_path:, updates:)
  call_julia_helper(
    function: "update_manifest",
    args: {
      project_path: project_path,
      updates: updates
    }
  )
end