asciisourcerer 0.4.0 → 0.6.0

data/lib/sourcerer/asciidoc.rb

@@ -43,9 +43,13 @@ module Sourcerer
     # Loads AsciiDoc attributes from a document header as a Hash.
     #
     # @param path [String] The path to the AsciiDoc file.
+    # @param user_only [Boolean] When true, strips Asciidoctor built-in attributes
+    #   and returns only user-defined attributes. Defaults to false.
     # @return [Hash] A hash of the document attributes.
-    def self.load_attributes path
+    def self.load_attributes path, user_only: false
       doc = Asciidoctor.load_file(path, safe: :unsafe)
+      return AttributesFilter.user_attributes(doc) if user_only
+
       doc.attributes
     end
 
@@ -192,17 +196,20 @@ module Sourcerer
     #
     # @param source_path [String] Path to AsciiDoc source file.
     # @param markdown_output_path [String, nil] Optional markdown output path.
+    # @param markdown_converter [#call, nil] Callable that accepts `(html, markdown_options)`.
+    #   Defaults to Sourcerer::MarkDownGrade.convert_html when nil.
     # @param html_output_path [String, nil] Optional HTML output path.
     # @param backend [String] HTML backend request (`html5` or `asciidoctor-html5s`).
     # @param header_footer [Boolean] Whether interim HTML should include document wrapper.
     # @param include_frontmatter [Boolean] Whether to prepend markdown YAML front matter.
     # @param markdown_options [Hash] Options passed to markdown converter.
-    # @param markdown_converter [#call] Callable that accepts `(html, markdown_options)`.
     # @param convert_tables_to_markdown [Boolean] Convert all tables to markdown UNLESS they have .no-markdown class.
     # @return [Hash] Conversion result containing markdown, frontmatter, and backend info.
-    def self.mark_down_grade source_path, markdown_output_path=nil, markdown_converter:, **options
+    def self.mark_down_grade source_path, markdown_output_path=nil, markdown_converter: nil, **options
       options = normalize_mark_down_grade_options(options)
 
+      markdown_converter ||= ->(html, opts) { Sourcerer::MarkDownGrade.convert_html(html, opts || {}) }
+
       source_text = File.read(source_path)
       conversion_source_text = strip_yaml_frontmatter(source_text)
       selected_backend = resolve_html_backend(options[:backend])

data/lib/sourcerer/builder.rb

@@ -62,7 +62,7 @@ module Sourcerer
       attributes.each_with_object({}) do |entry, acc|
         source = entry[:source]
         name   = entry[:name] || File.basename(source, '.adoc').to_sym
-        acc[name.to_sym] = Sourcerer::AsciiDoc.load_attributes(source)
+        acc[name.to_sym] = Sourcerer::AsciiDoc.load_attributes(source, user_only: true)
       end
     end
 

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/filters.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'base64'
+require 'bigdecimal'
 require 'cgi'
+require 'date'
 require 'kramdown-asciidoc'
 
 module Sourcerer
@@ -13,6 +15,22 @@ module Sourcerer
       # Core transformation logic lives in `Ops` so behavior is reusable and easier
       # to test/refactor without changing the Liquid surface.
       module Filters
+        # Load canonical CLI args templates from YAML once at module load time
+        def self.load_cli_args_parameters
+          require 'yaml'
+          # Path from filters.rb: lib/sourcerer/jekyll/liquid/filters.rb
+          # To specs/data/liquid-filters.yml: go up 4 levels to gem root, then to specs/data
+          yaml_path = File.join(__dir__, '../../../../specs/data/liquid-filters.yml')
+          yaml_path = File.expand_path(yaml_path)
+          data = YAML.load_file(yaml_path, permitted_classes: [Date, Time])
+          filters = data.is_a?(Array) ? data : data['filters'] || []
+          to_cli_args_filter = filters.find { |f| f['key'] == 'to_cli_args' }
+          to_cli_args_filter&.dig('parameters') || {}
+        end
+
+        # Canonical template definitions loaded from specs/data/liquid-filters.yml
+        CLI_ARGS_TEMPLATES = load_cli_args_parameters.freeze
+
         # Internal operations for filter behavior.
         module Ops
           module_function
@@ -42,6 +60,15 @@ module Sourcerer
             end
           end
 
+          # Convert a string into a lowercase URL slug, joining words with the
+          # given separator (default `-`).
+          def slugify input, *args
+            separator = args[0] || '-'
+            input.downcase
+                 .gsub(/[^a-z0-9]+/, separator)
+                 .gsub(/\A#{Regexp.escape(separator)}+|#{Regexp.escape(separator)}+\z/, '')
+          end
+
           def plusify input
             input.gsub(/\n\n+/, "\n+\n")
           end
@@ -113,6 +140,210 @@ module Sourcerer
           def html_unescape input
             CGI.unescapeHTML(input.to_s)
           end
+
+          def wrap input, width=80
+            return input unless input.is_a?(String)
+
+            width = width.to_i
+            return input if width <= 0
+
+            input.split("\n").map do |line|
+              line.gsub(/(.{1,#{width}})(\s+|$)/, "\\1\n").rstrip
+            end.join("\n")
+          end
+
+          def commentwrap input, width=80, prefix=nil
+            return input unless input.is_a?(String)
+
+            wrapped = wrap(input, width)
+            return wrapped unless prefix
+
+            case prefix
+            when 'xml'
+              "<!-- #{wrapped} -->"
+            when /\|/
+              # Format like "/*|*/" becomes /* ... */
+              parts = prefix.split('|')
+              open_tag = parts[0]
+              close_tag = parts[1] || ''
+              "#{open_tag} #{wrapped}\n#{close_tag}"
+            else
+              # Regular comment prefix
+              wrapped.split("\n").map { |line| "#{prefix}#{line}" }.join("\n")
+            end
+          end
+
+          def to_yaml input, *args
+            require 'yaml'
+
+            # Parse args: can be "flow" and/or "quotes"
+            flow = args.include?('flow')
+            quotes = args.include?('quotes')
+
+            if flow
+              # Flow format (inline): {key: val}
+              if input.is_a?(Array)
+                if quotes
+                  "[#{input.map { |item| "\"#{item}\"" }.join(', ')}]"
+                else
+                  "[#{input.map(&:inspect).join(', ')}]"
+                end
+              elsif input.is_a?(Hash)
+                "{#{input.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}}"
+              else
+                input.to_s
+              end
+            else
+              # Block format (YAML): key: val
+              output = YAML.dump(input)
+              output.chomp
+            end
+          end
+
+          def to_json input
+            require 'json'
+            input.to_json
+          end
+
+          def replace_regex input, pattern, replacement=''
+            return input unless input.is_a?(String)
+
+            input.gsub(/#{pattern}/, replacement)
+          end
+
+          def match input, pattern
+            return false unless input.is_a?(String)
+
+            !!(input =~ /#{pattern}/)
+          end
+
+          def holds_liquid input
+            return false unless input.is_a?(String)
+
+            # Check for Liquid tags: {{ }}, {% %}, {%- -%}, {{- -}}
+            !!(input =~ /\{\{.*?\}\}|\{%-?.*?-?%\}/)
+          end
+
+          def to_cli_args input, template=nil, delimiter=' '
+            return input unless input.is_a?(Hash)
+
+            # Use templates loaded from canonical YAML source (Filters::CLI_ARGS_TEMPLATES)
+            selected_template = Filters::CLI_ARGS_TEMPLATES[template] || template || '--<option> <argument>'
+
+            input.map do |key, value|
+              selected_template
+                .gsub('<option>', key.to_s)
+                .gsub('<o>', key.to_s[0])
+                .gsub('<argument>', value.to_s)
+                .gsub('<VARIABLE>', key.to_s.upcase)
+                .gsub('<key>', key.to_s)
+                .gsub('<value>', value.to_s)
+            end.join(delimiter)
+          end
+
+          def store_list_concat input, key_name
+            return input unless input.is_a?(Array)
+
+            input.each_with_object([]) do |item, acc|
+              values = item[key_name.to_s]
+              acc.concat(values) if values.is_a?(Array)
+            end.uniq
+          end
+
+          def store_list_dupes input, key_name
+            return input unless input.is_a?(Array)
+
+            # Collect all arrays from specified key
+            arrays = input.map { |item| item[key_name.to_s] }.compact.grep(Array)
+
+            # Find items that appear in multiple arrays
+            all_items = arrays.flatten
+            all_items.select { |item| all_items.count(item) > 1 }.uniq
+          end
+
+          # Overrides Jekyll's `inspect` filter, adding a `format` argument.
+          # `html` (the default) reproduces Jekyll's own behavior exactly:
+          # an HTML-escaped `Object#inspect` string.
+          def inspect input, format='html'
+            case format
+            when 'yaml'
+              require 'yaml'
+              YAML.dump(input)
+            when 'json'
+              require 'json'
+              input.to_json
+            else
+              html_escape(input.inspect)
+            end
+          end
+
+          # -- Ports of Liquid 5 StandardFilters --
+          #
+          # Jekyll pins to Liquid 4, which lacks these four filters (added in
+          # Liquid 5). Ported here so downstream templates can use them
+          # regardless of the Liquid version Jekyll pulls in.
+          # See BILL_OF_MATERIALS.adoc for provenance/license details.
+
+          # Removes the last instance of a substring from a string.
+          def remove_last input, string
+            replace_last(input, string, '')
+          end
+
+          # Replaces the last instance of a substring in a string with a replacement.
+          def replace_last input, string, replacement=''
+            return input unless input.is_a?(String)
+
+            target = string.to_s
+            start_index = input.rindex(target)
+            return input unless start_index
+
+            output = input.dup
+            output[start_index, target.length] = replacement.to_s
+            output
+          end
+
+          # Strips leading/trailing whitespace and collapses interior runs of
+          # whitespace to a single space.
+          def squish input
+            return input unless input.is_a?(String)
+
+            input.strip.gsub(/\s+/, ' ')
+          end
+
+          # Sums a numeric array, or an array of Hashes at the given property.
+          def sum input, property=nil
+            return 0 unless input.is_a?(Array)
+
+            values = input.map do |item|
+              if property.nil?
+                item
+              elsif item.respond_to?(:[])
+                item[property]
+              else
+                0
+              end
+            end
+
+            result = values.sum { |value| to_number(value) }
+            result.is_a?(BigDecimal) ? result.to_f : result
+          end
+
+          # @api private
+          # Coerces a Liquid value to a number, matching Liquid 5's
+          # `Utils.to_number` (Float -> BigDecimal for precision, numeric
+          # strings parsed, everything else 0).
+          def to_number obj
+            case obj
+            when Float
+              BigDecimal(obj.to_s)
+            when Numeric
+              obj
+            when String
+              /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+            else
+              0
+            end
+          end
         end
         private_constant :Ops
 
@@ -124,6 +355,10 @@ module Sourcerer
           Ops.sluggerize(input, format)
         end
 
+        def slugify(input, *)
+          Ops.slugify(input, *)
+        end
+
         def plusify input
           Ops.plusify(input)
         end
@@ -167,6 +402,66 @@ module Sourcerer
         def html_unescape input
           Ops.html_unescape(input)
         end
+
+        def wrap input, width=80
+          Ops.wrap(input, width)
+        end
+
+        def commentwrap input, width=80, prefix=nil
+          Ops.commentwrap(input, width, prefix)
+        end
+
+        def to_yaml(input, *)
+          Ops.to_yaml(input, *)
+        end
+
+        def to_json input
+          Ops.to_json(input)
+        end
+
+        def replace_regex input, pattern, replacement=''
+          Ops.replace_regex(input, pattern, replacement)
+        end
+
+        def match input, pattern
+          Ops.match(input, pattern)
+        end
+
+        def holds_liquid input
+          Ops.holds_liquid(input)
+        end
+
+        def to_cli_args input, template=nil, delimiter=' '
+          Ops.to_cli_args(input, template, delimiter)
+        end
+
+        def store_list_concat input, key_name
+          Ops.store_list_concat(input, key_name)
+        end
+
+        def store_list_dupes input, key_name
+          Ops.store_list_dupes(input, key_name)
+        end
+
+        def inspect input, format='html'
+          Ops.inspect(input, format)
+        end
+
+        def remove_last input, string
+          Ops.remove_last(input, string)
+        end
+
+        def replace_last input, string, replacement=''
+          Ops.replace_last(input, string, replacement)
+        end
+
+        def squish input
+          Ops.squish(input)
+        end
+
+        def sum input, property=nil
+          Ops.sum(input, property)
+        end
       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
@@ -18,12 +19,17 @@ module Sourcerer
       Bootstrapper.load_plugins
       Monkeypatches.patch_jekyll
 
-      # Ensure Sourcerer filters are registered
-      ::Liquid::Template.register_filter(::Sourcerer::Jekyll::Liquid::Filters)
+      # Registration order matters: Liquid's Strainer `include`s each module in
+      # turn, so a later registration wins over an earlier one for any
+      # same-named filter method. Sourcerer's filters register LAST so that,
+      # e.g., its `inspect` (which adds a `format` argument) overrides
+      # Jekyll's `inspect` rather than being shadowed by it.
       # Ensure Jekyll filters are registered
       ::Liquid::Template.register_filter(::Jekyll::Filters)
       # Ensure jekyll-asciidoc filters are registered
       ::Liquid::Template.register_filter(::Jekyll::AsciiDoc::Filters)
+      # Ensure Sourcerer filters are registered (last, so they can override)
+      ::Liquid::Template.register_filter(::Sourcerer::Jekyll::Liquid::Filters)
       # Ensure Sourcerer tags are registered
       ::Liquid::Template.register_tag('embed', ::Sourcerer::Jekyll::Liquid::Tags::EmbedTag)
     end