pray-cli 1.6.0

data/lib/pray/manifest_parser_blocks.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestMethods
+    module ParserBlocks
+      def parse_symbols_block(manifest)
+        while (statement = next_statement)
+          return if statement == "end"
+
+          assignment = StatementSurface.split_symbol_assignment(statement)
+          unless assignment
+            raise Error.parse(
+              "manifest",
+              "unsupported statement inside pray/template block: #{statement}"
+            )
+          end
+
+          key, value_literal = assignment
+          unless Substitute.pray_symbol_key?(key)
+            raise Error.parse("manifest", "invalid pray symbol key `#{key}`")
+          end
+          if manifest.symbols.key?(key)
+            raise Error.parse("manifest", "duplicate pray symbol `#{key}`")
+          end
+
+          manifest.symbols[key] = string_from_literal(value_literal)
+        end
+        raise Error.parse("manifest", "missing 'end' for pray/template block")
+      end
+
+      def parse_group_block(manifest)
+        while (statement = next_statement)
+          return if statement == "end"
+          if (match = statement.match(/\Aagent (.+)\z/))
+            manifest.note_deprecated_keyword("agent")
+            Destination.upsert_package(manifest, parse_package_with_groups(match[1]))
+          elsif (match = statement.match(/\A(?:package|pray|use|include) (.+)\z/))
+            Destination.upsert_package(manifest, parse_package_with_groups(match[1]))
+          elsif /\Agroup (.+)\z/.match?(statement)
+            raise Error.parse("manifest", "nested group blocks are not supported")
+          else
+            raise Error.parse(
+              "manifest",
+              "group blocks only support agent, package, or pray declarations: #{statement}"
+            )
+          end
+        end
+        raise Error.parse("manifest", "missing 'end' for group block")
+      end
+
+      def parse_destination_block(manifest, rest, mode)
+        unless rest.rstrip.end_with?("do")
+          label = (mode == "compose") ? "compose" : "tree"
+          raise Error.parse("manifest", "#{label} must use a block")
+        end
+
+        header = rest.sub(/\s*do\z/, "").strip
+        values, = parse_call(header)
+        raise Error.parse("manifest", "destination missing path") if values.empty?
+
+        path = string_from_value(values.first)
+        manifest.targets << Destination.new_destination_target(mode, path)
+        index = manifest.targets.length - 1
+        parse_destination_body(manifest, index, mode)
+      end
+
+      def parse_destination_body(manifest, index, mode)
+        while (statement = next_statement)
+          return if statement == "end"
+
+          apply_destination_statement(manifest, statement, index, mode)
+        end
+        raise Error.parse("manifest", "missing 'end' for destination block")
+      end
+
+      def apply_destination_statement(manifest, statement, index, mode)
+        if (match = statement.match(/\Aagent (.+)\z/))
+          manifest.note_deprecated_keyword("agent")
+          apply_pray_statement(manifest, match[1], index)
+          return
+        end
+        if (match = statement.match(/\A(?:pray|use|include|package) (.+)\z/))
+          apply_pray_statement(manifest, match[1], index)
+          return
+        end
+        if mode == "compose" && (match = statement.match(/\Alocal (.+)\z/))
+          bind_compose_local(manifest, index, match[1])
+          return
+        end
+        raise Error.parse("manifest", "unsupported statement inside destination block: #{statement}")
+      end
+
+      def bind_compose_local(manifest, index, rest)
+        local = parse_local_decl(rest)
+        local.bound = true
+        Destination.bind_local_entry(manifest.targets[index], local.path)
+        Destination.upsert_local(manifest, local)
+      end
+
+      def parse_file_block(manifest, rest)
+        unless rest.rstrip.end_with?("do")
+          raise Error.parse("manifest", "file must use a block (or use pray ..., file: \"path\")")
+        end
+
+        header = rest.sub(/\s*do\z/, "").strip
+        values, = parse_call(header)
+        raise Error.parse("manifest", "file block missing path") if values.empty?
+
+        parse_file_body(manifest, string_from_value(values.first))
+      end
+
+      def parse_file_body(manifest, file_path)
+        saw_package = false
+        while (statement = next_statement)
+          if statement == "end"
+            unless saw_package
+              raise Error.parse("manifest", "file block requires a pray package declaration")
+            end
+            return
+          end
+          saw_package = true if apply_file_body_statement(manifest, statement, file_path)
+        end
+        raise Error.parse("manifest", "missing 'end' for file block")
+      end
+
+      def apply_file_body_statement(manifest, statement, file_path)
+        if (match = statement.match(/\Aagent (.+)\z/))
+          manifest.note_deprecated_keyword("agent")
+          bind_file_package(manifest, match[1], file_path)
+          return true
+        end
+        if (match = statement.match(/\A(?:pray|use|include|package) (.+)\z/))
+          bind_file_package(manifest, match[1], file_path)
+          return true
+        end
+        raise Error.parse("manifest", "unsupported statement inside file block: #{statement}")
+      end
+
+      def bind_file_package(manifest, rest, file_path)
+        package = parse_package_with_groups(rest)
+        if package.file
+          raise Error.parse("manifest", "file: keyword is invalid inside a file block")
+        end
+        package.file = file_path
+        package.bound = true
+        package.roles << "file" unless package.roles.include?("file")
+        Destination.upsert_package(manifest, package)
+      end
+
+      def apply_pray_statement(manifest, rest, destination_index)
+        values, keywords = parse_call(rest)
+        raise Error.parse("manifest", "pray missing package or path") if values.empty?
+
+        first = string_from_value(values.first)
+        return if apply_local_pray_path(manifest, first, keywords, values, destination_index)
+
+        package = parse_package_with_groups(rest)
+        bind_pray_package(manifest, package, destination_index)
+      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
+      end
+
+      def package_signal?(values, keywords)
+        return true if values.length > 1
+
+        %w[source export exports file optional path git tag rev tarball oci targets features]
+          .any? { |key| keywords.key?(key) }
+      end
+
+      def bind_pray_package(manifest, package, destination_index)
+        if package.file
+          if destination_index
+            raise Error.parse("manifest", "file: is mutually exclusive with compose/tree nesting")
+          end
+          package.bound = true
+          package.roles << "file" unless package.roles.include?("file")
+        end
+        if destination_index
+          mode = manifest.targets[destination_index].mode
+          package.bound = true
+          role = Destination.role_for_destination(mode)
+          package.roles << role if role && !package.roles.include?(role)
+          Destination.bind_package_entry(manifest.targets[destination_index], package.name)
+        end
+        Destination.upsert_package(manifest, package)
+      end
+
+      def parse_target_block(manifest, target_index)
+        while (statement = next_statement)
+          return if statement == "end"
+
+          target = manifest.targets[target_index]
+          raise Error.manifest("target index out of range") unless target
+
+          manifest.note_deprecated_keyword("output") if statement.start_with?("output ")
+          apply_target_statement(target, statement)
+        end
+        raise Error.parse("manifest", "missing 'end' for target block")
+      end
+    end
+  end
+end

data/lib/pray/manifest_parser_helpers.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Pray
+  module ManifestMethods
+    module ParserHelpers
+      module_function
+
+      def parse_call(rest)
+        positional = []
+        keywords = {}
+        Literal.split_top_level(rest.strip.sub(/,\z/, ""), ",").each do |segment|
+          if (keyword = parse_keyword_segment(segment))
+            keywords[keyword[0]] = keyword[1]
+          elsif !segment.empty?
+            positional << Literal.parse_literal(segment)
+          end
+        end
+        [positional, keywords]
+      end
+
+      def parse_keyword_segment(segment)
+        if (index = Literal.find_top_level(segment, "=>"))
+          key = string_from_literal(segment[0...index].strip)
+          return [key, Literal.parse_literal(segment[(index + 2)..].strip)]
+        end
+        if (index = Literal.find_top_level(segment, ":"))
+          left = segment[0...index].strip
+          right = segment[(index + 1)..].strip
+          return nil if left.empty?
+
+          return [left.delete_prefix(":"), Literal.parse_literal(right)]
+        end
+        nil
+      end
+
+      def keyword_array(keywords, key)
+        keywords[key]&.as_array&.filter_map(&:as_string) || []
+      end
+
+      def string_from_value(value)
+        text = value.as_string
+        raise Error.parse("manifest", "expected string-like literal, found #{value.inspect}") unless text
+
+        text
+      end
+
+      def string_from_literal(input)
+        string_from_value(Literal.parse_literal(input))
+      end
+
+      def parse_source(rest)
+        values, keywords = parse_call(rest)
+        raise Error.parse("manifest", "source requires a name") if values.empty?
+        if values.length < 2 && !keywords.key?("path") && !keywords.key?("git")
+          raise Error.parse("manifest", "source requires a name and url, path:, or git:")
+        end
+
+        kind, url = source_kind_and_url(values, keywords)
+        ManifestSource.new(
+          name: string_from_value(values.first),
+          kind: kind,
+          url: url,
+          subdir: keyword_string(keywords, "subdir") || keyword_string(keywords, "distribution"),
+          rev: keyword_string(keywords, "rev"),
+          tag: keyword_string(keywords, "tag")
+        )
+      end
+
+      def source_kind_and_url(values, keywords)
+        if keywords["path"]
+          return ["path", string_from_value(keywords["path"])]
+        end
+        if keywords["git"]
+          url = string_from_value(keywords["git"])
+          url = "git+#{url}" unless url.start_with?("git+")
+          return ["git", url]
+        end
+
+        url = string_from_value(values[1])
+        [infer_source_kind(url), url]
+      end
+
+      def infer_source_kind(url)
+        return "git" if url.start_with?("git+")
+        return "pray_ssh" if url.start_with?("pray+ssh://", "ssh+pray://")
+
+        "registry"
+      end
+
+      def keyword_string(keywords, key)
+        keywords[key]&.then { |value| string_from_value(value) }
+      end
+
+      def parse_target_header(rest)
+        is_block = rest.rstrip.end_with?("do")
+        header = rest.sub(/\s*do\z/, "").strip
+        values, keywords = parse_call(header)
+        name = string_from_value(values.first)
+        outputs = keyword_array(keywords, "output")
+        folders = keyword_array(keywords, "folder") + keyword_array(keywords, "skills")
+        target = ManifestTarget.new(
+          name: name,
+          outputs: outputs,
+          skills: folders,
+          commands: keyword_array(keywords, "commands"),
+          rules: keyword_array(keywords, "rules"),
+          max_bytes: keywords["max_bytes"]&.as_integer
+        )
+        [target, is_block]
+      end
+
+      def parse_group_header(rest)
+        is_block = rest.rstrip.end_with?("do")
+        header = rest.sub(/\s*do\z/, "").strip
+        values, = parse_call(header)
+        raise Error.parse("manifest", "group missing name") if values.empty?
+
+        names = values.map { |value| string_from_value(value) }
+        [names, is_block]
+      end
+
+      def parse_package_decl(rest)
+        values, keywords = parse_call(rest)
+        raise Error.parse("manifest", "agent missing name") if values.empty?
+
+        file = keywords["file"]&.as_string
+        ManifestPackage.new(
+          name: string_from_value(values[0]),
+          constraint: package_constraint(values),
+          source: keywords["source"]&.as_string,
+          exports: package_exports(keywords),
+          targets: keyword_array(keywords, "targets"),
+          features: keyword_array(keywords, "features"),
+          optional: keywords["optional"]&.as_bool || false,
+          path: keywords["path"]&.as_string,
+          git: keywords["git"]&.as_string,
+          tag: keywords["tag"]&.as_string,
+          rev: keywords["rev"]&.as_string,
+          tarball: keywords["tarball"]&.as_string,
+          oci: keywords["oci"]&.as_string,
+          file: file,
+          roles: file ? ["file"] : [],
+          bound: false
+        )
+      end
+
+      def package_constraint(values)
+        return "*" unless values[1]
+
+        Constraint.normalize_version_constraint(string_from_value(values[1]))
+      end
+
+      def package_exports(keywords)
+        exports = keyword_array(keywords, "exports")
+        if (export = keywords["export"]&.as_string)
+          exports << export unless exports.include?(export)
+        end
+        exports
+      end
+
+      def parse_local_decl(rest)
+        values, keywords = parse_call(rest)
+        ManifestLocal.new(
+          path: string_from_value(values.first),
+          position: keywords["position"]&.as_string || keywords["at"]&.as_string || "after",
+          optional: keywords["optional"]&.as_bool || false,
+          bound: false
+        )
+      end
+
+      def parse_render_policy(rest)
+        _, keywords = parse_call(rest)
+        RenderPolicy.new(
+          mode: keywords["mode"]&.as_string || "managed",
+          conflict: keywords["conflict"]&.as_string || "fail",
+          churn: keywords["churn"]&.as_string || "minimal",
+          header: keyword_bool(keywords, "header", true),
+          section_markers: keyword_bool(keywords, "section_markers", true),
+          line_endings: keywords["line_endings"]&.as_string || "lf"
+        )
+      end
+
+      def keyword_bool(keywords, key, default)
+        value = keywords[key]
+        return default if value.nil?
+
+        value.as_bool
+      end
+
+      def apply_target_statement(target, statement)
+        case statement
+        when /\Aoutput (.+)\z/
+          target.outputs << string_from_literal(Regexp.last_match(1))
+        when /\Afolder (.+)\z/, /\Askills (.+)\z/
+          target.skills << string_from_literal(Regexp.last_match(1))
+        when /\Acommands (.+)\z/
+          target.commands << string_from_literal(Regexp.last_match(1))
+        when /\Arules (.+)\z/
+          target.rules << string_from_literal(Regexp.last_match(1))
+        when /\Amax_bytes (.+)\z/
+          target.max_bytes = Literal.parse_literal(Regexp.last_match(1).strip).as_integer
+        else
+          raise Error.parse("manifest", "unrecognized target statement: #{statement}")
+        end
+      end
+    end
+  end
+end

data/lib/pray/materialize.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Pray
+  module Materialize
+    module_function
+
+    def materialize_project(
+      manifest_path: nil,
+      frozen: false,
+      locked: false,
+      offline: false,
+      refresh: false
+    )
+      context = Invocation.invocation_context
+      manifest_path = File.expand_path(manifest_path || context.manifest_path)
+      unless File.exist?(manifest_path)
+        raise Error.manifest("missing #{manifest_path}")
+      end
+
+      project_root = context.project_root
+      options = ResolveOptions.new(
+        offline: offline,
+        refresh: refresh,
+        environment: context.environment
+      )
+      allow_git_refresh_fallback = !locked && !frozen
+      project = begin
+        Resolve.resolve_project_in_context(manifest_path, project_root, options)
+      rescue Error => error
+        if allow_git_refresh_fallback &&
+            !offline &&
+            !refresh &&
+            Resolve.resolution_may_benefit_from_git_source_refresh?(error)
+          refreshed = options.dup
+          refreshed.refresh = true
+          Resolve.resolve_project_in_context(manifest_path, project_root, refreshed)
+        else
+          raise
+        end
+      end
+      rendered = Render.render_project(project)
+      lockfile_path = default_lockfile_path(project.project_root)
+      next_lockfile = LockfileIO.build_lockfile(
+        project.manifest_hash,
+        project.environment,
+        project.project_root,
+        project.manifest.sources,
+        project.manifest.targets,
+        rendered,
+        project.packages,
+        project.source_revisions,
+        project.source_host_keys
+      )
+
+      if locked
+        unless File.exist?(lockfile_path)
+          raise Error.verify("missing Prayfile.lock; run install first")
+        end
+        existing = Pray.read_lockfile(lockfile_path)
+        unless Pray.lockfiles_equivalent?(existing, next_lockfile)
+          raise Error.verify("lockfile needs update; rerun install to refresh Prayfile.lock")
+        end
+        unless frozen
+          Render.write_rendered_targets(project, rendered)
+        end
+        if frozen
+          rendered.each do |target|
+            path = File.join(project.project_root, target.path)
+            on_disk = File.read(path)
+            if on_disk != target.content
+              raise Error.render(
+                "#{path} is stale; rerun install to regenerate it or plan to inspect the diff"
+              )
+            end
+          end
+        end
+        return
+      end
+
+      if frozen
+        existing = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+        if existing
+          rendered.each do |target|
+            output_path = File.join(project.project_root, target.path)
+            unless File.exist?(output_path)
+              raise Error.verify("Rendered file #{target.path} is missing under frozen mode")
+            end
+          end
+        end
+      end
+
+      Pray.write_lockfile_if_changed(lockfile_path, next_lockfile)
+      Render.write_rendered_targets(project, rendered)
+    end
+
+    def default_manifest_path(working_directory = Dir.pwd)
+      File.join(working_directory, "Prayfile")
+    end
+
+    def default_lockfile_path(project_root)
+      File.join(project_root, "Prayfile.lock")
+    end
+
+    def project_root_from_manifest(manifest_path)
+      Resolve.project_root_from_manifest(manifest_path)
+    end
+  end
+
+  module_function
+
+  def materialize_project(...) = Materialize.materialize_project(...)
+  def default_manifest_path(...) = Materialize.default_manifest_path(...)
+  def default_lockfile_path(...) = Materialize.default_lockfile_path(...)
+  def project_root_from_manifest(...) = Materialize.project_root_from_manifest(...)
+  def resolve_project(...) = Resolve.resolve_project(...)
+  def render_project(...) = Render.render_project(...)
+  def inspect_project(...) = Verify.inspect_project(...)
+  def verify_project(...) = Verify.verify_project(...)
+  def drift_project(...) = Verify.drift_project(...)
+end