asciisourcerer 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 862206bd89bcd6930165344b8623239c8220f5d598f12d3050508b8386432546
-  data.tar.gz: 6b95b84ae0f56421fc10b75a440cf4beaa29c24d7c3f7be50f9c168b3e4b9a63
+  metadata.gz: 7b6d7c78acf65b0a4c2b7aef397ea65a254fc486cc616a5977794cdd51eb67f2
+  data.tar.gz: 66de4e674a882d87dc919aa2eab680a10cd9fae2d8df5033b32f6b79d27b9a61
 SHA512:
-  metadata.gz: a6ef512103f8978b1fe583a7e55061d94cade1f783cffb43bb68044d154a7c438f7a9e2a2e55a9a0ad499304881c30f375eb6b666f12e5d7d1ce56dc3401d49a
-  data.tar.gz: 6101084fa33316a51458b08878a17b956dbb93558fe7acdd6f95675167daa2d7f8ee29e76943123b18889a54780914a6cc95fcef0ee7aee628daf0d201b0f550
+  metadata.gz: 86e2ef0fc8684ab20d29832f1a78d4d8171bd5f4a2de36659ae4cb96ddde8f37f42e35ed446afe466245e0ee4bbe596a9095549cf0f864fbea0ff86de588e54f
+  data.tar.gz: 3fc489d1777101bfbb178cbca588e0988828aa682fe4a763a9efd9cf4775cf2fe9bf7f1e887d0fba6c9a149353fa266747b44f30a4fad4a19791501c64e906e0

data/README.adoc

@@ -37,11 +37,11 @@ endif::[]
 :this_prod_name: {this_proj_name}
 // end::universal-settings[]
 :this_prod_vrsn_major: 0
-:this_prod_vrsn_minor: 5
+:this_prod_vrsn_minor: 6
 :this_prod_vrsn_majmin: {this_prod_vrsn_major}.{this_prod_vrsn_minor}
 :this_prod_vrsn_patch: 0
 :this_prod_vrsn: {this_prod_vrsn_majmin}.{this_prod_vrsn_patch}
-:next_prod_vrsn: 0.6.0
+:next_prod_vrsn: 0.7.0
 // end::global-settings[]
 // end::ai-prompt[]
 :toc: macro
@@ -823,7 +823,9 @@ Avoid exporting helper methods as accidental public API.
 === Generated Reference Docs
 
 Some reference documentation is generated from data rather than hand-written, so it can't drift from what the code actually does.
-`specs/data/docs-manifest.yml` lists each generation job: a Liquid (or ERB) template, a YAML data source, an output path, and optional `vars` to parameterize a shared template into multiple outputs.
+A manifest (`specs/data/docs-manifest.yml`) lists each generation job: a Liquid template, a YAML data source, an output path, and optional `vars` to parameterize a shared template into multiple outputs.
+Each entry also accepts the Liquid-only `preserve_missing` and `preserve_empty` booleans (both default `false`), forwarded straight through to `Sourcerer::Rendering.render_template`.
+See the API docs on `Sourcerer::Rendering.render_template` for exactly what each one preserves.
 
 For example, `specs/data/liquid-filters.yml` (the same source of truth used by the Liquid filter test suite; see <<tests>>) is rendered through `docs/templates/liquid-filters-ref.adoc.liquid` twice -- once grouped by filter category, once by filter source -- producing the partials committed at `lib/sourcerer/_docs/partials/liquid-filters-by-kind.adoc` and `liquid-filters-by-source.adoc`.
 These partials ship with the gem so downstream tools can `include::` them directly.
@@ -833,6 +835,15 @@ Regenerate all manifest entries with:
 [.prompt]
  bundle exec rake generate:docs
 
+These same partials are also published to the `documentation` branch, under `partials/`.
+That branch holds only generated output (no source code) so it can be pulled directly (ex: via raw.githubusercontent.com) by consumers who don't install the gem.
+Regenerate and locally commit an update to that branch with:
+
+[.prompt]
+ bundle exec rake generate:documentation
+
+This only commits locally; push with `git push -f origin documentation` after reviewing the result.
+
 [[tests]]
 === Tests
 
@@ -857,19 +868,28 @@ Run the PR/CI test suite:
 === Release Process and History
 
 AsciiSourcerer is intended to be the most primal gem in the DocOps Lab pool.
-As such, its development is less formal.
+As such, its release procedure is lighter and less formal.
 
-Each release is tested against all downstream gems and tools, but we are somewhat less formal about issue tracking and development branch management, at least in early stages.
+Each release is tested against all downstream gems and tools, but we are less concerned with issue tracking and development branch management, at least in these early stages.
 
-Standard release flow:
+Standard release flow differs from the general DocOps Lab conventions.
 
 . Update version in `lib/sourcerer/version.rb` and `README.adoc` attributes.
 
+. Test all changes using local clones of the latest released versions of these downstream gems:
+
+* link:{docopslab_src_www_url}/schemagraphy[DocOps/schemagraphy]
+* link:{docopslab_src_www_url}/lab[DocOps/lab]
+* link:{docopslab_src_www_url}/releasehx[DocOps/releasehx]
+
 . Commit to Git.
 
 . Push to GitHub.
 
-. Run `./scripts/build.sh` to validate the environment, run tests, and build the gem file to `pkg/`.
+. Run `./scripts/build.sh` to:
+.. validate the environment
+.. run tests, and
+.. build the gem file to `pkg/`
 
 . Tag the release in Git:
 +

data/lib/sourcerer/jekyll/bootstrapper.rb

@@ -37,7 +37,7 @@ module Sourcerer
       # @param includes_load_paths [Array<String>] Paths to load includes from.
       # @param plugin_dirs [Array<String>] Paths to load plugins from.
       # @return [Jekyll::Site] The initialized fake Jekyll site object.
-      # rubocop:disable Lint/UnusedMethodArgument
+      # rubocop:disable-next Lint/UnusedMethodArgument
       def self.fake_site includes_load_paths: [], plugin_dirs: []
         # NOTE: plugin_dirs parameter is accepted but not yet implemented; reserved for future plugin loading
         ::Jekyll.logger.log_level = :error if ::Jekyll.logger.respond_to?(:log_level=)
@@ -72,7 +72,6 @@ module Sourcerer
 
         site
       end
-      # rubocop:enable Lint/UnusedMethodArgument
     end
   end
 end

data/lib/sourcerer/jekyll/liquid/preserve_missing_variables.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+module Sourcerer
+  module Jekyll
+    module Liquid
+      # Opt-in alternative to Liquid's default "render nil/empty as empty
+      # string" behavior: when active, a `{{ ... }}` expression that
+      # evaluates to a missing or empty value renders as its own original
+      # source text (e.g. `{{ data.foo | capitalize }}`) instead of
+      # vanishing. Useful for document templates where an unfilled field
+      # should stay visible for the preparer to fill in by hand, rather
+      # than silently disappearing.
+      #
+      # Two independent toggles, each off by default:
+      #
+      # - `preserve_missing`: an outright `nil` result is preserved.
+      # - `preserve_empty`: a defined-but-empty String/Array/Hash result
+      #   (`""`, `[]`, `{}`) is preserved.
+      #
+      # Neither affects the other's target, and neither affects `0` or
+      # `false`. Both checks run against the fully-filtered result (i.e.
+      # any `| filters` in the tag have already run), matching what Liquid
+      # itself would otherwise render -- we never re-run the filters, we
+      # just restore the tag's own pre-render source text once a render
+      # has been judged missing/empty. `raw` is used verbatim (no
+      # whitespace trimming), so the reconstructed tag matches the
+      # original byte-for-byte -- except for `{{-`/`-}}` whitespace
+      # control markers, which Liquid's tokenizer strips before the
+      # markup ever reaches a `Variable` instance and so cannot be
+      # recovered here.
+      #
+      # Substitution only ever applies to a *top-level output* `{{ }}`
+      # tag -- never to a `Liquid::Variable` some other tag builds
+      # privately to parse its own syntax. `Assign`, for example, does
+      # exactly that (`lib/liquid/tags/assign.rb`: `@from = Variable.new(
+      # $2, options)`, then `@from.render(context)` directly), and that
+      # Variable's `#render` is the same patched method, with the same
+      # global toggle active. Without this distinction,
+      # `{% assign name = data.missing %}` under `preserve_missing: true`
+      # would assign the *reconstructed source text of the assign's own
+      # right-hand side* (a String) to `name`, rather than the real `nil`
+      # -- corrupting every later `{{ name }}` reference instead of
+      # leaving it to render its own clean placeholder. `BlockBodyPatch`
+      # below marks the one call site (`BlockBody#render_node_to_output`,
+      # when the node being rendered is itself a `Variable`) that
+      # corresponds to a literal `{{ }}` sitting directly in a template
+      # body's nodelist -- the only place a Variable's rendered text
+      # actually becomes document output. Any other tag's internal use of
+      # a Variable to compute a value (Assign's right-hand side, or
+      # anything similar) renders outside that marker and is left with
+      # Liquid's normal nil/empty behavior, exactly as if this feature
+      # were off.
+      #
+      # Liquid 4 has no built-in hook for this -- there is no Environment or
+      # parser-injection point (introduced only in Liquid 5) to substitute a
+      # custom Variable class per template -- so this prepends onto
+      # `::Liquid::Variable` globally and gates the actual behavior change
+      # with toggles scoped to one render call. See
+      # `Sourcerer::Rendering.render_template`'s `preserve_missing:`/
+      # `preserve_empty:` options, which flip these toggles for the
+      # duration of that one render.
+      module PreserveMissingVariables
+        def self.preserve_missing?
+          Thread.current[:sourcerer_preserve_missing] == true
+        end
+
+        def self.preserve_empty?
+          Thread.current[:sourcerer_preserve_empty] == true
+        end
+
+        def self.top_level_output?
+          Thread.current[:sourcerer_rendering_output_variable] == true
+        end
+
+        # Activates preserve-missing/-empty rendering for the duration of
+        # the block. Restores the prior values afterward so nested/
+        # sequential renders that don't ask for it are unaffected.
+        #
+        # @param preserve_missing [Boolean] See {PreserveMissingVariables}.
+        # @param preserve_empty [Boolean] See {PreserveMissingVariables}.
+        def self.with_active preserve_missing: false, preserve_empty: false
+          previous_missing = Thread.current[:sourcerer_preserve_missing]
+          previous_empty = Thread.current[:sourcerer_preserve_empty]
+          Thread.current[:sourcerer_preserve_missing] = preserve_missing
+          Thread.current[:sourcerer_preserve_empty] = preserve_empty
+          yield
+        ensure
+          Thread.current[:sourcerer_preserve_missing] = previous_missing
+          Thread.current[:sourcerer_preserve_empty] = previous_empty
+        end
+
+        # Prepended onto ::Liquid::Variable. Falls through to Liquid's own
+        # `render` untouched unless: this Variable is currently being
+        # rendered as a top-level output node (see `BlockBodyPatch`
+        # below), preserve-missing/-empty is active for this thread, and
+        # the fully-filtered result counts as missing (nil) or empty (a
+        # defined-but-empty String/Array/Hash).
+        module VariablePatch
+          def render context
+            result = super
+            return result unless PreserveMissingVariables.top_level_output?
+            return "{{#{raw}}}" if PreserveMissingVariables.preserve_missing? && result.nil?
+            return "{{#{raw}}}" if PreserveMissingVariables.preserve_empty? && empty_result?(result)
+
+            result
+          end
+
+          private
+
+          # Only the documented value types count as "empty" -- not any
+          # arbitrary object/Drop that happens to implement `empty?` with
+          # its own, possibly unrelated, meaning.
+          def empty_result? value
+            (value.is_a?(String) || value.is_a?(Array) || value.is_a?(Hash)) && value.empty?
+          end
+        end
+
+        # Prepended onto ::Liquid::BlockBody. `render_node_to_output` is
+        # the one call site where a node from a body's own nodelist --
+        # i.e. a literal `{{ }}` or `{% tag %}` written directly in
+        # template source -- gets rendered and appended to output. We
+        # only care about the `Variable` case: that's a genuine top-level
+        # `{{ }}` output tag, as opposed to a `Variable` some other tag
+        # (Assign, etc.) builds privately and renders itself, bypassing
+        # BlockBody entirely. See {PreserveMissingVariables} above for why
+        # this distinction matters.
+        module BlockBodyPatch
+          # rubocop:disable-next Style/OptionalBooleanParameter -- must match
+          # ::Liquid::BlockBody#render_node_to_output's own positional signature
+          def render_node_to_output node, output, context, skip_output = false
+            return super unless node.is_a?(::Liquid::Variable)
+
+            previous = Thread.current[:sourcerer_rendering_output_variable]
+            Thread.current[:sourcerer_rendering_output_variable] = true
+            super
+          ensure
+            Thread.current[:sourcerer_rendering_output_variable] = previous if node.is_a?(::Liquid::Variable)
+          end
+        end
+      end
+    end
+  end
+end
+
+Liquid::Variable.prepend(Sourcerer::Jekyll::Liquid::PreserveMissingVariables::VariablePatch)
+Liquid::BlockBody.prepend(Sourcerer::Jekyll::Liquid::PreserveMissingVariables::BlockBodyPatch)

data/lib/sourcerer/jekyll/liquid/tags.rb

@@ -8,12 +8,25 @@ module Sourcerer
         # A Liquid tag for embedding and rendering a file within a template.
         # It searches for the file in the configured include paths.
         class EmbedTag < ::Liquid::Tag
+          # Matches an optional single- or double-quoted string, capturing the
+          # inner content; falls back to the whole (trimmed) markup as a bareword.
+          # Requires at least one character inside the quotes: an empty quoted
+          # name (`""`/`''`) would otherwise expand to the includes directory
+          # itself, pass File.exist?, and raise Errno::EISDIR from File.read
+          # instead of the intended missing-file error. Left unmatched, it
+          # falls through to the bareword branch instead, where the literal
+          # (quoted) name is looked up and not found -- reported normally.
+          PARTIAL_NAME_PATTERN = /\A(?:"([^"]+)"|'([^']+)')\z/
+
           # @param tag_name [String] The name of the tag ('embed').
-          # @param markup [String] The name of the partial to embed.
+          # @param markup [String] The name of the partial to embed, quoted
+          #   (+"foo.liquid"+ / +'foo.liquid'+) or bareword (+foo.liquid+).
           # @param tokens [Array<String>] The list of tokens.
           def initialize tag_name, markup, tokens
             super
-            @partial_name = markup.strip
+            trimmed = markup.strip
+            match = trimmed.match(PARTIAL_NAME_PATTERN)
+            @partial_name = match ? (match[1] || match[2]) : trimmed
           end
 
           # Renders the embedded file.
@@ -22,7 +35,9 @@ module Sourcerer
           # @return [String] The rendered content of the embedded file.
           # @raise [IOError] if the embed file is not found.
           def render context
-            includes_paths = context.registers[:includes_load_paths] || []
+            includes_paths = context.registers[:includes_load_paths]
+            includes_paths = site_includes_load_paths(context) if includes_paths.nil? || includes_paths.empty?
+            includes_paths ||= []
 
             found_path = includes_paths.find do |base|
               candidate = File.expand_path(@partial_name, base)
@@ -37,6 +52,19 @@ module Sourcerer
             partial = ::Liquid::Template.parse(source)
             partial.render!(context)
           end
+
+          private
+
+          # Fallback for callers that register a fake/real Jekyll +:site+ but
+          # forget the separate +:includes_load_paths+ register (e.g. any
+          # future caller mirroring {Sourcerer::Rendering.render_liquid}).
+          # Reads +site.config['includes_load_paths']+ directly rather than
+          # +site.includes_load_paths+: the latter is Jekyll's own attribute,
+          # derived only from +config['includes_dir']+ (effectively just the
+          # first path), not the full list Sourcerer stores in config.
+          def site_includes_load_paths context
+            context.registers[:site]&.config&.[]('includes_load_paths')
+          end
         end
       end
     end

data/lib/sourcerer/jekyll.rb

@@ -5,6 +5,7 @@ require_relative 'jekyll/monkeypatches'
 require_relative 'jekyll/liquid/file_system'
 require_relative 'jekyll/liquid/filters'
 require_relative 'jekyll/liquid/tags'
+require_relative 'jekyll/liquid/preserve_missing_variables'
 require 'jekyll-asciidoc'
 
 module Sourcerer

data/lib/sourcerer/rendering.rb

@@ -37,7 +37,9 @@ module Sourcerer
           data_object: data_obj,
           attrs_source: attrs_source,
           engine: engine,
-          vars: render_entry[:vars] || {})
+          vars: render_entry[:vars] || {},
+          preserve_missing: render_entry[:preserve_missing] || false,
+          preserve_empty: render_entry[:preserve_empty] || false)
       end
     end
 
@@ -53,39 +55,53 @@ module Sourcerer
     # @param vars [Hash] Arbitrary caller-supplied variables, exposed to the
     #   template as `vars` (e.g. to parameterize a shared template between
     #   multiple render entries in a manifest).
+    # @param preserve_missing [Boolean] Liquid-only, independent of
+    #   `preserve_empty`. When true, a `{{ ... }}` expression that evaluates
+    #   to nil renders as its own original source text instead of an empty
+    #   string, so an unfilled field stays visible for manual completion
+    #   rather than silently disappearing. Has no effect on a defined
+    #   empty value (`""`, `[]`, `{}`).
+    # @param preserve_empty [Boolean] Liquid-only, independent of
+    #   `preserve_missing`. When true, a `{{ ... }}` expression that
+    #   evaluates to a defined-but-empty String/Array/Hash (`""`, `[]`,
+    #   `{}`) is preserved as its own original source text the same way.
+    #   Has no effect on nil. `0` and `false` are never affected by either
+    #   option.
     def self.render_template template_file, data_file, out_file, **options
-      supported_option_keys = %i[data_object includes_load_paths attrs_source engine vars]
+      supported_option_keys = %i[data_object includes_load_paths attrs_source engine vars
+                                 preserve_missing preserve_empty]
       unknown_option_keys = options.keys - supported_option_keys
       raise ArgumentError, "unknown option(s): #{unknown_option_keys.join(', ')}" unless unknown_option_keys.empty?
 
       data_object = options.fetch(:data_object, 'data')
-      includes_load_paths = options.fetch(:includes_load_paths, [])
-      attrs_source = options[:attrs_source]
-      engine = options.fetch(:engine, 'liquid')
+      data = load_render_data(data_file, options[:attrs_source])
       vars = (options[:vars] || {}).transform_keys(&:to_s)
+      context = { data_object => data, 'include' => { data_object => data }, 'vars' => vars }
+
+      preserve = { missing: options.fetch(:preserve_missing, false), empty: options.fetch(:preserve_empty, false) }
+      rendered = render_in_engine(
+        options.fetch(:engine, 'liquid'), template_file, context, options.fetch(:includes_load_paths, []), preserve)
 
-      data = load_render_data(data_file, attrs_source)
       out_file = File.expand_path(out_file)
       FileUtils.mkdir_p(File.dirname(out_file))
-
-      template_path = File.expand_path(template_file)
-      template_content = File.read(template_path)
-
-      context = {
-        data_object => data,
-        'include' => { data_object => data },
-        'vars' => vars
-      }
-
-      rendered = case engine.to_s
-                 when 'erb' then render_erb(template_content, context)
-                 when 'liquid' then render_liquid(template_file, template_content, context, includes_load_paths)
-                 else raise ArgumentError, "Unsupported template engine: #{engine}"
-                 end
-
       File.write(out_file, rendered)
     end
 
+    # @api private
+    # Dispatches rendering to the requested template engine.
+    #
+    # @param preserve [Hash] `{missing:, empty:}` -- see {.render_template}'s
+    #   `preserve_missing`/`preserve_empty` options.
+    # @return [String]
+    def self.render_in_engine engine, template_file, context, includes_load_paths, preserve
+      template_content = File.read(File.expand_path(template_file))
+      case engine.to_s
+      when 'erb' then render_erb(template_content, context)
+      when 'liquid' then render_liquid(template_file, template_content, context, includes_load_paths, preserve)
+      else raise ArgumentError, "Unsupported template engine: #{engine}"
+      end
+    end
+
     # Renders output using a converter callable or converter constant name.
     #
     # @param render_entry [Hash] Render entry containing converter config.
@@ -151,38 +167,43 @@ module Sourcerer
     # @param template_content [String]
     # @param context [Hash]
     # @param includes_load_paths [Array<String>]
+    # @param preserve [Hash] `{missing:, empty:}` -- see {.render_template}'s
+    #   `preserve_missing`/`preserve_empty` options.
     # @return [String]
-    def self.render_liquid template_file, template_content, context, includes_load_paths
+    def self.render_liquid template_file, template_content, context, includes_load_paths, preserve
       require_relative 'jekyll'
       require_relative 'jekyll/liquid/filters'
       require_relative 'jekyll/liquid/tags'
+      require_relative 'jekyll/liquid/preserve_missing_variables'
       require 'liquid' unless defined?(Liquid::Template)
       Sourcerer::Jekyll.initialize_liquid_runtime
 
+      registers = liquid_registers(template_file, includes_load_paths)
+      template = Liquid::Template.parse(template_content)
+      render = -> { template.render(context, registers: registers) }
+
+      return render.call unless preserve[:missing] || preserve[:empty]
+
+      Sourcerer::Jekyll::Liquid::PreserveMissingVariables.with_active(
+        preserve_missing: preserve[:missing], preserve_empty: preserve[:empty], &render)
+    end
+
+    # @api private
+    # Builds the Liquid registers hash (fake site + file system) a template
+    # render needs to resolve `{% embed %}`/include partials.
+    #
+    # @return [Hash]
+    def self.liquid_registers template_file, includes_load_paths
       fallback_templates_dir = File.expand_path('.', Dir.pwd)
       template_dir = File.dirname(File.expand_path(template_file))
       template_parent_dir = File.dirname(template_dir)
 
-      paths = if includes_load_paths.any?
-                includes_load_paths
-              else
-                [template_parent_dir, template_dir, fallback_templates_dir]
-              end
-
-      site = Sourcerer::Jekyll::Bootstrapper.fake_site(
-        includes_load_paths: paths,
-        plugin_dirs: [])
-
+      default_paths = [template_parent_dir, template_dir, fallback_templates_dir]
+      paths = includes_load_paths.any? ? includes_load_paths : default_paths
+      site = Sourcerer::Jekyll::Bootstrapper.fake_site(includes_load_paths: paths, plugin_dirs: [])
       file_system = Sourcerer::Jekyll::Liquid::FileSystem.new(paths)
 
-      template = Liquid::Template.parse(template_content)
-      options = {
-        registers: {
-          site: site,
-          file_system: file_system
-        }
-      }
-      template.render(context, options)
+      { site: site, file_system: file_system, includes_load_paths: paths }
     end
 
     # Render a Liquid template string directly with a data hash.
@@ -216,6 +237,8 @@ module Sourcerer
     private_class_method :load_render_data,
                          :resolve_converter,
                          :render_erb,
-                         :render_liquid
+                         :render_liquid,
+                         :render_in_engine,
+                         :liquid_registers
   end
 end

data/lib/sourcerer/source_skim/skimmer.rb

@@ -229,7 +229,7 @@ module Sourcerer
       end
 
       def process_blocks blocks, level, section_id
-        # rubocop:disable Metrics/BlockLength
+        # rubocop:disable-next Metrics/BlockLength
         blocks.each do |block|
           case block.context
           when :section
@@ -384,7 +384,6 @@ module Sourcerer
             process_blocks(block.blocks, level, section_id) if block.respond_to?(:blocks) && block.blocks.any?
           end
         end
-        # rubocop:enable Metrics/BlockLength
       end
     end
   end

data/lib/sourcerer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sourcerer
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: asciisourcerer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - DocOps Lab
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -145,6 +144,7 @@ files:
 - lib/sourcerer/jekyll/bootstrapper.rb
 - lib/sourcerer/jekyll/liquid/file_system.rb
 - lib/sourcerer/jekyll/liquid/filters.rb
+- lib/sourcerer/jekyll/liquid/preserve_missing_variables.rb
 - lib/sourcerer/jekyll/liquid/tags.rb
 - lib/sourcerer/jekyll/monkeypatches.rb
 - lib/sourcerer/mark_down_grade.rb
@@ -172,7 +172,6 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,8 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: APIs for specialized handling of AsciiDoc, YAML, and Liquid documents.
 test_files: []