textus 0.3.0 → 0.5.0

data/lib/textus/store/mover.rb

@@ -0,0 +1,118 @@
+require "fileutils"
+
+module Textus
+  class Store
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    class Mover
+      def initialize(store)
+        @store = store
+      end
+
+      def call(old_key, new_key, as: Role::DEFAULT, dry_run: false)
+        @store.manifest.validate_key!(old_key)
+        @store.manifest.validate_key!(new_key)
+        raise UsageError.new("mv: old and new keys are identical") if old_key == new_key
+
+        old_mentry, old_path, = @store.manifest.resolve(old_key)
+        raise UnknownKey.new(old_key) unless File.exist?(old_path)
+
+        new_mentry, new_path, = @store.manifest.resolve(new_key)
+
+        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
+        if old_mentry.format != new_mentry.format
+          raise UsageError.new(
+            "mv: format mismatch (#{old_mentry.format} → #{new_mentry.format}); refusing.",
+          )
+        end
+
+        writers = @store.manifest.zone_writers(old_mentry.zone)
+        raise WriteForbidden.new(old_key, old_mentry.zone, writers: writers) unless writers.include?(as)
+
+        raise UsageError.new("mv: target '#{new_key}' already exists at #{new_path}") if File.exist?(new_path)
+
+        # Mint uid before the move so the audit row carries it.
+        pre_env = @store.get(old_key)
+        current_uid = pre_env["uid"]
+        etag_before = pre_env["etag"]
+
+        if dry_run
+          return {
+            "protocol" => PROTOCOL, "ok" => true, "dry_run" => true,
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_path, "to_path" => new_path,
+            "uid" => current_uid
+          }
+        end
+
+        if current_uid.nil?
+          # Write the uid in place first so the source file carries it before mv.
+          pre_env = @store.put(old_key,
+                               meta: pre_env["_meta"],
+                               body: pre_env["body"],
+                               content: pre_env["content"],
+                               as: as,
+                               suppress_events: true)
+          current_uid = pre_env["uid"]
+          etag_before = pre_env["etag"]
+        end
+
+        FileUtils.mkdir_p(File.dirname(new_path))
+        FileUtils.mv(old_path, new_path)
+        rewrite_name_for_mv!(new_mentry, new_path, new_key)
+        etag_after = Etag.for_file(new_path)
+
+        @store.audit_log.append(
+          role: as, verb: "mv", key: new_key,
+          etag_before: etag_before, etag_after: etag_after,
+          extras: {
+            "from_key" => old_key, "to_key" => new_key,
+            "from_path" => old_path, "to_path" => new_path,
+            "uid" => current_uid
+          }
+        )
+
+        env = @store.get(new_key)
+        {
+          "protocol" => PROTOCOL, "ok" => true,
+          "from_key" => old_key, "to_key" => new_key,
+          "from_path" => old_path, "to_path" => new_path,
+          "uid" => current_uid,
+          "envelope" => env
+        }
+      end
+
+      private
+
+      # 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
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+  end
+end

data/lib/textus/store/staleness.rb

@@ -0,0 +1,142 @@
+require "time"
+
+module Textus
+  class Store
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+    class Staleness
+      def initialize(store)
+        @store = store
+      end
+
+      def call(prefix: nil, zone: nil)
+        out = []
+        @store.manifest.entries.each do |mentry|
+          next unless mentry.zone == "derived"
+          next if zone && mentry.zone != zone
+
+          gen = mentry.generator
+          next unless gen
+          next if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
+
+          path = path_for_entry(mentry)
+
+          unless File.exist?(path)
+            out << stale_row(mentry, path, "derived entry has never been generated")
+            next
+          end
+
+          raw = File.binread(path)
+          parsed = Entry.for_format(mentry.format).parse(raw, path: path)
+          generated_at = parsed["_meta"].dig("generated", "at")
+          unless generated_at
+            out << stale_row(mentry, path, "missing generated.at frontmatter")
+            next
+          end
+          gen_time = begin
+            Time.parse(generated_at.to_s)
+          rescue StandardError
+            nil
+          end
+          unless gen_time
+            out << stale_row(mentry, path, "unparseable generated.at: #{generated_at.inspect}")
+            next
+          end
+
+          offender = newest_source_after(gen, gen_time)
+          out << stale_row(mentry, path, "source '#{offender}' modified after generated.at") if offender
+        end
+
+        @store.manifest.entries.each do |mentry|
+          next unless mentry.action
+          next if zone && mentry.zone != zone
+          next if prefix && !(mentry.key == prefix || mentry.key.start_with?("#{prefix}."))
+
+          ttl = parse_ttl(mentry.ttl)
+          next unless ttl
+
+          path = path_for_entry(mentry)
+
+          unless File.exist?(path)
+            out << intake_stale_row(mentry, path, "never refreshed")
+            next
+          end
+
+          meta = Entry.for_format(mentry.format).parse(File.binread(path), path: path)["_meta"]
+          last_str = meta["last_refreshed_at"]
+          if last_str.nil?
+            out << intake_stale_row(mentry, path, "never refreshed (no last_refreshed_at)")
+            next
+          end
+
+          last = begin
+            Time.parse(last_str.to_s)
+          rescue StandardError
+            nil
+          end
+          out << intake_stale_row(mentry, path, "ttl exceeded (#{ttl}s)") if last.nil? || (Time.now - last) > ttl
+        end
+
+        out
+      end
+
+      private
+
+      def path_for_entry(mentry)
+        primary_ext = Entry.for_format(mentry.format).extensions.first
+        if File.extname(mentry.path) == ""
+          File.join(@store.root, "zones", mentry.path + primary_ext)
+        else
+          File.join(@store.root, "zones", mentry.path)
+        end
+      end
+
+      def newest_source_after(gen, gen_time)
+        Array(gen["sources"]).each do |src|
+          if src.match?(/\A[a-z0-9.][a-z0-9._-]*\z/) && !src.include?("/")
+            @store.manifest.enumerate(prefix: src).each do |row|
+              return src if File.mtime(row[:path]) > gen_time
+            end
+          else
+            abs = File.absolute_path?(src) ? src : File.join(File.dirname(@store.root), src)
+            if File.directory?(abs)
+              Dir.glob(File.join(abs, "**", "*")).each do |fp|
+                next unless File.file?(fp)
+                return src if File.mtime(fp) > gen_time
+              end
+            elsif File.exist?(abs)
+              return src if File.mtime(abs) > gen_time
+            end
+          end
+        end
+        nil
+      end
+
+      def parse_ttl(s)
+        return nil unless s
+
+        m = s.to_s.match(/\A(\d+)([smhd])\z/) or return nil
+        n = m[1].to_i
+        case m[2]
+        when "s" then n
+        when "m" then n * 60
+        when "h" then n * 3600
+        when "d" then n * 86_400
+        end
+      end
+
+      def intake_stale_row(mentry, path, reason)
+        { "key" => mentry.key, "path" => path, "action" => mentry.action, "reason" => reason }
+      end
+
+      def stale_row(mentry, path, reason)
+        {
+          "key" => mentry.key,
+          "path" => path,
+          "generator" => mentry.generator,
+          "reason" => reason,
+        }
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/BlockLength
+  end
+end

data/lib/textus/store/validator.rb

@@ -0,0 +1,53 @@
+module Textus
+  class Store
+    class Validator
+      def initialize(store)
+        @store = store
+      end
+
+      def call
+        violations = []
+        @store.manifest.enumerate.each do |row|
+          begin
+            @store.get(row[:key])
+          rescue Textus::Error => e
+            violations << { "key" => row[:key], "code" => e.code, "message" => e.message }
+          end
+        end
+
+        @store.manifest.enumerate.each do |row|
+          mentry = row[:manifest_entry]
+          next unless mentry.schema
+
+          schema = @store.schema_for(mentry.schema)
+          next unless schema
+
+          env = begin
+            @store.get(row[:key])
+          rescue StandardError
+            next
+          end
+          last_writer = @store.audit_log.last_writer_for(row[:key])
+          next if last_writer.nil?
+
+          env["_meta"].each_key do |field|
+            owner = schema.maintained_by(field)
+            next if owner.nil?
+            next if last_writer == owner
+            next if last_writer == "human"
+
+            violations << {
+              "key" => row[:key],
+              "code" => "role_authority",
+              "field" => field,
+              "expected" => owner,
+              "last_writer" => last_writer,
+            }
+          end
+        end
+
+        { "protocol" => PROTOCOL, "ok" => violations.empty?, "violations" => violations }
+      end
+    end
+  end
+end