textus 0.5.0 → 0.8.0

data/lib/textus/extensions.rb

@@ -1,33 +0,0 @@
-module Textus
-  THREAD_REGISTRY_KEY = :__textus_active_registry__
-  private_constant :THREAD_REGISTRY_KEY
-
-  def self.with_registry(registry)
-    prev = Thread.current[THREAD_REGISTRY_KEY]
-    Thread.current[THREAD_REGISTRY_KEY] = registry
-    yield
-  ensure
-    Thread.current[THREAD_REGISTRY_KEY] = prev
-  end
-
-  def self.current_registry
-    Thread.current[THREAD_REGISTRY_KEY] or
-      raise UsageError.new("no active registry; extension code must be loaded by a Store")
-  end
-
-  def self.action(name, &)
-    current_registry.register_action(name, &)
-  end
-
-  def self.reducer(name, &)
-    current_registry.register_reducer(name, &)
-  end
-
-  def self.hook(event, name, &)
-    current_registry.register_hook(event, name, &)
-  end
-
-  def self.doctor_check(name, &)
-    current_registry.register_doctor_check(name, &)
-  end
-end

data/lib/textus/key_distance.rb

@@ -1,53 +0,0 @@
-module Textus
-  # Small utilities for ranking key suggestions. Bounded inputs only —
-  # Levenshtein is O(n*m) so we refuse to compute on long strings.
-  module KeyDistance
-    MAX_LEN = 200
-
-    # Length of the shared dot-separated prefix between two dotted keys.
-    def self.shared_prefix_segments(left, right)
-      asegs = left.split(".")
-      bsegs = right.split(".")
-      n = [asegs.length, bsegs.length].min
-      i = 0
-      i += 1 while i < n && asegs[i] == bsegs[i]
-      i
-    end
-
-    # Classic iterative Levenshtein with two rows. Bounded to MAX_LEN.
-    def self.levenshtein(left, right)
-      return nil if left.length > MAX_LEN || right.length > MAX_LEN
-      return right.length if left.empty?
-      return left.length if right.empty?
-
-      prev = (0..right.length).to_a
-      curr = Array.new(right.length + 1, 0)
-      (1..left.length).each do |i|
-        curr[0] = i
-        (1..right.length).each do |j|
-          cost = left[i - 1] == right[j - 1] ? 0 : 1
-          curr[j] = [
-            curr[j - 1] + 1,      # insertion
-            prev[j] + 1,          # deletion
-            prev[j - 1] + cost,   # substitution
-          ].min
-        end
-        prev, curr = curr, prev
-      end
-      prev[right.length]
-    end
-
-    # Rank candidate keys against requested. Returns up to `limit` keys.
-    # Sort: longer shared prefix first; then smaller Levenshtein distance.
-    def self.suggest(requested, candidates, limit: 5)
-      return [] if requested.nil? || requested.empty?
-
-      scored = candidates.first(200).map do |k|
-        prefix = shared_prefix_segments(requested, k)
-        dist = levenshtein(requested, k) || Float::INFINITY
-        [k, prefix, dist]
-      end
-      scored.sort_by { |(_, prefix, dist)| [-prefix, dist] }.first(limit).map(&:first)
-    end
-  end
-end

data/lib/textus/manifest_entry.rb

@@ -1,185 +0,0 @@
-module Textus
-  class ManifestEntry
-    PUBLISH_EACH_VARS = %w[leaf basename key ext].freeze
-    PUBLISH_EACH_VAR_RE = /\{([a-z]+)\}/
-
-    attr_reader :key, :path, :zone, :schema, :owner, :nested, :generator, :raw, :format,
-                :projection, :template, :publish_to, :publish_each, :action, :action_config, :ttl, :events,
-                :inject_intro
-
-    def initialize(manifest, raw)
-      @manifest = manifest
-      @raw = raw
-      @key = raw["key"] or raise UsageError.new("manifest entry missing key")
-      @path = raw["path"] or raise UsageError.new("manifest entry '#{@key}' missing path")
-      @zone = raw["zone"] or raise UsageError.new("manifest entry '#{@key}' missing zone")
-      @schema = raw["schema"]
-      @owner = raw["owner"]
-      @nested = raw["nested"] == true
-      @generator = raw["generator"]
-      @projection = raw["projection"]
-      @template = raw["template"]
-      @publish_to = Array(raw["publish_to"])
-      @publish_each = raw["publish_each"]
-      @events = raw["events"] || {}
-      @inject_intro = raw["inject_intro"] == true
-      @format = resolve_format!(raw["format"])
-
-      validate_events!
-      parse_source!(raw["source"])
-      validate_format_matrix!
-      validate_publish_each!
-      validate_inject_intro!
-    end
-
-    # Resolves the per-leaf target path (relative to repo root) for a full
-    # dotted key under this entry's prefix. Returns nil if this entry has no
-    # publish_each template.
-    def publish_target_for(full_key)
-      return nil if @publish_each.nil?
-
-      entry_segs = @key.split(".")
-      key_segs = full_key.split(".")
-      raise UsageError.new("key '#{full_key}' is not under entry '#{@key}'") unless key_segs[0, entry_segs.length] == entry_segs
-
-      remaining = key_segs[entry_segs.length..] || []
-      leaf = remaining.join("/")
-      basename = remaining.last || ""
-      ext = Entry.for_format(@format).extensions.first.to_s.sub(/^\./, "")
-
-      vars = { "leaf" => leaf, "basename" => basename, "key" => full_key, "ext" => ext }
-      @publish_each.gsub(PUBLISH_EACH_VAR_RE) { vars.fetch(::Regexp.last_match(1)) }
-    end
-
-    def derived?
-      writers = @manifest.zone_writers(@zone)
-      writers.include?("build")
-    rescue UsageError => e
-      raise UsageError.new("entry '#{@key}': #{e.message}")
-    end
-
-    private
-
-    def validate_inject_intro!
-      return unless @inject_intro
-
-      unless derived?
-        raise UsageError.new(
-          "entry '#{@key}': inject_intro: is only valid on derived entries",
-        )
-      end
-      return unless @template.nil?
-
-      raise UsageError.new(
-        "entry '#{@key}': inject_intro: requires a template:",
-      )
-    end
-
-    def validate_publish_each!
-      return if @publish_each.nil?
-
-      raise UsageError.new("entry '#{@key}': publish_each requires nested: true") unless @nested
-      raise UsageError.new("entry '#{@key}': publish_to and publish_each are mutually exclusive") unless @publish_to.empty?
-      raise UsageError.new("entry '#{@key}': publish_each must be a string") unless @publish_each.is_a?(String)
-
-      used_vars = @publish_each.scan(PUBLISH_EACH_VAR_RE).flatten
-      unknown = used_vars - PUBLISH_EACH_VARS
-      unless unknown.empty?
-        raise UsageError.new(
-          "entry '#{@key}': publish_each uses unknown template variable(s) " \
-          "#{unknown.map { |v| "{#{v}}" }.join(", ")}. Known: #{PUBLISH_EACH_VARS.map { |v| "{#{v}}" }.join(", ")}.",
-        )
-      end
-
-      required = %w[leaf basename key]
-      return if used_vars.any? { |v| required.include?(v) }
-
-      raise UsageError.new(
-        "entry '#{@key}': publish_each must reference at least one of {leaf}, {basename}, or {key} " \
-        "(else every leaf would clobber the same target).",
-      )
-    end
-
-    def resolve_format!(declared)
-      ext = File.extname(@path)
-      inferred = Manifest::EXT_TO_FORMAT[ext]
-
-      if declared.nil?
-        return inferred if inferred
-        # No extension: nested defaults to markdown, leaf with no ext also markdown.
-        return "markdown" if ext == "" && @nested
-        return "markdown" if ext == ""
-      else
-        raise UsageError.new("entry '#{@key}': unknown format #{declared.inspect}") unless Manifest::EXT_TO_FORMAT.values.include?(declared)
-        # If the path has an extension, the declared format must match.
-        if ext != "" && inferred && inferred != declared
-          raise UsageError.new(
-            "entry '#{@key}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
-          )
-        end
-        return declared
-      end
-
-      "markdown"
-    end
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def validate_format_matrix!
-      ext = File.extname(@path)
-
-      case @format
-      when "markdown"
-        # .md, or no extension (will be appended). Anything else is a mismatch caught above.
-        raise UsageError.new("entry '#{@key}': markdown format requires '.md' path (got #{ext.inspect})") if ext != "" && ext != ".md"
-      when "json"
-        if @nested
-          # nested json: path is a directory; ext must be empty.
-          raise UsageError.new("entry '#{@key}': nested json path must not have an extension") if ext != ""
-        elsif ext != ".json"
-          raise UsageError.new("entry '#{@key}': json format requires '.json' path (got #{ext.inspect})")
-        end
-      when "yaml"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested yaml path must not have an extension") if ext != ""
-        elsif ext != ".yaml" && ext != ".yml"
-          raise UsageError.new("entry '#{@key}': yaml format requires '.yaml' or '.yml' path (got #{ext.inspect})")
-        end
-      when "text"
-        if @nested
-          raise UsageError.new("entry '#{@key}': nested text path must not have an extension") if ext != ""
-        elsif ext != ".txt" && ext != ""
-          raise UsageError.new("entry '#{@key}': text format requires '.txt' or no extension (got #{ext.inspect})")
-        end
-      end
-
-      # Schema rules.
-      raise UsageError.new("entry '#{@key}': text format must not declare a schema") if @format == "text" && !@schema.nil?
-
-      # Template-required-for-derived rules. Skipped for entries materialized by an
-      # external generator: command (those produce the bytes themselves).
-      if derived? && @template.nil? && @generator.nil? &&
-         (@format == "markdown" || @format == "text") && !@nested
-        raise UsageError.new("entry '#{@key}': derived #{@format} entries require a template")
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def parse_source!(src)
-      src ||= {}
-      @action = src["action"]
-      @action_config = src["config"] || {}
-      @ttl = src["ttl"]
-    end
-
-    def validate_events!
-      @events.each_key do |evt|
-        next if ExtensionRegistry::EVENTS.include?(evt.to_sym)
-
-        raise UsageError.new(
-          "entry '#{@key}': unknown event '#{evt}' in events: block. " \
-          "Known events: #{ExtensionRegistry::EVENTS.join(", ")}.",
-        )
-      end
-    end
-  end
-end

data/lib/textus/migrate_v2.rb

@@ -1,27 +0,0 @@
-require "yaml"
-
-module Textus
-  # One-shot migration: rewrites the manifest version string from textus/1
-  # to textus/2. On-disk entry file shapes are unchanged — the only change
-  # needed is the version: line in manifest.yaml.
-  module MigrateV2
-    def self.run(root)
-      manifest_path = File.join(root, "manifest.yaml")
-      raise IoError.new("manifest not found: #{manifest_path}") unless File.exist?(manifest_path)
-
-      content = File.read(manifest_path)
-      raw = YAML.safe_load(content, aliases: false)
-
-      case raw["version"]
-      when PROTOCOL
-        { "protocol" => PROTOCOL, "ok" => true, "no_op" => true, "message" => "already #{PROTOCOL}" }
-      when "textus/1"
-        new_content = content.sub(%r{^version:\s*textus/1\s*$}, "version: #{PROTOCOL}")
-        File.write(manifest_path, new_content)
-        { "protocol" => PROTOCOL, "ok" => true, "from" => "textus/1", "to" => PROTOCOL }
-      else
-        raise UsageError.new("cannot migrate from #{raw["version"].inspect}")
-      end
-    end
-  end
-end

data/lib/textus/schema_tools.rb

@@ -1,87 +0,0 @@
-require "yaml"
-require "fileutils"
-
-module Textus
-  module SchemaTools
-    # textus schema-init NAME --from=KEY  → infer YAML schema from an entry's frontmatter
-    def self.init(store, name:, from:)
-      env = store.get(from)
-      meta = env["_meta"]
-      schema = {
-        "name" => name,
-        "required" => meta.keys,
-        "optional" => [],
-        "fields" => meta.each_with_object({}) { |(k, v), h| h[k] = { "type" => infer_type(v) } },
-      }
-      FileUtils.mkdir_p(File.join(store.root, "schemas"))
-      target = File.join(store.root, "schemas", "#{name}.yaml")
-      File.write(target, YAML.dump(schema))
-      { "protocol" => PROTOCOL, "schema_name" => name, "path" => target }
-    end
-
-    # textus schema-diff NAME  → list keys whose frontmatter violates the schema
-    def self.diff(store, name:)
-      schema = load_schema(store, name)
-      drift = []
-      store.manifest.enumerate.each do |row|
-        env = store.get(row[:key])
-        begin
-          schema.validate!(env["_meta"])
-        rescue SchemaViolation => e
-          drift << { "key" => row[:key], "details" => e.details }
-        end
-      end
-      { "protocol" => PROTOCOL, "schema_name" => name, "drift" => drift }
-    end
-
-    # textus schema-migrate NAME --rename=OLD:NEW → rewrites frontmatter across affected entries
-    # If --rename is omitted, falls back to schema.evolution.migrate_from.
-    def self.migrate(store, name:, rename: nil)
-      renames =
-        if rename
-          old_field, new_field = rename.split(":", 2)
-          raise UsageError.new("--rename=OLD:NEW") unless old_field && new_field && !new_field.empty?
-
-          { old_field => new_field }
-        else
-          load_schema(store, name).evolution["migrate_from"] || {}
-        end
-      raise UsageError.new("schema-migrate needs --rename=OLD:NEW or schema.evolution.migrate_from") if renames.empty?
-
-      touched = []
-      store.manifest.enumerate.each do |row|
-        env = store.get(row[:key])
-        meta = env["_meta"]
-        changed = false
-        renames.each do |old, new|
-          if meta.key?(old)
-            meta[new] = meta.delete(old)
-            changed = true
-          end
-        end
-        next unless changed
-
-        store.put(row[:key], meta: meta, body: env["body"], as: "human")
-        touched << row[:key]
-      end
-      { "protocol" => PROTOCOL, "migrated" => touched, "renames" => renames }
-    end
-
-    def self.infer_type(value)
-      case value
-      when String  then "string"
-      when Numeric then "number"
-      when true, false then "boolean"
-      when Array   then "array"
-      when Hash    then "object"
-      else "string"
-      end
-    end
-
-    def self.load_schema(store, name)
-      store.schema_for(name)
-    rescue IoError
-      raise UsageError.new("schema not found: #{name}")
-    end
-  end
-end

data/lib/textus/store/events.rb

@@ -1,31 +0,0 @@
-require "timeout"
-
-module Textus
-  class Store
-    class Events
-      HOOK_TIMEOUT_SECONDS = 2
-
-      def initialize(store)
-        @store = store
-      end
-
-      def call(event, **kwargs)
-        view = StoreView.new(@store)
-        @store.registry.hooks(event).each do |entry|
-          name = entry[:name]
-          Timeout.timeout(HOOK_TIMEOUT_SECONDS) { entry[:callable].call(store: view, **kwargs) }
-        rescue StandardError => e
-          extras = { "event" => event.to_s, "hook" => name.to_s, "error" => "#{e.class}: #{e.message}" }
-          extras["target_key"]  = kwargs[:target_key]  if kwargs.key?(:target_key)
-          extras["pending_key"] = kwargs[:pending_key] if kwargs.key?(:pending_key)
-          @store.audit_log.append(
-            role: "script", verb: "event_error",
-            key: kwargs[:key] || kwargs[:target_key] || kwargs[:pending_key] || "-",
-            etag_before: nil, etag_after: nil,
-            extras: extras
-          )
-        end
-      end
-    end
-  end
-end

data/lib/textus/store_view.rb

@@ -1,27 +0,0 @@
-module Textus
-  class StoreView
-    READ_METHODS  = %i[get list where schema_envelope deps rdeps published stale validate_all].freeze
-    WRITE_METHODS = %i[put delete accept].freeze
-
-    def initialize(store, writable: false, as: nil)
-      raise UsageError.new("writable StoreView requires an as: role") if writable && (as.nil? || as.to_s.empty?)
-
-      @store = store
-      @writable = writable
-      @as = as
-    end
-
-    READ_METHODS.each do |m|
-      define_method(m) { |*args, **kw| @store.public_send(m, *args, **kw) }
-    end
-
-    WRITE_METHODS.each do |m|
-      define_method(m) do |*args, **kw|
-        raise UsageError.new("StoreView is read-only") unless @writable
-
-        kw[:as] = @as unless kw.key?(:as)
-        @store.public_send(m, *args, **kw)
-      end
-    end
-  end
-end