hamlit 2.9.3

data/ext/hamlit/hescape.c

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "hescape.h"
+
+static const char *ESCAPED_STRING[] = {
+  "",
+  "&quot;",
+  "&amp;",
+  "&#39;",
+  "&lt;",
+  "&gt;",
+};
+
+// This is strlen(ESCAPED_STRING[x]) optimized specially.
+// Mapping: 1 => 6, 2 => 5, 3 => 5, 4 => 4, 5 => 4
+#define ESC_LEN(x) ((13 - x) / 2)
+
+/*
+ * Given ASCII-compatible character, return index of ESCAPED_STRING.
+ *
+ * " (34) => 1 (&quot;)
+ * & (38) => 2 (&amp;)
+ * ' (39) => 3 (&#39;)
+ * < (60) => 4 (&lt;)
+ * > (62) => 5 (&gt;)
+ */
+static const char HTML_ESCAPE_TABLE[] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static char*
+ensure_allocated(char *buf, size_t size, size_t *asize)
+{
+  size_t new_size;
+
+  if (size < *asize)
+    return buf;
+
+  if (*asize == 0) {
+    new_size = size;
+  } else {
+    new_size = *asize;
+  }
+
+  // Increase buffer size by 1.5x if realloced multiple times.
+  while (new_size < size)
+    new_size = (new_size << 1) - (new_size >> 1);
+
+  // Round allocation up to multiple of 8.
+  new_size = (new_size + 7) & ~7;
+
+  *asize = new_size;
+  return realloc(buf, new_size);
+}
+
+size_t
+hesc_escape_html(char **dest, const char *buf, size_t size)
+{
+  size_t asize = 0, esc_i = 0, esize = 0, i = 0, rbuf_end = 0;
+  const char *esc;
+  char *rbuf = NULL;
+
+  while (i < size) {
+    // Loop here to skip non-escaped characters fast.
+    while (i < size && (esc_i = HTML_ESCAPE_TABLE[(unsigned char)buf[i]]) == 0)
+      i++;
+
+    if (i < size && esc_i) {
+      esc = ESCAPED_STRING[esc_i];
+      rbuf = ensure_allocated(rbuf, sizeof(char) * (size + esize + ESC_LEN(esc_i) + 1), &asize);
+
+      // Copy pending characters and escaped string.
+      memmove(rbuf + rbuf_end, buf + (rbuf_end - esize), i - (rbuf_end - esize));
+      memmove(rbuf + i + esize, esc, ESC_LEN(esc_i));
+      rbuf_end = i + esize + ESC_LEN(esc_i);
+      esize += ESC_LEN(esc_i) - 1;
+    }
+    i++;
+  }
+
+  if (rbuf_end == 0) {
+    // Return given buf and size if there are no escaped characters.
+    *dest = (char *)buf;
+    return size;
+  } else {
+    // Copy pending characters including NULL character.
+    memmove(rbuf + rbuf_end, buf + (rbuf_end - esize), (size + 1) - (rbuf_end - esize));
+
+    *dest = rbuf;
+    return size + esize;
+  }
+}

data/ext/hamlit/hescape.h

@@ -0,0 +1,20 @@
+#ifndef HESCAPE_H
+#define HESCAPE_H
+
+#include <sys/types.h>
+
+/*
+ * Replace characters according to the following rules.
+ * Note that this function can handle only ASCII-compatible string.
+ *
+ * " => &quot;
+ * & => &amp;
+ * ' => &#39;
+ * < => &lt;
+ * > => &gt;
+ *
+ * @return size of dest. If it's larger than len, dest is required to be freed.
+ */
+extern size_t hesc_escape_html(char **dest, const char *src, size_t size);
+
+#endif

data/hamlit.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hamlit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'hamlit'
+  spec.version       = Hamlit::VERSION
+  spec.authors       = ['Takashi Kokubun']
+  spec.email         = ['takashikkbn@gmail.com']
+
+  spec.summary       = %q{High Performance Haml Implementation}
+  spec.description   = %q{High Performance Haml Implementation}
+  spec.homepage      = 'https://github.com/k0kubun/hamlit'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sample)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  if /java/ === RUBY_PLATFORM
+    spec.platform = 'java'
+  else
+    spec.extensions = ['ext/hamlit/extconf.rb']
+    spec.required_ruby_version = '>= 2.1.0'
+  end
+
+  spec.add_dependency 'temple', '>= 0.8.0'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'tilt'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coffee-script'
+  spec.add_development_dependency 'erubi'
+  spec.add_development_dependency 'haml', '>= 5'
+  spec.add_development_dependency 'less'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'sass'
+  spec.add_development_dependency 'slim'
+  spec.add_development_dependency 'unindent'
+end

data/lib/hamlit.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require 'hamlit/engine'
+require 'hamlit/error'
+require 'hamlit/version'
+require 'hamlit/template'
+
+begin
+  require 'rails'
+  require 'hamlit/railtie'
+rescue LoadError
+end

data/lib/hamlit/attribute_builder.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+require 'hamlit/object_ref'
+
+module Hamlit::AttributeBuilder
+  BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
+                       autoplay controls loop selected hidden scoped async
+                       defer reversed ismap seamless muted required
+                       autofocus novalidate formnovalidate open pubdate
+                       itemscope allowfullscreen default inert sortable
+                       truespeed typemustmatch download].freeze
+
+  if /java/ === RUBY_PLATFORM # JRuby
+    class << self
+      def build(escape_attrs, quote, format, object_ref, *hashes)
+        hashes << Hamlit::ObjectRef.parse(object_ref) if object_ref
+        buf  = []
+        hash = merge_all_attrs(hashes)
+
+        keys = hash.keys.sort!
+        keys.each do |key|
+          case key
+          when 'id'.freeze
+            buf << " id=#{quote}#{build_id(escape_attrs, *hash[key])}#{quote}"
+          when 'class'.freeze
+            buf << " class=#{quote}#{build_class(escape_attrs, *hash[key])}#{quote}"
+          when 'data'.freeze
+            buf << build_data(escape_attrs, quote, *hash[key])
+          when *BOOLEAN_ATTRIBUTES, /\Adata-/
+            build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+          else
+            buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+          end
+        end
+        buf.join
+      end
+
+      def build_id(escape_attrs, *values)
+        escape_html(escape_attrs, values.flatten.select { |v| v }.join('_'))
+      end
+
+      def build_class(escape_attrs, *values)
+        if values.size == 1
+          value = values.first
+          case
+          when value.is_a?(String)
+            # noop
+          when value.is_a?(Array)
+            value = value.flatten.select { |v| v }.map(&:to_s).sort.uniq.join(' ')
+          when value
+            value = value.to_s
+          else
+            return ''
+          end
+          return escape_html(escape_attrs, value)
+        end
+
+        classes = []
+        values.each do |value|
+          case
+          when value.is_a?(String)
+            classes += value.split(' ')
+          when value.is_a?(Array)
+            classes += value.select { |v| v }
+          when value
+            classes << value.to_s
+          end
+        end
+        escape_html(escape_attrs, classes.map(&:to_s).sort.uniq.join(' '))
+      end
+
+      def build_data(escape_attrs, quote, *hashes)
+        build_data_attribute(:data, escape_attrs, quote, *hashes)
+      end
+
+      def build_aria(escape_attrs, quote, *hashes)
+        build_data_attribute(:aria, escape_attrs, quote, *hashes)
+      end
+
+      private
+
+      def build_data_attribute(key, escape_attrs, quote, *hashes)
+        attrs = []
+        if hashes.size > 1 && hashes.all? { |h| h.is_a?(Hash) }
+          data_value = merge_all_attrs(hashes)
+        else
+          data_value = hashes.last
+        end
+        hash = flatten_attributes(key => data_value)
+
+        hash.sort_by(&:first).each do |key, value|
+          case value
+          when true
+            attrs << " #{key}"
+          when nil, false
+            # noop
+          else
+            attrs << " #{key}=#{quote}#{escape_html(escape_attrs, value.to_s)}#{quote}"
+          end
+        end
+        attrs.join
+      end
+
+      def flatten_attributes(attributes)
+        flattened = {}
+
+        attributes.each do |key, value|
+          case value
+          when attributes
+          when Hash
+            flatten_attributes(value).each do |k, v|
+              if k.nil?
+                flattened[key] = v
+              else
+                flattened["#{key}-#{k.to_s.gsub(/_/, '-')}"] = v
+              end
+            end
+          else
+            flattened[key] = value if value
+          end
+        end
+        flattened
+      end
+
+      def merge_all_attrs(hashes)
+        merged = {}
+        hashes.each do |hash|
+          hash.each do |key, value|
+            key = key.to_s
+            case key
+            when 'id'.freeze, 'class'.freeze, 'data'.freeze
+              merged[key] ||= []
+              merged[key] << value
+            else
+              merged[key] = value
+            end
+          end
+        end
+        merged
+      end
+
+      def build_boolean!(escape_attrs, quote, format, buf, key, value)
+        case value
+        when true
+          case format
+          when :xhtml
+            buf << " #{key}=#{quote}#{key}#{quote}"
+          else
+            buf << " #{key}"
+          end
+        when false, nil
+          # omitted
+        else
+          buf << " #{key}=#{quote}#{escape_html(escape_attrs, value)}#{quote}"
+        end
+      end
+
+      def escape_html(escape_attrs, str)
+        if escape_attrs
+          Hamlit::Utils.escape_html(str)
+        else
+          str
+        end
+      end
+    end
+  else
+    # Hamlit::AttributeBuilder.build
+    # Hamlit::AttributeBuilder.build_id
+    # Hamlit::AttributeBuilder.build_class
+    # Hamlit::AttributeBuilder.build_data
+    # Hamlit::AttributeBuilder.build_aria
+    require 'hamlit/hamlit'
+  end
+end

data/lib/hamlit/attribute_compiler.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require 'hamlit/attribute_builder'
+require 'hamlit/attribute_parser'
+require 'hamlit/ruby_expression'
+
+module Hamlit
+  class AttributeCompiler
+    def initialize(identity, options)
+      @identity = identity
+      @quote  = options[:attr_quote]
+      @format = options[:format]
+      @escape_attrs = options[:escape_attrs]
+    end
+
+    def compile(node)
+      hashes = []
+      return runtime_compile(node) if node.value[:object_ref] != :nil
+      node.value[:attributes_hashes].each do |attribute_str|
+        hash = AttributeParser.parse(attribute_str)
+        return runtime_compile(node) unless hash
+        hashes << hash
+      end
+      static_compile(node.value[:attributes], hashes)
+    end
+
+    private
+
+    def runtime_compile(node)
+      attrs = node.value[:attributes_hashes]
+      attrs.unshift(node.value[:attributes].inspect) if node.value[:attributes] != {}
+
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect].push(node.value[:object_ref]) + attrs
+      [:html, :attrs, [:dynamic, "::Hamlit::AttributeBuilder.build(#{args.join(', ')})"]]
+    end
+
+    def static_compile(static_hash, dynamic_hashes)
+      temple = [:html, :attrs]
+      keys = [*static_hash.keys, *dynamic_hashes.map(&:keys).flatten].uniq.sort
+      keys.each do |key|
+        values = [[:static, static_hash[key]], *dynamic_hashes.map { |h| [:dynamic, h[key]] }]
+        values.select! { |_, exp| exp != nil }
+
+        case key
+        when 'id'
+          compile_id!(temple, key, values)
+        when 'class'
+          compile_class!(temple, key, values)
+        when 'data', 'aria'
+          compile_data!(temple, key, values)
+        when *AttributeBuilder::BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          compile_boolean!(temple, key, values)
+        else
+          compile_common!(temple, key, values)
+        end
+      end
+      temple
+    end
+
+    def compile_id!(temple, key, values)
+      build_code = attribute_builder(:id, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_class!(temple, key, values)
+      build_code = attribute_builder(:class, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_data!(temple, key, values)
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", values.map { |v| literal_for(v) }]
+      build_code = "::Hamlit::AttributeBuilder.build_#{key}(#{args.join(', ')})"
+
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:static, eval(build_code).to_s]
+      else
+        temple << [:dynamic, build_code]
+      end
+    end
+
+    def compile_boolean!(temple, key, values)
+      exp = literal_for(values.last)
+
+      if Temple::StaticAnalyzer.static?(exp)
+        value = eval(exp)
+        case value
+        when true then temple << [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]
+        when false, nil
+        else temple << [:html, :attr, key, [:fescape, @escape_attrs, [:static, value.to_s]]]
+        end
+      else
+        var = @identity.generate
+        temple << [
+          :case, "(#{var} = (#{exp}))",
+          ['true', [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]],
+          ['false, nil', [:multi]],
+          [:else, [:multi, [:static, " #{key}=#{@quote}"], [:fescape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
+        ]
+      end
+    end
+
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:fescape, @escape_attrs, values.last]]
+    end
+
+    def attribute_builder(type, values)
+      args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+      "::Hamlit::AttributeBuilder.build_#{type}(#{args.join(', ')})"
+    end
+
+    def literal_for(value)
+      type, exp = value
+      type == :static ? "#{exp.inspect}.freeze" : exp
+    end
+  end
+end