klenod-build 0.0.22 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7873fce94ba35f8420b6aa896bca1866896d5c9f038102f0d13522fb1fa9a16
-  data.tar.gz: 715c13a86148ae750ed6151f05e4fbcb32d1d73bf21d139d1b21d42f7bb405f4
+  metadata.gz: 6f22c9acfae008123fd3b68c5ab499c7bc8df3da4d5e135dea331f0fe6563596
+  data.tar.gz: da87ac500d4d0f26bdeb4ff3249afacd1e34d594bb2f4e18bff1c1c4dd818e64
 SHA512:
-  metadata.gz: 29157efe18cfdd5982f05ef742f07bb56ee64f54c820b152569be703b76a97dc76f71c166b67ff57e8b5124bed59f16ecbcf39415118dba3672a304854d4fbfa
-  data.tar.gz: 0a0b9e45f353aa70004c01ed9f78d1fe6ef667c7eb4faa5e7c64d038087ed82501c7f77755ed5e67dd26504ac122ee14a7c5414164b36c5933afae86df89df37
+  metadata.gz: 0dd4bce3f8c250ed256e4362e6337f8ddee38c2865b9aba9ae7153066b1fb4d34f0fb324714626b4787011fde4118b1bc3f80a487865e2ee409248aebb44375f
+  data.tar.gz: a65805c594f8d0823ce2df36a1b9d2f5c00e7b5ff71d3a178c1b8d7cc5f24a0f69d09d5d254d8bd16479d9c476b3ac14f67d097ea28efb2ccc7d89fd34f6dcec

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

@@ -40,13 +40,28 @@ module Klenod
           # `video` plus a `.id` class. Extend that form to ordinary Ruby
           # member and index expressions while leaving all other attributes on
           # Haml's native parsing path.
+          #
+          # Haml also continues a parenthesized list onto following lines only
+          # after the first attribute, so `%a(` followed by a line break is an
+          # invalid attribute list. Join the lines of an unclosed list first so
+          # both forms work across lines.
           def parse_new_attributes(text)
-            balanced, rest = ::Haml::Util.balance(text, "(", ")")
-            pairs = balanced && extended_attribute_pairs(balanced[1...-1])
-            return super unless pairs&.any? { |_name, value| value.match?(/[.\[]/) }
+            joined_lines = 0
+            until (close_index = attribute_list_close_index(text)) || @next_line.eod?
+              text = "#{text} #{@next_line.text}"
+              joined_lines += 1
+              next_line
+            end
+
+            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
+              return [attributes, rest, last_line + joined_lines]
+            end
 
             dynamic = pairs.reduce("{") { |source, (name, value)| "#{source}#{::Haml::Util.inspect_obj(name)} => #{value}," } << "}"
-            [[{}, dynamic], rest, @line.index + 1]
+            [[{}, dynamic], rest, @line.index + 1 + joined_lines]
           end
 
           def annotate_tag_nodes(root)
@@ -132,6 +147,36 @@ module Klenod
             pairs
           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)
+            depth = 0
+            quote = nil
+            escaped = false
+
+            source.each_char.with_index do |character, index|
+              if quote
+                if escaped
+                  escaped = false
+                elsif character == "\\"
+                  escaped = true
+                elsif character == quote
+                  quote = nil
+                end
+              else
+                case character
+                when "'", '"' then quote = character
+                when "(", "[", "{" then depth += 1
+                when ")", "]", "}"
+                  depth -= 1
+                  return index if depth.zero?
+                end
+              end
+            end
+
+            nil
+          end
+
           def attribute_boundary?(remaining_source)
             attribute_sequence?(remaining_source)
           end

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.22"
+    VERSION = "0.0.24"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.0.24
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.22
+        version: 0.0.24
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.22
+        version: 0.0.24
 - !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