pray-cli 1.18.1 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91a549f989bb5872cf7307c16101a89c479bda9f919dd4f969917a80f4bf5958
-  data.tar.gz: 01a7042cad4e383a95ca2b15d698b9e00a46707d27b2885381ce57f6775cb15b
+  metadata.gz: 6df9a00a7c009e00fdd00987564489607a77bf48cb6472e06951c7709a91a32f
+  data.tar.gz: 93ad851e71a69c13764f2a289d3f32dd7856a749aa341ef728b4c49ebc651149
 SHA512:
-  metadata.gz: 52f904573df3f97eb3ad240388db1ac7d81d36cd66fe24b43be8cf32f392d59abf6283fc496a92b9844e40cec4d7058bf8db54fb97716164635c395c95a27796
-  data.tar.gz: ccc7110154721dbc019d02c37ecdbeaaac225ccf702e8d1007cfe3af4b3f54f35627876fb78f15eb5617e691c7c7ca7016c9c05853b1719655545a087baf8eef
+  metadata.gz: 56060ecc2267d2f8a2c1b555591b3db551383d8350a9b3125a0647831ee2438dfb3f78b6424e2af98bbfc184ef8a91c181e1da5bf35835a160f34bcde865c1b0
+  data.tar.gz: 55b5590131213f639bc63be84817d65c17297354a1387b363c94d8953192ca03f80c9245b47d5cc1d7d99cd51569c2a9647147fb0de124966dfb294e125bf68b

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 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.
+
 ## 1.18.1 (2026-09-17)
 
 - Fix `pray package` and `pray publish` when the CLI cannot create a staging directory.

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

@@ -2,16 +2,64 @@
 
 module Pray
   module CLI
-    def publish_command(roots:, servers:)
+    def publish_command(roots:, servers:, to: [], dry_run: false)
       project = resolve_current_project
-      roots.each { |root| Publish.publish_to_root(project, root) }
-      servers.each { |server| Publish.publish_to_server(project, server) }
+      dests = PublishSelect.resolve_publish_destinations(
+        project.manifest.publish_remotes || [],
+        PublishSelect::PublishCliDest.new(to: to, roots: roots, servers: servers),
+        Dir.pwd
+      )
+      if dry_run
+        print_publish_plan(project, dests)
+        return
+      end
+      dests.each do |dest|
+        packages = selected_publish_packages(project, dest.packages)
+        filtered = project.dup
+        filtered.packages = packages
+        Publish.publish_to_root(filtered, dest.root) if dest.root
+        Publish.publish_to_server(filtered, dest.server) if dest.server
+      end
     end
 
-    def serve_command(root:, host:, port:, stdio:)
+    def selected_publish_packages(project, listed)
+      allowed = PublishRemote.allowed_publish_names(project.manifest, listed)
+      selected = project.packages.select { |package| allowed.include?(package.declaration.name) }
+      if selected.empty?
+        raise Error.usage("no path packages to publish; remote dependencies are not published")
+      end
+      selected.each { |package| package.spec.require_release_version! }
+      selected
+    end
+
+    def print_publish_plan(project, dests)
+      dests.each do |dest|
+        packages = selected_publish_packages(project, dest.packages)
+        target = dest.root || dest.server || dest.name
+        packages.each do |package|
+          puts "publish #{package.declaration.name} #{package.spec.version} -> #{dest.name} (#{target})"
+        end
+      end
+    end
+
+    def serve_command(root:, host:, port:, stdio:, to: nil)
       raise Error.unsupported("serve --stdio is not implemented yet in pray-cli Ruby") if stdio
 
-      Serve.run_server(root: root, host: host, port: port)
+      Serve.run_server(root: optional_path_remote_root(to, root), host: host, port: port)
+    end
+
+    def optional_path_remote_root(to, root)
+      remotes = begin
+        Pray.parse_manifest(Pray.read_manifest_text(manifest_path)).publish_remotes || []
+      rescue Error
+        return root if to.nil?
+
+        raise
+      end
+      return root if remotes.empty? && to.nil?
+
+      cli_root = (root == ".") ? nil : root
+      PublishSelect.resolve_path_remote(remotes, to, cli_root, Dir.pwd)
     end
   end
 end

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

@@ -34,6 +34,32 @@ module Pray
       FileUtils.mkdir_p(File.join(distribution_root, "v1", "artifacts"))
       Publish.write_registry_index(distribution_root, RegistryIndex.new)
       Distribution.write_settings(distribution_root)
+      maybe_declare_publish_remote(Dir.pwd, distribution_root)
+    end
+
+    def maybe_declare_publish_remote(project_root, distribution_root)
+      manifest_path_value = File.join(project_root, "Prayfile")
+      return unless File.exist?(manifest_path_value)
+
+      text = File.read(manifest_path_value)
+      manifest = Pray.parse_manifest(text)
+      return unless (manifest.publish_remotes || []).empty?
+
+      relative = if distribution_root == project_root
+        "."
+      else
+        prefix = project_root.end_with?("/") ? project_root : "#{project_root}/"
+        distribution_root.start_with?(prefix) ? distribution_root.delete_prefix(prefix).tr("\\", "/") : "prayers"
+      end
+      statement = %(publish "prayers", path: "#{relative}")
+      lines = text.split("\n")
+      insertion = lines.rindex { |line| line.lstrip.start_with?("source ") }
+      insertion ||= lines.index { |line| line.lstrip.start_with?("prayfile ") }
+      insertion = insertion ? insertion + 1 : 1
+      lines.insert(insertion, statement)
+      updated = lines.join("\n")
+      updated += "\n" unless updated.end_with?("\n")
+      File.write(manifest_path_value, updated)
     end
 
     def repo_distribution_root(root)

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

@@ -53,7 +53,12 @@ module Pray
 
     def package_command
       project = resolve_current_project
-      project.packages.each do |package|
+      allowed = PublishRemote.path_owned_package_names(project.manifest)
+      packages = project.packages.select { |package| allowed.include?(package.declaration.name) }
+      if packages.empty?
+        raise Error.usage("no path packages to package; remote dependencies are not packed")
+      end
+      packages.each do |package|
         package.spec.require_release_version!
         output_path = Archive.package_archive_path(package.declaration.name, package.spec.version)
         Archive.write_package_archive(package, output_path)

data/lib/pray/cli/help.rb

@@ -23,9 +23,9 @@ module Pray
       ].freeze
 
       DISTRIBUTION_COMMANDS = [
-        "publish --root PATH [--server URL ...]",
+        "publish [--root PATH|--server URL|--to NAME] [--dry-run]",
         "login --server URL --email EMAIL",
-        "serve [--root PATH] [--host HOST] [--port PORT] [--stdio]",
+        "serve [--root PATH | --to NAME] [--host HOST] [--port PORT] [--stdio]",
         "sync [--root PATH] [--peer URL ...]",
         "confess <package> | --from-lock SPAN_ID [--accepted|--rejected]"
       ].freeze
@@ -146,9 +146,11 @@ module Pray
         "vendor" => "copy resolved packages locally\n\nUsage: pray vendor",
         "clean" => "remove local cache and vendor trees, or only unused registry entries\n\nUsage: pray clean [--unused]",
         "publish" => <<~TEXT.strip,
-          upload packages to a registry or local root
+          upload path packages to a registry or local root
 
-          Usage: pray publish --root PATH [--server URL ...]
+          Usage: pray publish [--root PATH] [--server URL ...] [--to NAME] [--dry-run]
+
+          Prayfile publish remotes supply dests when flags are omitted.
         TEXT
         "login" => <<~TEXT.strip,
           authenticate to a registry server
@@ -158,7 +160,7 @@ module Pray
         "serve" => <<~TEXT.strip,
           run a local registry server
 
-          Usage: pray serve [--root PATH] [--host HOST] [--port PORT] [--stdio]
+          Usage: pray serve [--root PATH | --to NAME] [--host HOST] [--port PORT] [--stdio]
         TEXT
         "sync" => <<~TEXT.strip,
           sync packages with peer registries

data/lib/pray/cli/parse.rb

@@ -141,26 +141,33 @@ module Pray
     def parse_publish_arguments(arguments)
       roots = []
       servers = []
+      to = []
+      dry_run = false
       while (argument = arguments.shift)
         case argument
         when "--root"
           roots << arguments.shift
         when "--server"
           servers << arguments.shift
+        when "--to"
+          to << arguments.shift
+        when "--dry-run"
+          dry_run = true
+        when "--signing-key"
+          arguments.shift
         else
           raise Error.unsupported("unexpected publish argument: #{argument}")
         end
       end
-      raise Error.unsupported("publish requires at least one --root PATH or --server URL") if roots.empty? && servers.empty?
-
-      {roots: roots, servers: servers}
+      {roots: roots, servers: servers, to: to, dry_run: dry_run}
     end
 
     def parse_serve_arguments(arguments)
-      options = {root: ".", host: "127.0.0.1", port: 7429, stdio: false}
+      options = {root: ".", to: nil, host: "127.0.0.1", port: 7429, stdio: false}
       while (argument = arguments.shift)
         case argument
         when "--root" then options[:root] = arguments.shift
+        when "--to" then options[:to] = arguments.shift
         when "--host" then options[:host] = arguments.shift
         when "--port" then options[:port] = Integer(arguments.shift)
         when "--stdio" then options[:stdio] = true

data/lib/pray/format_manifest.rb

@@ -79,6 +79,7 @@ module Pray
         targets: [],
         packages: manifest.packages.map { |package| clone_package(package) },
         local: manifest.local.map { |local| local.dup },
+        publish_remotes: (manifest.publish_remotes || []).map(&:dup),
         symbols: manifest.symbols.dup,
         render: manifest.render.dup
       )

data/lib/pray/format_serialize.rb

@@ -12,6 +12,11 @@ module Pray
         manifest.sources.each { |source| lines << format_source(source) }
       end
 
+      unless (manifest.publish_remotes || []).empty?
+        lines << ""
+        manifest.publish_remotes.each { |remote| lines << format_publish_remote(remote) }
+      end
+
       unless manifest.symbols.empty?
         lines << ""
         lines << "pray do"
@@ -109,6 +114,18 @@ module Pray
       parts.join(", ")
     end
 
+    def format_publish_remote(remote)
+      parts = [%(publish "#{remote.name}")]
+      parts << %(path: "#{remote.path}") if remote.path
+      parts << %("#{remote.url}") if remote.url
+      return parts.join(", ") if remote.packages.empty?
+
+      lines = ["#{parts.join(", ")} do"]
+      remote.packages.each { |name| lines << %(  pray "#{name}") }
+      lines << "end"
+      lines.join("\n")
+    end
+
     def format_destination_entry(entry, manifest)
       if entry.kind == "local"
         return %(pray "#{entry.path}")

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_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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pray-cli
 version: !ruby/object:Gem::Version
-  version: 1.18.1
+  version: 1.19.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -156,6 +156,7 @@ files:
 - lib/pray/manifest_parser.rb
 - lib/pray/manifest_parser_blocks.rb
 - lib/pray/manifest_parser_helpers.rb
+- lib/pray/manifest_parser_publish.rb
 - lib/pray/materialize.rb
 - lib/pray/package_spec.rb
 - lib/pray/package_spec_render.rb
@@ -164,6 +165,8 @@ files:
 - lib/pray/plan.rb
 - lib/pray/project_context.rb
 - lib/pray/publish.rb
+- lib/pray/publish_remote.rb
+- lib/pray/publish_select.rb
 - lib/pray/registry.rb
 - lib/pray/registry_http_cache.rb
 - lib/pray/registry_install.rb