pray-cli 1.18.1 → 1.20.0

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/manifest.rb

@@ -4,8 +4,11 @@ require_relative "manifest_json"
 require_relative "manifest_formatter"
 require_relative "manifest_parser_helpers"
 require_relative "manifest_parser_blocks"
+require_relative "manifest_parser_publish"
 require_relative "manifest_parser"
 require_relative "path_safety"
+require_relative "publish_remote"
+require_relative "publish_select"
 
 module Pray
   RenderPolicy = Struct.new(
@@ -53,7 +56,7 @@ module Pray
   end
 
   Manifest = Struct.new(
-    :prayfile_version, :sources, :targets, :packages, :local, :symbols, :render,
+    :prayfile_version, :sources, :targets, :packages, :local, :publish_remotes, :symbols, :render,
     :deprecated_keywords,
     keyword_init: true
   ) do
@@ -63,6 +66,7 @@ module Pray
       targets: [],
       packages: [],
       local: [],
+      publish_remotes: [],
       symbols: {},
       render: RenderPolicy.default,
       deprecated_keywords: []
@@ -99,6 +103,7 @@ module Pray
         copy.targets = targets.sort_by(&:name)
         copy.packages = packages.sort_by { |package| [package.name, package.source.to_s, package.constraint] }
         copy.local = local.sort_by(&:path)
+        copy.publish_remotes = (publish_remotes || []).sort_by(&:name)
         copy.deprecated_keywords = []
       end
     end
@@ -139,6 +144,7 @@ module Pray
         PathSafety.validate_project_relative_path!(local.path)
         PathSafety.validate_destination_path!(local.file) if local.file
       end
+      PublishRemote.validate_publish_remotes!(manifest)
     end
   end
 

data/lib/pray/manifest_json.rb

@@ -17,10 +17,20 @@ module Pray
         "local" => manifest.local.map { |entry| local_fields(entry) }
       }
       fields["symbols"] = manifest.symbols.sort.to_h unless manifest.symbols.empty?
+      unless (manifest.publish_remotes || []).empty?
+        fields["publish_remotes"] = manifest.publish_remotes.map { |remote| publish_remote_fields(remote) }
+      end
       fields["render"] = render_fields(manifest.render)
       fields
     end
 
+    def publish_remote_fields(remote)
+      fields = {"name" => remote.name, "packages" => remote.packages}
+      fields["path"] = remote.path if remote.path
+      fields["url"] = remote.url if remote.url
+      fields
+    end
+
     def source_fields(source)
       fields = {
         "name" => source.name,

data/lib/pray/manifest_parser.rb

@@ -5,6 +5,7 @@ module Pray
     class BlockParser
       include ParserHelpers
       include ParserBlocks
+      include ParserPublish
 
       def initialize(lines)
         @lines = lines
@@ -41,6 +42,8 @@ module Pray
           manifest.prayfile_version = string_from_literal(Regexp.last_match(1))
         when /\Asource (.+)\z/
           manifest.sources << parse_source(Regexp.last_match(1))
+        when /\Apublish (.+)\z/
+          apply_publish(manifest, Regexp.last_match(1))
         when /\Atarget (.+)\z/
           apply_legacy_target(manifest, statement, Regexp.last_match(1), allow_target)
         when /\Agroup (.+)\z/

data/lib/pray/manifest_parser_publish.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestMethods
+    module ParserPublish
+      def apply_publish(manifest, rest)
+        is_block = rest.rstrip.end_with?(" do")
+        header = rest.sub(/\s+do\z/, "").strip
+        remote = parse_publish_header(header)
+        parse_publish_block(remote) if is_block
+        manifest.publish_remotes << remote
+      end
+
+      def parse_publish_header(rest)
+        values, keywords = parse_call(rest)
+        raise Error.parse("manifest", "publish requires a name") if values.empty?
+
+        name = string_from_value(values.first)
+        if %w[git source signing_key token].any? { |key| keywords.key?(key) }
+          raise Error.parse(
+            "manifest",
+            "publish \"#{name}\" does not take git:, source:, signing_key:, or token:"
+          )
+        end
+        ManifestPublishRemote.new(
+          name: name,
+          path: keyword_string(keywords, "path"),
+          url: values[1] && string_from_value(values[1]),
+          packages: []
+        )
+      end
+
+      def parse_publish_block(remote)
+        while (statement = next_statement)
+          return if statement == "end"
+
+          pray_rest = statement[/\A(?:pray|use|include|agent|package) (.+)\z/, 1]
+          unless pray_rest
+            raise Error.parse("manifest", "publish blocks only support pray package names: #{statement}")
+          end
+
+          package = parse_package_decl(pray_rest)
+          if remote.packages.include?(package.name)
+            raise Error.parse("manifest", "duplicate package #{package.name} in publish \"#{remote.name}\"")
+          end
+          remote.packages << package.name
+        end
+        raise Error.parse("manifest", "missing 'end' for publish block")
+      end
+    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/publish_remote.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pray
+  ManifestPublishRemote = Struct.new(:name, :path, :url, :packages) do
+    def initialize(name:, path: nil, url: nil, packages: [])
+      super
+    end
+  end
+
+  module PublishRemote
+    module_function
+
+    def validate_publish_remotes!(manifest)
+      seen = {}
+      (manifest.publish_remotes || []).each do |remote|
+        raise Error.parse("manifest", "publish requires a name") if remote.name.to_s.strip.empty?
+        if seen[remote.name]
+          raise Error.manifest("duplicate publish remote: #{remote.name}")
+        end
+        seen[remote.name] = true
+        if remote.path && remote.url
+          raise Error.parse("manifest", "publish \"#{remote.name}\" must set path: or a URL, not both")
+        end
+        if remote.path.nil? && remote.url.nil?
+          raise Error.parse("manifest", "publish \"#{remote.name}\" requires path: or a URL")
+        end
+        PathSafety.validate_project_relative_path!(remote.path) if remote.path
+        if remote.url && !publish_url?(remote.url)
+          raise Error.parse(
+            "manifest",
+            "publish \"#{remote.name}\" URL must be https://, http://, pray+ssh://, or ssh+pray://"
+          )
+        end
+        validate_remote_packages!(manifest, remote)
+      end
+    end
+
+    def validate_remote_packages!(manifest, remote)
+      remote.packages.each do |package_name|
+        package = manifest.packages.find { |entry| entry.name == package_name }
+        unless package
+          raise Error.manifest("publish \"#{remote.name}\" lists unknown package #{package_name}")
+        end
+        next if package_is_path_owned?(package, manifest.sources)
+
+        raise Error.manifest(
+          "publish \"#{remote.name}\" lists #{package_name}, which is not a path package"
+        )
+      end
+    end
+
+    def package_is_path_owned?(package, sources)
+      return true if package.path
+      return false if package.git || package.tarball || package.oci
+
+      map = sources.to_h { |source| [source.name, source] }
+      name = ResolveSource.implied_source_name(package, map)
+      name && map[name]&.kind == "path"
+    rescue Error
+      false
+    end
+
+    def path_owned_package_names(manifest)
+      manifest.packages.select { |package| package_is_path_owned?(package, manifest.sources) }
+        .map(&:name)
+    end
+
+    def allowed_publish_names(manifest, listed)
+      listed.empty? ? path_owned_package_names(manifest) : listed
+    end
+
+    def publish_url?(url)
+      url.start_with?("https://", "http://", "pray+ssh://", "ssh+pray://")
+    end
+  end
+end

data/lib/pray/publish_select.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Pray
+  module PublishSelect
+    module_function
+
+    PublishDestination = Struct.new(:name, :root, :server, :packages) do
+      def initialize(name:, root: nil, server: nil, packages: [])
+        super
+      end
+    end
+    PublishCliDest = Struct.new(:to, :roots, :servers) do
+      def initialize(to: [], roots: [], servers: [])
+        super
+      end
+    end
+
+    def resolve_publish_destinations(remotes, cli, project_root)
+      if !cli.to.empty? && (!cli.roots.empty? || !cli.servers.empty?)
+        raise Error.usage("publish --to cannot be combined with --root or --server")
+      end
+      return resolve_undeclared_destinations(cli) if remotes.empty?
+
+      select_remotes(remotes, cli, project_root).map do |remote|
+        PublishDestination.new(
+          name: remote.name,
+          root: remote.path && File.join(project_root, remote.path),
+          server: remote.url,
+          packages: remote.packages
+        )
+      end
+    end
+
+    def resolve_path_remote(remotes, to, root, project_root)
+      path_remotes = remotes.select(&:path)
+      if to
+        remote = remotes.find { |entry| entry.name == to }
+        raise Error.usage("unknown publish remote: #{to}") unless remote
+        unless remote.path
+          raise Error.usage("publish remote #{to} is a URL; yank, serve, and token need a path remote")
+        end
+        return File.join(project_root, remote.path)
+      end
+      if remotes.empty?
+        raise Error.usage("requires --root PATH") unless root
+
+        return root
+      end
+      if root
+        matched = remotes.find { |remote| remote.path && root_matches?(root, remote.path, project_root) }
+        raise Error.usage("path #{root} is not a declared publish remote") unless matched
+
+        return root
+      end
+      if path_remotes.length == 1 && path_remotes.first.path
+        return File.join(project_root, path_remotes.first.path)
+      end
+
+      raise Error.usage("say which path remote with --to NAME or --root PATH")
+    end
+
+    def resolve_undeclared_destinations(cli)
+      if !cli.to.empty?
+        raise Error.usage("Prayfile has no publish remotes; pass --root PATH or --server URL")
+      end
+      if cli.roots.empty? && cli.servers.empty?
+        raise Error.unsupported("publish requires at least one --root PATH or --server URL")
+      end
+
+      dests = cli.roots.map { |root| PublishDestination.new(name: root, root: root, packages: []) }
+      dests + cli.servers.map { |server| PublishDestination.new(name: server, server: server, packages: []) }
+    end
+
+    def select_remotes(remotes, cli, project_root)
+      unless cli.to.empty?
+        return cli.to.map do |name|
+          remote = remotes.find { |entry| entry.name == name }
+          raise Error.usage("unknown publish remote: #{name}") unless remote
+
+          remote
+        end
+      end
+      return remotes if cli.roots.empty? && cli.servers.empty?
+
+      selected = cli.roots.map do |root|
+        remote = remotes.find { |entry| entry.path && root_matches?(root, entry.path, project_root) }
+        raise Error.usage("path #{root} is not a declared publish remote") unless remote
+
+        remote
+      end
+      selected + cli.servers.map do |server|
+        remote = remotes.find { |entry| entry.url == server }
+        raise Error.usage("server #{server} is not a declared publish remote") unless remote
+
+        remote
+      end
+    end
+
+    def root_matches?(cli_root, remote_path, project_root)
+      declared = File.join(project_root, remote_path)
+      return true if cli_root == declared || cli_root == remote_path
+
+      strip_dot_slash(cli_root) == strip_dot_slash(remote_path)
+    end
+
+    def strip_dot_slash(value)
+      value.to_s.strip.delete_prefix("./").delete_suffix("/").tr("\\", "/")
+    end
+  end
+end

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.18.1"
-  GENERATED_BY = "pray 1.18.1"
+  VERSION = "1.20.0"
+  GENERATED_BY = "pray 1.20.0"
 end