slim 1.2.2 → 1.3.0

data/Rakefile

@@ -11,20 +11,36 @@ task :bench, :iterations, :slow do
   ruby('benchmarks/run-benchmarks.rb')
 end
 
-Rake::TestTask.new('test') do |t|
-  t.libs << 'lib' << 'test/slim'
-  t.test_files = FileList['test/slim/test_*.rb']
-  t.verbose = true
-end
+task 'test' => %w(test:core test:logic_less test:translator)
 
-Rake::TestTask.new('test:rails') do |t|
-  t.libs << 'lib'
-  t.test_files = FileList['test/rails/test/test_*.rb']
-  t.verbose = true
-end
+namespace 'test' do
+  Rake::TestTask.new('core') do |t|
+    t.libs << 'lib' << 'test/slim'
+    t.test_files = FileList['test/slim/test_*.rb']
+    t.verbose = true
+  end
+
+  Rake::TestTask.new('logic_less') do |t|
+    t.libs << 'lib' << 'test/slim'
+    t.test_files = FileList['test/slim/logic_less/test_*.rb']
+    t.verbose = true
+  end
+
+  Rake::TestTask.new('translator') do |t|
+    t.libs << 'lib' << 'test/slim'
+    t.test_files = FileList['test/slim/translator/test_*.rb']
+    t.verbose = true
+  end
 
-task 'test:ci' do |t|
-  Rake::Task[ENV['TASK']].execute
+  Rake::TestTask.new('rails') do |t|
+    t.libs << 'lib'
+    t.test_files = FileList['test/rails/test/test_*.rb']
+    t.verbose = true
+  end
+
+  task 'ci' do |t|
+    Rake::Task[ENV['TASK']].execute
+  end
 end
 
 begin

data/benchmarks/profile-render.rb

@@ -3,10 +3,10 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'), File.dirname(__FILE__))
 
 require 'slim'
-require 'complex_view'
+require 'context'
 
 content = File.read(File.dirname(__FILE__) + '/view.slim')
 slim = Slim::Template.new { content }
-view  = ComplexView.new
+context = Context.new
 
-10000.times { slim.render(view) }
+10000.times { slim.render(context) }

data/benchmarks/run-benchmarks.rb

@@ -6,6 +6,7 @@ require 'slim'
 require 'context'
 
 require 'benchmark'
+require 'tilt'
 require 'erubis'
 require 'erb'
 require 'haml'
@@ -15,63 +16,101 @@ class SlimBenchmarks
     @iterations = (iterations || 1000).to_i
     @benches    = []
 
-    tpl_erb  = File.read(File.dirname(__FILE__) + '/view.erb')
-    tpl_haml = File.read(File.dirname(__FILE__) + '/view.haml')
-    tpl_slim = File.read(File.dirname(__FILE__) + '/view.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__) + '/view.slim')
 
-    context  = Context.new
-    context_binding = context.instance_eval { binding }
+    init_compiled_benches
+    init_tilt_benches
+    init_cached_benches
+    init_parsing_benches if slow
+  end
 
-    erb         = ERB.new(tpl_erb)
-    erubis      = Erubis::Eruby.new(tpl_erb)
-    fast_erubis = Erubis::FastEruby.new(tpl_erb)
-    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 }
+  def init_compiled_benches
+    erb         = ERB.new(@erb_code)
+    erubis      = Erubis::Eruby.new(@erb_code)
+    fast_erubis = Erubis::FastEruby.new(@erb_code)
+    haml_pretty = Haml::Engine.new(@haml_code, :format => :html5)
+    haml_ugly   = Haml::Engine.new(@haml_code, :format => :html5, :ugly => true)
 
-    tilt_erb       = Tilt::ERBTemplate.new { tpl_erb }
-    tilt_erubis    = Tilt::ErubisTemplate.new { tpl_erb }
-    tilt_haml      = Tilt::HamlTemplate.new(:format => :html5){ tpl_haml }
-    tilt_haml_ugly = Tilt::HamlTemplate.new(:format => :html5, :ugly => true){ tpl_haml }
-    tilt_slim      = Slim::Template.new { tpl_slim }
+    context  = Context.new
 
-    haml.def_method(context, :run_haml)
+    haml_pretty.def_method(context, :run_haml_pretty)
     haml_ugly.def_method(context, :run_haml_ugly)
     context.instance_eval %{
       def run_erb; #{erb.src}; end
       def run_erubis; #{erubis.src}; end
+      def run_temple_erb; #{Temple::ERB::Engine.new.call @erb_code}; end
       def run_fast_erubis; #{fast_erubis.src}; end
-      def run_slim; #{slim.precompiled_template}; end
+      def run_slim_pretty; #{Slim::Engine.new(:pretty => true).call @slim_code}; end
+      def run_slim_ugly; #{Slim::Engine.new.call @slim_code}; end
     }
 
-    if slow
-      bench('(1) erb')         { ERB.new(tpl_erb).result(context_binding) }
-      bench('(1) erubis')      { Erubis::Eruby.new(tpl_erb).result(context_binding) }
-      bench('(1) fast erubis') { Erubis::Eruby.new(tpl_erb).result(context_binding) }
-      bench('(1) slim')        { Slim::Template.new { tpl_slim }.render(context) }
-      bench('(1) haml')        { Haml::Engine.new(tpl_haml, :format => :html5).render(context) }
-      bench('(1) haml ugly')   { Haml::Engine.new(tpl_haml, :format => :html5, :ugly => true).render(context) }
-    end
+    bench('(1) erb')         { context.run_erb }
+    bench('(1) erubis')      { context.run_erubis }
+    bench('(1) fast erubis') { context.run_fast_erubis }
+    bench('(1) temple erb')  { context.run_temple_erb }
+    bench('(1) slim pretty') { context.run_slim_pretty }
+    bench('(1) slim ugly')   { context.run_slim_ugly }
+    bench('(1) haml pretty') { context.run_haml_pretty }
+    bench('(1) haml ugly')   { context.run_haml_ugly }
+  end
 
-    bench('(2) erb')         { erb.result(context_binding) }
-    bench('(2) erubis')      { erubis.result(context_binding) }
-    bench('(2) fast erubis') { fast_erubis.result(context_binding) }
-    bench('(2) slim')        { slim.render(context) }
-    bench('(2) haml')        { haml.render(context) }
-    bench('(2) haml ugly')   { haml_ugly.render(context) }
-
-    bench('(3) erb')         { context.run_erb }
-    bench('(3) erubis')      { context.run_erubis }
-    bench('(3) fast erubis') { context.run_fast_erubis }
-    bench('(3) slim')        { context.run_slim }
-    bench('(3) haml')        { context.run_haml }
-    bench('(3) haml ugly')   { context.run_haml_ugly }
-
-    bench('(4) erb')       { tilt_erb.render(context) }
-    bench('(4) erubis')    { tilt_erubis.render(context) }
-    bench('(4) slim')      { tilt_slim.render(context) }
-    bench('(4) haml')      { tilt_haml.render(context) }
-    bench('(4) haml ugly') { tilt_haml_ugly.render(context) }
+  def init_tilt_benches
+    tilt_erb        = Tilt::ERBTemplate.new { @erb_code }
+    tilt_erubis     = Tilt::ErubisTemplate.new { @erb_code }
+    tilt_temple_erb = Temple::ERB::Template.new { @erb_code }
+    tilt_haml_pretty= Tilt::HamlTemplate.new(:format => :html5){ @haml_code }
+    tilt_haml_ugly  = Tilt::HamlTemplate.new(:format => :html5, :ugly => true){ @haml_code }
+    tilt_slim_pretty= Slim::Template.new(:pretty => true) { @slim_code }
+    tilt_slim_ugly  = Slim::Template.new { @slim_code }
+
+    context  = Context.new
+
+    bench('(2) erb')         { tilt_erb.render(context) }
+    bench('(2) erubis')      { tilt_erubis.render(context) }
+    bench('(2) temple erb')  { tilt_temple_erb.render(context) }
+    bench('(2) slim pretty') { tilt_slim_pretty.render(context) }
+    bench('(2) slim ugly')   { tilt_slim_ugly.render(context) }
+    bench('(2) haml pretty') { tilt_haml_pretty.render(context) }
+    bench('(2) haml ugly')   { tilt_haml_ugly.render(context) }
+  end
+
+  def init_cached_benches
+    context  = Context.new
+    context_binding = context.instance_eval { binding }
+
+    erb         = ERB.new(@erb_code)
+    erubis      = Erubis::Eruby.new(@erb_code)
+    fast_erubis = Erubis::FastEruby.new(@erb_code)
+    temple_erb  = Temple::ERB::Template.new { @erb_code }
+    haml_pretty = Haml::Engine.new(@haml_code, :format => :html5)
+    haml_ugly   = Haml::Engine.new(@haml_code, :format => :html5, :ugly => true)
+    slim_pretty = Slim::Template.new(:pretty => true) { @slim_code }
+    slim_ugly   = Slim::Template.new { @slim_code }
+
+    bench('(3) erb')         { erb.result(context_binding) }
+    bench('(3) erubis')      { erubis.result(context_binding) }
+    bench('(3) fast erubis') { fast_erubis.result(context_binding) }
+    bench('(3) temple erb')  { temple_erb.render(context) }
+    bench('(3) slim pretty') { slim_pretty.render(context) }
+    bench('(3) slim ugly')   { slim_ugly.render(context) }
+    bench('(3) haml pretty') { haml_pretty.render(context) }
+    bench('(3) haml ugly')   { haml_ugly.render(context) }
+  end
+
+  def init_parsing_benches
+    context  = Context.new
+    context_binding = context.instance_eval { binding }
+
+    bench('(4) erb')         { ERB.new(@erb_code).result(context_binding) }
+    bench('(4) erubis')      { Erubis::Eruby.new(@erb_code).result(context_binding) }
+    bench('(4) fast erubis') { Erubis::FastEruby.new(@erb_code).result(context_binding) }
+    bench('(4) temple erb')  { Temple::ERB::Template.new { @erb_code }.render(context) }
+    bench('(4) slim pretty') { Slim::Template.new(:pretty => true) { @slim_code }.render(context) }
+    bench('(4) slim ugly')   { Slim::Template.new { @slim_code }.render(context) }
+    bench('(4) haml pretty') { Haml::Engine.new(@haml_code, :format => :html5).render(context) }
+    bench('(4) haml ugly')   { Haml::Engine.new(@haml_code, :format => :html5, :ugly => true).render(context) }
   end
 
   def run
@@ -84,23 +123,26 @@ class SlimBenchmarks
       end
     end
     puts "
-1. Uncached benchmark. Template is parsed every time.
-   Activate this benchmark with 'rake bench 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.
-
-4. Compiled Tilt benchmark. Template is compiled with Tilt, which gives a more
-   accurate result of the performance in production mode in frameworks like
-   Sinatra, Ramaze and Camping. (Rails still uses its own template
-   compilation.)
-
+(1) 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.
+
+(2) Compiled Tilt benchmark. Template is compiled with Tilt, which gives a more
+    accurate result of the performance in production mode in frameworks like
+    Sinatra, Ramaze and Camping. (Rails still uses its own template
+    compilation.)
+
+(3) 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.
+
+(4) Parsing benchmark. Template is parsed every time.
+    This is not the recommended way to use the template engine
+    and Slim is not optimized for it. Activate this benchmark with 'rake bench slow=1'.
+
+Temple ERB is the ERB implementation using the Temple framework. It shows the
+overhead added by the Temple framework compared to ERB.
 "
   end
 

data/benchmarks/run-diffbench.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'), File.dirname(__FILE__))
+
+require 'slim'
+require 'context'
+require 'diffbench'
+
+content = File.read(File.dirname(__FILE__) + '/view.slim')
+engine = Slim::Engine.new
+template = Slim::Template.new { content }
+context = Context.new
+
+DiffBench.bm do
+  report("Parse") do
+    2000.times { engine.call(content) }
+  end
+  report("Render") do
+    100000.times { template.render(context) }
+  end
+end

data/bin/slimrb

@@ -3,5 +3,4 @@
 $:.unshift File.dirname(__FILE__) + '/../lib'
 require 'slim/command'
 
-cmd = Slim::Command.new(ARGV)
-cmd.run
+Slim::Command.new(ARGV).run

data/lib/slim.rb

@@ -6,9 +6,7 @@ require 'slim/filter'
 require 'slim/end_inserter'
 require 'slim/embedded_engine'
 require 'slim/interpolation'
-require 'slim/sections'
 require 'slim/compiler'
 require 'slim/engine'
 require 'slim/template'
 require 'slim/version'
-require 'slim/wrapper'

data/lib/slim/command.rb

@@ -1,4 +1,5 @@
-require 'slim'
+require 'slim/logic_less'
+require 'slim/translator'
 require 'optparse'
 
 module Slim
@@ -44,8 +45,12 @@ module Slim
         @options[:rails] = true
       end
 
-      opts.on('-S', '--sections', :NONE, 'Logic-less sections mode') do
-        @options[:sections] = true
+      opts.on('-t', '--translator', :NONE, 'Enable translator plugin') do
+        @options[:translator] = true
+      end
+
+      opts.on('-l', '--logic-less', :NONE, 'Enable logic-less plugin') do
+        @options[:logic_less] = true
       end
 
       opts.on('-p', '--pretty', :NONE, 'Produce pretty html') do
@@ -85,15 +90,17 @@ module Slim
       if @options[:compile]
         @options[:output].puts(Slim::Engine.new(:file => @options[:file],
                                                 :pretty => @options[:pretty],
-                                                :sections => @options[:sections],
+                                                :logic_less => @options[:logic_less],
                                                 :disable_capture => @options[:rails],
+                                                :tr => @options[:translator],
                                                 :generator => @options[:rails] ?
                                                 Temple::Generators::RailsOutputBuffer :
                                                 Temple::Generators::ArrayBuffer).call(@options[:input].read))
       else
         @options[:output].puts(Slim::Template.new(@options[:file],
                                                   :pretty => @options[:pretty],
-                                                  :sections => @options[:sections]) { @options[:input].read }.render)
+                                                  :tr => @options[:translator],
+                                                  :logic_less => @options[:logic_less]) { @options[:input].read }.render)
       end
     end
   end

data/lib/slim/compiler.rb

@@ -13,7 +13,7 @@ module Slim
 
     # Handle control expression `[:slim, :control, code, content]`
     #
-    # @param [String] ruby code
+    # @param [String] code Ruby code
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_control(code, content)
@@ -22,19 +22,6 @@ module Slim
         compile(content)]
     end
 
-    # Handle conditional comment expression
-    # `[:slim, :conditional_comment, conditional, content]`
-    #
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_condcomment(condition, content)
-      [:html, :comment,
-       [:multi,
-        [:static, "[#{condition}]>"],
-        compile(content),
-        [:static, '<![endif]']]]
-    end
-
     # Handle output expression `[:slim, :output, escape, code, content]`
     #
     # @param [Boolean] escape Escape html
@@ -67,6 +54,14 @@ module Slim
       end
     end
 
+    # Handle text expression `[:slim, :text, content]`
+    #
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_text(content)
+      compile(content)
+    end
+
     # Handle tag expression `[:slim, :tag, name, attrs, content]`
     #
     # @param [String] name Tag name
@@ -103,7 +98,7 @@ module Slim
 
     # Handle attributes expression `[:slim, :attrs, *attrs]`
     #
-    # @param [Array] *attrs Array of temple expressions
+    # @param [Array] attrs Array of temple expressions
     # @return [Array] Compiled temple expression
     def on_slim_attrs(*attrs)
       if attrs.any? {|attr| attr[1] == :splat}

data/lib/slim/embedded_engine.rb

@@ -1,6 +1,6 @@
 module Slim
   # @api private
-  class CollectText < Filter
+  class TextCollector < Filter
     def call(exp)
       @collected = ''
       super(exp)
@@ -14,7 +14,7 @@ module Slim
   end
 
   # @api private
-  class CollectNewlines < Filter
+  class NewlineCollector < Filter
     def call(exp)
       @collected = [:multi]
       super(exp)
@@ -28,7 +28,7 @@ module Slim
   end
 
   # @api private
-  class ProtectOutput < Filter
+  class OutputProtector < Filter
     def call(exp)
       @protect = []
       @collected = ''
@@ -87,18 +87,26 @@ module Slim
       engine.new(Temple::ImmutableHash.new(local_options, filtered_options)).on_slim_embedded(name, body)
     end
 
+    protected
+
+    def collect_text(body)
+      @text_collector ||= TextCollector.new
+      @text_collector.call(body)
+    end
+
     # Basic tilt engine
     class TiltEngine < EmbeddedEngine
       def on_slim_embedded(engine, body)
         tilt_engine = Tilt[engine] || raise("Tilt engine #{engine} is not available.")
         tilt_options = options[engine.to_sym] || {}
-        [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), CollectNewlines.new.call(body)]
+        [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), collect_newlines(body)]
       end
 
       protected
 
-      def collect_text(body)
-        CollectText.new.call(body)
+      def collect_newlines(body)
+        @newline_collector ||= NewlineCollector.new
+        @newline_collector.call(body)
       end
     end
 
@@ -135,25 +143,35 @@ module Slim
 
     # Static template with interpolated ruby code
     class InterpolateTiltEngine < TiltEngine
-      def initialize(opts = {})
-        super
-        @protect = ProtectOutput.new
-      end
-
       def collect_text(body)
-        text = Interpolation.new.call(body)
-        @protect.call(text)
+        output_protector.call(interpolation.call(body))
       end
 
       def tilt_render(tilt_engine, tilt_options, text)
-        @protect.unprotect(tilt_engine.new(tilt_options) { text }.render)
+        output_protector.unprotect(tilt_engine.new(tilt_options) { text }.render)
+      end
+
+      private
+
+      def interpolation
+        @interpolation ||= Interpolation.new
+      end
+
+      def output_protector
+        @output_protector ||= OutputProtector.new
       end
     end
 
     # ERB engine (uses the Temple ERB implementation)
     class ERBEngine < EmbeddedEngine
       def on_slim_embedded(engine, body)
-        [:multi, [:newline], Temple::ERB::Parser.new.call(CollectText.new.call(body))]
+        [:multi, [:newline], erb_parser.call(collect_text(body))]
+      end
+
+      protected
+
+      def erb_parser
+        @erb_parser ||= Temple::ERB::Parser.new
       end
     end
 
@@ -169,7 +187,7 @@ module Slim
     # Embeds ruby code
     class RubyEngine < EmbeddedEngine
       def on_slim_embedded(engine, body)
-        [:multi, [:newline], [:code, CollectText.new.call(body)]]
+        [:multi, [:newline], [:code, collect_text(body)]]
       end
     end