RubyGems - slim - Versions diffs - 0.7.0 → 0.7.1 - Mend

slim 0.7.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

data/Gemfile.lock +3 -6
data/README.md +32 -56
data/Rakefile +2 -2
data/benchmarks/run.rb +49 -16
data/lib/slim.rb +0 -8
data/lib/slim/compiler.rb +17 -26
data/lib/slim/embedded_engine.rb +18 -11
data/lib/slim/end_inserter.rb +10 -11
data/lib/slim/engine.rb +8 -3
data/lib/slim/filter.rb +8 -37
data/lib/slim/parser.rb +27 -25
data/lib/slim/template.rb +2 -31
data/lib/slim/version.rb +1 -1
data/slim.gemspec +1 -2
data/test/helper.rb +35 -8
data/test/slim/test_code_blocks.rb +37 -2
data/test/slim/test_code_escaping.rb +2 -2
data/test/slim/test_code_evaluation.rb +31 -9
data/test/slim/test_code_output.rb +9 -1
data/test/slim/test_code_structure.rb +23 -13
data/test/slim/test_html_structure.rb +32 -8
data/test/slim/test_parser_errors.rb +2 -2
data/test/slim/test_ruby_errors.rb +28 -0
metadata +25 -42
data/lib/slim/helpers.rb +0 -81
data/test/slim/test_code_helpers.rb +0 -30

data/Gemfile.lock CHANGED

@@ -2,8 +2,7 @@ PATH
   remote: .
   specs:
     slim (0.7.0)
-      escape_utils (>= 0.1.9)
-      temple (~> 0.1.3)
+      temple (~> 0.1.4)
       tilt (~> 1.1)
 GEM
@@ -12,14 +11,13 @@ GEM
     abstract (1.0.0)
     erubis (2.6.6)
       abstract (>= 1.0.0)
-    escape_utils (0.1.9)
     haml (3.0.22)
     liquid (2.2.2)
     minitest (1.7.2)
     rake (0.8.7)
     rcov (0.9.9)
     rdiscount (1.6.5)
-    temple (0.1.3)
+    temple (0.1.4)
     tilt (1.1)
     yard (0.6.1)
@@ -28,7 +26,6 @@ PLATFORMS
 DEPENDENCIES
   erubis
-  escape_utils (>= 0.1.9)
   haml
   liquid
   minitest
@@ -36,6 +33,6 @@ DEPENDENCIES
   rcov
   rdiscount
   slim!
-  temple (~> 0.1.3)
+  temple (~> 0.1.4)
   tilt (~> 1.1)
   yard

data/README.md CHANGED

@@ -5,7 +5,7 @@ Slim is a template language whose goal is to reduce the view syntax to the essen
 ## What?
-Slim is a fast, lightweight templating engine with support for __Rails 3__. It has been tested on Ruby 1.9.2 and Ruby/REE 1.8.7.
+Slim is a fast, lightweight templating engine with support for __Rails 3__. It has been tested on Ruby 1.9.2 and Ruby/REE 1.8.7.
 Slim's core syntax is guided by one thought: "What's the minimum required to make this work".
@@ -15,10 +15,11 @@ Slim uses [Temple](http://github.com/judofyr/temple) for parsing/compilation and
 ## Why?
-Within the Rails community, _Erb_ and _Haml_ are without doubt the two most popular templating engines. However, _Erb_'s syntax is cumbersome and Haml's performance isn't exactly the best.
+Within the Rails community, _Erb_ and _Haml_ are without doubt the two most popular templating engines. However, _Erb_'s syntax is cumbersome and _Haml_'s performance isn't exactly the best.
-Slim was born to bring a minimalist syntax approach with speed.  If people chose not to use Slim, it would not be because of speed.  ___Yes, Slim is speedy!___ Benchmarks are provided at the end of this README file. Alternatively, a benchmark rake task is provided so you could test it yourself (`rake bench`).
+Slim was born to bring a minimalist syntax approach with speed. If people chose not to use Slim, it would not be because of speed.
+___Yes, Slim is speedy!___ Benchmarks are provided at the end of this README file. Alternatively, a benchmark rake task is provided so you could test it yourself (`rake bench`).
 ## How?
@@ -28,13 +29,9 @@ Install Slim as a gem:
 Include Slim in your Gemfile:
-    gem 'slim'
+    gem 'slim', require: 'slim/rails'
-In `config/application.rb`, add the following line near the top (i.e. just below `require 'rails/all'`):
-    require 'slim/rails'
-That's it!
+That's it! Now, just use the .slim extension and you're good to go.
 If you want to use the Slim template directly, you can use the Tilt interface:
@@ -122,7 +119,7 @@ __Please note that all line indicators must be followed by a space__
 ### Things to know
 #### Standard Ruby syntax after `-` and `=`
-  `end` is not required but can be used if you don't want to omit it
+  `end` is forbidden behind `-`. Blocks are defined only by indentation.
 #### Can put content on same line or nest it.
   If you nest content (e.g. put it on the next line), start the line with a pipe (`|`) or a backtick (`` ` ``).
@@ -267,56 +264,29 @@ __Please note that all line indicators must be followed by a space__
     <body><p></p></body>
 ## Benchmarks
     # OS X 10.6 + Ruby 1.9.2
-                               user     system      total        real
-    erb                    0.410000   0.010000   0.420000 (  0.421608)
-    erubis                 0.350000   0.000000   0.350000 (  0.357187)
-    fast erubis            0.340000   0.000000   0.340000 (  0.351943)
-    slim                   2.360000   0.020000   2.380000 (  2.495331)
-    haml                   2.970000   0.010000   2.980000 (  3.023121)
-    haml ugly              2.870000   0.010000   2.880000 (  2.968662)
-    erb (cached)           0.150000   0.000000   0.150000 (  0.149980)
-    erubis (cached)        0.120000   0.000000   0.120000 (  0.122935)
-    fast erubis (cached)   0.100000   0.000000   0.100000 (  0.105832)
-    slim (cached)          0.020000   0.000000   0.020000 (  0.020290)
-    haml (cached)          0.330000   0.000000   0.330000 (  0.335519)
-    haml ugly (cached)     0.280000   0.000000   0.280000 (  0.286695)
-    # OS X 10.6 + REE 1.8.7
-                               user     system      total        real
-    erb                    0.440000   0.010000   0.450000 (  0.463941)
-    erubis                 0.310000   0.000000   0.310000 (  0.322083)
-    fast erubis            0.310000   0.000000   0.310000 (  0.309852)
-    slim                   2.420000   0.020000   2.440000 (  2.470208)
-    haml                   2.990000   0.020000   3.010000 (  3.040942)
-    haml ugly              2.900000   0.020000   2.920000 (  3.101786)
-    erb (cached)           0.080000   0.000000   0.080000 (  0.079252)
-    erubis (cached)        0.070000   0.000000   0.070000 (  0.066370)
-    fast erubis (cached)   0.060000   0.000000   0.060000 (  0.062001)
-    slim (cached)          0.030000   0.000000   0.030000 (  0.023835)
-    haml (cached)          0.270000   0.010000   0.280000 (  0.279409)
-    haml ugly (cached)     0.210000   0.000000   0.210000 (  0.221059)
-    # OSX 10.6 + JRuby 1.5.3
-                               user     system      total        real
-    erb                    0.970000   0.000000   0.970000 (  0.970000)
-    erubis                 0.672000   0.000000   0.672000 (  0.672000)
-    fast erubis            0.624000   0.000000   0.624000 (  0.624000)
-    slim                   2.694000   0.000000   2.694000 (  2.694000)
-    haml                   3.368000   0.000000   3.368000 (  3.368000)
-    haml ugly              3.462000   0.000000   3.462000 (  3.462000)
-    erb (cached)           0.736000   0.000000   0.736000 (  0.736000)
-    erubis (cached)        0.413000   0.000000   0.413000 (  0.413000)
-    fast erubis (cached)   0.340000   0.000000   0.340000 (  0.340000)
-    slim (cached)          0.069000   0.000000   0.069000 (  0.069000)
-    haml (cached)          1.001000   0.000000   1.001000 (  1.001000)
-    haml ugly (cached)     0.763000   0.000000   0.763000 (  0.763000)
+                                 user     system      total        real
+    erb                      2.200000   0.020000   2.220000 (  2.259262)
+    erubis                   1.870000   0.010000   1.880000 (  1.895547)
+    fast erubis              1.870000   0.010000   1.880000 (  1.887996)
+    slim                    10.380000   0.080000  10.460000 ( 10.543296)
+    haml                    16.250000   0.070000  16.320000 ( 16.376137)
+    haml ugly               15.700000   0.080000  15.780000 ( 15.869233)
+    erb (compiled)           0.820000   0.010000   0.830000 (  0.821538)
+    erubis (compiled)        0.680000   0.000000   0.680000 (  0.680444)
+    fast erubis (compiled)   0.600000   0.010000   0.610000 (  0.605370)
+    slim (compiled)          0.180000   0.000000   0.180000 (  0.182536)
+    haml (compiled)          1.800000   0.020000   1.820000 (  1.863224)
+    haml ugly (compiled)     1.560000   0.020000   1.580000 (  1.602106)
+    erb (cached)             0.120000   0.000000   0.120000 (  0.127988)
+    erubis (cached)          0.110000   0.000000   0.110000 (  0.115064)
+    fast erubis (cached)     0.120000   0.010000   0.130000 (  0.122645)
+    slim (cached)            0.140000   0.000000   0.140000 (  0.134598)
+    haml (cached)            0.660000   0.000000   0.660000 (  0.661025)
+    haml ugly (cached)       0.590000   0.010000   0.600000 (  0.602522)
 ## Authors
@@ -327,3 +297,9 @@ __Please note that all line indicators must be followed by a space__
 ## Discuss
 [Google Group](http://groups.google.com/group/slim-template)
+## Slim related projects
+* [Textmate bundle](http://github.com/fredwu/ruby-slim-textmate-bundle)
+* [Rails 3 Generators](http://github.com/leogalmeida/slim-rails)
+* [Slim for Clojure](http://github.com/chaslemley/slim.clj)

data/Rakefile CHANGED

@@ -7,8 +7,8 @@ end
 require 'rake/testtask'
 desc 'Run Slim benchmarks! (Default :iterations is 1000)'
-task :bench, :iterations do |t, args|
-  ruby("benchmarks/run.rb #{args[:iterations]}")
+task :bench, :iterations, :slow do |t, args|
+  ruby("benchmarks/run.rb #{args[:slow]} #{args[:iterations]}")
 end
 Rake::TestTask.new(:test) do |t|

data/benchmarks/run.rb CHANGED

@@ -12,7 +12,7 @@ require 'erb'
 require 'haml'
 class SlimBenchmarks
-  def initialize(iterations)
+  def initialize(slow, iterations)
     @iterations = (iterations || 1000).to_i
     @benches    = []
@@ -26,22 +26,41 @@ class SlimBenchmarks
     erb         = ERB.new(tpl_erb)
     erubis      = Erubis::Eruby.new(tpl_erb)
     fast_erubis = Erubis::FastEruby.new(tpl_erb)
-    haml        = Haml::Engine.new(tpl_haml)
-    haml_ugly   = Haml::Engine.new(tpl_haml, :ugly => true)
+    haml        = Haml::Engine.new(tpl_haml, :format => :html5)
+    haml_ugly   = Haml::Engine.new(tpl_haml, :format => :html5, :ugly => true)
     slim        = Slim::Template.new { tpl_slim }
-    bench('erb')                  { ERB.new(tpl_erb).result(eview) }
-    bench('erubis')               { Erubis::Eruby.new(tpl_erb).result(eview) }
-    bench('fast erubis')          { Erubis::Eruby.new(tpl_erb).result(eview) }
-    bench('slim')                 { Slim::Template.new { tpl_slim }.render(view) }
-    bench('haml')                 { Haml::Engine.new(tpl_haml).render(view) }
-    bench('haml ugly')            { Haml::Engine.new(tpl_haml, :ugly => true).render(view) }
-    bench('erb (cached)')         { erb.result(eview) }
-    bench('erubis (cached)')      { erubis.result(eview) }
-    bench('fast erubis (cached)') { fast_erubis.result(eview) }
-    bench('slim (cached)')        { slim.render(view) }
-    bench('haml (cached)')        { haml.render(view) }
-    bench('haml ugly (cached)')   { haml_ugly.render(view) }
+    haml.def_method(view, :run_haml)
+    haml_ugly.def_method(view, :run_haml_ugly)
+    view.instance_eval %{
+      def run_erb; #{erb.src}; end
+      def run_erubis; #{erubis.src}; end
+      def run_fast_erubis; #{fast_erubis.src}; end
+      def run_slim; #{slim.precompiled_template}; end
+    }
+    if slow
+      bench('erb (1)')         { ERB.new(tpl_erb).result(eview) }
+      bench('erubis (1)')      { Erubis::Eruby.new(tpl_erb).result(eview) }
+      bench('fast erubis (1)') { Erubis::Eruby.new(tpl_erb).result(eview) }
+      bench('slim (1)')        { Slim::Template.new { tpl_slim }.render(view) }
+      bench('haml (1)')        { Haml::Engine.new(tpl_haml, :format => :html5).render(view) }
+      bench('haml ugly (1)')   { Haml::Engine.new(tpl_haml, :format => :html5, :ugly => true).render(view) }
+    end
+    bench('erb (2)')         { erb.result(eview) }
+    bench('erubis (2)')      { erubis.result(eview) }
+    bench('fast (2)')        { fast_erubis.result(eview) }
+    bench('slim (2)')        { slim.render(view) }
+    bench('haml (2)')        { haml.render(view) }
+    bench('haml (2)')        { haml_ugly.render(view) }
+    bench('erb (3)')         { view.run_erb }
+    bench('erubis (3)')      { view.run_erubis }
+    bench('fast erubis (3)') { view.run_fast_erubis }
+    bench('slim (3)')        { view.run_slim }
+    bench('haml (3)')        { view.run_haml }
+    bench('haml ugly (3)')   { view.run_haml_ugly }
   end
   def run
@@ -53,6 +72,20 @@ class SlimBenchmarks
         end
       end
     end
+    puts "
+1. Uncached benchmark. Template is parsed every time.
+   Activate this benchmark with slow=1.
+2. Cached benchmark. Template is parsed before the benchmark.
+   The ruby code generated by the template engine might be evaluated every time.
+   This benchmark uses the standard API of the template engine.
+3. Compiled benchmark. Template is parsed before the benchmark and
+   generated ruby code is compiled into a method.
+   This is the fastest evaluation strategy because it benchmarks
+   pure execution speed of the generated ruby code.
+"
   end
   def bench(name, &block)
@@ -60,4 +93,4 @@ class SlimBenchmarks
   end
 end
-SlimBenchmarks.new(ARGV[0]).run
+SlimBenchmarks.new(ARGV[0], ARGV[1]).run

data/lib/slim.rb CHANGED

@@ -1,9 +1,6 @@
 # encoding: utf-8
 require 'temple'
-require 'tilt'
-require 'slim/helpers'
 require 'slim/parser'
 require 'slim/filter'
 require 'slim/end_inserter'
@@ -13,11 +10,6 @@ require 'slim/engine'
 require 'slim/template'
 require 'slim/version'
-begin
-  require 'escape_utils'
-rescue LoadError
-end
 module Slim
   def self.version
     VERSION

data/lib/slim/compiler.rb CHANGED

@@ -6,7 +6,7 @@ module Slim
     #
     # @param [String] string Static text
     # @return [Array] Compiled temple expression
-    def on_text(string)
+    def on_slim_text(string)
       # Interpolate variables in text (#{variable}).
       # Split the text into multiple dynamic and static parts.
       block = [:multi]
@@ -17,7 +17,7 @@ module Slim
           block << [:static, $1]
         when /^\#\{([^\}]*)\}/
           # Interpolation
-          block << [:dynamic, escape_code($1)]
+          block << [:escape, :dynamic, $1]
         when /^([^\#]+|\#)/
           # Static text
           block << [:static, $&]
@@ -32,10 +32,10 @@ module Slim
     # @param [String] ruby code
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_control(code, content)
+    def on_slim_control(code, content)
       [:multi,
         [:block, code],
-        compile(content)]
+        compile!(content)]
     end
     # Handle output expression `[:slim, :output, escape, code, content]`
@@ -44,11 +44,11 @@ module Slim
     # @param [String] code Ruby code
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_output(escape, code, content)
+    def on_slim_output(escape, code, content)
       if empty_exp?(content)
-        [:multi, [:dynamic, escape ? escape_code(code) : code], content]
+        [:multi, escape ? [:escape, :dynamic, code] : [:dynamic, code], content]
       else
-        on_output_block(escape, code, content)
+        on_slim_output_block(escape, code, content)
       end
     end
@@ -59,7 +59,7 @@ module Slim
     # @param [String] code Ruby code
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_output_block(escape, code, content)
+    def on_slim_output_block(escape, code, content)
       tmp1, tmp2 = tmp_var, tmp_var
       [:multi,
@@ -72,7 +72,7 @@ module Slim
         # that `yield` will not output the content to the current buffer,
         # but rather return the output.
         [:capture, tmp2,
-         compile(content)],
+         compile!(content)],
         # Make sure that `yield` returns the output.
         [:block, tmp2],
@@ -81,14 +81,14 @@ module Slim
         [:block, 'end'],
         # Output the content.
-        on_output(escape, tmp1, [:multi])]
+        on_slim_output(escape, tmp1, [:multi])]
     end
     # Handle directive expression `[:slim, :directive, type]`
     #
     # @param [String] type Directive type
     # @return [Array] Compiled temple expression
-    def on_directive(type)
+    def on_slim_directive(type)
       if type =~ /^doctype/
         [:html, :doctype, $'.strip]
       end
@@ -100,29 +100,20 @@ module Slim
     # @param [Array] attrs Attributes
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_tag(name, attrs, content)
-      attrs = attrs.inject([:html, :attrs]) do |m, (key, dynamic, value)|
+    def on_slim_tag(name, attrs, closed, content)
+      attrs = attrs.inject([:html, :staticattrs]) do |m, (key, dynamic, value)|
         value = if dynamic
-                  [:dynamic, escape_code(value)]
+                  [:escape, :dynamic, value]
                 else
-                  on_text(value)
+                  on_slim_text(value)
                 end
-        m << [:html, :basicattr, [:static, key.to_s], value]
+        m << [key.to_s, value]
       end
-      [:html, :tag, name, attrs, compile(content)]
+      [:html, :tag, name, attrs, closed, compile!(content)]
     end
     private
-    # Generate code to escape html
-    #
-    # @param [String] param Ruby code
-    # @return [String] Ruby code
-    def escape_code(param)
-      "Slim::Helpers.escape_html#{@options[:use_html_safe] ? '_safe' : ''}((#{param}))"
-    end
     # Generate unique temporary variable name
     #
     # @return [String] Variable name

data/lib/slim/embedded_engine.rb CHANGED

@@ -14,8 +14,8 @@ module Slim
       engine.dup
     end
-    def on_embedded(engine, *body)
-      EmbeddedEngine[engine].on_embedded(engine, *body)
+    def on_slim_embedded(engine, *body)
+      EmbeddedEngine[engine].on_slim_embedded(engine, *body)
     end
     def collect_text(body)
@@ -33,18 +33,18 @@ module Slim
       # Code to collect local variables
       COLLECT_LOCALS = %q{eval('{' + local_variables.select {|v| v[0] != ?_ }.map {|v| ":#{v}=>#{v}" }.join(',') + '}')}
-      def on_embedded(engine, *body)
+      def on_slim_embedded(engine, *body)
         text = collect_text(body)
         engine = Tilt[engine]
-        if @options[:precompiled]
+        if options[:precompiled]
           # Wrap precompiled code in proc, local variables from out the proc are accessible
           # WARNING: This is a bit of a hack. Tilt::Engine#precompiled is protected
           precompiled = engine.new { text }.send(:precompiled, {}).first
           [:dynamic, "proc { #{precompiled} }.call"]
-        elsif @options[:dynamic]
+        elsif options[:dynamic]
           # Fully dynamic evaluation of the template during runtime (Slow and uncached)
           [:dynamic, "#{engine.name}.new { #{text.inspect} }.render(self, #{COLLECT_LOCALS})"]
-        elsif @options[:interpolate]
+        elsif options[:interpolate]
           # Static template with interpolated ruby code
           [:slim, :text, engine.new { text }.render]
         else
@@ -54,15 +54,22 @@ module Slim
       end
     end
+    class ERBEngine < EmbeddedEngine
+      def on_slim_embedded(engine, *body)
+        text = collect_text(body)
+        Temple::ERB::Parser.new(:auto_escape => true).compile(text)
+      end
+    end
     class TagEngine < EmbeddedEngine
-      def on_embedded(engine, *body)
-        content = @options[:engine] ? @options[:engine].new.on_embedded(engine, *body) : [:multi, *body]
-        [:slim, :tag, @options[:tag], @options[:attributes].map {|k, v| [k, false, v ] }, content]
+      def on_slim_embedded(engine, *body)
+        content = options[:engine] ? options[:engine].new.on_slim_embedded(engine, *body) : [:multi, *body]
+        [:slim, :tag, options[:tag], options[:attributes].map {|k, v| [k, false, v] }, false, content]
       end
     end
     class RubyEngine < EmbeddedEngine
-      def on_embedded(engine, *body)
+      def on_slim_embedded(engine, *body)
         [:block, collect_text(body)]
       end
     end
@@ -79,7 +86,7 @@ module Slim
     register :less, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
     # These engines are precompiled, code is embedded
-    register :erb, TiltEngine, :precompiled => true
+    register :erb, ERBEngine
     register :haml, TiltEngine, :precompiled => true
     register :nokogiri, TiltEngine, :precompiled => true
     register :builder, TiltEngine, :precompiled => true