pray-cli 1.6.0

data/lib/pray/lockfile_serialize.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Pray
+  module LockfileSerialize
+    module_function
+
+    def lockfile_to_toml(lockfile)
+      serialize_lockfile_text(lockfile.canonicalized)
+    end
+
+    def serialize_lockfile_text(lockfile)
+      lines = [
+        "prayfile_lock = #{format_string(lockfile.prayfile_lock)}",
+        "spec = #{format_string(lockfile.spec)}",
+        "generated_by = #{format_string(lockfile.generated_by)}",
+        "manifest_hash = #{format_string(lockfile.manifest_hash)}"
+      ]
+      lines << "environment = #{format_string(lockfile.environment)}" if lockfile.environment
+      lines << ""
+
+      lockfile.source.each { |entry| append_section(lines, format_source(entry)) }
+      lockfile.package.each { |entry| append_section(lines, format_package(entry)) }
+      lockfile.target.each { |entry| append_section(lines, format_target(entry)) }
+      lockfile.managed_span.each { |entry| append_section(lines, format_managed_span(entry)) }
+
+      lines.pop while lines.last == ""
+      "#{lines.join("\n")}\n"
+    end
+
+    def append_section(lines, section_lines)
+      return if section_lines.empty?
+
+      lines.concat(section_lines, [""])
+    end
+
+    def format_source(entry)
+      lines = ["[[source]]"]
+      scalars = [
+        ["name", entry.name],
+        ["kind", entry.kind],
+        ["url", entry.url]
+      ]
+      scalars << ["revision", entry.revision] if entry.revision
+      scalars << ["host_key_fingerprint", entry.host_key_fingerprint] if entry.host_key_fingerprint
+      append_scalars(lines, scalars)
+      lines
+    end
+
+    def format_package(entry)
+      lines = ["[[package]]"]
+      scalars = [
+        ["name", entry.name],
+        ["version", entry.version]
+      ]
+      scalars << ["source", entry.source] unless entry.source.nil?
+      scalars.concat(
+        [
+          ["path", entry.path],
+          ["tree_hash", entry.tree_hash],
+          ["artifact_hash", entry.artifact_hash],
+          ["artifact", entry.artifact]
+        ]
+      )
+      append_scalars(lines, scalars)
+      lines << "exports = #{format_string_array(entry.exports)}"
+      lines << "dependencies = #{format_string_array(entry.dependencies)}"
+      lines << "signer_fingerprint = #{format_string(entry.signer_fingerprint)}" if entry.signer_fingerprint
+      lines
+    end
+
+    def format_target(entry)
+      lines = ["[[target]]"]
+      append_scalars(lines, [["name", entry.name]])
+      lines << "outputs = #{format_string_array(entry.outputs)}"
+      lines
+    end
+
+    def format_managed_span(entry)
+      lines = ["[[managed_span]]"]
+      append_scalars(
+        lines,
+        [
+          ["id", entry.id],
+          ["target", entry.target],
+          ["open_line", entry.open_line],
+          ["close_line", entry.close_line],
+          ["ideal_checksum", entry.ideal_checksum],
+          ["package", entry.package],
+          ["export", entry.export],
+          ["source_checksum", entry.source_checksum],
+          ["silenced", entry.silenced]
+        ]
+      )
+      lines
+    end
+
+    def append_scalars(lines, entries)
+      entries.each do |key, value|
+        lines << case value
+        when String
+          "#{key} = #{format_string(value)}"
+        when Integer
+          "#{key} = #{value}"
+        when TrueClass, FalseClass
+          "#{key} = #{value}"
+        else
+          raise ArgumentError, "unsupported lockfile scalar type for #{key}"
+        end
+      end
+    end
+
+    def format_string(value)
+      escaped = value.gsub("\\", "\\\\").gsub("\"", "\\\"")
+      "\"#{escaped}\""
+    end
+
+    def format_string_array(values)
+      return "[]" if values.empty?
+      return "[#{format_string(values.first)}]" if values.length == 1
+
+      items = values.map { |value| "    #{format_string(value)}" }.join(",\n")
+      "[\n#{items},\n]"
+    end
+  end
+end

data/lib/pray/manifest.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "manifest_json"
+require_relative "manifest_formatter"
+require_relative "manifest_parser_helpers"
+require_relative "manifest_parser_blocks"
+require_relative "manifest_parser"
+
+module Pray
+  RenderPolicy = Struct.new(
+    :mode, :conflict, :churn, :header, :section_markers, :line_endings
+  ) do
+    def self.default
+      new(
+        mode: "managed",
+        conflict: "fail",
+        churn: "minimal",
+        header: true,
+        section_markers: true,
+        line_endings: "lf"
+      )
+    end
+  end
+
+  ManifestSource = Struct.new(:name, :kind, :url, :subdir, :rev, :tag)
+  ManifestTarget = Struct.new(
+    :name, :outputs, :skills, :commands, :rules, :max_bytes, :mode, :scoped, :entries
+  ) do
+    def initialize(
+      name:, outputs: [], skills: [], commands: [], rules: [], max_bytes: nil,
+      mode: "legacy", scoped: false, entries: []
+    )
+      super
+    end
+  end
+
+  ManifestPackage = Struct.new(
+    :name, :constraint, :source, :exports, :targets, :features, :groups, :optional,
+    :path, :git, :tag, :rev, :tarball, :oci, :file, :roles, :bound
+  ) do
+    def initialize(
+      name:, constraint: "*", source: nil, exports: [], targets: [], features: [], groups: [],
+      optional: false, path: nil, git: nil, tag: nil, rev: nil, tarball: nil, oci: nil,
+      file: nil, roles: [], bound: false
+    )
+      super
+    end
+  end
+
+  ManifestLocal = Struct.new(:path, :position, :optional, :bound) do
+    def initialize(path:, position: "after", optional: false, bound: false)
+      super
+    end
+  end
+
+  Manifest = Struct.new(
+    :prayfile_version, :sources, :targets, :packages, :local, :symbols, :render,
+    :deprecated_keywords,
+    keyword_init: true
+  ) do
+    def initialize(
+      prayfile_version: "",
+      sources: [],
+      targets: [],
+      packages: [],
+      local: [],
+      symbols: {},
+      render: RenderPolicy.default,
+      deprecated_keywords: []
+    )
+      super
+    end
+
+    def note_deprecated_keyword(keyword)
+      return unless %w[target output agent].include?(keyword)
+      self.deprecated_keywords ||= []
+      deprecated_keywords << keyword unless deprecated_keywords.include?(keyword)
+    end
+
+    def deprecation_warnings
+      replacements = {
+        "target" => "compose` / `tree",
+        "output" => "compose",
+        "agent" => "pray"
+      }
+      (deprecated_keywords || []).filter_map do |keyword|
+        replacement = replacements[keyword]
+        next unless replacement
+
+        "warning: `#{keyword}` is deprecated and will be removed in version 2; prefer `#{replacement}`"
+      end
+    end
+
+    def canonicalized
+      dup.tap do |copy|
+        copy.sources = sources.sort_by(&:name)
+        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.deprecated_keywords = []
+      end
+    end
+
+    def manifest_hash
+      bytes = ManifestJson.encode_compact(canonicalized)
+      Hashing.sha256_prefixed(bytes)
+    end
+  end
+
+  module ManifestMethods
+    module_function
+
+    def read_manifest_text(manifest_path)
+      File.read(manifest_path)
+    rescue Errno::ENOENT
+      raise Error.manifest("missing #{manifest_path}; run pray init to create one")
+    end
+
+    def parse_manifest(text)
+      lines = Literal.prepare_parser_lines(text)
+      BlockParser.new(lines).parse_root
+    end
+  end
+
+  extend ManifestMethods
+end

data/lib/pray/manifest_formatter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestMethods
+    module_function
+
+    def format_package_declaration(package)
+      parts = ["pray \"#{package.name}\""]
+      parts << "\"#{package.constraint}\"" unless package.constraint == "*"
+      parts << "path: \"#{package.path}\"" if package.path
+      parts << "source: \"#{package.source}\"" if package.source
+      parts << "git: \"#{package.git}\"" if package.git
+      parts << "tag: \"#{package.tag}\"" if package.tag
+      parts << "rev: \"#{package.rev}\"" if package.rev
+      parts << "tarball: \"#{package.tarball}\"" if package.tarball
+      parts << "oci: \"#{package.oci}\"" if package.oci
+      parts << "file: \"#{package.file}\"" if package.file
+      unless package.exports.empty?
+        parts << if package.exports.length == 1
+          "export: \"#{package.exports.first}\""
+        else
+          "exports: [#{format_string_keyword_list(package.exports)}]"
+        end
+      end
+      parts << "targets: [#{format_string_keyword_list(package.targets)}]" unless package.targets.empty?
+      parts << "features: [#{format_string_keyword_list(package.features)}]" unless package.features.empty?
+      parts << "optional: true" if package.optional
+      parts.join(", ")
+    end
+
+    def replace_package_declaration(text, package)
+      name = package.name
+      prefixes = [
+        "pray \"#{name}\"", "pray '#{name}'",
+        "use \"#{name}\"", "include \"#{name}\"",
+        "agent \"#{name}\"", "agent '#{name}'",
+        "package \"#{name}\"", "package '#{name}'"
+      ]
+      lines = text.lines.map(&:chomp)
+      index = lines.index { |line|
+        trimmed = line.lstrip
+        prefixes.any? { |prefix| trimmed.start_with?(prefix) }
+      }
+      raise Error.manifest("package #{name} not found in manifest") unless index
+
+      lines[index] = format_package_declaration(package)
+      output = lines.join("\n")
+      output += "\n" if text.end_with?("\n") && !output.end_with?("\n")
+      output
+    end
+
+    def format_string_keyword_list(values)
+      values.map { |value| "\"#{value}\"" }.join(", ")
+    end
+  end
+end

data/lib/pray/manifest_json.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestJson
+    module_function
+
+    def encode_compact(manifest)
+      encode_object(manifest_fields(manifest))
+    end
+
+    def manifest_fields(manifest)
+      fields = {
+        "prayfile_version" => manifest.prayfile_version,
+        "sources" => manifest.sources.map { |source| source_fields(source) },
+        "targets" => manifest.targets.map { |target| target_fields(target) },
+        "packages" => manifest.packages.map { |package| package_fields(package) },
+        "local" => manifest.local.map { |entry| local_fields(entry) },
+        "render" => render_fields(manifest.render)
+      }
+      fields["symbols"] = manifest.symbols.sort.to_h unless manifest.symbols.empty?
+      fields
+    end
+
+    def source_fields(source)
+      fields = {
+        "name" => source.name,
+        "kind" => source.kind,
+        "url" => source.url
+      }
+      fields["subdir"] = source.subdir if source.subdir
+      fields["rev"] = source.rev if source.rev
+      fields["tag"] = source.tag if source.tag
+      fields
+    end
+
+    def target_fields(target)
+      {
+        "name" => target.name,
+        "outputs" => target.outputs,
+        "skills" => target.skills,
+        "commands" => target.commands,
+        "rules" => target.rules,
+        "max_bytes" => target.max_bytes,
+        "mode" => target.mode || "legacy",
+        "scoped" => target.scoped || false,
+        "entries" => (target.entries || []).map { |entry| entry_fields(entry) }
+      }
+    end
+
+    def entry_fields(entry)
+      if entry.kind == "package"
+        {"kind" => "package", "name" => entry.name}
+      else
+        {"kind" => "local", "path" => entry.path}
+      end
+    end
+
+    def package_fields(package)
+      fields = {
+        "name" => package.name,
+        "constraint" => package.constraint,
+        "source" => package.source,
+        "exports" => package.exports,
+        "targets" => package.targets,
+        "features" => package.features,
+        "groups" => package.groups,
+        "optional" => package.optional,
+        "path" => package.path,
+        "git" => package.git,
+        "tag" => package.tag,
+        "rev" => package.rev,
+        "tarball" => package.tarball,
+        "oci" => package.oci
+      }
+      fields["file"] = package.file if package.file
+      fields["roles"] = package.roles unless package.roles.nil? || package.roles.empty?
+      fields["bound"] = true if package.bound
+      fields
+    end
+
+    def local_fields(entry)
+      fields = {
+        "path" => entry.path,
+        "position" => entry.position,
+        "optional" => entry.optional
+      }
+      fields["bound"] = true if entry.bound
+      fields
+    end
+
+    def render_fields(render)
+      {
+        "mode" => render.mode,
+        "conflict" => render.conflict,
+        "churn" => render.churn,
+        "header" => render.header,
+        "section_markers" => render.section_markers,
+        "line_endings" => render.line_endings
+      }
+    end
+
+    def encode_object(hash)
+      entries = hash.map { |key, value| "#{encode_string(key)}:#{encode_value(value)}" }
+      "{#{entries.join(",")}}"
+    end
+
+    def encode_array(array)
+      "[#{array.map { |value| encode_value(value) }.join(",")}]"
+    end
+
+    def encode_value(value)
+      case value
+      when Hash then encode_object(value)
+      when Array then encode_array(value)
+      when String then encode_string(value)
+      when TrueClass, FalseClass then value.to_s
+      when NilClass then "null"
+      when Integer then value.to_s
+      else
+        raise Error.manifest("unsupported JSON value: #{value.inspect}")
+      end
+    end
+
+    def encode_string(text)
+      "\"#{text.gsub("\\", "\\\\").gsub("\"", "\\\"").gsub("\n", "\\n").gsub("\r", "\\r").gsub("\t", "\\t")}\""
+    end
+  end
+end

data/lib/pray/manifest_parser.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestMethods
+    class BlockParser
+      include ParserHelpers
+      include ParserBlocks
+
+      def initialize(lines)
+        @lines = lines
+        @cursor = 0
+        @group_stack = []
+        @surface = StatementSurface::Reader.new
+      end
+
+      def parse_root
+        manifest = Manifest.new
+        while (statement = next_statement)
+          raise Error.parse("manifest", "unexpected 'end'") if statement == "end"
+
+          apply_statement(manifest, statement, false)
+        end
+        raise Error.manifest("missing prayfile version") if manifest.prayfile_version.empty?
+
+        manifest
+      end
+
+      def parse_nested(manifest, stop_on_end:)
+        while (statement = next_statement)
+          return if statement == "end" && stop_on_end
+          raise Error.parse("manifest", "unexpected 'end'") if statement == "end"
+
+          apply_statement(manifest, statement, true)
+        end
+        raise Error.parse("manifest", "missing 'end'") if stop_on_end
+      end
+
+      def apply_statement(manifest, statement, allow_target)
+        case statement
+        when /\Aprayfile (.+)\z/
+          manifest.prayfile_version = string_from_literal(Regexp.last_match(1))
+        when /\Asource (.+)\z/
+          manifest.sources << parse_source(Regexp.last_match(1))
+        when /\Atarget (.+)\z/
+          apply_legacy_target(manifest, statement, Regexp.last_match(1), allow_target)
+        when /\Agroup (.+)\z/
+          apply_group(manifest, Regexp.last_match(1))
+        when "pray do", "template do"
+          parse_symbols_block(manifest)
+        when /\A(?:compose|output) (.+)\z/
+          apply_compose_or_output(manifest, statement, Regexp.last_match(1))
+        when /\A(?:tree|folder|skills) (.+)\z/
+          apply_tree_or_folder(manifest, statement, Regexp.last_match(1))
+        when /\Afile (.+)\z/
+          parse_file_block(manifest, Regexp.last_match(1))
+        when /\Aagent (.+)\z/
+          apply_agent_package(manifest, Regexp.last_match(1))
+        when /\Apackage (.+)\z/
+          Destination.upsert_package(manifest, parse_package_with_groups(Regexp.last_match(1)))
+        when /\A(?:pray|use|include) (.+)\z/
+          apply_pray_statement(manifest, Regexp.last_match(1), nil)
+        when /\Alocal (.+)\z/
+          apply_unbound_local(manifest, Regexp.last_match(1))
+        when /\Arender (.+)\z/
+          manifest.render = parse_render_policy(Regexp.last_match(1))
+        else
+          raise Error.parse("manifest", "unrecognized statement: #{statement}")
+        end
+      end
+
+      def apply_legacy_target(manifest, statement, rest, allow_target)
+        raise Error.parse("manifest", "target must use a block") if !allow_target && !statement.end_with?(" do")
+
+        manifest.note_deprecated_keyword("target")
+        target, is_block = parse_target_header(rest)
+        manifest.targets << target
+        parse_target_block(manifest, manifest.targets.length - 1) if is_block
+      end
+
+      def apply_group(manifest, rest)
+        group_names, is_block = parse_group_header(rest)
+        raise Error.parse("manifest", "group must use a block") unless is_block
+        raise Error.parse("manifest", "nested group blocks are not supported") if @group_stack.any?
+
+        @group_stack.push(group_names)
+        parse_group_block(manifest)
+        @group_stack.pop
+      end
+
+      def apply_compose_or_output(manifest, statement, rest)
+        if statement.start_with?("output ")
+          unless statement.end_with?(" do")
+            raise Error.parse(
+              "manifest",
+              "top-level output must use a compose block (output \"path\" do ... end)"
+            )
+          end
+          manifest.note_deprecated_keyword("output")
+        end
+        parse_destination_block(manifest, rest, "compose")
+      end
+
+      def apply_tree_or_folder(manifest, statement, rest)
+        if statement.start_with?("folder ", "skills ") && !statement.end_with?(" do")
+          raise Error.parse("manifest", "top-level folder/skills must use a tree block")
+        end
+        parse_destination_block(manifest, rest, "tree")
+      end
+
+      def apply_agent_package(manifest, rest)
+        manifest.note_deprecated_keyword("agent")
+        Destination.upsert_package(manifest, parse_package_with_groups(rest))
+      end
+
+      def apply_unbound_local(manifest, rest)
+        local = parse_local_decl(rest)
+        local.bound = false
+        Destination.upsert_local(manifest, local)
+      end
+
+      def parse_package_with_groups(rest)
+        package = parse_package_decl(rest)
+        package.groups = @group_stack.last&.dup || []
+        package
+      end
+
+      def next_statement
+        pending = @surface.next
+        return pending if pending
+
+        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
+          @surface.push_raw(statement)
+          pending = @surface.next
+          return pending if pending
+        end
+        nil
+      end
+    end
+  end
+end