textus 0.10.5 → 0.14.0

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

@@ -0,0 +1,144 @@
+require "fileutils"
+
+module Textus
+  module Application
+    module Writes
+      class Mv
+        MovePlan = Data.define(
+          :old_key, :new_key, :old_path, :new_path,
+          :new_mentry, :uid, :etag_before
+        )
+
+        def initialize(ctx:, bus:)
+          @ctx = ctx
+          @bus = bus
+        end
+
+        def call(old_key, new_key, dry_run: false)
+          plan, pre_env = prepare_plan(old_key, new_key)
+          return dry_run_result(plan) if dry_run
+
+          plan = ensure_uid!(plan, pre_env: pre_env)
+          etag_after = perform_move!(plan)
+          new_envelope = record_move(plan, etag_after: etag_after)
+          success_result(plan, new_envelope: new_envelope)
+        end
+
+        private
+
+        def manifest = @ctx.store.manifest
+        def reader   = @ctx.store.reader
+
+        def prepare_plan(old_key, new_key)
+          manifest.validate_key!(old_key)
+          manifest.validate_key!(new_key)
+          raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
+
+          old_mentry, old_path, = manifest.resolve(old_key)
+          raise UnknownKey.new(old_key) unless File.exist?(old_path)
+
+          new_mentry, new_path, = manifest.resolve(new_key)
+          validate_zone_and_format!(old_mentry, new_mentry)
+          validate_writer!(old_mentry, old_key)
+          raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_path)
+
+          pre_env = reader.get(old_key)
+          plan = MovePlan.new(
+            old_key: old_key, new_key: new_key,
+            old_path: old_path, new_path: new_path,
+            new_mentry: new_mentry,
+            uid: pre_env.uid, etag_before: pre_env.etag
+          )
+          [plan, pre_env]
+        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
+
+        def validate_writer!(mentry, key)
+          writers = manifest.zone_writers(mentry.zone)
+          return if writers.include?(@ctx.role)
+
+          raise WriteForbidden.new(key, mentry.zone, writers: writers)
+        end
+
+        def ensure_uid!(plan, pre_env:)
+          return plan if plan.uid
+
+          env = Textus::Application::Writes::Put.new(ctx: @ctx, bus: @bus).call(
+            plan.old_key,
+            meta: pre_env.meta,
+            body: pre_env.body,
+            content: pre_env.content,
+            suppress_events: true,
+          )
+          plan.with(uid: env.uid, etag_before: env.etag)
+        end
+
+        def perform_move!(plan)
+          FileUtils.mkdir_p(File.dirname(plan.new_path))
+          FileUtils.mv(plan.old_path, plan.new_path)
+          rewrite_name_for_mv!(plan.new_mentry, plan.new_path, plan.new_key)
+          Etag.for_file(plan.new_path)
+        end
+
+        def record_move(plan, etag_after:)
+          extras = {
+            "from_key" => plan.old_key, "to_key" => plan.new_key,
+            "from_path" => plan.old_path, "to_path" => plan.new_path,
+            "uid" => plan.uid
+          }
+          extras["correlation_id"] = @ctx.correlation_id if @ctx.correlation_id
+
+          @ctx.store.audit_log.append(
+            role: @ctx.role, verb: "mv", key: plan.new_key,
+            etag_before: plan.etag_before, etag_after: etag_after,
+            extras: extras
+          )
+          new_envelope = reader.get(plan.new_key)
+          @bus.publish(:entry_renamed,
+                       store: @ctx.with_role(@ctx.role),
+                       key: plan.new_key,
+                       from_key: plan.old_key,
+                       to_key: plan.new_key,
+                       envelope: new_envelope,
+                       correlation_id: @ctx.correlation_id)
+          new_envelope
+        end
+
+        def dry_run_result(plan)
+          {
+            "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
+            "from_key" => plan.old_key, "to_key" => plan.new_key,
+            "from_path" => plan.old_path, "to_path" => plan.new_path,
+            "uid" => plan.uid
+          }
+        end
+
+        def success_result(plan, new_envelope:)
+          {
+            "protocol" => PROTOCOL, "ok" => true,
+            "from_key" => plan.old_key, "to_key" => plan.new_key,
+            "from_path" => plan.old_path, "to_path" => plan.new_path,
+            "uid" => plan.uid,
+            "envelope" => new_envelope.to_h_for_wire
+          }
+        end
+
+        def rewrite_name_for_mv!(mentry, new_path, new_key)
+          basename = new_key.split(".").last
+          Entry.for_format(mentry.format).rewrite_name(new_path, basename)
+        end
+      end
+    end
+  end
+end

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

@@ -1,23 +1,55 @@
 module Textus
   module Application
     module Writes
+      # Copies nested-leaf entries to their `publish_each:` targets. Fires
+      # `:file_published` for each copy. Mirror of `Build` for the publish
+      # half — split out from the old Build per ADR 0007.
       class Publish
         def initialize(ctx:, bus:)
           @ctx = ctx
           @bus = bus
         end
 
-        def call(source:, target:, key:)
-          Textus::Infra::Publisher.publish(
-            source: source,
-            target: target,
-            store_root: @ctx.store.root,
-          )
-          @bus.publish(:published,
-                       key: key,
-                       source: source,
-                       target: target,
+        def call(prefix: nil)
+          repo_root = File.dirname(store.root)
+          out = []
+          manifest.entries.each do |mentry|
+            next unless mentry.nested && mentry.publish_each
+            next if prefix && !mentry.key.start_with?(prefix) && !prefix.start_with?("#{mentry.key}.")
+
+            manifest.enumerate(prefix: mentry.key).each do |row|
+              next unless row[:manifest_entry].equal?(mentry)
+              next if prefix && !row[:key].start_with?(prefix) && row[:key] != prefix
+
+              out << publish_leaf(mentry, row, repo_root)
+            end
+          end
+          { "protocol" => Textus::PROTOCOL, "published_leaves" => out }
+        end
+
+        private
+
+        def store = @ctx.store
+        def manifest = store.manifest
+
+        def publish_leaf(mentry, row, repo_root)
+          target_rel = mentry.publish_target_for(row[:key])
+          target_abs = File.expand_path(File.join(repo_root, target_rel))
+          unless target_abs.start_with?(File.expand_path(repo_root) + File::SEPARATOR)
+            raise PublishError.new(
+              "entry '#{mentry.key}': publish_each target '#{target_rel}' for key '#{row[:key]}' escapes repo root",
+            )
+          end
+
+          Textus::Infra::Publisher.publish(source: row[:path], target: target_abs, store_root: store.root)
+          @bus.publish(:file_published,
+                       store: @ctx.with_role(@ctx.role),
+                       key: row[:key],
+                       envelope: store.reader.get(row[:key]),
+                       source: row[:path],
+                       target: target_abs,
                        correlation_id: @ctx.correlation_id)
+          { "key" => row[:key], "source" => row[:path], "target" => target_abs }
         end
       end
     end

data/lib/textus/application/writes/put.rb

@@ -25,7 +25,7 @@ module Textus
           )
 
           unless suppress_events
-            @bus.publish(:put,
+            @bus.publish(:entry_put,
                          store: @ctx.with_role(@ctx.role),
                          key: key,
                          envelope: envelope,

data/lib/textus/application/writes/reject.rb

@@ -0,0 +1,37 @@
+module Textus
+  module Application
+    module Writes
+      class Reject
+        def initialize(ctx:, bus:)
+          @ctx = ctx
+          @bus = bus
+        end
+
+        def call(pending_key)
+          raise ProposalError.new("only human role can reject proposals; got '#{@ctx.role}'") unless @ctx.role == "human"
+
+          mentry, = @ctx.store.manifest.resolve(pending_key)
+          unless mentry.in_proposal_zone?
+            raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})")
+          end
+
+          env = @ctx.store.reader.get(pending_key)
+          proposal = env.meta&.dig("proposal") or
+            raise ProposalError.new("entry has no proposal block: #{pending_key}")
+          target_key = proposal["target_key"] or
+            raise ProposalError.new("proposal missing target_key")
+
+          Textus::Application::Writes::Delete.new(ctx: @ctx, bus: @bus).call(pending_key, suppress_events: true)
+
+          @bus.publish(:proposal_rejected,
+                       store: @ctx.with_role(@ctx.role),
+                       key: pending_key,
+                       target_key: target_key,
+                       correlation_id: @ctx.correlation_id)
+
+          { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
+        end
+      end
+    end
+  end
+end

data/lib/textus/builder/pipeline.rb

@@ -10,7 +10,7 @@ module Textus
         from = Array(mentry.projection&.fetch("select", nil)).compact
         meta["from"] = from unless from.empty?
         meta["template"] = mentry.template if mentry.template
-        reduce = mentry.projection&.dig("reduce")
+        reduce = mentry.projection&.dig("transform")
         meta["reduce"] = reduce if reduce
 
         out = { "_meta" => meta }

data/lib/textus/builder/renderer/json.rb

@@ -28,7 +28,7 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["reduce"] && data.is_a?(Hash) && !data.key?("entries")
+          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

data/lib/textus/builder/renderer/yaml.rb

@@ -28,7 +28,7 @@ module Textus
         end
 
         def default_shape(mentry, data)
-          if mentry.projection && mentry.projection["reduce"] && data.is_a?(Hash) && !data.key?("entries")
+          if mentry.projection && mentry.projection["transform"] && data.is_a?(Hash) && !data.key?("entries")
             data
           elsif data.is_a?(Hash) && data["entries"].is_a?(Array)
             { "entries" => data["entries"] }

data/lib/textus/cli/group/key.rb

@@ -5,7 +5,7 @@ module Textus
         self.cli_name = "key"
         subcommands["mv"]      = Verb::Mv
         subcommands["uid"]     = Verb::Uid
-        subcommands["migrate"] = Verb::MigrateKeys
+        subcommands["normalize"] = Verb::KeyNormalize
       end
     end
   end

data/lib/textus/cli/group/refresh.rb

@@ -0,0 +1,21 @@
+module Textus
+  class CLI
+    class Group
+      class Refresh < Group
+        self.cli_name = "refresh"
+        subcommands["stale"] = Verb::RefreshStale
+
+        def parse(argv)
+          if argv.first == "stale"
+            argv.shift
+            @sub_klass = Verb::RefreshStale
+          else
+            @sub_klass = Verb::Refresh
+          end
+          @sub = @sub_klass.new(stdin: @stdin, stdout: @stdout, stderr: @stderr, cwd: @cwd)
+          @sub.parse(argv)
+        end
+      end
+    end
+  end
+end

data/lib/textus/cli/group/rule.rb

@@ -0,0 +1,11 @@
+module Textus
+  class CLI
+    class Group
+      class Rule < Group
+        self.cli_name = "rule"
+        subcommands["list"]    = Verb::RuleList
+        subcommands["explain"] = Verb::RuleExplain
+      end
+    end
+  end
+end

data/lib/textus/cli/verb/accept.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("accept requires a key")
-          ctx = context_for(store)
-          emit(Textus::Composition.writes_accept(ctx).call(key))
+          emit(operations_for(store).writes.accept.call(key))
         end
       end
     end

data/lib/textus/cli/verb/audit.rb

@@ -11,9 +11,9 @@ module Textus
         option :limit, "--limit=N"
 
         def call(store)
-          ctx = context_for(store)
-          since_time = since && Textus::Application::Reads::Audit.parse_since(since, now: ctx.now)
-          rows = Textus::Composition.audit(ctx).call(
+          ops = operations_for(store)
+          since_time = since && Textus::Application::Reads::Audit.parse_since(since, now: ops.ctx.now)
+          rows = ops.reads.audit.call(
             key: key_filter,
             zone: zone,
             role: role_filter,

data/lib/textus/cli/verb/blame.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("blame requires a key")
-          ctx = context_for(store)
-          rows = Textus::Composition.blame(ctx).call(key: key, limit: limit&.to_i)
+          rows = operations_for(store).reads.blame.call(key: key, limit: limit&.to_i)
           emit({ "verb" => "blame", "key" => key, "rows" => rows })
         end
       end

data/lib/textus/cli/verb/build.rb

@@ -5,8 +5,12 @@ module Textus
         option :prefix, "--prefix=K"
 
         def call(store)
-          ctx = Textus::Composition.context(store, role: "build")
-          emit(Textus::Composition.writes_build(ctx).call(prefix: prefix))
+          ops = Textus::Operations.for(store, role: "builder")
+          build_res   = ops.writes.build.call(prefix: prefix)
+          publish_res = ops.writes.publish.call(prefix: prefix)
+          emit({ "protocol" => Textus::PROTOCOL,
+                 "built" => build_res["built"],
+                 "published_leaves" => publish_res["published_leaves"] })
         end
       end
     end

data/lib/textus/cli/verb/delete.rb

@@ -7,8 +7,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("delete requires a key")
-          ctx = context_for(store)
-          emit(Textus::Composition.writes_delete(ctx).call(key, if_etag: if_etag))
+          emit(operations_for(store).writes.delete.call(key, if_etag: if_etag))
         end
       end
     end

data/lib/textus/cli/verb/deps.rb

@@ -4,7 +4,7 @@ module Textus
       class Deps < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("deps requires a key")
-          emit({ "key" => key, "deps" => store.deps(key) })
+          emit({ "key" => key, "deps" => operations_for(store).reads.deps.call(key) })
         end
       end
     end

data/lib/textus/cli/verb/freshness.rb

@@ -6,8 +6,7 @@ module Textus
         option :zone, "--zone=Z"
 
         def call(store)
-          ctx = context_for(store)
-          rows = Textus::Composition.freshness(ctx).call(prefix: prefix, zone: zone)
+          rows = operations_for(store).reads.freshness.call(prefix: prefix, zone: zone)
           emit({ "verb" => "freshness", "rows" => rows })
         end
       end

data/lib/textus/cli/verb/get.rb

@@ -6,11 +6,10 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("get requires a key")
-          ctx = context_for(store)
-          result = Textus::Composition.reads_get(ctx).call(key)
+          result = operations_for(store).reads.get.call(key)
           raise Textus::UnknownKey.new(key, suggestions: store.manifest.suggestions_for(key)) if result.nil?
 
-          emit(result)
+          emit(result.to_h_for_wire)
         end
       end
     end

data/lib/textus/cli/verb/hook_run.rb

@@ -15,7 +15,8 @@ module Textus
           @raw_argv.each do |tok|
             case tok
             when /\A--as=(.+)\z/         then as_flag = ::Regexp.last_match(1)
-            when /\A--format=/           then next
+            when /\A--output=/           then next
+            when /\A--format=/           then raise FlagRenamed.new("--format", "--output")
             when /\A--([\w-]+)=(.*)\z/   then args[::Regexp.last_match(1)] = ::Regexp.last_match(2)
             else
               raise UsageError.new("unknown arg to 'hook run #{name}': #{tok}")
@@ -23,7 +24,7 @@ module Textus
           end
 
           role = Role.resolve(flag: as_flag, env: ENV, root: store.root)
-          callable = store.registry.rpc_callable(:intake, name)
+          callable = store.registry.rpc_callable(:resolve_intake, name)
           view = Application::Context.new(store: store, role: role)
 
           begin

data/lib/textus/cli/verb/hooks.rb

@@ -35,7 +35,7 @@ module Textus
 
                 rows << {
                   "event" => evt.to_s, "mode" => "manifest", "exec" => defn["exec"],
-                  "key" => e.key, "as" => defn["as"] || "script"
+                  "key" => e.key, "as" => defn["as"] || "runner"
                 }
               end
             end

data/lib/textus/cli/verb/{migrate_keys.rb → key_normalize.rb}

@@ -1,7 +1,7 @@
 module Textus
   class CLI
     class Verb
-      class MigrateKeys < Verb
+      class KeyNormalize < Verb
         option :write, "--write"
         option :dry_run, "--dry-run"
 

data/lib/textus/cli/verb/list.rb

@@ -6,7 +6,7 @@ module Textus
         option :zone, "--zone=Z"
 
         def call(store)
-          emit({ "entries" => store.list(prefix: prefix, zone: zone) })
+          emit({ "entries" => operations_for(store).reads.list.call(prefix: prefix, zone: zone) })
         end
       end
     end

data/lib/textus/cli/verb/mv.rb

@@ -8,7 +8,7 @@ module Textus
         def call(store)
           old_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
           new_key = positional.shift or raise UsageError.new("mv requires <old-key> <new-key>")
-          emit(store.mv(old_key, new_key, as: resolved_role(store), dry_run: dry_run || false))
+          emit(operations_for(store).writes.mv.call(old_key, new_key, dry_run: dry_run || false))
         end
       end
     end

data/lib/textus/cli/verb/published.rb

@@ -3,7 +3,7 @@ module Textus
     class Verb
       class Published < Verb
         def call(store)
-          emit({ "published" => store.published })
+          emit({ "published" => operations_for(store).reads.published.call })
         end
       end
     end

data/lib/textus/cli/verb/put.rb

@@ -15,7 +15,7 @@ module Textus
           raw = @stdin.read
           payload =
             if fetch_name
-              callable = store.registry.rpc_callable(:intake, fetch_name)
+              callable = store.registry.rpc_callable(:resolve_intake, fetch_name)
               result =
                 begin
                   Timeout.timeout(Textus::Application::Refresh::Worker::FETCH_TIMEOUT_SECONDS) do
@@ -43,8 +43,8 @@ module Textus
           meta = payload["_meta"] || {}
           body = payload["body"] || ""
           if_etag = payload["if_etag"]
-          ctx = Textus::Composition.context(store, role: role)
-          emit(Textus::Composition.writes_put(ctx).call(key, meta: meta, body: body, if_etag: if_etag))
+          result = Textus::Operations.for(store, role: role).writes.put.call(key, meta: meta, body: body, if_etag: if_etag)
+          emit(result.to_h_for_wire)
         end
       end
     end

data/lib/textus/cli/verb/rdeps.rb

@@ -4,7 +4,7 @@ module Textus
       class Rdeps < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("rdeps requires a key")
-          emit({ "key" => key, "rdeps" => store.rdeps(key) })
+          emit({ "key" => key, "rdeps" => operations_for(store).reads.rdeps.call(key) })
         end
       end
     end

data/lib/textus/cli/verb/refresh.rb

@@ -6,8 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("refresh requires a key")
-          ctx = context_for(store)
-          emit(Textus::Composition.refresh_worker(ctx).run(key))
+          emit(operations_for(store).refresh.worker.run(key).to_h_for_wire)
         end
       end
     end

data/lib/textus/cli/verb/reject.rb

@@ -6,7 +6,7 @@ module Textus
 
         def call(store)
           key = positional.shift or raise UsageError.new("reject requires a key")
-          emit(store.reject(key, as: resolved_role(store)))
+          emit(operations_for(store).writes.reject.call(key))
         end
       end
     end

data/lib/textus/cli/verb/{policy_explain.rb → rule_explain.rb}

@@ -1,11 +1,10 @@
 module Textus
   class CLI
     class Verb
-      class PolicyExplain < Verb
+      class RuleExplain < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("policy explain requires a KEY")
-          ctx = context_for(store)
-          result = Textus::Composition.policy_explain(ctx).call(key: key)
+          result = operations_for(store).reads.policy_explain.call(key: key)
           emit({ "verb" => "policy_explain" }.merge(result.transform_keys(&:to_s)))
         end
       end

data/lib/textus/cli/verb/{policy_list.rb → rule_list.rb}

@@ -1,9 +1,9 @@
 module Textus
   class CLI
     class Verb
-      class PolicyList < Verb
+      class RuleList < Verb
         def call(store)
-          policies = store.manifest.policies.blocks.map do |b|
+          policies = store.manifest.rules.blocks.map do |b|
             row = { "match" => b.match }
             if b.refresh
               row["refresh"] = {
@@ -13,7 +13,7 @@ module Textus
               }
             end
             row["handler_allowlist"] = b.handler_allowlist.handlers if b.handler_allowlist
-            row["promote_requires"] = b.promote.requires if b.promote
+            row["promotion"] = { "requires" => b.promote.requires } if b.promote
             row["retention"] = b.retention if b.retention
             row
           end

data/lib/textus/cli/verb/schema.rb

@@ -4,7 +4,7 @@ module Textus
       class Schema < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("schema requires a key")
-          emit(store.schema_envelope(key))
+          emit(operations_for(store).reads.schema_envelope.call(key))
         end
       end
     end

data/lib/textus/cli/verb/uid.rb

@@ -4,7 +4,7 @@ module Textus
       class Uid < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("uid requires a key")
-          emit({ "key" => key, "uid" => store.uid(key) })
+          emit({ "key" => key, "uid" => operations_for(store).reads.uid.call(key) })
         end
       end
     end

data/lib/textus/cli/verb/where.rb

@@ -4,7 +4,7 @@ module Textus
       class Where < Verb
         def call(store)
           key = positional.shift or raise UsageError.new("where requires a key")
-          emit(store.where(key))
+          emit(operations_for(store).reads.where.call(key))
         end
       end
     end

data/lib/textus/cli/verb.rb

@@ -41,9 +41,10 @@ module Textus
           self.class.options.each do |name, optspec|
             o.on(optspec) { |v| public_send(:"#{name}=", v) }
           end
-          o.on("--format=FMT") { |v| fmt = v }
+          o.on("--output=FMT") { |v| fmt = v }
+          o.on("--format=FMT") { |_v| raise FlagRenamed.new("--format", "--output") }
         end.permute!(argv)
-        raise UsageError.new("only --format=json is supported in v1") unless fmt == "json"
+        raise UsageError.new("only --output=json is supported in v1") unless fmt == "json"
 
         @positional = argv.dup
       end
@@ -69,7 +70,12 @@ module Textus
       # Convenience for verbs whose only pre-call boilerplate is
       # resolving the role and wrapping it in a context.
       def context_for(store)
-        Textus::Composition.context(store, role: resolved_role(store))
+        Textus::Operations.for(store, role: resolved_role(store)).ctx
+      end
+
+      # Returns an Operations instance bound to the resolved role.
+      def operations_for(store)
+        Textus::Operations.for(store, role: resolved_role(store))
       end
     end
   end