hamlit 2.9.5 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 818a7688a58be17941aea6ddd21986d58186048882d0672b9f8a586d19a00972
-  data.tar.gz: 22c7eaef6d2fb67fe939c8d861780d4d56affa6df0d478ede2b0beb7da6bf79f
+  metadata.gz: d8a587e57cbdc02c90d18591926efb8bf4fd990d60c31969501418a1eed0d2d9
+  data.tar.gz: 7f97e39c33bad82a1cc5b4056b8ac0765a2939f2a9c0a6fecfd156daefa98fa3
 SHA512:
-  metadata.gz: 56fa71f1352812b9f98e2042f4f59fb54cb35183ee3ee9c29fd9302293446522bbd5c03e0cd9859fb0d757ec854692e544a4a51e169bb9478da68b251f1059a2
-  data.tar.gz: 564b8282a5a1db7b476d664792d157112fbe5f4d28be48b0d31f89542c084fda0c17f86a2930306c3ed9b599b04e43073e81929488d49b0101a78ed2c336bceb
+  metadata.gz: dba41938cf6697aeef29f404178de0ccf46cb438402510e989af63593e5ea853627f3f0594fd0359e4b10c68b3c53a7ae64b9c3e2d2f717707e5996006b49721
+  data.tar.gz: 61ce345a747e0fffee535ecab7caee9b0320858f0243b405643115b97cef012039ed9d72766f5bbd4f1b0cde8fa2ffca7b7cea74a8b9ce2a875106c680f5274d

data/.gitignore

@@ -11,6 +11,7 @@
 .ruby-version
 *.bundle
 *.so
+*.su
 *.o
 *.a
 *.swp

data/.travis.yml

@@ -9,11 +9,13 @@ matrix:
   include:
     - rvm: 2.3.8
       env: TASK=test
-    - rvm: 2.4.5
+    - rvm: 2.4.9
       env: TASK=test
-    - rvm: 2.5.3
+    - rvm: 2.5.7
       env: TASK=test
-    - rvm: 2.6.0
+    - rvm: 2.6.5
+      env: TASK=test
+    - rvm: 2.7.0
       env: TASK=test
     - rvm: ruby-head
       env: TASK=test
@@ -21,19 +23,19 @@ matrix:
       env: TASK=test
     - rvm: truffleruby
       env: TASK=test
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=benchmark/boolean_attribute.haml,benchmark/class_attribute.haml,benchmark/id_attribute.haml,benchmark/data_attribute.haml,benchmark/common_attribute.haml
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=benchmark/dynamic_attributes/boolean_attribute.haml,benchmark/dynamic_attributes/class_attribute.haml,benchmark/dynamic_attributes/id_attribute.haml,benchmark/dynamic_attributes/data_attribute.haml,benchmark/dynamic_attributes/common_attribute.haml
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench SLIM_BENCH=1
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=benchmark/etc/attribute_builder.haml
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=benchmark/etc/static_analyzer.haml
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=benchmark/etc/string_interpolation.haml
-    - rvm: 2.6.0
+    - rvm: 2.7.0
       env: TASK=bench TEMPLATE=test/haml/templates/standard.haml COMPILE=1
   allow_failures:
     - rvm: ruby-head

data/CHANGELOG.md

@@ -4,6 +4,45 @@ All notable changes to this project will be documented in this file. This
 project adheres to [Semantic Versioning](http://semver.org/). This change log is based upon
 [keep-a-changelog](https://github.com/olivierlacan/keep-a-changelog).
 
+## [2.12.0](https://github.com/k0kubun/hamlit/compare/v2.11.1...v2.12.0) - 2020-09-30
+
+### Changed
+
+- Class names are no longer ordered alphabetically
+  *Thanks to @aliismayilov*
+  - This is compatible with [Haml 5.2](https://github.com/haml/haml/blob/v5.2.0/CHANGELOG.md#52)
+
+## [2.11.1](https://github.com/k0kubun/hamlit/compare/v2.11.0...v2.11.1) - 2020-08-25
+
+### Fixed
+
+- Fix a line number on an error after filters like preserve, plain, and ruby.
+  *Thanks to @rgisiger*
+
+## [2.11.0](https://github.com/k0kubun/hamlit/compare/v2.10.1...v2.11.0) - 2019-12-12
+
+### Added
+
+- Support Haml's _revealed_ conditional comment feature on `/![if !IE]` [#153](https://github.com/k0kubun/hamlit/issues/153).
+  *Thanks to @esb*
+
+## [2.10.1](https://github.com/k0kubun/hamlit/compare/v2.10.0...v2.10.1) - 2019-11-28
+
+### Added
+
+- Register `Hamlit::Template` to Tilt as :hamlit as well, in addition to :haml
+
+## [2.10.0](https://github.com/k0kubun/hamlit/compare/v2.9.5...v2.10.0) - 2019-09-15
+
+### Added
+
+- Optimize template rendering by string interpolation [#146](https://github.com/k0kubun/hamlit/issues/146)
+  - Exploiting pre-allocation of string interpolation introduced in Ruby 2.5 [ruby/ruby#1626](https://github.com/ruby/ruby/pull/1626)
+
+### Changed
+
+- Require temple.gem >= 0.8.2
+
 ## [2.9.5](https://github.com/k0kubun/hamlit/compare/v2.9.4...v2.9.5) - 2019-09-08
 
 ### Added

data/Gemfile

@@ -8,23 +8,17 @@ end
 # Specify your gem's dependencies in hamlit.gemspec
 gemspec
 
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.2')
-  gem 'rack', '< 2'
-end
-
 gem 'benchmark-ips', '2.3.0'
 gem 'maxitest'
+gem 'pry'
 
 if /java/ === RUBY_PLATFORM # JRuby
   gem 'pandoc-ruby'
 else
-  gem 'pry-byebug'
   gem 'redcarpet'
 
   if RUBY_PLATFORM !~ /mswin|mingw/ && RUBY_ENGINE != 'truffleruby'
-    if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7.0') # Travis cannot compile ruby.h with C++
-      gem 'faml'
-    end
+    gem 'faml'
     gem 'stackprof'
   end
 end

data/REFERENCE.md

@@ -57,6 +57,7 @@ for full features in original implementation.
   - [x] :plain
   - [x] :preserve
   - [x] :ruby
+     - `haml_io` API is not supported. Use [hamlit-haml\_io.gem](https://github.com/hamlit/hamlit-haml_io) if you need.
   - [x] :sass
   - [x] :scss
   - [ ] :textile
@@ -121,10 +122,10 @@ and merging multiple ids results in concatenation by "\_".
 %div{ id: false }
 
 # Output
-<div id='foo_bar'></span>
-<div id='foo_bar'></span>
-<div id='foo_bar'></span>
-<div id=''></span>
+<div id='foo_bar'></div>
+<div id='foo_bar'></div>
+<div id='foo_bar'></div>
+<div id=''></div>
 ```
 
 ### class attribute
@@ -224,6 +225,14 @@ Hamlit::RailsTemplate.set_options attr_quote: '"'
 set :haml, { attr_quote: '"' }
 ```
 
+## Ruby module
+
+`Hamlit::Template` is a module registered to `Tilt`. You can use it like:
+
+```rb
+Hamlit::Template.new { "%strong Yay for HAML!" }.render
+```
+
 ## Creating a custom filter
 
 Currently it doesn't have filter registering interface compatible with Haml.

data/benchmark/dynamic_merger/benchmark.rb

@@ -0,0 +1,25 @@
+# Original: https://github.com/amatsuda/string_template/blob/master/benchmark.rb
+require 'benchmark_driver'
+
+Benchmark.driver(repeat_count: 8) do |x|
+  x.prelude %{
+    require 'rails'
+    require 'action_view'
+    require 'string_template'
+    StringTemplate::Railtie.run_initializers
+    require 'hamlit'
+    Hamlit::Railtie.run_initializers
+    Hamlit::RailsTemplate.set_options(escape_html: false, generator: Temple::Generators::ArrayBuffer)
+    require 'action_view/base'
+
+    (view = Class.new(ActionView::Base).new(ActionView::LookupContext.new(''))).instance_variable_set(:@world, 'world!')
+
+    # compile template
+    hello = 'benchmark/dynamic_merger/hello'
+    view.render(template: hello, handlers: 'string')
+    view.render(template: hello, handlers: 'haml')
+  }
+  x.report 'string', %{ view.render(template: hello, handlers: 'string') }
+  x.report 'hamlit', %{ view.render(template: hello, handlers: 'haml') }
+  x.loop_count 100_000
+end

data/benchmark/dynamic_merger/hello.haml

@@ -0,0 +1,50 @@
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }

data/benchmark/dynamic_merger/hello.string

@@ -0,0 +1,50 @@
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }
+hello, #{ @world }

data/bin/bench

@@ -25,7 +25,7 @@ class Bench < Thor
     haml = File.read(file)
 
     Benchmark.ips do |x|
-      x.report("haml v#{Haml::VERSION}") { Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).precompiled }
+      x.report("haml v#{Haml::VERSION}") { Haml::Engine.new(haml, escape_html: true, escape_attrs: true).precompiled }
       x.report("faml v#{Faml::VERSION}") { Faml::Engine.new.call(haml) }
       x.report("hamlit v#{Hamlit::VERSION}") { Hamlit::Engine.new.call(haml) }
       x.compare!
@@ -43,7 +43,7 @@ class Bench < Thor
       object.instance_eval(File.read(ruby_file))
     end
 
-    Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).def_method(object, :haml)
+    Haml::Engine.new(haml, escape_html: true, escape_attrs: true).def_method(object, :haml)
     object.instance_eval "def faml; #{Faml::Engine.new.call(haml)}; end"
     object.instance_eval "def hamlit; #{Hamlit::Engine.new.call(haml)}; end"
 
@@ -59,7 +59,7 @@ class Bench < Thor
   def code(file)
     haml = File.read(file)
     puts "#{?= * 49}\n Haml Source: #{file}\n#{?= * 49}"
-    puts Haml::Engine.new(haml, escape_html: true, escape_attrs: true, ugly: true).precompiled
+    puts Haml::Engine.new(haml, escape_html: true, escape_attrs: true).precompiled
     puts "\n#{?= * 49}\n Faml Source: #{file}\n#{?= * 49}"
     puts Faml::Engine.new.call(haml)
     puts "\n#{?= * 49}\n Hamlit Source: #{file}\n#{?= * 49}"

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

@@ -25,11 +25,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/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/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/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 InvalidAttributeNameError.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

data/lib/hamlit/parser/haml_helpers.rb

@@ -617,6 +617,9 @@ MESSAGE
       text.gsub(HTML_ESCAPE_REGEX, HTML_ESCAPE)
     end
 
+    # Always escape text regardless of html_safe?
+    alias_method :html_escape_without_haml_xss, :html_escape
+
     HTML_ESCAPE_ONCE_REGEX = /[\"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/
 
     # Escapes HTML entities in `text`, but without escaping an ampersand
@@ -629,6 +632,9 @@ MESSAGE
       text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
     end
 
+    # Always escape text once regardless of html_safe?
+    alias_method :escape_once_without_haml_xss, :escape_once
+
     # Returns whether or not the current template is a Haml template.
     #
     # This function, unlike other {Haml::Helpers} functions,

data/lib/hamlit/parser/haml_parser.rb

@@ -1,6 +1,7 @@
 require 'strscan'
 require 'hamlit/parser/haml_util'
 require 'hamlit/parser/haml_error'
+require 'hamlit/parser/haml_attribute_builder'
 
 module Hamlit
   class HamlParser
@@ -206,6 +207,31 @@ module Hamlit
       end
     end
 
+    # @param [String] new - Hash literal including dynamic values.
+    # @param [String] old - Hash literal including dynamic values or Ruby literal of multiple Hashes which MUST be interpreted as method's last arguments.
+    DynamicAttributes = Struct.new(:new, :old) do
+      undef :old=
+      def old=(value)
+        unless value =~ /\A{.*}\z/m
+          raise ArgumentError.new('Old attributes must start with "{" and end with "}"')
+        end
+        self[:old] = value
+      end
+
+      # This will be a literal for Haml::Buffer#attributes's last argument, `attributes_hashes`.
+      def to_literal
+        [new, stripped_old].compact.join(', ')
+      end
+
+      private
+
+      # For `%foo{ { foo: 1 }, bar: 2 }`, :old is "{ { foo: 1 }, bar: 2 }" and this method returns " { foo: 1 }, bar: 2 " for last argument.
+      def stripped_old
+        return nil if old.nil?
+        old.sub!(/\A{/, '').sub!(/}\z/m, '')
+      end
+    end
+
     # Processes and deals with lowering indentation.
     def process_indent(line)
       return unless line.tabs <= @template_tabs && @template_tabs > 0
@@ -403,22 +429,20 @@ module Hamlit
       end
 
       attributes = ::Hamlit::HamlParser.parse_class_and_id(attributes)
-      attributes_list = []
+      dynamic_attributes = DynamicAttributes.new
 
       if attributes_hashes[:new]
         static_attributes, attributes_hash = attributes_hashes[:new]
-        ::Hamlit::HamlBuffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hash
+        HamlAttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
+        dynamic_attributes.new = attributes_hash
       end
 
       if attributes_hashes[:old]
         static_attributes = parse_static_hash(attributes_hashes[:old])
-        ::Hamlit::HamlBuffer.merge_attrs(attributes, static_attributes) if static_attributes
-        attributes_list << attributes_hashes[:old] unless static_attributes || @options.suppress_eval
+        HamlAttributeBuilder.merge_attributes!(attributes, static_attributes) if static_attributes
+        dynamic_attributes.old = attributes_hashes[:old] unless static_attributes || @options.suppress_eval
       end
 
-      attributes_list.compact!
-
       raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:illegal_nesting_self_closing), @next_line.index) if block_opened? && self_closing
       raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:no_ruby_code, action), last_line - 1) if parse && value.empty?
       raise ::Hamlit::HamlSyntaxError.new(::Hamlit::HamlError.message(:self_closing_content), last_line - 1) if self_closing && !value.empty?
@@ -433,7 +457,7 @@ module Hamlit
       line = handle_ruby_multiline(line) if parse
 
       ParseNode.new(:tag, line.index + 1, :name => tag_name, :attributes => attributes,
-        :attributes_hashes => attributes_list, :self_closing => self_closing,
+        :dynamic_attributes => dynamic_attributes, :self_closing => self_closing,
         :nuke_inner_whitespace => nuke_inner_whitespace,
         :nuke_outer_whitespace => nuke_outer_whitespace, :object_ref => object_ref,
         :escape_html => escape_html, :preserve_tag => preserve_tag,
@@ -641,7 +665,6 @@ module Hamlit
         raise e
       end
 
-      attributes_hash = attributes_hash[1...-1] if attributes_hash
       return attributes_hash, rest, last_line
     end
 

data/lib/hamlit/parser/haml_xss_mods.rb

@@ -6,12 +6,15 @@ module Hamlit
     # to work with Rails' XSS protection methods.
     module XssMods
       def self.included(base)
-        %w[html_escape find_and_preserve preserve list_of surround
-           precede succeed capture_haml haml_concat haml_internal_concat haml_indent
-           escape_once].each do |name|
+        %w[find_and_preserve preserve list_of surround
+           precede succeed capture_haml haml_concat haml_internal_concat haml_indent].each do |name|
           base.send(:alias_method, "#{name}_without_haml_xss", name)
           base.send(:alias_method, name, "#{name}_with_haml_xss")
         end
+        # Those two always have _without_haml_xss
+        %w[html_escape escape_once].each do |name|
+          base.send(:alias_method, name, "#{name}_with_haml_xss")
+        end
       end
 
       # Don't escape text that's already safe,

data/lib/hamlit/string_splitter.rb

@@ -2,87 +2,18 @@ require 'ripper'
 require 'hamlit/ruby_expression'
 
 module Hamlit
-  class StringSplitter < Temple::Filter
-    class << self
-      # `code` param must be valid string literal
-      def compile(code)
-        [].tap do |exps|
-          tokens = Ripper.lex(code.strip)
-          tokens.pop while tokens.last && %i[on_comment on_sp].include?(tokens.last[1])
-
-          if tokens.size < 2
-            raise Hamlit::InternalError.new("Expected token size >= 2 but got: #{tokens.size}")
-          end
-          compile_tokens!(exps, tokens)
-        end
-      end
-
-      private
-
-      def strip_quotes!(tokens)
-        _, type, beg_str = tokens.shift
-        if type != :on_tstring_beg
-          raise Hamlit::InternalError.new("Expected :on_tstring_beg but got: #{type}")
-        end
-
-        _, type, end_str = tokens.pop
-        if type != :on_tstring_end
-          raise Hamlit::InternalError.new("Expected :on_tstring_end but got: #{type}")
-        end
-
-        [beg_str, end_str]
-      end
-
-      def compile_tokens!(exps, tokens)
-        beg_str, end_str = strip_quotes!(tokens)
-
-        until tokens.empty?
-          _, type, str = tokens.shift
-
-          case type
-          when :on_tstring_content
-            exps << [:static, eval("#{beg_str}#{str}#{end_str}")]
-          when :on_embexpr_beg
-            embedded = shift_balanced_embexpr(tokens)
-            exps << [:dynamic, embedded] unless embedded.empty?
-          end
-        end
-      end
-
-      def shift_balanced_embexpr(tokens)
-        String.new.tap do |embedded|
-          embexpr_open = 1
-
-          until tokens.empty?
-            _, type, str = tokens.shift
-            case type
-            when :on_embexpr_beg
-              embexpr_open += 1
-            when :on_embexpr_end
-              embexpr_open -= 1
-              break if embexpr_open == 0
-            end
-
-            embedded << str
-          end
-        end
+  module StringSplitter
+    # `code` param must be valid string literal
+    def self.compile(code)
+      unless Ripper.respond_to?(:lex) # truffleruby doesn't have Ripper.lex
+        return [[:dynamic, code]]
       end
-    end
-
-    def on_dynamic(code)
-      return [:dynamic, code] unless RubyExpression.string_literal?(code)
-      return [:dynamic, code] if code.include?("\n")
 
-      temple = [:multi]
-      StringSplitter.compile(code).each do |type, content|
-        case type
-        when :static
-          temple << [:static, content]
-        when :dynamic
-          temple << on_dynamic(content)
-        end
+      begin
+        Temple::Filters::StringSplitter.compile(code)
+      rescue Temple::FilterError => e
+        raise Hamlit::InternalError.new(e.message)
       end
-      temple
     end
   end
 end

data/lib/hamlit/template.rb

@@ -14,7 +14,7 @@ end
 module Hamlit
   Template = Temple::Templates::Tilt.create(
     Hamlit::Engine,
-    register_as: :haml,
+    register_as: [:haml, :hamlit],
   )
 
   module TemplateExtension

data/lib/hamlit/temple_line_counter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Hamlit
+  # A module to count lines of expected code. This would be faster than actual code generation
+  # and counting newlines in it.
+  module TempleLineCounter
+    class UnexpectedExpression < StandardError; end
+
+    def self.count_lines(exp)
+      type, *args = exp
+      case type
+      when :multi
+        args.map { |a| count_lines(a) }.reduce(:+) || 0
+      when :dynamic, :code
+        args.first.count("\n")
+      when :static
+        0 # It has not real newline "\n" but escaped "\\n".
+      when :case
+        arg, *cases = args
+        arg.count("\n") + cases.map do |cond, e|
+          (cond == :else ? 0 : cond.count("\n")) + count_lines(e)
+        end.reduce(:+)
+      when :escape
+        count_lines(args[1])
+      when :newline
+        1
+      else
+        raise UnexpectedExpression.new("[HAML BUG] Unexpected Temple expression '#{type}' is given!")
+      end
+    end
+  end
+end

data/lib/hamlit/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Hamlit
-  VERSION = '2.9.5'
+  VERSION = '2.12.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hamlit
 version: !ruby/object:Gem::Version
-  version: 2.9.5
+  version: 2.12.0
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-08 00:00:00.000000000 Z
+date: 2020-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: temple
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.2
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark_driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +220,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: string_template
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: unindent
   requirement: !ruby/object:Gem::Requirement
@@ -247,6 +275,9 @@ files:
 - benchmark/dynamic_attributes/data_attribute.haml
 - benchmark/dynamic_attributes/id_attribute.haml
 - benchmark/dynamic_boolean_attribute.haml
+- benchmark/dynamic_merger/benchmark.rb
+- benchmark/dynamic_merger/hello.haml
+- benchmark/dynamic_merger/hello.string
 - benchmark/etc/attribute_builder.haml
 - benchmark/etc/real_sample.haml
 - benchmark/etc/real_sample.rb
@@ -290,6 +321,7 @@ files:
 - lib/hamlit/compiler/script_compiler.rb
 - lib/hamlit/compiler/silent_script_compiler.rb
 - lib/hamlit/compiler/tag_compiler.rb
+- lib/hamlit/dynamic_merger.rb
 - lib/hamlit/engine.rb
 - lib/hamlit/error.rb
 - lib/hamlit/escapable.rb
@@ -311,7 +343,6 @@ files:
 - lib/hamlit/filters/text_base.rb
 - lib/hamlit/filters/tilt_base.rb
 - lib/hamlit/force_escapable.rb
-- lib/hamlit/hamlit.su
 - lib/hamlit/helpers.rb
 - lib/hamlit/html.rb
 - lib/hamlit/identity.rb
@@ -319,6 +350,7 @@ files:
 - lib/hamlit/parser.rb
 - lib/hamlit/parser/MIT-LICENSE
 - lib/hamlit/parser/README.md
+- lib/hamlit/parser/haml_attribute_builder.rb
 - lib/hamlit/parser/haml_buffer.rb
 - lib/hamlit/parser/haml_compiler.rb
 - lib/hamlit/parser/haml_error.rb
@@ -333,6 +365,7 @@ files:
 - lib/hamlit/ruby_expression.rb
 - lib/hamlit/string_splitter.rb
 - lib/hamlit/template.rb
+- lib/hamlit/temple_line_counter.rb
 - lib/hamlit/utils.rb
 - lib/hamlit/version.rb
 homepage: https://github.com/k0kubun/hamlit
@@ -354,7 +387,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: High Performance Haml Implementation