htx 0.0.6 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bb09e36ecc0e6a70df4fed4552ae20a9512eadd3ac57d86bd88fa278c8d6029
-  data.tar.gz: e45e67362bc5422faa7df5330c5bd4940d4973c8ab0303cdd8207f0d7149efed
+  metadata.gz: 395620b3af20b4da17e4413632418481ee28d6d0fe6b46427af240475087efce
+  data.tar.gz: bc15b61294daaf218b3a3d5a106de7c9279a7d9e8cb7ebd01002fcd618491b1f
 SHA512:
-  metadata.gz: 9eaea052f3b131de348f9ad20de712d55e180820d184a54356935aeacc3f2a7116266f2a4a6ff6e725ca44052a6c15350debcacd250b0f60be5ed0bb586aca26
-  data.tar.gz: f0f3ca8fd975d7bbf3b8d26c65d62cda86caaf245dd8143be571a5a9b28088e2274fb89a04a5fba9c567ef549f1d9d5dbaad8fcbc9db1ee346f395cd863097df
+  metadata.gz: 83805b10f30d1846a187b458579a0748339a3956a4123226b7b9ebdb6dcff6cae3dbcd94913c1bbab2c91186ef3f46642f30a4ed9c3f30b072b3efe2f2ceb1ca
+  data.tar.gz: 26e48419a9a719f1b8b582ef9e525ffcc37affdcb279f0cba95c6fe4cd2108cc6ec66e9ba4d3216a0ef02aad506d56c4743b059916ba78409f0dc672a760a1fc

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

@@ -1 +1 @@
-0.0.6
+0.0.9

data/lib/htx/template.rb

@@ -4,42 +4,36 @@ require('nokogiri')
 
 module HTX
   class Template
-    CHILDLESS  = 0b001
-    TEXT_NODE  = 0b010
-    XMLNS_NODE = 0b100
-    FLAG_BITS  = 3
+    ELEMENT   = 1 << 0
+    CHILDLESS = 1 << 1
+    XMLNS     = 1 << 2
+    FLAG_BITS = 3
 
     INDENT_DEFAULT = '  '
-    TEXT_NODE_TAG = 'htx-text'
+    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
 
-    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
+    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-text>), will return true if Nokogiri's HTML5 parser is available. To use it now, monkey patch
+    # <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?
@@ -51,15 +45,14 @@ module HTX
     # otherwise.
     #
     def self.nokogiri_parser
-      html5_parser? ? Nokogiri::HTML5::DocumentFragment : Nokogiri::HTML::DocumentFragment
+      html5_parser? ? Nokogiri::HTML5 : Nokogiri::HTML
     end
 
     ##
-    # Creates a new HTX instance.
+    # Creates a new instance.
     #
-    # * +name+ - Name of the template. Conventionally the path of the template file is used for the name,
-    #   but it can be anything.
-    # * +content+ - Template content string.
+    # * +name+ - Template name. Conventionally the path of the template file.
+    # * +content+ - Template content.
     #
     def initialize(name, content)
       @name = name
@@ -69,107 +62,196 @@ module HTX
     ##
     # Compiles the HTX template.
     #
-    # * +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 <tt>window</tt>
-    #   object.
-    #
-    def compile(indent: nil, assign_to: 'window')
-      doc = self.class.nokogiri_parser.parse(@content)
-      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
-
+    # * +assign_to+ - JavaScript object to assign the template function to (default: +window+).
+    # * +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.kind_of?(String) && indent !~ /^[ \t]+$/
-          raise("Invalid indent value #{indent.inspect}: only spaces and tabs are allowed")
+        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.rstrip!
 
-      <<~EOS
-        #{assign_to}['#{@name}'] = function(htx) {
-        #{@indent}#{@compiled}
-        }
-      EOS
+      @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.
     #
-    # * +base+ - Base Nokogiri node to start from.
+    # * +node+ - Nokogiri node to process.
     #
-    def process(base)
-      base.children.each do |node|
-        next unless node.element? || node.text?
+    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
 
-        dynamic_key = process_value(node.attr(DYNAMIC_KEY_ATTR), :attr)
+    ##
+    # Processes a document fragment node.
+    #
+    # * +node+ - Nokogiri node to process.
+    #
+    def process_fragment_node(node)
+      append("#{@assign_to}['#{@name}'] = function(htx) {")
+      @whitespace_buff = "\n"
 
-        if node.text? || node.name == TEXT_NODE_TAG || node.name == ':'
-          if node.name == ':'
-            warn("#{@name}:#{node.line}: The <:> tag has been deprecated. Please use <#{TEXT_NODE_TAG}> "\
-              'for identical functionality.')
-          end
+      node.children.each do |child|
+        process(child)
+      end
 
-          if (non_text_node = node.children.find { |n| !n.text? })
-            raise(MalformedTemplateError.new('text node tags may not contain child tags', @name,
-              non_text_node))
-          end
+      append("\n}\n",)
+      flush
+    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))
+    ##
+    # Processes an element node.
+    #
+    # * +node+ - Nokogiri node to process.
+    # * +xmlns+ - True if node is the descendant 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
-          childless = node.children.empty? || (node.children.size == 1 && node.children[0].text.strip == '')
-          attrs, xmlns = process_attrs(node)
-
-          append("htx.node(#{[
-            "'#{tag_name(node.name)}'",
-            attrs,
-            dynamic_key,
-            ((@static_key += 1) << FLAG_BITS) | (childless ? CHILDLESS : 0) | (xmlns ? XMLNS_NODE : 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
+          @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
@@ -181,17 +263,52 @@ module HTX
     # * +text+ - String to append to the compiled template string.
     #
     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
+      return 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
 
-      @compiled << text
+      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
+    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
     end
 
     ##
@@ -200,98 +317,89 @@ module HTX
     # * +text+ - String of lines to indent.
     #
     def indent(text)
-      return '' unless text
-
-      text.gsub!(NEWLINE_NON_BLANK, "\n#{@indent}")
+      text.gsub!(INDENT_REGEX, "\\0#{@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.
-    #
-    # * +text+ - String to process.
-    # * +is_attr+ - Truthy if the text is an attribute value.
-    #
-    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
-
-      # 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')}" })
+    # 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
 
     ##
-    # Processes a node's attributes, returning two items: a flat array of attribute names and values, and a
-    # boolean indicating whether or not an xmlns attribute is present.
+    # Returns true if the node is an <htx-content> node (or one of its now-deprecated names).
     #
-    # Note: if the node is a <math> or <svg> tag without an explicit xmlns attribute set, an appropriate one
-    # will be automatically added since it is required for those elements to render properly.
+    # * +node+ - Nokogiri node to check.
     #
-    # * +node+ - Nokogiri node to process for attributes.
-    #
-    def process_attrs(node)
-      attrs = []
-      xmlns = !!node.attributes['xmlns']
-
-      if !xmlns && DEFAULT_XMLNS[node.name]
-        xmlns = true
+    def self.htx_content_node?(node)
+      node && (node.name == CONTENT_TAG || node.name == 'htx-text' || node.name == ':')
+    end
 
-        attrs << "'xmlns'"
-        attrs << process_value(DEFAULT_XMLNS[node.name], :attr)
+    ##
+    # 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.attributes.each do |_, attr|
-        next if attr.name == DYNAMIC_KEY_ATTR
+      node.attribute_nodes.each.with_object(attributes) do |attribute, attributes|
+        next if attribute.node_name == DYNAMIC_KEY_ATTR
 
-        attrs << "'#{attr_name(attr.name)}'"
-        attrs << process_value(attr.value, :attr)
+        attributes.push(
+          attribute_name(attribute.node_name),
+          attribute_value(attribute.value)
+        )
       end
+    end
 
-      [attrs, xmlns]
+    ##
+    # Returns namespace URL of a Nokogiri node.
+    #
+    # * +node+ - Nokogiri node to get the namespace of.
+    #
+    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 parser.
+    # * +text+ - Tag name as returned by Nokogiri.
     #
-    def tag_name(text)
-      self.class.html5_parser? ? text : (TAG_MAP[text] || text)
+    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 parser.
+    # * +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 attr_name(text)
-      self.class.html5_parser? ? text : (ATTR_MAP[text] || text)
+    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
@@ -300,9 +408,9 @@ module HTX
     #
     # 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-text>. 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).
+    # 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[

data/lib/htx/text_parser.rb

@@ -0,0 +1,233 @@
+# 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.
+    #
+    # * +state+ - Last state that was parsed.
+    #
+    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

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

data/lib/htx.rb

@@ -2,6 +2,7 @@
 
 require('htx/malformed_template_error')
 require('htx/template')
+require('htx/text_parser')
 require('htx/version')
 
 ##
@@ -13,8 +14,12 @@ module HTX
   ##
   # Convenience method to create a new Template instance and compile it.
   #
-  def self.compile(name, template, options = EMPTY_HASH)
-    Template.new(name, template).compile(**options)
+  # * +name+ - Template name. Conventionally the path of the template file.
+  # * +content+ - Template content.
+  # * +options+ - Options to be passed to Template#compile.
+  #
+  def self.compile(name, content, options = EMPTY_HASH)
+    Template.new(name, content).compile(**options)
   end
 
   ##
@@ -22,9 +27,8 @@ module HTX
   # compilation. This method allows HTX.new calls to continue working (but support will be removed in the
   # near future).
   #
-  # * +name+ - Name of the template. Conventionally the path of the template file is used for the name,
-  #   but it can be anything.
-  # * +content+ - Template content string.
+  # * +name+ - Template name. Conventionally the path of the template file.
+  # * +content+ - Template content.
   #
   def self.new(name, content)
     warn('HTX.new is deprecated. Please use HTX::Template.new instead.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: htx
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.9
 platform: ruby
 authors:
 - Nate Pickens
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -72,6 +72,7 @@ files:
 - 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: