slim 0.8.1 → 0.8.2

data/lib/slim/compiler.rb

@@ -2,6 +2,8 @@ module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
+    set_default_options :disable_capture => false
+
     # Handle control expression `[:slim, :control, code, content]`
     #
     # @param [String] ruby code
@@ -35,25 +37,28 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_output_block(escape, code, content)
-      tmp1, tmp2 = tmp_var('capture'), tmp_var('capture')
+      tmp = tmp_var('capture')
 
       [: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, "#{tmp1} = #{code}"],
+        [: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.
-        [:capture, tmp2,
-         compile!(content)],
+        #
+        # 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)],
 
         # Close the block.
         [:block, 'end'],
 
         # Output the content.
-        on_slim_output(escape, tmp1, [:multi])]
+        on_slim_output(escape, tmp, [:multi])]
     end
 
     # Handle directive expression `[:slim, :directive, type]`

data/lib/slim/engine.rb

@@ -11,19 +11,22 @@ module Slim
                         :attr_wrapper => '"',
                         :format => :html5,
                         :id_delimiter => nil,
-                        :generator => Temple::Generators::ArrayBuffer
+                        :generator => Temple::Generators::ArrayBuffer,
+                        :disable_capture => false,
+                        :debug => false
 
     use Slim::Parser, :file, :tabsize
     use Slim::EmbeddedEngine, :enable_engines, :disable_engines
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
-    use Slim::Compiler
+    use Slim::Compiler, :disable_capture
     filter :EscapeHTML, :use_html_safe
     use Temple::HTML::Pretty, :format, :attr_wrapper, :id_delimiter, :pretty
     filter :MultiFlattener
     filter :StaticMerger
     filter :DynamicInliner
+    filter :Debugger, :debug, :debug_prefix, :debug_pretty
     chain << proc {|options| options[:generator].new }
   end
 end

data/lib/slim/interpolation.rb

@@ -12,19 +12,48 @@ module Slim
       block = [:multi]
       until string.empty?
         case string
-        when /^\\(\#\{[^\}]*\})/
+        when /^\\\#\{/
           # Escaped interpolation
-          block << [:static, $1]
-        when /^\#\{([^\}]*)\}/
+          block << [:static, '#{']
+          string = $'
+        when /^\#\{/
           # Interpolation
-          block << [:slim, :output, true, $1, [:multi]]
+          string, code = parse_expression($')
+          block << [:slim, :output, true, code, [:multi]]
         when /^([^\#]+|\#)/
           # Static text
           block << [:static, $&]
+          string = $'
         end
-        string = $'
       end
       block
     end
+
+    def parse_expression(string)
+      stack, code = [], ''
+
+      until string.empty?
+        if stack.empty? && string =~ /^\}/
+          # Stack is empty, this means we are finished
+          # if the next character is a closing bracket
+          string.slice!(0)
+          break
+        elsif string =~ Parser::DELIMITER_REGEX
+          # Delimiter found, push it on the stack
+          stack << Parser::DELIMITERS[$1]
+          code << string.slice!(0)
+        elsif string =~ Parser::CLOSE_DELIMITER_REGEX
+          # Closing delimiter found, pop it from the stack if everything is ok
+          raise "Text interpolation: Unexpected closing #{$1}" if stack.empty?
+          raise "Text interpolation: Expected closing #{stack.last}" if stack.last != $1
+          code << string.slice!(0)
+          stack.pop
+        else
+          code << string.slice!(0)
+        end
+      end
+
+      return string, code
+    end
   end
 end

data/lib/slim/parser.rb

@@ -222,6 +222,14 @@ module Slim
       result
     end
 
+    DELIMITERS = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+    }.freeze
+    DELIMITER_REGEX = /^([\(\[\{])/
+    CLOSE_DELIMITER_REGEX = /^([\)\]\}])/
+
     private
 
     ATTR_REGEX = /^ (\w[:\w-]*)=/
@@ -230,13 +238,7 @@ module Slim
       '#' => 'id',
       '.' => 'class',
     }.freeze
-    DELIMITERS = {
-      '(' => ')',
-      '[' => ']',
-      '{' => '}',
-    }.freeze
-    DELIMITER_REGEX = /^([\(\[\{])/
-    CLOSE_DELIMITER_REGEX = /^([\)\]\}])/
+
     if RUBY_VERSION > '1.9'
       CLASS_ID_REGEX = /^(#|\.)([\w\u00c0-\uFFFF][\w:\u00c0-\uFFFF-]*)/
     else

data/lib/slim/rails.rb

@@ -1,6 +1,7 @@
 require 'slim'
 
 Slim::Engine.default_options[:generator] = Temple::Generators::RailsOutputBuffer
+Slim::Engine.default_options[:disable_capture] = true
 
 module ActionView
   module TemplateHandlers

data/lib/slim/validator.rb

@@ -1,5 +1,5 @@
 module Slim
-  class Validator
+  module Validator
     class << self
       def validate!(source)
         Slim::Engine.new.compile(source.to_s)

data/lib/slim/version.rb

@@ -1,3 +1,3 @@
 module Slim
-  VERSION = '0.8.1'
+  VERSION = '0.8.2'
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 8
-  - 1
-  version: 0.8.1
+  - 2
+  version: 0.8.2
 platform: ruby
 authors: 
 - Andrew Stone
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-17 00:00:00 +11:00
+date: 2010-12-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency