pray-cli 1.16.0 → 1.18.0

data/lib/pray/cli.rb

@@ -9,6 +9,8 @@ require_relative "cli/help"
 require_relative "cli/suggest"
 require_relative "cli/helpers"
 require_relative "cli/commands/init"
+require_relative "cli/commands/init_prayer_manifest"
+require_relative "cli/commands/init_prayer"
 require_relative "cli/commands/workflow"
 require_relative "cli/commands/update_latest"
 require_relative "cli/commands/packages"
@@ -82,7 +84,7 @@ module Pray
       case command
       in [:manifest] then manifest_command
       in [:init, targets] then init_command(targets)
-      in [:prayer_init] then prayer_init_command
+      in [:prayer_init, name, directory] then prayer_init_command(name, directory)
       in [:repo_init] then repo_init_command
       in [:install, flags] then install_command(flags)
       in [:add, add_args] then add_command(**add_args)

data/lib/pray/destination.rb

@@ -16,8 +16,7 @@ module Pray
 
     def local_path_form?(value)
       value.start_with?(".", "/") ||
-        value.end_with?(".md", ".txt", ".markdown") ||
-        !value.include?("/")
+        value.end_with?(".md", ".txt", ".markdown")
     end
 
     def destination_target_name(mode, path)
@@ -106,6 +105,7 @@ module Pray
       if existing.position == "after" && local.position != "after"
         existing.position = local.position
       end
+      existing.file ||= local.file
     end
 
     def bind_package_entry(target, package_name)
@@ -154,5 +154,35 @@ module Pray
       else false
       end
     end
+
+    def local_compose_embed?(manifest, local)
+      return false if local.file
+
+      manifest.targets.none? do |target|
+        target.mode == "tree" &&
+          target.entries.any? { |entry| entry.kind == "local" && entry.path == local.path }
+      end
+    end
+
+    def try_apply_local_pray(manifest, path, file_dest, other_package_signal, destination_index)
+      return false unless local_path_form?(path)
+
+      if file_dest
+        return false if other_package_signal
+        raise Error.parse("manifest", "a local file cannot use file:")
+      end
+      return false if other_package_signal
+      unless destination_index
+        raise Error.parse("manifest", "local pray paths are only valid inside compose")
+      end
+      mode = manifest.targets[destination_index].mode
+      unless mode == "compose"
+        raise Error.parse("manifest", "local pray paths are only valid inside compose")
+      end
+      local = ManifestLocal.new(path: path, bound: true)
+      bind_local_entry(manifest.targets[destination_index], local.path)
+      upsert_local(manifest, local)
+      true
+    end
   end
 end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "error"
+require_relative "hashing"
+require_relative "git_run"
+require_relative "git_clone"
+
+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)]
+    end
+
+    def git_source_cache_directory(project_root, clone_url, subdir = nil)
+      identity = (subdir && !subdir.empty?) ? "#{clone_url}\n#{subdir}" : clone_url
+      File.join(project_root, ".pray", "cache", "git", cache_key(identity))
+    end
+
+    def git_source_cached_repository(project_root, clone_url)
+      shared = git_source_cache_directory(project_root, clone_url)
+      return shared if git_checkout?(shared)
+
+      cache_root = File.join(project_root, ".pray", "cache", "git")
+      return nil unless File.directory?(cache_root)
+
+      Dir.children(cache_root).each do |name|
+        path = File.join(cache_root, name)
+        return path if git_checkout?(path) && origin_matches?(path, clone_url)
+      end
+      nil
+    end
+
+    def git_checkout?(path)
+      File.exist?(File.join(path, ".git"))
+    end
+
+    def cache_key(text)
+      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?
+
+      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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "git_run"
+
+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]
+      filtered.insert(1, "--quiet") if quiet
+      return if GitRun.try_run_git(working_directory, *filtered)
+
+      full = ["clone", "--depth", "1", 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"]
+      else
+        ["v1/packages", "prayers/v1/packages"]
+      end
+    end
+  end
+end

data/lib/pray/git_materialize.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "git_run"
+require_relative "error"
+require_relative "path_safety"
+
+module Pray
+  module GitMaterialize
+    module_function
+
+    def read_local_artifact_bytes(source_root, artifact)
+      if artifact.start_with?("file://")
+        path = PathSafety.join_under_root(source_root, artifact.delete_prefix("file://"))
+        raise Error.resolution("package artifact path escapes distribution root") unless path
+
+        return File.binread(path)
+      end
+      if artifact.match?(%r{\A[a-z][a-z0-9+.-]*:}i)
+        raise Error.integrity("remote artifact path must be relative: #{artifact}")
+      end
+
+      path = PathSafety.join_under_root(source_root, artifact)
+      raise Error.resolution("package artifact path escapes distribution root") unless path
+
+      materialize_catalog_file(source_root, artifact) unless File.exist?(path)
+      raise Error.resolution("package artifact missing at #{path}") unless File.exist?(path)
+
+      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
+
+      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
+
+    def sparse_checkout_enabled?(source_root)
+      output, status = GitRun.capture_git(source_root, "config", "--get", "core.sparseCheckout")
+      status.success? && output.strip == "true"
+    end
+
+    def git_toplevel(source_root)
+      output, status = GitRun.capture_git(source_root, "rev-parse", "--show-toplevel")
+      return unless status.success?
+
+      text = output.strip
+      text.empty? ? nil : text
+    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)
+    end
+
+    def artifact_sparse_cone(repo_relative)
+      parts = repo_relative.split("/").reject(&:empty?)
+      return repo_relative if parts.length < 2
+
+      parts.pop
+      parts.pop if parts.last != "artifacts" && parts.length > 3
+      parts.join("/")
+    end
+  end
+end

data/lib/pray/git_run.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "error"
+
+module Pray
+  module GitRun
+    module_function
+
+    def run_git(cwd, *arguments)
+      output, status = capture_git(cwd, *arguments)
+      return if status.success?
+
+      raise Error.resolution(command_error("git #{arguments.join(" ")}", output))
+    end
+
+    def try_run_git(cwd, *arguments)
+      _output, status = capture_git(cwd, *arguments)
+      status.success?
+    end
+
+    def capture_git(cwd, *arguments)
+      env = ENV.to_h.merge("GIT_TERMINAL_PROMPT" => "0")
+      Open3.capture2e(
+        env,
+        "git",
+        "-c",
+        "protocol.file.allow=always",
+        "-C",
+        cwd,
+        *arguments,
+        stdin_data: ""
+      )
+    end
+
+    def command_error(program, output)
+      message = output.strip
+      message.empty? ? "#{program} failed" : "#{program} failed: #{message}"
+    end
+  end
+end