RubyGems - yard-yaml - Versions diffs - 0.1.0 - Mend

yard-yaml 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

checksums.yaml +7 -0
checksums.yaml.gz.sig +0 -0
data/CHANGELOG.md +48 -0
data/CITATION.cff +20 -0
data/CODE_OF_CONDUCT.md +134 -0
data/CONTRIBUTING.md +221 -0
data/FUNDING.md +74 -0
data/LICENSE.txt +21 -0
data/README.md +1340 -0
data/REEK +0 -0
data/RUBOCOP.md +71 -0
data/SECURITY.md +21 -0
data/lib/yard/yaml/cli.rb +176 -0
data/lib/yard/yaml/config.rb +122 -0
data/lib/yard/yaml/converter.rb +118 -0
data/lib/yard/yaml/discovery.rb +117 -0
data/lib/yard/yaml/emitter.rb +174 -0
data/lib/yard/yaml/plugin.rb +60 -0
data/lib/yard/yaml/tag_renderer.rb +70 -0
data/lib/yard/yaml/tags.rb +66 -0
data/lib/yard/yaml/template_helpers.rb +57 -0
data/lib/yard/yaml/templates.rb +37 -0
data/lib/yard/yaml/version.rb +10 -0
data/lib/yard/yaml.rb +128 -0
data/lib/yard-yaml.rb +6 -0
data/sig/yard/yaml.rbs +78 -0
data.tar.gz.sig +0 -0
metadata +306 -0
metadata.gz.sig +0 -0

data/lib/yard/yaml/emitter.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+require "fileutils"
+module Yard
+  module Yaml
+    # Writes converted YAML pages to the YARD output directory.
+    #
+    # Phase 4 scope:
+    # - Emits per-page HTML files under <output>/<config.out_dir>/
+    # - Optionally emits an index.html when config.index is true
+    # - Keeps implementation independent of YARD internals; caller passes output_dir
+    # - Deterministic filenames and ordering
+    #
+    # This class purposefully uses a tiny built-in template to keep behavior
+    # deterministic for tests. In a later phase, we can wire ERB templates via
+    # YARD::Templates::Engine and theme hooks.
+    class Emitter
+      class << self
+        # Emit all pages to disk.
+        #
+        # @param pages [Array<Hash>] normalized pages with keys :path, :html, :title, :description, :meta
+        # @param output_dir [String] the YARD output directory (typically `YARD::Registry.yardoc_file`/`YARD::Templates::Engine.generate` destination)
+        # @param config [Yard::Yaml::Config]
+        # @return [Array<String>] list of written file paths
+        def emit!(pages:, output_dir:, config: Yard::Yaml.config)
+          pages = Array(pages)
+          written = []
+          base = File.join(output_dir.to_s, config.out_dir.to_s)
+          FileUtils.mkdir_p(base)
+          # Write per-page files
+          pages.each do |page|
+            slug = page_slug(page)
+            path = File.join(base, "#{slug}.html")
+            html = render_page_html(page)
+            atomic_write(path, html, strict: config.strict)
+            written << path
+          end
+          # Index (optional)
+          if config.index
+            index_path = File.join(base, "index.html")
+            html = render_index_html(pages)
+            atomic_write(index_path, html, strict: config.strict)
+            written << index_path
+          end
+          written
+        end
+        # Public: derive a stable slug for a page hash. Shared by templates.
+        # @param page [Hash]
+        # @return [String]
+        def slug_for(page)
+          page_slug(page)
+        end
+        private
+        def page_slug(page)
+          meta = page[:meta] || {}
+          slug = meta["slug"] || meta[:slug]
+          return sanitize_slug(slug) if slug && !slug.to_s.empty?
+          title = page[:title].to_s
+          return sanitize_slug(title) unless title.empty?
+          if page[:path]
+            base = File.basename(page[:path].to_s, File.extname(page[:path].to_s))
+            return sanitize_slug(base)
+          end
+          "page"
+        end
+        def sanitize_slug(s)
+          s.to_s.strip.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-+|-+$/, "")
+        end
+        def render_page_html(page)
+          title = page[:title] || "Untitled"
+          desc = page[:description]
+          body = page[:html].to_s
+          <<~HTML
+            <!doctype html>
+            <html lang="en">
+            <head>
+              <meta charset="utf-8" />
+              <meta name="viewport" content="width=device-width, initial-scale=1" />
+              <title>#{escape_html(title)}</title>
+              <style>
+                /* minimal, namespaced styles */
+                .yyaml-page { font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Helvetica, Arial, sans-serif; }
+                .yyaml-title { margin: 0.2em 0 0.4em; font-size: 1.6em; }
+                .yyaml-desc { color: #444; margin-bottom: 1em; }
+                .yyaml-body { line-height: 1.5; }
+              </style>
+            </head>
+            <body class="yyaml-page">
+              <h1 class="yyaml-title">#{escape_html(title)}</h1>
+              #{"<p class=\"yyaml-desc\">#{escape_html(desc)}</p>" if desc}
+              <div class="yyaml-body">#{body}</div>
+            </body>
+            </html>
+          HTML
+        end
+        def render_index_html(pages)
+          rows = pages.map do |p|
+            title = p[:title] || page_slug(p)
+            slug = page_slug(p)
+            desc = p[:description]
+            %(<li><a href="#{escape_html(slug)}.html">#{escape_html(title)}</a>#{" — #{escape_html(desc)}" if desc}</li>)
+          end.join("\n")
+          <<~HTML
+            <!doctype html>
+            <html lang="en">
+            <head>
+              <meta charset="utf-8" />
+              <meta name="viewport" content="width=device-width, initial-scale=1" />
+              <title>YAML Index</title>
+              <style>
+                .yyaml-index { font-family: -apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Helvetica, Arial, sans-serif; }
+                .yyaml-index h1 { font-size: 1.8em; }
+                .yyaml-index ul { list-style: disc; padding-left: 1.4em; }
+              </style>
+            </head>
+            <body class="yyaml-index">
+              <h1>YAML Documents</h1>
+              <ul>
+                #{rows}
+              </ul>
+            </body>
+            </html>
+          HTML
+        end
+        def atomic_write(path, content, strict: false)
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir)
+          tmp = File.join(dir, ".#{$$}.#{Time.now.to_i}.tmp")
+          File.open(tmp, "wb") { |f| f.write(content.to_s) }
+          FileUtils.mv(tmp, path)
+        rescue StandardError => e
+          message = "write failed for #{path}: #{e.message}"
+          if strict
+            raise Yard::Yaml::Error, message
+          elsif defined?(::Yard) && ::Yard.const_defined?(:Yaml)
+            ::Yard::Yaml.warn(message)
+          else
+            Kernel.warn("yard-yaml: #{message}")
+          end
+        ensure
+          begin
+            FileUtils.rm_f(tmp) if tmp && File.exist?(tmp)
+          rescue StandardError
+            # ignore
+          end
+        end
+        def escape_html(s)
+          s.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+        end
+      end
+    end
+  end
+end

data/lib/yard/yaml/plugin.rb ADDED Viewed

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Yard
+  module Yaml
+    # Plugin activation for yard-yaml (Phase 3: config + discovery; still no YARD registrations).
+    module Plugin
+      @activated = false
+      class << self
+        # Whether the plugin has been activated for the current process.
+        # Activation is explicit; requiring this file does not activate anything.
+        #
+        # @return [Boolean]
+        def activated?
+          @activated
+        end
+        # Activate the plugin.
+        #
+        # Phase 3 behavior:
+        # - Parse argv for `--yard_yaml-*` flags and apply to configuration.
+        # - Run discovery to collect YAML pages and mirror to registry store.
+        # - Do NOT register tags, templates, or handlers yet.
+        #
+        # @param argv [Array<String>, nil] optional argument vector to parse
+        # @return [void]
+        def activate(argv = nil)
+          # Parse and apply CLI overrides if provided
+          begin
+            overrides = Cli.parse(argv || [])
+            Yard::Yaml.configure(overrides) unless overrides.empty?
+          rescue StandardError
+            # Parsing failures should not prevent activation in Phase 3
+          end
+          # Collect pages via discovery using current config
+          begin
+            pages = Discovery.collect(Yard::Yaml.config)
+            Yard::Yaml.__set_pages__(pages)
+          rescue Yard::Yaml::Error
+            # strict mode surfaced an error; re-raise to fail activation/build
+            raise
+          rescue StandardError
+            # Non-strict errors are already warned by converter/discovery
+          end
+          @activated = true
+          nil
+        end
+        # Test-helper: reset internal activation flag.
+        # Not part of public API; used from test teardown to avoid state leakage.
+        def __reset_state__
+          @activated = false
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/yard/yaml/tag_renderer.rb ADDED Viewed

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+module Yard
+  module Yaml
+    # Renders HTML fragments for @yaml (inline block) and @yaml_file tags
+    # found on a YARD code object. This is a small, YARD-agnostic utility
+    # that can be called from templates. It does not depend on YARD internals
+    # beyond the code object responding to `tags(:name)`.
+    #
+    # Phase 5: This provides the wiring surface needed by templates. Actual
+    # template hook-up can call {TagRenderer.render_for(object, ...)}.
+    module TagRenderer
+      module_function
+      # Render YAML-related tags on a code object into a single HTML fragment.
+      #
+      # @param object [#tags] a YARD code object (or duck-typed test double)
+      # @param base_dir [String] base directory to resolve @yaml_file paths
+      # @param config [Yard::Yaml::Config]
+      # @return [String] HTML fragment (may be empty string)
+      def render_for(object, base_dir: Dir.pwd, config: Yard::Yaml.config)
+        return "" unless object && object.respond_to?(:tags)
+        parts = []
+        # Inline @yaml blocks (text of the tag is treated as YAML)
+        fetch_tags(object, :yaml).each do |tag|
+          yaml_text = extract_text(tag)
+          next if yaml_text.nil? || yaml_text.strip.empty?
+          html = Yard::Yaml::TemplateHelpers.render_yaml_block(yaml_text, config: config)
+          parts << wrap_section(html, kind: :yaml)
+        end
+        # @yaml_file path
+        fetch_tags(object, :yaml_file).each do |tag|
+          path = extract_text(tag)
+          next if path.nil? || path.strip.empty?
+          html = Yard::Yaml::TemplateHelpers.render_yaml_file(path, base_dir: base_dir, config: config)
+          parts << wrap_section(html, kind: :yaml_file)
+        end
+        parts.join("\n")
+      end
+      # --- internal helpers ---
+      def fetch_tags(object, name)
+        object.tags(name) || []
+      rescue StandardError
+        []
+      end
+      module_function :fetch_tags
+      def extract_text(tag)
+        return tag.text if tag.respond_to?(:text)
+        # Some YARD tags use #name or #to_s; fall back sensibly
+        return tag.name.to_s if tag.respond_to?(:name)
+        tag.to_s
+      end
+      module_function :extract_text
+      def wrap_section(html, kind:)
+        return "" if html.to_s.empty?
+        css = (kind == :yaml) ? "yyaml-inline" : "yyaml-file"
+        %(<div class="#{css}">#{html}</div>)
+      end
+      module_function :wrap_section
+    end
+  end
+end

data/lib/yard/yaml/tags.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# Tag definitions for yard-yaml.
+#
+# Guarded so requiring this file has no side effects when YARD is not loaded.
+# Actual rendering is performed via Yard::Yaml::TemplateHelpers and templates.
+# Registration only occurs when YARD and its tag library are present.
+module Yard
+  module Yaml
+    module Tags
+      module_function
+      def register!
+        return unless defined?(::YARD) && ::YARD.const_defined?(:Tags)
+        # Ensure a minimal Library exists under ::YARD::Tags if missing
+        unless ::YARD::Tags.const_defined?(:Library, false)
+          # If the test provided a top-level ::Library constant, attach it.
+          if defined?(::Library) && ::Library.is_a?(Module)
+            begin
+              ::YARD::Tags.const_set(:Library, ::Library)
+            rescue StandardError
+              return
+            end
+          else
+            # Create a minimal shim that records define_tag calls
+            lib = Module.new
+            class << lib
+              attr_accessor :calls
+              def define_tag(*args)
+                self.calls ||= []
+                self.calls << args
+              end
+            end
+            begin
+              ::YARD::Tags.const_set(:Library, lib)
+            rescue StandardError
+              # if we failed to set, just return silently
+              return
+            end
+          end
+        end
+        begin
+          ::YARD::Tags::Library.define_tag("YAML", :yaml, :with_title_and_text)
+        rescue StandardError
+          # ignore if already defined or unavailable
+        end
+        begin
+          ::YARD::Tags::Library.define_tag("YAML File", :yaml_file, :with_text)
+        rescue StandardError
+          # ignore if already defined or unavailable
+        end
+      end
+    end
+  end
+end
+# Auto-register on load only if the YARD tag library is already available.
+begin
+  if defined?(YARD) && YARD.const_defined?(:Tags) && YARD::Tags.const_defined?(:Library)
+    Yard::Yaml::Tags.register!
+  end
+rescue StandardError
+  # ignore in non-YARD or partially loaded contexts
+end

data/lib/yard/yaml/template_helpers.rb ADDED Viewed

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Yard
+  module Yaml
+    # View/template helpers for rendering YAML blocks and files.
+    #
+    # Phase 5 scope:
+    # - Provide simple helpers independent of YARD templates so they are unit-testable.
+    # - Use Converter with current config and safe defaults.
+    # - For files: resolve relative paths against a provided base_dir (default: Dir.pwd).
+    module TemplateHelpers
+      module_function
+      # Render inline YAML text to HTML via Converter.
+      #
+      # @param text [String] YAML content
+      # @param config [Yard::Yaml::Config]
+      # @return [String] HTML fragment
+      def render_yaml_block(text, config: Yard::Yaml.config)
+        res = Yard::Yaml::Converter.from_string(text.to_s, {}, config: config)
+        res[:html].to_s
+      end
+      # Render a YAML file to HTML via Converter.
+      #
+      # @param path [String] file path (absolute or relative)
+      # @param base_dir [String] base directory to resolve relative paths against (default: Dir.pwd)
+      # @param config [Yard::Yaml::Config]
+      # @return [String] HTML fragment (empty on non-strict missing file)
+      def render_yaml_file(path, base_dir: Dir.pwd, config: Yard::Yaml.config)
+        resolved = resolve_path(path, base_dir)
+        res = Yard::Yaml::Converter.from_file(resolved, {}, config: config)
+        res[:html].to_s
+      rescue Yard::Yaml::Error
+        # strict mode errors bubble from converter; re-raise
+        raise
+      rescue StandardError => e
+        # Non-strict paths should already be handled by converter; this is a last-resort guard.
+        if defined?(::Yard) && ::Yard.const_defined?(:Yaml)
+          ::Yard::Yaml.warn("#{e.class}: #{e.message} while rendering #{path}")
+        else
+          Kernel.warn("yard-yaml: #{e.class}: #{e.message} while rendering #{path}")
+        end
+        ""
+      end
+      # Resolve a path relative to base_dir when necessary.
+      # @api private
+      def resolve_path(path, base_dir)
+        p = path.to_s
+        return p if p.start_with?("/") || p.match?(/^[A-Za-z]:[\\\/]?/) # absolute on unix or windows
+        File.expand_path(File.join(base_dir.to_s, p))
+      end
+      private_class_method :resolve_path
+    end
+  end
+end

data/lib/yard/yaml/templates.rb ADDED Viewed

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+# Template path registration for yard-yaml.
+#
+# Phase 5 (part 1): register a templates directory so future template
+# overrides/partials can be discovered by YARD. Actual inline placement and
+# navigation hooks will follow in the next step to keep require-time behavior
+# inert and tests deterministic.
+#
+# This file is safe to require in environments without YARD present; it checks
+# for YARD constants before attempting any registration.
+module Yard
+  module Yaml
+    module Templates
+      module_function
+      # Register the templates path with YARD if available.
+      # Idempotent and safe when YARD is not loaded.
+      def register!
+        return unless defined?(::YARD) && ::YARD.const_defined?(:Templates)
+        base = File.expand_path("../../../templates", __dir__)
+        begin
+          ::YARD::Templates::Engine.register_template_path(base)
+        rescue StandardError
+          # ignore if engine not available or already registered
+        end
+      end
+    end
+  end
+end
+# Try to register immediately if YARD is present; otherwise remain inert.
+begin
+  Yard::Yaml::Templates.register!
+rescue StandardError
+  # ignore in non-YARD contexts
+end

data/lib/yard/yaml/version.rb ADDED Viewed

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Yard
+  module Yaml
+    module Version
+      VERSION = "0.1.0"
+    end
+    VERSION = Version::VERSION # Support the traditional VERSION constant.
+  end
+end

data/lib/yard/yaml.rb ADDED Viewed

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require_relative "yaml/version"
+require_relative "yaml/config"
+require_relative "yaml/cli"
+require_relative "yaml/plugin"
+require_relative "yaml/converter"
+require_relative "yaml/discovery"
+require_relative "yaml/emitter"
+require_relative "yaml/template_helpers"
+require_relative "yaml/tag_renderer"
+require_relative "yaml/tags"
+require_relative "yaml/templates"
+module Yard
+  module Yaml
+    # Generic error for yard-yaml
+    class Error < StandardError; end
+    @config = nil
+    @pages = nil
+    class << self
+      # Access the global configuration for yard-yaml.
+      #
+      # Returns a memoized instance. It is safe to mutate via accessors in
+      # controlled contexts (e.g., tests or explicit configuration blocks).
+      #
+      # @return [Yard::Yaml::Config]
+      def config
+        @config ||= Config.new
+      end
+      # Access collected pages (Phase 3). Nil until plugin activation performs discovery.
+      # Each page is a Hash with keys: :path, :html, :title, :description, :meta
+      # @return [Array<Hash>, nil]
+      attr_reader :pages
+      # Internal: set collected pages (used by Plugin during activation)
+      def __set_pages__(list)
+        @pages = Array(list)
+        mirror_pages_to_registry(@pages)
+        @pages
+      end
+      # Configure the plugin programmatically.
+      #
+      # @param overrides [Hash,nil] optional overrides to apply
+      # @yieldparam cfg [Yard::Yaml::Config] the live config instance
+      # @return [Yard::Yaml::Config] the resulting config
+      def configure(overrides = nil)
+        cfg = config
+        cfg.apply(overrides) if overrides && !overrides.empty?
+        yield(cfg) if block_given?
+        mirror_to_registry(cfg)
+        cfg
+      end
+      # Public: emit a warning message via YARD logger when available, otherwise stderr.
+      # Prefix is standardized to "yard-yaml: ".
+      # @param message [String]
+      def warn(message)
+        __warn(message)
+      end
+      # Public: emit an error-level log message (does not raise).
+      # Uses YARD::Logger.error if available, else falls back to stderr with prefix.
+      # @param message [String]
+      def error(message)
+        if defined?(::YARD) && ::YARD.const_defined?(:Logger)
+          begin
+            ::YARD::Logger.instance.error("yard-yaml: #{message}")
+            return
+          rescue StandardError
+            # fall back
+          end
+        end
+        Kernel.warn("yard-yaml: ERROR: #{message}")
+      end
+      # Test-helper: reset memoized config to defaults (not public API)
+      def __reset_state__
+        @config = nil
+        @pages = nil
+        if defined?(::Yard::Yaml::Plugin) && ::Yard::Yaml::Plugin.respond_to?(:__reset_state__)
+          ::Yard::Yaml::Plugin.__reset_state__
+        end
+        nil
+      end
+      private
+      # Internal: unified warning helper to avoid constants errors when a partial
+      # YARD stub is present in tests. Prefer using this helper over direct
+      # YARD::Logger usage.
+      def __warn(message)
+        if defined?(::YARD) && ::YARD.const_defined?(:Logger)
+          begin
+            ::YARD::Logger.instance.warn("yard-yaml: #{message}")
+            return
+          rescue StandardError
+            # fall back
+          end
+        end
+        Kernel.warn("yard-yaml: #{message}")
+      end
+      def mirror_to_registry(cfg)
+        return unless defined?(::YARD) && ::YARD.const_defined?(:Registry)
+        # Registry.store is a Hash-like; avoid raising if unavailable
+        begin
+          ::YARD::Registry.store[:yard_yaml_config] = cfg
+        rescue StandardError
+          # ignore if registry store not ready
+        end
+      end
+      def mirror_pages_to_registry(pages)
+        return unless defined?(::YARD) && ::YARD.const_defined?(:Registry)
+        begin
+          ::YARD::Registry.store[:yard_yaml_pages] = pages
+        rescue StandardError
+          # ignore if registry store not ready
+        end
+      end
+    end
+  end
+end

data/lib/yard-yaml.rb ADDED Viewed

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# YARD plugin loader for `--plugin yaml`.
+# YARD tries requiring several patterns; providing `yard-yaml` ensures
+# it can be loaded regardless of whether YARD attempts `yard-yaml` or `yard/yaml`.
+require_relative "yard/yaml"

data/sig/yard/yaml.rbs ADDED Viewed

@@ -0,0 +1,78 @@
+module Yard
+  module Yaml
+    VERSION: String
+    # Global configuration and pages accessors
+    def self.config: () -> Yard::Yaml::Config
+    def self.configure: (?Hash[untyped, untyped] overrides) { (Yard::Yaml::Config) -> void } -> Yard::Yaml::Config
+    def self.pages: () -> (Array[Hash[untyped, untyped]] | nil)
+    def self.__set_pages__: (Array[Hash[untyped, untyped]] list) -> Array[Hash[untyped, untyped]]
+    def self.warn: (String message) -> void
+    def self.error: (String message) -> void
+    class Config
+      DEFAULT_INCLUDE: Array[String]
+      DEFAULT_EXCLUDE: Array[String]
+      DEFAULT_OUT_DIR: String
+      DEFAULT_INDEX: bool
+      DEFAULT_TOC: String
+      DEFAULT_CONVERTER_OPTIONS: Hash[untyped, untyped]
+      DEFAULT_FRONT_MATTER: bool
+      DEFAULT_STRICT: bool
+      DEFAULT_ALLOW_ERB: bool
+      attr_accessor include: Array[String]
+      attr_accessor exclude: Array[String]
+      attr_accessor out_dir: String
+      attr_accessor index: bool
+      attr_accessor toc: String
+      attr_accessor converter_options: Hash[untyped, untyped]
+      attr_accessor front_matter: bool
+      attr_accessor strict: bool
+      attr_accessor allow_erb: bool
+      def initialize: (?Hash[untyped, untyped] overrides) -> void
+      def apply: (Hash[untyped, untyped]) -> Config
+    end
+    module Cli
+      def self.parse: (Array[String] argv) -> Hash[untyped, untyped]
+    end
+    module Plugin
+      def self.activated?: () -> bool
+      def self.activate: (?Array[String] argv) -> void
+    end
+    module Discovery
+      def self.find_files: (Array[String] include_globs, Array[String] exclude_globs) -> Array[String]
+      def self.collect: (?Yard::Yaml::Config config) -> Array[Hash[untyped, untyped]]
+    end
+    class Converter
+      def self.from_string: (String yaml, ?Hash[untyped, untyped] options, ?config: Yard::Yaml::Config) -> Hash[untyped, untyped]
+      def self.from_file: (String path, ?Hash[untyped, untyped] options, ?config: Yard::Yaml::Config) -> Hash[untyped, untyped]
+    end
+    class Emitter
+      def self.emit!: (pages: Array[Hash[untyped, untyped]], output_dir: String, ?config: Yard::Yaml::Config) -> Array[String]
+      def self.slug_for: (Hash[untyped, untyped] page) -> String
+    end
+    module TemplateHelpers
+      def self.render_yaml_block: (String text, ?config: Yard::Yaml::Config) -> String
+      def self.render_yaml_file: (String path, ?base_dir: String, ?config: Yard::Yaml::Config) -> String
+    end
+    module TagRenderer
+      def self.render_for: (untyped object, ?base_dir: String, ?config: Yard::Yaml::Config) -> String
+    end
+    module Tags
+      def self.register!: () -> void
+    end
+    class Error < ::StandardError
+    end
+  end
+end

data.tar.gz.sig ADDED Viewed

Binary file