textus 0.14.4 → 0.18.0

data/lib/textus/store.rb

@@ -1,16 +1,8 @@
 require "fileutils"
-require "securerandom"
 
 module Textus
   class Store
-    attr_reader :root, :manifest, :registry, :reader, :writer, :bus
-
-    # A Textus UID: 16 lowercase hex chars (SecureRandom.hex(8)). Not a UUID —
-    # short on purpose. Random enough for collision-never-in-practice within a
-    # single store.
-    def self.mint_uid
-      SecureRandom.hex(8)
-    end
+    attr_reader :root, :manifest, :schemas, :file_store, :audit_log, :bus, :registry
 
     def self.discover(start_dir = Dir.pwd, root: nil)
       explicit = root || ENV.fetch("TEXTUS_ROOT", nil)
@@ -37,46 +29,17 @@ module Textus
     end
 
     def initialize(root)
-      @root = File.expand_path(root)
-      @manifest = Manifest.load(@root)
-      @bus = Hooks::Dispatcher.new(audit_log: audit_log)
-      @registry = Hooks::Registry.new(dispatcher: @bus)
-      @schemas = {}
-      load_hooks
-      @reader = Reader.new(self)
-      @writer = Writer.new(self)
-      @bus.publish(:store_loaded, store: Textus::Application::Context.system(self))
-    end
-
-    def load_hooks
-      Textus.with_registry(@registry) do
-        Hooks::Builtin.register_all
-        dir = File.join(@root, "hooks")
-        return unless File.directory?(dir)
-
-        Dir.glob(File.join(dir, "**/*.rb")).sort.each do |f| # rubocop:disable Lint/RedundantDirGlobSort
-          begin
-            load(f)
-          rescue StandardError, ScriptError => e
-            raise UsageError.new("failed loading hook #{File.basename(f)}: #{e.class}: #{e.message}")
-          end
-        end
-      end
-    end
-
-    def schema_for(name)
-      return nil if name.nil?
-
-      @schemas[name] ||= begin
-        sp = File.join(@root, "schemas", "#{name}.yaml")
-        raise IoError.new("schema not found: #{sp}") unless File.exist?(sp)
-
-        Schema.load(sp)
-      end
-    end
-
-    def audit_log
-      @audit_log ||= Store::AuditLog.new(@root)
+      @root       = File.expand_path(root)
+      @manifest   = Manifest.load(@root)
+      @schemas    = Schemas.new(File.join(@root, "schemas"))
+      @file_store = Infra::Storage::FileStore.new
+      @audit_log  = Infra::AuditLog.new(@root)
+      @bus        = Hooks::Dispatcher.new
+      @registry   = Hooks::Registry.new(dispatcher: @bus)
+      Infra::AuditSubscriber.new(@audit_log).attach(@bus)
+      Hooks::Builtin.register_all(@registry)
+      Hooks::Loader.new(registry: @registry).load_dir(File.join(@root, "hooks"))
+      @bus.publish(:store_loaded, store: Application::Context.system(self))
     end
   end
 end

data/lib/textus/uid.rb

@@ -0,0 +1,18 @@
+require "securerandom"
+
+module Textus
+  # A Textus UID: 16 lowercase hex chars (SecureRandom.hex(8)). Not a UUID —
+  # short on purpose. Random enough for collision-never-in-practice within a
+  # single store.
+  module Uid
+    module_function
+
+    def mint
+      SecureRandom.hex(8)
+    end
+
+    def valid?(str)
+      str.is_a?(String) && str.match?(/\A[0-9a-f]{16}\z/)
+    end
+  end
+end

data/lib/textus/version.rb

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

data/lib/textus.rb

@@ -8,11 +8,27 @@ loader.inflector.inflect(
   "json" => "Json",
   "yaml" => "Yaml",
   "hook_dsl_scanner" => "HookDSLScanner",
+  "envelope_io" => "EnvelopeIO",
 )
 loader.ignore(File.expand_path("textus/errors.rb", __dir__))
 loader.setup
 loader.eager_load
 
 module Textus
-  extend Hooks::Dsl
+  @hook_mutex  = Mutex.new
+  @hook_blocks = []
+
+  def self.hook(&blk)
+    raise UsageError.new("hook block required") unless blk
+
+    @hook_mutex.synchronize { @hook_blocks << blk }
+  end
+
+  def self.drain_hook_blocks
+    @hook_mutex.synchronize do
+      blocks = @hook_blocks
+      @hook_blocks = []
+      blocks
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.14.4
+  version: 0.18.0
 platform: ruby
 authors:
 - Patrick
@@ -115,6 +115,7 @@ files:
 - lib/textus/application/reads/deps.rb
 - lib/textus/application/reads/freshness.rb
 - lib/textus/application/reads/get.rb
+- lib/textus/application/reads/get_or_refresh.rb
 - lib/textus/application/reads/list.rb
 - lib/textus/application/reads/policy_explain.rb
 - lib/textus/application/reads/published.rb
@@ -123,6 +124,7 @@ files:
 - lib/textus/application/reads/stale.rb
 - lib/textus/application/reads/uid.rb
 - lib/textus/application/reads/validate_all.rb
+- lib/textus/application/reads/validator.rb
 - lib/textus/application/reads/where.rb
 - lib/textus/application/refresh/all.rb
 - lib/textus/application/refresh/orchestrator.rb
@@ -130,6 +132,7 @@ files:
 - lib/textus/application/writes/accept.rb
 - lib/textus/application/writes/build.rb
 - lib/textus/application/writes/delete.rb
+- lib/textus/application/writes/envelope_io.rb
 - lib/textus/application/writes/mv.rb
 - lib/textus/application/writes/publish.rb
 - lib/textus/application/writes/put.rb
@@ -197,6 +200,7 @@ files:
 - lib/textus/doctor/check/templates.rb
 - lib/textus/doctor/check/unowned_schema_fields.rb
 - lib/textus/domain/action.rb
+- lib/textus/domain/freshness.rb
 - lib/textus/domain/freshness/evaluator.rb
 - lib/textus/domain/freshness/policy.rb
 - lib/textus/domain/freshness/verdict.rb
@@ -210,6 +214,10 @@ files:
 - lib/textus/domain/policy/promote.rb
 - lib/textus/domain/policy/promotion.rb
 - lib/textus/domain/policy/refresh.rb
+- lib/textus/domain/sentinel.rb
+- lib/textus/domain/staleness.rb
+- lib/textus/domain/staleness/generator_check.rb
+- lib/textus/domain/staleness/intake_check.rb
 - lib/textus/entry.rb
 - lib/textus/entry/base.rb
 - lib/textus/entry/json.rb
@@ -221,15 +229,17 @@ files:
 - lib/textus/etag.rb
 - lib/textus/hooks/builtin.rb
 - lib/textus/hooks/dispatcher.rb
-- lib/textus/hooks/dsl.rb
 - lib/textus/hooks/loader.rb
 - lib/textus/hooks/registry.rb
+- lib/textus/infra/audit_log.rb
+- lib/textus/infra/audit_subscriber.rb
 - lib/textus/infra/build_lock.rb
 - lib/textus/infra/clock.rb
 - lib/textus/infra/event_bus.rb
 - lib/textus/infra/publisher.rb
 - lib/textus/infra/refresh/detached.rb
 - lib/textus/infra/refresh/lock.rb
+- lib/textus/infra/storage/file_store.rb
 - lib/textus/init.rb
 - lib/textus/intro.rb
 - lib/textus/key/distance.rb
@@ -244,28 +254,20 @@ files:
 - 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/resolution.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/refresh.rb
 - lib/textus/role.rb
 - lib/textus/schema.rb
 - lib/textus/schema/tools.rb
+- lib/textus/schemas.rb
 - lib/textus/store.rb
-- lib/textus/store/audit_log.rb
-- lib/textus/store/reader.rb
-- lib/textus/store/sentinel.rb
-- lib/textus/store/staleness.rb
-- lib/textus/store/staleness/generator_check.rb
-- lib/textus/store/staleness/intake_check.rb
-- lib/textus/store/validator.rb
-- lib/textus/store/writer.rb
+- lib/textus/uid.rb
 - lib/textus/version.rb
 homepage: https://github.com/patrick204nqh/textus
 licenses:

data/lib/textus/hooks/dsl.rb

@@ -1,11 +0,0 @@
-module Textus
-  module Hooks
-    module Dsl
-      def on(event, name, **, &blk)
-        raise UsageError.new("hook needs a block") unless blk
-
-        Loader.current_registry.register(event, name, **, &blk)
-      end
-    end
-  end
-end

data/lib/textus/operations/reads.rb

@@ -1,39 +0,0 @@
-module Textus
-  class Operations
-    class Reads
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def get
-        Application::Reads::Get.new(ctx: @ctx, orchestrator: orchestrator)
-      end
-
-      def freshness      = Application::Reads::Freshness.new(ctx: @ctx)
-      def audit          = Application::Reads::Audit.new(ctx: @ctx)
-      def blame          = Application::Reads::Blame.new(ctx: @ctx)
-      def policy_explain = Application::Reads::PolicyExplain.new(ctx: @ctx)
-      def list           = Application::Reads::List.new(ctx: @ctx)
-      def where           = Application::Reads::Where.new(ctx: @ctx)
-      def uid             = Application::Reads::Uid.new(ctx: @ctx)
-      def schema_envelope = Application::Reads::SchemaEnvelope.new(ctx: @ctx)
-      def deps            = Application::Reads::Deps.new(ctx: @ctx)
-      def rdeps           = Application::Reads::Rdeps.new(ctx: @ctx)
-      def published       = Application::Reads::Published.new(ctx: @ctx)
-      def stale           = Application::Reads::Stale.new(ctx: @ctx)
-      def validate_all    = Application::Reads::ValidateAll.new(ctx: @ctx)
-
-      private
-
-      def orchestrator
-        Application::Refresh::Orchestrator.new(
-          worker: Application::Refresh::Worker.new(ctx: @ctx, bus: @ctx.store.bus),
-          bus: @ctx.store.bus,
-          store_root: @ctx.store.root,
-          store: @ctx.store,
-          role: @ctx.role,
-        )
-      end
-    end
-  end
-end

data/lib/textus/operations/refresh.rb

@@ -1,27 +0,0 @@
-module Textus
-  class Operations
-    class Refresh
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def worker
-        Application::Refresh::Worker.new(ctx: @ctx, bus: @ctx.store.bus)
-      end
-
-      def orchestrator
-        Application::Refresh::Orchestrator.new(
-          worker: worker,
-          bus: @ctx.store.bus,
-          store_root: @ctx.store.root,
-          store: @ctx.store,
-          role: @ctx.role,
-        )
-      end
-
-      def all
-        Application::Refresh::All.new(ctx: @ctx, bus: @ctx.store.bus)
-      end
-    end
-  end
-end

data/lib/textus/operations/writes.rb

@@ -1,21 +0,0 @@
-module Textus
-  class Operations
-    class Writes
-      def initialize(ctx)
-        @ctx = ctx
-      end
-
-      def put     = Application::Writes::Put.new(ctx: @ctx, bus: bus)
-      def delete  = Application::Writes::Delete.new(ctx: @ctx, bus: bus)
-      def mv      = Application::Writes::Mv.new(ctx: @ctx, bus: bus)
-      def accept  = Application::Writes::Accept.new(ctx: @ctx, bus: bus)
-      def build   = Application::Writes::Build.new(ctx: @ctx, bus: bus)
-      def publish = Application::Writes::Publish.new(ctx: @ctx, bus: bus)
-      def reject  = Application::Writes::Reject.new(ctx: @ctx, bus: bus)
-
-      private
-
-      def bus = @ctx.store.bus
-    end
-  end
-end

data/lib/textus/store/reader.rb

@@ -1,69 +0,0 @@
-module Textus
-  class Store
-    class Reader
-      def initialize(store)
-        @store = store
-        @manifest = store.manifest
-      end
-
-      def get(key)
-        read_raw_envelope(key) || raise(UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)))
-      end
-
-      # Reads the current on-disk state of key as a bare envelope, skipping
-      # freshness annotation to avoid recursion. Used by Freshness.refresh_sync
-      # after a sync refresh completes.
-      def read_raw_envelope(key)
-        mentry, path, = @manifest.resolve(key)
-        return nil unless File.exist?(path)
-
-        raw = File.binread(path)
-        parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        Envelope.build(
-          key: key, mentry: mentry, path: path,
-          meta: parsed["_meta"], body: parsed["body"],
-          etag: Etag.for_bytes(raw), content: parsed["content"]
-        )
-      end
-
-      def list(prefix: nil, zone: nil)
-        rows = @manifest.enumerate(prefix: prefix)
-        rows = rows.select { |r| r[:manifest_entry].zone == zone } if zone
-        rows.map { |row| { "key" => row[:key], "zone" => row[:manifest_entry].zone, "path" => row[:path] } }
-      end
-
-      def where(key)
-        mentry, path, = @manifest.resolve(key)
-        { "protocol" => PROTOCOL, "key" => key, "zone" => mentry.zone, "owner" => mentry.owner, "path" => path }
-      end
-
-      def schema_envelope(key)
-        mentry, = @manifest.resolve(key)
-        schema = @store.schema_for(mentry.schema)
-        { "protocol" => PROTOCOL, "key" => key, "schema_ref" => mentry.schema, "schema" => schema&.to_h }
-      end
-
-      # Returns the Textus UID for a key (or nil if the entry has none yet).
-      # Raises UnknownKey if the key doesn't resolve to a real file.
-      def uid(key)
-        get(key).uid
-      end
-
-      def deps(key)   = Dependencies.deps_of(@manifest, key)
-      def rdeps(key)  = Dependencies.rdeps_of(@manifest, key)
-      def published   = Dependencies.published_of(@manifest)
-
-      def stale(prefix: nil, zone: nil)
-        Staleness.new(manifest: @manifest).call(prefix: prefix, zone: zone)
-      end
-
-      def validate_all
-        Validator.new(
-          reader: self, manifest: @manifest,
-          audit_log: @store.audit_log,
-          schema_for: ->(name) { @store.schema_for(name) }
-        ).call
-      end
-    end
-  end
-end

data/lib/textus/store/validator.rb

@@ -1,82 +0,0 @@
-module Textus
-  class Store
-    class Validator
-      def initialize(reader:, manifest:, audit_log:, schema_for:)
-        @reader = reader
-        @manifest = manifest
-        @audit_log = audit_log
-        @schema_for = schema_for
-      end
-
-      def call
-        violations = []
-        check_content_violations(violations)
-        check_role_authority_violations(violations)
-        { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
-      end
-
-      private
-
-      def check_content_violations(violations)
-        @manifest.enumerate.each do |row|
-          key = row[:key]
-          mentry = row[:manifest_entry]
-          env = fetch_envelope(key, violations) or next
-          schema = mentry.schema && @schema_for.call(mentry.schema)
-          next unless schema
-
-          begin
-            validate_schema!(schema, env, mentry.format)
-          rescue Textus::Error => e
-            violations << { "key" => key, "code" => e.code, "message" => e.message }
-          end
-        end
-      end
-
-      def check_role_authority_violations(violations)
-        @manifest.enumerate.each do |row|
-          mentry = row[:manifest_entry]
-          next unless mentry.schema
-
-          schema = @schema_for.call(mentry.schema)
-          next unless schema
-
-          env = begin
-            @reader.get(row[:key])
-          rescue StandardError
-            next
-          end
-          append_authority_violations(violations, row[:key], env, schema)
-        end
-      end
-
-      def append_authority_violations(violations, key, env, schema)
-        last_writer = @audit_log.last_writer_for(key)
-        return if last_writer.nil?
-
-        env.meta.each_key do |field|
-          owner = schema.maintained_by(field)
-          next if owner.nil? || last_writer == owner || last_writer == "human"
-
-          violations << { "key" => key, "code" => "role_authority",
-                          "field" => field, "expected" => owner, "last_writer" => last_writer }
-        end
-      end
-
-      def fetch_envelope(key, violations)
-        @reader.get(key)
-      rescue Textus::Error => e
-        violations << { "key" => key, "code" => e.code, "message" => e.message }
-        nil
-      end
-
-      def validate_schema!(schema, envelope, format)
-        payload = case format
-                  when "json", "yaml" then envelope.content || {}
-                  else envelope.meta || {}
-                  end
-        schema.validate!(payload)
-      end
-    end
-  end
-end

data/lib/textus/store/writer.rb

@@ -1,102 +0,0 @@
-require "fileutils"
-
-module Textus
-  class Store
-    class Writer
-      Payload = Data.define(:meta, :body, :content)
-
-      def initialize(store)
-        @store = store
-        @manifest = store.manifest
-        @reader = store.reader
-      end
-
-      # 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).
-      def write_envelope_to_disk(key, mentry:, payload:, ctx:, if_etag: nil)
-        _, path, = @manifest.resolve(key)
-
-        meta = payload.meta || {}
-        strategy = Entry.for_format(mentry.format)
-
-        existing_uid = existing_uid_for(mentry, path)
-        meta, content = ensure_uid(mentry.format, meta, payload.content, existing_uid)
-
-        bytes, eff_meta, eff_body, eff_content = serialize_for_put(
-          mentry: mentry, path: path, strategy: strategy,
-          meta: meta, body: payload.body, content: content
-        )
-
-        enforce_name_match!(path, eff_meta, mentry.format)
-
-        schema = @store.schema_for(mentry.schema)
-        if schema
-          Entry.for_format(mentry.format).validate_against(
-            schema,
-            { "_meta" => eff_meta, "content" => eff_content },
-          )
-        end
-
-        etag_before = File.exist?(path) ? Etag.for_file(path) : nil
-        raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && (etag_before != if_etag)
-
-        FileUtils.mkdir_p(File.dirname(path))
-        File.binwrite(path, bytes)
-        etag_after = Etag.for_bytes(bytes)
-        @store.audit_log.append(
-          role: ctx.role, verb: "put", key: key,
-          etag_before: etag_before, etag_after: etag_after,
-          extras: ctx.correlation_id ? { "correlation_id" => ctx.correlation_id } : nil
-        )
-        Envelope.build(
-          key: key, mentry: mentry, path: path,
-          meta: eff_meta, body: eff_body, etag: etag_after, content: eff_content
-        )
-      end
-
-      def existing_uid_for(mentry, path)
-        return nil unless File.exist?(path)
-
-        raw = File.binread(path)
-        parsed = Entry.for_format(mentry.format).parse(raw, path: path)
-        Envelope.extract_uid(parsed["_meta"])
-      rescue StandardError
-        nil
-      end
-
-      def ensure_uid(format, meta, content, existing_uid)
-        Textus::Entry.for_format(format).inject_uid(meta, content, existing_uid)
-      end
-
-      def enforce_name_match!(path, meta, format)
-        Textus::Entry.for_format(format).enforce_name_match!(path, meta)
-      end
-
-      def serialize_for_put(mentry:, path:, strategy:, meta:, body:, content:)
-        _ = strategy
-        Textus::Entry.for_format(mentry.format).serialize_for_put(
-          meta: meta, body: body, content: content, path: path,
-        )
-      end
-
-      # Pure I/O: resolve path, validate etag, delete from disk, audit. No
-      # permission check and no event firing — those are handled by the caller
-      # (Application::Writes::Delete).
-      def delete_envelope_from_disk(key, ctx:, if_etag: nil)
-        _, path, = @manifest.resolve(key)
-        raise UnknownKey.new(key, suggestions: @manifest.suggestions_for(key)) unless File.exist?(path)
-
-        etag_before = Etag.for_file(path)
-        raise EtagMismatch.new(key, if_etag, etag_before) if if_etag && if_etag != etag_before
-
-        File.delete(path)
-        @store.audit_log.append(
-          role: ctx.role, verb: "delete", key: key,
-          etag_before: etag_before, etag_after: nil,
-          extras: ctx.correlation_id ? { "correlation_id" => ctx.correlation_id } : nil
-        )
-      end
-    end
-  end
-end