hamlit 2.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7782d0478a595899a7218a798f2e3448fe454b62
-  data.tar.gz: 44b82b3aa85549836524a284a1fed4744efb7042
+  metadata.gz: 17985d049789075f9ccaa498376e506980a85eba
+  data.tar.gz: 31d451aa5c850358ab1c752ab8bb670666b5a8fe
 SHA512:
-  metadata.gz: 29045e0c90085d396ee564b06607abf72c318ba0c4864e4930eba7a747ee8ad218bf879d5175cc7fc3ff0044bfb61e53377ee5e7d2201bc586164cbfd4adfdd4
-  data.tar.gz: bdd6e4cdcbdb9e82225890a075a73a4b82303e8dba72c166d9ab771924d1b63fedc0f4c7ffea8c45d1ca56b20d8c624debe2760fc1cf35459874c796c8ee332f
+  metadata.gz: 2c7a0f41cc218efdfd399363b6c00cdee940b864056208ffb4f02207c0579e8eda75f6f2d77f0bef4fceb3570e79d4ae7b34544d00c1805ece39295b85c7e35b
+  data.tar.gz: 3065e24a52cc9ad34854ac0d3b4d17353fae2acdc2dd50d5a1c5b5cf4754a4137866be58c9e01b1a3d762644930384076c9d98648ac2bc00cc143147e8425627

data/.travis.yml

@@ -14,6 +14,8 @@ matrix:
       env: TASK=test
     - rvm: 2.2
       env: TASK=test
+    - rvm: ruby-head
+      env: TASK=test
     - rvm: 2.2
       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.2

data/CHANGELOG.md

@@ -4,33 +4,40 @@ 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.2.0](https://github.com/k0kubun/hamlit/compare/v2.1.2...v2.2.0) - 2015-12-24
+
+### Added
+
+- Optimize inline script inside a tag
+- Optimize string interpolation recursively
+
 ## [2.1.2](https://github.com/k0kubun/hamlit/compare/v2.1.1...v2.1.2) - 2015-12-16
 
-## Fixed
+### Fixed
 
 - Fix rendering failure for static integer
   [#50](https://github.com/k0kubun/hamlit/pull/50). *Thanks to @yatmsu*
 
 ## [2.1.1](https://github.com/k0kubun/hamlit/compare/v2.1.0...v2.1.1) - 2015-12-15
 
-## Fixed
+### Fixed
 
 - Use faster HTML-escape method for compiling
 - Show proper line number for unbalanced brackets error
 
 ## [2.1.0](https://github.com/k0kubun/hamlit/compare/v2.0.2...v2.1.0) - 2015-12-14
 
-## Added
+### Added
 
 - `-I` and `-r` options are added to `hamlit render` command
   [#37](https://github.com/k0kubun/hamlit/issues/37). *Thanks to @jhurliman*
 
-## Changed
+### Changed
 
 - Dropped obsolete `escape_utils` gem dependency
   [#48](https://github.com/k0kubun/hamlit/pull/48). *Thanks to @eagletmt*
 
-## Fixed
+### Fixed
 
 - Accept NUL character in attribute keys
   [#49](https://github.com/k0kubun/hamlit/pull/49). *Thanks to @eagletmt*

data/Rakefile

@@ -1,3 +1,4 @@
+require 'bundler/setup'
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 require 'rake/extensiontask'

data/lib/hamlit/attribute_compiler.rb

@@ -0,0 +1,123 @@
+require 'hamlit/attribute_builder'
+require 'hamlit/attribute_parser'
+require 'hamlit/ruby_expression'
+require 'hamlit/static_analyzer'
+
+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, @quote, @format].map(&: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'.freeze
+          compile_id!(temple, key, values)
+        when 'class'.freeze
+          compile_class!(temple, key, values)
+        when 'data'.freeze
+          compile_data!(temple, key, values)
+        when *AttributeBuilder::BOOLEAN_ATTRIBUTES, /\Adata-/
+          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 || 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 || 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, values.map { |v| literal_for(v) }]
+      build_code = "::Hamlit::AttributeBuilder.build_data(#{args.join(', ')})"
+
+      if values.all? { |type, exp| type == :static || 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 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, [:escape, @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}"], [:escape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
+        ]
+      end
+    end
+
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:escape, @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 : exp
+    end
+  end
+end

data/lib/hamlit/compiler/script_compiler.rb

@@ -1,6 +1,6 @@
 require 'hamlit/ruby_expression'
 require 'hamlit/static_analyzer'
-require 'hamlit/string_interpolation'
+require 'hamlit/string_splitter'
 
 module Hamlit
   class Compiler
@@ -10,10 +10,13 @@ module Hamlit
       end
 
       def compile(node, &block)
+        no_children = node.children.empty?
         case
-        when node.children.empty? && RubyExpression.string_literal?(node.value[:text])
-          string_compile(node)
-        when node.children.empty? && StaticAnalyzer.static?(node.value[:text])
+        when no_children && node.value[:escape_interpolation]
+          compile_interpolated_plain(node)
+        when no_children && RubyExpression.string_literal?(node.value[:text])
+          delegate_optimization(node)
+        when no_children && StaticAnalyzer.static?(node.value[:text])
           static_compile(node)
         else
           dynamic_compile(node, &block)
@@ -23,28 +26,30 @@ module Hamlit
       private
 
       # String-interpolated plain text must be compiled with this method
-      def string_compile(node)
+      # because we have to escape only interpolated values.
+      def compile_interpolated_plain(node)
         temple = [:multi]
-        StringInterpolation.compile(node.value[:text]).each do |type, value|
+        StringSplitter.compile(node.value[:text]).each do |type, value|
           case type
           when :static
-            value = Hamlit::Utils.escape_html(value) if node.value[:escape_html]
             temple << [:static, value]
           when :dynamic
-            if Hamlit::StaticAnalyzer.static?(value)
-              value = eval(value).to_s
-              value = Hamlit::Utils.escape_html(value) if node.value[:escape_html] || node.value[:escape_interpolation]
-              temple << [:static, value]
-            else
-              temple << [:escape, node.value[:escape_html] || node.value[:escape_interpolation], [:dynamic, value]]
-            end
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
           end
         end
         temple << [:newline]
       end
 
+      # :dynamic is optimized in other filter: StringSplitter
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:text]]],
+         [:newline],
+        ]
+      end
+
       def static_compile(node)
-        str = eval("(#{node.value[:text]}).to_s")
+        str = eval(node.value[:text]).to_s
         if node.value[:escape_html]
           str = Hamlit::Utils.escape_html(str)
         elsif node.value[:preserve]

data/lib/hamlit/compiler/tag_compiler.rb

@@ -1,6 +1,7 @@
 require 'hamlit/parser/haml_util'
-require 'hamlit/compiler/attribute_compiler'
-require 'hamlit/string_interpolation'
+require 'hamlit/attribute_compiler'
+require 'hamlit/static_analyzer'
+require 'hamlit/string_splitter'
 
 module Hamlit
   class Compiler
@@ -26,7 +27,9 @@ module Hamlit
         when node.value[:value].nil? && self_closing?(node)
           nil
         when node.value[:parse]
-          return compile_string(node) if RubyExpression.string_literal?(node.value[:value])
+          return compile_interpolated_plain(node) if node.value[:escape_interpolation]
+          return delegate_optimization(node) if RubyExpression.string_literal?(node.value[:value])
+          return delegate_optimization(node) if StaticAnalyzer.static?(node.value[:value])
 
           var = @identity.generate
           [:multi,
@@ -40,21 +43,23 @@ module Hamlit
         end
       end
 
-      def compile_string(node)
+      # :dynamic is optimized in other filters: StringSplitter or StaticAnalyzer
+      def delegate_optimization(node)
+        [:multi,
+         [:escape, node.value[:escape_html], [:dynamic, node.value[:value]]],
+         [:newline],
+        ]
+      end
+
+      # We should handle interpolation here to escape only interpolated values.
+      def compile_interpolated_plain(node)
         temple = [:multi]
-        StringInterpolation.compile(node.value[:value]).each do |type, value|
+        StringSplitter.compile(node.value[:value]).each do |type, value|
           case type
           when :static
-            value = Hamlit::Utils.escape_html(value) if node.value[:escape_html]
             temple << [:static, value]
           when :dynamic
-            if Hamlit::StaticAnalyzer.static?(value)
-              value = eval(value).to_s
-              value = Hamlit::Utils.escape_html(value) if node.value[:escape_html] || node.value[:escape_interpolation]
-              temple << [:static, value]
-            else
-              temple << [:escape, node.value[:escape_html] || node.value[:escape_interpolation], [:dynamic, value]]
-            end
+            temple << [:escape, node.value[:escape_interpolation], [:dynamic, value]]
           end
         end
         temple << [:newline]

data/lib/hamlit/engine.rb

@@ -3,6 +3,8 @@ require 'hamlit/parser'
 require 'hamlit/compiler'
 require 'hamlit/escapable'
 require 'hamlit/html'
+require 'hamlit/string_splitter'
+require 'hamlit/static_analyzer'
 
 module Hamlit
   class Engine < Temple::Engine
@@ -21,6 +23,8 @@ module Hamlit
     use Parser
     use Compiler
     use HTML
+    use StringSplitter
+    use StaticAnalyzer
     use Escapable
     filter :ControlFlow
     filter :MultiFlattener

data/lib/hamlit/static_analyzer.rb

@@ -1,7 +1,7 @@
 require 'hamlit/ruby_expression'
 
 module Hamlit
-  class StaticAnalyzer
+  class StaticAnalyzer < Temple::Filter
     STATIC_TOKENS = %i[
       on_tstring_beg on_tstring_end on_tstring_content
       on_embexpr_beg on_embexpr_end
@@ -25,11 +25,11 @@ module Hamlit
       =>
     ].freeze
 
-    def self.static?(exp)
-      return false if exp.nil? || exp.strip.empty?
-      return false if RubyExpression.syntax_error?(exp)
+    def self.static?(code)
+      return false if code.nil? || code.strip.empty?
+      return false if RubyExpression.syntax_error?(code)
 
-      Ripper.lex(exp).each do |(_, col), token, str|
+      Ripper.lex(code).each do |(_, col), token, str|
         case token
         when *STATIC_TOKENS
           # noop
@@ -45,5 +45,13 @@ module Hamlit
       end
       true
     end
+
+    def on_dynamic(code)
+      if StaticAnalyzer.static?(code)
+        [:static, eval(code).to_s]
+      else
+        [:dynamic, code]
+      end
+    end
   end
 end

data/lib/hamlit/string_splitter.rb

@@ -0,0 +1,88 @@
+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
+      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
+      end
+      temple
+    end
+  end
+end

data/lib/hamlit/version.rb

@@ -1,3 +1,3 @@
 module Hamlit
-  VERSION = '2.1.2'
+  VERSION = '2.2.0'
 end

metadata

@@ -1,251 +1,251 @@
 --- !ruby/object:Gem::Specification
 name: hamlit
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 2.2.0
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-16 00:00:00.000000000 Z
+date: 2015-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: temple
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.6
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   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
     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: coffee-script
   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: erubis
   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: faml
   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: less
   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: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   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: redcarpet
   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: sass
   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: slim
   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: therubyracer
   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
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: High Performance Haml Implementation
@@ -257,9 +257,9 @@ extensions:
 - ext/hamlit/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
-- .gitmodules
-- .travis.yml
+- ".gitignore"
+- ".gitmodules"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -304,13 +304,33 @@ files:
 - exe/hamlit
 - ext/hamlit/extconf.rb
 - ext/hamlit/hamlit.c
+- ext/hamlit/houdini/.gitignore
+- ext/hamlit/houdini/COPYING
+- ext/hamlit/houdini/Makefile
+- ext/hamlit/houdini/README.md
+- ext/hamlit/houdini/buffer.c
+- ext/hamlit/houdini/buffer.h
+- ext/hamlit/houdini/houdini.h
+- ext/hamlit/houdini/houdini_href_e.c
+- ext/hamlit/houdini/houdini_html_e.c
+- ext/hamlit/houdini/houdini_html_u.c
+- ext/hamlit/houdini/houdini_js_e.c
+- ext/hamlit/houdini/houdini_js_u.c
+- ext/hamlit/houdini/houdini_uri_e.c
+- ext/hamlit/houdini/houdini_uri_u.c
+- ext/hamlit/houdini/houdini_xml_e.c
+- ext/hamlit/houdini/html_unescape.gperf
+- ext/hamlit/houdini/html_unescape.h
+- ext/hamlit/houdini/tools/build_table.py
+- ext/hamlit/houdini/tools/build_tables.c
+- ext/hamlit/houdini/tools/wikipedia_table.txt
 - hamlit.gemspec
 - lib/hamlit.rb
 - lib/hamlit/attribute_builder.rb
+- lib/hamlit/attribute_compiler.rb
 - lib/hamlit/attribute_parser.rb
 - lib/hamlit/cli.rb
 - lib/hamlit/compiler.rb
-- lib/hamlit/compiler/attribute_compiler.rb
 - lib/hamlit/compiler/children_compiler.rb
 - lib/hamlit/compiler/comment_compiler.rb
 - lib/hamlit/compiler/doctype_compiler.rb
@@ -355,30 +375,10 @@ files:
 - lib/hamlit/railtie.rb
 - lib/hamlit/ruby_expression.rb
 - lib/hamlit/static_analyzer.rb
-- lib/hamlit/string_interpolation.rb
+- lib/hamlit/string_splitter.rb
 - lib/hamlit/template.rb
 - lib/hamlit/utils.rb
 - lib/hamlit/version.rb
-- ext/hamlit/houdini/.gitignore
-- ext/hamlit/houdini/COPYING
-- ext/hamlit/houdini/Makefile
-- ext/hamlit/houdini/README.md
-- ext/hamlit/houdini/buffer.c
-- ext/hamlit/houdini/buffer.h
-- ext/hamlit/houdini/houdini.h
-- ext/hamlit/houdini/houdini_href_e.c
-- ext/hamlit/houdini/houdini_html_e.c
-- ext/hamlit/houdini/houdini_html_u.c
-- ext/hamlit/houdini/houdini_js_e.c
-- ext/hamlit/houdini/houdini_js_u.c
-- ext/hamlit/houdini/houdini_uri_e.c
-- ext/hamlit/houdini/houdini_uri_u.c
-- ext/hamlit/houdini/houdini_xml_e.c
-- ext/hamlit/houdini/html_unescape.gperf
-- ext/hamlit/houdini/html_unescape.h
-- ext/hamlit/houdini/tools/build_table.py
-- ext/hamlit/houdini/tools/build_tables.c
-- ext/hamlit/houdini/tools/wikipedia_table.txt
 homepage: https://github.com/k0kubun/hamlit
 licenses:
 - MIT
@@ -389,19 +389,18 @@ 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: []
 rubyforge_project: 
-rubygems_version: 2.0.14.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: High Performance Haml Implementation
 test_files: []
-has_rdoc: 

data/lib/hamlit/compiler/attribute_compiler.rb

@@ -1,148 +0,0 @@
-require 'hamlit/attribute_builder'
-require 'hamlit/attribute_parser'
-require 'hamlit/ruby_expression'
-require 'hamlit/static_analyzer'
-require 'hamlit/string_interpolation'
-
-module Hamlit
-  class Compiler
-    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, @quote, @format].map(&: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'.freeze
-            compile_id!(temple, key, values)
-          when 'class'.freeze
-            compile_class!(temple, key, values)
-          when 'data'.freeze
-            compile_data!(temple, key, values)
-          when *AttributeBuilder::BOOLEAN_ATTRIBUTES, /\Adata-/
-            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 || 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 || 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, values.map { |v| literal_for(v) }]
-        build_code = "::Hamlit::AttributeBuilder.build_data(#{args.join(', ')})"
-
-        if values.all? { |type, exp| type == :static || 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 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, [:escape, @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}"], [:escape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
-          ]
-        end
-      end
-
-      def compile_common!(temple, key, values)
-        type, exp = values.last
-
-        case
-        when type == :dynamic && StaticAnalyzer.static?(exp)
-          temple << [:html, :attr, key, [:escape, @escape_attrs, [:static, eval(exp).to_s]]]
-        when type == :dynamic && RubyExpression.string_literal?(exp)
-          value_temple = [:multi]
-          StringInterpolation.compile(exp).each do |type, v|
-            case type
-            when :static
-              value_temple << [:escape, @escape_attrs, [:static, v]]
-            when :dynamic
-              if Hamlit::StaticAnalyzer.static?(v)
-                value_temple << [:escape, @escape_attrs, [:static, eval(v).to_s]]
-              else
-                value_temple << [:escape, @escape_attrs, [:dynamic, v]]
-              end
-            end
-          end
-          temple << [:html, :attr, key, value_temple]
-        else
-          temple << [:html, :attr, key, [:escape, @escape_attrs, [type, exp]]]
-        end
-      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 : exp
-      end
-    end
-  end
-end

data/lib/hamlit/string_interpolation.rb

@@ -1,69 +0,0 @@
-require 'ripper'
-
-module Hamlit::StringInterpolation
-  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
-    end
-  end
-end