ruby_ui_converter 0.1.0 → 0.2.0

data/lib/ruby_ui_converter/haml_parser.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Builds the converter's AST (Nodes) from a HAML template.
+  #
+  # Parsing itself is delegated to the haml gem's own parser (Haml::Parser), an
+  # OPTIONAL dependency required lazily — only when a .haml file is converted —
+  # so ERB-only users keep `thor` as the sole runtime dependency. Apps with
+  # .haml views already have haml in their bundle.
+  #
+  # The result has the same shape the ERB Parser builds for the equivalent ERB
+  # (Text/Output/Statement/Control/Element nodes, attribute "parts"), so the
+  # whole downstream pipeline — Transformer, ComponentMap, RailsHelpers,
+  # FormBuilder, LocalsDetector — is shared between both formats. HAML text
+  # (which may hold inline HTML) is itself routed through the ERB Parser, with
+  # each `#{}` interpolation turned into an `<%= %>` tag.
+  #
+  # Verified against haml 5.2, 6.x and 7.x, which share the ParseNode tree
+  # shape and the `Haml::Parser.new(options).call(source)` API.
+  class HamlParser
+    # Mid-block keywords. Haml nests them (flattened) among the children of the
+    # `if`/`case`/`begin` node they belong to; each one starts a new Branch.
+    MID_KEYWORDS = %w[else elsif when in rescue ensure].freeze
+
+    # With escape_html on, haml 5 and 6 wrap every text interpolation in an
+    # escape call (haml 5: `Haml::Helpers.html_escape((x))`, haml 6:
+    # `Haml::Util.escape_html_safe((x).to_s)`); haml 7 doesn't. Phlex escapes
+    # output itself, so the wrapper is stripped back to the original code.
+    ESCAPE_WRAPPER = /\A(?:::)?Haml::(?:Helpers\.html_escape|Util\.escape_html_safe|Util\.escape_html)\(\((.*)\)(?:\.to_s)?\)\z/m
+
+    # Filters whose content is HAML/HTML text (interpolated, unescaped HTML).
+    TEXT_FILTERS = %w[plain preserve].freeze
+    # Filters rendered as an element wrapping their raw content.
+    RAW_ELEMENT_FILTERS = { "javascript" => "script", "css" => "style" }.freeze
+
+    MISSING_HAML = "converting .haml templates requires the haml gem " \
+                   "(add `gem \"haml\"` to your Gemfile or run `gem install haml`)"
+
+    def self.load_haml!
+      require_haml
+      true
+    rescue LoadError
+      raise Error, MISSING_HAML
+    end
+
+    # Separate seam so tests can simulate a missing haml gem.
+    def self.require_haml
+      require "haml"
+    end
+
+    # `Haml::Helpers.html_escape((name))` -> `name`; anything else unchanged.
+    def self.unwrap_escape(code)
+      code = code.to_s.strip
+      (inner = code[ESCAPE_WRAPPER, 1]) ? inner.strip : code
+    end
+
+    def initialize(source)
+      @source = source.to_s
+    end
+
+    def parse
+      self.class.load_haml!
+      # escape_html: true (the Rails default) is what lets the parser tell
+      # `=` (escaped) apart from `!=` (raw).
+      root = ::Haml::Parser.new(escape_html: true).call(@source)
+
+      document = Nodes::Document.new
+      convert_children(root.children, document.children)
+      document
+    end
+
+    private
+
+    # Converts sibling HAML nodes, then pads text that sits next to another
+    # rendered sibling: HAML puts a newline between lines, so `Signed in as`
+    # followed by `%strong= name` renders with a space in between.
+    def convert_children(nodes, target)
+      rendered = nodes.reject { |node| silent?(node) }
+
+      nodes.each do |node|
+        start = target.length
+        convert(node, target)
+        next if silent?(node)
+
+        position = rendered.index { |other| other.equal?(node) }
+        before = position.positive? && !nuke_outer?(rendered[position - 1])
+        after = position < rendered.length - 1 && !nuke_outer?(rendered[position + 1])
+        pad_text(target, start, before: before && !nuke_outer?(node), after: after && !nuke_outer?(node))
+      end
+    end
+
+    # Nodes that render nothing between their siblings.
+    def silent?(node)
+      node.type == :haml_comment || (node.type == :silent_script && node.children.empty?)
+    end
+
+    # `%img>`: whitespace around the tag is removed.
+    def nuke_outer?(node)
+      node.type == :tag && node.value[:nuke_outer_whitespace] ? true : false
+    end
+
+    def pad_text(target, start, before:, after:)
+      return if start >= target.length
+
+      first = target[start]
+      if before && first.is_a?(Nodes::Text) && first.content !~ /\A\s/
+        target[start] = Nodes::Text.new(content: " #{first.content}")
+      end
+
+      last = target[-1]
+      return unless after && last.is_a?(Nodes::Text) && last.content !~ /\s\z/
+
+      target[-1] = Nodes::Text.new(content: "#{last.content} ")
+    end
+
+    def convert(node, target)
+      case node.type
+      when :tag then target << element(node)
+      when :plain then target.concat(text_nodes([[:text, node.value[:text].to_s]]))
+      when :script then script(node, target)
+      when :silent_script then silent_script(node, target)
+      when :haml_comment then target << ruby_comment(node.value[:text])
+      when :comment then html_comment(node, target)
+      when :doctype then doctype(node, target)
+      when :filter then filter(node, target)
+      end
+    end
+
+    # HAML text is unescaped HTML with escaped `#{}` interpolations — exactly
+    # what ERB text with `<%= %>` tags is — so it goes through the ERB Parser:
+    # inline markup (`Hi <strong>you</strong>`) becomes real elements, and
+    # interpolated helpers (`#{link_to ...}`) become Output nodes the
+    # RailsHelpers mapping understands.
+    def text_nodes(parts)
+      erb = parts.map { |kind, value| kind == :text ? value : "<%= #{value} %>" }.join
+      Parser.new(erb).parse.children
+    end
+
+    # --- tags --------------------------------------------------------------
+
+    def element(node)
+      value = node.value
+      element = Nodes::Element.new(
+        name: value[:name],
+        attributes: HamlAttributes.build(value),
+        self_closing: value[:self_closing] ? true : false
+      )
+      inline_content(value, element.children)
+      convert_children(node.children, element.children)
+      element
+    end
+
+    # `%p Hello` / `%p= code` / `%p!= code` / `%p Hi #{name}`
+    def inline_content(value, target)
+      content = value[:value]
+      return if content.nil? || content.to_s.empty?
+
+      if value[:parse]
+        expression(content, value[:escape_html], value[:escape_interpolation], target)
+      else
+        target.concat(text_nodes([[:text, content.to_s]]))
+      end
+    end
+
+    # --- Ruby --------------------------------------------------------------
+
+    # `= code` (with or without a block) and interpolated plain text, which
+    # haml hands over as a script node.
+    def script(node, target)
+      text = node.value[:text].to_s.strip
+
+      if node.children.any?
+        target << control(node, text, output: true)
+      else
+        expression(text, node.value[:escape_html], node.value[:escape_interpolation], target)
+      end
+    end
+
+    def silent_script(node, target)
+      text = node.value[:text].to_s.strip
+
+      if mid_keyword?(node) && target.last.is_a?(Nodes::Control)
+        # Defensive: a mid-block keyword left as a sibling of its opener.
+        branch = Nodes::Branch.new(header: text)
+        target.last.branches << branch
+        convert_children(node.children, branch.children)
+      elsif node.children.any?
+        target << control(node, text, output: false)
+      else
+        target << Nodes::Statement.new(code: text)
+      end
+    end
+
+    # `- if a` … `- elsif b` … `- else`, `- case`/`- when`, `- x.each do |i|`,
+    # `= form_with(...) do |f|`. Haml always closes blocks by indentation, so
+    # the matching `end` is implicit (the Transformer emits it).
+    def control(node, header, output:)
+      control = Nodes::Control.new(block: block_opener?(header), output: output)
+      segments = [[header, []]]
+
+      node.children.each do |child|
+        if mid_keyword?(child)
+          segments << [child.value[:text].to_s.strip, child.children.dup]
+        else
+          segments.last[1] << child
+        end
+      end
+
+      segments.each do |branch_header, children|
+        branch = Nodes::Branch.new(header: branch_header)
+        convert_children(children, branch.children)
+        control.branches << branch
+      end
+
+      control
+    end
+
+    def mid_keyword?(node)
+      node.type == :silent_script && MID_KEYWORDS.include?(node.value[:keyword])
+    end
+
+    def block_opener?(code)
+      code =~ /\bdo\s*(\|[^|]*\|)?\s*\z/ ? true : false
+    end
+
+    # A Ruby expression whose value is output: escaped (`=`, `&=`, `~`), raw
+    # (`!=`), or text with `#{}` interpolation — parsed like the ERB
+    # `Hello <%= name %>` equivalent, so helpers and locals inside the
+    # interpolation are seen by the rest of the pipeline.
+    def expression(code, escape_html, escape_interpolation, target)
+      code = code.to_s.strip
+      parts = interpolated_text_parts(code, escape_html, escape_interpolation)
+
+      if parts
+        target.concat(text_nodes(parts))
+      else
+        target << Nodes::Output.new(code: code, raw: escape_html == false)
+      end
+    end
+
+    # Interpolated text is flagged with escape_interpolation (haml 6/7 plain
+    # lines, haml 7 inline text); haml 5/6 inline text is only recognizable by
+    # the escape wrappers around its interpolations.
+    def interpolated_text_parts(code, escape_html, escape_interpolation)
+      parts = RubyLiteral.string_parts(code)
+      return nil unless parts
+
+      wrapped = parts.any? { |kind, value| kind == :code && value.match?(ESCAPE_WRAPPER) }
+      return nil unless escape_interpolation || (escape_html == false && wrapped)
+
+      parts.map { |kind, value| kind == :code ? [kind, self.class.unwrap_escape(value)] : [kind, value] }
+    end
+
+    # Text with HAML `#{}` interpolation (filter content) as text/code parts.
+    def interpolation_parts(text)
+      return [[:text, text]] unless text =~ /#[{@$]/
+
+      RubyLiteral.string_parts(::Haml::Util.unescape_interpolation(text)) || [[:text, text]]
+    end
+
+    # --- comments, doctype, filters ----------------------------------------
+
+    def ruby_comment(text)
+      Nodes::Comment.new(text: text.to_s.strip, html: false)
+    end
+
+    # `/ note` -> comment { "note" }; a `/` with nested HAML renders that
+    # content inside the comment (`comment do ... end`). IE conditional
+    # comments (`/[if IE]`) are obsolete and left as a TODO.
+    def html_comment(node, target)
+      value = node.value
+
+      if value[:conditional]
+        target << ruby_comment("TODO: HAML conditional comment #{value[:conditional]} dropped (content not converted)")
+      else
+        comment = Nodes::Comment.new(text: value[:text].to_s, html: true)
+        convert_children(node.children, comment.children)
+        target << comment
+      end
+    end
+
+    def doctype(node, target)
+      return if node.value[:type].to_s.downcase == "xml"
+
+      target << Nodes::Doctype.new(value: "<!DOCTYPE html>")
+    end
+
+    def filter(node, target)
+      name = node.value[:name].to_s
+      text = node.value[:text].to_s
+
+      if RAW_ELEMENT_FILTERS.key?(name)
+        target << raw_element(RAW_ELEMENT_FILTERS[name], text)
+      elsif TEXT_FILTERS.include?(name)
+        target.concat(text_nodes(interpolation_parts(text.rstrip)))
+      elsif name == "escaped"
+        interpolation_parts(text.rstrip).each do |kind, value|
+          target << (kind == :text ? Nodes::Text.new(content: value) : Nodes::Output.new(code: value))
+        end
+      elsif name == "erb"
+        target.concat(Parser.new(text).parse.children)
+      elsif name == "ruby"
+        text.each_line { |line| target << Nodes::Statement.new(code: line.rstrip) unless line.strip.empty? }
+      else
+        target << ruby_comment("TODO: HAML :#{name} filter not converted\n#{text.rstrip}")
+      end
+    end
+
+    # :javascript / :css -> script / style. Content without interpolation is
+    # kept verbatim (RawText, like an ERB <script>); with `#{}` it becomes a
+    # raw interpolated string.
+    def raw_element(tag, text)
+      element = Nodes::Element.new(name: tag)
+      return element if text.strip.empty?
+
+      parts = interpolation_parts(text)
+      element.children <<
+        if parts.any? { |kind, _| kind == :code }
+          Nodes::Output.new(code: ::Haml::Util.unescape_interpolation(text), raw: true)
+        else
+          Nodes::RawText.new(content: text)
+        end
+      element
+    end
+  end
+end

data/lib/ruby_ui_converter/html_entities.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RubyUIConverter
+  # Decodes HTML character references found in template text and attribute
+  # values (`©`, ` `, `—`, `—`) into the characters they
+  # stand for. Phlex escapes everything it outputs, so leaving them encoded
+  # would double-escape them (`©` would render as the literal text
+  # "&copy;"); decoded, Phlex re-escapes only what needs it (`&lt;` -> `<` ->
+  # `&lt;`).
+  #
+  # Named references come from the HTML 4 set (plus `&apos;`) — the ones seen
+  # in real templates. Unknown names, references without the closing `;` and
+  # invalid code points are left untouched.
+  module HtmlEntities
+    module_function
+
+    PATTERN = /&(?:#(\d+)|#[xX](\h+)|([A-Za-z][A-Za-z0-9]*));/
+
+    # Generated from Python's html.entities.name2codepoint (HTML 4.01) + apos.
+    NAMED = {
+      "Aacute" => 193, "aacute" => 225, "Acirc" => 194, "acirc" => 226, "acute" => 180,
+      "AElig" => 198, "aelig" => 230, "Agrave" => 192, "agrave" => 224, "alefsym" => 8501,
+      "Alpha" => 913, "alpha" => 945, "amp" => 38, "and" => 8743, "ang" => 8736, "apos" => 39,
+      "Aring" => 197, "aring" => 229, "asymp" => 8776, "Atilde" => 195, "atilde" => 227,
+      "Auml" => 196, "auml" => 228, "bdquo" => 8222, "Beta" => 914, "beta" => 946, "brvbar" => 166,
+      "bull" => 8226, "cap" => 8745, "Ccedil" => 199, "ccedil" => 231, "cedil" => 184,
+      "cent" => 162, "Chi" => 935, "chi" => 967, "circ" => 710, "clubs" => 9827, "cong" => 8773,
+      "copy" => 169, "crarr" => 8629, "cup" => 8746, "curren" => 164, "Dagger" => 8225,
+      "dagger" => 8224, "dArr" => 8659, "darr" => 8595, "deg" => 176, "Delta" => 916,
+      "delta" => 948, "diams" => 9830, "divide" => 247, "Eacute" => 201, "eacute" => 233,
+      "Ecirc" => 202, "ecirc" => 234, "Egrave" => 200, "egrave" => 232, "empty" => 8709,
+      "emsp" => 8195, "ensp" => 8194, "Epsilon" => 917, "epsilon" => 949, "equiv" => 8801,
+      "Eta" => 919, "eta" => 951, "ETH" => 208, "eth" => 240, "Euml" => 203, "euml" => 235,
+      "euro" => 8364, "exist" => 8707, "fnof" => 402, "forall" => 8704, "frac12" => 189,
+      "frac14" => 188, "frac34" => 190, "frasl" => 8260, "Gamma" => 915, "gamma" => 947,
+      "ge" => 8805, "gt" => 62, "hArr" => 8660, "harr" => 8596, "hearts" => 9829, "hellip" => 8230,
+      "Iacute" => 205, "iacute" => 237, "Icirc" => 206, "icirc" => 238, "iexcl" => 161,
+      "Igrave" => 204, "igrave" => 236, "image" => 8465, "infin" => 8734, "int" => 8747,
+      "Iota" => 921, "iota" => 953, "iquest" => 191, "isin" => 8712, "Iuml" => 207, "iuml" => 239,
+      "Kappa" => 922, "kappa" => 954, "Lambda" => 923, "lambda" => 955, "lang" => 9001,
+      "laquo" => 171, "lArr" => 8656, "larr" => 8592, "lceil" => 8968, "ldquo" => 8220,
+      "le" => 8804, "lfloor" => 8970, "lowast" => 8727, "loz" => 9674, "lrm" => 8206,
+      "lsaquo" => 8249, "lsquo" => 8216, "lt" => 60, "macr" => 175, "mdash" => 8212,
+      "micro" => 181, "middot" => 183, "minus" => 8722, "Mu" => 924, "mu" => 956, "nabla" => 8711,
+      "nbsp" => 160, "ndash" => 8211, "ne" => 8800, "ni" => 8715, "not" => 172, "notin" => 8713,
+      "nsub" => 8836, "Ntilde" => 209, "ntilde" => 241, "Nu" => 925, "nu" => 957, "Oacute" => 211,
+      "oacute" => 243, "Ocirc" => 212, "ocirc" => 244, "OElig" => 338, "oelig" => 339,
+      "Ograve" => 210, "ograve" => 242, "oline" => 8254, "Omega" => 937, "omega" => 969,
+      "Omicron" => 927, "omicron" => 959, "oplus" => 8853, "or" => 8744, "ordf" => 170,
+      "ordm" => 186, "Oslash" => 216, "oslash" => 248, "Otilde" => 213, "otilde" => 245,
+      "otimes" => 8855, "Ouml" => 214, "ouml" => 246, "para" => 182, "part" => 8706,
+      "permil" => 8240, "perp" => 8869, "Phi" => 934, "phi" => 966, "Pi" => 928, "pi" => 960,
+      "piv" => 982, "plusmn" => 177, "pound" => 163, "Prime" => 8243, "prime" => 8242,
+      "prod" => 8719, "prop" => 8733, "Psi" => 936, "psi" => 968, "quot" => 34, "radic" => 8730,
+      "rang" => 9002, "raquo" => 187, "rArr" => 8658, "rarr" => 8594, "rceil" => 8969,
+      "rdquo" => 8221, "real" => 8476, "reg" => 174, "rfloor" => 8971, "Rho" => 929, "rho" => 961,
+      "rlm" => 8207, "rsaquo" => 8250, "rsquo" => 8217, "sbquo" => 8218, "Scaron" => 352,
+      "scaron" => 353, "sdot" => 8901, "sect" => 167, "shy" => 173, "Sigma" => 931, "sigma" => 963,
+      "sigmaf" => 962, "sim" => 8764, "spades" => 9824, "sub" => 8834, "sube" => 8838,
+      "sum" => 8721, "sup" => 8835, "sup1" => 185, "sup2" => 178, "sup3" => 179, "supe" => 8839,
+      "szlig" => 223, "Tau" => 932, "tau" => 964, "there4" => 8756, "Theta" => 920, "theta" => 952,
+      "thetasym" => 977, "thinsp" => 8201, "THORN" => 222, "thorn" => 254, "tilde" => 732,
+      "times" => 215, "trade" => 8482, "Uacute" => 218, "uacute" => 250, "uArr" => 8657,
+      "uarr" => 8593, "Ucirc" => 219, "ucirc" => 251, "Ugrave" => 217, "ugrave" => 249,
+      "uml" => 168, "upsih" => 978, "Upsilon" => 933, "upsilon" => 965, "Uuml" => 220,
+      "uuml" => 252, "weierp" => 8472, "Xi" => 926, "xi" => 958, "Yacute" => 221, "yacute" => 253,
+      "yen" => 165, "Yuml" => 376, "yuml" => 255, "Zeta" => 918, "zeta" => 950, "zwj" => 8205,
+      "zwnj" => 8204
+    }.freeze
+
+    def decode(text)
+      return text unless text.include?("&")
+
+      text.gsub(PATTERN) do
+        match = Regexp.last_match
+        codepoint =
+          if match[1] then match[1].to_i
+          elsif match[2] then match[2].to_i(16)
+          else NAMED[match[3]]
+          end
+        valid_codepoint?(codepoint) ? codepoint.chr(Encoding::UTF_8) : match[0]
+      end
+    end
+
+    def valid_codepoint?(codepoint)
+      codepoint && codepoint.positive? && codepoint <= 0x10FFFF && !(0xD800..0xDFFF).cover?(codepoint)
+    end
+  end
+end

data/lib/ruby_ui_converter/locals_detector.rb

@@ -104,6 +104,8 @@ module RubyUIConverter
             end
           end
           collect(node.children, codes)
+        when Nodes::Comment
+          collect(node.children, codes)
         end
       end
     end

data/lib/ruby_ui_converter/nodes.rb

@@ -86,12 +86,16 @@ module RubyUIConverter
       end
     end
 
+    # An HTML comment (html: true) or a template-only comment (html: false).
+    # HTML comments may wrap rendered children (HAML's `/` with nested
+    # content), emitted as `comment do ... end`.
     class Comment < Base
-      attr_reader :text, :html
+      attr_reader :text, :html, :children
 
       def initialize(text:, html: false)
         @text = text
         @html = html
+        @children = []
       end
     end
 

data/lib/ruby_ui_converter/parser.rb

@@ -81,7 +81,7 @@ module RubyUIConverter
     def emit_text(text, stack)
       split_parts(text).each do |kind, value|
         if kind == :text
-          append(stack, Nodes::Text.new(content: value)) unless value.empty?
+          append(stack, Nodes::Text.new(content: HtmlEntities.decode(value))) unless value.empty?
         else
           emit_erb(value, stack)
         end
@@ -149,11 +149,17 @@ module RubyUIConverter
         if name.include?("RUCxERBx") && value.nil?
           [:__splat__, split_parts(name)]
         else
-          [name, value.nil? ? nil : split_parts(value)]
+          [name, value.nil? ? nil : decode_text_parts(split_parts(value))]
         end
       end
     end
 
+    # Literal attribute text is HTML: decode its character references
+    # (`title="Tom & Jerry"`) — Phlex re-escapes attribute values.
+    def decode_text_parts(parts)
+      parts.map { |kind, value| kind == :text ? [kind, HtmlEntities.decode(value)] : [kind, value] }
+    end
+
     def split_parts(string)
       parts = []
       pos = 0

data/lib/ruby_ui_converter/ruby_literal.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module RubyUIConverter
+  # Splits a Ruby string literal into its literal text and interpolated code.
+  # Used by the HAML front-end, whose parser hands interpolated text and
+  # attribute values over as Ruby source (`"Hello #{name}!"`), so they can be
+  # turned into the same Text/Output nodes and attribute "parts" the ERB
+  # front-end produces. Lexing is done with Ripper (stdlib), so this has no
+  # dependency on the haml gem.
+  module RubyLiteral
+    module_function
+
+    QUOTES = ['"', "'"].freeze
+
+    # '"Hi #{name}!"' -> [[:text, "Hi "], [:code, "name"], [:text, "!"]]
+    # "'static'"      -> [[:text, "static"]]
+    #
+    # Returns nil unless `code` is exactly one single- or double-quoted string
+    # literal (so `"a" + b`, `"a".upcase`, `:sym`, `%w[]` and heredocs are
+    # rejected), or when an escape sequence can't be decoded safely.
+    def string_parts(code)
+      code = code.to_s.strip
+      return nil unless single_string_literal?(code)
+
+      tokens = Ripper.lex(code)
+      quote = tokens.first[2]
+      return nil unless QUOTES.include?(quote) && tokens.last[1] == :on_tstring_end
+
+      parts = scan_parts(tokens[1...-1], quote)
+      parts && merge_text(parts)
+    rescue StandardError
+      nil
+    end
+
+    def single_string_literal?(code)
+      sexp = Ripper.sexp(code)
+      statements = sexp && sexp[1]
+      statements.is_a?(Array) && statements.length == 1 &&
+        statements[0].is_a?(Array) && statements[0][0] == :string_literal
+    end
+
+    def scan_parts(tokens, quote)
+      parts = []
+      depth = 0
+      buffer = +""
+      embedded_var = false
+
+      tokens.each do |(_, type, tok, _)|
+        if depth.positive?
+          depth += 1 if type == :on_embexpr_beg
+          depth -= 1 if type == :on_embexpr_end
+          depth.zero? ? parts << [:code, buffer.strip] : buffer << tok
+          next
+        end
+
+        case type
+        when :on_tstring_content
+          parts << [:text, unescape(tok, quote)]
+        when :on_embexpr_beg
+          depth = 1
+          buffer = +""
+        when :on_embvar # "#@ivar" / "#$global" shorthand
+          embedded_var = true
+        when :on_ivar, :on_gvar, :on_cvar
+          return nil unless embedded_var
+
+          embedded_var = false
+          parts << [:code, tok]
+        else
+          return nil
+        end
+      end
+
+      depth.zero? ? parts : nil
+    end
+
+    # Decodes the escapes of a literal's raw content. String#undump understands
+    # every escape String#dump emits (which is how haml hands text over) but
+    # rejects raw non-ASCII characters, so those are \u-escaped first.
+    def unescape(content, quote)
+      return content.gsub(/\\([\\'])/, '\1') if quote == "'"
+      return content unless content.include?("\\")
+
+      ascii = content.gsub(/[^\x00-\x7F]/) { |char| format("\\u{%x}", char.ord) }
+      "\"#{ascii}\"".undump.force_encoding(content.encoding)
+    end
+
+    def merge_text(parts)
+      parts.each_with_object([]) do |part, merged|
+        if part[0] == :text && merged.last && merged.last[0] == :text
+          merged.last[1] = merged.last[1] + part[1]
+        elsif part[0] != :text || !part[1].empty?
+          merged << part.dup
+        end
+      end
+    end
+  end
+end

data/lib/ruby_ui_converter/template.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module RubyUIConverter
-  # Represents a single .erb file and knows how to render its .rb equivalent.
+  # Represents a single template file (.erb or .haml) and knows how to render
+  # its .rb equivalent.
   class Template
     attr_reader :path, :root, :config
 
@@ -19,7 +20,12 @@ module RubyUIConverter
       File.basename(path)
     end
 
-    # "index.html.erb" -> "index"; "_form.html.erb" -> "_form"
+    # Source format, from the extension: :erb or :haml.
+    def format
+      RubyUIConverter.format_for(path) || :erb
+    end
+
+    # "index.html.erb" -> "index"; "_form.html.haml" -> "_form"
     def basename
       filename.split(".").first
     end
@@ -67,7 +73,7 @@ module RubyUIConverter
     end
 
     def tree
-      @tree ||= Parser.new(source).parse
+      @tree ||= RubyUIConverter.parse(source, format: format)
     end
 
     def locals