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.



22
23
24
25
 
# File 'lib/dependabot/julia/registry_client.rb', line 22

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

Instance Method Details

#batch_fetch_available_versions(dependencies) ⇒ Object 



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'lib/dependabot/julia/registry_client.rb', line 312

def batch_fetch_available_versions(dependencies)
  return {} if dependencies.empty?

  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 }
  )
end

#batch_fetch_package_info(dependencies) ⇒ Object 



274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
 
# File 'lib/dependabot/julia/registry_client.rb', line 274

def batch_fetch_package_info(dependencies)
  return {} if dependencies.empty?

  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 }
  )
end

#batch_fetch_version_release_dates(packages_versions) ⇒ Object 



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
 
# File 'lib/dependabot/julia/registry_client.rb', line 295

def batch_fetch_version_release_dates(packages_versions)
  return {} if packages_versions.empty?

  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
end

#fetch_available_versions(package_name, package_uuid = nil) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/dependabot/julia/registry_client.rb', line 216

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
  if result["error"]
    Dependabot.logger.warn("Failed to fetch available versions for #{package_name}: #{result['error']}")
    return []
  end

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

  versions.map(&:to_s)
end

#fetch_available_versions_with_custom_registries(package_name, package_uuid = nil) ⇒ Object 



242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/dependabot/julia/registry_client.rb', line 242

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
  if result["error"]
    Dependabot.logger.warn(
      "Failed to fetch available versions with custom registries for #{package_name}: #{result['error']}"
    )
    return []
  end

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

  versions.map(&:to_s)
end

#fetch_latest_version(package_name, package_uuid = nil) ⇒ Object 



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

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)
  if result["error"]
    Dependabot.logger.warn(
      "Failed to fetch latest version for #{package_name}: #{result['error']}"
    )
    return nil
  end

  # 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"])
end

#fetch_latest_version_with_custom_registries(package_name, package_uuid = nil) ⇒ Object 



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

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)
  if result["error"]
    Dependabot.logger.warn(
      "Failed to fetch latest version with custom registries for #{package_name}: #{result['error']}"
    )
    return nil
  end

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

  Gem::Version.new(result["version"])
end

#fetch_package_metadata(package_name, package_uuid) ⇒ Object 



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

def fetch_package_metadata(package_name, package_uuid)
  call_julia_helper(
    function: "get_package_metadata",
    args: { package_name: package_name, package_uuid: package_uuid }
  )
end

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



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/dependabot/julia/registry_client.rb', line 193

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 ArgumentError => e
  Dependabot.logger.warn("Failed to parse 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
 
# 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"]
  }
end

#find_package_source_url(package_name, package_uuid = nil) ⇒ Object 



166
167
168
169
170
171
172
173
174
 
# File 'lib/dependabot/julia/registry_client.rb', line 166

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 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/dependabot/julia/registry_client.rb', line 130

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"] || ""
  }
end

#get_version_from_manifest(manifest_path, name, uuid) ⇒ Object 



152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/dependabot/julia/registry_client.rb', line 152

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 



182
183
184
185
186
187
188
189
190
 
# File 'lib/dependabot/julia/registry_client.rb', line 182

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