hamlit 2.9.5-java → 2.13.0-java

data/ext/hamlit/hamlit.c

@@ -152,7 +152,6 @@ hamlit_build_multi_class(VALUE escape_attrs, VALUE values)
     }
   }
 
-  rb_ary_sort_bang(buf);
   rb_funcall(buf, id_uniq_bang, 0);
 
   return escape_attribute(escape_attrs, rb_ary_join(buf, str_space()));

data/hamlit.gemspec

@@ -26,10 +26,11 @@ Gem::Specification.new do |spec|
     spec.required_ruby_version = '>= 2.1.0'
   end
 
-  spec.add_dependency 'temple', '>= 0.8.0'
+  spec.add_dependency 'temple', '>= 0.8.2'
   spec.add_dependency 'thor'
   spec.add_dependency 'tilt'
 
+  spec.add_development_dependency 'benchmark_driver'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'coffee-script'
   spec.add_development_dependency 'erubi'
@@ -41,5 +42,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake-compiler'
   spec.add_development_dependency 'sass'
   spec.add_development_dependency 'slim'
+  spec.add_development_dependency 'string_template'
   spec.add_development_dependency 'unindent'
 end

data/lib/hamlit/attribute_builder.rb

@@ -47,7 +47,7 @@ module Hamlit::AttributeBuilder
           when value.is_a?(String)
             # noop
           when value.is_a?(Array)
-            value = value.flatten.select { |v| v }.map(&:to_s).sort.uniq.join(' ')
+            value = value.flatten.select { |v| v }.map(&:to_s).uniq.join(' ')
           when value
             value = value.to_s
           else
@@ -67,7 +67,7 @@ module Hamlit::AttributeBuilder
             classes << value.to_s
           end
         end
-        escape_html(escape_attrs, classes.map(&:to_s).sort.uniq.join(' '))
+        escape_html(escape_attrs, classes.map(&:to_s).uniq.join(' '))
       end
 
       def build_data(escape_attrs, quote, *hashes)

data/lib/hamlit/attribute_compiler.rb

@@ -17,7 +17,7 @@ module Hamlit
       if node.value[:object_ref] != :nil || !Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
         return runtime_compile(node)
       end
-      node.value[:attributes_hashes].each do |attribute_str|
+      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
         hash = AttributeParser.parse(attribute_str)
         return runtime_compile(node) unless hash
         hashes << hash
@@ -28,11 +28,11 @@ module Hamlit
     private
 
     def runtime_compile(node)
-      attrs = node.value[:attributes_hashes]
+      attrs = []
       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(', ')})"]]
+      [:html, :attrs, [:dynamic, "::Hamlit::AttributeBuilder.build(#{args.join(', ')}, #{node.value[:dynamic_attributes].to_literal})"]]
     end
 
     def static_compile(static_hash, dynamic_hashes)

data/lib/hamlit/compiler/children_compiler.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'hamlit/temple_line_counter'
+
 module Hamlit
   class Compiler
     class ChildrenCompiler
@@ -14,7 +16,7 @@ module Hamlit
         node.children.each do |n|
           rstrip_whitespace!(temple) if nuke_prev_whitespace?(n)
           insert_newlines!(temple, n)
-          temple << yield(n)
+          temple << moving_lineno(n) { block.call(n) }
           temple << :whitespace if insert_whitespace?(n)
         end
         rstrip_whitespace!(temple) if nuke_inner_whitespace?(node)
@@ -27,19 +29,31 @@ module Hamlit
         (node.line - @lineno).times do
           temple << [:newline]
         end
+
         @lineno = node.line
+      end
 
+      def moving_lineno(node, &block)
+        # before: As they may have children, we need to increment lineno before compilation.
         case node.type
         when :script, :silent_script
           @lineno += 1
-        when :filter
-          @lineno += (node.value[:text] || '').split("\n").size
         when :tag
-          node.value[:attributes_hashes].each do |attribute_hash|
+          [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_hash|
             @lineno += attribute_hash.count("\n")
           end
           @lineno += 1 if node.children.empty? && node.value[:parse]
         end
+
+        temple = block.call # compile
+
+        # after: filter may not have children, and for some dynamic filters we can't predict the number of lines.
+        case node.type
+        when :filter
+          @lineno += TempleLineCounter.count_lines(temple)
+        end
+
+        temple
       end
 
       def confirm_whitespace(temple)

data/lib/hamlit/compiler/comment_compiler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hamlit
   class Compiler
     class CommentCompiler
@@ -25,11 +26,13 @@ module Hamlit
           condition = $1
         end
 
-        if node.children.empty?
-          [:html, :condcomment, condition, [:static, " #{node.value[:text]} "]]
-        else
-          [:html, :condcomment, condition, yield(node)]
-        end
+        content =
+          if node.children.empty?
+            [:static, " #{node.value[:text]} "]
+          else
+            yield(node)
+          end
+        [:html, :condcomment, condition, content, node.value[:revealed]]
       end
     end
   end

data/lib/hamlit/compiler/tag_compiler.rb

@@ -55,10 +55,6 @@ module Hamlit
 
       # We should handle interpolation here to escape only interpolated values.
       def compile_interpolated_plain(node)
-        unless Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
-          return [:multi, [:escape, node.value[:escape_interpolation], [:dynamic, "%Q[#{node.value[:value]}]"]], [:newline]]
-        end
-
         temple = [:multi]
         StringSplitter.compile(node.value[:value]).each do |type, value|
           case type

data/lib/hamlit/dynamic_merger.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+module Hamlit
+  # Compile [:multi, [:static, 'foo'], [:dynamic, 'bar']] to [:dynamic, '"foo#{bar}"']
+  class DynamicMerger < Temple::Filter
+    def on_multi(*exps)
+      exps = exps.dup
+      result = [:multi]
+      buffer = []
+
+      until exps.empty?
+        type, arg = exps.first
+        if type == :dynamic && arg.count("\n") == 0
+          buffer << exps.shift
+        elsif type == :static && exps.size > (count = arg.count("\n")) &&
+              exps[1, count].all? { |e| e == [:newline] }
+          (1 + count).times { buffer << exps.shift }
+        elsif type == :newline && exps.size > (count = count_newline(exps)) &&
+              exps[count].first == :static && count == exps[count].last.count("\n")
+          (count + 1).times { buffer << exps.shift }
+        else
+          result.concat(merge_dynamic(buffer))
+          buffer = []
+          result << compile(exps.shift)
+        end
+      end
+      result.concat(merge_dynamic(buffer))
+
+      result.size == 2 ? result[1] : result
+    end
+
+    private
+
+    def merge_dynamic(exps)
+      # Merge exps only when they have both :static and :dynamic
+      unless exps.any? { |type,| type == :static } && exps.any? { |type,| type == :dynamic }
+        return exps
+      end
+
+      strlit_body = String.new
+      exps.each do |type, arg|
+        case type
+        when :static
+          strlit_body << arg.dump.sub!(/\A"/, '').sub!(/"\z/, '').gsub('\n', "\n")
+        when :dynamic
+          strlit_body << "\#{#{arg}}"
+        when :newline
+          # newline is added by `gsub('\n', "\n")`
+        else
+          raise "unexpected type #{type.inspect} is given to #merge_dynamic"
+        end
+      end
+      [[:dynamic, "%Q\0#{strlit_body}\0"]]
+    end
+
+    def count_newline(exps)
+      count = 0
+      exps.each do |exp|
+        if exp == [:newline]
+          count += 1
+        else
+          return count
+        end
+      end
+      return count
+    end
+  end
+end

data/lib/hamlit/engine.rb

@@ -2,10 +2,10 @@
 require 'temple'
 require 'hamlit/parser'
 require 'hamlit/compiler'
+require 'hamlit/html'
 require 'hamlit/escapable'
 require 'hamlit/force_escapable'
-require 'hamlit/html'
-require 'hamlit/string_splitter'
+require 'hamlit/dynamic_merger'
 
 module Hamlit
   class Engine < Temple::Engine
@@ -25,15 +25,14 @@ module Hamlit
     use Parser
     use Compiler
     use HTML
-    if Ripper.respond_to?(:lex) # No Ripper.lex in truffleruby
-      use StringSplitter
-      filter :StaticAnalyzer
-    end
+    filter :StringSplitter
+    filter :StaticAnalyzer
     use Escapable
     use ForceEscapable
     filter :ControlFlow
     filter :MultiFlattener
     filter :StaticMerger
+    use DynamicMerger
     use :Generator, -> { options[:generator] }
   end
 end

data/lib/hamlit/filters/escaped.rb

@@ -12,7 +12,7 @@ module Hamlit
 
       def compile_text(text)
         if ::Hamlit::HamlUtil.contains_interpolation?(text)
-          [:dynamic, ::Hamlit::HamlUtil.slow_unescape_interpolation(text)]
+          [:dynamic, ::Hamlit::HamlUtil.unescape_interpolation(text)]
         else
           [:static, text]
         end

data/lib/hamlit/filters/markdown.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Hamlit
   class Filters
     class Markdown < TiltBase

data/lib/hamlit/filters/plain.rb

@@ -14,10 +14,6 @@ module Hamlit
 
       def compile_plain(text)
         string_literal = ::Hamlit::HamlUtil.unescape_interpolation(text)
-        unless Ripper.respond_to?(:lex) # truffleruby doesn't have Ripper.lex
-          return [[:escape, false, [:dynamic, string_literal]]]
-        end
-
         StringSplitter.compile(string_literal).map do |temple|
           type, str = temple
           case type

data/lib/hamlit/filters/preserve.rb

@@ -12,7 +12,7 @@ module Hamlit
 
       def compile_text(text)
         if ::Hamlit::HamlUtil.contains_interpolation?(text)
-          [:dynamic, ::Hamlit::HamlUtil.slow_unescape_interpolation(text)]
+          [:dynamic, ::Hamlit::HamlUtil.unescape_interpolation(text)]
         else
           [:static, text]
         end

data/lib/hamlit/filters/text_base.rb

@@ -6,7 +6,7 @@ module Hamlit
         text = node.value[:text].rstrip.gsub(/^/, prefix)
         if ::Hamlit::HamlUtil.contains_interpolation?(node.value[:text])
           # original: Haml::Filters#compile
-          text = ::Hamlit::HamlUtil.slow_unescape_interpolation(text).gsub(/(\\+)n/) do |s|
+          text = ::Hamlit::HamlUtil.unescape_interpolation(text).gsub(/(\\+)n/) do |s|
             escapes = $1.size
             next s if escapes % 2 == 0
             "#{'\\' * (escapes - 1)}\n"

data/lib/hamlit/filters/tilt_base.rb

@@ -35,7 +35,7 @@ module Hamlit
 
       def dynamic_compile(node, name, indent_width: 0)
         # original: Haml::Filters#compile
-        text = ::Hamlit::HamlUtil.slow_unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
+        text = ::Hamlit::HamlUtil.unescape_interpolation(node.value[:text]).gsub(/(\\+)n/) do |s|
           escapes = $1.size
           next s if escapes % 2 == 0
           "#{'\\' * (escapes - 1)}\n"

data/lib/hamlit/html.rb

@@ -10,5 +10,13 @@ module Hamlit
       end
       super(opts)
     end
+
+    # This dispatcher supports Haml's "revealed" conditional comment.
+    def on_html_condcomment(condition, content, revealed = false)
+      on_html_comment [:multi,
+                       [:static, "[#{condition}]>#{'<!-->' if revealed}"],
+                       content,
+                       [:static, "#{'<!--' if revealed}<![endif]"]]
+    end
   end
 end

data/lib/hamlit/parser.rb

@@ -2,13 +2,17 @@
 # Hamlit::Parser uses original Haml::Parser to generate Haml AST.
 # hamlit/parser/haml_* are modules originally in haml gem.
 
+require 'hamlit/parser/haml_attribute_builder'
 require 'hamlit/parser/haml_error'
 require 'hamlit/parser/haml_util'
+require 'hamlit/parser/haml_helpers'
 require 'hamlit/parser/haml_buffer'
 require 'hamlit/parser/haml_compiler'
 require 'hamlit/parser/haml_parser'
-require 'hamlit/parser/haml_helpers'
 require 'hamlit/parser/haml_options'
+require 'hamlit/parser/haml_escapable'
+require 'hamlit/parser/haml_generator'
+require 'hamlit/parser/haml_temple_engine'
 
 module Hamlit
   class Parser
@@ -29,7 +33,7 @@ module Hamlit
       template = Hamlit::HamlUtil.check_haml_encoding(template) do |msg, line|
         raise Hamlit::Error.new(msg, line)
       end
-      HamlParser.new(template, HamlOptions.new(@options)).parse
+      HamlParser.new(HamlOptions.new(@options)).call(template)
     rescue ::Hamlit::HamlError => e
       error_with_lineno(e)
     end

data/lib/hamlit/parser/haml_attribute_builder.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Hamlit
+  module HamlAttributeBuilder
+    # https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+    INVALID_ATTRIBUTE_NAME_REGEX = /[ \0"'>\/=]/
+
+    class << self
+      def build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes = {})
+        # @TODO this is an absolutely ridiculous amount of arguments. At least
+        # some of this needs to be moved into an instance method.
+        join_char = hyphenate_data_attrs ? '-' : '_'
+
+        attributes.each do |key, value|
+          if value.is_a?(Hash)
+            data_attributes = attributes.delete(key)
+            data_attributes = flatten_data_attributes(data_attributes, '', join_char)
+            data_attributes = build_data_keys(data_attributes, hyphenate_data_attrs, key)
+            verify_attribute_names!(data_attributes.keys)
+            attributes = data_attributes.merge(attributes)
+          end
+        end
+
+        result = attributes.collect do |attr, value|
+          next if value.nil?
+
+          value = filter_and_join(value, ' ') if attr == 'class'
+          value = filter_and_join(value, '_') if attr == 'id'
+
+          if value == true
+            next " #{attr}" if is_html
+            next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
+          elsif value == false
+            next
+          end
+
+          value =
+            if escape_attrs == :once
+              Hamlit::HamlHelpers.escape_once_without_haml_xss(value.to_s)
+            elsif escape_attrs
+              Hamlit::HamlHelpers.html_escape_without_haml_xss(value.to_s)
+            else
+              value.to_s
+            end
+          " #{attr}=#{attr_wrapper}#{value}#{attr_wrapper}"
+        end
+        result.compact!
+        result.sort!
+        result.join
+      end
+
+      # @return [String, nil]
+      def filter_and_join(value, separator)
+        return '' if (value.respond_to?(:empty?) && value.empty?)
+
+        if value.is_a?(Array)
+          value = value.flatten
+          value.map! {|item| item ? item.to_s : nil}
+          value.compact!
+          value = value.join(separator)
+        else
+          value = value ? value.to_s : nil
+        end
+        !value.nil? && !value.empty? && value
+      end
+
+      # Merges two attribute hashes.
+      # This is the same as `to.merge!(from)`,
+      # except that it merges id, class, and data attributes.
+      #
+      # ids are concatenated with `"_"`,
+      # and classes are concatenated with `" "`.
+      # data hashes are simply merged.
+      #
+      # Destructively modifies `to`.
+      #
+      # @param to [{String => String,Hash}] The attribute hash to merge into
+      # @param from [{String => Object}] The attribute hash to merge from
+      # @return [{String => String,Hash}] `to`, after being merged
+      def merge_attributes!(to, from)
+        from.keys.each do |key|
+          to[key] = merge_value(key, to[key], from[key])
+        end
+        to
+      end
+
+      # Merge multiple values to one attribute value. No destructive operation.
+      #
+      # @param key [String]
+      # @param values [Array<Object>]
+      # @return [String,Hash]
+      def merge_values(key, *values)
+        values.inject(nil) do |to, from|
+          merge_value(key, to, from)
+        end
+      end
+
+      def verify_attribute_names!(attribute_names)
+        attribute_names.each do |attribute_name|
+          if attribute_name =~ INVALID_ATTRIBUTE_NAME_REGEX
+            raise HamlInvalidAttributeNameError.new("Invalid attribute name '#{attribute_name}' was rendered")
+          end
+        end
+      end
+
+      private
+
+      # Merge a couple of values to one attribute value. No destructive operation.
+      #
+      # @param to [String,Hash,nil]
+      # @param from [Object]
+      # @return [String,Hash]
+      def merge_value(key, to, from)
+        if from.kind_of?(Hash) || to.kind_of?(Hash)
+          from = { nil => from } if !from.is_a?(Hash)
+          to   = { nil => to }   if !to.is_a?(Hash)
+          to.merge(from)
+        elsif key == 'id'
+          merged_id = filter_and_join(from, '_')
+          if to && merged_id
+            merged_id = "#{to}_#{merged_id}"
+          elsif to || merged_id
+            merged_id ||= to
+          end
+          merged_id
+        elsif key == 'class'
+          merged_class = filter_and_join(from, ' ')
+          if to && merged_class
+            merged_class = (to.split(' ') | merged_class.split(' ')).join(' ')
+          elsif to || merged_class
+            merged_class ||= to
+          end
+          merged_class
+        else
+          from
+        end
+      end
+
+      def build_data_keys(data_hash, hyphenate, attr_name="data")
+        Hash[data_hash.map do |name, value|
+          if name == nil
+            [attr_name, value]
+          elsif hyphenate
+            ["#{attr_name}-#{name.to_s.tr('_', '-')}", value]
+          else
+            ["#{attr_name}-#{name}", value]
+          end
+        end]
+      end
+
+      def flatten_data_attributes(data, key, join_char, seen = [])
+        return {key => data} unless data.is_a?(Hash)
+
+        return {key => nil} if seen.include? data.object_id
+        seen << data.object_id
+
+        data.sort {|x, y| x[0].to_s <=> y[0].to_s}.inject({}) do |hash, (k, v)|
+          joined = key == '' ? k : [key, k].join(join_char)
+          hash.merge! flatten_data_attributes(v, joined, join_char, seen)
+        end
+      end
+    end
+  end
+end