pray-cli 1.16.0 → 1.18.0

data/lib/pray/git_sources.rb

@@ -1,48 +1,73 @@
 # frozen_string_literal: true
 
-require "open3"
-require "fileutils"
 require "pathname"
+require_relative "git_cache"
 
 module Pray
   GitSourceCheckout = Struct.new(:cache_directory, :revision, :subdir)
 
+  class GitSourceSet
+    def initialize(project_root, sources, lockfile, refresh:)
+      @project_root = project_root
+      @lockfile = lockfile
+      @refresh = refresh
+      @sources = sources.select { |source| source.kind == "git" }.to_h { |source| [source.name, source] }
+      @checkouts = {}
+    end
+
+    def [](name)
+      return @checkouts[name] if @checkouts.key?(name)
+
+      source = @sources[name]
+      return nil unless source
+
+      checkout = GitSources.prepare_one_git_source(@project_root, source, @lockfile, refresh: @refresh)
+      @checkouts[name] = checkout if checkout
+      checkout
+    end
+
+    def revisions
+      @checkouts.each_with_object({}) do |(name, checkout), collected|
+        next if checkout.revision.to_s.empty?
+
+        collected[name] = checkout.revision
+      end
+    end
+  end
+
   module GitSources
     module_function
 
     def prepare_git_sources(project_root, sources, lockfile, refresh: false)
-      checkouts = {}
-      sources.each do |source|
-        next unless source.kind == "git"
-
-        clone_url = source.url.delete_prefix("git+")
-        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,
-              revision: "",
-              subdir: source.subdir
-            )
-          end
-          next
-        end
-
-        pinned_revision = refresh ? nil : pinned_revision_for_source(lockfile, source)
-        cache_directory, revision = ensure_git_repository(
-          project_root,
-          clone_url,
-          refresh: refresh,
-          pinned_revision: pinned_revision,
-          sparse_subdir: source.subdir
-        )
-        checkouts[source.name] = GitSourceCheckout.new(
-          cache_directory: cache_directory,
-          revision: revision,
+      GitSourceSet.new(project_root, sources, lockfile, refresh: refresh)
+    end
+
+    def prepare_one_git_source(project_root, source, lockfile, refresh:)
+      clone_url = source.url.delete_prefix("git+")
+      if local_filesystem_source?(clone_url) && !local_git_repo_path(project_root, clone_url)
+        source_root = local_git_source_root(project_root, clone_url)
+        return unless source_root
+
+        return GitSourceCheckout.new(
+          cache_directory: source_root,
+          revision: "",
           subdir: source.subdir
         )
       end
-      checkouts
+
+      pinned_revision = refresh ? nil : pinned_revision_for_source(lockfile, source)
+      cache_directory, revision = GitCache.ensure_git_repository(
+        project_root,
+        clone_url,
+        refresh: refresh,
+        pinned_revision: pinned_revision,
+        sparse_subdir: source.subdir
+      )
+      GitSourceCheckout.new(
+        cache_directory: cache_directory,
+        revision: revision,
+        subdir: source.subdir
+      )
     end
 
     def resolve_distribution_root(repo_root, subdir)
@@ -83,39 +108,12 @@ module Pray
       discover_distribution_root(path)
     end
 
-    def ensure_git_repository(project_root, clone_url, refresh:, pinned_revision:, sparse_subdir:)
-      cache_directory = git_source_cache_directory(project_root, clone_url)
-      if File.directory?(File.join(cache_directory, ".git"))
-        refresh_global_git_cache(clone_url) if refresh
-        if pinned_revision
-          checkout_git_revision(cache_directory, clone_url, pinned_revision, refresh)
-        elsif refresh
-          refresh_git_worktree(cache_directory, clone_url)
-        end
-        apply_sparse_checkout(cache_directory, sparse_subdir) if sparse_subdir
-        revision = git_head_revision(cache_directory)
-        return [cache_directory, revision]
-      end
-
-      FileUtils.rm_rf(cache_directory) if File.exist?(cache_directory)
-      FileUtils.mkdir_p(File.dirname(cache_directory))
-      if seed_git_cache_from_global(clone_url, cache_directory, project_root)
-        run_git_in_repo(cache_directory, "remote", "set-url", "origin", clone_url)
-      else
-        run_git(project_root, "clone", "--depth", "1", clone_url, cache_directory)
-        mirror_git_cache_to_global(clone_url, cache_directory)
-      end
-      checkout_git_revision(cache_directory, clone_url, pinned_revision, true) if pinned_revision
-      apply_sparse_checkout(cache_directory, sparse_subdir) if sparse_subdir
-      [cache_directory, git_head_revision(cache_directory)]
-    end
-
-    def git_source_cache_directory(project_root, clone_url)
-      File.join(project_root, ".pray", "cache", "git", cache_key(clone_url))
+    def git_source_cache_directory(project_root, clone_url, subdir = nil)
+      GitCache.git_source_cache_directory(project_root, clone_url, subdir)
     end
 
-    def cache_key(text)
-      Hashing.sha256_prefixed(text)[7, 16]
+    def git_source_cached_repository(project_root, clone_url)
+      GitCache.git_source_cached_repository(project_root, clone_url)
     end
 
     def pinned_revision_for_source(lockfile, source)
@@ -142,88 +140,5 @@ module Pray
       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"]
-
-      home = ENV["HOME"]
-      home ? File.join(home, ".cache", "pray") : nil
-    end
-
-    def global_git_cache_directory(clone_url)
-      root = global_cache_root
-      root ? File.join(root, "git", cache_key(clone_url)) : nil
-    end
-
-    def global_git_cache_ready?(global_cache)
-      File.directory?(File.join(global_cache, ".git")) || File.file?(File.join(global_cache, "HEAD"))
-    end
-
-    def seed_git_cache_from_global(clone_url, destination, working_directory)
-      global_cache = global_git_cache_directory(clone_url)
-      return false unless global_cache && global_git_cache_ready?(global_cache)
-
-      run_git(working_directory, "clone", "--depth", "1", "--quiet", global_cache, destination)
-      true
-    end
-
-    def mirror_git_cache_to_global(clone_url, project_cache)
-      global_cache = global_git_cache_directory(clone_url)
-      return unless global_cache
-      return if global_git_cache_ready?(global_cache)
-
-      FileUtils.mkdir_p(File.dirname(global_cache))
-      FileUtils.rm_rf(global_cache) if File.exist?(global_cache)
-      run_git(File.dirname(project_cache), "clone", "--bare", "--quiet", File.basename(project_cache), global_cache)
-    end
-
-    def apply_sparse_checkout(repository, subdir)
-      run_git_in_repo(repository, "sparse-checkout", "init", "--cone")
-      run_git_in_repo(repository, "sparse-checkout", "set", subdir)
-    end
-
-    def checkout_git_revision(repository, _clone_url, revision, refresh)
-      run_git_in_repo(repository, "fetch", "--depth", "1", "origin", revision) if refresh
-      run_git_in_repo(repository, "checkout", "--force", revision)
-    end
-
-    def refresh_git_worktree(repository, _clone_url)
-      run_git_in_repo(repository, "fetch", "--depth", "1", "origin")
-      run_git_in_repo(repository, "reset", "--hard", "origin/HEAD")
-    end
-
-    def refresh_global_git_cache(clone_url)
-      global_cache = global_git_cache_directory(clone_url)
-      return unless global_cache && global_git_cache_ready?(global_cache)
-
-      run_git_in_repo(global_cache, "fetch", "--depth", "1", "origin")
-    end
-
-    def git_head_revision(repository)
-      output, status = Open3.capture2e("git", "-C", repository, "rev-parse", "HEAD")
-      raise Error.resolution(command_error("git rev-parse HEAD", output)) unless status.success?
-
-      revision = output.strip
-      raise Error.resolution("git repository has no HEAD revision") if revision.empty?
-
-      revision
-    end
-
-    def run_git(cwd, *arguments)
-      output, status = Open3.capture2e("git", "-C", cwd, *arguments)
-      return if status.success?
-
-      raise Error.resolution(command_error("git #{arguments.join(" ")}", output))
-    end
-
-    def run_git_in_repo(repository, *arguments)
-      run_git(repository, *arguments)
-    end
-
-    def command_error(program, output)
-      message = output.strip
-      message.empty? ? "#{program} failed" : "#{program} failed: #{message}"
-    end
   end
 end

data/lib/pray/local_prayer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pray
+  DEFAULT_LOCAL_PRAYER_NAME = "project"
+  DEFAULT_PATH_SOURCE_NAME = "local"
+  DEFAULT_PATH_SOURCE_DIRECTORY = "prayers"
+
+  module LocalPrayer
+    module_function
+
+    def validate_name!(name)
+      trimmed = name.to_s.strip
+      raise Error.usage("prayer name is missing") if trimmed.empty?
+      if trimmed.include?("/") || trimmed.include?("\\") || trimmed == "." || trimmed == ".."
+        raise Error.usage("prayer name must be a single folder name")
+      end
+      if reserved_distribution_layout_name?(trimmed)
+        raise Error.usage("#{trimmed} is reserved for the distribution layout")
+      end
+
+      trimmed
+    end
+
+    def path_source_package_directory(source_name, package_name)
+      prefix = "#{source_name}/"
+      rest = package_name.delete_prefix(prefix)
+      if rest != package_name && !rest.empty? && !rest.include?("/") && !rest.include?("\\")
+        return rest
+      end
+
+      package_name.to_s.tr("/", "-").tr("\\", "-")
+    end
+
+    def reserved_distribution_layout_name?(name)
+      name.match?(/\Av[0-9]+\z/)
+    end
+  end
+end

data/lib/pray/lockfile.rb

@@ -5,6 +5,8 @@ require "perfect_toml"
 require_relative "lockfile_serialize"
 
 module Pray
+  LOCAL_EMBED_PACKAGE = "local"
+
   LockSource = Struct.new(:name, :kind, :url, :revision, :host_key_fingerprint)
   LockedPackage = Struct.new(
     :name, :version, :source, :path, :tree_hash, :artifact_hash, :artifact,
@@ -20,7 +22,11 @@ module Pray
   ManagedSpanRecord = Struct.new(
     :id, :target, :open_line, :close_line, :ideal_checksum, :package, :export,
     :source_checksum, :silenced
-  )
+  ) do
+    def local_embed?
+      package == LOCAL_EMBED_PACKAGE
+    end
+  end
   ProvisionedFileRecord = Struct.new(:path, :content_hash, :package, :export)
 
   Lockfile = Struct.new(
@@ -179,7 +185,7 @@ module Pray
         package: packages.map do |package|
           LockedPackage.new(
             name: package.declaration.name,
-            version: package.spec.version,
+            version: package.spec.recorded_version,
             source: package.declaration.source,
             path: relative_lockfile_path(project_root, package.root),
             tree_hash: package.tree_hash,

data/lib/pray/manifest.rb

@@ -46,8 +46,8 @@ module Pray
     end
   end
 
-  ManifestLocal = Struct.new(:path, :position, :optional, :bound) do
-    def initialize(path:, position: "after", optional: false, bound: false)
+  ManifestLocal = Struct.new(:path, :position, :optional, :bound, :file) do
+    def initialize(path:, position: "after", optional: false, bound: false, file: nil)
       super
     end
   end
@@ -135,7 +135,10 @@ module Pray
         PathSafety.validate_project_relative_path!(package.path) if package.path
         PathSafety.validate_destination_path!(package.file) if package.file
       end
-      manifest.local.each { |local| PathSafety.validate_project_relative_path!(local.path) }
+      manifest.local.each do |local|
+        PathSafety.validate_project_relative_path!(local.path)
+        PathSafety.validate_destination_path!(local.file) if local.file
+      end
     end
   end
 

data/lib/pray/manifest_json.rb

@@ -87,6 +87,7 @@ module Pray
         "optional" => entry.optional
       }
       fields["bound"] = true if entry.bound
+      fields["file"] = entry.file if entry.file
       fields
     end
 

data/lib/pray/manifest_parser_blocks.rb

@@ -116,7 +116,7 @@ module Pray
         while (statement = next_statement)
           if statement == "end"
             unless saw_package
-              raise Error.parse("manifest", "file block requires a pray package declaration")
+              raise Error.parse("manifest", "file block requires a pray package")
             end
             return
           end
@@ -132,7 +132,15 @@ module Pray
           return true
         end
         if (match = statement.match(/\A(?:pray|use|include|package) (.+)\z/))
-          bind_file_package(manifest, match[1], file_path)
+          rest = match[1]
+          values, keywords = parse_call(rest)
+          if values.length == 1 && keywords.empty?
+            first = string_from_value(values.first)
+            if Destination.local_path_form?(first)
+              raise Error.parse("manifest", "file: requires a package")
+            end
+          end
+          bind_file_package(manifest, rest, file_path)
           return true
         end
         raise Error.parse("manifest", "unsupported statement inside file block: #{statement}")
@@ -161,19 +169,11 @@ module Pray
       end
 
       def apply_local_pray_path(manifest, first, keywords, values, destination_index)
-        return false if package_signal?(values, keywords)
-        return false unless Destination.local_path_form?(first)
-
-        in_compose = destination_index &&
-          manifest.targets[destination_index]&.mode == "compose"
-        unless in_compose
-          raise Error.parse("manifest", "local pray paths are only valid inside compose blocks")
-        end
-
-        local = ManifestLocal.new(path: first, position: "after", optional: false, bound: true)
-        Destination.bind_local_entry(manifest.targets[destination_index], local.path)
-        Destination.upsert_local(manifest, local)
-        true
+        file_dest = keywords["file"]&.as_string
+        other_package_signal = values.length > 1 ||
+          %w[source export exports optional path git tag rev tarball oci targets features]
+            .any? { |key| keywords.key?(key) }
+        Destination.try_apply_local_pray(manifest, first, file_dest, other_package_signal, destination_index)
       end
 
       def package_signal?(values, keywords)

data/lib/pray/materialize.rb

@@ -54,9 +54,15 @@ module Pray
           raise
         end
       end
+      previous_lockfile = project.previous_lockfile
+      unless locked || frozen
+        if Upstream.apply_path_upstream_refreshes(project, previous_lockfile, nil, options)
+          project = Resolve.resolve_project_in_context(manifest_path, project_root, options)
+          previous_lockfile = project.previous_lockfile
+        end
+      end
       rendered = Render.render_project(project)
       lockfile_path = default_lockfile_path(project.project_root)
-      previous_lockfile = project.previous_lockfile
       next_lockfile = LockfileIO.build_lockfile(
         project.manifest_hash,
         project.environment,

data/lib/pray/package_spec.rb

@@ -12,12 +12,12 @@ module Pray
   PackageUpstream = Struct.new(:name, :constraint, keyword_init: true)
 
   PackageSpec = Struct.new(
-    :name, :version, :summary, :description, :authors, :license, :homepage,
+    :name, :version, :summary, :description, :authors, :maintainers, :license, :homepage,
     :source_code_uri, :changelog_uri, :prayfile_version, :files, :exports,
     :skills, :templates, :adapters, :targets, :dependencies, :metadata, :upstream
   ) do
     def initialize(
-      name: "", version: "", summary: nil, description: nil, authors: [], license: nil,
+      name: "", version: "", summary: nil, description: nil, authors: [], maintainers: [], license: nil,
       homepage: nil, source_code_uri: nil, changelog_uri: nil, prayfile_version: nil,
       files: [], exports: {}, skills: {}, templates: {}, adapters: {}, targets: [],
       dependencies: [], metadata: {}, upstream: nil
@@ -47,8 +47,9 @@ module Pray
     def canonicalized
       dup.tap do |copy|
         copy.files = files.sort
-        copy.authors = authors.sort
-        copy.targets = targets.sort
+        copy.authors = Array(authors).sort
+        copy.maintainers = Array(maintainers).sort
+        copy.targets = Array(targets).sort
         copy.dependencies = dependencies.sort_by { |dependency| [dependency.name, dependency.constraint, dependency.optional] }
       end
     end
@@ -227,18 +228,29 @@ module Pray
         end
       end
 
+      STRING_ASSIGNMENTS = {
+        "name" => :name=,
+        "version" => :version=,
+        "summary" => :summary=,
+        "description" => :description=,
+        "license" => :license=,
+        "homepage" => :homepage=,
+        "source_code_uri" => :source_code_uri=,
+        "changelog_uri" => :changelog_uri=,
+        "prayfile_version" => :prayfile_version=,
+        "pray_version" => :prayfile_version=
+      }.freeze
+
       def apply_assignment(spec, field, value)
+        setter = STRING_ASSIGNMENTS[field]
+        if setter
+          spec.public_send(setter, string_from_literal(value))
+          return
+        end
+
         case field
-        when "name" then spec.name = string_from_literal(value)
-        when "version" then spec.version = string_from_literal(value)
-        when "summary" then spec.summary = string_from_literal(value)
-        when "description" then spec.description = string_from_literal(value)
         when "authors" then spec.authors = array_of_strings(value)
-        when "license" then spec.license = string_from_literal(value)
-        when "homepage" then spec.homepage = string_from_literal(value)
-        when "source_code_uri" then spec.source_code_uri = string_from_literal(value)
-        when "changelog_uri" then spec.changelog_uri = string_from_literal(value)
-        when "prayfile_version" then spec.prayfile_version = string_from_literal(value)
+        when "maintainers" then spec.maintainers = array_of_strings(value)
         when "files" then spec.files = array_of_strings(value)
         when "targets" then spec.targets = array_of_strings(value)
         when "exports" then spec.exports = parse_exports(value)

data/lib/pray/package_spec_render.rb

@@ -4,9 +4,9 @@ module Pray
   module PackageSpecRender
     module_function
 
-    def fork_spec_after_refresh(local, new_upstream, local_prayspec_file, clean_replica, merged_content_paths)
+    def fork_spec_after_refresh(local, new_upstream, clean_replica, merged_content_paths)
       spec = local.dup
-      spec.files = [local_prayspec_file, *merged_content_paths]
+      spec.files = merged_content_paths.dup
       if clean_replica
         spec.exports = new_upstream.exports.dup
         spec.templates = new_upstream.templates.dup
@@ -32,10 +32,11 @@ module Pray
 
     def push_identity_fields(lines, spec)
       push_assignment(lines, "name", spec.name)
-      push_assignment(lines, "version", spec.version)
+      push_assignment(lines, "version", spec.version) unless spec.version.to_s.empty?
       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_array(lines, "maintainers", spec.maintainers) unless spec.maintainers.nil? || spec.maintainers.empty?
       push_optional(lines, "license", spec.license)
       push_optional(lines, "homepage", spec.homepage)
       push_optional(lines, "source_code_uri", spec.source_code_uri)

data/lib/pray/package_spec_version.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pray
+  class PackageSpec
+    LOCAL_VERSION = "local"
+
+    def has_release_version?
+      !version.to_s.empty? && version != LOCAL_VERSION
+    end
+
+    def recorded_version
+      has_release_version? ? version : LOCAL_VERSION
+    end
+
+    def require_release_version!
+      return if has_release_version?
+
+      raise Error.manifest("package #{name} needs a version before it can be packaged")
+    end
+
+    def satisfy_constraint!(constraint)
+      unless has_release_version?
+        normalized = Constraint.normalize_version_constraint(constraint)
+        return if normalized.empty? || normalized == "*"
+
+        raise Error.resolution("package #{name} has no version; add spec.version or omit the constraint")
+      end
+      return if Constraint.version_satisfies(version, constraint)
+
+      raise Error.resolution("package #{name} version #{version} does not satisfy constraint #{constraint}")
+    end
+  end
+end

data/lib/pray/plan.rb

@@ -13,7 +13,8 @@ module Pray
     def build_materialization_preview(project, rendered, lockfile, _lockfile_path, previous_lockfile)
       destinations = RenderDest.validate_destinations!(project, previous_lockfile)
       MaterializationPreview.new(
-        package_lines: package_summary_lines(previous_lockfile, lockfile, project),
+        package_lines: ApplyReport.local_summary_lines(previous_lockfile, project) +
+          package_summary_lines(previous_lockfile, lockfile, project),
         lockfile: lockfile_change_status(previous_lockfile, lockfile),
         targets: rendered.map { |target| target_change(project, target) },
         provisioned: destinations.map { |file, status| [file.path, status.to_s] },

data/lib/pray/publish.rb

@@ -17,14 +17,16 @@ module Pray
     def publish_to_root(project, root, signer: "local", signer_fingerprint: nil)
       root = File.expand_path(root)
       index = load_registry_index(root)
+      distribution = Distribution.read_settings(root)
       package_names = index.packages.to_set
 
       project.packages.each do |package|
+        package.spec.require_release_version!
         artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
         metadata_path = registry_metadata_path(root, package.declaration.name)
         metadata = load_registry_package_metadata(metadata_path, package.declaration.name)
         existing = metadata.versions.find { |entry| entry.version == package.spec.version }
-        stored_artifact = stored_package_artifact(root, artifact_path, package, existing)
+        stored_artifact = stored_package_artifact(root, artifact_path, package, existing, distribution)
         if stored_artifact && stored_publish_matches?(
           stored_artifact, package, signer, signer_fingerprint, existing
         )
@@ -35,6 +37,14 @@ module Pray
 
         archive_bytes = Archive.build_package_archive_bytes(package)
         write_output_bytes(File.join(root, artifact_path), archive_bytes)
+        TorrentManifest.write(
+          root,
+          name: package.declaration.name,
+          version: package.spec.version,
+          artifact_path: artifact_path,
+          archive_bytes: archive_bytes,
+          settings: distribution
+        )
         version_entry = published_registry_package_version(
           package,
           signer,
@@ -54,10 +64,24 @@ module Pray
     end
 
     def publish_to_server(project, server_url, signer: "local", signer_fingerprint: nil)
+      distribution = Distribution.fetch_settings(server_url)
       project.packages.each do |package|
         archive_bytes = Archive.build_package_archive_bytes(package)
         artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
         Registry.http_put(join_url(server_url, artifact_path), "application/octet-stream", archive_bytes)
+        if distribution.allows_torrent?
+          Registry.http_put(
+            join_url(server_url, TorrentManifest.path_for(artifact_path)),
+            "application/json",
+            TorrentManifest.bytes(
+              name: package.declaration.name,
+              version: package.spec.version,
+              artifact_path: artifact_path,
+              archive_bytes: archive_bytes,
+              trackers: distribution.bootstrap_trackers
+            )
+          )
+        end
 
         metadata = RegistryPackageMetadata.new(
           name: package.declaration.name,
@@ -95,7 +119,7 @@ module Pray
       )
     end
 
-    def stored_package_artifact(root, artifact_path, package, existing)
+    def stored_package_artifact(root, artifact_path, package, existing, distribution)
       return unless existing&.artifact == artifact_path && existing.tree_hash == package.tree_hash
 
       stored_path = File.join(root, artifact_path)
@@ -104,6 +128,7 @@ module Pray
       artifact_bytes = File.binread(stored_path)
       return unless existing.artifact_hash == Hashing.sha256_prefixed(artifact_bytes)
       return unless stored_prayspec_matches?(artifact_bytes, package.root)
+      return unless TorrentManifest.descriptor_present?(root, artifact_path, distribution)
 
       artifact_bytes
     end

data/lib/pray/registry.rb

@@ -9,6 +9,8 @@ require "time"
 require_relative "path_safety"
 require_relative "http_body"
 require_relative "registry_paths"
+require_relative "registry_http_cache"
+require_relative "git_materialize"
 
 module Pray
   RegistryPackageVersion = Struct.new(
@@ -134,9 +136,7 @@ module Pray
         return parse_metadata(File.read(metadata_path, encoding: "UTF-8"))
       end
 
-      PathSafety.reject_unsafe_package_name!(package_name)
-      response = http_get(join_url(source_url, "v1/packages/#{package_name}.json"))
-      parse_metadata(response)
+      RegistryHttpCache.fetch_package_metadata(source_url, package_name)
     end
 
     def parse_metadata(text)
@@ -207,18 +207,7 @@ module Pray
     end
 
     def read_local_artifact_bytes(source_root, artifact)
-      if artifact.start_with?("file://")
-        path = PathSafety.join_under_root(source_root, artifact.delete_prefix("file://"))
-        raise Error.resolution("package artifact path escapes distribution root") unless path
-        return File.binread(path)
-      end
-      reject_absolute_artifact!(artifact)
-
-      path = PathSafety.join_under_root(source_root, artifact)
-      raise Error.resolution("package artifact path escapes distribution root") unless path
-      raise Error.resolution("package artifact missing at #{path}") unless File.exist?(path)
-
-      File.binread(path)
+      GitMaterialize.read_local_artifact_bytes(source_root, artifact)
     end
 
     def read_artifact_bytes(source_url, artifact)