pray-cli 1.6.0

data/lib/pray/package_spec.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Pray
+  PackageExport = Struct.new(:kind, :path, :summary, :only, :except, :default_path) do
+    def initialize(kind: "fragment", path: "", summary: nil, only: [], except: [], default_path: nil)
+      super
+    end
+  end
+  PackageSkill = Struct.new(:path, :summary)
+  PackageTemplate = Struct.new(:path, :summary)
+  PackageDependency = Struct.new(:name, :constraint, :optional)
+
+  PackageSpec = Struct.new(
+    :name, :version, :summary, :description, :authors, :license, :homepage,
+    :source_code_uri, :changelog_uri, :prayfile_version, :files, :exports,
+    :skills, :templates, :adapters, :targets, :dependencies, :metadata
+  ) do
+    def initialize(
+      name: "", version: "", summary: nil, description: nil, authors: [], license: nil,
+      homepage: nil, source_code_uri: nil, changelog_uri: nil, prayfile_version: nil,
+      files: [], exports: {}, skills: {}, templates: {}, adapters: {}, targets: [],
+      dependencies: [], metadata: {}
+    )
+      super
+    end
+
+    def canonicalized
+      dup.tap do |copy|
+        copy.files = files.sort
+        copy.authors = authors.sort
+        copy.targets = targets.sort
+        copy.dependencies = dependencies.sort_by { |dependency| [dependency.name, dependency.constraint, dependency.optional] }
+      end
+    end
+
+    def tree_hash_for_root(root)
+      file_bytes = {}
+      files.each do |file|
+        path = File.join(root, file)
+        raise Error.integrity("package file missing: #{file}") unless File.exist?(path)
+        raise Error.integrity("package file is a directory: #{file}") if File.directory?(path)
+
+        file_bytes[file] = File.binread(path)
+      end
+      self.class.tree_hash_from_file_bytes(file_bytes)
+    end
+
+    def self.tree_hash_from_file_bytes(file_bytes)
+      entries = file_bytes.map { |path, bytes| [path, Hashing.sha256_prefixed(bytes)] }.sort_by(&:first)
+      serialized = entries.map do |path, hash|
+        "file\0regular\0#{path}\0#{hash}\n"
+      end.join
+      Hashing.sha256_prefixed(serialized)
+    end
+  end
+
+  module PackageSpecParser
+    module_function
+
+    module ParserHelpers
+      include ManifestMethods::ParserHelpers
+
+      def parse_dependency(rest, optional)
+        values, keywords = parse_call(rest)
+        name = string_from_value(values.first)
+        constraint = values[1] ? string_from_value(values[1]) : "*"
+        PackageDependency.new(
+          name: name,
+          constraint: constraint,
+          optional: keywords["optional"]&.as_bool || optional
+        )
+      end
+
+      def parse_exports(value)
+        map = Literal.parse_literal_map(value)
+        exports = {}
+        map.each do |name, literal|
+          entry = literal.as_map
+          raise Error.parse("prayspec", "export #{name} must be a map") unless entry
+
+          exports[name] = PackageExport.new(
+            kind: map_string(entry, "type") || "fragment",
+            path: map_string(entry, "path") || raise(Error.parse("prayspec", "export #{name} missing path")),
+            summary: map_string(entry, "summary"),
+            only: map_string_array(entry, "only"),
+            except: map_string_array(entry, "except"),
+            default_path: map_string(entry, "default_path")
+          )
+        end
+        exports
+      end
+
+      def parse_skills(value)
+        map = Literal.parse_literal_map(value)
+        map.transform_values do |literal|
+          entry = literal.as_map
+          raise Error.parse("prayspec", "skill must be a map") unless entry
+
+          PackageSkill.new(
+            path: map_string(entry, "path") || raise(Error.parse("prayspec", "skill missing path")),
+            summary: map_string(entry, "summary")
+          )
+        end
+      end
+
+      def parse_templates(value)
+        map = Literal.parse_literal_map(value)
+        map.transform_values do |literal|
+          entry = literal.as_map
+          raise Error.parse("prayspec", "template must be a map") unless entry
+
+          PackageTemplate.new(
+            path: map_string(entry, "path") || raise(Error.parse("prayspec", "template missing path")),
+            summary: map_string(entry, "summary")
+          )
+        end
+      end
+
+      def parse_string_map(value)
+        Literal.parse_literal_map(value).transform_values { |literal| string_from_value(literal) }
+      end
+
+      def map_string(map, key)
+        map[key]&.as_string
+      end
+
+      def map_string_array(map, key)
+        values = map[key]&.as_array
+        return [] unless values
+
+        values.filter_map(&:as_string)
+      end
+
+      def array_of_strings(value)
+        array = Literal.parse_literal(value)
+        values = array.as_array
+        raise Error.parse("prayspec", "expected array") unless values
+
+        values.map { |entry| string_from_value(entry) }
+      end
+
+      def string_from_value(value)
+        text = value.as_string
+        raise Error.parse("prayspec", "expected string-like literal, found #{value.inspect}") unless text
+
+        text
+      end
+
+      def string_from_literal(value)
+        string_from_value(Literal.parse_literal(value))
+      end
+    end
+
+    def parse_package_spec(text)
+      lines = Literal.prepare_parser_lines(text)
+      BlockParser.new(lines).parse_root
+    end
+
+    class BlockParser
+      include ParserHelpers
+
+      def initialize(lines)
+        @lines = lines
+        @cursor = 0
+      end
+
+      def parse_root
+        expect_start!
+        spec = PackageSpec.new
+        while (statement = next_statement)
+          return spec.canonicalized if statement == "end"
+
+          apply_statement(spec, statement)
+        end
+        raise Error.parse("prayspec", "missing 'end'")
+      end
+
+      def expect_start!
+        statement = next_statement
+        raise Error.parse("prayspec", "empty package spec") unless statement
+        unless statement.start_with?("Package::Specification.new")
+          raise Error.parse("prayspec", "expected Package::Specification.new")
+        end
+      end
+
+      def apply_statement(spec, statement)
+        case statement
+        when /\Aspec\.add_dependency (.+)\z/
+          spec.dependencies << parse_dependency(Regexp.last_match(1), false)
+        when /\Aspec\.add_optional_dependency (.+)\z/
+          spec.dependencies << parse_dependency(Regexp.last_match(1), true)
+        when /\Aspec\.(.+) = (.+)\z/
+          apply_assignment(spec, Regexp.last_match(1).strip, Regexp.last_match(2).strip)
+        else
+          raise Error.parse("prayspec", "unrecognized statement: #{statement}")
+        end
+      end
+
+      def apply_assignment(spec, field, value)
+        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 "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)
+        when "skills" then spec.skills = parse_skills(value)
+        when "templates" then spec.templates = parse_templates(value)
+        when "adapters" then spec.adapters = parse_string_map(value)
+        when "metadata" then spec.metadata = Literal.parse_literal_map(value)
+        else
+          raise Error.parse("prayspec", "unsupported assignment: #{field}")
+        end
+      end
+
+      def next_statement
+        while @cursor < @lines.length
+          statement = @lines[@cursor].strip
+          @cursor += 1
+          next if statement.empty?
+
+          while !statement.end_with?(" do") && statement != "end" && @cursor < @lines.length &&
+              (statement.rstrip.end_with?(",") || !Literal.is_balanced?(statement))
+            next_line = @lines[@cursor].strip
+            @cursor += 1
+            next if next_line.empty?
+
+            statement = "#{statement} #{next_line}"
+          end
+          return statement
+        end
+        nil
+      end
+    end
+  end
+
+  extend PackageSpecParser
+end

data/lib/pray/path_safety.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Pray
+  module PathSafety
+    module_function
+
+    def path_under_root?(root, candidate)
+      root_path = Pathname.new(File.expand_path(root)).cleanpath
+      candidate_path = Pathname.new(File.expand_path(candidate)).cleanpath
+      candidate_path == root_path || candidate_path.to_s.start_with?("#{root_path}#{File::SEPARATOR}")
+    end
+
+    def join_under_root(root, *segments)
+      root_path = Pathname.new(File.expand_path(root)).cleanpath
+      candidate = root_path.join(*segments).cleanpath
+      return candidate.to_s if path_under_root?(root_path.to_s, candidate.to_s)
+
+      nil
+    end
+
+    def reject_unsafe_package_name!(package_name)
+      if package_name.nil? || package_name.empty? || package_name.include?("\0") || package_name.include?("\\") ||
+          package_name.include?("..")
+        raise Error.resolution("invalid package name: #{package_name.inspect}")
+      end
+
+      package_name
+    end
+
+    def sanitize_relative_path(path)
+      cleaned = path.to_s.delete_prefix("/").tr("\\", "/")
+      if cleaned.empty? || cleaned.include?("\0") || cleaned.split("/").include?("..")
+        raise Error.resolution("unsafe relative path: #{path.inspect}")
+      end
+
+      cleaned
+    end
+  end
+end

data/lib/pray/plan.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Pray
+  module Plan
+    MaterializationPreview = Struct.new(
+      :package_lines, :lockfile, :targets, :provisioned, :warnings
+    )
+
+    module_function
+
+    def build_materialization_preview(project, rendered, lockfile, lockfile_path, previous_lockfile)
+      MaterializationPreview.new(
+        package_lines: package_summary_lines(previous_lockfile, lockfile, project),
+        lockfile: lockfile_change_status(lockfile_path, lockfile),
+        targets: rendered.map { |target| target_change(project, target) },
+        provisioned: Render.planned_provisioned_files(project).map { |file| provisioned_change(project, file) },
+        warnings: []
+      )
+    end
+
+    def print_materialization_report(preview, mode)
+      puts (mode == :plan) ? "Plan" : "Install"
+      preview.package_lines.each { |line| puts line }
+      puts "Lockfile: #{preview.lockfile}"
+      preview.targets.each do |path, change|
+        puts "Target #{path}: #{change}"
+      end
+      preview.provisioned.each do |path, change|
+        puts "Provisioned #{path}: #{change}"
+      end
+      preview.warnings.each { |warning| puts "Warning: #{warning}" }
+    end
+
+    def package_summary_lines(previous_lockfile, lockfile, _project)
+      if previous_lockfile.nil?
+        lockfile.package.map do |entry|
+          "Package #{entry.name} #{entry.version} (new)"
+        end
+      else
+        lockfile.package.filter_map do |entry|
+          previous = previous_lockfile.package.find { |package| package.name == entry.name }
+          next "Package #{entry.name} #{entry.version} (new)" unless previous
+          next if previous.version == entry.version && previous.tree_hash == entry.tree_hash
+
+          "Package #{entry.name} #{previous.version} -> #{entry.version}"
+        end
+      end
+    end
+
+    def lockfile_change_status(lockfile_path, lockfile)
+      return "create" unless File.exist?(lockfile_path)
+
+      existing = Pray.read_lockfile(lockfile_path)
+      Pray.lockfiles_equivalent?(lockfile, existing) ? "unchanged" : "update"
+    end
+
+    def target_change(project, target)
+      path = File.join(project.project_root, target.path)
+      change = if !File.exist?(path)
+        "write"
+      elsif File.read(path) == target.content
+        "unchanged"
+      else
+        "update"
+      end
+      [target.path, change]
+    end
+
+    def provisioned_change(project, file)
+      destination = File.join(project.project_root, file.path)
+      change = if !File.exist?(destination)
+        "write"
+      elsif FileUtils.compare_file(destination, file.source)
+        "unchanged"
+      else
+        "update"
+      end
+      [file.path, change]
+    end
+  end
+end

data/lib/pray/project_context.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Pray
+  ENV_PROJECT_PATH = "PRAY_PATH"
+  ENV_MANIFEST_PATH = "PRAY_FILE_PATH"
+  ENV_ENVIRONMENT = "PRAY_ENV"
+
+  ProjectInvocationContext = Struct.new(:project_root, :manifest_path, :environment) do
+    def lockfile_path
+      File.join(project_root, "Prayfile.lock")
+    end
+  end
+
+  ProjectInvocationOptions = Struct.new(:project_root, :manifest_path, :environment)
+
+  module ProjectContext
+    module_function
+
+    def from_current_directory
+      from_options(ProjectInvocationOptions.new)
+    end
+
+    def from_options(options)
+      cwd = Dir.pwd
+      dotenv = Dotenv.load_dotenv_variables(cwd)
+      project_root_hint = options.project_root ||
+        env_value(ENV_PROJECT_PATH) ||
+        dotenv[ENV_PROJECT_PATH] ||
+        cwd
+      project_root = canonicalize_path(cwd, project_root_hint)
+      manifest_hint = options.manifest_path ||
+        env_value(ENV_MANIFEST_PATH) ||
+        dotenv[ENV_MANIFEST_PATH] ||
+        "Prayfile"
+      manifest_path = if Pathname(manifest_hint).absolute?
+        canonicalize_path(cwd, manifest_hint)
+      else
+        canonicalize_path(project_root, manifest_hint)
+      end
+      environment = (options.environment || env_value(ENV_ENVIRONMENT) || dotenv[ENV_ENVIRONMENT])&.strip
+      environment = nil if environment.nil? || environment.empty?
+
+      ProjectInvocationContext.new(
+        project_root: project_root,
+        manifest_path: manifest_path,
+        environment: environment
+      )
+    end
+
+    def env_value(key)
+      value = ENV[key]
+      return nil if value.nil? || value.strip.empty?
+
+      value
+    end
+
+    def canonicalize_path(base, path)
+      resolved = Pathname(path).absolute? ? Pathname(path) : Pathname(base).join(path)
+      resolved = resolved.expand_path
+      resolved.exist? ? resolved.realpath.to_s : resolved.cleanpath.to_s
+    rescue
+      resolved.to_s
+    end
+  end
+end

data/lib/pray/publish.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+
+module Pray
+  RegistryIndex = Struct.new(:spec, :packages) do
+    def initialize(spec: "prayfile-distribution-1", packages: [])
+      super
+    end
+  end
+
+  module Publish
+    module_function
+
+    def publish_to_root(project, root, signer: "local", signer_fingerprint: nil)
+      root = File.expand_path(root)
+      index = load_registry_index(root)
+      package_names = index.packages.to_set
+
+      project.packages.each do |package|
+        archive_bytes = Archive.build_package_archive_bytes(package)
+        artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
+        artifact_output_path = File.join(root, artifact_path)
+        write_output_bytes(artifact_output_path, archive_bytes)
+
+        metadata_path = registry_metadata_path(root, package.declaration.name)
+        metadata = load_registry_package_metadata(metadata_path, package.declaration.name)
+        version_entry = published_registry_package_version(
+          package,
+          signer,
+          signer_fingerprint,
+          archive_bytes,
+          artifact_path
+        )
+        metadata.versions.reject! { |entry| entry.version == version_entry.version }
+        metadata.versions << version_entry
+        write_registry_package_metadata(metadata_path, metadata)
+        package_names << package.declaration.name
+      end
+
+      index.packages = package_names.sort
+      write_registry_index(root, index)
+    end
+
+    def publish_to_server(project, server_url, signer: "local", signer_fingerprint: nil)
+      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)
+
+        metadata = RegistryPackageMetadata.new(
+          name: package.declaration.name,
+          versions: [
+            published_registry_package_version(
+              package,
+              signer,
+              signer_fingerprint,
+              archive_bytes,
+              artifact_path
+            )
+          ]
+        )
+        Registry.http_put(
+          join_url(server_url, "v1/packages/#{package.declaration.name}.json"),
+          "application/json",
+          JSON.pretty_generate(metadata_to_hash(metadata))
+        )
+      end
+    end
+
+    def published_registry_package_version(package, signer, signer_fingerprint, archive_bytes, artifact_path)
+      RegistryPackageVersion.new(
+        version: package.spec.version,
+        artifact: artifact_path,
+        artifact_hash: Hashing.sha256_prefixed(archive_bytes),
+        tree_hash: package.tree_hash,
+        yanked: false,
+        targets: package.spec.targets,
+        exports: package.spec.exports.keys,
+        signer: signer,
+        signer_fingerprint: signer_fingerprint,
+        published_at: Time.now.utc.iso8601,
+        signature: Registry.registry_artifact_signature(archive_bytes, package.tree_hash, signer)
+      )
+    end
+
+    def load_registry_index(root)
+      path = File.join(root, "v1", "index.json")
+      return RegistryIndex.new unless File.exist?(path)
+
+      data = JSON.parse(File.read(path))
+      RegistryIndex.new(spec: data["spec"], packages: data["packages"] || [])
+    end
+
+    def write_registry_index(root, index)
+      path = File.join(root, "v1", "index.json")
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate({"spec" => index.spec, "packages" => index.packages}))
+    end
+
+    def load_registry_package_metadata(path, package_name)
+      if File.exist?(path)
+        data = JSON.parse(File.read(path))
+        RegistryPackageMetadata.new(
+          name: data["name"],
+          versions: Array(data["versions"]).map { |entry| Registry.version_from_hash(entry) }
+        )
+      else
+        RegistryPackageMetadata.new(name: package_name, versions: [])
+      end
+    end
+
+    def write_registry_package_metadata(path, metadata)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(metadata_to_hash(metadata)))
+    end
+
+    def metadata_to_hash(metadata)
+      {
+        "name" => metadata.name,
+        "versions" => metadata.versions.map { |entry| version_to_hash(entry) }
+      }
+    end
+
+    def version_to_hash(entry)
+      hash = {
+        "version" => entry.version,
+        "artifact" => entry.artifact,
+        "yanked" => entry.yanked,
+        "targets" => entry.targets,
+        "exports" => entry.exports
+      }
+      hash["artifact_hash"] = entry.artifact_hash if entry.artifact_hash
+      hash["tree_hash"] = entry.tree_hash if entry.tree_hash
+      hash["signer"] = entry.signer if entry.signer
+      hash["signer_fingerprint"] = entry.signer_fingerprint if entry.signer_fingerprint
+      hash["published_at"] = entry.published_at if entry.published_at
+      hash["signature"] = entry.signature if entry.signature
+      hash
+    end
+
+    def registry_metadata_path(root, package_name)
+      File.join(root, "v1", "packages", "#{package_name}.json")
+    end
+
+    def registry_artifact_path(package_name, version)
+      artifact_name = "#{package_name.tr("/", "-")}-#{version}.praypkg"
+      "v1/artifacts/#{package_name}/#{version}/#{artifact_name}"
+    end
+
+    def write_output_bytes(path, bytes)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.binwrite(path, bytes)
+    end
+
+    def join_url(base, path)
+      Registry.join_url(base, path)
+    end
+  end
+end