htx 0.0.5 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 637943258561910b726a2956a9c9e683b1fe2180ab80803a484032ba56fb3101
-  data.tar.gz: b4c6faf31037d5a8e0550e2331e6820d21349e9ca80bed18f9a6611a8004de5b
+  metadata.gz: b83c07872c223b61b939883d9f2f6bc45a1cecc380c4b21701d04a606e7ae381
+  data.tar.gz: bfbf43071b20b13be3895bf4e358617765f39f276ed1d37c91c93f09c024b48a
 SHA512:
-  metadata.gz: 82e119f2932d7e96c17a2a336c6bcb88a27759d6657308ac91c4f1e0b6bd4c38000f5e4e45592b2603f6e9f71e6f1d670a4458745b172b157aa429a843d32970
-  data.tar.gz: b2583375f80f0062ea9f5a73df2c72c34b728cf3e2c7b863fc4feb93e18e94aaf81a689d45933bcac3914f71b86ce16865cecec8cca86ef728d8a038c2b15eba
+  metadata.gz: 0dc4f9f8fad2b18266ca93a562fa1565361b330744e8f02134341c1a5982f0821a9b008975adcff7840626d85f05bca223dd433705799c227217584dab1f970c
+  data.tar.gz: 58756df107105643831511c4faff3f7ccdc96fdcd318d7f65833cb642b4c08be60ab2e2f9cc6ffb999a9980a63a8a15a9b0b8b94c0aab8a4f8447ee61909c5a4

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2019-2021 Nate Pickens
+Copyright 2019-2022 Nate Pickens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the Software without restriction, including without

data/README.md

@@ -20,29 +20,24 @@ gem install htx
 
 ## Usage
 
-To compile an HTX template, pass a name (conventionally the path of the template file) and template as
-strings to the `HTX.compile` method:
+To compile an HTX template, pass a name (conventionally the path of the template file) and template content
+as strings to the `HTX.compile` method (all other arguments are optional):
 
 ```ruby
-path = '/my/hot/template.htx'
+path = '/components/crew.htx'
 template = File.read(File.join('some/asset/dir', path))
 
 HTX.compile(path, template)
 
-# Or to attach to a custom object instead of `window`:
+# window['/components/crew.htx'] = function(htx) {
+#   // ...
+# }
+
 HTX.compile(path, template, assign_to: 'myTemplates')
 
-# Result:
-#
-#   window['/my/hot/template.htx'] = function(htx) {
-#     ...
-#   }
-#
-# If `assign_to` is specified:
-#
-#   myTemplates['/components/people.htx'] = function(htx) {
-#     // ...
-#   }
+# myTemplates['/components/crew.htx'] = function(htx) {
+#   // ...
+# }
 ```
 
 ## Contributing

data/VERSION

@@ -0,0 +1 @@
+0.0.8

data/lib/htx/malformed_template_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module HTX
+  ##
+  # Error class used when a problem is encountered processing a template.
+  #
+  class MalformedTemplateError < StandardError
+    ##
+    # Creates a new instance.
+    #
+    # * +message+ - Description of the error.
+    # * +name+ - Name of the template.
+    # * +node+ - Nokogiri node being processed when the error was encountered (optional).
+    #
+    def initialize(message, name, node = nil)
+      if node
+        line = node.line
+        line = node.parent.line if line < 1
+        line = nil if line == -1
+      end
+
+      super("Malformed template #{name}#{":#{line}" if line}: #{message}")
+    end
+  end
+end

data/lib/htx/template.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+require('nokogiri')
+
+module HTX
+  class Template
+    ELEMENT   = 1 << 0
+    CHILDLESS = 1 << 1
+    XMLNS     = 1 << 2
+    FLAG_BITS = 3
+
+    INDENT_DEFAULT = '  '
+    CONTENT_TAG = 'htx-content'
+    DYNAMIC_KEY_ATTR = 'htx-key'
+    DEFAULT_XMLNS = {
+      'math' => 'http://www.w3.org/1998/Math/MathML',
+      'svg' => 'http://www.w3.org/2000/svg',
+    }.freeze
+
+    INDENT_VALID = /^( +|\t+)$/.freeze
+    INDENT_GUESS = /^( +|\t+)(?=\S)/.freeze
+    INDENT_REGEX = /\n(?=[^\n])/.freeze
+
+    NO_SEMICOLON_BEGIN = /\A\s*[\n;}]/.freeze
+    NO_SEMICOLON_END = /(\A|[\n;{}][^\S\n]*)\z/.freeze
+
+    NEWLINE_BEGIN = /\A\s*\n/.freeze
+    NEWLINE_END = /\n[^\S\n]*\z/.freeze
+    NEWLINE_END_OPTIONAL = /\n?[^\S\n]*\z/.freeze
+
+    WHITESPACE_BEGIN = /\A\s/.freeze
+    NON_WHITESPACE = /\S/.freeze
+
+    ##
+    # Returns false. In the near future when support for the <:> tag has been dropped (in favor of
+    # <htx-content>), will return true if Nokogiri's HTML5 parser is available. To use it now, monkey patch
+    # this method to return true.
+    #
+    def self.html5_parser?
+      false # !!defined?(Nokogiri::HTML5)
+    end
+
+    ##
+    # Returns Nokogiri's HTML5 parser if available and enabled, and Nokogiri's regular HTML parser
+    # otherwise.
+    #
+    def self.nokogiri_parser
+      html5_parser? ? Nokogiri::HTML5 : Nokogiri::HTML
+    end
+
+    ##
+    # Creates a new instance.
+    #
+    # * +name+ - Template name. Conventionally the path of the template file.
+    # * +content+ - Template content.
+    #
+    def initialize(name, content)
+      @name = name
+      @content = content
+    end
+
+    ##
+    # Compiles the HTX template.
+    #
+    # * +assign_to+ - JavaScript object to assign the template function to (default: <tt>window</tt>).
+    # * +indent+ - DEPRECATED. Indentation amount (number) or string (must be only spaces or tabs but not
+    #   both) to use for indentation of compiled output (default: indentation of first indented line of
+    #   uncompiled template).
+    #
+    def compile(assign_to: nil, indent: (indent_omitted = true; nil))
+      @assign_to = assign_to || 'window'
+      @indent =
+        if indent.kind_of?(Numeric)
+          ' ' * indent
+        elsif indent && !indent.match?(INDENT_VALID)
+          raise("Invalid indent value #{indent.inspect}: only spaces and tabs (but not both) are allowed")
+        else
+          indent || @content[INDENT_GUESS] || INDENT_DEFAULT
+        end
+
+      warn('The indent: option for HTX template compilation is deprecated.') unless indent_omitted
+
+      @static_key = 0
+      @close_count = 0
+      @whitespace_buff = nil
+      @statement_buff = +''
+      @compiled = +''
+
+      doc = self.class.nokogiri_parser.fragment(@content)
+      preprocess(doc)
+      process(doc)
+
+      @compiled
+    end
+
+    private
+
+    ##
+    # Removes comment nodes and merges any adjoining text nodes that result from such removals.
+    #
+    # * +node+ - Nokogiri node to preprocess.
+    #
+    def preprocess(node)
+      if node.text?
+        if node.parent&.fragment? && node.blank?
+          node.remove
+        elsif (prev_node = node.previous)&.text?
+          prev_node.content += node.content
+          node.remove
+        end
+      elsif node.comment?
+        if node.previous&.text? && node.next&.text? && node.next.content.match?(NEWLINE_BEGIN)
+          content = node.previous.content.sub!(NEWLINE_END_OPTIONAL, '')
+          content.empty? ? node.previous.remove : node.previous.content = content
+        end
+
+        node.remove
+      end
+
+      node.children.each do |child|
+        preprocess(child)
+      end
+
+      if node.fragment?
+        children = node.children
+        root, root2 = children[0..1]
+
+        if (child = children.find(&:text?))
+          raise(MalformedTemplateError.new('text nodes are not allowed at root level', @name, child))
+        elsif !root
+          raise(MalformedTemplateError.new('a root node is required', @name))
+        elsif root2
+          raise(MalformedTemplateError.new("root node already defined on line #{root.line}", @name, root2))
+        end
+      end
+    end
+
+    ##
+    # Processes a DOM node's descendents.
+    #
+    # * +node+ - Nokogiri node to process.
+    #
+    def process(node, xmlns: false)
+      if node.fragment?
+        process_fragment_node(node)
+      elsif node.element?
+        process_element_node(node, xmlns: xmlns)
+      elsif node.text?
+        process_text_node(node)
+      else
+        raise(MalformedTemplateError.new("unrecognized node type #{node.class}", @name, node))
+      end
+    end
+
+    ##
+    # Processes a document fragment node.
+    #
+    # * +node+ - Nokogiri node to process.
+    #
+    def process_fragment_node(node)
+      append("#{@assign_to}['#{@name}'] = function(htx) {")
+      @whitespace_buff = "\n"
+
+      node.children.each do |child|
+        process(child)
+      end
+
+      append("\n}\n",)
+      flush
+    end
+
+    ##
+    # Processes an element node.
+    #
+    # * +node+ - Nokogiri node to process.
+    # * +xmlns+ - True if node is the descendent of a node with an xmlns attribute.
+    #
+    def process_element_node(node, xmlns: false)
+      children = node.children
+      childless = children.empty? || (children.size == 1 && self.class.formatting_node?(children.first))
+      dynamic_key = self.class.attribute_value(node.attr(DYNAMIC_KEY_ATTR))
+      attributes = self.class.process_attributes(node)
+      xmlns ||= !!self.class.namespace(node)
+
+      if self.class.htx_content_node?(node)
+        if node.name != CONTENT_TAG
+          warn("#{@name}:#{node.line}: The <#{node.name}> tag has been deprecated. Use <#{CONTENT_TAG}> "\
+            "for identical functionality.")
+        end
+
+        if attributes.size > 0
+          raise(MalformedTemplateError.new("<#{node.name}> tags may not have attributes other than "\
+            "#{DYNAMIC_KEY_ATTR}", @name, node))
+        elsif (child = children.find { |n| !n.text? })
+          raise(MalformedTemplateError.new("<#{node.name}> tags may not contain child tags", @name, child))
+        end
+
+        process_text_node(
+          children.first || Nokogiri::XML::Text.new('', node.document),
+          dynamic_key: dynamic_key,
+        )
+      else
+        append_htx_node(
+          "'#{self.class.tag_name(node.name)}'",
+          *attributes,
+          dynamic_key,
+          ELEMENT | (childless ? CHILDLESS : 0) | (xmlns ? XMLNS : 0),
+        )
+
+        unless childless
+          children.each do |child|
+            process(child, xmlns: xmlns)
+          end
+
+          @close_count += 1
+        end
+      end
+    end
+
+    ##
+    # Processes a text node.
+    #
+    # * +node+ - Nokogiri node to process.
+    # * +dynamic_key+ - Dynamic key of the parent if it's an <htx-content> node.
+    #
+    def process_text_node(node, dynamic_key: nil)
+      content = node.content
+
+      if node.blank?
+        if !content.include?("\n")
+          append_htx_node("`#{content}`")
+        elsif node.next
+          append(content)
+        else
+          @whitespace_buff = content[NEWLINE_END]
+        end
+      else
+        htx_content_node = self.class.htx_content_node?(node.parent)
+        parser = TextParser.new(content, statement_allowed: !htx_content_node)
+        parser.parse
+
+        append(parser.leading) unless htx_content_node
+
+        if parser.statement?
+          append(indent(parser.content))
+        elsif parser.raw?
+          append_htx_node(indent(parser.content), dynamic_key)
+        else
+          append_htx_node(parser.content, dynamic_key)
+        end
+
+        unless htx_content_node
+          append(parser.trailing)
+          @whitespace_buff = parser.whitespace_buff
+        end
+      end
+    end
+
+    ##
+    # Appends a string to the compiled template function string with appropriate punctuation and/or
+    # whitespace inserted.
+    #
+    # * +text+ - String to append to the compiled template string.
+    #
+    def append(text)
+      return @compiled if text.nil? || text.empty?
+
+      if @close_count > 0
+        close_count = @close_count
+        @close_count = 0
+
+        append("htx.close(#{close_count unless close_count == 1})")
+      end
+
+      if @whitespace_buff
+        @statement_buff << @whitespace_buff
+        @whitespace_buff = nil
+        confirmed_newline = true
+      end
+
+      if (confirmed_newline || @statement_buff.match?(NEWLINE_END)) && !text.match?(NEWLINE_BEGIN)
+        @statement_buff << @indent
+      elsif !@statement_buff.match?(NO_SEMICOLON_END) && !text.match?(NO_SEMICOLON_BEGIN)
+        @statement_buff << ";#{' ' unless text.match?(WHITESPACE_BEGIN)}"
+      end
+
+      flush if text.match?(NON_WHITESPACE)
+      @statement_buff << text
+
+      @compiled
+    end
+
+    ##
+    # Appends an +htx.node+ call to the compiled template function string.
+    #
+    # * +args+ - Arguments to use for the +htx.node+ call (any +nil+ ones are removed).
+    #
+    def append_htx_node(*args)
+      return if args.first.nil?
+
+      args.compact!
+      args << 0 unless args.last.kind_of?(Integer)
+      args[-1] |= (@static_key += 1) << FLAG_BITS
+
+      append("htx.node(#{args.join(', ')})")
+    end
+
+    ##
+    # Flushes statement buffer.
+    #
+    def flush
+      @compiled << @statement_buff
+      @statement_buff.clear
+
+      @compiled
+    end
+
+    ##
+    # Indents each line of a string (except the first).
+    #
+    # * +text+ - String of lines to indent.
+    #
+    def indent(text)
+      text.gsub!(INDENT_REGEX, "\\0#{@indent}")
+      text
+    end
+
+    ##
+    # Returns true if the node is whitespace containing at least one newline.
+    #
+    # * +node+ - Nokogiri node to check.
+    #
+    def self.formatting_node?(node)
+      node.blank? && node.content.include?("\n")
+    end
+
+    ##
+    # Returns true if the node is an <htx-content> node (or one of its now-deprecated names).
+    #
+    # * +node+ - Nokogiri node to check.
+    #
+    def self.htx_content_node?(node)
+      node && (node.name == CONTENT_TAG || node.name == 'htx-text' || node.name == ':')
+    end
+
+    ##
+    # Processes a node's attributes returning a flat array of attribute names and values.
+    #
+    # * +node+ - Nokogiri node to process the attributes of.
+    #
+    def self.process_attributes(node)
+      attributes = []
+
+      if !node.attribute('xmlns') && (xmlns = namespace(node))
+        attributes.push(
+          attribute_name('xmlns'),
+          attribute_value(xmlns)
+        )
+      end
+
+      node.attribute_nodes.each.with_object(attributes) do |attribute, attributes|
+        next if attribute.node_name == DYNAMIC_KEY_ATTR
+
+        attributes.push(
+          attribute_name(attribute.node_name),
+          attribute_value(attribute.value)
+        )
+      end
+    end
+
+    ##
+    #
+    #
+    def self.namespace(node)
+      node.namespace&.href || DEFAULT_XMLNS[node.name]
+    end
+
+    ##
+    # Returns the given text if the HTML5 parser is in use, or looks up the value in the tag map to get the
+    # correctly-cased version, falling back to the supplied text if no mapping exists.
+    #
+    # * +text+ - Tag name as returned by Nokogiri.
+    #
+    def self.tag_name(text)
+      html5_parser? ? text : (TAG_MAP[text] || text)
+    end
+
+    ##
+    # Returns the given text if the HTML5 parser is in use, or looks up the value in the attribute map to
+    # get the correctly-cased version, falling back to the supplied text if no mapping exists.
+    #
+    # * +text+ - Attribute name as returned by Nokogiri.
+    #
+    def self.attribute_name(text)
+      "'#{html5_parser? ? text : (ATTR_MAP[text] || text)}'"
+    end
+
+    ##
+    # Returns the processed value of an attribute.
+    #
+    # * +text+ - Attribute value as returned by Nokogiri.
+    #
+    def self.attribute_value(text)
+      text ? TextParser.new(text, statement_allowed: false).parse : nil
+    end
+
+    # The Nokogiri HTML parser downcases all tag and attribute names, but SVG tags and attributes are case
+    # sensitive and often mix cased. These maps are used to restore the correct case of such tags and
+    # attributes.
+    #
+    # Note: Nokogiri's newer HTML5 parser resulting from the Nokogumbo merge fixes this issue, but it is
+    # currently not available for JRuby. It also does not parse <:> as a tag, which is why it's been
+    # deprecated in favor of <htx-content>. Once support for <:> has been completely removed, the HTML5
+    # parser will be used for regular Ruby and this tag and attribute mapping hack reserved for JRuby (and
+    # any other potential environments where the HTML5 parser is not available).
+
+    # Source: https://developer.mozilla.org/en-US/docs/Web/SVG/Element
+    TAG_MAP = %w[
+      animateMotion animateTransform clipPath feBlend feColorMatrix feComponentTransfer feComposite
+      feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight feDropShadow feFlood feFuncA
+      feFuncB feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode feMorphology feOffset fePointLight
+      feSpecularLighting feSpotLight feTile feTurbulence foreignObject linearGradient radialGradient
+      textPath
+    ].map { |tag| [tag.downcase, tag] }.to_h.freeze
+
+    # Source: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute
+    ATTR_MAP = %w[
+      attributeName attributeType baseFrequency baseProfile calcMode clipPathUnits contentScriptType
+      contentStyleType diffuseConstant edgeMode filterRes filterUnits glyphRef gradientTransform
+      gradientUnits kernelMatrix kernelUnitLength keyPoints keySplines keyTimes lengthAdjust
+      limitingConeAngle markerHeight markerUnits markerWidth maskContentUnits maskUnits numOctaves
+      pathLength patternContentUnits patternTransform patternUnits pointsAtX pointsAtY pointsAtZ
+      preserveAlpha preserveAspectRatio primitiveUnits refX refY referrerPolicy repeatCount repeatDur
+      requiredExtensions requiredFeatures specularConstant specularExponent spreadMethod startOffset
+      stdDeviation stitchTiles surfaceScale systemLanguage tableValues targetX targetY textLength viewBox
+      viewTarget xChannelSelector yChannelSelector zoomAndPan
+    ].map { |attr| [attr.downcase, attr] }.to_h.freeze
+  end
+end

data/lib/htx/text_parser.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require('strscan')
+
+module HTX
+  class TextParser
+    LEADING = /\A((?:[^\S\n]*\n)+)?((?:[^\S\n])+)?(?=\S)/.freeze
+    TRAILING = /([\S\s]*?)(\s*?)(\n[^\S\n]*)?\z/.freeze
+
+    NOT_ESCAPED = /(?<=^|[^\\])(?:\\\\)*/.freeze
+    OF_INTEREST = /#{NOT_ESCAPED}(?<chars>[`'"]|\${)|(?<chars>{|}|\/\/|\/\*|\*\/|\n[^\S\n]*(?=\S))/.freeze
+    TERMINATOR = {
+      '\'' => '\'',
+      '"' => '"',
+      '//' => "\n",
+      '/*' => '*/',
+    }.freeze
+
+    TEXT = /\S|\A[^\S\n]+\z/.freeze
+    IDENTIFIER = /[_$a-zA-Z][_$a-zA-Z0-9]*/.freeze
+    ASSIGNMENT = /\s*(\+|&|\||\^|\/|\*\*|<<|&&|\?\?|\|\||\*|%|-|>>>)?=/.freeze
+    STATEMENT = /[{}]|(^|\s)#{IDENTIFIER}(\.#{IDENTIFIER})*(#{ASSIGNMENT}|\+\+|--|\[|\()/.freeze
+
+    attr_reader(:type, :content, :leading, :trailing, :whitespace_buff)
+
+    ##
+    # Creates a new instance.
+    #
+    # * +text+ - Text to parse.
+    # * +statement_allowed+ - True if statements are allowed; false if text is always a template or raw (
+    #   single interpolation).
+    #
+    def initialize(text, statement_allowed:)
+      @text = text
+      @statement_allowed = statement_allowed
+    end
+
+    ##
+    # Returns true if parsed text is a statement.
+    #
+    def statement?
+      @type == :statement
+    end
+
+    ##
+    # Returns true if parsed text is a single interpolation.
+    #
+    def raw?
+      @type == :raw
+    end
+
+    ##
+    # Returns true if parsed text is a template.
+    #
+    def template?
+      @type == :template
+    end
+
+    ##
+    # Parses text.
+    #
+    def parse
+      @type = nil
+      @content = +''
+
+      @first_indent = nil
+      @min_indent = nil
+      @last_indent = nil
+
+      @buffer = +''
+      @stack = []
+      curlies = []
+      ignore_end = nil
+
+      @has_text = false
+      @is_statement = false
+      @template_count = 0
+      @interpolation_count = 0
+
+      scanner = StringScanner.new(@text)
+
+      scanner.scan(LEADING)
+      @leading_newlines = scanner[1]
+      @leading_indent = @first_indent = scanner[2]
+      @leading = scanner[0] if @leading_newlines || @leading_indent
+
+      until scanner.eos?
+        if (scanned = scanner.scan_until(OF_INTEREST))
+          ignore = @stack.last == :ignore
+          template = @stack.last == :template
+          interpolation = @stack.last == :interpolation
+          can_ignore = (@stack.empty? && @statement_allowed) || interpolation
+          can_template = @stack.empty? || interpolation
+          can_interpolate = @stack.empty? || template
+
+          chars = scanner[:chars]
+          @buffer << scanned.chomp!(chars)
+
+          if chars[0] == "\n"
+            indent = chars.delete_prefix("\n")
+
+            if !@last_indent
+              @last_indent = indent
+            else
+              @min_indent = @last_indent if !@min_indent || @last_indent.size < @min_indent.size
+              @last_indent = indent
+            end
+          end
+
+          if can_ignore && (ignore_end = TERMINATOR[chars])
+            push_state(:ignore)
+            @buffer << chars
+          elsif ignore && chars == ignore_end
+            @buffer << chars
+            pop_state
+            ignore_end = nil
+          elsif can_template && chars == '`'
+            push_state(:template)
+            @buffer << chars
+          elsif template && chars == '`'
+            @buffer << chars
+            pop_state
+          elsif can_interpolate && chars == '${'
+            push_state(:interpolation)
+            curlies << 1
+            @buffer << chars
+          elsif interpolation && (curlies[-1] += (chars == '{' && 1) || (chars == '}' && -1) || 0) == 0
+            @buffer << chars
+            curlies.pop
+            pop_state
+          else
+            @buffer << chars
+          end
+        else
+          scanner.scan(TRAILING)
+
+          @buffer << scanner[1]
+          @trailing = scanner[2] == '' ? nil : scanner[2]
+          @whitespace_buff = scanner[3]
+        end
+      end
+
+      flush(@stack.last)
+      finalize
+
+      @content
+    end
+
+    private
+
+    ##
+    # Determines type (statement, raw, or template) and adjust formatting accordingly. Called at the end of
+    # parsing.
+    #
+    def finalize
+      if @is_statement
+        @type = :statement
+        @content.insert(0, @leading) && @leading = nil if @leading
+        @content.insert(-1, @trailing) && @trailing = nil if @trailing
+      elsif !@has_text && @template_count == 0 && @interpolation_count == 1
+        @type = :raw
+        @content.delete_prefix!('${')
+        @content.delete_suffix!('}')
+
+        if @content.empty?
+          @type = :template
+          @content = '``'
+        end
+      else
+        @type = :template
+
+        if !@has_text && @template_count == 1 && @interpolation_count == 0
+          @quoted = true
+          @outdent = @min_indent
+          @content.delete_prefix!('`')
+          @content.delete_suffix!('`')
+        else
+          @outdent = [@first_indent, @min_indent, @last_indent].compact.min
+        end
+
+        @content.gsub!(/(?<=\n)([^\S\n]+$|#{@outdent})/, '') if @outdent && !@outdent.empty?
+
+        unless @quoted
+          @content.insert(0, @leading) && @leading = nil if @leading && !@leading_newlines
+          @content.insert(-1, @trailing) && @trailing = nil if @trailing && !@trailing.include?("\n")
+        end
+
+        @content.insert(0, '`').insert(-1, '`')
+      end
+    end
+
+    ##
+    # Pushes a state onto the stack during parsing.
+    #
+    # * +state+ - State to push onto the stack.
+    #
+    def push_state(state)
+      flush if @stack.empty?
+      @stack << state
+    end
+
+    ##
+    # Pops a state from the stack during parsing.
+    #
+    def pop_state
+      state = @stack.pop
+
+      if @stack.empty?
+        flush(state)
+
+        @interpolation_count += 1 if state == :interpolation
+        @template_count += 1 if state == :template
+      end
+    end
+
+    ##
+    # Flushes buffer during parsing and performs statement detection if appropriate.
+    #
+    def flush(state = nil)
+      return if @buffer.empty?
+
+      if !state || state == :text
+        @has_text ||= @buffer.match?(TEXT)
+        @is_statement ||= @buffer.match?(STATEMENT) if @statement_allowed
+      end
+
+      @content << @buffer
+      @buffer.clear
+    end
+  end
+end

data/lib/htx/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HTX
+  VERSION = '0.0.8'
+end

data/lib/htx.rb

@@ -1,256 +1,38 @@
 # frozen_string_literal: true
 
-require('nokogiri')
+require('htx/malformed_template_error')
+require('htx/template')
+require('htx/text_parser')
+require('htx/version')
 
 ##
 # A Ruby compiler for HTX templates.
 #
-class HTX
-  VERSION = '0.0.5'
-
-  CHILDLESS = 0b01
-  TEXT_NODE = 0b10
-  FLAG_BITS = 2
-
-  INDENT_DEFAULT = '  '
-  DYNAMIC_KEY_ATTR = 'htx-key'
-
-  LEADING_WHITESPACE = /\A[ \t]*\n[ \t]*/.freeze
-  TRAILING_WHITESPACE = /\n[ \t]*\z/.freeze
-  NON_BLANK_NON_FIRST_LINE = /(?<=\n)[ \t]*(?=\S)/.freeze
-  NEWLINE_NON_BLANK = /\n(?=[^\n])/.freeze
-  INDENT_GUESS = /^[ \t]+/.freeze
-
-  END_STATEMENT_END = /(;|\n|\{|\})[ \t]*\z/.freeze
-  BEGIN_STATEMENT_END = /\A[ \t]*(;|\{|\n|\})/.freeze
-  END_WHITESPACE = /\s\z/.freeze
-  BEGIN_WHITESPACE = /\A\s/.freeze
-
-  RAW_VALUE = /\A\s*\${([\S\s]*)}\s*\z/.freeze
-  TEMPLATE_STRING = /\A\s*`([\S\s]*)`\s*\z/.freeze
-  INTERPOLATION = /\$\\?{([^}]*})?/.freeze
-  HTML_ENTITY = /&([a-zA-Z]+|#\d+|x[0-9a-fA-F]+);/.freeze
-  NON_CONTROL_STATEMENT = /#{INTERPOLATION}|(#{HTML_ENTITY})/.freeze
-  CONTROL_STATEMENT = /[{}();]/.freeze
-  CLOSE_STATEMENT = /;?\s*htx\.close\((\d*)\);?(\s*)\z/.freeze
-
+module HTX
   EMPTY_HASH = {}.freeze
 
   ##
-  # Convenience method to create a new instance and immediately call compile on it.
-  #
-  def self.compile(name, template, options = EMPTY_HASH)
-    new(name, template).compile(options)
-  end
-
-  ##
-  # Creates a new HTX instance. Conventionally the path of the template file is used for the name, but it
-  # can be anything.
-  #
-  def initialize(name, template)
-    @name = name
-    @template = template
-  end
-
-  ##
-  # Compiles the HTX template. Options:
-  #
-  # * :indent - Indent output by this number of spaces if Numeric, or by this string if a String (if the
-  #     latter, may only contain space and tab characters).
-  # * :assign_to - Assign the template function to this JavaScript object instead of the `window` object.
-  #
-  def compile(options = EMPTY_HASH)
-    doc = Nokogiri::HTML::DocumentFragment.parse(@template)
-    root_nodes = doc.children.select { |n| n.element? || (n.text? && n.text.strip != '') }
-
-    if (text_node = root_nodes.find(&:text?))
-      raise(MalformedTemplateError.new('text nodes are not allowed at root level', @name, text_node))
-    elsif root_nodes.size == 0
-      raise(MalformedTemplateError.new('a root node is required', @name))
-    elsif root_nodes.size > 1
-      raise(MalformedTemplateError.new("root node already defined on line #{root_nodes[0].line}", @name,
-          root_nodes[1]))
-    end
-
-    @compiled = ''.dup
-    @static_key = 0
-
-    @indent =
-      if options[:indent].kind_of?(Numeric)
-        ' ' * options[:indent]
-      elsif options[:indent].kind_of?(String) && options[:indent] !~ /^[ \t]+$/
-        raise("Invalid :indent value #{options[:indent].inspect}: only spaces and tabs are allowed")
-      else
-        options[:indent] || @template[INDENT_GUESS] || INDENT_DEFAULT
-      end
-
-    process(doc)
-    @compiled.rstrip!
-
-    <<~EOS
-      #{options[:assign_to] || 'window'}['#{@name}'] = function(htx) {
-      #{@indent}#{@compiled}
-      }
-    EOS
-  end
-
-  private
-
-  ##
-  # Processes a DOM node's descendents.
+  # Convenience method to create a new Template instance and compile it.
   #
-  def process(base)
-    base.children.each do |node|
-      next unless node.element? || node.text?
-
-      dynamic_key = process_value(node.attr(DYNAMIC_KEY_ATTR), :attr)
-
-      if node.text? || node.name == ':'
-        if (non_text_node = node.children.find { |n| !n.text? })
-          raise(MalformedTemplateError.new('dummy tags may not contain child tags', @name, non_text_node))
-        end
-
-        text = (node.text? ? node : node.children).text
-
-        if (value = process_value(text))
-          append(
-            "#{indent(text[LEADING_WHITESPACE])}"\
-            "htx.node(#{[
-              value,
-              dynamic_key,
-              ((@static_key += 1) << FLAG_BITS) | TEXT_NODE,
-            ].compact.join(', ')})"\
-            "#{indent(text[TRAILING_WHITESPACE])}"
-          )
-        else
-          append(indent(text))
-        end
-      else
-        attrs = node.attributes.inject([]) do |attrs, (_, attr)|
-          next attrs if attr.name == DYNAMIC_KEY_ATTR
-
-          attrs << "'#{ATTR_MAP[attr.name] || attr.name}'"
-          attrs << process_value(attr.value, :attr)
-        end
-
-        childless = node.children.empty? || (node.children.size == 1 && node.children[0].text.strip == '')
-
-        append("htx.node(#{[
-          "'#{TAG_MAP[node.name] || node.name}'",
-          attrs,
-          dynamic_key,
-          ((@static_key += 1) << FLAG_BITS) | (childless ? CHILDLESS : 0),
-        ].compact.flatten.join(', ')})")
-
-        unless childless
-          process(node)
-
-          count = ''
-          @compiled.sub!(CLOSE_STATEMENT) do
-            count = $1 == '' ? 2 : $1.to_i + 1
-            $2
-          end
-
-          append("htx.close(#{count})")
-        end
-      end
-    end
-  end
-
-  ##
-  # Appends a string to the compiled template function string with appropriate punctuation and/or whitespace
-  # inserted.
+  # * +name+ - Template name. Conventionally the path of the template file.
+  # * +content+ - Template content.
+  # * +options+ - Options to be passed to Template#compile.
   #
-  def append(text)
-    if @compiled == ''
-      # Do nothing.
-    elsif @compiled !~ END_STATEMENT_END && text !~ BEGIN_STATEMENT_END
-      @compiled << '; '
-    elsif @compiled !~ END_WHITESPACE && text !~ BEGIN_WHITESPACE
-      @compiled << ' '
-    elsif @compiled[-1] == "\n"
-      @compiled << @indent
-    end
-
-    @compiled << text
+  def self.compile(name, content, options = EMPTY_HASH)
+    Template.new(name, content).compile(**options)
   end
 
   ##
-  # Indents each line of a string (except the first).
+  # DEPRECATED. Use HTX::Template.new instead. HTX was formerly a class that would be instantiated for
+  # compilation. This method allows HTX.new calls to continue working (but support will be removed in the
+  # near future).
   #
-  def indent(text)
-    return '' unless text
-
-    text.gsub!(NEWLINE_NON_BLANK, "\n#{@indent}")
-    text
-  end
-
-  ##
-  # Processes, formats, and encodes an attribute or text node value. Returns nil if the value is determined
-  # to be a control statement.
+  # * +name+ - Template name. Conventionally the path of the template file.
+  # * +content+ - Template content.
   #
-  def process_value(text, is_attr = false)
-    return nil if text.nil? || (!is_attr && text.strip == '')
-
-    if (value = text[RAW_VALUE, 1])
-      # Entire text is enclosed in ${...}.
-      value.strip!
-      quote = false
-    elsif (value = text[TEMPLATE_STRING, 1])
-      # Entire text is enclosed in backticks (template string).
-      quote = true
-    elsif is_attr || text.gsub(NON_CONTROL_STATEMENT, '') !~ CONTROL_STATEMENT
-      # Text is an attribute value or doesn't match control statement pattern.
-      value = text.dup
-      quote = true
-    else
-      return nil
-    end
+  def self.new(name, content)
+    warn('HTX.new is deprecated. Please use HTX::Template.new instead.')
 
-    # Strip one leading and trailing newline (and attached spaces) and perform outdent. Outdent amount
-    # calculation ignores everything before the first newline in its search for the least-indented line.
-    outdent = value.scan(NON_BLANK_NON_FIRST_LINE).min
-    value.gsub!(/#{LEADING_WHITESPACE}|#{TRAILING_WHITESPACE}|^#{outdent}/, '')
-    value.insert(0, '`').insert(-1, '`') if quote
-
-    # Ensure any Unicode characters get converted to Unicode escape sequences. Also note that since Nokogiri
-    # converts HTML entities to Unicode characters, this causes them to be properly passed to
-    # `document.createTextNode` calls as Unicode escape sequences rather than (incorrectly) as HTML
-    # entities.
-    value.encode('ascii', fallback: ->(c) { "\\u#{c.ord.to_s(16).rjust(4, '0')}" })
-  end
-
-  class MalformedTemplateError < StandardError
-    def initialize(message, name, node = nil)
-      if node
-        line = node.line
-        line = node.parent.line if line < 1
-        line = nil if line == -1
-      end
-
-      super("Malformed template #{name}#{":#{line}" if line}: #{message}")
-    end
+    Template.new(name, content)
   end
-
-  # The Nokogiri HTML parser downcases all tag and attribute names, but SVG tags and attributes are case
-  # sensitive and often mix cased. These maps are used to restore the correct case of such tags and
-  # attributes.
-  TAG_MAP = %w[
-    animateMotion animateTransform clipPath feBlend feColorMatrix feComponentTransfer feComposite
-    feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight feDropShadow feFlood feFuncA feFuncB
-    feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode feMorphology feOffset fePointLight
-    feSpecularLighting feSpotLight feTile feTurbulence foreignObject linearGradient radialGradient textPath
-  ].map { |tag| [tag.downcase, tag] }.to_h.freeze
-
-  ATTR_MAP = %w[
-    allowReorder attributeName attributeType autoReverse baseFrequency baseProfile calcMode clipPathUnits
-    contentScriptType contentStyleType diffuseConstant edgeMode externalResourcesRequired filterRes
-    filterUnits glyphRef gradientTransform gradientUnits kernelMatrix kernelUnitLength keyPoints keySplines
-    keyTimes lengthAdjust limitingConeAngle markerHeight markerUnits markerWidth maskContentUnits maskUnits
-    numOctaves pathLength patternContentUnits patternTransform patternUnits pointsAtX pointsAtY pointsAtZ
-    preserveAlpha preserveAspectRatio primitiveUnits refX refY referrerPolicy repeatCount repeatDur
-    requiredExtensions requiredFeatures specularConstant specularExponent spreadMethod startOffset
-    stdDeviation stitchTiles surfaceScale systemLanguage tableValues targetX targetY textLength viewBox
-    viewTarget xChannelSelector yChannelSelector zoomAndPan
-  ].map { |attr| [attr.downcase, attr] }.to_h.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: htx
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.8
 platform: ruby
 authors:
 - Nate Pickens
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-05 00:00:00.000000000 Z
+date: 2022-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '1.13'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -68,7 +68,12 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- VERSION
 - lib/htx.rb
+- lib/htx/malformed_template_error.rb
+- lib/htx/template.rb
+- lib/htx/text_parser.rb
+- lib/htx/version.rb
 homepage: https://github.com/npickens/htx
 licenses:
 - MIT
@@ -84,14 +89,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.8
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: A Ruby compiler for HTX templates.