textus 0.20.2 → 0.26.0

data/lib/textus/application/read/rdeps.rb

@@ -0,0 +1,35 @@
+module Textus
+  module Application
+    module Read
+      module Rdeps
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(caps:)
+            @manifest = caps.manifest
+          end
+
+          def call(key)
+            @manifest.data.entries.each_with_object([]) do |e, acc|
+              next unless e.is_a?(Textus::Manifest::Entry::Derived)
+
+              src = e.source
+              sources = if src.is_a?(Textus::Manifest::Entry::Derived::Projection)
+                          Array(src.select).compact
+                        elsif src.is_a?(Textus::Manifest::Entry::Derived::External)
+                          Array(src.sources).compact
+                        else
+                          []
+                        end
+              acc << e.key if sources.any? { |s| s == key || key.start_with?("#{s}.") }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:rdeps, Textus::Application::Read::Rdeps, caps: :read)

data/lib/textus/application/read/schema_envelope.rb

@@ -0,0 +1,26 @@
+module Textus
+  module Application
+    module Read
+      module SchemaEnvelope
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(caps:)
+            @manifest = caps.manifest
+            @schemas  = caps.schemas
+          end
+
+          def call(key)
+            mentry = @manifest.resolver.resolve(key).entry
+            schema = @schemas.fetch_or_nil(mentry.schema)
+            { "protocol" => PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:schema_envelope, Textus::Application::Read::SchemaEnvelope, caps: :read)

data/lib/textus/application/read/stale.rb

@@ -0,0 +1,23 @@
+module Textus
+  module Application
+    module Read
+      module Stale
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(caps:)
+            @manifest = caps.manifest
+          end
+
+          def call(prefix: nil, zone: nil)
+            Textus::Domain::Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:stale, Textus::Application::Read::Stale, caps: :read)

data/lib/textus/application/read/uid.rb

@@ -0,0 +1,30 @@
+module Textus
+  module Application
+    module Read
+      module Uid
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(ctx: ctx, caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(ctx:, caps:)
+            @ctx = ctx
+            @caps = caps
+          end
+
+          def call(key)
+            get.get(key).uid
+          end
+
+          private
+
+          def get
+            @get ||= Get::Impl.new(ctx: @ctx, caps: @caps)
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:uid, Textus::Application::Read::Uid, caps: :read)

data/lib/textus/application/read/validate_all.rb

@@ -0,0 +1,32 @@
+module Textus
+  module Application
+    module Read
+      module ValidateAll
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(ctx: ctx, caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(ctx:, caps:)
+            @ctx = ctx
+            @caps = caps
+            @manifest  = caps.manifest
+            @schemas   = caps.schemas
+            @audit_log = caps.audit_log
+          end
+
+          def call
+            Validator.new(
+              reader: Get::Impl.new(ctx: @ctx, caps: @caps),
+              manifest: @manifest,
+              audit_log: @audit_log,
+              schema_for: ->(name) { @schemas.fetch_or_nil(name) },
+            ).call
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:validate_all, Textus::Application::Read::ValidateAll, caps: :read)

data/lib/textus/application/{reads → read}/validator.rb

@@ -1,6 +1,6 @@
 module Textus
   module Application
-    module Reads
+    module Read
       class Validator
         def initialize(reader:, manifest:, audit_log:, schema_for:)
           @reader = reader
@@ -55,7 +55,7 @@ module Textus
           last_writer = @audit_log.last_writer_for(key)
           return if last_writer.nil?
 
-          last_writer_is_authority = @manifest.role_kind(last_writer) == :accept_authority
+          last_writer_is_authority = @manifest.policy.role_kind(last_writer) == :accept_authority
 
           env.meta.each_key do |field|
             owner = schema.maintained_by(field)

data/lib/textus/application/read/where.rb

@@ -0,0 +1,26 @@
+module Textus
+  module Application
+    module Read
+      module Where
+        def self.call(*, session:, ctx:, caps:, **) # rubocop:disable Lint/UnusedMethodArgument
+          Impl.new(caps: caps).call(*, **)
+        end
+
+        class Impl
+          def initialize(caps:)
+            @manifest = caps.manifest
+          end
+
+          def call(key)
+            res = @manifest.resolver.resolve(key)
+            mentry = res.entry
+            path = res.path
+            { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:where, Textus::Application::Read::Where, caps: :read)

data/lib/textus/application/use_case.rb

@@ -0,0 +1,22 @@
+module Textus
+  module Application
+    # Registry mapping verb symbols to use-case modules. Each entry says
+    # which caps slice the use case needs (:read or :write); Session
+    # uses this to define one method per verb.
+    module UseCase
+      Entry = Data.define(:verb, :mod, :caps_kind)
+
+      @entries = []
+
+      class << self
+        attr_reader :entries
+
+        def register(verb, mod, caps:)
+          @entries << Entry.new(verb: verb.to_sym, mod: mod, caps_kind: caps.to_sym)
+        end
+
+        def each(&) = @entries.each(&)
+      end
+    end
+  end
+end

data/lib/textus/application/write/accept.rb

@@ -0,0 +1,102 @@
+require_relative "authority_gate"
+
+module Textus
+  module Application
+    module Write
+      module Accept
+        def self.call(*, session:, ctx:, caps:, **)
+          Impl.new(
+            ctx: ctx, caps: caps,
+            writer: session.envelope_writer,
+            hook_context: session.hook_context
+          ).call(*, **)
+        end
+
+        class Impl
+          include AuthorityGate
+
+          def initialize(ctx:, caps:, writer:, hook_context:)
+            @ctx          = ctx
+            @caps         = caps
+            @manifest     = caps.manifest
+            @file_store   = caps.file_store
+            @schemas      = caps.schemas
+            @writer       = writer
+            @events       = caps.events
+            @authorizer   = caps.authorizer
+            @hook_context = hook_context
+          end
+
+          def call(pending_key)
+            assert_accept_authority!("accept")
+
+            env = Textus::Application::Read::Get::Impl.new(
+              ctx: @ctx, caps: @caps,
+            ).call(pending_key)
+            proposal = env.meta["proposal"] or raise ProposalError.new("entry has no proposal block: #{pending_key}")
+            target = proposal["target_key"] or raise ProposalError.new("proposal missing target_key")
+            action = proposal["action"] || "put"
+
+            evaluate_promotion!(env, target)
+
+            case action
+            when "put"
+              # Nested proposal "frontmatter" — the meta to write to the accepted
+              # target. Not related to the removed intake-handler legacy bridge.
+              target_meta = env.meta["frontmatter"] || {}
+              target_body = env.body
+              put_op.call(target, meta: target_meta, body: target_body)
+            when "delete"
+              delete_op.call(target)
+            else
+              raise ProposalError.new("unknown action: #{action}")
+            end
+
+            delete_op.call(pending_key)
+
+            @events.publish(:proposal_accepted,
+                            ctx: @hook_context,
+                            key: pending_key,
+                            target_key: target)
+
+            { "protocol" => PROTOCOL, "accepted" => pending_key, "target_key" => target, "action" => action }
+          end
+
+          private
+
+          def put_op
+            @put_op ||= Textus::Application::Write::Put::Impl.new(
+              ctx: @ctx, caps: @caps, writer: @writer,
+              hook_context: @hook_context
+            )
+          end
+
+          def delete_op
+            @delete_op ||= Textus::Application::Write::Delete::Impl.new(
+              ctx: @ctx, caps: @caps, writer: @writer,
+              hook_context: @hook_context
+            )
+          end
+
+          def evaluate_promotion!(env, target_key)
+            rules = @manifest.rules.for(target_key)
+            promote = rules.promote
+            return if promote.nil? || promote.requires.empty?
+
+            policy = Textus::Domain::Policy::Promotion.from_names(promote.requires)
+            result = policy.evaluate(
+              entry: env, schemas: @schemas, manifest: @manifest, role: @ctx.role,
+            )
+            return if result.ok?
+
+            raise ProposalError.new(
+              "promotion gate failed: #{result.reasons.join("; ")}",
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:accept, Textus::Application::Write::Accept, caps: :write)

data/lib/textus/application/{writes → write}/authority_gate.rb

@@ -1,15 +1,15 @@
 module Textus
   module Application
-    module Writes
+    module Write
       # Shared gate for write verbs that require the caller to hold the
       # manifest's accept_authority role. Provides one method, expressed
       # as two early-returns rather than a ternary, so each failure mode
       # reads on its own line.
       module AuthorityGate
         def assert_accept_authority!(verb)
-          return if @manifest.role_kind(@ctx.role) == :accept_authority
+          return if @manifest.policy.role_kind(@ctx.role) == :accept_authority
 
-          authority = @manifest.roles_with_kind(:accept_authority).first
+          authority = @manifest.policy.roles_with_kind(:accept_authority).first
           if authority.nil?
             raise ProposalError.new(
               "no role with accept_authority kind is declared in this manifest; #{verb} is disabled",

data/lib/textus/application/write/delete.rb

@@ -0,0 +1,45 @@
+module Textus
+  module Application
+    module Write
+      module Delete
+        def self.call(*, session:, ctx:, caps:, **)
+          Impl.new(
+            ctx: ctx, caps: caps,
+            writer: session.envelope_writer,
+            hook_context: session.hook_context
+          ).call(*, **)
+        end
+
+        class Impl
+          def initialize(ctx:, caps:, writer:, hook_context:)
+            @ctx          = ctx
+            @manifest     = caps.manifest
+            @events       = caps.events
+            @authorizer   = caps.authorizer
+            @writer       = writer
+            @hook_context = hook_context
+          end
+
+          def call(key, if_etag: nil, suppress_events: false)
+            Textus::Manifest::Data.validate_key!(key)
+            mentry = @manifest.resolver.resolve(key).entry
+
+            @authorizer.authorize_write!(mentry, role: @ctx.role)
+
+            @writer.delete(key, mentry: mentry, if_etag: if_etag)
+
+            unless suppress_events
+              @events.publish(:entry_deleted,
+                              ctx: @hook_context,
+                              key: key)
+            end
+
+            { "protocol" => Textus::PROTOCOL, "ok" => true, "key" => key, "deleted" => true }
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:delete, Textus::Application::Write::Delete, caps: :write)

data/lib/textus/application/{writes → write}/materializer.rb

@@ -2,37 +2,36 @@ require "fileutils"
 
 module Textus
   module Application
-    module Writes
+    module Write
       # Materializes a single Derived manifest entry onto disk by running
       # the builder pipeline (template + projection + external runner).
-      # Extracted from Application::Writes::Build so that Publish can reuse
+      # Extracted from Application::Write::Build so that Publish can reuse
       # it without creating a Build dependency.
       class Materializer
-        def initialize(ctx:, manifest:, file_store:, bus:, root:, store:)
+        def initialize(ctx:, caps:, rpc:, session:)
           @ctx        = ctx
-          @manifest   = manifest
-          @file_store = file_store
-          @bus        = bus
-          @root       = root
-          @store      = store
+          @caps       = caps
+          @manifest   = caps.manifest
+          @file_store = caps.file_store
+          @rpc        = rpc
+          @root       = caps.root
+          @session    = session
         end
 
         # Runs the builder pipeline for `mentry` and returns the on-disk
         # target_path string.
         def run(mentry)
-          reader = Textus::Application::Reads::Get.new(
-            ctx: @ctx, manifest: @manifest, file_store: @file_store,
-          )
-          lister = Textus::Application::Reads::List.new(manifest: @manifest)
+          reader = Textus::Application::Read::Get::Impl.new(ctx: @ctx, caps: @caps)
+          lister = Textus::Application::Read::List::Impl.new(caps: @caps)
           Builder::Pipeline.run(
             mentry: mentry,
             manifest: @manifest,
             reader: reader.method(:call),
             lister: lister.method(:call),
-            transform_resolver: ->(name) { @bus.rpc_callable(:transform_rows, name) },
+            rpc: @rpc,
             template_loader: ->(name) { read_template(name) },
-            transform_context: @store,
-            inject_intro: -> { Textus::Intro.run(@store) },
+            transform_context: @caps,
+            inject_boot: -> { Textus::Boot.run(@session) },
           )
         end
 

data/lib/textus/application/write/mv.rb

@@ -0,0 +1,118 @@
+module Textus
+  module Application
+    module Write
+      module Mv
+        def self.call(*, session:, ctx:, caps:, **)
+          Impl.new(
+            ctx: ctx, caps: caps,
+            reader: session.envelope_reader,
+            writer: session.envelope_writer,
+            hook_context: session.hook_context
+          ).call(*, **)
+        end
+
+        class Impl
+          def initialize(ctx:, caps:, reader:, writer:, hook_context:)
+            @ctx          = ctx
+            @manifest     = caps.manifest
+            @events       = caps.events
+            @authorizer   = caps.authorizer
+            @reader       = reader
+            @writer       = writer
+            @hook_context = hook_context
+          end
+
+          def call(old_key, new_key, dry_run: false)
+            old_res, new_res = prepare(old_key, new_key)
+            return dry_run_result(old_key, new_key, old_res, new_res) if dry_run
+
+            ensure_uid!(old_key, old_res.entry)
+            envelope = @writer.move(
+              from_key: old_key, to_key: new_key,
+              new_mentry: new_res.entry
+            )
+            publish_renamed(old_key, new_key, envelope)
+            success_result(old_key, new_key, old_res, new_res, envelope)
+          end
+
+          private
+
+          def prepare(old_key, new_key)
+            Textus::Manifest::Data.validate_key!(old_key)
+            Textus::Manifest::Data.validate_key!(new_key)
+            raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
+
+            old_res = @manifest.resolver.resolve(old_key)
+            new_res = @manifest.resolver.resolve(new_key)
+            raise UnknownKey.new(old_key) unless @reader.exists?(old_key)
+
+            validate_zone_and_format!(old_res.entry, new_res.entry)
+            @authorizer.authorize_write!(old_res.entry, role: @ctx.role)
+            @authorizer.authorize_write!(new_res.entry, role: @ctx.role)
+            raise UsageError.new("mv: target '#{new_key}' already exists at #{new_res.path}") if @reader.exists?(new_key)
+
+            [old_res, new_res]
+          end
+
+          def validate_zone_and_format!(old_mentry, new_mentry)
+            if old_mentry.zone != new_mentry.zone
+              raise UsageError.new(
+                "mv: cross-zone move refused (#{old_mentry.zone} → #{new_mentry.zone}). " \
+                "Use put+delete for cross-zone moves.",
+              )
+            end
+            return if old_mentry.format == new_mentry.format
+
+            raise UsageError.new("mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.")
+          end
+
+          # If the source file lacks a UID, rewrite it in-place via the writer
+          # so a UID gets injected before the move. This produces one "put"
+          # audit row, then the "mv" row from Writer#move.
+          def ensure_uid!(old_key, old_mentry)
+            pre_env = @reader.read(old_key)
+            return if pre_env.uid
+
+            @writer.put(
+              old_key, mentry: old_mentry,
+                       payload: Textus::Application::Envelope::Writer::Payload.new(
+                         meta: pre_env.meta, body: pre_env.body, content: pre_env.content,
+                       )
+            )
+          end
+
+          def publish_renamed(old_key, new_key, envelope)
+            @events.publish(:entry_renamed,
+                            ctx: @hook_context,
+                            key: new_key,
+                            from_key: old_key,
+                            to_key: new_key,
+                            envelope: envelope)
+          end
+
+          def dry_run_result(old_key, new_key, old_res, new_res)
+            pre_env = @reader.read(old_key)
+            {
+              "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
+              "from_key" => old_key, "to_key" => new_key,
+              "from_path" => old_res.path, "to_path" => new_res.path,
+              "uid" => pre_env.uid
+            }
+          end
+
+          def success_result(old_key, new_key, old_res, new_res, envelope)
+            {
+              "protocol" => PROTOCOL, "ok" => true,
+              "from_key" => old_key, "to_key" => new_key,
+              "from_path" => old_res.path, "to_path" => new_res.path,
+              "uid" => envelope.uid,
+              "envelope" => envelope.to_h_for_wire
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:mv, Textus::Application::Write::Mv, caps: :write)

data/lib/textus/application/write/publish.rb

@@ -0,0 +1,96 @@
+module Textus
+  module Application
+    module Write
+      # Single-pass publish use case: dispatches polymorphically to each
+      # entry's `publish_via` method. Derived entries materialize their body
+      # via Materializer; Nested entries fan out via publish_each; Leaf and
+      # Intake entries copy their stored body to publish_to targets. The
+      # Publish layer owns wiring (context, accumulation) but not per-kind
+      # logic.
+      #
+      # Return shape: { "protocol", "built", "published_leaves" }
+      module Publish
+        def self.call(*, session:, ctx:, caps:, **)
+          Impl.new(
+            ctx: ctx, caps: caps,
+            rpc: session.rpc,
+            session: session,
+            hook_context: session.hook_context
+          ).call(*, **)
+        end
+
+        class Impl
+          def initialize(ctx:, caps:, rpc:, session:, hook_context:)
+            @ctx          = ctx
+            @caps         = caps
+            @manifest     = caps.manifest
+            @file_store   = caps.file_store
+            @events       = caps.events
+            @root         = caps.root
+            @rpc          = rpc
+            @session      = session
+            @hook_context = hook_context
+          end
+
+          def call(prefix: nil)
+            built  = []
+            leaves = []
+            context = build_context
+
+            @manifest.data.entries.each do |mentry|
+              next if prefix && !entry_matches_prefix?(mentry, prefix)
+
+              result = mentry.publish_via(context, prefix: prefix)
+              next if result.nil?
+
+              case result[:kind]
+              when :built  then built << result[:value]
+              when :leaves then leaves.concat(result[:value])
+              end
+            end
+
+            { "protocol" => Textus::PROTOCOL, "built" => built, "published_leaves" => leaves }
+          end
+
+          private
+
+          def build_context
+            Textus::Manifest::Entry::Base::PublishContext.new(
+              repo_root: File.dirname(@root),
+              manifest: @manifest,
+              file_store: @file_store,
+              root: @root,
+              caps: @caps,
+              rpc: @rpc,
+              session: @session,
+              ctx: @ctx,
+              bus: @events,
+              hook_context: @hook_context,
+              reader: reader,
+              emit: ->(event, **payload) { @events.publish(event, ctx: @hook_context, **payload) },
+            )
+          end
+
+          # Whether the entry should be processed for the given prefix filter.
+          def entry_matches_prefix?(mentry, prefix)
+            return true unless prefix
+
+            case mentry
+            when Textus::Manifest::Entry::Nested
+              mentry.key.start_with?(prefix) ||
+                prefix.start_with?("#{mentry.key}.")
+            else
+              mentry.key.start_with?(prefix)
+            end
+          end
+
+          def reader
+            @reader ||= Textus::Application::Read::Get::Impl.new(ctx: @ctx, caps: @caps)
+          end
+        end
+      end
+    end
+  end
+end
+
+Textus::Application::UseCase.register(:publish, Textus::Application::Write::Publish, caps: :write)