htx 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 94e1883a59d09cce6170061c9e0602a3430da8ca800163ba2fe8cc9d10b316b4
+  data.tar.gz: a26e6aa3a874e40569cd62204aa698a6bdec5b02a78dc35ea993d0a11ff8f0f2
+SHA512:
+  metadata.gz: 004dca83de5a65ba167eb345d21a1a8c1d771efbe946fc746cfb470d4ca783bad57830ced8ba6f1a7ce47e9e04abc3ee06a6ebf02fc9d5a0eee2892983dbf136
+  data.tar.gz: ab814533c1f9ead9fa8daa2ef46959a2a8893c21e3705ee9863fbcaeed90ec0e70f835d36420fe1ade8c1a0bf9c33478987e76d07cbb20c154a4da26d3ef7492

data/LICENSE

@@ -0,0 +1,16 @@
+Copyright 2019 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
+limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# HTX Ruby Compiler
+
+HTX templates are compiled to JavaScript before being used. This library provides a Ruby implementation of
+the compiler. For more information on HTX, see
+[https://github.com/npickens/htx](https://github.com/npickens/htx).
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem('htx')
+```
+
+Or install manually on the command line:
+
+```bash
+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:
+
+```ruby
+path = '/my/hot/template.htx'
+template = File.read(File.join('some/asset/dir', path))
+
+HTX.compile(path, template)
+
+# Result:
+#
+#   window['/my/hot/template.htx'] = function(htx) {
+#     ...
+#   }
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/npickens/htx.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/lib/htx.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require('nokogiri')
+
+##
+# A Ruby compiler for HTX templates.
+#
+class HTX
+  VERSION = '0.0.1'
+
+  CHILDLESS = 0b01
+  TEXT_NODE = 0b10
+  FLAG_BITS = 2
+
+  DYNAMIC_KEY_ATTR = 'htx-key'
+
+  LEADING_WHITESPACE = /\A *\n */.freeze
+  TRAILING_WHITESPACE = /\n *\z/.freeze
+  NON_BLANK_NON_FIRST_LINE = /(?<=\n) *(?=\S)/.freeze
+  NEWLINE_NON_BLANK = /\n(?=[^\n]+)/.freeze
+
+  END_STATEMENT_END = /(;|\n|\{|\}) *\z/.freeze
+  BEGIN_STATEMENT_END = /\A *(;|\{|\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
+
+  ##
+  # Compiles an HTX template and assigns it the given name (conventionally the path of the template file is
+  # used, but it can be anything).
+  #
+  def self.compile(name, template)
+    doc = Nokogiri::HTML::DocumentFragment.parse(template)
+    js = ''.dup
+
+    process(doc, js, static_key: 0)
+    js.rstrip!
+
+    <<~EOS
+      window['#{name}'] = function(htx) {
+        #{js}
+      }
+    EOS
+  end
+
+  ##
+  # Processes a DOM node.
+  #
+  def self.process(base, js, options = {})
+    base.children.each do |node|
+      next if node.comment?
+
+      dynamic_key = process_value(node.attr(DYNAMIC_KEY_ATTR), :attr)
+
+      if node.text? || node.name == ':'
+        text = (node.text? ? node : node.children).text
+
+        if (value = process_value(text))
+          append(js,
+            "#{indent(text[LEADING_WHITESPACE])}"\
+            "htx.node(#{[
+              value,
+              dynamic_key,
+              ((options[:static_key] += 1) << FLAG_BITS) | TEXT_NODE,
+            ].compact.join(', ')})"\
+            "#{indent(text[TRAILING_WHITESPACE])}"
+          )
+        else
+          append(js, 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
+
+        append(js, "htx.node(#{[
+          "'#{TAG_MAP[node.name] || node.name}'",
+          attrs,
+          dynamic_key,
+          ((options[:static_key] += 1) << FLAG_BITS) | (node.children.empty? ? CHILDLESS : 0),
+        ].compact.flatten.join(', ')})")
+
+        unless node.children.empty?
+          process(node, js, options)
+
+          count = ''
+          js.sub!(CLOSE_STATEMENT) do
+            count = $1 == '' ? 2 : $1.to_i + 1
+            $2
+          end
+
+          append(js, "htx.close(#{count})")
+        end
+      end
+    end
+  end
+
+  ##
+  # Appends a string to the compiled template function string with appropriate punctuation and/or
+  # whitespace inserted.
+  #
+  def self.append(js, text)
+    if js == ''
+      # Do nothing.
+    elsif js !~ END_STATEMENT_END && text !~ BEGIN_STATEMENT_END
+      js << '; '
+    elsif js !~ END_WHITESPACE && text !~ BEGIN_WHITESPACE
+      js << ' '
+    elsif js[-1] == "\n"
+      js << '  '
+    end
+
+    js << text
+  end
+
+  ##
+  # Indents each line of a string (except the first).
+  #
+  def self.indent(text)
+    return '' unless text
+
+    text.gsub!(NEWLINE_NON_BLANK, "\n  ")
+    text
+  end
+
+  ##
+  # Processes, formats, and encodes an attribute or text node value. Returns nil if the value is determined
+  # to be a control statement.
+  #
+  def self.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')}" })
+  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[
+    attributeName baseFrequency calcMode clipPathUnits diffuseConstant edgeMode filterUnits
+    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 repeatCount repeatDur requiredExtensions specularConstant
+    specularExponent spreadMethod startOffset stdDeviation stitchTiles surfaceScale systemLanguage
+    tableValues targetX targetY textLength viewBox xChannelSelector yChannelSelector zoomAndPan
+  ].map { |attr| [attr.downcase, attr] }.to_h.freeze
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: htx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nate Pickens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+description: HTX is a full-featured HTML template system that is simple, lightweight,
+  and highly performant. This library is a Ruby implementation of the HTX template
+  compiler--it converts HTX templates to their compiled JavaScript form.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/htx.rb
+homepage: https://github.com/npickens/htx
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/npickens/htx
+  source_code_uri: https://github.com/npickens/htx
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A Ruby compiler for HTX templates.
+test_files: []