pray-cli 1.19.0 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6df9a00a7c009e00fdd00987564489607a77bf48cb6472e06951c7709a91a32f
-  data.tar.gz: 93ad851e71a69c13764f2a289d3f32dd7856a749aa341ef728b4c49ebc651149
+  metadata.gz: 4eb951f0ca0abc5ac0aa68ab27e63e4f778c92453fddb9a7cca0115dac1526d9
+  data.tar.gz: 28ba1073042c0c2a77138e35a9ae80688cb1a6075dd16cba5ee1b9aef2c9c3af
 SHA512:
-  metadata.gz: 56060ecc2267d2f8a2c1b555591b3db551383d8350a9b3125a0647831ee2438dfb3f78b6424e2af98bbfc184ef8a91c181e1da5bf35835a160f34bcde865c1b0
-  data.tar.gz: 55b5590131213f639bc63be84817d65c17297354a1387b363c94d8953192ca03f80c9245b47d5cc1d7d99cd51569c2a9647147fb0de124966dfb294e125bf68b
+  metadata.gz: 260a99edc903d99d235b2d9dd40904490fbcc392d67a07a4323d43b1359fead4428976745e438e17767948a1494262daa97b87650965ffc22366267c8faf5226
+  data.tar.gz: f031ff7ebaeceee86829abac7e2f99f060be902ebc586c00e5ad67135d25958248ac7c4fd5425a12068b67d1a01ebd747cacf53501f2c81cc68f3bdcbcfd838d

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # CHANGELOG
 
+## 1.20.0 (2026-09-18)
+
+- Fetch a locked git catalog revision during `pray install` when the local cache does not have that commit yet. `pray install --offline` still refuses a missing commit.
+- Refuse `pray install --offline` when a git catalog is not already in the local cache, instead of cloning it. A global cache seed still works.
+- Honour a locked git revision for a local file catalog. Install does not read the origin worktree after that checkout fails.
+- Keep git catalog objects in the shared cache. The project catalog is a file tree without a git directory.
+- When a locked git revision is missing from a shallow cache, fetch the missing history instead of only that one commit.
+- Keep an unchanged published version when a later `pray publish` uses a different publisher label.
+- Keep `pray drift` clean after `pray install` when a compose block adds a local file after a package dest already had.
+
 ## 1.19.0 (2026-09-18)
 
 - Declare named `publish` remotes in Prayfile (RFC 0118). `pray publish` uses them when dest flags are omitted, and publishes only path-owned packages.

data/lib/pray/git_cache.rb

@@ -1,33 +1,26 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "pathname"
 require_relative "error"
 require_relative "hashing"
 require_relative "git_run"
-require_relative "git_clone"
+require_relative "git_store"
+require_relative "git_materialize"
 
 module Pray
   module GitCache
     module_function
 
-    def ensure_git_repository(project_root, clone_url, refresh:, pinned_revision:, sparse_subdir:)
-      shared = git_source_cache_directory(project_root, clone_url)
-      ensure_shared_git_repository(project_root, clone_url, shared, refresh: refresh, pinned_revision: pinned_revision)
-      checkout = git_source_cache_directory(project_root, clone_url, sparse_subdir)
-      if checkout != shared
-        ensure_linked_worktree(shared, checkout)
-        GitClone.apply_sparse_checkout(checkout, sparse_subdir)
-        if pinned_revision
-          checkout_git_revision(checkout, clone_url, pinned_revision, refresh)
-        elsif refresh
-          GitRun.run_git(checkout, "reset", "--hard", git_head_revision(shared))
-        end
-        return [checkout, git_head_revision(checkout)]
-      end
-
-      GitClone.apply_sparse_checkout(shared)
-      [shared, git_head_revision(shared)]
+    def ensure_git_repository(project_root, clone_url, refresh:, pinned_revision:, sparse_subdir:, offline: false)
+      db, revision = GitStore.ensure_global_git_db(
+        clone_url,
+        pinned_revision: pinned_revision,
+        refresh: refresh,
+        offline: offline,
+        working_directory: project_root
+      )
+      catalog = git_source_cache_directory(project_root, clone_url, sparse_subdir)
+      GitMaterialize.materialize_catalog_tree(db, catalog, revision, sparse_subdir, refresh)
+      [catalog, revision]
     end
 
     def git_source_cache_directory(project_root, clone_url, subdir = nil)
@@ -36,6 +29,9 @@ module Pray
     end
 
     def git_source_cached_repository(project_root, clone_url)
+      global_cache = GitStore.global_git_cache_directory(clone_url)
+      return global_cache if global_cache && GitStore.global_git_cache_ready?(global_cache)
+
       shared = git_source_cache_directory(project_root, clone_url)
       return shared if git_checkout?(shared)
 
@@ -57,60 +53,6 @@ module Pray
       Hashing.sha256_prefixed(text)[7, 16]
     end
 
-    def ensure_shared_git_repository(project_root, clone_url, shared, refresh:, pinned_revision:)
-      if File.directory?(File.join(shared, ".git"))
-        if pinned_revision
-          checkout_git_revision(shared, clone_url, pinned_revision, refresh)
-        elsif refresh
-          refresh_git_worktree(shared, clone_url)
-        end
-        refresh_global_from_project(clone_url, shared) if refresh
-        return
-      end
-
-      FileUtils.rm_rf(shared) if File.exist?(shared)
-      FileUtils.mkdir_p(File.dirname(shared))
-      seeded = seed_git_cache_from_global(clone_url, shared, project_root)
-      if seeded
-        GitRun.run_git(shared, "remote", "set-url", "origin", clone_url)
-      else
-        GitClone.clone_git_cache(project_root, clone_url, shared, quiet: false)
-        mirror_git_cache_to_global(clone_url, shared)
-      end
-      GitClone.apply_sparse_checkout(shared)
-      if pinned_revision
-        checkout_git_revision(shared, clone_url, pinned_revision, true)
-      elsif refresh && seeded
-        refresh_git_worktree(shared, clone_url)
-      end
-      refresh_global_from_project(clone_url, shared) if refresh && seeded
-    end
-
-    def ensure_linked_worktree(shared, checkout)
-      return if same_object_store?(shared, checkout)
-
-      FileUtils.rm_rf(checkout) if File.exist?(checkout)
-      FileUtils.mkdir_p(File.dirname(checkout))
-      return if GitRun.try_run_git(shared, "worktree", "add", "--detach", "--no-checkout", checkout)
-
-      GitRun.run_git(shared, "worktree", "add", "--detach", checkout)
-    end
-
-    def same_object_store?(shared, checkout)
-      return false unless git_checkout?(checkout)
-
-      git_common_dir(shared) == git_common_dir(checkout)
-    end
-
-    def git_common_dir(repository)
-      output, status = GitRun.capture_git(repository, "rev-parse", "--git-common-dir")
-      raise Error.resolution(GitRun.command_error("git rev-parse --git-common-dir", output)) unless status.success?
-
-      reported = output.strip
-      path = Pathname.new(reported).absolute? ? reported : File.expand_path(reported, repository)
-      File.realpath(path)
-    end
-
     def origin_matches?(repository, clone_url)
       output, status = GitRun.capture_git(repository, "remote", "get-url", "origin")
       return false unless status.success?
@@ -118,75 +60,5 @@ module Pray
       origin = output.strip.delete_prefix("git+")
       origin == clone_url
     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)
-
-      GitClone.clone_git_cache(working_directory, global_cache, destination, quiet: true)
-      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)
-      GitRun.run_git(File.dirname(project_cache), "clone", "--bare", "--quiet", File.basename(project_cache), global_cache)
-    end
-
-    def fetch_origin(repository, revision = nil)
-      extra = revision ? [revision] : []
-      return if GitRun.try_run_git(repository, "fetch", "--depth", "1", "--filter=blob:none", "origin", *extra)
-
-      GitRun.run_git(repository, "fetch", "--depth", "1", "origin", *extra)
-    end
-
-    def checkout_git_revision(repository, _clone_url, revision, refresh)
-      fetch_origin(repository, revision) if refresh
-      GitRun.run_git(repository, "checkout", "--force", revision)
-    end
-
-    def refresh_git_worktree(repository, _clone_url)
-      fetch_origin(repository)
-      GitRun.run_git(repository, "reset", "--hard", "origin/HEAD")
-    end
-
-    def refresh_global_from_project(clone_url, project_cache)
-      global_cache = global_git_cache_directory(clone_url)
-      return unless global_cache
-
-      FileUtils.rm_rf(global_cache) if global_git_cache_ready?(global_cache) || File.exist?(global_cache)
-      mirror_git_cache_to_global(clone_url, project_cache)
-    end
-
-    def git_head_revision(repository)
-      output, status = GitRun.capture_git(repository, "rev-parse", "HEAD")
-      raise Error.resolution(GitRun.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
   end
 end

data/lib/pray/git_clone.rb

@@ -6,21 +6,17 @@ module Pray
   module GitClone
     module_function
 
-    def clone_git_cache(working_directory, source, destination, quiet:)
-      filtered = ["clone", "--depth", "1", "--filter=blob:none", "--sparse", source, destination]
+    def clone_bare_git_db(working_directory, source, destination, quiet:)
+      local = source.start_with?("file://", "/") ? ["--no-local"] : []
+      filtered = ["clone", "--bare", "--depth", "1", "--filter=blob:none", *local, source, destination]
       filtered.insert(1, "--quiet") if quiet
       return if GitRun.try_run_git(working_directory, *filtered)
 
-      full = ["clone", "--depth", "1", source, destination]
+      full = ["clone", "--bare", "--depth", "1", *local, source, destination]
       full.insert(1, "--quiet") if quiet
       GitRun.run_git(working_directory, *full)
     end
 
-    def apply_sparse_checkout(repository, subdir = nil)
-      GitRun.run_git(repository, "sparse-checkout", "init", "--cone")
-      GitRun.run_git(repository, "sparse-checkout", "set", *catalog_sparse_cones(subdir))
-    end
-
     def catalog_sparse_cones(subdir)
       if subdir && !subdir.empty?
         ["#{subdir}/v1/packages"]

data/lib/pray/git_materialize.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
-require_relative "git_run"
+require "fileutils"
+require "open3"
 require_relative "error"
+require_relative "git_clone"
+require_relative "git_run"
 require_relative "path_safety"
 
 module Pray
   module GitMaterialize
+    REVISION_MARKER = ".pray-revision"
+    GIT_DIR_MARKER = ".pray-git-dir"
+
     module_function
 
     def read_local_artifact_bytes(source_root, artifact)
@@ -28,49 +34,95 @@ module Pray
       File.binread(path)
     end
 
-    def materialize_catalog_file(source_root, relative)
-      return if File.file?(File.join(source_root, relative))
-      return unless sparse_checkout_enabled?(source_root)
-
-      toplevel = git_toplevel(source_root)
-      return unless toplevel
-
-      repo_relative = repo_relative_text(source_root, relative)
-      return unless repo_relative
+    def materialize_catalog_tree(git_dir, dest, revision, subdir, refresh)
+      return if !refresh && catalog_matches?(dest, git_dir, revision)
 
-      cone = artifact_sparse_cone(repo_relative)
-      GitRun.run_git(toplevel, "sparse-checkout", "add", cone) if cone
-      GitRun.run_git(toplevel, "checkout", "HEAD", "--", repo_relative)
-    end
+      FileUtils.rm_rf(dest) if File.exist?(dest)
+      FileUtils.mkdir_p(dest)
+      unpacked = GitClone.catalog_sparse_cones(subdir).any? do |prefix|
+        unpack_archive_prefix(git_dir, dest, revision, prefix)
+      end
+      raise Error.resolution("no pray distribution root in git source at revision #{revision}") unless unpacked
 
-    def sparse_checkout_enabled?(source_root)
-      output, status = GitRun.capture_git(source_root, "config", "--get", "core.sparseCheckout")
-      status.success? && output.strip == "true"
+      File.write(File.join(dest, REVISION_MARKER), revision)
+      File.write(File.join(dest, GIT_DIR_MARKER), git_dir)
     end
 
-    def git_toplevel(source_root)
-      output, status = GitRun.capture_git(source_root, "rev-parse", "--show-toplevel")
-      return unless status.success?
+    def materialize_catalog_file(source_root, relative)
+      return if File.file?(File.join(source_root, relative))
 
-      text = output.strip
-      text.empty? ? nil : text
+      markers = find_catalog_markers(source_root)
+      return unless markers
+
+      full_path = File.join(source_root, relative)
+      repo_relative = full_path.delete_prefix(markers.fetch(:work_tree)).delete_prefix("/")
+      GitRun.run_git(
+        markers.fetch(:git_dir),
+        "--work-tree",
+        markers.fetch(:work_tree),
+        "checkout",
+        markers.fetch(:revision),
+        "--",
+        repo_relative
+      )
     end
 
-    def repo_relative_text(source_root, relative)
-      output, status = GitRun.capture_git(source_root, "rev-parse", "--show-prefix")
-      return unless status.success?
-
-      prefix = output.strip
-      prefix.empty? ? relative : File.join(prefix, relative)
+    def catalog_matches?(dest, git_dir, revision)
+      revision_path = File.join(dest, REVISION_MARKER)
+      git_dir_path = File.join(dest, GIT_DIR_MARKER)
+      return false unless File.file?(revision_path) && File.file?(git_dir_path)
+      return false unless File.read(revision_path).strip == revision
+      return false unless File.read(git_dir_path).strip == git_dir
+
+      File.directory?(File.join(dest, "v1", "packages")) ||
+        File.directory?(File.join(dest, "prayers", "v1", "packages")) ||
+        Dir.children(dest).any? { |name| File.directory?(File.join(dest, name, "v1", "packages")) }
+    rescue Errno::ENOENT
+      false
     end
 
-    def artifact_sparse_cone(repo_relative)
-      parts = repo_relative.split("/").reject(&:empty?)
-      return repo_relative if parts.length < 2
+    def unpack_archive_prefix(git_dir, dest, revision, prefix)
+      env = ENV.to_h.merge("GIT_TERMINAL_PROMPT" => "0")
+      stdout, _stderr, status = Open3.capture3(
+        env,
+        "git",
+        "-c",
+        "protocol.file.allow=always",
+        "-C",
+        git_dir,
+        "archive",
+        "--format=tar",
+        revision,
+        "--",
+        prefix,
+        stdin_data: ""
+      )
+      return false unless status.success? && !stdout.empty?
+
+      _ignored, extract_status = Open3.capture2(env, "tar", "-x", "-C", dest, stdin_data: stdout)
+      raise Error.resolution("failed to unpack git catalog archive") unless extract_status.success?
+
+      true
+    end
 
-      parts.pop
-      parts.pop if parts.last != "artifacts" && parts.length > 3
-      parts.join("/")
+    def find_catalog_markers(start)
+      current = start
+      8.times do
+        revision_path = File.join(current, REVISION_MARKER)
+        git_dir_path = File.join(current, GIT_DIR_MARKER)
+        if File.file?(revision_path) && File.file?(git_dir_path)
+          revision = File.read(revision_path).strip
+          git_dir = File.read(git_dir_path).strip
+          return if revision.empty? || !File.exist?(git_dir)
+
+          return {git_dir: git_dir, revision: revision, work_tree: current}
+        end
+        parent = File.dirname(current)
+        return if parent == current
+
+        current = parent
+      end
+      nil
     end
   end
 end

data/lib/pray/git_sources.rb

@@ -7,10 +7,11 @@ module Pray
   GitSourceCheckout = Struct.new(:cache_directory, :revision, :subdir)
 
   class GitSourceSet
-    def initialize(project_root, sources, lockfile, refresh:)
+    def initialize(project_root, sources, lockfile, refresh:, offline: false)
       @project_root = project_root
       @lockfile = lockfile
       @refresh = refresh
+      @offline = offline
       @sources = sources.select { |source| source.kind == "git" }.to_h { |source| [source.name, source] }
       @checkouts = {}
     end
@@ -21,7 +22,7 @@ module Pray
       source = @sources[name]
       return nil unless source
 
-      checkout = GitSources.prepare_one_git_source(@project_root, source, @lockfile, refresh: @refresh)
+      checkout = GitSources.prepare_one_git_source(@project_root, source, @lockfile, refresh: @refresh, offline: @offline)
       @checkouts[name] = checkout if checkout
       checkout
     end
@@ -38,21 +39,21 @@ module Pray
   module GitSources
     module_function
 
-    def prepare_git_sources(project_root, sources, lockfile, refresh: false)
-      GitSourceSet.new(project_root, sources, lockfile, refresh: refresh)
+    def prepare_git_sources(project_root, sources, lockfile, refresh: false, offline: false)
+      GitSourceSet.new(project_root, sources, lockfile, refresh: refresh, offline: offline)
     end
 
-    def prepare_one_git_source(project_root, source, lockfile, refresh:)
+    def prepare_one_git_source(project_root, source, lockfile, refresh:, offline: false)
       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
-        )
+        if source_root
+          return GitSourceCheckout.new(
+            cache_directory: source_root,
+            revision: "",
+            subdir: source.subdir
+          )
+        end
       end
 
       pinned_revision = refresh ? nil : pinned_revision_for_source(lockfile, source)
@@ -61,7 +62,8 @@ module Pray
         clone_url,
         refresh: refresh,
         pinned_revision: pinned_revision,
-        sparse_subdir: source.subdir
+        sparse_subdir: source.subdir,
+        offline: offline
       )
       GitSourceCheckout.new(
         cache_directory: cache_directory,

data/lib/pray/git_store.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "error"
+require_relative "hashing"
+require_relative "git_run"
+require_relative "git_clone"
+
+module Pray
+  module GitStore
+    module_function
+
+    def ensure_global_git_db(clone_url, pinned_revision:, refresh:, offline:, working_directory:)
+      db = global_git_cache_directory(clone_url)
+      raise Error.resolution("git object cache is not configured") unless db
+
+      unless global_git_cache_ready?(db)
+        raise Error.resolution(offline_git_source_uncached(clone_url)) if offline
+
+        FileUtils.rm_rf(db) if File.exist?(db)
+        FileUtils.mkdir_p(File.dirname(db))
+        GitClone.clone_bare_git_db(working_directory, clone_url, db, quiet: false)
+        ensure_git_remote_origin(db, clone_url)
+      end
+      fetch_origin_tip(db, clone_url) if refresh && !offline
+      if pinned_revision
+        ensure_revision_in_db(db, clone_url, pinned_revision, !offline)
+        return [db, pinned_revision]
+      end
+
+      [db, git_head_revision(db)]
+    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", Hashing.sha256_prefixed(clone_url)[7, 16]) : nil
+    end
+
+    def global_git_cache_ready?(global_cache)
+      File.file?(File.join(global_cache, "HEAD")) || File.directory?(File.join(global_cache, ".git"))
+    end
+
+    def offline_git_source_uncached(clone_url)
+      "git source #{clone_url} is not cached locally and offline mode is enabled"
+    end
+
+    def ensure_revision_in_db(db, clone_url, revision, allow_fetch)
+      return if GitRun.try_run_git(db, "cat-file", "-e", revision)
+      unless allow_fetch
+        raise Error.resolution(
+          "git source #{db.inspect} is locked to revision #{revision}, but that commit is not available locally and offline mode is enabled"
+        )
+      end
+
+      ensure_git_remote_origin(db, clone_url)
+      fetch_unshallow(db) if File.file?(File.join(db, "shallow"))
+      return if GitRun.try_run_git(db, "cat-file", "-e", revision)
+
+      fetch_revision(db, revision)
+      return if GitRun.try_run_git(db, "cat-file", "-e", revision)
+
+      raise Error.resolution(
+        "git source #{db.inspect} is locked to revision #{revision}, but that commit could not be fetched"
+      )
+    end
+
+    def ensure_git_remote_origin(repository, clone_url)
+      if GitRun.try_run_git(repository, "remote", "get-url", "origin")
+        GitRun.run_git(repository, "remote", "set-url", "origin", clone_url)
+      else
+        GitRun.run_git(repository, "remote", "add", "origin", clone_url)
+      end
+    end
+
+    def fetch_origin_tip(db, clone_url)
+      ensure_git_remote_origin(db, clone_url)
+      unless GitRun.try_run_git(db, "fetch", "--depth", "1", "--filter=blob:none", "origin")
+        GitRun.run_git(db, "fetch", "--depth", "1", "origin")
+      end
+      GitRun.run_git(db, "update-ref", "HEAD", "FETCH_HEAD")
+    end
+
+    def fetch_unshallow(db)
+      return if GitRun.try_run_git(db, "fetch", "--unshallow", "--filter=blob:none", "origin")
+
+      GitRun.run_git(db, "fetch", "--unshallow", "origin")
+    end
+
+    def fetch_revision(db, revision)
+      return if GitRun.try_run_git(db, "fetch", "--filter=blob:none", "origin", revision)
+
+      GitRun.run_git(db, "fetch", "origin", revision)
+    end
+
+    def git_head_revision(repository)
+      output, status = GitRun.capture_git(repository, "rev-parse", "HEAD")
+      raise Error.resolution(GitRun.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
+  end
+end

data/lib/pray/publish.rb

@@ -28,9 +28,7 @@ module Pray
         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, distribution)
-        if stored_artifact && stored_publish_matches?(
-          stored_artifact, package, signer, signer_fingerprint, existing
-        )
+        if stored_artifact && stored_publish_matches?(stored_artifact, package, existing)
           package_names << package.declaration.name
           write_registry_package_metadata(metadata_path, metadata)
           next
@@ -134,10 +132,17 @@ module Pray
       artifact_bytes
     end
 
-    def stored_publish_matches?(artifact_bytes, package, signer, signer_fingerprint, existing)
-      existing.signer == signer &&
-        existing.signer_fingerprint == signer_fingerprint &&
-        existing.signature == Registry.registry_artifact_signature(artifact_bytes, package.tree_hash, signer)
+    # A stored row is current when its own recorded signature still authenticates the
+    # stored artifact. The check deliberately ignores who is publishing now: a row signed
+    # by another publisher is still a valid attestation of identical bytes, and rewriting
+    # it would restate authorship without republishing anything. A row carrying no
+    # signature is not current, so publish repairs it.
+    def stored_publish_matches?(artifact_bytes, package, existing)
+      return false if existing.signer.nil? || existing.signature.nil?
+
+      existing.signature == Registry.registry_artifact_signature(
+        artifact_bytes, package.tree_hash, existing.signer
+      )
     end
 
     def stored_prayspec_matches?(artifact_bytes, package_root)

data/lib/pray/render_patch.rb

@@ -19,7 +19,7 @@ module Pray
         used,
         output
       )
-      splice_existing_managed(remaining, fresh_managed, used, output)
+      splice_existing_managed(remaining, fresh_segments, fresh_managed, used, output)
       append_unused_fresh_managed(fresh_segments, used, output)
       output.end_with?("\n") ? output : "#{output}\n"
     end
@@ -36,8 +36,8 @@ module Pray
       segments.filter_map { |segment| segment[:id] if segment[:kind] == :managed }.to_h { |id| [id, true] }
     end
 
-    def splice_existing_managed(remaining, fresh_managed, used, output)
-      remaining.each do |segment|
+    def splice_existing_managed(remaining, fresh_segments, fresh_managed, used, output)
+      remaining.each_with_index do |segment, index|
         if segment[:kind] == :text
           output << segment[:text]
           next
@@ -45,15 +45,47 @@ module Pray
 
         used[segment[:id]] = true
         output << managed_segment(segment[:id], fresh_managed.fetch(segment[:id], segment[:body]))
+        next_segment = remaining[index + 1]
+        next unless next_segment && next_segment[:kind] == :managed
+
+        output << text_between(fresh_segments, segment[:id], next_segment[:id])
       end
     end
 
+    def text_between(segments, left, right)
+      copying = false
+      text = +""
+      segments.each do |segment|
+        if segment[:kind] == :managed
+          if segment[:id] == left
+            copying = true
+            text = +""
+          elsif copying
+            return (segment[:id] == right) ? text : ""
+          end
+        elsif copying
+          text << segment[:text]
+        end
+      end
+      ""
+    end
+
     def append_unused_fresh_managed(fresh_segments, used, output)
+      pending = +""
+      seen_used = false
       fresh_segments.each do |segment|
-        next unless segment[:kind] == :managed
-        next if used[segment[:id]]
-
-        output << managed_segment(segment[:id], segment[:body])
+        if segment[:kind] == :managed
+          if used[segment[:id]]
+            seen_used = true
+            pending = +""
+            next
+          end
+          output << pending
+          pending = +""
+          output << managed_segment(segment[:id], segment[:body])
+        elsif seen_used
+          pending << segment[:text]
+        end
       end
     end
 

data/lib/pray/resolve.rb

@@ -59,7 +59,8 @@ module Pray
         project_root,
         manifest.sources,
         lockfile_hints,
-        refresh: options.refresh || options.refresh_source_revisions
+        refresh: options.refresh || options.refresh_source_revisions,
+        offline: options.offline
       )
       source_host_keys = Trust.prepare_source_host_keys(manifest.sources)
 

data/lib/pray/upstream_drift.rb

@@ -10,7 +10,8 @@ module Pray
         project.project_root,
         project.manifest.sources,
         previous,
-        refresh: options.refresh || options.refresh_source_revisions
+        refresh: options.refresh || options.refresh_source_revisions,
+        offline: options.offline
       )
       sources = Resolve.source_map(project.manifest.sources)
       lines = []

data/lib/pray/upstream_latest.rb

@@ -15,7 +15,8 @@ module Pray
         project.project_root,
         project.manifest.sources,
         previous,
-        refresh: options.refresh || options.refresh_source_revisions
+        refresh: options.refresh || options.refresh_source_revisions,
+        offline: options.offline
       )
       sources = Resolve.source_map(project.manifest.sources)
       plans = []

data/lib/pray/upstream_refresh.rb

@@ -10,7 +10,8 @@ module Pray
         project.project_root,
         project.manifest.sources,
         previous,
-        refresh: options.refresh || options.refresh_source_revisions
+        refresh: options.refresh || options.refresh_source_revisions,
+        offline: options.offline
       )
       sources = Resolve.source_map(project.manifest.sources)
       changed = false

data/lib/pray/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Pray
-  VERSION = "1.19.0"
-  GENERATED_BY = "pray 1.19.0"
+  VERSION = "1.20.0"
+  GENERATED_BY = "pray 1.20.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pray-cli
 version: !ruby/object:Gem::Version
-  version: 1.19.0
+  version: 1.20.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -142,6 +142,7 @@ files:
 - lib/pray/git_refresh.rb
 - lib/pray/git_run.rb
 - lib/pray/git_sources.rb
+- lib/pray/git_store.rb
 - lib/pray/hashing.rb
 - lib/pray/http_body.rb
 - lib/pray/invocation.rb