textus 0.55.1 → 0.56.0

data/lib/textus/manifest/entry/publish/to_paths.rb

@@ -1,76 +0,0 @@
-require "tempfile"
-
-module Textus
-  class Manifest
-    class Entry
-      module Publish
-        # publish.to: render or copy the entry's stored data to each fixed repo path.
-        # The behaviour of any entry that declares `publish: [{ to: ... }, ...]`.
-        # ADR 0094: iterates publish_targets (to-targets), rendering through a
-        # template when the target declares one, or copying verbatim otherwise.
-        class ToPaths < Mode
-          def initialize(entry, publisher: Textus::Port::Publisher.new)
-            super(entry)
-            @publisher = publisher
-          end
-
-          def publish(pctx, prefix: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/AbcSize
-            targets = entry.publish_targets.select(&:to_target?)
-
-            return nil if targets.empty?
-
-            data_path = pctx.manifest.resolver.resolve(entry.key).path
-            envelope  = pctx.reader.call(entry.key)
-            renderer  = Textus::Produce::Render.new(template_loader: ->(n) { pctx.read_template(n) })
-            content = nil # parsed lazily; the data's `content` (always _meta-free)
-
-            targets.each do |t|
-              if t.renders?
-                content ||= Textus::Format.for(entry.format).parse(File.read(data_path), path: data_path)["content"]
-                publish_bytes(render_bytes(t, content, renderer, pctx), entry.key, t, pctx, data_path, envelope)
-              elsif strip_meta?(entry)
-                content ||= Textus::Format.for(entry.format).parse(File.read(data_path), path: data_path)["content"]
-                bytes = Textus::Format.for(entry.format).serialize(meta: {}, body: "", content: content)
-                publish_bytes(bytes, entry.key, t, pctx, data_path, envelope)
-              else
-                # opaque / command / non-structured — publish the stored file as-is
-                target_abs = File.join(pctx.repo_root, t.to)
-                @publisher.publish(source: data_path, target: target_abs, store_root: pctx.root)
-                pctx.emit(:entry_published, key: entry.key, envelope: envelope, source: data_path, target: target_abs)
-              end
-            end
-
-            { kind: :built, value: { "key" => entry.key, "path" => data_path, "published_to" => targets.map(&:to) } }
-          end
-
-          private
-
-          def strip_meta?(entry)
-            %w[json yaml].include?(entry.format.to_s)
-          end
-
-          def render_bytes(target, content, renderer, pctx)
-            boot = target.inject_boot ? Textus::Boot.build(container: pctx.container) : nil
-            renderer.bytes_for(target: target, data: content, boot: boot)
-          end
-
-          # Write bytes to a system temp, publish (recording the persistent data
-          # file as the sentinel source), then remove the temp — the store is
-          # never polluted with render artifacts.
-          def publish_bytes(bytes, key, target, pctx, data_path, envelope)
-            target_abs = File.join(pctx.repo_root, target.to)
-            Tempfile.create(["textus-publish", File.extname(target.to)]) do |f|
-              f.binmode
-              f.write(bytes)
-              f.flush
-              @publisher.publish(
-                source: f.path, target: target_abs, store_root: pctx.root, provenance_source: data_path,
-              )
-            end
-            pctx.emit(:entry_published, key: key, envelope: envelope, source: data_path, target: target_abs)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/publish/tree.rb

@@ -1,50 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Publish
-        # publish_tree (ADR 0047): mirror this entry's whole subtree to one
-        # target dir by real path. No resolver, no keys — files are opaque
-        # payload (envelope nil). The prune honors `ignore` so a derived index
-        # (e.g. a SKILL.md written by a separate entry into the same dir)
-        # survives the whole-target prune (ADR 0047 D4).
-        class Tree < Mode
-          # Mirrored files are opaque payload, never addressable keys (ADR 0047).
-          def keyless? = true
-
-          def publish(pctx, prefix: nil) # rubocop:disable Lint/UnusedMethodArgument
-            target_rel = entry.publish_tree
-            target_dir = repo_abs(pctx, target_rel)
-            unless inside_repo?(pctx, target_dir)
-              raise Textus::PublishError.new(
-                "entry '#{entry.key}': publish_tree target '#{target_rel}' escapes repo root",
-              )
-            end
-
-            result = SubtreeMirror.new(entry, pctx).mirror(
-              base: store_base(pctx),
-              walk_root: store_base(pctx),
-              target_dir: target_dir,
-              key: entry.key,
-              envelope: nil,
-              prune_honors_ignore: true,
-            )
-            { kind: :leaves, value: result[:written], pruned: result[:pruned] }
-          end
-
-          def validate!
-            publish_tree = entry.publish_tree
-            raise UsageError.new("entry '#{entry.key}': publish.tree must be a string") unless publish_tree.is_a?(String)
-
-            used_vars = publish_tree.scan(Template::VAR_RE).flatten
-            return if used_vars.empty?
-
-            raise UsageError.new(
-              "entry '#{entry.key}': publish.tree names a single directory and takes no template variable(s) " \
-              "#{used_vars.map { |v| "{#{v}}" }.join(", ")} — it mirrors the whole subtree to one target dir.",
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/publish.rb

@@ -1,45 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      # ADR 0049: the publish design is a key-split concept (ADR 0047 table)
-      # realized as one resolved sum type. Each directory entry resolves, once,
-      # to one Publish::* mode that owns its publish algorithm — no nil-cascade,
-      # no pairwise exclusivity guards, one shared subtree mirror. ADR 0051
-      # removed `publish_each` (both leaf modes); ADR 0052 folded the two surviving
-      # keys into one `publish:` block (`to:` xor `tree:`). The surface is two modes:
-      #
-      #   None      — nothing to publish (no publish: block)
-      #   ToPaths   — publish: { to: [...] }  — 1 stored file -> N fixed repo paths
-      #   Tree      — publish: { tree: "dir" } — whole entry subtree -> 1 dir, no keys
-      module Publish
-        # Resolve an entry to its single publish mode. The publish config is the
-        # ADR 0052 `publish:` block, sourced into entry.publish_to/publish_tree.
-        # Raises one UsageError if both `publish.to` and `publish.tree` are set —
-        # the block groups the two but does not make exclusivity structural, so
-        # this stays the one enforcement point (ADR 0052 D2).
-        def self.resolve(entry)
-          set = []
-          set << "publish.to"   unless Array(entry.publish_to).empty?
-          set << "publish.tree" unless entry.publish_tree.nil?
-
-          if set.length > 1
-            raise Textus::UsageError.new(
-              "entry '#{entry.key}': #{set.join(" and ")} are mutually exclusive — an entry publishes exactly one way",
-            )
-          end
-
-          mode_for(entry, set.first)
-        end
-
-        def self.mode_for(entry, key)
-          case key
-          when "publish.to"   then ToPaths.new(entry)
-          when "publish.tree" then Tree.new(entry)
-          else None.new(entry)
-          end
-        end
-        private_class_method :mode_for
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/validators/format_matrix.rb

@@ -1,21 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Validators
-        module FormatMatrix
-          def self.call(entry, policy:) # rubocop:disable Lint/UnusedMethodArgument
-            begin
-              Textus::Format.for(entry.format).validate_path_extension(entry.path, entry.nested?)
-            rescue UsageError => e
-              raise UsageError.new("entry '#{entry.key}': #{e.message}")
-            end
-
-            return unless entry.format == "text" && !entry.schema.nil?
-
-            raise UsageError.new("entry '#{entry.key}': text format must not declare a schema")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/validators/ignore.rb

@@ -1,28 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Validators
-        # Validates the per-entry `ignore:` field (ADR 0042): a list of
-        # non-empty glob strings, allowed only on nested entries.
-        module Ignore
-          def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
-            patterns = entry.raw["ignore"]
-            return if patterns.nil?
-
-            raise UsageError.new("entry '#{entry.key}': ignore requires nested: true") unless entry.nested?
-
-            raise UsageError.new("entry '#{entry.key}': ignore must be a list of glob strings") unless patterns.is_a?(Array)
-
-            patterns.each do |pat|
-              next if pat.is_a?(String) && !pat.empty?
-
-              raise UsageError.new(
-                "entry '#{entry.key}': each ignore pattern must be a non-empty string (got #{pat.inspect})",
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/validators/publish.rb

@@ -1,30 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Validators
-        # ADR 0049: one publish validator. Exclusivity among the publish keys is
-        # enforced structurally by Publish.resolve (reached via #publish_mode),
-        # and each mode's shape rules run *because that mode resolved* — replacing
-        # the scattered pairwise "not-both" guards of the old PublishEach +
-        # PublishTree validators. Misuse on a non-nested entry is still caught
-        # here from raw, since the typed attrs stub nil on Base. (publish_each was
-        # removed in 0.42.0 — ADR 0051; the publish_to/publish_tree keys were folded
-        # into the `publish:` block in 0.43.0 — ADR 0052; Schema rejects the retired
-        # flat keys at load.)
-        module Publish
-          def self.call(entry, policy: nil) # rubocop:disable Lint/UnusedMethodArgument
-            unless entry.nested?
-              # ADR 0094: publish: is now a list; use publish_tree (derived reader)
-              # rather than raw.dig("publish", "tree") which breaks on an Array.
-              raise UsageError.new("entry '#{entry.key}': publish.tree requires nested: true") if entry.publish_tree
-
-              return
-            end
-
-            entry.publish_mode.validate!
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry/validators.rb

@@ -1,18 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      module Validators
-        REGISTERED = [
-          Publish,
-          Ignore,
-          FormatMatrix,
-        ].freeze
-
-        def self.run_all(entry, policy:)
-          REGISTERED.each { |v| v.call(entry, policy: policy) }
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/entry.rb

@@ -1,8 +0,0 @@
-module Textus
-  class Manifest
-    class Entry
-      # Populated by each Entry::* subclass at load time.
-      REGISTRY = {}
-    end
-  end
-end

data/lib/textus/manifest/policy/matcher.rb

@@ -1,51 +0,0 @@
-module Textus
-  class Manifest
-    class Policy
-      module Matcher
-        module_function
-
-        def matches?(glob, key)
-          glob_segs = glob.split(".")
-          key_segs  = key.split(".")
-          consume(glob_segs, key_segs)
-        end
-
-        def specificity(glob)
-          glob.split(".").reduce(0) do |s, seg|
-            s + case seg
-                when "**" then 0
-                when "*"  then 1
-                else 10
-                end
-          end
-        end
-
-        def pick_most_specific(globs, key:)
-          matching = globs.select { |g| matches?(g, key) }
-          return nil if matching.empty?
-
-          matching.max_by { |g| [specificity(g), -g.length, g] }
-        end
-
-        def self.consume(glob_segs, key_segs)
-          return key_segs.empty? if glob_segs.empty?
-
-          head = glob_segs.first
-          rest = glob_segs[1..]
-
-          if head == "**"
-            return true if rest.empty?
-
-            (0..key_segs.length).any? { |i| consume(rest, key_segs[i..]) }
-          elsif key_segs.empty?
-            false
-          elsif head == "*" || head == key_segs.first
-            consume(rest, key_segs[1..])
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/policy/publish_target.rb

@@ -1,34 +0,0 @@
-module Textus
-  class Manifest
-    class Policy
-      # One publish destination (ADR 0094). Exactly one of:
-      #   to-target   { to:, template:?, inject_boot:? }  — render data through a
-      #               template, or copy verbatim when no template
-      #   tree-target { tree: }                           — ADR 0052 subtree mirror
-      # Provenance is NOT a publish flag — it lives in the data's `_meta`.
-      class PublishTarget
-        attr_reader :to, :tree, :template, :inject_boot
-
-        def initialize(raw)
-          if raw.key?("provenance")
-            raise Textus::BadManifest.new("publish `provenance:` was removed (ADR 0094): provenance lives in the data's `_meta`")
-          end
-
-          @to   = raw["to"]
-          @tree = raw["tree"]
-          raise Textus::BadManifest.new("a publish target needs exactly one of `to:` or `tree:`") unless @to.nil? ^ @tree.nil?
-
-          @template    = raw["template"]
-          @inject_boot = raw["inject_boot"] == true
-          return unless tree_target? && (@template || @inject_boot)
-
-          raise Textus::BadManifest.new("a tree target takes no template/inject_boot (ADR 0094)")
-        end
-
-        def to_target?   = !@to.nil?
-        def tree_target? = !@tree.nil?
-        def renders?     = to_target? && !@template.nil?
-      end
-    end
-  end
-end

data/lib/textus/manifest/policy/react.rb

@@ -1,30 +0,0 @@
-module Textus
-  class Manifest
-    class Policy
-      class React
-        ALLOWED_KEYS = %w[on when do scope budget idempotency observe priority].freeze
-
-        attr_reader :raw
-
-        def initialize(raw:)
-          raise Textus::BadManifest.new("react: must be a map") unless raw.is_a?(Hash)
-
-          raw = raw.each_with_object({}) do |(key, value), out|
-            normalized = key == true ? "on" : key.to_s
-            out[normalized] = value
-          end
-          raise Textus::BadManifest.new("react.ttl is invalid; ttl belongs only to source.ttl or retention.ttl") if raw.key?("ttl")
-
-          unknown = raw.keys - ALLOWED_KEYS
-          raise Textus::BadManifest.new("react: unknown key(s): #{unknown.join(", ")}") unless unknown.empty?
-
-          @raw = raw
-        end
-
-        def to_h
-          @raw
-        end
-      end
-    end
-  end
-end

data/lib/textus/manifest/policy/retention.rb

@@ -1,29 +0,0 @@
-module Textus
-  class Manifest
-    class Policy
-      # Garbage collection (ADR 0093). A glob-matched rule slot: when an entry
-      # ages past `ttl`, retire it. Destructive only — runs on the full
-      # `converge` pass, never on a write (ADR 0079's invariant). Orthogonal to
-      # production (`source:`): an intake entry can re-pull hourly AND archive
-      # after 90 days. `warn`/`refresh` are gone (refresh is implied by an
-      # intake source; warn never fired after ADR 0089's pure-read get).
-      class Retention
-        ACTIONS = %i[drop archive].freeze
-
-        attr_reader :action
-
-        def initialize(raw)
-          @ttl = raw["ttl"] or
-            raise Textus::BadManifest.new("retention requires a 'ttl:'")
-          @action = (raw["action"] || "").to_s.to_sym
-          return if ACTIONS.include?(@action)
-
-          raise Textus::BadManifest.new("retention action must be one of #{ACTIONS.join("|")}, got #{raw["action"].inspect}")
-        end
-
-        def ttl_seconds = Textus::Core::Duration.seconds(@ttl)
-        def destructive? = true
-      end
-    end
-  end
-end

data/lib/textus/manifest/policy/source.rb

@@ -1,30 +0,0 @@
-module Textus
-  class Manifest
-    class Policy
-      # An entry's external-generator declaration. `source:` now means ONLY
-      # `from: external` — out-of-band runner; textus never invokes it, only
-      # detects drift (doctor generator_drift check).
-      # `from: fetch` and `from: derive` are removed; those concerns now live
-      # in workflow files under .textus/workflows/.
-      class Source
-        attr_reader :command, :sources
-
-        def initialize(raw)
-          from = raw["from"].to_s
-          unless from == "external"
-            raise Textus::BadManifest.new(
-              "from: #{from} is removed — use a workflow file under .textus/workflows/ instead",
-            )
-          end
-
-          @command = raw["command"] or
-            raise Textus::BadManifest.new("source (from: external) requires a `command:` field")
-          @sources = raw["sources"] || []
-        end
-
-        def external? = true
-        def kind      = :external
-      end
-    end
-  end
-end

data/lib/textus/manifest/policy.rb

@@ -1,95 +0,0 @@
-module Textus
-  class Manifest
-    # Authority over lanes and roles derived from a Manifest::Data snapshot.
-    # Encapsulates the lookups previously living on Manifest itself
-    # (lane_writers, permission_for). Write authority is derived from
-    # capabilities x lane-kind (ADR 0030): each lane-kind requires one verb
-    # (Schema::KIND_REQUIRES_VERB) and a role may write a lane iff its caps
-    # include that verb (verb_for_lane, roles_with_capability). Derived /
-    # proposal-queue status is authoritative via the declared-kind family
-    # (declared_kind, derived_entry?, queue_lane?, queue_lane).
-    class Policy
-      def initialize(data)
-        @data = data
-      end
-
-      # The capability a lane's kind requires to be written, or nil if the
-      # lane declares no kind. declared_kind returns a Symbol; the table is
-      # keyed by String.
-      def verb_for_lane(lane_name)
-        kind = declared_kind(lane_name)
-        kind && Schema::KIND_REQUIRES_VERB[kind.to_s]
-      end
-
-      # Names of roles whose declared caps include `verb`.
-      def roles_with_capability(verb)
-        @data.role_caps.select { |_name, caps| caps.include?(verb) }.keys
-      end
-
-      # The conventional automated proposer: a role that can propose but is not
-      # the author-anchor (so it resolves to `agent`, not `human`, under the
-      # default mapping). Falls back to the first proposer, then nil.
-      def proposer_role
-        proposers = roles_with_capability("propose")
-        (proposers - roles_with_capability("author")).first || proposers.first
-      end
-
-      # The role textus acts AS for a system-initiated operation requiring
-      # `verb` (no human passed --as). Capability-derived — a role name that
-      # exists in the manifest, or nil. Never a hardcoded literal (ADR 0044).
-      def actor_for(verb)
-        roles_with_capability(verb).first
-      end
-
-      # The kind declared on a lane in the manifest, or nil if undeclared.
-      def declared_kind(lane_name)
-        @data.declared_lane_kinds[lane_name]
-      end
-
-      # Lane names declaring `kind` (a Symbol), in manifest order. Lets callers
-      # (boot) name a kind's live lane instance(s) instead of hardcoding names.
-      def lanes_of_kind(kind)
-        @data.declared_lane_kinds.select { |_name, k| k == kind }.keys
-      end
-
-      # The single lane declaring `kind: queue`, or nil. Schema guarantees <=1.
-      def queue_lane
-        @data.declared_lane_kinds.key(:queue)
-      end
-
-      # ADR 0091: derived-ness is a property of the ENTRY, not its lane (one
-      # machine lane holds both intake and derived entries). Resolve the entry
-      # and ask it directly. Returns false if entries are not yet built
-      # (validator phase during Data#initialize) — validators must not rely on
-      # cross-entry state during construction.
-      def derived_entry?(_key)
-        false
-      end
-
-      # The single lane declaring kind: machine, or nil.
-      def machine_lane
-        @data.declared_lane_kinds.key(:machine)
-      end
-
-      # A lane is a proposal queue iff it declares kind: queue.
-      def queue_lane?(lane_name)
-        declared_kind(lane_name) == :queue
-      end
-
-      # The lane a proposer role writes proposals into: the single lane that
-      # declares kind: queue, when the role can write it. Returns nil if there
-      # is no queue lane or the role cannot write it.
-      def propose_lane_for(role)
-        return nil if role.nil?
-
-        q = queue_lane
-        return nil unless q
-
-        q_verb = verb_for_lane(q)
-        return nil unless roles_with_capability(q_verb).include?(role)
-
-        q
-      end
-    end
-  end
-end

data/lib/textus/manifest/resolver.rb

@@ -1,118 +0,0 @@
-module Textus
-  class Manifest
-    class Resolver
-      Resolution = ::Data.define(:entry, :path, :remaining)
-
-      def initialize(data)
-        @data = data
-      end
-
-      def resolve(key)
-        @data.validate_key!(key)
-        segments = key.split(".")
-        candidates = @data.entries
-                          .map { |e| [e, e.key.split(".")] }
-                          .select { |(_, esegs)| esegs == segments[0, esegs.length] }
-                          .sort_by { |(_, esegs)| -esegs.length }
-        raise UnknownKey.new(key, suggestions: suggestions_for(key)) if candidates.empty?
-
-        entry, esegs = candidates.first
-        remaining = segments[esegs.length..]
-        build_resolution(entry, remaining, key)
-      end
-
-      def suggestions_for(key)
-        candidates = enumerate.map { |r| r[:key] }
-        candidates.concat(@data.entries.reject { |e| nested_entry?(e) }.map(&:key))
-        candidates.uniq!
-        Key::Distance.suggest(key, candidates, limit: 5)
-      rescue StandardError
-        []
-      end
-
-      def enumerate(prefix: nil, include_keyless: false)
-        out = @data.entries.flat_map do |entry|
-          nested_entry?(entry) ? enumerate_nested(entry, include_keyless: include_keyless) : enumerate_leaf(entry)
-        end
-        out.select! { |row| row[:key] == prefix || row[:key].start_with?("#{prefix}.") } if prefix
-        out.sort_by { |row| row[:key] }
-      end
-
-      private
-
-      # Returns true for entries that behave as nested (Nested subclass, or any
-      # entry with nested: true in the raw YAML — e.g. Intake entries covering
-      # a directory of leaf files).
-      def nested_entry?(entry)
-        entry.nested?
-      end
-
-      def build_resolution(entry, remaining, key)
-        if remaining.empty?
-          Resolution.new(entry: entry, path: resolve_leaf_path(entry), remaining: [])
-        else
-          raise UnknownKey.new(key, suggestions: suggestions_for(key)) unless nested_entry?(entry)
-
-          primary_ext = Textus::Format.for(entry.format).extensions.first
-          base = Textus::Key::Path.normalize_relative_path(entry.path)
-          path = File.join(@data.root, base, *remaining) + primary_ext
-          Resolution.new(entry: entry, path: path, remaining: remaining)
-        end
-      end
-
-      def enumerate_leaf(entry)
-        fp = resolve_leaf_path(entry)
-        File.exist?(fp) ? [{ key: entry.key, path: fp, manifest_entry: entry }] : []
-      end
-
-      def enumerate_nested(entry, include_keyless: false)
-        # publish_tree mirrors opaque payload by path — its files are never
-        # enumerated as keys (ADR 0047). Ask the resolved mode, not the path.
-        # The `include_keyless:` override is used only by the projection lister
-        # so that `from: project` selects can read source data from keyless
-        # nested entries (e.g. knowledge.decisions) without exposing them as
-        # addressable store keys in the public `list` surface.
-        return [] if entry.publish_mode.keyless? && !include_keyless
-
-        base = File.join(@data.root, Textus::Key::Path.normalize_relative_path(entry.path))
-        return [] unless File.directory?(base)
-
-        Dir.glob(File.join(base, nested_glob(entry.format)))
-           .filter_map { |path| nested_row_for(entry, base, path) }
-      end
-
-      def nested_row_for(entry, base, path)
-        rel = path.sub(%r{\A#{Regexp.escape(base)}/?}, "")
-        return nil if entry.ignored?(rel)
-
-        stripped = rel.sub(/#{Regexp.escape(File.extname(rel))}\z/, "")
-        segs = stripped.split("/").reject { |s| s.empty? || s == "." }
-        return nil if segs.empty?
-
-        illegal = segs.find { |s| !valid_segment?(s) }
-        if illegal
-          warn("textus: skipping illegal key segment '#{illegal}' at #{path} — " \
-               "rename to match [a-z0-9][a-z0-9-]* (run 'textus doctor' for the full list)")
-          return nil
-        end
-
-        { key: (entry.key.split(".") + segs).join("."), path: path, manifest_entry: entry }
-      end
-
-      def valid_segment?(seg)
-        return false if seg.nil? || seg.empty?
-        return false if seg.length > Key::Grammar::MAX_SEGMENT_LEN
-
-        seg.match?(Key::Grammar::SEGMENT)
-      end
-
-      def resolve_leaf_path(entry)
-        Textus::Key::Path.resolve(@data, entry)
-      end
-
-      def nested_glob(format)
-        Textus::Format.for(format).nested_glob
-      end
-    end
-  end
-end