textus 0.12.1 → 0.14.0

data/lib/textus/store/validator.rb

@@ -54,7 +54,7 @@ module Textus
         last_writer = @audit_log.last_writer_for(key)
         return if last_writer.nil?
 
-        env["_meta"].each_key do |field|
+        env.meta.each_key do |field|
           owner = schema.maintained_by(field)
           next if owner.nil? || last_writer == owner || last_writer == "human"
 
@@ -72,8 +72,8 @@ module Textus
 
       def validate_schema!(schema, envelope, format)
         payload = case format
-                  when "json", "yaml" then envelope["content"] || {}
-                  else envelope["_meta"] || {}
+                  when "json", "yaml" then envelope.content || {}
+                  else envelope.meta || {}
                   end
         schema.validate!(payload)
       end

data/lib/textus/store/writer.rb

@@ -11,16 +11,6 @@ module Textus
         @reader = store.reader
       end
 
-      # Backward-compat shim — orchestration now lives in Application::Writes::Put.
-      # rubocop:disable Metrics/ParameterLists
-      def put(key, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-        ctx = Textus::Application::Context.new(store: @store, role: as)
-        Textus::Application::Writes::Put.new(ctx: ctx, bus: @store.bus).call(
-          key, meta: meta, body: body, content: content, if_etag: if_etag, suppress_events: suppress_events
-        )
-      end
-      # rubocop:enable Metrics/ParameterLists
-
       # Pure I/O: validate, serialize, etag-check, write to disk, audit. No
       # permission check and no event firing — those are handled by the caller
       # (Application::Writes::Put).
@@ -76,56 +66,17 @@ module Textus
       end
 
       def ensure_uid(format, meta, content, existing_uid)
-        case format
-        when "markdown", "json", "yaml"
-          m = meta.is_a?(Hash) ? meta.dup : {}
-          m["uid"] = existing_uid || Store.mint_uid unless m["uid"].is_a?(String) && !m["uid"].empty?
-          [m, content]
-        else
-          [meta, content]
-        end
+        Textus::Entry.for_format(format).inject_uid(meta, content, existing_uid)
       end
 
       def enforce_name_match!(path, meta, format)
-        return unless %w[markdown json yaml].include?(format)
-        return unless meta.is_a?(Hash) && meta["name"]
-
-        ext = Entry.for_format(format).extensions.first
-        basename = File.basename(path, ext)
-        return if meta["name"] == basename
-
-        raise BadFrontmatter.new(path, "name '#{meta["name"]}' does not match basename '#{basename}'")
+        Textus::Entry.for_format(format).enforce_name_match!(path, meta)
       end
 
       def serialize_for_put(mentry:, path:, strategy:, meta:, body:, content:)
-        case mentry.format
-        when "markdown", "text"
-          bytes = strategy.serialize(meta: meta, body: body.to_s)
-          [bytes, meta, body.to_s, nil]
-        when "json", "yaml"
-          raise UsageError.new("put for #{mentry.format} requires content: or body:") if content.nil? && (body.nil? || body.to_s.empty?)
-
-          if content.nil?
-            begin
-              parsed = strategy.parse(body.to_s, path: path)
-            rescue BadFrontmatter => e
-              raise BadContent.new(path, "bad_content: #{e.message}")
-            end
-            [body.to_s, parsed["_meta"], body.to_s, parsed["content"]]
-          else
-            bytes = strategy.serialize(meta: meta, body: "", content: content)
-            [bytes, meta, bytes, content]
-          end
-        else
-          raise UsageError.new("unknown format #{mentry.format.inspect}")
-        end
-      end
-
-      # Backward-compat shim — orchestration now lives in Application::Writes::Delete.
-      def delete(key, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-        ctx = Textus::Application::Context.new(store: @store, role: as)
-        Textus::Application::Writes::Delete.new(ctx: ctx, bus: @store.bus).call(
-          key, if_etag: if_etag, suppress_events: suppress_events
+        _ = strategy
+        Textus::Entry.for_format(mentry.format).serialize_for_put(
+          meta: meta, body: body, content: content, path: path,
         )
       end
 
@@ -146,26 +97,6 @@ module Textus
           extras: ctx.correlation_id ? { "correlation_id" => ctx.correlation_id } : nil
         )
       end
-
-      def accept(key, as:)
-        Proposal.accept(@store, key, as: as)
-      end
-
-      def reject(pending_key, as: Role::DEFAULT)
-        raise ProposalError.new("only human role can reject proposals; got '#{as}'") unless as == "human"
-
-        mentry, = @store.manifest.resolve(pending_key)
-        raise ProposalError.new("reject: '#{pending_key}' is not in a proposal zone (zone=#{mentry.zone})") unless mentry.in_proposal_zone?
-
-        env = @store.get(pending_key)
-        proposal = env.dig("_meta", "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")
-
-        delete(pending_key, as: as)
-        @store.fire_event(:proposal_rejected, key: pending_key, target_key: target_key)
-        { "protocol" => PROTOCOL, "rejected" => pending_key, "target_key" => target_key }
-      end
     end
   end
 end

data/lib/textus/store.rb

@@ -45,7 +45,7 @@ module Textus
       load_hooks
       @reader = Reader.new(self)
       @writer = Writer.new(self)
-      fire_event(:store_loaded)
+      @bus.publish(:store_loaded, store: Textus::Application::Context.system(self))
     end
 
     def load_hooks
@@ -75,60 +75,6 @@ module Textus
       end
     end
 
-    def get(key, as: Textus::Role::DEFAULT)
-      ctx = Textus::Composition.context(self, role: as)
-      result = Textus::Composition.reads_get(ctx).call(key)
-      raise UnknownKey.new(key, suggestions: manifest.suggestions_for(key)) if result.nil?
-
-      result
-    end
-
-    def where(key) = @reader.where(key)
-    def list(**) = @reader.list(**)
-    def schema_envelope(key) = @reader.schema_envelope(key)
-
-    # rubocop:disable Metrics/ParameterLists
-    def put(key, meta: nil, body: nil, content: nil, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-      ctx = Textus::Composition.context(self, role: as)
-      Textus::Composition.writes_put(ctx).call(
-        key, meta: meta, body: body, content: content, if_etag: if_etag, suppress_events: suppress_events
-      )
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    def delete(key, if_etag: nil, as: Role::DEFAULT, suppress_events: false)
-      ctx = Textus::Composition.context(self, role: as)
-      Textus::Composition.writes_delete(ctx).call(key, if_etag: if_etag, suppress_events: suppress_events)
-    end
-
-    def fire_event(event, **)
-      view = Textus::Application::Context.new(store: self, role: "human")
-      @bus.publish(event, store: view, **)
-    end
-
-    def accept(key, as: Role::DEFAULT)
-      ctx = Textus::Composition.context(self, role: as)
-      Textus::Composition.writes_accept(ctx).call(key)
-    end
-
-    def reject(...) = @writer.reject(...)
-
-    def deps(key)    = @reader.deps(key)
-    def rdeps(key)   = @reader.rdeps(key)
-    def published    = @reader.published
-    def stale(**)    = @reader.stale(**)
-    def validate_all = @reader.validate_all
-
-    def uid(key) = @reader.uid(key)
-
-    # Move an entry from old_key to new_key within the same zone. Preserves
-    # uid (minting one first if absent), validates both keys against the
-    # manifest, refuses to clobber, and writes one mv audit row.
-    def mv(old_key, new_key, as: Role::DEFAULT, dry_run: false, correlation_id: nil)
-      Mover.new(store: self, reader: @reader, writer: @writer, manifest: @manifest, audit_log: audit_log)
-           .call(old_key, new_key, as: as, dry_run: dry_run, correlation_id: correlation_id)
-    end
-
     def audit_log
       @audit_log ||= Store::AuditLog.new(@root)
     end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.12.1"
+  VERSION = "0.14.0"
   PROTOCOL = "textus/3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Patrick
@@ -112,17 +112,28 @@ files:
 - lib/textus/application/context.rb
 - lib/textus/application/reads/audit.rb
 - lib/textus/application/reads/blame.rb
+- lib/textus/application/reads/deps.rb
 - lib/textus/application/reads/freshness.rb
 - lib/textus/application/reads/get.rb
+- lib/textus/application/reads/list.rb
 - lib/textus/application/reads/policy_explain.rb
+- lib/textus/application/reads/published.rb
+- lib/textus/application/reads/rdeps.rb
+- lib/textus/application/reads/schema_envelope.rb
+- lib/textus/application/reads/stale.rb
+- lib/textus/application/reads/uid.rb
+- lib/textus/application/reads/validate_all.rb
+- lib/textus/application/reads/where.rb
 - lib/textus/application/refresh/all.rb
 - lib/textus/application/refresh/orchestrator.rb
 - lib/textus/application/refresh/worker.rb
 - lib/textus/application/writes/accept.rb
 - lib/textus/application/writes/build.rb
 - lib/textus/application/writes/delete.rb
+- lib/textus/application/writes/mv.rb
 - lib/textus/application/writes/publish.rb
 - lib/textus/application/writes/put.rb
+- lib/textus/application/writes/reject.rb
 - lib/textus/builder/pipeline.rb
 - lib/textus/builder/renderer.rb
 - lib/textus/builder/renderer/json.rb
@@ -167,7 +178,6 @@ files:
 - lib/textus/cli/verb/schema_migrate.rb
 - lib/textus/cli/verb/uid.rb
 - lib/textus/cli/verb/where.rb
-- lib/textus/composition.rb
 - lib/textus/dependencies.rb
 - lib/textus/doctor.rb
 - lib/textus/doctor/check.rb
@@ -225,19 +235,28 @@ files:
 - lib/textus/key/path.rb
 - lib/textus/manifest.rb
 - lib/textus/manifest/entry.rb
+- lib/textus/manifest/entry/parser.rb
+- lib/textus/manifest/entry/validators.rb
+- lib/textus/manifest/entry/validators/events.rb
+- lib/textus/manifest/entry/validators/format_matrix.rb
+- lib/textus/manifest/entry/validators/index_filename.rb
+- lib/textus/manifest/entry/validators/inject_intro.rb
+- lib/textus/manifest/entry/validators/publish_each.rb
 - lib/textus/manifest/rules.rb
 - lib/textus/manifest/schema.rb
 - lib/textus/migrate_keys.rb
 - lib/textus/mustache.rb
+- lib/textus/operations.rb
+- lib/textus/operations/reads.rb
+- lib/textus/operations/refresh.rb
+- lib/textus/operations/writes.rb
 - lib/textus/projection.rb
-- lib/textus/proposal.rb
 - lib/textus/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
 - lib/textus/schema/tools.rb
 - lib/textus/store.rb
 - lib/textus/store/audit_log.rb
-- lib/textus/store/mover.rb
 - lib/textus/store/reader.rb
 - lib/textus/store/sentinel.rb
 - lib/textus/store/staleness.rb

data/lib/textus/composition.rb

@@ -1,72 +0,0 @@
-module Textus
-  module Composition
-    module_function
-
-    def context(store, role:, correlation_id: nil, dry_run: false)
-      Textus::Application::Context.new(
-        store: store,
-        role: role,
-        correlation_id: correlation_id,
-        dry_run: dry_run,
-      )
-    end
-
-    def reads_get(ctx)
-      Textus::Application::Reads::Get.new(ctx: ctx, orchestrator: refresh_orchestrator(ctx))
-    end
-
-    def freshness(ctx)
-      Textus::Application::Reads::Freshness.new(ctx: ctx)
-    end
-
-    def audit(ctx)
-      Textus::Application::Reads::Audit.new(ctx: ctx)
-    end
-
-    def blame(ctx)
-      Textus::Application::Reads::Blame.new(ctx: ctx)
-    end
-
-    def policy_explain(ctx)
-      Textus::Application::Reads::PolicyExplain.new(ctx: ctx)
-    end
-
-    def refresh_worker(ctx)
-      Textus::Application::Refresh::Worker.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def refresh_orchestrator(ctx)
-      Textus::Application::Refresh::Orchestrator.new(
-        worker: refresh_worker(ctx),
-        bus: ctx.store.bus,
-        store_root: ctx.store.root,
-        store: ctx.store,
-        role: ctx.role,
-      )
-    end
-
-    def writes_put(ctx)
-      Textus::Application::Writes::Put.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def writes_delete(ctx)
-      Textus::Application::Writes::Delete.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def writes_build(ctx)
-      Textus::Application::Writes::Build.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def writes_accept(ctx)
-      Textus::Application::Writes::Accept.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def writes_publish(ctx)
-      Textus::Application::Writes::Publish.new(ctx: ctx, bus: ctx.store.bus)
-    end
-
-    def event_bus(ctx)
-      Textus::Infra::EventBus.new(registry: ctx.store.registry)
-    end
-  end
-end

data/lib/textus/proposal.rb

@@ -1,10 +0,0 @@
-module Textus
-  module Proposal
-    # Deprecated as of 0.9.1: use Textus::Application::Writes::Accept (via
-    # Textus::Composition.writes_accept).
-    def self.accept(store, pending_key, as:)
-      ctx = Textus::Composition.context(store, role: as)
-      Textus::Application::Writes::Accept.new(ctx: ctx, bus: store.bus).call(pending_key)
-    end
-  end
-end

data/lib/textus/store/mover.rb

@@ -1,167 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    class Mover
-      MovePlan = Data.define(
-        :old_key, :new_key, :old_path, :new_path,
-        :new_mentry, :uid, :etag_before, :as
-      )
-
-      def initialize(store:, reader:, writer:, manifest:, audit_log:)
-        @store = store
-        @reader = reader
-        @writer = writer
-        @manifest = manifest
-        @audit_log = audit_log
-      end
-
-      def call(old_key, new_key, as: Role::DEFAULT, dry_run: false, correlation_id: nil)
-        plan, pre_env = prepare_plan(old_key, new_key, as: as)
-        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, correlation_id: correlation_id)
-        success_result(plan, new_envelope: new_envelope)
-      end
-
-      private
-
-      # Validates inputs, resolves manifest entries, and reads the source
-      # envelope. Returns [MovePlan, pre_envelope]; the pre_envelope is only
-      # needed by ensure_uid! and is threaded separately to keep MovePlan
-      # focused on the planned operation.
-      def prepare_plan(old_key, new_key, as:)
-        @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, as)
-        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"], as: as
-        )
-        [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, as)
-        writers = @manifest.zone_writers(mentry.zone)
-        return if writers.include?(as)
-
-        raise WriteForbidden.new(key, mentry.zone, writers: writers)
-      end
-
-      def ensure_uid!(plan, pre_env:)
-        return plan if plan.uid
-
-        env = @writer.put(
-          plan.old_key,
-          meta: pre_env["_meta"],
-          body: pre_env["body"],
-          content: pre_env["content"],
-          as: plan.as,
-          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:, correlation_id:)
-        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"] = correlation_id if correlation_id
-
-        @audit_log.append(
-          role: plan.as, verb: "mv", key: plan.new_key,
-          etag_before: plan.etag_before, etag_after: etag_after,
-          extras: extras
-        )
-        new_envelope = @reader.get(plan.new_key)
-        @store.fire_event(
-          :entry_renamed,
-          key: plan.new_key, from_key: plan.old_key, to_key: plan.new_key,
-          envelope: new_envelope
-        )
-        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
-        }
-      end
-
-      # If the moved file carries a `name:` field (markdown) or `_meta.name`
-      # (json/yaml), rewrite it to the new basename so enforce_name_match! stays
-      # happy on the next read. Only touches the bytes when name actually changes.
-      def rewrite_name_for_mv!(mentry, new_path, new_key)
-        strategy = Entry.for_format(mentry.format)
-        raw = File.binread(new_path)
-        parsed = strategy.parse(raw, path: new_path)
-        basename = new_key.split(".").last
-
-        case mentry.format
-        when "markdown"
-          meta = parsed["_meta"] || {}
-          return unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
-
-          meta = meta.merge("name" => basename)
-          File.binwrite(new_path, strategy.serialize(meta: meta, body: parsed["body"]))
-        when "json", "yaml"
-          meta = parsed["_meta"]
-          return unless meta.is_a?(Hash) && meta["name"].is_a?(String) && meta["name"] != basename
-
-          new_meta = meta.merge("name" => basename)
-          File.binwrite(new_path, strategy.serialize(meta: new_meta, body: "", content: parsed["content"]))
-        end
-      end
-    end
-  end
-end