slim 0.9.2 → 0.9.3

data/extra/test.slim

@@ -0,0 +1,49 @@
+doctype html
+html
+  head
+    title Slim Test
+    meta name="keywords" content="slim, syntax"
+
+    javascript:
+      $(function() {
+        alert('Hello World');
+      });
+
+    haml:
+      #someid.someclass{:this => 'test'} Content in haml
+
+    erb:
+      <%= some_method(@request) %>
+
+  body
+    / comment block
+      with multiple lines
+      This is another line
+    h1 = @page_title
+    p#notice.message
+      | Welcome to the the syntax test.
+        This file is to exercise the various markup.
+        This is another line
+    - unless @users.empty?
+      table
+        - for user in users do
+          tr
+            td.user id=some_ruby('ere', @rme) data-test="some text #{with @ruby}" = @post.name 
+    - else
+      p There are no users.
+
+    / Single comment line
+    #content Hello #{@user.name}! Welcome to the test page!
+             Try out Slim!
+
+    = function_with_many_parameters(:a, @variable, :option => 1)
+
+    p.text
+      ' Another text block
+        with multiple lines
+
+    = link_to('Test', @site)
+
+    .text#footer
+      ' Footer text block
+        with multiple lines

data/lib/slim/command.rb

@@ -52,10 +52,6 @@ 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
@@ -91,14 +87,12 @@ module Slim
                                                 :pretty => @options[:pretty],
                                                 :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

@@ -2,7 +2,7 @@ module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
-    set_default_options :auto_escape => true
+    set_default_options :bool_attrs => %w(selected)
 
     # Handle control expression `[:slim, :control, code, content]`
     #
@@ -11,16 +11,17 @@ module Slim
     # @return [Array] Compiled temple expression
     def on_slim_control(code, content)
       [:multi,
-        [:block, code],
+        [:code, code],
         compile(content)]
     end
 
-    # Handle comment expression `[:slim, :comment, content]`
+    # Handle conditional comment expression
+    # `[:slim, :conditional_comment, conditional, content]`
     #
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_slim_comment(content)
-      [:html, :comment, compile(content)]
+    def on_slim_condcomment(condition, content)
+      [:multi, [:static, "<!--[#{condition}]>"], compile(content), [:static, '<![endif]-->']]
     end
 
     # Handle output expression `[:slim, :output, escape, code, content]`
@@ -31,42 +32,28 @@ module Slim
     # @return [Array] Compiled temple expression
     def on_slim_output(escape, code, content)
       if empty_exp?(content)
-        [:multi, [:escape, escape && options[:auto_escape], [:dynamic, code]], content]
+        [:multi, [:escape, escape, [:dynamic, code]], content]
       else
-        on_slim_output_block(escape, code, content)
-      end
-    end
-
-    # Handle output expression `[:slim, :output, escape, code, content]`
-    # if content is not empty.
-    #
-    # @param [Boolean] escape Escape html
-    # @param [String] code Ruby code
-    # @param [Array] content Temple expression
-    # @return [Array] Compiled temple expression
-    def on_slim_output_block(escape, code, content)
-      tmp = tmp_var(:output)
-
-      [: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}"],
+        tmp = unique_name
 
-        # 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 (with_output_buffer - braindead!).
-        options[:disable_capture] ? compile(content) : [:capture, tmp_var(:output), compile(content)],
+        [: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}",
 
-        # Close the block.
-        [:block, 'end'],
+          # 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.
-        on_slim_output(escape, tmp, [:multi])]
+         # Output the content.
+         [:escape, escape, [:dynamic, tmp]]]
+      end
     end
 
     # Handle directive expression `[:slim, :directive, type, args]`
@@ -82,22 +69,24 @@ module Slim
       end
     end
 
-    # Handle tag expression `[:slim, :tag, name, attrs, closed, content]`
-    #
-    # @param [String] name Tag name
-    # @param [Array] attrs Attributes
-    # @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)]
-    end
-
-    # Handle tag attributes expression `[:slim, :attrs, *attrs]`
+    # Handle attribute expression `[:slim, :attr, escape, code]`
     #
-    # @param [Array] attrs Attributes
+    # @param [Boolean] escape Escape html
+    # @param [String] code Ruby code
     # @return [Array] Compiled temple expression
-    def on_slim_attrs(*attrs)
-      [:html, :staticattrs, *attrs.map {|k, v| [k.to_s, compile(v)] }]
+    def on_slim_attr(name, escape, code)
+      if options[:bool_attrs].include?(name)
+        escape = false
+        value = [:dynamic, "(#{code}) ? #{name.inspect} : nil"]
+      elsif delimiter = options[:attr_delimiter][name]
+        tmp = unique_name
+        value = [:multi,
+                 [:code, "#{tmp} = #{code}"],
+                 [:dynamic, "#{tmp}.respond_to?(:join) ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"]]
+      else
+        value = [:dynamic, code]
+      end
+      [:html, :attr, name,  [:escape, escape, value]]
     end
   end
 end

data/lib/slim/embedded_engine.rb

@@ -7,96 +7,124 @@ module Slim
     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]
       end
     end
 
+    def on_slim_embedded(name, body)
+      new_engine(name).on_slim_embedded(name, body)
+    end
+
+    protected
+
     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, 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))
+      engine.new(Temple::ImmutableHash.new(local_options, filtered_options))
     end
 
-    def on_slim_embedded(name, *body)
-      new_engine(name).on_slim_embedded(name, *body)
+    def collect_text(body)
+      body[1..-1].inject('') do |text, exp|
+        exp[0] == :slim && exp[1] == :interpolate ? (text << exp[2]) : text
+      end
     end
 
-    def collect_text(body)
-      body.inject('') do |text, exp|
-        text << exp[2] if exp[0] == :slim && exp[1] == :text
-        text
+    def collect_newlines(body)
+      body[1..-1].inject([:multi]) do |multi, exp|
+        exp[0] == :newline ? (multi << exp) : multi
       end
     end
 
+    # Basic tilt engine
     class TiltEngine < EmbeddedEngine
-      def on_slim_embedded(engine, *body)
-        text = collect_text(body)
+      def on_slim_embedded(engine, body)
         engine = Tilt[engine] || raise("Tilt engine #{engine} is not available.")
-        tilt_render(engine, text)
+        [:multi, render(engine, collect_text(body)), collect_newlines(body)]
       end
+    end
+
+    # Tilt-based static template (evaluated at compile-time)
+    class StaticTiltEngine < TiltEngine
+      protected
 
-      def tilt_render(engine, text)
-        # Static template
+      def render(engine, text)
         [: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
+    # Sass engine which supports :pretty option
+    class SassEngine < StaticTiltEngine
+      protected
+
+      def render(engine, text)
+        text = engine.new(:style => (options[:pretty] ? :expanded : :compressed), :cache => false) { text }.render
         text.chomp!
         [:static, options[:pretty] ? "\n#{text}\n" : text]
       end
     end
 
-    class DynamicTiltEngine < TiltEngine
+    # Tilt-based engine which is fully dynamically evaluated during runtime (Slow and uncached)
+    class DynamicTiltEngine < StaticTiltEngine
+      protected
+
       # Code to collect local variables
       COLLECT_LOCALS = %q{eval('{' + local_variables.select {|v| v[0] != ?_ }.map {|v| ":#{v}=>#{v}" }.join(',') + '}')}
 
-      def tilt_render(engine, text)
-        # Fully dynamic evaluation of the template during runtime (Slow and uncached)
+      def render(engine, text)
         [: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
+    # Tilt-based engine which is precompiled
+    class PrecompiledTiltEngine < StaticTiltEngine
+      protected
+
+      def render(engine, text)
         # WARNING: This is a bit of a hack. Tilt::Engine#precompiled is protected
-        precompiled = engine.new { text }.send(:precompiled, {}).first
-        [:dynamic, "proc { #{precompiled} }.call"]
+        [:dynamic, engine.new { text }.send(:precompiled, {}).first]
       end
     end
 
-    class InterpolateTiltEngine < TiltEngine
-      def tilt_render(engine, text)
-        # Static template with interpolated ruby code
-        [:slim, :text, engine.new { text }.render]
+    # Static template with interpolated ruby code
+    class InterpolateTiltEngine < StaticTiltEngine
+      protected
+
+      def render(engine, text)
+        [:slim, :interpolate, engine.new { text }.render]
       end
     end
 
+    # ERB engine (uses the Temple ERB implementation)
     class ERBEngine < EmbeddedEngine
-      def on_slim_embedded(engine, *body)
-        text = collect_text(body)
-        Temple::ERB::Parser.new(:auto_escape => true).call(text)
+      def on_slim_embedded(engine, body)
+        Temple::ERB::Parser.new.call(collect_text(body))
       end
     end
 
+    # Tag wrapper engine
+    # Generates a html tag and wraps another engine (specified via :engine option)
     class TagEngine < EmbeddedEngine
-      def on_slim_embedded(engine, *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]
+      def on_slim_embedded(engine, body)
+        content = options[:engine] ? options[:engine].new(options).on_slim_embedded(engine, body) : [:multi, body]
+        [:html, :tag, options[:tag], [:html, :attrs, *options[:attributes].map {|k, v| [:html, :attr, k, [:static, v]] }], content]
       end
     end
 
+    # Embeds ruby code
     class RubyEngine < EmbeddedEngine
-      def on_slim_embedded(engine, *body)
-        [:block, collect_text(body)]
+      def on_slim_embedded(engine, body)
+        [:code, "\n" + collect_text(body)]
       end
     end
 
@@ -107,10 +135,10 @@ module Slim
     register :creole,     InterpolateTiltEngine
 
     # These engines are executed at compile time
-    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
+    register :coffee,     TagEngine,  :tag => :script, :attributes => { :type => 'text/javascript' },  :engine => StaticTiltEngine
+    register :less,       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
@@ -124,8 +152,8 @@ module Slim
     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

data/lib/slim/end_inserter.rb

@@ -14,6 +14,8 @@ module Slim
     END_REGEX = /^end\b/
 
     # Handle multi expression `[:multi, *exps]`
+    #
+    # @return [Array] Corrected Temple expression with ends inserted
     def on_multi(*exps)
       result = [:multi]
       # This variable is true if the previous line was
@@ -46,12 +48,12 @@ module Slim
 
     private
 
-    # Appends an end.
+    # Appends an end
     def append_end(result)
-      result << [:block, 'end']
+      result << [:code, 'end']
     end
 
-    # Checks if an expression is a Slim control code.
+    # Checks if an expression is a Slim control code
     def control?(exp)
       exp[0] == :slim && exp[1] == :control
     end

data/lib/slim/engine.rb

@@ -11,7 +11,7 @@ module Slim
     set_default_options :pretty => false,
                         :attr_wrapper => '"',
                         :format => :html5,
-                        :id_delimiter => nil,
+                        :attr_delimiter => {'class' => ' '},
                         :generator => Temple::Generators::ArrayBuffer
 
     #
@@ -28,12 +28,12 @@ module Slim
     # String      | :dictionary        | "self"                        | Name of dictionary variable in sections mode
     # Symbol      | :dictionary_access | :wrapped                      | Access mode of dictionary variable (:wrapped, :symbol, :string)
     # Boolean     | :disable_capture   | false (true in Rails)         | Disable capturing in blocks (blocks write to the default buffer then)
-    # Boolean     | :auto_escape       | true                          | Enable automatic escaping of strings
-    # Boolean     | :use_html_safe     | false (true in Rails)         | Use String#html_safe? from ActiveSupport (Works together with :auto_escape)
-    # Boolean     | :debug             | false                         | Enable debug outputs (Temple internals)
+    # Boolean     | :disable_escape    | false                         | Disable automatic escaping of strings
+    # Boolean     | :use_html_safe     | false (true in Rails)         | Use String#html_safe? from ActiveSupport (Works together with :disable_escape)
     # Symbol      | :format            | :html5                        | HTML output format
     # 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)
+    # Hash        | :attr_delimiter    | {'class' => ' '}              | Joining character used if multiple html attributes are supplied (e.g. id1_id2)
+    # String list | :bool_attrs        | %w(selected)                  | List of boolean attributes
     # Boolean     | :pretty            | false                         | Pretty html indenting (This is slower!)
     # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (default generator generates array buffer)
     #
@@ -58,14 +58,12 @@ module Slim
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
-    use Slim::Compiler, :disable_capture, :auto_escape
-    filter :EscapeHTML, :use_html_safe
-    filter :Debugger, :debug, :debug_prefix => 'After Slim'
-    use Temple::HTML::Pretty, :format, :attr_wrapper, :id_delimiter, :pretty
+    use Slim::Compiler, :disable_capture, :attr_delimiter, :bool_attrs
+    use Temple::HTML::Pretty, :format, :attr_wrapper, :attr_delimiter, :pretty
+    filter :Escapable, :use_html_safe, :disable_escape
+    filter :ControlFlow
     filter :MultiFlattener
-    filter :StaticMerger
     filter :DynamicInliner
-    filter :Debugger, :debug, :debug_prefix => 'Optimized code'
     use(:Generator) {|exp| options[:generator].new(options).call(exp) }
   end
 end