slim 1.3.0 → 1.3.2

data/Rakefile

@@ -11,24 +11,26 @@ task :bench, :iterations, :slow do
   ruby('benchmarks/run-benchmarks.rb')
 end
 
-task 'test' => %w(test:core test:logic_less test:translator)
+task 'test' => %w(test:core_and_plugins)
 
 namespace 'test' do
+  task 'core_and_plugins' => %w(core logic_less translator)
+
   Rake::TestTask.new('core') do |t|
-    t.libs << 'lib' << 'test/slim'
-    t.test_files = FileList['test/slim/test_*.rb']
+    t.libs << 'lib' << 'test/core'
+    t.test_files = FileList['test/core/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.libs << 'lib' << 'test/core'
+    t.test_files = FileList['test/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.libs << 'lib' << 'test/core'
+    t.test_files = FileList['test/translator/test_*.rb']
     t.verbose = true
   end
 
@@ -38,8 +40,18 @@ namespace 'test' do
     t.verbose = true
   end
 
-  task 'ci' do |t|
-    Rake::Task[ENV['TASK']].execute
+  begin
+    require 'sinatra'
+    spec = Gem::Specification.find_by_name('sinatra')
+    Rake::TestTask.new('sinatra') do |t|
+      # Run Slim integration test in Sinatra
+      t.test_files = FileList["#{spec.gem_dir}/test/slim_test.rb"]
+      t.verbose = true
+    end
+  rescue LoadError
+    task :sinatra do
+      abort 'Sinatra is not available'
+    end
   end
 end
 

data/lib/slim.rb

@@ -1,12 +1,12 @@
-# encoding: utf-8
-
 require 'temple'
 require 'slim/parser'
 require 'slim/filter'
 require 'slim/end_inserter'
 require 'slim/embedded_engine'
 require 'slim/interpolation'
-require 'slim/compiler'
+require 'slim/control_structures'
+require 'slim/splat_attributes'
+require 'slim/boolean_attributes'
 require 'slim/engine'
 require 'slim/template'
 require 'slim/version'

data/lib/slim/boolean_attributes.rb

@@ -0,0 +1,67 @@
+module Slim
+  # @api private
+  class BooleanAttributes < Filter
+    define_options :attr_delimiter
+
+    # Handle attributes expression `[:html, :attrs, *attrs]`
+    #
+    # @param [Array] attrs Array of temple expressions
+    # @return [Array] Compiled temple expression
+    def on_html_attrs(*attrs)
+      [:multi, *attrs.map {|a| compile(a) }]
+    end
+
+    # Handle attribute expression `[:slim, :attr, escape, code]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @return [Array] Compiled temple expression
+    def on_html_attr(name, value)
+      unless value[0] == :slim && value[1] == :attrvalue
+        @attr = name
+        return super
+      end
+
+      escape, code = value[2], value[3]
+      case code
+      when 'true'
+        [:html, :attr, name, [:static, name]]
+      when 'false', 'nil'
+        [:multi]
+      else
+        tmp = unique_name
+        conds = [:case, tmp,
+                 ['true', [:html, :attr, name, [:static, name]]],
+                 ['false, nil', [:multi]]]
+        if delimiter = options[:attr_delimiter][name]
+          conds << ['Array',
+                    [:multi,
+                     [:code, "#{tmp} = #{tmp}.flatten.compact.join(#{delimiter.inspect})"],
+                     [:if, "!#{tmp}.empty?",
+                      [:html, :attr, name, [:escape, escape, [:dynamic, tmp]]]]]]
+        end
+        conds << [:else, [:html, :attr, name, [:escape, escape, [:dynamic, tmp]]]]
+        [:multi, [:code, "#{tmp} = (#{code})"], conds]
+      end
+    end
+
+    # Handle attribute expression `[:slim, :attrvalue, escape, code]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @return [Array] Compiled temple expression
+    def on_slim_attrvalue(escape, code)
+      tmp = unique_name
+      [:multi,
+       [:code, "#{tmp} = #{code}"],
+       [:escape, escape,
+        [:dynamic,
+         if delimiter = options[:attr_delimiter][@attr]
+           "Array === #{tmp} ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"
+         else
+           tmp
+         end
+        ]]]
+    end
+  end
+end

data/lib/slim/command.rb

@@ -3,6 +3,10 @@ require 'slim/translator'
 require 'optparse'
 
 module Slim
+  Engine.set_default_options :logic_less => false,
+                             :pretty => false,
+                             :tr => false
+
   # Slim commandline interface
   # @api private
   class Command
@@ -29,32 +33,38 @@ module Slim
 
     # Configure OptionParser
     def set_opts(opts)
-      opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
+      opts.on('-s', '--stdin', 'Read input from standard input instead of an input file') do
         @options[:input] = $stdin
       end
 
-      opts.on('--trace', :NONE, 'Show a full traceback on error') do
+      opts.on('--trace', 'Show a full traceback on error') do
         @options[:trace] = true
       end
 
-      opts.on('-c', '--compile', :NONE, 'Compile only but do not run') do
+      opts.on('-c', '--compile', 'Compile only but do not run') do
+        @options[:compile] = true
+      end
+
+      opts.on('-r', '--rails', 'Generate rails compatible code (Implies --compile)') do
+        Engine.set_default_options :disable_capture => true, :generator => Temple::Generators::RailsOutputBuffer
         @options[:compile] = true
       end
 
-      opts.on('-r', '--rails', :NONE, 'Generate rails compatible code (combine with -c)') do
-        @options[:rails] = true
+      opts.on('-t', '--translator', 'Enable translator plugin') do
+        Engine.set_default_options :tr => true
       end
 
-      opts.on('-t', '--translator', :NONE, 'Enable translator plugin') do
-        @options[:translator] = true
+      opts.on('-l', '--logic-less', 'Enable logic less plugin') do
+        Engine.set_default_options :logic_less => true
       end
 
-      opts.on('-l', '--logic-less', :NONE, 'Enable logic-less plugin') do
-        @options[:logic_less] = true
+      opts.on('-p', '--pretty', 'Produce pretty html') do
+        Engine.set_default_options :pretty => true
       end
 
-      opts.on('-p', '--pretty', :NONE, 'Produce pretty html') do
-        @options[:pretty] = true
+      opts.on('-o', '--option [NAME=CODE]', String, 'Set slim option') do |str|
+        parts = str.split('=', 2)
+        Engine.default_options[parts.first.to_sym] = eval(parts.last)
       end
 
       opts.on_tail('-h', '--help', 'Show this message') do
@@ -88,19 +98,9 @@ module Slim
       end
 
       if @options[:compile]
-        @options[:output].puts(Slim::Engine.new(:file => @options[:file],
-                                                :pretty => @options[:pretty],
-                                                :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))
+        @options[:output].puts(Slim::Engine.new(:file => @options[:file]).call(@options[:input].read))
       else
-        @options[:output].puts(Slim::Template.new(@options[:file],
-                                                  :pretty => @options[:pretty],
-                                                  :tr => @options[:translator],
-                                                  :logic_less => @options[:logic_less]) { @options[:input].read }.render)
+        @options[:output].puts(Slim::Template.new(@options[:file]) { @options[:input].read }.render)
       end
     end
   end

data/lib/slim/control_structures.rb

@@ -0,0 +1,57 @@
+module Slim
+  # @api private
+  class ControlStructures < Filter
+    define_options :disable_capture
+
+    # Handle control expression `[:slim, :control, code, content]`
+    #
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_control(code, content)
+      [:multi,
+        [:code, code],
+        compile(content)]
+    end
+
+    # Handle output expression `[:slim, :output, escape, code, content]`
+    #
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_slim_output(escape, code, content)
+      if empty_exp?(content)
+        [:multi, [:escape, escape, [:dynamic, code]], content]
+      else
+        tmp = unique_name
+
+        [:multi,
+         # Capture the result of the code in a variable. We can't do
+         # `[:dynamic, code]` because it's probably not a complete
+         # expression (which is a requirement for Temple).
+         [:block, "#{tmp} = #{code}",
+
+          # Capture the content of a block in a separate buffer. This means
+          # that `yield` will not output the content to the current buffer,
+          # but rather return the output.
+          #
+          # The capturing can be disabled with the option :disable_capture.
+          # Output code in the block writes directly to the output buffer then.
+          # Rails handles this by replacing the output buffer for helpers.
+          options[:disable_capture] ? compile(content) : [:capture, unique_name, compile(content)]],
+
+         # Output the content.
+         [:escape, escape, [:dynamic, tmp]]]
+      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
+  end
+end

data/lib/slim/embedded_engine.rb

@@ -63,53 +63,78 @@ module Slim
   class EmbeddedEngine < Filter
     @engines = {}
 
-    class << self
-      attr_reader :engines
-
-      # Register embedded engine
-      #
-      # @param [String] name Name of the engine
-      # @param [Class]  klass Engine class
-      # @param option_filter List of options to pass to engine.
-      #                      Last argument can be default option hash.
-      def register(name, klass, *option_filter)
-        local_options = Hash === option_filter.last ? option_filter.pop : nil
-        @engines[name.to_s] = [klass, option_filter, local_options]
+    # Register embedded engine
+    #
+    # @param [String] name Name of the engine
+    # @param [Class]  klass Engine class
+    # @param option_filter List of options to pass to engine.
+    #                      Last argument can be default option hash.
+    def self.register(name, klass, *option_filter)
+      name = name.to_sym
+      local_options = option_filter.last.respond_to?(:to_hash) ? option_filter.pop.to_hash : {}
+      define_options(name, *option_filter)
+      klass.define_options(name)
+      @engines[name.to_sym] = proc do |options|
+        klass.new({}.update(options).delete_if {|k,v| !option_filter.include?(k) && k != name }.update(local_options))
       end
     end
 
+    def self.create(name, options)
+      constructor = @engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
+      constructor.call(options)
+    end
+
+    define_options :enable_engines, :disable_engines
+
+    def initialize(opts = {})
+      super
+      @engines = {}
+      @enabled = normalize_engine_list(options[:enable_engines])
+      @disabled = normalize_engine_list(options[:disable_engines])
+    end
+
     def on_slim_embedded(name, body)
-      name = name.to_s
-      raise "Embedded engine #{name} is disabled" if (options[:enable_engines] && !options[:enable_engines].include?(name)) ||
-                                                     (options[:disable_engines] && options[:disable_engines].include?(name))
-      engine, option_filter, local_options = self.class.engines[name] || raise("Embedded engine #{name} not found")
-      filtered_options = Hash[*option_filter.select {|k| options.include?(k) }.map {|k| [k, options[k]] }.flatten]
-      engine.new(Temple::ImmutableHash.new(local_options, filtered_options)).on_slim_embedded(name, body)
+      name = name.to_sym
+      raise(Temple::FilterError, "Embedded engine #{name} is disabled") unless enabled?(name)
+      @engines[name] ||= self.class.create(name, options)
+      @engines[name].on_slim_embedded(name, body)
+    end
+
+    def enabled?(name)
+      (!@enabled || @enabled.include?(name)) &&
+        (!@disabled || !@disabled.include?(name))
     end
 
     protected
 
-    def collect_text(body)
-      @text_collector ||= TextCollector.new
-      @text_collector.call(body)
+    def normalize_engine_list(list)
+      raise(ArgumentError, "Option :enable_engines/:disable_engines must be String or Symbol list") unless !list || Array === list
+      list ? list.map {|s| s.to_sym } : list
     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)), collect_newlines(body)]
-      end
-
+    class Engine < Filter
       protected
 
+      def collect_text(body)
+        @text_collector ||= TextCollector.new
+        @text_collector.call(body)
+      end
+
       def collect_newlines(body)
         @newline_collector ||= NewlineCollector.new
         @newline_collector.call(body)
       end
     end
 
+    # Basic tilt engine
+    class TiltEngine < Engine
+      def on_slim_embedded(engine, body)
+        tilt_engine = Tilt[engine] || raise(Temple::FilterError, "Tilt engine #{engine} is not available.")
+        tilt_options = options[engine.to_sym] || {}
+        [:multi, tilt_render(tilt_engine, tilt_options, collect_text(body)), collect_newlines(body)]
+      end
+    end
+
     # Tilt-based static template (evaluated at compile-time)
     class StaticTiltEngine < TiltEngine
       protected
@@ -121,11 +146,14 @@ module Slim
 
     # Sass engine which supports :pretty option
     class SassEngine < TiltEngine
+      define_options :pretty
+
       protected
 
       def tilt_render(tilt_engine, tilt_options, text)
         text = tilt_engine.new(tilt_options.merge(
-          :style => (options[:pretty] ? :expanded : :compressed), :cache => false)) { text }.render
+          :style => options[:pretty] ? :expanded : :compressed,
+          :cache => false)) { text }.render
         text.chomp!
         [:static, options[:pretty] ? "\n#{text}\n" : text]
       end
@@ -136,7 +164,7 @@ module Slim
       protected
 
       def tilt_render(tilt_engine, tilt_options, text)
-        # WARNING: This is a bit of a hack. Tilt::Engine#precompiled is protected
+        # HACK: Tilt::Engine#precompiled is protected
         [:dynamic, tilt_engine.new(tilt_options) { text }.send(:precompiled, {}).first]
       end
     end
@@ -163,7 +191,7 @@ module Slim
     end
 
     # ERB engine (uses the Temple ERB implementation)
-    class ERBEngine < EmbeddedEngine
+    class ERBEngine < Engine
       def on_slim_embedded(engine, body)
         [:multi, [:newline], erb_parser.call(collect_text(body))]
       end
@@ -177,15 +205,24 @@ module Slim
 
     # Tag wrapper engine
     # Generates a html tag and wraps another engine (specified via :engine option)
-    class TagEngine < EmbeddedEngine
+    class TagEngine < Engine
+      disable_option_validator!
+
       def on_slim_embedded(engine, body)
-        content = options[:engine] ? options[:engine].new(options).on_slim_embedded(engine, body) : body
-        [:html, :tag, options[:tag], [:html, :attrs, *options[:attributes].map {|k, v| [:html, :attr, k, [:static, v]] }], content]
+        if options[:engine]
+          opts = {}.update(options)
+          opts.delete(:engine)
+          opts.delete(:tag)
+          opts.delete(:attributes)
+          @engine ||= options[:engine].new(opts)
+          body = @engine.on_slim_embedded(engine, body)
+        end
+        [:html, :tag, options[:tag], [:html, :attrs, *options[:attributes].map {|k, v| [:html, :attr, k, [:static, v]] }], body]
       end
     end
 
     # Embeds ruby code
-    class RubyEngine < EmbeddedEngine
+    class RubyEngine < Engine
       def on_slim_embedded(engine, body)
         [:multi, [:newline], [:code, collect_text(body)]]
       end
@@ -200,11 +237,11 @@ module Slim
     register :mediawiki,  InterpolateTiltEngine
 
     # These engines are executed at compile time
-    register :coffee,     TagEngine,  :tag => :script, :attributes => { :type => 'text/javascript' },  :engine => StaticTiltEngine
-    register :less,       TagEngine,  :tag => :style,  :attributes => { :type => 'text/css' },         :engine => StaticTiltEngine
-    register :styl,       TagEngine,  :tag => :style,  :attributes => { :type => 'text/css' },         :engine => StaticTiltEngine
-    register :sass,       TagEngine,  :pretty, :tag => :style, :attributes => { :type => 'text/css' }, :engine => SassEngine
-    register :scss,       TagEngine,  :pretty, :tag => :style, :attributes => { :type => 'text/css' }, :engine => SassEngine
+    register :coffee,     TagEngine, :tag => :script, :attributes => { :type => 'text/javascript' },  :engine => StaticTiltEngine
+    register :less,       TagEngine, :tag => :style,  :attributes => { :type => 'text/css' },         :engine => StaticTiltEngine
+    register :styl,       TagEngine, :tag => :style,  :attributes => { :type => 'text/css' },         :engine => StaticTiltEngine
+    register :sass,       TagEngine, :pretty, :tag => :style, :attributes => { :type => 'text/css' }, :engine => SassEngine
+    register :scss,       TagEngine, :pretty, :tag => :style, :attributes => { :type => 'text/css' }, :engine => SassEngine
 
     # These engines are precompiled, code is embedded
     register :erb,        ERBEngine
@@ -212,8 +249,8 @@ module Slim
     register :builder,    PrecompiledTiltEngine
 
     # Embedded javascript/css
-    register :javascript, TagEngine,  :tag => :script, :attributes => { :type => 'text/javascript' }
-    register :css,        TagEngine,  :tag => :style,  :attributes => { :type => 'text/css' }
+    register :javascript, TagEngine, :tag => :script, :attributes => { :type => 'text/javascript' }
+    register :css,        TagEngine, :tag => :style,  :attributes => { :type => 'text/css' }
 
     # Embedded ruby code
     register :ruby,       RubyEngine