klenod-build 0.0.23 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac47aee2306ee0d732be8f5959e27c168022a6b6d9cc8f6fec350e8cde16e38d
-  data.tar.gz: a3af1863c0c21df86885135fdd7c29d8b6a48b3997eb125fe00b0f02c72c5a64
+  metadata.gz: ceb99aac4328e67769eebf0c137e9e2f8412bbfc65c51c0757906f7e5e1ce88f
+  data.tar.gz: 7bd420cb85700ace2a34e6e0460ee5f63f8a9b1530264f8b1f5d4a8f7f4583e3
 SHA512:
-  metadata.gz: 17abab231fe71a6022e15a5ed712273ce59b4234e0593211ea9fb4614cfa089dc0fa8c4930a058a0034e2703c13a979cc3b0e23437b1e930f465c0361fdff419
-  data.tar.gz: e5305dbcc39bc6ae1bfb14369060806b333d3e091ff562d4030136e514149ee658fdd964abf5372693575227f8a69ed7364e08551510a14b924c4b85005581f2
+  metadata.gz: a8225fdd2f9208f17b2feeb832d03ed7bbb0fd5669bfd875fccdff579d05050a846f229996ccdce028e028d47b48cc70f24355b7a9384409d99c77e31a0a4a62
+  data.tar.gz: 0c5e2b51e492c0a56772ff6a9ed4309924a2da19e3a973c60782b1182605be59cec2cc3b10cc4c20a1641c21ae8102d9d37c3a6b00549fcf0e6a2b6347e84430

data/lib/klenod/build/plugins/google_fonts_plugin/font_metrics.json

@@ -1106,6 +1106,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 362
   },
+  "Asap Sharp": {
+    "familyName": "Asap Sharp",
+    "category": "sans-serif",
+    "ascent": 934,
+    "descent": -212,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 442
+  },
   "Asar": {
     "familyName": "Asar",
     "category": "serif",
@@ -2537,6 +2546,15 @@
     "unitsPerEm": 16,
     "xWidthAvg": 8
   },
+  "Caacupe One": {
+    "familyName": "Caacupe One",
+    "category": "display",
+    "ascent": 960,
+    "descent": -340,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 309
+  },
   "Cabin": {
     "familyName": "Cabin",
     "category": "sans-serif",
@@ -8187,7 +8205,7 @@
     "descent": -120,
     "lineGap": 0,
     "unitsPerEm": 1000,
-    "xWidthAvg": 311
+    "xWidthAvg": 313
   },
   "Macondo": {
     "familyName": "Macondo",
@@ -14993,6 +15011,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 457
   },
+  "Scoutie Sans": {
+    "familyName": "Scoutie Sans",
+    "category": "sans-serif",
+    "ascent": 2000,
+    "descent": -600,
+    "lineGap": 0,
+    "unitsPerEm": 2000,
+    "xWidthAvg": 920
+  },
   "Seaweed Script": {
     "familyName": "Seaweed Script",
     "category": "display",
@@ -16847,6 +16874,15 @@
     "unitsPerEm": 1000,
     "xWidthAvg": 400
   },
+  "Valley Sans": {
+    "familyName": "Valley Sans",
+    "category": "sans-serif",
+    "ascent": 960,
+    "descent": -240,
+    "lineGap": 0,
+    "unitsPerEm": 1000,
+    "xWidthAvg": 487
+  },
   "Vampiro One": {
     "familyName": "Vampiro One",
     "category": "display",

data/lib/klenod/build/plugins/google_fonts_plugin/font_metrics.txt

@@ -5,7 +5,7 @@ Update them to the latest Capsize revision from the Klenod repository root:
     bundle exec rake google_fonts:metrics:update
 
 Project: https://github.com/seek-oss/capsize
-Commit: b0eb891c39e2ecd8b680f550bcda6f5fe9e38326
+Commit: 8df97f098adc19d8a6d33df301757d7e9670bae6
 Source: packages/metrics/src/entireMetricsCollection.json
 
 MIT License

data/lib/klenod/build/plugins/haml_plugin/parser.rb

@@ -46,6 +46,7 @@ module Klenod
           # invalid attribute list. Join the lines of an unclosed list first so
           # both forms work across lines.
           def parse_new_attributes(text)
+            tag_prefix = @line.text.strip[/\A[^(]*/]
             joined_lines = 0
             until (close_index = attribute_list_close_index(text)) || @next_line.eod?
               text = "#{text} #{@next_line.text}"
@@ -56,7 +57,13 @@ module Klenod
             pairs = close_index && extended_attribute_pairs(text[1...close_index])
             rest = close_index && text[(close_index + 1)..]
             unless pairs&.any? { |_name, value| value.match?(/[.\[]/) }
-              attributes, rest, last_line = super
+              begin
+                attributes, rest, last_line = super
+              rescue ::Haml::SyntaxError => error
+                raise unless pairs && error.message.start_with?("Invalid attribute list")
+
+                raise ::Haml::SyntaxError.new("#{error.message}\n\n#{hash_attributes_hint(tag_prefix, pairs)}", error.line)
+              end
               return [attributes, rest, last_line + joined_lines]
             end
 
@@ -147,6 +154,19 @@ module Klenod
             pairs
           end
 
+          # Every value is valid Ruby, but some are neither Haml's bare variables
+          # nor the member and index expressions handled above. Suggest the
+          # equivalent hash attributes, which accept any Ruby expression.
+          def hash_attributes_hint(tag_prefix, pairs)
+            entries = pairs.map do |name, value|
+              key = name.match?(/\A[a-z_]\w*\z/i) ? name : name.inspect
+              "#{key}: #{value}"
+            end
+            tag_prefix = "" unless tag_prefix.match?(/\A[%.#][-:\w.#]*\z/)
+
+            "Hint:\n  Use {} attributes for Ruby expressions: #{tag_prefix}{#{entries.join(", ")}}"
+          end
+
           # Returns the index of the `)` that closes the list opened at index 0,
           # ignoring brackets inside quoted values.
           def attribute_list_close_index(source)

data/lib/klenod/build/plugins/haml_plugin/transformer/ruby_builder.rb

@@ -585,7 +585,7 @@ module Klenod
               return source unless source.include?("__LINE__")
 
               line_offsets = [0]
-              source.each_line(chomp: false) { |line| line_offsets << line_offsets.last + line.length }
+              source.each_line(chomp: false) { |line| line_offsets << line_offsets.last + line.bytesize }
 
               Ripper
                 .lex(source)
@@ -593,7 +593,7 @@ module Klenod
                 .reverse_each
                 .each_with_object(source.dup) do |((line, column), _type, token, _state), rewritten|
                   offset = line_offsets.fetch(line - 1) + column
-                  rewritten[offset, token.length] = line_no.to_s
+                  rewritten.bytesplice(offset, token.bytesize, line_no.to_s)
                 end
             end
 
@@ -607,7 +607,7 @@ module Klenod
               return source if @variables.empty?
 
               line_offsets = [0]
-              source.each_line(chomp: false) { |line| line_offsets << line_offsets.last + line.length }
+              source.each_line(chomp: false) { |line| line_offsets << line_offsets.last + line.bytesize }
 
               tokens = Ripper.lex(source)
 
@@ -617,17 +617,17 @@ module Klenod
                   kind, prefix, pattern = VARIABLE_TOKEN_KINDS[type]
                   receiver = @variables[kind]
                   if type == :on_gvar && token == "$*" && receiver
-                    [offset_for(line_offsets, line, column), token.length, receiver]
+                    [offset_for(line_offsets, line, column), token.bytesize, receiver]
                   elsif receiver && token.match?(pattern)
                     name = token.delete_prefix(prefix)
                     replacement = "(#{receiver})[#{symbol_source(name)}]"
                     replacement = "{#{replacement}}" if tokens[index - 1]&.fetch(1) == :on_embvar
-                    [offset_for(line_offsets, line, column), token.length, replacement]
+                    [offset_for(line_offsets, line, column), token.bytesize, replacement]
                   end
                 end
                 .reverse_each
                 .each_with_object(source.dup) do |(offset, length, replacement), rewritten|
-                  rewritten[offset, length] = replacement
+                  rewritten.bytesplice(offset, length, replacement)
                 end
             end
 

data/lib/klenod/build/plugins/haml_plugin/transformer.rb

@@ -5,6 +5,7 @@ require "ripper"
 
 require "klenod/runtime/source_map"
 require_relative "../markdown_compiler"
+require_relative "../text_interpolation"
 require_relative "parser"
 
 module Klenod
@@ -613,11 +614,18 @@ module Klenod
           def compile_filter_node(node, builder:, markdown_compiler:)
             return builder.render_ruby_filter(compile_ruby_filter(node, builder: builder)) if ruby_filter?(node)
             return builder.expression(markdown_compiler.compile(node.value.fetch(:text), interpolate: true)) if markdown_filter?(node)
-            return builder.literal(node.value.fetch(:text).to_s) if plain_filter?(node)
+            return compile_plain_filter(node.value.fetch(:text).to_s, builder: builder) if plain_filter?(node)
 
             raise ArgumentError, "Only :ruby, :markdown, and :plain Haml filters are supported"
           end
 
+          def compile_plain_filter(text, builder:)
+            source = TextInterpolation::Source.new(text)
+            return builder.literal(source.literal(source.text)) unless source.interpolated?
+
+            builder.expression("[#{source.expressions(source.text).join(", ")}]")
+          end
+
           def ruby_filter?(node)
             node.type == :filter && node.value.fetch(:name) == "ruby"
           end

data/lib/klenod/build/plugins/markdown_compiler.rb

@@ -9,11 +9,13 @@ ensure
   $VERBOSE = previous_verbose
 end
 
+require_relative "text_interpolation"
+
 module Klenod
   module Build
     module Plugins
       class MarkdownCompiler
-        ESCAPED_INTERPOLATION_SENTINEL = "\uE000klenod_escaped_interpolation\uE000"
+        TYPOGRAPHIC_TEXT = Kramdown::Converter::Html::TYPOGRAPHIC_SYMS.transform_values { |entities| entities.map(&:char).join }.freeze
 
         def initialize(factory:, components_source: "{}")
           @factory = factory
@@ -21,69 +23,95 @@ module Klenod
         end
 
         def compile(source, interpolate: false)
-          source = protect_escaped_interpolation(source) if interpolate
-          document = Kramdown::Document.new(source, input: "GFM", hard_wrap: false)
-          compile_children(document.root.children, interpolate: interpolate)
+          @interpolation = TextInterpolation::Source.new(source) if interpolate
+          document = Kramdown::Document.new(@interpolation&.text || source, input: "GFM", hard_wrap: false)
+          compile_children(document.root.children)
+        ensure
+          @interpolation = nil
         end
 
         private
 
-        def compile_children(children, parent: nil, interpolate: false)
-          expressions = compile_child_expressions(children, parent: parent, interpolate: interpolate)
+        def compile_children(children, parent: nil)
+          expressions = compile_child_expressions(children, parent: parent)
           return "nil" if expressions.empty?
           return expressions.fetch(0) if expressions.length == 1
 
           "[#{expressions.join(", ")}]"
         end
 
-        def compile_child_expressions(children, parent:, interpolate:, table_section: nil)
-          children.flat_map { |child| compile_node(child, parent: parent, table_section: table_section, interpolate: interpolate) }.compact
+        def compile_child_expressions(children, parent:, table_section: nil)
+          merge_text_nodes(children).flat_map { |child| compile_node(child, parent: parent, table_section: table_section) }.compact
+        end
+
+        # Kramdown splits typographic replacements and entities out of text.
+        # Fold them back into neighboring text so "it's" stays one string.
+        def merge_text_nodes(children)
+          children.each_with_object([]) do |child, merged|
+            text = inline_text(child)
+            if text.nil?
+              merged << child
+            elsif merged.last&.type == :text
+              merged[-1] = Kramdown::Element.new(:text, merged.last.value + text)
+            else
+              merged << Kramdown::Element.new(:text, text)
+            end
+          end
+        end
+
+        def inline_text(node)
+          case node.type
+          when :text then node.value
+          when :smart_quote then Kramdown::Utils::Entities.entity(node.value.to_s).char
+          when :typographic_sym then TYPOGRAPHIC_TEXT.fetch(node.value)
+          when :entity then node.value.char
+          end
         end
 
-        def compile_node(node, parent: nil, table_section: nil, interpolate: false)
+        def compile_node(node, parent: nil, table_section: nil)
           case node.type
           when :root
-            [compile_children(node.children, parent: node, interpolate: interpolate)]
+            [compile_children(node.children, parent: node)]
           when :blank
             nil
           when :text
-            text_expressions(node.value, interpolate: interpolate)
+            text_expressions(node.value)
           when :p
-            return compile_child_expressions(node.children, parent: node, interpolate: interpolate) if node.options[:transparent]
+            return compile_child_expressions(node.children, parent: node) if node.options[:transparent]
 
-            [factory_call(:p, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(:p, node.children, attrs: node.attr, parent: node)]
           when :header
-            [factory_call(:"h#{node.options.fetch(:level)}", node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(:"h#{node.options.fetch(:level)}", node.children, attrs: header_attrs(node), parent: node)]
           when :em, :strong, :a, :blockquote, :ul, :ol, :li, :table
-            [factory_call(node.type, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node)]
           when :thead, :tbody
-            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: node.type, interpolate: interpolate)]
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: node.type)]
           when :tr
-            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: table_section, interpolate: interpolate)]
+            [factory_call(node.type, node.children, attrs: node.attr, parent: node, table_section: table_section)]
           when :td
-            [factory_call((table_section == :thead) ? :th : :td, node.children, attrs: node.attr, parent: node, table_section: table_section, interpolate: interpolate)]
+            [factory_call((table_section == :thead) ? :th : :td, node.children, attrs: node.attr, parent: node, table_section: table_section)]
           when :img, :hr, :br
-            [factory_call(node.type, [], attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(node.type, [], attrs: node.attr, parent: node)]
           when :codespan
-            [factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node)]
           when :codeblock
-            code = factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node, interpolate: interpolate)
-            [factory_call(:pre, [], child_sources: [code], parent: node, interpolate: interpolate)]
+            code = factory_call(:code, [node], raw_text: node.value, attrs: node.attr, parent: node)
+            [factory_call(:pre, [], child_sources: [code], parent: node)]
           when :html_element
-            [factory_call(node.value.to_sym, node.children, attrs: node.attr, parent: node, interpolate: interpolate)]
+            [factory_call(node.value.to_sym, node.children, attrs: node.attr, parent: node)]
           when :raw
-            [restore_escaped_interpolation(node.value.to_s).inspect]
+            [literal_text(node.value.to_s).inspect]
           else
-            [compile_children(node.children, parent: node, interpolate: interpolate)]
+            [compile_children(node.children, parent: node)]
           end
         end
 
-        def factory_call(tag, children, parent:, attrs: {}, raw_text: nil, child_sources: nil, table_section: nil, interpolate: false)
+        def factory_call(tag, children, parent:, attrs: {}, raw_text: nil, child_sources: nil, table_section: nil)
           child_sources ||=
             if raw_text.nil?
-              compile_child_expressions(children, parent: parent, table_section: table_section, interpolate: interpolate)
+              compile_child_expressions(children, parent: parent, table_section: table_section)
             else
-              [restore_escaped_interpolation(raw_text).inspect]
+              [literal_text(raw_text).inspect]
             end
           tag_source = tag_source(tag)
           parts = [tag_source, *child_sources]
@@ -97,82 +125,33 @@ module Klenod
         end
 
         def attrs_source(attrs)
-          attrs.transform_keys(&:to_sym).inspect
-        end
-
-        def text_expressions(text, interpolate:)
-          return [restore_escaped_interpolation(text).inspect] unless interpolate && text.include?("\#{")
-
-          expressions = []
-          buffer = +""
-          index = 0
-
-          while index < text.length
-            if text[index, 2] == "\#{"
-              expression, next_index = read_interpolation(text, index + 2)
-              if expression
-                expressions << restore_escaped_interpolation(buffer).inspect unless buffer.empty?
-                buffer.clear
-                expressions << "(#{expression})"
-                index = next_index
-              else
-                buffer << text[index]
-                index += 1
-              end
-            else
-              buffer << text[index]
-              index += 1
-            end
+          pairs = attrs.map do |name, value|
+            value_source = value.is_a?(String) ? string_source(value) : value.inspect
+            "#{name.to_sym.inspect} => #{value_source}"
           end
 
-          expressions << restore_escaped_interpolation(buffer).inspect unless buffer.empty?
-          expressions
+          "{#{pairs.join(", ")}}"
         end
 
-        def read_interpolation(text, index)
-          expression = +""
-          depth = 1
-          quote = nil
-          escaped = false
-
-          while index < text.length
-            char = text[index]
-
-            if quote
-              expression << char
-              if escaped
-                escaped = false
-              elsif char == "\\"
-                escaped = true
-              elsif char == quote
-                quote = nil
-              end
-            else
-              case char
-              when "\"", "'", "`"
-                quote = char
-              when "{"
-                depth += 1
-              when "}"
-                depth -= 1
-                return [expression.strip, index + 1] if depth.zero?
-              end
-
-              expression << char
-            end
+        # Kramdown derives heading IDs from text that still contains
+        # interpolation tokens, which leaves stray separators behind.
+        def header_attrs(node)
+          id = node.attr["id"]
+          return node.attr unless id && @interpolation&.interpolated?(node.options[:raw_text].to_s)
 
-            index += 1
-          end
+          node.attr.merge("id" => id.gsub(/-{2,}/, "-").delete_prefix("-").delete_suffix("-"))
+        end
 
-          nil
+        def text_expressions(text)
+          @interpolation ? @interpolation.expressions(text) : [text.inspect]
         end
 
-        def protect_escaped_interpolation(source)
-          source.gsub("\\\#{", ESCAPED_INTERPOLATION_SENTINEL)
+        def string_source(text)
+          @interpolation ? @interpolation.string_source(text) : text.inspect
         end
 
-        def restore_escaped_interpolation(text)
-          text.gsub(ESCAPED_INTERPOLATION_SENTINEL, "\#{")
+        def literal_text(text)
+          @interpolation ? @interpolation.literal(text) : text
         end
       end
     end

data/lib/klenod/build/plugins/text_interpolation.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Klenod
+  module Build
+    module Plugins
+      # Compiles Ruby-style `#{...}` interpolation in filter text into Ruby
+      # source. `\#{` stays literal.
+      #
+      # Each interpolation is replaced by an opaque private-use token before
+      # the text is parsed further, so parsers such as Markdown never see the
+      # Ruby expression. Compile the parsed pieces back with the same Source.
+      module TextInterpolation
+        TOKEN_START = ""
+        TOKEN_END = ""
+        ESCAPE_TOKEN = ""
+        FIRST_INDEX_CODEPOINT = 0xE100
+        LAST_INDEX_CODEPOINT = 0xF8FF
+        TOKEN_PATTERN = /#{TOKEN_START}([\u{E100}-\u{F8FF}])#{TOKEN_END}/o
+        SEGMENT_PATTERN = /#{TOKEN_START}[\u{E100}-\u{F8FF}]#{TOKEN_END}|#{ESCAPE_TOKEN}/o
+
+        class Source
+          # The source with interpolations and escapes replaced by tokens.
+          attr_reader :text
+
+          def initialize(source)
+            @interpolations = []
+            @text = tokenize(source)
+          end
+
+          def interpolated?(text = @text)
+            text.match?(TOKEN_PATTERN)
+          end
+
+          # Returns Ruby source for each literal and interpolated segment of
+          # tokenized text.
+          def expressions(text)
+            segments(text).map { |kind, value| (kind == :ruby) ? "(#{value})" : value.inspect }
+          end
+
+          # Returns Ruby source for one String built from tokenized text.
+          def string_source(text)
+            parts = segments(text)
+            return literal(text).inspect if parts.none? { |kind, _| kind == :ruby }
+
+            body = parts.map { |kind, value| (kind == :ruby) ? "\#{#{value}}" : value.inspect[1...-1] }.join
+            "\"#{body}\""
+          end
+
+          # Restores tokenized text to its original characters, keeping
+          # interpolations as literal `#{...}` text.
+          def literal(text)
+            text.gsub(SEGMENT_PATTERN) do |token|
+              (token == ESCAPE_TOKEN) ? "\#{" : @interpolations.fetch(token_index(token)).fetch(:raw)
+            end
+          end
+
+          private
+
+          def segments(text)
+            segments = []
+            buffer = +""
+
+            text.split(/(#{SEGMENT_PATTERN})/o).each do |part|
+              if part == ESCAPE_TOKEN
+                buffer << "\#{"
+              elsif part.match?(TOKEN_PATTERN)
+                segments << [:text, buffer] unless buffer.empty?
+                buffer = +""
+                segments << [:ruby, @interpolations.fetch(token_index(part)).fetch(:expression)]
+              else
+                buffer << part
+              end
+            end
+
+            segments << [:text, buffer] unless buffer.empty?
+            segments
+          end
+
+          def token_index(token)
+            token[TOKEN_PATTERN, 1].ord - FIRST_INDEX_CODEPOINT
+          end
+
+          def tokenize(source)
+            output = +""
+            index = 0
+
+            while index < source.length
+              if source[index, 3] == "\\\#{"
+                output << ESCAPE_TOKEN
+                index += 3
+              elsif source[index, 2] == "\#{" && (interpolation = read_interpolation(source, index + 2))
+                expression, next_index = interpolation
+                output << token(expression, raw: source[index...next_index])
+                index = next_index
+              else
+                output << source[index]
+                index += 1
+              end
+            end
+
+            output
+          end
+
+          def token(expression, raw:)
+            codepoint = FIRST_INDEX_CODEPOINT + @interpolations.length
+            raise ArgumentError, "Too many interpolations in one filter" if codepoint > LAST_INDEX_CODEPOINT
+
+            @interpolations << {expression: expression, raw: raw}
+            "#{TOKEN_START}#{codepoint.chr(Encoding::UTF_8)}#{TOKEN_END}"
+          end
+
+          def read_interpolation(text, index)
+            expression = +""
+            depth = 1
+            quote = nil
+            escaped = false
+
+            while index < text.length
+              char = text[index]
+
+              if quote
+                expression << char
+                if escaped
+                  escaped = false
+                elsif char == "\\"
+                  escaped = true
+                elsif char == quote
+                  quote = nil
+                end
+              else
+                case char
+                when "\"", "'", "`"
+                  quote = char
+                when "{"
+                  depth += 1
+                when "}"
+                  depth -= 1
+                  return [expression.strip, index + 1] if depth.zero?
+                end
+
+                expression << char
+              end
+
+              index += 1
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.23"
+    VERSION = "0.0.25"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.25
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.23
+        version: 0.0.25
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.23
+        version: 0.0.25
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -293,6 +293,7 @@ files:
 - lib/klenod/build/plugins/ruby_plugin.rb
 - lib/klenod/build/plugins/static_asset_plugin.rb
 - lib/klenod/build/plugins/svg_plugin.rb
+- lib/klenod/build/plugins/text_interpolation.rb
 - lib/klenod/build/profiler.rb
 - lib/klenod/build/resolution_error_formatter.rb
 - lib/klenod/build/resolver.rb