dependabot-julia 0.394.0 → 0.395.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0219cc4b94273c02bf11ff9ca22e92ec689176e726642e5ef6c997c37fdbf135'
-  data.tar.gz: 5f9bfa61d84f6e038708ada16bf668bddca75cd16d21c16391398384193c2a81
+  metadata.gz: 54579433c6beab3470827fa806a2e620123a56fd2d4b52e1b20573558630cb4c
+  data.tar.gz: 9d9d3d58871d1cfbc2ef1dd47f51628d6b9af1473f0559ebc58783433f5f53d1
 SHA512:
-  metadata.gz: 3e5b6dc2946c09316008c22a48760367eb4fc194713bae8cf3502480ed1c4309c062b022026648551b0f012e4f5ea81d43648c673b50b87483a8e18b799f6489
-  data.tar.gz: 02ad07a0267576e4adcf8f428f485c45536a4e78e6b638b61e6313b3d4721ee3f48f40adb6de4d9bf98e112a0907326e4e4421c2e571ff81d5098d3e30aea837
+  metadata.gz: 84c9be79e65dd54336e7d4edf6547099dcc9454f9199774f1b7781f322eafd869622740d7197183dcf35211495cd1d712fdc7aac0e27d322064119d0902117d4
+  data.tar.gz: c94d643415848f2ff46c5c69303321a535404f64eb53a39ca1ba39035a528711a9ecf2ecde5c1b8835e851bf390469a7ed58d0c0363f8e87798166f0d696e4ca

data/lib/dependabot/julia/file_fetcher.rb

@@ -33,10 +33,12 @@ module Dependabot
       sig { params(temp_dir: T.any(Pathname, String)).returns(T::Array[Dependabot::DependencyFile]) }
       def fetch_files_using_julia_helper(temp_dir)
         workspace_info = registry_client.find_workspace_project_files(temp_dir.to_s)
-        validate_workspace_info!(workspace_info)
+        if workspace_info.is_a?(Dependabot::Julia::RegistryClient::Result::Failure)
+          raise Dependabot::DependencyFileNotFound, "No Project.toml or JuliaProject.toml found."
+        end
 
-        project_files = T.cast(workspace_info["project_files"], T::Array[String])
-        manifest_path = T.cast(workspace_info["manifest_file"], String)
+        project_files = workspace_info.project_files
+        manifest_path = workspace_info.manifest_file
 
         fetched_files = fetch_all_project_files(project_files, temp_dir.to_s)
         raise Dependabot::DependencyFileNotFound, "No Project.toml or JuliaProject.toml found." if fetched_files.empty?
@@ -45,20 +47,6 @@ module Dependabot
         fetched_files
       end
 
-      sig { params(workspace_info: T::Hash[String, Object]).void }
-      def validate_workspace_info!(workspace_info)
-        # Only domain errors ("no project file found") reach here; helper
-        # crashes raise from RegistryClient rather than being misreported as
-        # a missing Project.toml.
-        error_value = T.cast(workspace_info["error"], T.nilable(String))
-        has_error = !error_value.nil?
-        project_files = T.cast(workspace_info["project_files"], T.nilable(T::Array[String]))
-        no_projects = project_files.nil? || project_files.empty?
-        return unless has_error || no_projects
-
-        raise Dependabot::DependencyFileNotFound, "No Project.toml or JuliaProject.toml found."
-      end
-
       sig { params(project_files: T::Array[String], base_dir: String).returns(T::Array[Dependabot::DependencyFile]) }
       def fetch_all_project_files(project_files, base_dir)
         project_files.filter_map do |project_path|

data/lib/dependabot/julia/file_parser.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "tempfile"
@@ -114,22 +114,20 @@ module Dependabot
         # a sibling member) resolve by path within the workspace, never from a
         # registry, so they must not be treated as updatable dependencies.
         workspace_package_uuids = parsed_projects.filter_map do |_, result|
-          T.cast(result["uuid"], T.nilable(String))
+          result.uuid
         end
 
         parsed_projects.each do |proj_file, result|
-          parsed_deps = T.cast(result["dependencies"] || [], T::Array[T.untyped])
           merge_dependencies_from_list(
-            parsed_deps,
+            result.dependencies,
             ["deps"],
             proj_file.name,
             dependencies_map,
             workspace_package_uuids
           )
 
-          parsed_weak_deps = T.cast(result["weak_dependencies"] || [], T::Array[T.untyped])
           merge_dependencies_from_list(
-            parsed_weak_deps,
+            result.weak_dependencies,
             ["weakdeps"],
             proj_file.name,
             dependencies_map,
@@ -171,34 +169,34 @@ module Dependabot
 
         result = parse_manifest_content(T.must(manifest.content))
 
-        if result["error"]
-          Dependabot.logger.warn("Failed to parse Julia manifest: #{result['error']}")
+        if result.is_a?(Dependabot::Julia::RegistryClient::Result::Failure)
+          Dependabot.logger.warn("Failed to parse Julia manifest: #{result.message}")
           return {}
         end
 
-        deps = T.cast(result["dependencies"] || [], T::Array[T.untyped])
-        deps.each_with_object({}) do |dep_info, map|
-          dep_hash = T.cast(dep_info, T::Hash[String, T.untyped])
-          uuid = T.cast(dep_hash["uuid"], T.nilable(String))
-          version = T.cast(dep_hash["version"], T.nilable(String)).to_s
-          next if uuid.nil? || version.empty?
+        result.dependencies.each_with_object({}) do |dependency, map|
+          next if dependency.version.empty?
 
-          map[uuid] = version
+          map[dependency.uuid] = dependency.version
         end
       end
 
-      sig { params(content: String).returns(T::Hash[String, T.untyped]) }
+      sig do
+        params(content: String)
+          .returns(T.any(
+                     Dependabot::Julia::RegistryClient::Result::Manifest,
+                     Dependabot::Julia::RegistryClient::Result::Failure
+                   ))
+      end
       def parse_manifest_content(content)
-        result = T.let(nil, T.nilable(T::Hash[String, T.untyped]))
         Dir.mktmpdir("julia_manifest") do |temp_dir|
           # Written under a fixed name: version-suffixed manifests
           # (Manifest-v1.11.toml) would otherwise be skipped by Pkg when the
           # helper's Julia version doesn't match.
           manifest_path = File.join(temp_dir, "Manifest.toml")
           File.write(manifest_path, content)
-          result = registry_client.parse_manifest(manifest_path)
+          registry_client.parse_manifest(manifest_path)
         end
-        T.must(result)
       end
 
       sig { returns(T.nilable(Dependabot::DependencyFile)) }
@@ -208,7 +206,10 @@ module Dependabot
         end
       end
 
-      sig { params(proj_file: Dependabot::DependencyFile).returns(T.nilable(T::Hash[String, T.untyped])) }
+      sig do
+        params(proj_file: Dependabot::DependencyFile)
+          .returns(T.nilable(Dependabot::Julia::RegistryClient::Result::Project))
+      end
       def parse_project_file(proj_file)
         temp_dir = Dir.mktmpdir("julia_project")
         # File names like "../Project.toml" (a workspace root fetched from a
@@ -224,7 +225,7 @@ module Dependabot
         begin
           result = registry_client.parse_project(project_path: project_path)
 
-          return nil if result["error"]
+          return nil if result.is_a?(Dependabot::Julia::RegistryClient::Result::Failure)
 
           result
         ensure
@@ -234,7 +235,7 @@ module Dependabot
 
       sig do
         params(
-          dep_list: T::Array[T.untyped],
+          dep_list: T::Array[Dependabot::Julia::RegistryClient::Result::ProjectDependency],
           groups: T::Array[String],
           file_name: String,
           dependencies_map: T::Hash[String, Dependabot::Dependency],
@@ -242,13 +243,12 @@ module Dependabot
         ).void
       end
       def merge_dependencies_from_list(dep_list, groups, file_name, dependencies_map, workspace_package_uuids)
-        dep_list.each do |dep_info|
-          dep_hash = T.cast(dep_info, T::Hash[String, T.untyped])
-          name = T.cast(dep_hash["name"], String)
+        dep_list.each do |dependency|
+          name = dependency.name
           next if name == "julia" # Skip Julia version requirement
 
-          uuid = T.cast(dep_hash["uuid"], T.nilable(String))
-          requirement_string = T.cast(dep_hash["requirement"], T.nilable(String))
+          uuid = dependency.uuid
+          requirement_string = dependency.requirement
 
           next if skip_dependency?(uuid, requirement_string, file_name, workspace_package_uuids)
 
@@ -279,7 +279,7 @@ module Dependabot
               version: nil,
               requirements: [new_requirement],
               package_manager: "julia",
-              metadata: uuid ? { julia_uuid: uuid } : {}
+              metadata: { julia_uuid: uuid }
             )
           end
         end

data/lib/dependabot/julia/file_updater.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "toml-rb"
@@ -70,7 +70,9 @@ module Dependabot
           write_all_temporary_files(updated_project_files, actual_manifest)
           result = call_julia_helper
 
-          return handle_julia_helper_error_multi(result, actual_manifest, updated_project_files) if result["error"]
+          if result.is_a?(Dependabot::Julia::RegistryClient::Result::Failure)
+            return handle_julia_helper_error_multi(result, actual_manifest, updated_project_files)
+          end
 
           build_updated_files_multi(updated_files, updated_project_files, actual_manifest, result)
         end
@@ -147,7 +149,14 @@ module Dependabot
         File.write(manifest_path, actual_manifest.content)
       end
 
-      sig { returns(T::Hash[String, T.untyped]) }
+      sig do
+        returns(
+          T.any(
+            Dependabot::Julia::RegistryClient::Result::ManifestUpdate,
+            Dependabot::Julia::RegistryClient::Result::Failure
+          )
+        )
+      end
       def call_julia_helper
         registry_client.update_manifest(
           project_path: Dir.pwd,
@@ -157,13 +166,13 @@ module Dependabot
 
       sig do
         params(
-          result: T::Hash[String, T.untyped],
+          result: Dependabot::Julia::RegistryClient::Result::Failure,
           actual_manifest: Dependabot::DependencyFile,
           updated_project_files: T::Array[T::Hash[Symbol, T.untyped]]
         ).returns(T::Array[Dependabot::DependencyFile])
       end
       def handle_julia_helper_error_multi(result, actual_manifest, updated_project_files)
-        error_message = result["error"]
+        error_message = result.message
         manifest_path = actual_manifest.name
 
         is_resolver_error = resolver_error?(error_message)
@@ -212,7 +221,7 @@ module Dependabot
           updated_files: T::Array[Dependabot::DependencyFile],
           updated_project_files: T::Array[T::Hash[Symbol, T.untyped]],
           actual_manifest: Dependabot::DependencyFile,
-          result: T::Hash[String, T.untyped]
+          result: Dependabot::Julia::RegistryClient::Result::ManifestUpdate
         ).void
       end
       def build_updated_files_multi(updated_files, updated_project_files, actual_manifest, result)
@@ -225,16 +234,10 @@ module Dependabot
           updated_files << updated_file(file: file, content: content)
         end
 
-        return unless result["manifest_content"]
-
-        updated_manifest_content = result["manifest_content"]
+        updated_manifest_content = result.manifest_content
         return unless updated_manifest_content != actual_manifest.content
 
-        manifest_for_update = if result["manifest_path"]
-                                manifest_file_for_path(result["manifest_path"])
-                              else
-                                actual_manifest
-                              end
+        manifest_for_update = manifest_file_for_path(result.manifest_path)
         updated_files << updated_file(file: manifest_for_update, content: updated_manifest_content)
       end
 

data/lib/dependabot/julia/metadata_finder.rb

@@ -30,10 +30,9 @@ module Dependabot
       def source_url_from_julia_helper
         uuid = T.cast(dependency.metadata[:julia_uuid], T.nilable(String))
         result = registry_client.find_package_source_url(dependency.name, uuid)
-        error = T.cast(result["error"], T.nilable(T.any(String, T::Boolean)))
-        return nil if error
+        return nil if result.is_a?(Dependabot::Julia::RegistryClient::Result::Failure)
 
-        T.cast(result["source_url"], T.nilable(String))
+        result.source_url
       rescue StandardError => e
         Dependabot.logger.warn("Failed to get source URL from Julia helper: #{e.message}")
         nil

data/lib/dependabot/julia/package/package_details_fetcher.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "time"
@@ -89,35 +89,41 @@ module Dependabot
         def fetch_release_dates_batch(registry_client, available_versions, uuid)
           return {} if available_versions.empty?
 
-          packages_versions = [{
-            name: dependency.name,
-            uuid: uuid || "",
-            versions: available_versions
-          }]
+          packages_versions = [
+            RegistryClient::Result::PackageVersionsRequest.new(
+              name: dependency.name,
+              uuid: uuid || "",
+              versions: available_versions
+            )
+          ]
 
           result = registry_client.batch_fetch_version_release_dates(packages_versions)
-          dates_for_package = result[dependency.name] || {}
+          return {} if result.is_a?(RegistryClient::Result::Failure)
+
+          dates_for_package = result.packages[dependency.name]
+          return {} unless dates_for_package.is_a?(RegistryClient::Result::ReleaseDates)
 
           convert_dates_to_time_objects(dates_for_package)
         end
 
         sig do
           params(
-            dates_hash: T::Hash[String, T.untyped]
+            release_dates: RegistryClient::Result::ReleaseDates
           ).returns(T::Hash[String, T.nilable(Time)])
         end
-        def convert_dates_to_time_objects(dates_hash)
-          dates_hash.transform_values do |date_value|
-            convert_single_date(date_value)
+        def convert_dates_to_time_objects(release_dates)
+          release_dates.dates.transform_values do |result|
+            next if result.is_a?(RegistryClient::Result::Failure)
+
+            convert_single_date(result.release_date)
           end
         end
 
-        sig { params(date_value: T.untyped).returns(T.nilable(Time)) }
+        sig { params(date_value: T.nilable(String)).returns(T.nilable(Time)) }
         def convert_single_date(date_value)
           return nil if date_value.nil?
-          return nil if date_value.is_a?(Hash) && date_value["error"]
 
-          Time.parse(date_value.to_s)
+          Time.parse(date_value)
         rescue ArgumentError, TypeError
           nil
         end