hamlit 1.6.7 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed569855be3cfd062957586173c438777bbad1bf
-  data.tar.gz: cb9f5d24e5290a801e38a9c1558e01e18dfd2c8b
+  metadata.gz: ca12e0120f1176a67b7f89077b8f00b832cafe16
+  data.tar.gz: fe98fcc635527e47b22441eadb3409bbd4c5864e
 SHA512:
-  metadata.gz: c599f0dcbac927f422137f528949f4ee6111a3f8104caf062e7abe1e23dc861f8ba4f3aae4119bf4dc72b2b5d86265250e7d7dd1d8a967d1d0d887fa2f04c98c
-  data.tar.gz: 8f53b9e6279a35eb5430846173017b09a3b88350b8c29c8f113c2bef31735524760ea9b19e8a12d185f7b35df5fd8e4a3b5938af6f8a705ca71d9259c3be260e
+  metadata.gz: f233e410357f3812775992bcfc6da6bfc27f6ed2b4153f60f050c34df4221084711da794ca22da329ae4665d43a2c9d1f700528038381bbd5ab56d9959b5658f
+  data.tar.gz: 200d020c6ed62d628aeeb03634b71f842f9d5ff245a4a6205b820b5293124fd622a766e843371fd7755096c185d8962c226463ffa796525cc354405aa18684d0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## v1.7.0
+
+- Support Ruby 2.2.0 hash syntax
+  - like `{ "hyphened-key": "value" }`
+
 ## v1.6.7
 
 - Remove unused variables and avoid shadowing

data/benchmarks/benchmark.rb

@@ -12,22 +12,15 @@ require 'slim'
 require 'hamlit'
 
 class Benchmarks
-  def initialize(time)
+  def initialize(time, escape_enabled)
     @time     = time
     @benches  = []
     @versions = {}
-  end
 
-  def init_compiled_benches(escape_enabled)
+    init_compiled_benches(escape_enabled)
     if escape_enabled
-      @erb_code  = File.read(File.dirname(__FILE__) + '/view.erb')
-      @haml_code = File.read(File.dirname(__FILE__) + '/view.haml')
-      @slim_code = File.read(File.dirname(__FILE__) + '/view.escaped.slim')
       init_escaped_benches
     else
-      @erb_code  = File.read(File.dirname(__FILE__) + '/view.erb')
-      @haml_code = File.read(File.dirname(__FILE__) + '/view.haml')
-      @slim_code = File.read(File.dirname(__FILE__) + '/view.slim')
       init_plain_benches
     end
   end
@@ -45,11 +38,26 @@ class Benchmarks
 
   private
 
+  def init_compiled_benches(escape_enabled)
+    slim_path  = "/view#{'.escaped' if escape_enabled}.slim"
+    @erb_code  = File.read(File.dirname(__FILE__) + '/view.erb')
+    @haml_code = File.read(File.dirname(__FILE__) + '/view.haml')
+    @slim_code = File.read(File.dirname(__FILE__) + slim_path)
+  end
+
   # Totally the same as slim-template/slim's compiled bench.
   def init_plain_benches
     puts 'Compiled rendering benchmarks without HTML escape'
     context = Context.new
+    define_plain_methods!(context)
+
+    bench('hamlit', Hamlit::VERSION) { context.run_hamlit }
+    bench('erubis', Erubis::VERSION) { context.run_erubis }
+    bench('slim', Slim::VERSION)     { context.run_slim_ugly }
+    bench('haml', Haml::VERSION)     { context.run_haml_ugly }
+  end
 
+  def define_plain_methods!(context)
     haml_ugly = Haml::Engine.new(@haml_code, format: :html5, ugly: true)
     haml_ugly.def_method(context, :run_haml_ugly)
     context.instance_eval %{
@@ -57,19 +65,23 @@ class Benchmarks
       def run_slim_ugly; #{Slim::Engine.new.call @slim_code}; end
       def run_hamlit; #{Hamlit::Engine.new(escape_html: false).call @haml_code}; end
     }
-
-    bench('hamlit', Hamlit::VERSION) { context.run_hamlit }
-    bench('erubis', Erubis::VERSION) { context.run_erubis }
-    bench('slim', Slim::VERSION)     { context.run_slim_ugly }
-    bench('haml', Haml::VERSION)     { context.run_haml_ugly }
   end
 
   # slim-template/slim's compiled bench with HTML escaping.
   def init_escaped_benches
     puts 'Compiled rendering benchmarks with HTML escape'
     context = Context.new
-    context.instance_eval("def header; '<script>'; end")
+    define_escaped_methods!(context)
+
+    bench('hamlit', Hamlit::VERSION) { context.run_hamlit }
+    bench('slim', Slim::VERSION)     { context.run_slim_ugly }
+    bench('faml', Faml::VERSION)     { context.run_faml }
+    bench('erubis', Erubis::VERSION) { context.run_erubis }
+    bench('haml', Haml::VERSION)     { context.run_haml_ugly }
+  end
 
+  def define_escaped_methods!(context)
+    context.instance_eval("def header; '<script>'; end")
     haml_ugly = Haml::Engine.new(@haml_code, format: :html5, ugly: true, escape_html: true)
     haml_ugly.def_method(context, :run_haml_ugly)
     context.instance_eval %{
@@ -78,12 +90,6 @@ class Benchmarks
       def run_faml; #{Faml::Engine.new.call @haml_code}; end
       def run_hamlit; #{Hamlit::Engine.new.call @haml_code}; end
     }
-
-    bench('hamlit', Hamlit::VERSION) { context.run_hamlit }
-    bench('slim', Slim::VERSION)     { context.run_slim_ugly }
-    bench('faml', Faml::VERSION)     { context.run_faml }
-    bench('erubis', Erubis::VERSION) { context.run_erubis }
-    bench('haml', Haml::VERSION)     { context.run_haml_ugly }
   end
 
   def bench(name, version, &block)
@@ -100,6 +106,5 @@ class Benchmarks
 end
 
 time = (ENV['TIME'] || 5).to_i
-bench = Benchmarks.new(time)
-bench.init_compiled_benches(ENV['HTML_ESCAPE'])
+bench = Benchmarks.new(time, ENV['HTML_ESCAPE'] == '1')
 bench.run

data/lib/hamlit/attribute.rb

@@ -57,18 +57,22 @@ module Hamlit
       target = flatten_attributes(target)
 
       (base.keys | target.keys).each do |key|
-        if base[key] && target[key]
-          case key
-          when :id
-            result[key] = [base[key], target[key]].compact.join('_')
-          when :class
-            result[key] = [base[key], target[key]].flatten.compact.map(&:to_s).sort.uniq.join(' ')
-          end
-        else
-          result[key] = base[key].nil? ? target[key] : base[key]
-        end
+        result[key] = merge_attribute_value(base, target, key)
       end
       result
     end
+
+    def merge_attribute_value(base, target, key)
+      return target[key] unless base[key]
+      return base[key]   unless target[key]
+
+      values = [base[key], target[key]].flatten.compact
+      case key
+      when :id
+        values.join('_')
+      when :class
+        values.map(&:to_s).sort.uniq.join(' ')
+      end
+    end
   end
 end

data/lib/hamlit/compilers/old_attribute.rb

@@ -31,6 +31,27 @@ module Hamlit
                            itemscope allowfullscreen default inert sortable
                            truespeed typemustmatch data].freeze
 
+      DEFAULT_COUNTS = {
+        brace:  -1,
+        emb:     0,
+        paren:   0,
+        bracket: 0,
+      }.freeze
+
+      OPEN_TOKEN_TYPES = {
+        on_lbrace:      :brace,
+        on_embexpr_beg: :emb,
+        on_lparen:      :paren,
+        on_lbracket:    :bracket,
+      }.freeze
+
+      CLOSE_TOKEN_TYPES = {
+        on_rbrace:      :brace,
+        on_embexpr_end: :emb,
+        on_rparen:      :paren,
+        on_rbracket:    :bracket,
+      }.freeze
+
       def compile_old_attribute(str)
         raise RuntimeBuild unless valid_hash?(str)
 
@@ -99,16 +120,9 @@ module Hamlit
         attributes = {}
 
         split_hash(str).each do |attr|
-          tokens = Ripper.lex("{#{attr}")
-          tokens = tokens.drop(1)
-
+          tokens = Ripper.lex("{#{attr}").drop(1)
           key = read_hash_key!(tokens)
-          val = tokens.map(&:last).join.strip
-
-          skip_tokens!(tokens, :on_sp)
-          if type_of(tokens.first) == :on_lbrace
-            val = parse_old_attributes(val)
-          end
+          val = read_hash_value!(tokens)
 
           attributes[key] = val if key
         end
@@ -116,6 +130,16 @@ module Hamlit
         attributes
       end
 
+      def read_hash_value!(tokens)
+        skip_tokens!(tokens, :on_sp)
+        val = tokens.map(&:last).join.strip
+
+        if type_of(tokens.first) == :on_lbrace
+          val = parse_old_attributes(val)
+        end
+        val
+      end
+
       def read_hash_key!(tokens)
         skip_tokens!(tokens, :on_sp)
 
@@ -131,17 +155,21 @@ module Hamlit
           end
           assert_rocket!(tokens)
         when :on_tstring_beg
-          str = read_string!(tokens)
-          assert_rocket!(tokens)
+          str = read_string!(tokens, assert_rocket: true)
         end
         str
       end
 
-      def read_string!(tokens)
+      def read_string!(tokens, assert_rocket: false)
         _, type, str = tokens.shift
         return '' if type == :on_tstring_end
 
-        raise SyntaxError if type_of(tokens.shift) != :on_tstring_end
+        next_token = tokens.shift
+        return str if RUBY_VERSION >= "2.2.0" && type_of(next_token) == :on_label_end
+
+        raise SyntaxError if type_of(next_token) != :on_tstring_end
+        assert_rocket!(tokens) if assert_rocket
+
         str
       end
 
@@ -168,40 +196,26 @@ module Hamlit
 
       def reject_nested_columns(str, columns)
         result = []
-        open_count = 0
-        count = {
-          emb:     0,
-          paren:   0,
-          bracket: 0,
-        }
+        counts = DEFAULT_COUNTS.dup
 
         Ripper.lex(str).each do |(_, col), type, _|
-          if columns.include?(col) && open_count == 1 && count.values.all?(&:zero?)
+          if columns.include?(col) && counts.values.all?(&:zero?)
             result << col
           end
-
-          case type
-          when :on_lbrace
-            open_count += 1
-          when :on_rbrace
-            open_count -= 1
-          when :on_embexpr_beg
-            count[:emb] += 1
-          when :on_embexpr_end
-            count[:emb] -= 1
-          when :on_lparen
-            count[:paren] += 1
-          when :on_rparen
-            count[:paren] -= 1
-          when :on_lbracket
-            count[:bracket] += 1
-          when :on_rbracket
-            count[:bracket] -= 1
-          end
+          update_open_counts(counts, type)
         end
         result
       end
 
+      def update_open_counts(counts, type)
+        case
+        when OPEN_TOKEN_TYPES[type]
+          counts[OPEN_TOKEN_TYPES[type]] += 1
+        when CLOSE_TOKEN_TYPES[type]
+          counts[CLOSE_TOKEN_TYPES[type]] -= 1
+        end
+      end
+
       class HashParser < Ripper
         attr_reader :columns
 

data/lib/hamlit/concerns/string_interpolation.rb

@@ -2,7 +2,13 @@ module Hamlit
   module Concerns
     module StringInterpolation
       def string_literal(str)
-        unescape_interpolation(str)
+        res = ''
+        rest = handle_interpolation(str.inspect) do |scan|
+          escapes = (scan[2].size - 1) / 2
+          res << scan.matched[0...-3 - escapes]
+          res << (escapes.odd? ? '#{' : unescape_interpolation(scan))
+        end
+        res + rest
       end
 
       def contains_interpolation?(str)
@@ -11,19 +17,9 @@ module Hamlit
 
       private
 
-      def unescape_interpolation(str)
-        res = ''
-        rest = handle_interpolation(str.inspect) do |scan|
-          escapes = (scan[2].size - 1) / 2
-          res << scan.matched[0...-3 - escapes]
-          if escapes % 2 == 1
-            res << '#{'
-          else
-            content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
-            res << '#{' + content + '}'
-          end
-        end
-        res + rest
+      def unescape_interpolation(scan)
+        content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
+        '#{' + content + '}'
       end
 
       def handle_interpolation(str)
@@ -34,15 +30,19 @@ module Hamlit
 
       def balance(scanner, start, finish, count = 0)
         str = ''
-        scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
-        regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
-        while scanner.scan(regexp)
+        while balanced_scan(scanner, start, finish)
           str << scanner.matched
           count += 1 if scanner.matched[-1] == start
           count -= 1 if scanner.matched[-1] == finish
           return [str.strip, scanner.rest] if count == 0
         end
       end
+
+      def balanced_scan(scanner, start, finish)
+        regexp  = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+        scanner = StringScanner.new(scanner) unless scanner.is_a?(StringScanner)
+        scanner.scan(regexp)
+      end
     end
   end
 end

data/lib/hamlit/filters/base.rb

@@ -39,6 +39,31 @@ module Hamlit
         end
         lines
       end
+
+      def compile_html(tag, lines)
+        ast = [:haml, :text, compile_lines(lines, indent_width: 2), false]
+        ast = [:multi, [:static, "\n"], ast]
+        ast = [:html, :tag, tag, [:html, :attrs], ast]
+        ast
+      end
+
+      def compile_xhtml(tag, type, lines)
+        attr  = [:html, :attr, 'type', [:static, type]]
+        attrs = [:html, :attrs, attr]
+
+        content = [:haml, :text, compile_lines(lines, indent_width: 4)]
+        multi = [:multi, [:static, "\n"], *cdata_for(type, content)]
+        [:html, :tag, tag, attrs, multi]
+      end
+
+      def cdata_for(type, ast)
+        case type
+        when 'text/javascript'
+          [[:static, "  //<![CDATA[\n"], ast, [:static, "  //]]>\n"]]
+        when 'text/css'
+          [[:static, "  /*<![CDATA[*/\n"], ast, [:static, "  /*]]>*/\n"]]
+        end
+      end
     end
   end
 end

data/lib/hamlit/filters/css.rb

@@ -4,30 +4,11 @@ module Hamlit
   module Filters
     class Css < Base
       def compile(lines)
-        return compile_xhtml(lines) if options[:format] == :xhtml
+        if options[:format] == :xhtml
+          return compile_xhtml('style', 'text/css', lines)
+        end
 
-        compile_html(lines)
-      end
-
-      private
-
-      def compile_html(lines)
-        ast = [:haml, :text, compile_lines(lines, indent_width: 2), false]
-        ast = [:multi, [:static, "\n"], ast]
-        ast = [:html, :tag, 'style', [:html, :attrs], ast]
-        ast
-      end
-
-      def compile_xhtml(lines)
-        attr  = [:html, :attr, 'type', [:static, 'text/css']]
-        attrs = [:html, :attrs, attr]
-
-        multi = [:multi, [:static, "\n"]]
-        multi << [:static, "  /*<![CDATA[*/\n"]
-        multi << [:haml, :text, compile_lines(lines, indent_width: 4)]
-        multi << [:static, "  /*]]>*/\n"]
-
-        [:html, :tag, 'style', attrs, multi]
+        compile_html('style', lines)
       end
     end
   end

data/lib/hamlit/filters/javascript.rb

@@ -4,30 +4,11 @@ module Hamlit
   module Filters
     class Javascript < Base
       def compile(lines)
-        return compile_xhtml(lines) if options[:format] == :xhtml
+        if options[:format] == :xhtml
+          return compile_xhtml('script', 'text/javascript', lines)
+        end
 
-        compile_html(lines)
-      end
-
-      private
-
-      def compile_html(lines)
-        ast = [:haml, :text, compile_lines(lines, indent_width: 2), false]
-        ast = [:multi, [:static, "\n"], ast]
-        ast = [:html, :tag, 'script', [:html, :attrs], ast]
-        ast
-      end
-
-      def compile_xhtml(lines)
-        attr  = [:html, :attr, 'type', [:static, 'text/javascript']]
-        attrs = [:html, :attrs, attr]
-
-        multi = [:multi, [:static, "\n"]]
-        multi << [:static, "  //<![CDATA[\n"]
-        multi << [:haml, :text, compile_lines(lines, indent_width: 4)]
-        multi << [:static, "  //]]>\n"]
-
-        [:html, :tag, 'script', attrs, multi]
+        compile_html('script', lines)
       end
     end
   end

data/lib/hamlit/version.rb

@@ -1,3 +1,3 @@
 module Hamlit
-  VERSION = "1.6.7"
+  VERSION = "1.7.0"
 end

data/spec/hamlit/engine/old_attributes_spec.rb

@@ -371,5 +371,26 @@ describe Hamlit::Engine do
         HTML
       end
     end
+
+    if RUBY_VERSION >= "2.2.0"
+      describe 'Ruby 2.2 syntax' do
+        it 'renders static attributes' do
+          assert_render(<<-HAML, <<-HTML)
+            %meta{ content: 'IE=edge', 'http-equiv': 'X-UA-Compatible' }
+          HAML
+            <meta content='IE=edge' http-equiv='X-UA-Compatible'>
+          HTML
+        end
+
+        it 'renders dynamic attributes' do
+          assert_render(<<-HAML, <<-HTML)
+            - hash = { content: 'IE=edge' }
+            %meta{ hash, 'http-equiv': 'X-UA-Compatible' }
+          HAML
+            <meta content='IE=edge' http-equiv='X-UA-Compatible'>
+          HTML
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hamlit
 version: !ruby/object:Gem::Version
-  version: 1.6.7
+  version: 1.7.0
 platform: ruby
 authors:
 - Takashi Kokubun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-27 00:00:00.000000000 Z
+date: 2015-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: escape_utils
@@ -626,4 +626,3 @@ test_files:
 - spec/spec_helper/document_generator.rb
 - spec/spec_helper/render_helper.rb
 - spec/spec_helper/test_case.rb
-has_rdoc: