temple 0.6.10 → 0.7.1

data/test/filters/test_escapable.rb

@@ -32,14 +32,16 @@ describe Temple::Filters::Escapable do
   end
 
   it 'should have use_html_safe option' do
-    filter = Temple::Filters::Escapable.new(:use_html_safe => true)
-    filter.call([:escape, true,
-      [:static, Temple::HTML::SafeString.new("a < b")]
-    ]).should.equal [:static, "a < b"]
+    with_html_safe do
+      filter = Temple::Filters::Escapable.new(use_html_safe: true)
+      filter.call([:escape, true,
+        [:static, Temple::HTML::SafeString.new("a < b")]
+      ]).should.equal [:static, "a < b"]
+    end
   end
 
   it 'should support censoring' do
-    filter = Temple::Filters::Escapable.new(:escape_code => '(%s).gsub("Temple sucks", "Temple rocks")')
+    filter = Temple::Filters::Escapable.new(escape_code: '(%s).gsub("Temple sucks", "Temple rocks")')
     filter.call([:escape, true,
       [:static, "~~ Temple sucks ~~"]
     ]).should.equal [:static, "~~ Temple rocks ~~"]

data/test/filters/test_static_freezer.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+describe Temple::Filters::StaticFreezer do
+  if RUBY_VERSION >= '2.1'
+    it 'should freeze static on new ruby' do
+      filter = Temple::Filters::StaticFreezer.new
+      filter.call([:static, 'hi']).should.equal [:dynamic, '"hi".freeze']
+    end
+  else
+    it 'should not freeze static on old ruby' do
+      filter = Temple::Filters::StaticFreezer.new
+      filter.call([:static, 'hi']).should.equal [:static, 'hi']
+    end
+  end
+
+  it 'should freeze static if free_static==true' do
+    filter = Temple::Filters::StaticFreezer.new(freeze_static: true)
+    filter.call([:static, 'hi']).should.equal [:dynamic, '"hi".freeze']
+  end
+
+  it 'should not freeze static if free_static==false' do
+    filter = Temple::Filters::StaticFreezer.new(freeze_static: false)
+    filter.call([:static, 'hi']).should.equal [:static, 'hi']
+  end
+end

data/test/html/test_attribute_sorter.rb

@@ -3,7 +3,7 @@ require 'helper'
 describe Temple::HTML::AttributeSorter do
   before do
     @ordered   = Temple::HTML::AttributeSorter.new
-    @unordered = Temple::HTML::AttributeSorter.new :sort_attrs => false
+    @unordered = Temple::HTML::AttributeSorter.new sort_attrs: false
   end
 
   it 'should sort html attributes by name by default, when :sort_attrs is true' do

data/test/html/test_fast.rb

@@ -21,15 +21,15 @@ describe Temple::HTML::Fast do
   end
 
   it 'should compile js wrapped in comments' do
-    Temple::HTML::Fast.new(:js_wrapper => nil).call([:html, :js, [:static, 'test']]).should.equal [:static, "test"]
-    Temple::HTML::Fast.new(:js_wrapper => :comment).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
-    Temple::HTML::Fast.new(:js_wrapper => :cdata).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(:js_wrapper => :both).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]]
+    Temple::HTML::Fast.new(js_wrapper: nil).call([:html, :js, [:static, 'test']]).should.equal [:static, "test"]
+    Temple::HTML::Fast.new(js_wrapper: :comment).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+    Temple::HTML::Fast.new(js_wrapper: :cdata).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
+    Temple::HTML::Fast.new(js_wrapper: :both).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n//-->"]]
   end
 
   it 'should guess default js comment' do
-    Temple::HTML::Fast.new(:js_wrapper => :guess, :format => :xhtml).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
-    Temple::HTML::Fast.new(:js_wrapper => :guess, :format => :html).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
+    Temple::HTML::Fast.new(js_wrapper: :guess, format: :xhtml).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "\n//<![CDATA[\n"], [:static, "test"], [:static, "\n//]]>\n"]]
+    Temple::HTML::Fast.new(js_wrapper: :guess, format: :html).call([:html, :js, [:static, 'test']]).should.equal [:multi, [:static, "<!--\n"], [:static, "test"], [:static, "\n//-->"]]
   end
 
   it 'should compile autoclosed html tag' do

data/test/html/test_pretty.rb

@@ -20,10 +20,7 @@ describe Temple::HTML::Pretty do
                        [:static, ">"],
                        [:multi,
                         [:static, "\n    text"],
-                        [:multi,
-                         [:code, "_temple_html_pretty2 = (code).to_s"],
-                         [:code, "if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty2 = _temple_html_pretty2.gsub(\"\\n\", \"\\n    \"); end"],
-                         [:dynamic, "_temple_html_pretty2"]]],
+                        [:dynamic, "::Temple::Utils.indent_dynamic((code), false, \"\\n    \", _temple_html_pretty1)"]],
                        [:static, "\n  </p>"]],
                       [:static, "\n</div>"]]]
   end
@@ -52,10 +49,7 @@ describe Temple::HTML::Pretty do
         [:dynamic, '"text<".html_safe']
       ).should.equal [:multi,
                       [:code, "_temple_html_pretty1 = /<code|<pre|<textarea/"],
-                      [:multi,
-                       [:code, "_temple_html_pretty2 = (\"text<\".html_safe).to_s"],
-                       [:code, "if _temple_html_pretty1 !~ _temple_html_pretty2; _temple_html_pretty3 = _temple_html_pretty2.html_safe?; _temple_html_pretty2 = _temple_html_pretty2.gsub(\"\\n\", \"\\n\"); _temple_html_pretty2 = _temple_html_pretty2.html_safe if _temple_html_pretty3; end"],
-                       [:dynamic, "_temple_html_pretty2"]]]
+                      [:dynamic, "::Temple::Utils.indent_dynamic((\"text<\".html_safe), nil, \"\\n\", _temple_html_pretty1)"]]
     end
   end
 end

data/test/test_engine.rb

@@ -19,7 +19,7 @@ class TestEngine < Temple::Engine
   end
   use :MyFilter1, proc {|exp| exp }
   use :MyFilter2, proc {|exp| exp }
-  use Temple::HTML::Pretty, :format, :pretty => true
+  use Temple::HTML::Pretty, pretty: true
   filter :MultiFlattener
   generator :ArrayBuffer
   use :BeforeLast, Callable1.new

data/test/test_erb.rb

@@ -56,7 +56,7 @@ world}
 <% end %>
 }
 
-    erb(src, :trim_mode => '>').should.equal ERB.new(src, nil, '>').result
-    erb(src, :trim_mode => '<>').should.equal ERB.new(src, nil, '<>').result
+    erb(src, trim_mode: '>').should.equal ERB.new(src, nil, '>').result
+    erb(src, trim_mode: '<>').should.equal ERB.new(src, nil, '<>').result
   end
 end

data/test/test_filter.rb

@@ -13,8 +13,8 @@ describe Temple::Filter do
     Temple::Filter.should.respond_to :default_options
     Temple::Filter.should.respond_to :set_default_options
     Temple::Filter.should.respond_to :define_options
-    Temple::Filter.new.options.should.be.instance_of Temple::ImmutableHash
-    SimpleFilter.new(:key => 3).options[:key].should.equal 3
+    Temple::Filter.new.options.should.be.instance_of Temple::ImmutableMap
+    SimpleFilter.new(key: 3).options[:key].should.equal 3
   end
 
   it 'should implement call' do

data/test/test_generator.rb

@@ -32,7 +32,7 @@ describe Temple::Generator do
   end
 
   it 'should compile multi expression' do
-    gen = SimpleGenerator.new(:buffer => "VAR")
+    gen = SimpleGenerator.new(buffer: "VAR")
     gen.call([:multi,
       [:static, "static"],
       [:dynamic, "dynamic"],
@@ -41,14 +41,14 @@ describe Temple::Generator do
   end
 
   it 'should compile capture' do
-    gen = SimpleGenerator.new(:buffer => "VAR", :capture_generator => SimpleGenerator)
+    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
     gen.call([:capture, "foo",
       [:static, "test"]
     ]).should.equal 'VAR = BUFFER; foo = BUFFER; foo << (S:test); foo; VAR'
   end
 
   it 'should compile capture with multi' do
-    gen = SimpleGenerator.new(:buffer => "VAR", :capture_generator => SimpleGenerator)
+    gen = SimpleGenerator.new(buffer: "VAR", capture_generator: SimpleGenerator)
     gen.call([:multi,
       [:static, "before"],
 
@@ -63,7 +63,7 @@ describe Temple::Generator do
   end
 
   it 'should compile newlines' do
-    gen = SimpleGenerator.new(:buffer => "VAR")
+    gen = SimpleGenerator.new(buffer: "VAR")
     gen.call([:multi,
       [:static, "static"],
       [:newline],

data/test/test_map.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+describe Temple::ImmutableMap do
+  it 'has read accessor' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    hash[:a].should.equal 1
+    hash[:b].should.equal 2
+  end
+
+  it 'has include?' do
+    hash = Temple::ImmutableMap.new({a: 1},{b: 2, a: 3})
+    hash.should.include :a
+    hash.should.include :b
+    hash.should.not.include :c
+  end
+
+  it 'has values' do
+    Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).values.sort.should.equal [1,2]
+  end
+
+  it 'has keys' do
+    Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).keys.should.equal [:a,:b]
+  end
+
+  it 'has to_a' do
+    Temple::ImmutableMap.new({a: 1},{b: 2, a: 3}).to_a.should.equal [[:a, 1], [:b, 2]]
+  end
+end
+
+describe Temple::MutableMap do
+  it 'has write accessor' do
+    parent = {a: 1}
+    hash = Temple::MutableMap.new(parent)
+    hash[:a].should.equal 1
+    hash[:a] = 2
+    hash[:a].should.equal 2
+    parent[:a].should.equal 1
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: temple
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.7.1
 platform: ruby
 authors:
 - Magnus Holm
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-27 00:00:00.000000000 Z
+date: 2014-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
@@ -86,6 +86,7 @@ files:
 - lib/temple/filters/escapable.rb
 - lib/temple/filters/multi_flattener.rb
 - lib/temple/filters/remove_bom.rb
+- lib/temple/filters/static_freezer.rb
 - lib/temple/filters/static_merger.rb
 - lib/temple/filters/validator.rb
 - lib/temple/generator.rb
@@ -95,7 +96,6 @@ files:
 - lib/temple/generators/rails_output_buffer.rb
 - lib/temple/generators/string_buffer.rb
 - lib/temple/grammar.rb
-- lib/temple/hash.rb
 - lib/temple/html/attribute_merger.rb
 - lib/temple/html/attribute_remover.rb
 - lib/temple/html/attribute_sorter.rb
@@ -104,6 +104,7 @@ files:
 - lib/temple/html/filter.rb
 - lib/temple/html/pretty.rb
 - lib/temple/html/safe.rb
+- lib/temple/map.rb
 - lib/temple/mixins/dispatcher.rb
 - lib/temple/mixins/engine_dsl.rb
 - lib/temple/mixins/grammar_dsl.rb
@@ -122,6 +123,7 @@ files:
 - test/filters/test_eraser.rb
 - test/filters/test_escapable.rb
 - test/filters/test_multi_flattener.rb
+- test/filters/test_static_freezer.rb
 - test/filters/test_static_merger.rb
 - test/helper.rb
 - test/html/test_attribute_merger.rb
@@ -136,7 +138,7 @@ files:
 - test/test_filter.rb
 - test/test_generator.rb
 - test/test_grammar.rb
-- test/test_hash.rb
+- test/test_map.rb
 - test/test_utils.rb
 homepage: https://github.com/judofyr/temple
 licenses:
@@ -150,7 +152,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/temple/hash.rb

@@ -1,105 +0,0 @@
-module Temple
-  # Immutable hash class which supports hash merging
-  # @api public
-  class ImmutableHash
-    include Enumerable
-
-    def initialize(*hash)
-      @hash = hash.compact
-    end
-
-    def include?(key)
-      @hash.any? {|h| h.include?(key) }
-    end
-
-    def [](key)
-      @hash.each {|h| return h[key] if h.include?(key) }
-      nil
-    end
-
-    def each
-      keys.each {|k| yield(k, self[k]) }
-    end
-
-    def keys
-      @hash.inject([]) {|keys, h| keys.concat(h.keys) }.uniq
-    end
-
-    def values
-      keys.map {|k| self[k] }
-    end
-
-    def to_hash
-      result = {}
-      each {|k, v| result[k] = v }
-      result
-    end
-  end
-
-  # Mutable hash class which supports hash merging
-  # @api public
-  class MutableHash < ImmutableHash
-    def initialize(*hash)
-      super({}, *hash)
-    end
-
-    def []=(key, value)
-      @hash.first[key] = value
-    end
-
-    def update(hash)
-      @hash.first.update(hash)
-    end
-  end
-
-  class OptionHash < MutableHash
-    def initialize(*hash, &block)
-      super(*hash)
-      @handler = block
-      @valid = {}
-      @deprecated = {}
-    end
-
-    def []=(key, value)
-      validate_key!(key)
-      super
-    end
-
-    def update(hash)
-      validate_hash!(hash)
-      super
-    end
-
-    def valid_keys
-      (keys + @valid.keys +
-       @hash.map {|h| h.valid_keys if h.respond_to?(:valid_keys) }.compact.flatten).uniq
-    end
-
-    def add_valid_keys(*keys)
-      keys.flatten.each { |key| @valid[key] = true }
-    end
-
-    def add_deprecated_keys(*keys)
-      keys.flatten.each { |key| @valid[key] = @deprecated[key] = true }
-    end
-
-    def validate_hash!(hash)
-      hash.to_hash.keys.each {|key| validate_key!(key) }
-    end
-
-    def validate_key!(key)
-      @handler.call(self, key, true) if deprecated_key?(key)
-      @handler.call(self, key, false) unless valid_key?(key)
-    end
-
-    def deprecated_key?(key)
-      @deprecated.include?(key) ||
-        @hash.any? {|h| h.deprecated_key?(key) if h.respond_to?(:deprecated_key?) }
-    end
-
-    def valid_key?(key)
-      include?(key) || @valid.include?(key) ||
-        @hash.any? {|h| h.valid_key?(key) if h.respond_to?(:valid_key?) }
-    end
-  end
-end

data/test/test_hash.rb

@@ -1,39 +0,0 @@
-require 'helper'
-
-describe Temple::ImmutableHash do
-  it 'has read accessor' do
-    hash = Temple::ImmutableHash.new({:a => 1},{:b => 2, :a => 3})
-    hash[:a].should.equal 1
-    hash[:b].should.equal 2
-  end
-
-  it 'has include?' do
-    hash = Temple::ImmutableHash.new({:a => 1},{:b => 2, :a => 3})
-    hash.should.include :a
-    hash.should.include :b
-    hash.should.not.include :c
-  end
-
-  it 'has values' do
-    Temple::ImmutableHash.new({:a => 1},{:b => 2, :a => 3}).values.sort.should.equal [1,2]
-  end
-
-  it 'has keys' do
-    Temple::ImmutableHash.new({:a => 1},{:b => 2, :a => 3}).keys.should.equal [:a,:b]
-  end
-
-  it 'has to_a' do
-    Temple::ImmutableHash.new({:a => 1},{:b => 2, :a => 3}).to_a.should.equal [[:a, 1], [:b, 2]]
-  end
-end
-
-describe Temple::MutableHash do
-  it 'has write accessor' do
-    parent = {:a => 1}
-    hash = Temple::MutableHash.new(parent)
-    hash[:a].should.equal 1
-    hash[:a] = 2
-    hash[:a].should.equal 2
-    parent[:a].should.equal 1
-  end
-end