pray-cli 1.16.0 → 1.17.0

data/lib/pray/distribution.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Pray
+  DISTRIBUTION_CONFIG_SPEC = "pray-distribution-config-1"
+  TORRENT_PROTOCOL = "torrent"
+  DISTRIBUTION_CONFIG_FIELDS = %w[spec protocols bootstrap_trackers enable_dht].freeze
+
+  RegistryDistributionSettings = Struct.new(
+    :spec, :protocols, :bootstrap_trackers, :enable_dht,
+    keyword_init: true
+  ) do
+    def initialize(spec: DISTRIBUTION_CONFIG_SPEC, protocols: [], bootstrap_trackers: [], enable_dht: false)
+      super
+    end
+
+    def allows_torrent?
+      Array(protocols).include?(TORRENT_PROTOCOL)
+    end
+  end
+
+  module Distribution
+    module_function
+
+    def default_settings
+      RegistryDistributionSettings.new
+    end
+
+    def parse_settings(text)
+      data = JSON.parse(text)
+      unless data.is_a?(Hash)
+        raise Error.parse("distribution config", "expected an object")
+      end
+
+      data.each_key do |key|
+        next if DISTRIBUTION_CONFIG_FIELDS.include?(key)
+
+        raise Error.parse("distribution config", "unsupported field: #{key}")
+      end
+      settings = RegistryDistributionSettings.new(
+        spec: data.fetch("spec", DISTRIBUTION_CONFIG_SPEC),
+        protocols: Array(data["protocols"]),
+        bootstrap_trackers: Array(data["bootstrap_trackers"]),
+        enable_dht: data["enable_dht"] == true
+      )
+      validate_settings!(settings)
+      settings
+    rescue JSON::ParserError => error
+      raise Error.parse("distribution config", error.message)
+    end
+
+    def read_settings(root)
+      path = File.join(root, "v1", "distribution.json")
+      return default_settings unless File.file?(path)
+
+      parse_settings(File.read(path))
+    end
+
+    def write_settings(root, settings = default_settings)
+      validate_settings!(settings)
+      path = File.join(root, "v1", "distribution.json")
+      FileUtils.mkdir_p(File.dirname(path))
+      payload = {"spec" => settings.spec, "protocols" => Array(settings.protocols)}
+      File.write(path, JSON.pretty_generate(payload))
+    end
+
+    def validate_settings!(settings)
+      unless settings.spec == DISTRIBUTION_CONFIG_SPEC
+        raise Error.parse("distribution config", "unsupported distribution config spec: #{settings.spec}")
+      end
+      Array(settings.protocols).each do |name|
+        next if name == TORRENT_PROTOCOL
+
+        raise Error.parse("distribution config", "unsupported protocol: #{name}")
+      end
+      if settings.enable_dht
+        raise Error.parse("distribution config", "DHT announce is not implemented")
+      end
+      return if Array(settings.bootstrap_trackers).empty? || settings.allows_torrent?
+
+      raise Error.parse("distribution config", "bootstrap_trackers requires protocols to include torrent")
+    end
+
+    def fetch_settings(source_url)
+      parse_settings(Registry.http_get(Registry.join_url(source_url, "v1/distribution.json")))
+    rescue Error => error
+      return default_settings if error.message.match?(/:\s*404\b/)
+
+      raise
+    end
+  end
+end

data/lib/pray/format_serialize.rb

@@ -42,10 +42,7 @@ module Pray
           path = target.skills.first || ""
           lines << %(tree "#{path}" do)
           target.entries.each do |entry|
-            next unless entry.kind == "package"
-
-            package = find_package(manifest, entry.name)
-            lines << "  #{ManifestMethods.format_package_declaration(package)}" if package
+            lines << "  #{format_destination_entry(entry, manifest)}"
           end
           lines << "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/render.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require "pathname"
 require_relative "render_content"
+require_relative "render_managed"
 
 module Pray
   RenderedTarget = Struct.new(:path, :content, :managed_spans) do
@@ -76,7 +77,7 @@ module Pray
 
       (target.entries || []).each do |entry|
         if entry.kind == "local"
-          append_scoped_local(builder, project, entry.path, symbols)
+          append_scoped_local(builder, managed_spans, project, target, output, entry.path, symbols)
         else
           append_scoped_package(builder, managed_spans, project, target, output, entry.name, symbols)
         end
@@ -99,18 +100,17 @@ module Pray
         builder.append_empty_line
       end
       symbols = project.manifest.symbols || {}
+      managed_spans = []
       unbound_locals.each do |local|
         next if local.content.empty? && local.optional
 
         builder.append_line("### #{local.manifest_path}")
-        builder.append_body(Substitute.substitute_pray_symbols(local.content, symbols))
-        builder.append_empty_line
+        append_managed_local(builder, managed_spans, local, target, output, symbols)
       end
 
       builder.append_line("## Shared instructions")
       builder.append_empty_line
 
-      managed_spans = []
       project.packages.each do |package|
         next unless Environment.package_matches_environment?(package.declaration.groups, project.environment)
         next unless Destination.package_bound_to_compose?(package.declaration, target)
@@ -133,13 +133,11 @@ module Pray
       builder.append_empty_line
     end
 
-    def append_scoped_local(builder, project, path, symbols)
+    def append_scoped_local(builder, managed_spans, project, target, output, path, symbols)
       local = project.local_files.find { |candidate| candidate.manifest_path == path }
       return unless local
-      return if local.content.empty? && local.optional
 
-      builder.append_body(Substitute.substitute_pray_symbols(local.content, symbols))
-      builder.append_empty_line
+      append_managed_local(builder, managed_spans, local, target, output, symbols)
     end
 
     def append_scoped_package(builder, managed_spans, project, target, output, package_name, symbols)
@@ -154,34 +152,6 @@ module Pray
       end
     end
 
-    def append_managed_export(builder, managed_spans, package, export, target, output, symbols)
-      body = package.export_bodies[export]
-      unless body
-        raise Error.integrity("compose cannot write binary export #{export}; use file: for unmarked bytes") if package.spec.exports[export]&.kind == "file"
-        raise Error.render("package #{package.declaration.name} is missing cached export #{export}")
-      end
-
-      body = Substitute.substitute_pray_symbols(body, symbols)
-      identifier = Hashing.marker_id("#{package.declaration.name}:#{export}:#{target.name}")
-      open_line = builder.next_line_number
-      builder.append_line("<!-- pray:#{identifier} -->")
-      builder.append_body(body)
-      close_line = builder.next_line_number
-      builder.append_line("<!-- pray:#{identifier} -->")
-      managed_spans << ManagedSpanRecord.new(
-        id: identifier,
-        target: output,
-        open_line: open_line,
-        close_line: close_line,
-        ideal_checksum: Hashing.checksum_managed_span_content(body),
-        package: package.declaration.name,
-        export: export,
-        source_checksum: package.source_checksum,
-        silenced: false
-      )
-      builder.append_empty_line
-    end
-
     def should_inline_export?(package, export_name)
       export = package.spec.exports[export_name]
       export.nil? || %w[fragment file].include?(export.kind)

data/lib/pray/render_managed.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pray
+  module Render
+    module_function
+
+    def append_managed_local(builder, managed_spans, local, target, output, symbols)
+      return if local.content.empty? && local.optional
+
+      body = Substitute.substitute_pray_symbols(local.content, symbols)
+      append_managed_span(
+        builder,
+        managed_spans,
+        "local:#{local.manifest_path}:#{target.name}",
+        body,
+        output,
+        LOCAL_EMBED_PACKAGE,
+        local.manifest_path,
+        local.source_checksum
+      )
+    end
+
+    def append_managed_export(builder, managed_spans, package, export, target, output, symbols)
+      body = package.export_bodies[export]
+      unless body
+        raise Error.integrity("compose cannot write binary export #{export}; use file: for unmarked bytes") if package.spec.exports[export]&.kind == "file"
+        raise Error.render("package #{package.declaration.name} is missing cached export #{export}")
+      end
+
+      body = Substitute.substitute_pray_symbols(body, symbols)
+      append_managed_span(
+        builder,
+        managed_spans,
+        "#{package.declaration.name}:#{export}:#{target.name}",
+        body,
+        output,
+        package.declaration.name,
+        export,
+        package.source_checksum
+      )
+    end
+
+    def append_managed_span(builder, managed_spans, seed, body, output, package, export, source_checksum)
+      identifier = Hashing.marker_id(seed)
+      open_line = builder.next_line_number
+      builder.append_line("<!-- pray:#{identifier} -->")
+      builder.append_body(body)
+      close_line = builder.next_line_number
+      builder.append_line("<!-- pray:#{identifier} -->")
+      managed_spans << ManagedSpanRecord.new(
+        id: identifier,
+        target: output,
+        open_line: open_line,
+        close_line: close_line,
+        ideal_checksum: Hashing.checksum_managed_span_content(body),
+        package: package,
+        export: export,
+        source_checksum: source_checksum,
+        silenced: false
+      )
+      builder.append_empty_line
+    end
+  end
+end