slim 0.9.1 → 0.9.2

data/README.md

@@ -288,24 +288,29 @@ There are two helpers you could use to validate your Slim syntax:
     # OS X 10.6 + Ruby 1.9.2, 1000 iterations
 
                           user     system      total        real
-    (1) erb           0.420000   0.000000   0.420000 (  0.429334)
-    (1) erubis        0.350000   0.000000   0.350000 (  0.356078)
-    (1) fast erubis   0.350000   0.000000   0.350000 (  0.355976)
-    (1) slim          3.300000   0.010000   3.310000 (  3.340637)
-    (1) haml          2.950000   0.000000   2.950000 (  2.970671)
-    (1) haml ugly     2.840000   0.010000   2.850000 (  2.856405)
-    (2) erb           0.150000   0.000000   0.150000 (  0.151098)
-    (2) erubis        0.130000   0.000000   0.130000 (  0.130713)
-    (2) fast erubis   0.100000   0.000000   0.100000 (  0.112199)
-    (2) slim          0.030000   0.000000   0.030000 (  0.027752)
-    (2) haml          0.320000   0.000000   0.320000 (  0.332581)
-    (2) haml ugly     0.280000   0.000000   0.280000 (  0.305250)
-    (3) erb           0.010000   0.000000   0.010000 (  0.014402)
-    (3) erubis        0.010000   0.000000   0.010000 (  0.015365)
-    (3) fast erubis   0.010000   0.000000   0.010000 (  0.012789)
-    (3) slim          0.010000   0.000000   0.010000 (  0.015583)
-    (3) haml          0.120000   0.000000   0.120000 (  0.120017)
-    (3) haml ugly     0.100000   0.010000   0.110000 (  0.117665)
+    (1) erb           0.310000   0.000000   0.310000 (  0.311769)
+    (1) erubis        0.250000   0.000000   0.250000 (  0.252026)
+    (1) fast erubis   0.250000   0.000000   0.250000 (  0.257639)
+    (1) slim          3.250000   0.040000   3.290000 (  3.282734)
+    (1) haml          2.230000   0.000000   2.230000 (  2.237396)
+    (1) haml ugly     2.160000   0.000000   2.160000 (  2.154061)
+    (2) erb           0.100000   0.000000   0.100000 (  0.107232)
+    (2) erubis        0.090000   0.000000   0.090000 (  0.087301)
+    (2) fast erubis   0.080000   0.000000   0.080000 (  0.073382)
+    (2) slim          0.020000   0.000000   0.020000 (  0.017364)
+    (2) haml          0.240000   0.010000   0.250000 (  0.234680)
+    (2) haml ugly     0.200000   0.000000   0.200000 (  0.209600)
+    (3) erb           0.010000   0.000000   0.010000 (  0.010558)
+    (3) erubis        0.010000   0.000000   0.010000 (  0.008676)
+    (3) fast erubis   0.010000   0.000000   0.010000 (  0.009134)
+    (3) slim          0.010000   0.000000   0.010000 (  0.012114)
+    (3) haml          0.090000   0.000000   0.090000 (  0.086450)
+    (3) haml ugly     0.070000   0.000000   0.070000 (  0.078825)
+    (4) erb           0.020000   0.000000   0.020000 (  0.015715)
+    (4) erubis        0.010000   0.000000   0.010000 (  0.014027)
+    (4) slim          0.020000   0.000000   0.020000 (  0.017591)
+    (4) haml          0.100000   0.000000   0.100000 (  0.098249)
+    (4) haml ugly     0.090000   0.000000   0.090000 (  0.089413)
 
     1. Uncached benchmark. Template is parsed every time.
        Activate this benchmark with slow=1.
@@ -319,6 +324,11 @@ There are two helpers you could use to validate your Slim syntax:
        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.)
+
 ## License
 
 This project is released under the MIT license.
@@ -335,6 +345,7 @@ This project is released under the MIT license.
 
 ## Slim related projects
 
+* [Vim files](https://github.com/bbommarito/vim-slim)
 * [Textmate bundle](https://github.com/fredwu/ruby-slim-textmate-bundle)
 * [Haml2Slim converter](https://github.com/fredwu/haml2slim)
 * [Rails 3 Generators](https://github.com/leogalmeida/slim-rails)

data/lib/slim/command.rb

@@ -40,6 +40,10 @@ module Slim
         @options[:compile] = true
       end
 
+      opts.on('-r', '--rails', :NONE, 'Generate rails compatible code (combine with -c)') do
+        @options[:rails] = true
+      end
+
       opts.on('-S', '--sections', :NONE, 'Logic-less sections mode') do
         @options[:sections] = true
       end
@@ -48,6 +52,10 @@ module Slim
         @options[:pretty] = true
       end
 
+      opts.on('-d', '--debug', :NONE, 'Debugging output') do
+        @options[:debug] = true
+      end
+
       opts.on_tail('-h', '--help', 'Show this message') do
         puts opts
         exit
@@ -81,10 +89,16 @@ module Slim
       if @options[:compile]
         @options[:output].puts(Slim::Engine.new(:file => @options[:file],
                                                 :pretty => @options[:pretty],
-                                                :sections => @options[:sections]).compile(@options[:input].read))
+                                                :sections => @options[:sections],
+                                                :disable_capture => @options[:rails],
+                                                :debug => @options[:debug],
+                                                :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],
+                                                  :debug => @options[:debug],
                                                   :sections => @options[:sections]) { @options[:input].read }.render)
       end
     end

data/lib/slim/compiler.rb

@@ -12,7 +12,7 @@ module Slim
     def on_slim_control(code, content)
       [:multi,
         [:block, code],
-        compile!(content)]
+        compile(content)]
     end
 
     # Handle comment expression `[:slim, :comment, content]`
@@ -20,7 +20,7 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_comment(content)
-      [:html, :comment, compile!(content)]
+      [:html, :comment, compile(content)]
     end
 
     # Handle output expression `[:slim, :output, escape, code, content]`
@@ -31,7 +31,7 @@ module Slim
     # @return [Array] Compiled temple expression
     def on_slim_output(escape, code, content)
       if empty_exp?(content)
-        [:multi, escape && options[:auto_escape] ? [:escape, :dynamic, code] : [:dynamic, code], content]
+        [:multi, [:escape, escape && options[:auto_escape], [:dynamic, code]], content]
       else
         on_slim_output_block(escape, code, content)
       end
@@ -45,7 +45,7 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_output_block(escape, code, content)
-      tmp = tmp_var('capture')
+      tmp = tmp_var(:output)
 
       [:multi,
         # Capture the result of the code in a variable. We can't do
@@ -60,7 +60,7 @@ module Slim
         # 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 (with_output_buffer - braindead!).
-        options[:disable_capture] ? compile!(content) : [:capture, tmp_var('capture'), compile!(content)],
+        options[:disable_capture] ? compile(content) : [:capture, tmp_var(:output), compile(content)],
 
         # Close the block.
         [:block, 'end'],
@@ -74,8 +74,11 @@ module Slim
     # @param [String] type Directive type
     # @return [Array] Compiled temple expression
     def on_slim_directive(type, args)
-      if type == 'doctype'
+      case type
+      when 'doctype'
         [:html, :doctype, args]
+      else
+        raise "Invalid directive #{type}"
       end
     end
 
@@ -86,7 +89,7 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_tag(name, attrs, closed, content)
-      [:html, :tag, name, compile!(attrs), closed, compile!(content)]
+      [:html, :tag, name, compile(attrs), closed, compile(content)]
     end
 
     # Handle tag attributes expression `[:slim, :attrs, *attrs]`
@@ -94,7 +97,7 @@ module Slim
     # @param [Array] attrs Attributes
     # @return [Array] Compiled temple expression
     def on_slim_attrs(*attrs)
-      [:html, :staticattrs, *attrs.map {|k, v| [k.to_s, compile!(v)] }]
+      [:html, :staticattrs, *attrs.map {|k, v| [k.to_s, compile(v)] }]
     end
   end
 end

data/lib/slim/embedded_engine.rb

@@ -4,21 +4,26 @@ module Slim
   class EmbeddedEngine < Filter
     @engines = {}
 
-    def self.register(name, klass, options = {})
-      @engines[name.to_s] = klass.new(options)
-    end
+    class << self
+      attr_reader :engines
 
-    def self.[](name)
-      engine = @engines[name.to_s]
-      raise "Invalid embedded engine #{name}" if !engine
-      engine.dup
+      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]
+      end
     end
 
-    def on_slim_embedded(name, *body)
-      engine = EmbeddedEngine[name]
+    def new_engine(name)
+      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.on_slim_embedded(name, *body)
+      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::Utils::ImmutableHash.new(local_options, filtered_options))
+    end
+
+    def on_slim_embedded(name, *body)
+      new_engine(name).on_slim_embedded(name, *body)
     end
 
     def collect_text(body)
@@ -29,40 +34,62 @@ module Slim
     end
 
     class TiltEngine < EmbeddedEngine
+      def on_slim_embedded(engine, *body)
+        text = collect_text(body)
+        engine = Tilt[engine] || raise("Tilt engine #{engine} is not available.")
+        tilt_render(engine, text)
+      end
+
+      def tilt_render(engine, text)
+        # Static template
+        [:static, engine.new { text }.render]
+      end
+    end
+
+    class SassEngine < TiltEngine
+      def tilt_render(engine, text)
+        text = engine.new(:style => (options[:pretty] ? :expanded : :compressed)) { text }.render
+        text.chomp!
+        [:static, options[:pretty] ? "\n#{text}\n" : text]
+      end
+    end
+
+    class DynamicTiltEngine < TiltEngine
       # Code to collect local variables
       COLLECT_LOCALS = %q{eval('{' + local_variables.select {|v| v[0] != ?_ }.map {|v| ":#{v}=>#{v}" }.join(',') + '}')}
 
-      def on_slim_embedded(engine, *body)
-        text = collect_text(body)
-        engine = Tilt[engine]
-        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]
-          # Fully dynamic evaluation of the template during runtime (Slow and uncached)
-          [:dynamic, "#{engine.name}.new { #{text.inspect} }.render(self, #{COLLECT_LOCALS})"]
-        elsif options[:interpolate]
-          # Static template with interpolated ruby code
-          [:slim, :text, engine.new { text }.render]
-        else
-          # Static template
-          [:static, engine.new { text }.render]
-        end
+      def tilt_render(engine, text)
+        # Fully dynamic evaluation of the template during runtime (Slow and uncached)
+        [:dynamic, "#{engine.name}.new { #{text.inspect} }.render(self, #{COLLECT_LOCALS})"]
+      end
+    end
+
+    class PrecompiledTiltEngine < TiltEngine
+      def tilt_render(engine, text)
+        # 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"]
+      end
+    end
+
+    class InterpolateTiltEngine < TiltEngine
+      def tilt_render(engine, text)
+        # Static template with interpolated ruby code
+        [:slim, :text, engine.new { text }.render]
       end
     end
 
     class ERBEngine < EmbeddedEngine
       def on_slim_embedded(engine, *body)
         text = collect_text(body)
-        Temple::ERB::Parser.new(:auto_escape => true).compile(text)
+        Temple::ERB::Parser.new(:auto_escape => true).call(text)
       end
     end
 
     class TagEngine < EmbeddedEngine
       def on_slim_embedded(engine, *body)
-        content = options[:engine] ? options[:engine].new.on_slim_embedded(engine, *body) : [:multi, *body]
+        content = options[:engine] ? options[:engine].new(options).on_slim_embedded(engine, *body) : [:multi, *body]
         [:slim, :tag, options[:tag], [:slim, :attrs, *options[:attributes].map {|k, v| [k, [:static, v]] }], false, content]
       end
     end
@@ -74,32 +101,33 @@ module Slim
     end
 
     # These engines are executed at compile time, embedded ruby is interpolated
-    register :markdown, TiltEngine, :interpolate => true
-    register :textile, TiltEngine, :interpolate => true
-    register :rdoc, TiltEngine, :interpolate => true
+    register :markdown,   InterpolateTiltEngine
+    register :textile,    InterpolateTiltEngine
+    register :rdoc,       InterpolateTiltEngine
+    register :creole,     InterpolateTiltEngine
 
     # These engines are executed at compile time
-    register :coffee, TagEngine, :tag => 'script', :attributes => { :type => 'text/javascript' }, :engine => TiltEngine
-    register :sass, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
-    register :scss, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
-    register :less, TagEngine, :tag => 'style', :attributes => { :type => 'text/css' }, :engine => TiltEngine
+    register :coffee,     TagEngine,  :tag => 'script', :attributes => { :type => 'text/javascript' },  :engine => TiltEngine
+    register :less,       TagEngine,  :tag => 'style',  :attributes => { :type => 'text/css' },         :engine => TiltEngine
+    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
-    register :haml, TiltEngine, :precompiled => true
-    register :nokogiri, TiltEngine, :precompiled => true
-    register :builder, TiltEngine, :precompiled => true
+    register :erb,        ERBEngine
+    register :haml,       PrecompiledTiltEngine
+    register :nokogiri,   PrecompiledTiltEngine
+    register :builder,    PrecompiledTiltEngine
 
     # These engines are completely executed at runtime (Usage not recommended, no caching!)
-    register :liquid, TiltEngine, :dynamic => true
-    register :radius, TiltEngine, :dynamic => true
-    register :markaby, TiltEngine, :dynamic => true
+    register :liquid,     DynamicTiltEngine
+    register :radius,     DynamicTiltEngine
+    register :markaby,    DynamicTiltEngine
 
     # 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
+    register :ruby,       RubyEngine
   end
 end

data/lib/slim/end_inserter.rb

@@ -37,7 +37,7 @@ module Slim
           prev_indent = false
         end
 
-        result << compile!(exp)
+        result << compile(exp)
       end
 
       # The last line can be a control code too.

data/lib/slim/engine.rb

@@ -14,12 +14,14 @@ module Slim
                         :id_delimiter => nil,
                         :generator => Temple::Generators::ArrayBuffer
 
+    #
     # Document all supported options with purpose, type etc.
     #
     # Type        | Name               | Default value                 | Purpose
     # --------------------------------------------------------------------------------------------------------------------------------------------
     # String      | :file              | nil                           | Name of parsed file, set automatically by Slim::Template
     # Integer     | :tabsize           | 4                             | Number of whitespaces per tab (used by the parser)
+    # String      | :encoding          | utf-8                         | Set encoding of template
     # String list | :enable_engines    | All enabled                   | List of enabled embedded engines (whitelist)
     # String list | :disable_engines   | None disabled                 | List of disabled embedded engines (blacklist)
     # Boolean     | :sections          | false                         | Enable sections mode (logic-less)
@@ -33,9 +35,26 @@ module Slim
     # String      | :attr_wrapper      | '"'                           | Character to wrap attributes in html (can be ' or ")
     # String      | :id_delimiter      | '_'                           | Joining character used if multiple html ids are supplied (e.g. #id1#id2)
     # Boolean     | :pretty            | false                         | Pretty html indenting (This is slower!)
-    # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (defaults generates array buffer)
-    use Slim::Parser, :file, :tabsize
-    use Slim::EmbeddedEngine, :enable_engines, :disable_engines
+    # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (default generator generates array buffer)
+    #
+    # It is also possible to set all options supported by the generator (option :generator). The standard generators
+    # support the options :buffer and :capture_generator.
+    #
+    # Options can be set at multiple positions. Slim/Temple uses a inheritance mechanism to allow
+    # subclasses to overwrite options of the superclass. The option priorities are as follows:
+    #
+    # Custom (Options passed by the user) > Slim::Template > Slim::Engine > Parser/Filter/Generator (e.g Slim::Parser, Slim::Compiler)
+    #
+    # It is also possible to set options for superclasses like Temple::Engine. But this will affect all temple template engines then.
+    #
+    # Slim::Engine > Temple::Engine
+    # Slim::Compiler > Temple::Filter
+    #
+    # It is recommended to set the default settings only once in the code and avoid duplication. Only use
+    # `set_default_options` when you have to override some default settings.
+    #
+    use Slim::Parser, :file, :tabsize, :encoding
+    use Slim::EmbeddedEngine, :enable_engines, :disable_engines, :pretty
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
@@ -47,6 +66,6 @@ module Slim
     filter :StaticMerger
     filter :DynamicInliner
     filter :Debugger, :debug, :debug_prefix => 'Optimized code'
-    chain << proc {|options| options[:generator].new }
+    use(:Generator) {|exp| options[:generator].new(options).call(exp) }
   end
 end

data/lib/slim/filter.rb

@@ -1,36 +1,33 @@
 module Slim
   # Base class for Temple filters used in Slim
+  #
+  # This base filter passes everything through and allows
+  # to override only some methods without affecting the rest
+  # of the expression.
+  #
   # @api private
   class Filter < Temple::Filter
     # Dispatch on_slim_*
     temple_dispatch :slim
 
     def on_slim_control(code, content)
-      [:slim, :control, code, compile!(content)]
+      [:slim, :control, code, compile(content)]
     end
 
     def on_slim_comment(content)
-      [:slim, :comment, compile!(content)]
+      [:slim, :comment, compile(content)]
     end
 
     def on_slim_output(code, escape, content)
-      [:slim, :output, code, escape, compile!(content)]
+      [:slim, :output, code, escape, compile(content)]
     end
 
     def on_slim_tag(name, attrs, closed, content)
-      [:slim, :tag, name, compile!(attrs), closed, compile!(content)]
+      [:slim, :tag, name, compile(attrs), closed, compile(content)]
     end
 
     def on_slim_attrs(*attrs)
-      [:slim, :attrs, *attrs.map {|k, v| [k, compile!(v)] }]
-    end
-
-    # Generate unique temporary variable name
-    #
-    # @return [String] Variable name
-    def tmp_var(prefix)
-      @tmp_var ||= 0
-      "_slim#{prefix}#{@tmp_var += 1}"
+      [:slim, :attrs, *attrs.map {|k, v| [k, compile(v)] }]
     end
   end
 end

data/lib/slim/interpolation.rb

@@ -1,5 +1,7 @@
 module Slim
-  # Perform interpolation of #{var_name}
+  # Perform interpolation of #{var_name} in the
+  # expressions `[:slim, :text, string]`.
+  #
   # @api private
   class Interpolation < Filter
     # Handle text expression `[:slim, :text, string]`

data/lib/slim/parser.rb

@@ -4,6 +4,9 @@ module Slim
   class Parser
     include Temple::Mixins::Options
 
+    set_default_options :tabsize  => 4,
+                        :encoding => 'utf-8'
+
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
 
@@ -24,8 +27,6 @@ module Slim
       end
     end
 
-    default_options[:tabsize] = 4
-
     def initialize(options = {})
       super
       @tab = ' ' * @options[:tabsize]
@@ -35,7 +36,9 @@ module Slim
     #
     # @param [String] str Slim code
     # @return [Array] Temple expression representing the code
-    def compile(str)
+    def call(str)
+      str.force_encoding(options[:encoding]) if options[:encoding] && str.respond_to?(:force_encoding)
+
       lineno = 0
       result = [:multi]
 
@@ -245,7 +248,7 @@ module Slim
     private
 
     ATTR_REGEX = /^\s+(\w[:\w-]*)=/
-    QUOTED_VALUE_REGEX = /^("[^"]+"|'[^']+')/
+    QUOTED_VALUE_REGEX = /^("[^"]*"|'[^']*')/
     ATTR_SHORTHAND = {
       '#' => 'id',
       '.' => 'class',
@@ -277,6 +280,8 @@ module Slim
 
       # Find any literal class/id attributes
       while line =~ CLASS_ID_REGEX
+        # The class/id attribute is :static instead of :slim :text,
+        # because we don't want text interpolation in .class or #id shortcut
         attributes << [ATTR_SHORTHAND[$1], [:static, $2]]
         line = $'
       end

data/lib/slim/rails.rb

@@ -1,32 +1,3 @@
+# TODO: I would say we remove when we reach 1.0
 require 'slim'
-
-Slim::Engine.default_options[:generator] = Temple::Generators::RailsOutputBuffer
-Slim::Engine.default_options[:disable_capture] = true
-
-module ActionView
-  module TemplateHandlers
-    if Rails::VERSION::MAJOR < 3
-      raise "Slim supports only Rails 3.x and greater, your Rails version is #{Rails::VERSION::STRING}"
-    end
-
-    if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR < 1
-      # Slim handler for Rails 3.0
-      class SlimHandler < TemplateHandler
-        include Compilable
-
-        def compile(template)
-          Slim::Engine.new.compile(template.source)
-        end
-      end
-    else
-      # Slim handler for Rails 3.1 and greater
-      class SlimHandler
-        def self.call(template)
-          Slim::Engine.new.compile(template.source)
-        end
-      end
-    end
-  end
-
-  Template.register_template_handler :slim, TemplateHandlers::SlimHandler
-end
+puts 'Deprecated: Use `require \'slim\'` instead of `require \'slim/rails\'`'

data/lib/slim/sections.rb

@@ -14,7 +14,7 @@ module Slim
       end
     end
 
-    def compile(exp)
+    def call(exp)
       if options[:sections]
         # Store the dictionary in the _slimdict variable
         dictionary = options[:dictionary]
@@ -37,17 +37,17 @@ module Slim
     end
 
     def on_slim_inverted_section(name, content)
-      tmp = tmp_var('section')
+      tmp = tmp_var(:section)
       [:multi,
        [:block, "#{tmp} = #{access name}"],
        [:block, "if !#{tmp} || #{tmp}.respond_to?(:empty) && #{tmp}.empty?"],
-                  compile!(content),
+                  compile(content),
        [:block, 'end']]
     end
 
     def on_slim_section(name, content)
-      content = compile!(content)
-      tmp1, tmp2 = tmp_var('dict'), tmp_var('dict')
+      content = compile(content)
+      tmp1, tmp2 = tmp_var(:dict), tmp_var(:dict)
 
       [:multi,
        [:block, "if #{tmp1} = #{access name}"],

data/lib/slim/template.rb

@@ -1,9 +1,17 @@
 module Slim
   # Tilt template implementation for Slim
   # @api public
-  class Template < Temple::Template
-    engine Slim::Engine
-  end
+  Template = Temple::Templates::Tilt(Slim::Engine, :register_as => :slim)
+
+  if Object.const_defined?(:Rails)
+    # Rails template implementation for Slim
+    # @api public
+    RailsTemplate = Temple::Templates::Rails(Slim::Engine, :register_as => :slim)
 
-  Tilt.register 'slim', Template
+    # Use rails-specific generator. This is necessary
+    # to support block capturing. Disable the internal slim capturing.
+    # Rails takes care of the capturing by itself.
+    RailsTemplate.set_default_options :generator => Temple::Generators::RailsOutputBuffer,
+                                      :disable_capture => true
+  end
 end

data/lib/slim/version.rb

@@ -1,3 +1,3 @@
 module Slim
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
 end

data/lib/slim.rb

@@ -12,4 +12,3 @@ require 'slim/engine'
 require 'slim/template'
 require 'slim/version'
 require 'slim/wrapper'
-require 'slim/validator'

data/test/helper.rb

@@ -14,7 +14,6 @@ class TestSlim < MiniTest::Unit::TestCase
 
   def teardown
     Slim::Sections.set_default_options(:dictionary_access => :wrapped)
-    Temple::Filters::EscapeHTML.default_options.delete(:use_html_safe)
   end
 
   def render(source, options = {}, &block)

data/test/integration/rails/dummy/config/application.rb

@@ -1,12 +1,12 @@
 require File.expand_path('../boot', __FILE__)
 
-require "active_model/railtie"
-require "active_record/railtie"
-require "action_controller/railtie"
-require "action_view/railtie"
-require "action_mailer/railtie"
+require 'active_model/railtie'
+require 'active_record/railtie'
+require 'action_controller/railtie'
+require 'action_view/railtie'
+require 'action_mailer/railtie'
 
-require "slim/rails"
+require 'slim'
 
 module Dummy
   class Application < Rails::Application

data/test/slim/test_chain_manipulation.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class TestSlimChainManipulation < TestSlim
+  def test_replace
+    source = %q{
+p Test
+}
+    chain = proc do |engine|
+      engine.replace(Temple::HTML::Pretty, :ReplacementFilter) do |exp|
+        [:dynamic, '1+1']
+      end
+    end
+
+    assert_html '2', source, :chain => chain
+  end
+
+  def test_before
+    source = %q{
+p Test
+}
+    chain = proc do |engine|
+      engine.before(Slim::Parser, :WrapInput) do |input|
+        "p Header\n#{input}\np Footer"
+      end
+    end
+
+    assert_html '<p>Header</p><p>Test</p><p>Footer</p>', source, :chain => chain
+  end
+
+  def test_after
+    source = %q{
+p Test
+}
+    chain = proc do |engine|
+      engine.after(Slim::Parser, :ReplaceParsedExp) do |exp|
+        [:slim, :output, false, '1+1', [:multi]]
+      end
+    end
+
+    assert_html '2', source, :chain => chain
+  end
+end

data/test/slim/test_embedded_engines.rb

@@ -1,7 +1,25 @@
 require 'helper'
+begin
+  require('creole/template')
+rescue LoadError
+end
 
 class TestSlimEmbeddedEngines < TestSlim
-  def test_render_with_embedded_template
+  def test_render_with_haml
+    source = %q{
+p
+  - text = 'haml'
+  haml:
+    %b Hello from #{text.upcase}!
+    Second Line!
+    - if true
+      = true
+}
+
+    assert_html "<p><b>Hello from HAML!</b>\nSecond Line!\ntrue\n</p>", source
+  end
+
+  def test_render_with_erb
     source = %q{
 p
   - text = 'before erb block'
@@ -14,7 +32,7 @@ p
     assert_html "<p><b>Hello from BEFORE ERB BLOCK!</b>\nSecond Line!\ntrue</p>", source
   end
 
-  def test_render_with_interpolated_embedded_template
+  def test_render_with_markdown
     source = %q{
 markdown:
   #Header
@@ -24,6 +42,15 @@ markdown:
     assert_html "<h1>Header</h1>\n\n<p>Hello from Markdown!\n\"Second Line!\"</p>\n", source
   end
 
+  def test_render_with_creole
+    source = %q{
+creole:
+  = head1
+  == head2
+}
+    assert_html "<h1>head1</h1><h2>head2</h2>", source
+  end
+
   def test_render_with_javascript
     # Keep the trailing space behind "javascript:   "!
     source = %q{
@@ -59,7 +86,7 @@ scss:
   $color: #f00;
   body { color: $color; }
 }
-    assert_html "<style type=\"text/css\">body {\n  color: red; }\n</style>", source
+    assert_html "<style type=\"text/css\">body{color:red}</style>", source
   end
 
   def test_disabled_embedded_engine

data/test/slim/test_html_structure.rb

@@ -262,6 +262,22 @@ p(id="marvin" class="martian" data-info="Illudium Q-36")= output_number
     assert_html '<p class="martian" data-info="Illudium Q-36" id="marvin">1337</p>', source
   end
 
+  def test_empty_attribute
+    source = %q{
+p(id="marvin" class="" data-info="Illudium Q-36")= output_number
+}
+
+    assert_html '<p data-info="Illudium Q-36" id="marvin">1337</p>', source
+  end
+
+  def test_dynamic_empty_attribute
+    source = %q{
+p(id="marvin" class=nil data-info="Illudium Q-36")= output_number
+}
+
+    assert_html '<p data-info="Illudium Q-36" id="marvin">1337</p>', source
+  end
+
   def test_closed_tag
     source = %q{
 closed/

data/test/slim/test_pretty.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+class TestSlimPretty < TestSlim
+  def setup
+    Slim::Engine.set_default_options :pretty => true
+  end
+
+  def teardown
+    Slim::Engine.set_default_options :pretty => false
+  end
+
+  def test_pretty_sass
+    source = %q{
+doctype 5
+html
+  head
+    title Hello World!
+    sass:
+      body
+        background-color: red
+  body
+    #container
+      p Hello!
+}
+
+    result = %q{<!DOCTYPE html>
+<html>
+  <head>
+    <title>Hello World!</title>
+    <style type="text/css">
+      body {
+        background-color: red;
+      } 
+    </style>
+  </head>
+  <body>
+    <div id="container">
+      <p>Hello!</p>
+    </div>
+  </body>
+</html>}
+
+    assert_html result, source
+  end
+end

data/test/slim/test_ruby_errors.rb

@@ -121,7 +121,7 @@ p
     1+1
 }
 
-    assert_runtime_error 'Invalid embedded engine embed_unknown', source
+    assert_runtime_error 'Embedded engine embed_unknown not found', source
   end
 
   def test_explicit_end

data/test/slim/test_text_interpolation.rb

@@ -1,6 +1,13 @@
 require 'helper'
 
 class TestSlimTextInterpolation < TestSlim
+  def test_interpolation_in_attribute
+    source = %q{
+p id="a#{id_helper}b" = hello_world
+}
+
+    assert_html '<p id="anoticeb">Hello World from @env</p>', source
+  end
 
   def test_interpolation_in_text
     source = %q{

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 1
-  version: 0.9.1
+  - 2
+  version: 0.9.2
 platform: ruby
 authors: 
 - Andrew Stone
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-10 00:00:00 -05:00
+date: 2011-03-30 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,9 +29,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 1
-        - 8
-        version: 0.1.8
+        - 2
+        - 0
+        version: 0.2.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -141,6 +141,19 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: creole
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
 description: Slim is a template language whose goal is reduce the syntax to the essential parts without becoming cryptic.
 email: 
 - andy@stonean.com
@@ -169,7 +182,6 @@ files:
 - lib/slim/rails.rb
 - lib/slim/sections.rb
 - lib/slim/template.rb
-- lib/slim/validator.rb
 - lib/slim/version.rb
 - lib/slim/wrapper.rb
 - test/helper.rb
@@ -213,6 +225,7 @@ files:
 - test/integration/rails/dummy/script/rails
 - test/integration/rails/test_helper.rb
 - test/integration/rails/test_slim_rails.rb
+- test/slim/test_chain_manipulation.rb
 - test/slim/test_code_blocks.rb
 - test/slim/test_code_escaping.rb
 - test/slim/test_code_evaluation.rb
@@ -222,11 +235,11 @@ files:
 - test/slim/test_html_escaping.rb
 - test/slim/test_html_structure.rb
 - test/slim/test_parser_errors.rb
+- test/slim/test_pretty.rb
 - test/slim/test_ruby_errors.rb
 - test/slim/test_sections.rb
 - test/slim/test_slim_template.rb
 - test/slim/test_text_interpolation.rb
-- test/slim/test_validator.rb
 - test/slim/test_wrapper.rb
 has_rdoc: true
 homepage: http://github.com/stonean/slim

data/lib/slim/validator.rb

@@ -1,16 +0,0 @@
-module Slim
-  module Validator
-    class << self
-      def validate!(source)
-        Slim::Engine.new.compile(source.to_s)
-        true
-      rescue Exception => ex
-        ex
-      end
-
-      def valid?(source)
-        validate!(source) === true
-      end
-    end
-  end
-end

data/test/slim/test_validator.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-class TestSlimValidator < TestSlim
-  def test_valid_true?
-    source = %q{
-p Slim
-}
-    assert_valid? true, source
-  end
-
-  def test_valid_false?
-    source = %q{
- p
-  Slim
-}
-    assert_valid? false, source
-  end
-
-  def test_valid!
-    source = %q{
-p Slim
-}
-    assert_valid! false, source
-  end
-
-  def test_invalid!
-    source = %q{
- p
-  Slim
-}
-    assert_invalid! Slim::Parser::SyntaxError, source
-  end
-
-  private
-
-  def assert_valid?(expected, source)
-    assert_equal expected, Slim::Validator.valid?(source)
-  end
-
-  def assert_valid!(expected, source)
-    assert_equal true, Slim::Validator.validate!(source)
-  end
-
-  def assert_invalid!(expected, source)
-    assert_equal expected, Slim::Validator.validate!(source).class
-  end
-end