pray-cli 1.14.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc753f65405f7052d882da07b3293b66c69e60cb26b8fe865919000323f2da1a
-  data.tar.gz: 91586f374cc5a677b0f5d2b722a4ba5da5912d8bd3664eac0ccd48b864889c65
+  metadata.gz: 5950b63f50e919bd5864874919afde95413ed095954046604d570d4c3daf090a
+  data.tar.gz: 82056f753f0d244afd54de70b7528d1e5d98b0c67f0da18538eb5d906986f12b
 SHA512:
-  metadata.gz: a84c2945dba3386f31dfdfc08d603ecee88d2be1e9898c20a993cd9dba9149ae4966b9cf9e02ba8c28905b7a1c81e2f5158bdf2eff8b36fe7f470e0bbd82ab6a
-  data.tar.gz: 48f107b5721d69c62b83db0f99247f9c4821eea42f85d3459cac09b7441badc3fa092965f877b1d3ae3fb0d38f391e8f65ae76cc21a6fd1595799dd2de0c6324
+  metadata.gz: e3289cc2a08751a1358c37ddfb692d042c2d522374b02ed370dd25e703f5c5fe3be66996bbd008a7e6dfbe26a9ea6b278b87f640035a55a235ef7e1ed1d00967
+  data.tar.gz: a54b4dbed546b3f301d42692033552c3878b2281f25fee70e647e02634c19541a7440542bddbade45619a2e6dd4cac8bcefc05ff89b035645195ce90a3bffad6

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 1.16.0 (2026-09-15)
+
+- Rewrite a two-component pessimistic Prayfile pin on `pray update --latest` (`~> 2.2` to `~> 2.4` when registry latest is 2.4.0), matching the Rust and TypeScript CLIs. Install a newer version that the current constraint already allows.
+- Resolve a local `.praypkg` from `tarball:`, including offline when the archive is on disk.
+- Refuse two-package dependency cycles during resolve, matching the Rust CLI.
+- Check dest files against `Prayfile.lock` managed spans without resolving packages (`inspect_locked_destinations`, RFC 0106).
+
+## 1.15.0 (2026-09-15)
+
+- Refresh path-fork trees with `pray update` (RFC 0114). Rewrite `spec.upstream` pins with `pray update --latest` when the pin does not admit the latest upstream version. Rewrite Prayfile constraints with `pray update --latest` when they do not admit the registry latest version. `pray update --latest --dry-run` prints the planned rewrite and does not write.
+- Keep `spec.upstream` in the packaged prayspec. Published registry metadata does not copy that pin.
+- Keep a listed package spec in `spec.files` when packing; refuse a repeated or aliased content path in the package archive.
+- Use the current project for a later install after an earlier in-process command in another directory.
+
 ## 1.14.0 (2026-09-14)
 
 - Keep an unchanged package version's artifact, first-publish time, and yank when `pray publish` runs again (RFC 0061).

data/lib/pray/archive.rb

@@ -4,6 +4,7 @@ require "json"
 require "open3"
 require "fileutils"
 require_relative "archive_unpack"
+require_relative "path_safety"
 
 module Pray
   module Archive
@@ -11,14 +12,23 @@ module Pray
 
     def build_package_archive_bytes(package)
       prayspec_path = Resolve.find_prayspec_file(package.root)
-      prayspec_name = File.basename(prayspec_path)
+      prayspec_name = PathSafety.validate_archive_member_path!(File.basename(prayspec_path))
       metadata = package_metadata_json(package)
+      written_paths = Set.new
+      record_archive_path(written_paths, "metadata.json", prayspec_name)
+      record_archive_path(written_paths, prayspec_name, prayspec_name)
+      package.spec.files.each do |file|
+        record_archive_path(written_paths, file, prayspec_name)
+      end
 
       Dir.mktmpdir("pray-package-") do |staging|
         File.write(File.join(staging, "metadata.json"), metadata)
         File.write(File.join(staging, prayspec_name), File.binread(prayspec_path))
         package.spec.files.each do |file|
-          destination = File.join(staging, file)
+          member = PathSafety.validate_archive_member_path!(file)
+          next if member == prayspec_name
+
+          destination = File.join(staging, member)
           FileUtils.mkdir_p(File.dirname(destination))
           File.binwrite(destination, File.binread(File.join(package.root, file)))
         end
@@ -66,5 +76,14 @@ module Pray
     def with_binary_process_encoding(&block)
       ArchiveUnpack.with_binary_process_encoding(&block)
     end
+
+    def record_archive_path(written_paths, path, auto_included_prayspec)
+      normalized = PathSafety.validate_archive_member_path!(path)
+      return if written_paths.add?(normalized)
+      return if normalized == auto_included_prayspec
+
+      raise Error.integrity("duplicate package archive path: #{normalized}")
+    end
+    private_class_method :record_archive_path
   end
 end

data/lib/pray/cli/commands/update_latest.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pray
+  module CLI
+    def update_latest_command(package, dry_run:, offline:)
+      path = manifest_path
+      original_text = Pray.read_manifest_text(path)
+      manifest_text = original_text
+      preview_options = ResolveOptions.new(
+        offline: offline,
+        refresh: true,
+        refresh_source_revisions: true,
+        ignore_locked_versions: true
+      )
+      project = resolve_current_project(preview_options)
+      if package && project.manifest.packages.none? { |entry| entry.name == package }
+        raise Error.manifest("package #{package} not found")
+      end
+
+      manifest_updates = []
+      project.packages.each do |resolved|
+        next if package && resolved.declaration.name != package
+        next unless resolved.registry_latest_version
+        next if Constraint.version_satisfies(resolved.registry_latest_version, resolved.declaration.constraint)
+
+        new_constraint = Constraint.latest_constraint_for_package(
+          resolved.declaration.constraint,
+          resolved.registry_latest_version
+        )
+        unless Constraint.version_satisfies(resolved.registry_latest_version, new_constraint)
+          raise Error.resolution(
+            "derived constraint #{new_constraint} does not admit registry latest #{resolved.registry_latest_version} for #{resolved.declaration.name}"
+          )
+        end
+
+        manifest_updates << {
+          name: resolved.declaration.name,
+          from_constraint: resolved.declaration.constraint,
+          to_constraint: new_constraint,
+          registry_latest_version: resolved.registry_latest_version
+        }
+        updated = resolved.declaration.dup
+        updated.constraint = new_constraint
+        manifest_text = Pray.replace_package_declaration(manifest_text, updated)
+      end
+
+      previous = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+      upstream_plans = Upstream.plan_path_upstream_latest_constraints(
+        project, previous, package, preview_options
+      )
+      print_latest_constraint_plans(manifest_updates, upstream_plans)
+
+      return if dry_run
+
+      Upstream.apply_path_upstream_latest_constraints(upstream_plans)
+      Transaction.write_file(path, manifest_text) if manifest_text != original_text
+      unlocked = package ? Set[package] : Set.new
+      options = ResolveOptions.new(
+        offline: offline,
+        refresh: true,
+        refresh_source_revisions: true,
+        ignore_locked_versions: package.nil?,
+        unlocked_packages: unlocked
+      )
+      current = resolve_current_project(options)
+      Upstream.apply_path_upstream_refreshes(current, previous, package, options)
+      install_command(
+        {
+          locked: false,
+          frozen: false,
+          offline: offline,
+          refresh: true,
+          ignore_locked_versions: package.nil?,
+          unlocked_packages: unlocked
+        }
+      )
+    end
+
+    def print_latest_constraint_plans(manifest_updates, upstream_plans)
+      if manifest_updates.empty? && upstream_plans.empty?
+        puts "All package constraints already allow latest versions"
+        return
+      end
+
+      manifest_updates.each do |update|
+        puts "Prayfile: #{update[:name]} constraint #{update[:from_constraint]} -> #{update[:to_constraint]} " \
+          "(registry latest #{update[:registry_latest_version]})"
+      end
+      upstream_plans.each do |plan|
+        puts "#{plan.package_name} upstream #{plan.current_constraint} -> #{plan.new_constraint} (latest #{plan.latest_version})"
+      end
+    end
+  end
+end

data/lib/pray/cli/commands/workflow.rb

@@ -10,7 +10,9 @@ module Pray
         frozen: flags[:frozen],
         locked: flags[:locked],
         offline: flags[:offline],
-        refresh: flags[:refresh]
+        refresh: flags[:refresh],
+        ignore_locked_versions: flags[:ignore_locked_versions],
+        unlocked_packages: flags[:unlocked_packages]
       )
     end
 
@@ -84,10 +86,10 @@ module Pray
     end
 
     def update_command(arguments)
-      if arguments.any? { |argument| %w[--dry-run --json].include?(argument) }
+      if arguments.include?("--json") || (arguments.include?("--dry-run") && !arguments.include?("--latest"))
         raise Error.unsupported("this Ruby CLI does not support --dry-run or --json for update; use `pray plan` to preview the current Prayfile")
       end
-      if arguments.any? { |argument| %w[--latest --major].include?(argument) }
+      if arguments.include?("--major")
         raise Error.unsupported(
           "to update beyond the current constraint, edit the package version in Prayfile, then run `pray update`"
         )
@@ -100,9 +102,29 @@ module Pray
           raise Error.manifest("package #{package} not found")
         end
       end
-      current = resolve_current_project(ResolveOptions.new(offline: offline))
-      Upstream.ensure_update_supported!(current.packages, package)
-      install_command({locked: false, frozen: false, offline: offline, refresh: true})
+      if arguments.include?("--latest")
+        return update_latest_command(package, dry_run: arguments.include?("--dry-run"), offline: offline)
+      end
+      unlocked = package ? Set[package] : Set.new
+      options = ResolveOptions.new(
+        offline: offline,
+        refresh: true,
+        refresh_source_revisions: true,
+        ignore_locked_versions: package.nil?,
+        unlocked_packages: unlocked
+      )
+      current = resolve_current_project(options)
+      Upstream.apply_path_upstream_refreshes(current, current.previous_lockfile, package, options)
+      install_command(
+        {
+          locked: false,
+          frozen: false,
+          offline: offline,
+          refresh: true,
+          ignore_locked_versions: package.nil?,
+          unlocked_packages: unlocked
+        }
+      )
     end
 
     def unlock_command(name)

data/lib/pray/cli/help.rb

@@ -101,7 +101,11 @@ module Pray
         "update" => <<~TEXT.strip,
           refresh package versions within constraints
 
-          Usage: pray update [package]
+          Usage: pray update [package] [--latest] [--latest --dry-run]
+
+          --latest adjusts constraints to allow the latest package versions.
+          --latest also rewrites exact spec.upstream pins in path packages, then refreshes those trees.
+          --latest --dry-run prints the planned rewrite and does not write.
         TEXT
         "plan" => <<~TEXT.strip,
           preview install/apply changes

data/lib/pray/cli.rb

@@ -10,6 +10,7 @@ require_relative "cli/suggest"
 require_relative "cli/helpers"
 require_relative "cli/commands/init"
 require_relative "cli/commands/workflow"
+require_relative "cli/commands/update_latest"
 require_relative "cli/commands/packages"
 require_relative "cli/commands/distribution"
 require_relative "cli/commands/trust"
@@ -22,6 +23,7 @@ module Pray
     LOCKFILE_PATH = "Prayfile.lock"
 
     def run(arguments)
+      previous_context = Invocation.context
       arguments = arguments.dup
       if arguments.delete("--no-input")
         ENV["PRAY_NO_INPUT"] = "1"
@@ -35,6 +37,8 @@ module Pray
       else
         dispatch(command)
       end
+    ensure
+      Invocation.context = previous_context
     end
 
     def maybe_print_help(arguments)

data/lib/pray/constraint.rb

@@ -17,15 +17,28 @@ module Pray
     end
 
     def version_satisfies(version, constraint)
-      normalized = normalize_version_constraint(constraint)
-      return true if normalized.empty? || normalized == "*"
+      parts = constraint.to_s.split(",").map(&:strip).reject(&:empty?)
+      return true if parts.empty?
 
-      requirement = Gem::Requirement.new(normalized.strip)
-      requirement.satisfied_by?(Gem::Version.new(version))
+      parsed = Gem::Version.new(version)
+      parts.all? { |part| version_satisfies_one(parsed, part) }
     rescue ArgumentError => error
       raise Error.resolution(error.message)
     end
 
+    def version_satisfies_one(version, constraint)
+      normalized = normalize_version_constraint(constraint)
+      return true if normalized.empty? || normalized == "*"
+
+      requirement_text = if normalized.lstrip.start_with?("~>")
+        ruby_pessimistic_to_semver(normalized)
+      else
+        normalized.strip
+      end
+      clauses = requirement_text.split(",").map(&:strip).reject(&:empty?)
+      Gem::Requirement.new(*clauses).satisfied_by?(version)
+    end
+
     def pessimistic_constraint_for_version(version)
       parsed = Gem::Version.new(version)
       if parsed.segments[1].to_i.zero? && parsed.segments[2].to_i.zero?

data/lib/pray/dependency_graph.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pray
+  module DependencyGraph
+    module_function
+
+    def find_dependency_cycle(edges)
+      visiting = {}
+      visited = {}
+      stack = []
+      edges.keys.sort.each do |name|
+        next if visited[name]
+
+        cycle = depth_first_search(name, edges, visiting, visited, stack)
+        return cycle if cycle
+      end
+      nil
+    end
+
+    def depth_first_search(name, edges, visiting, visited, stack)
+      return nil if visited[name]
+      if visiting[name]
+        start = stack.index(name)
+        return nil unless start
+
+        return stack[start..] + [name]
+      end
+
+      visiting[name] = true
+      stack << name
+      Array(edges[name]).each do |dependency|
+        next unless edges.key?(dependency)
+
+        cycle = depth_first_search(dependency, edges, visiting, visited, stack)
+        return cycle if cycle
+      end
+      stack.pop
+      visiting.delete(name)
+      visited[name] = true
+      nil
+    end
+  end
+end

data/lib/pray/git_sources.rb

@@ -16,8 +16,8 @@ module Pray
         next unless source.kind == "git"
 
         clone_url = source.url.delete_prefix("git+")
-        if local_filesystem_source?(clone_url) && !local_git_repo_path(clone_url)
-          source_root = local_git_source_root(clone_url)
+        if local_filesystem_source?(clone_url) && !local_git_repo_path(project_root, clone_url)
+          source_root = local_git_source_root(project_root, clone_url)
           if source_root
             checkouts[source.name] = GitSourceCheckout.new(
               cache_directory: source_root,
@@ -76,12 +76,8 @@ module Pray
       File.directory?(File.join(path, "v1", "packages"))
     end
 
-    def local_git_source_root(clone_url)
-      path = if clone_url.start_with?("file://")
-        clone_url.delete_prefix("file://")
-      else
-        clone_url
-      end
+    def local_git_source_root(project_root, clone_url)
+      path = clone_url_filesystem_path(project_root, clone_url)
       return nil unless File.exist?(path)
 
       discover_distribution_root(path)
@@ -136,12 +132,17 @@ module Pray
       clone_url.start_with?("file://") || Pathname.new(clone_url).absolute?
     end
 
-    def local_git_repo_path(clone_url)
-      path = clone_url.delete_prefix("file://")
+    def local_git_repo_path(project_root, clone_url)
+      path = clone_url_filesystem_path(project_root, clone_url)
       git_directory = File.join(path, ".git")
       File.directory?(git_directory) ? path : nil
     end
 
+    def clone_url_filesystem_path(project_root, clone_url)
+      path = clone_url.delete_prefix("file://")
+      Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+    end
+
     def global_cache_root
       return ENV["PRAY_CACHE"] if ENV["PRAY_CACHE"]
       return File.join(ENV["PRAY_HOME"], "cache") if ENV["PRAY_HOME"]

data/lib/pray/materialize.rb

@@ -13,7 +13,9 @@ module Pray
       frozen: false,
       locked: false,
       offline: false,
-      refresh: false
+      refresh: false,
+      ignore_locked_versions: false,
+      unlocked_packages: nil
     )
       context = Invocation.invocation_context
       manifest_path = File.expand_path(manifest_path || context.manifest_path)
@@ -25,6 +27,9 @@ module Pray
       options = ResolveOptions.new(
         offline: offline,
         refresh: refresh,
+        refresh_source_revisions: refresh,
+        ignore_locked_versions: ignore_locked_versions,
+        unlocked_packages: unlocked_packages ? Set.new(unlocked_packages) : Set.new,
         environment: context.environment
       )
       allow_git_refresh_fallback = !locked && !frozen
@@ -128,6 +133,7 @@ module Pray
   def resolve_project(...) = Resolve.resolve_project(...)
   def render_project(...) = Render.render_project(...)
   def inspect_project(...) = Verify.inspect_project(...)
+  def inspect_locked_destinations(...) = Verify.inspect_locked_destinations(...)
   def verify_project(...) = Verify.verify_project(...)
   def drift_project(...) = Verify.drift_project(...)
 end

data/lib/pray/package_spec_render.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Pray
+  module PackageSpecRender
+    module_function
+
+    def fork_spec_after_refresh(local, new_upstream, local_prayspec_file, clean_replica, merged_content_paths)
+      spec = local.dup
+      spec.files = [local_prayspec_file, *merged_content_paths]
+      if clean_replica
+        spec.exports = new_upstream.exports.dup
+        spec.templates = new_upstream.templates.dup
+      end
+      if spec.upstream
+        spec.upstream = PackageUpstream.new(
+          name: new_upstream.name,
+          constraint: Upstream.next_upstream_constraint(spec.upstream.constraint, new_upstream.version)
+        )
+      end
+      spec
+    end
+
+    def render_package_spec(spec)
+      lines = ["Package::Specification.new do |spec|"]
+      push_identity_fields(lines, spec)
+      push_content_fields(lines, spec)
+      push_relation_fields(lines, spec)
+      lines << "end"
+      lines << ""
+      lines.join("\n")
+    end
+
+    def push_identity_fields(lines, spec)
+      push_assignment(lines, "name", spec.name)
+      push_assignment(lines, "version", spec.version)
+      push_optional(lines, "summary", spec.summary)
+      push_optional(lines, "description", spec.description)
+      push_array(lines, "authors", spec.authors) unless spec.authors.nil? || spec.authors.empty?
+      push_optional(lines, "license", spec.license)
+      push_optional(lines, "homepage", spec.homepage)
+      push_optional(lines, "source_code_uri", spec.source_code_uri)
+      push_optional(lines, "changelog_uri", spec.changelog_uri)
+      push_optional(lines, "prayfile_version", spec.prayfile_version)
+    end
+
+    def push_content_fields(lines, spec)
+      push_array(lines, "files", spec.files)
+      push_exports(lines, spec.exports)
+      push_named_paths(lines, "skills", spec.skills)
+      push_named_paths(lines, "templates", spec.templates)
+      push_string_map(lines, "adapters", spec.adapters)
+      push_array(lines, "targets", spec.targets) unless spec.targets.nil? || spec.targets.empty?
+    end
+
+    def push_relation_fields(lines, spec)
+      (spec.dependencies || []).each do |dependency|
+        method = dependency.optional ? "add_optional_dependency" : "add_dependency"
+        lines << "  spec.#{method} #{quote(dependency.name)}, #{quote(dependency.constraint)}"
+      end
+      unless spec.metadata.nil? || spec.metadata.empty?
+        lines << "  spec.metadata = #{literal_map(spec.metadata)}"
+      end
+      return unless spec.upstream
+
+      lines << "  spec.upstream #{quote(spec.upstream.name)}, #{quote(spec.upstream.constraint)}"
+    end
+
+    def push_assignment(lines, field, value)
+      lines << "  spec.#{field} = #{quote(value)}"
+    end
+
+    def push_optional(lines, field, value)
+      push_assignment(lines, field, value) unless value.nil?
+    end
+
+    def push_array(lines, field, values)
+      lines << "  spec.#{field} = [#{string_array(values)}]"
+    end
+
+    def push_exports(lines, exports)
+      return if exports.nil? || exports.empty?
+
+      lines << "  spec.exports = {"
+      exports.each do |name, export|
+        fields = ["type: #{quote(export.kind)}", "path: #{quote(export.path)}"]
+        fields << "summary: #{quote(export.summary)}" if export.summary
+        fields << "only: [#{string_array(export.only)}]" unless export.only.nil? || export.only.empty?
+        fields << "except: [#{string_array(export.except)}]" unless export.except.nil? || export.except.empty?
+        fields << "default_path: #{quote(export.default_path)}" if export.default_path
+        lines << "    #{quote(name)} => { #{fields.join(", ")} },"
+      end
+      lines << "  }"
+    end
+
+    def push_named_paths(lines, field, entries)
+      return if entries.nil? || entries.empty?
+
+      lines << "  spec.#{field} = {"
+      entries.each do |name, entry|
+        summary = entry.summary ? ", summary: #{quote(entry.summary)}" : ""
+        lines << "    #{quote(name)} => { path: #{quote(entry.path)}#{summary} },"
+      end
+      lines << "  }"
+    end
+
+    def push_string_map(lines, field, entries)
+      return if entries.nil? || entries.empty?
+
+      values = entries.map { |name, value| "#{quote(name)} => #{quote(value)}" }.join(", ")
+      lines << "  spec.#{field} = { #{values} }"
+    end
+
+    def string_array(values)
+      Array(values).map { |value| quote(value) }.join(", ")
+    end
+
+    def quote(value)
+      escaped = value.to_s.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n").gsub("\r", "\\r").gsub("\t", "\\t")
+      %("#{escaped}")
+    end
+
+    def literal_map(entries)
+      values = entries.map { |name, value| "#{quote(name)} => #{literal(value)}" }.join(", ")
+      "{ #{values} }"
+    end
+
+    def literal(value)
+      case value.kind
+      when :string then quote(value.value)
+      when :symbol then ":#{value.value}"
+      when :bool then value.value.to_s
+      when :null then "nil"
+      when :integer then value.value.to_s
+      when :array then "[#{value.value.map { |entry| literal(entry) }.join(", ")}]"
+      when :map then literal_map(value.value)
+      else quote(value.value)
+      end
+    end
+    private_class_method :push_identity_fields, :push_content_fields, :push_relation_fields,
+      :push_assignment, :push_optional, :push_array, :push_exports,
+      :push_named_paths, :push_string_map, :string_array, :quote, :literal_map, :literal
+  end
+end

data/lib/pray/path_safety.rb

@@ -39,20 +39,24 @@ module Pray
     end
 
     def validate_archive_member_path!(path)
-      cleaned = path.to_s.delete_prefix("./")
-      if cleaned.empty? || Pathname.new(cleaned).absolute? || cleaned.start_with?("/")
+      text = path.to_s.tr("\\", "/")
+      if text.empty? || Pathname.new(text).absolute? || text.start_with?("/")
         raise Error.integrity("package path must be relative: #{path}")
       end
 
-      cleaned.split("/").each do |part|
+      parts = []
+      text.split("/").each do |part|
         next if part.empty? || part == "."
 
         if part == ".." || part.include?("\0")
           raise Error.integrity("package path escapes package root: #{path}")
         end
+
+        parts << part
       end
+      raise Error.integrity("package path must be relative: #{path}") if parts.empty?
 
-      cleaned
+      parts.join("/")
     end
 
     def validate_project_relative_path!(value)

data/lib/pray/registry.rb

@@ -8,6 +8,7 @@ require "pathname"
 require "time"
 require_relative "path_safety"
 require_relative "http_body"
+require_relative "registry_paths"
 
 module Pray
   RegistryPackageVersion = Struct.new(
@@ -40,6 +41,17 @@ module Pray
     module_function
 
     def resolve_registry_package_root(project_root, source_url, declaration, preferred_version: nil, offline: false)
+      if local_source?(source_url)
+        return resolve_local_registry_package_root(
+          project_root,
+          source_url,
+          RegistryPaths.local_registry_root(project_root, source_url),
+          declaration,
+          preferred_version: preferred_version,
+          offline: offline
+        )
+      end
+
       metadata = fetch_package_metadata(source_url, declaration.name)
       registry_latest_version = registry_latest_version_label(metadata)
       selected = select_package_version(metadata, declaration.constraint, preferred_version)

data/lib/pray/registry_paths.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Pray
+  module RegistryPaths
+    module_function
+
+    def local_registry_root(project_root, source_url)
+      path = source_url.delete_prefix("file://")
+      Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+    end
+  end
+end