slim 2.0.3 → 2.1.0

data/lib/slim/command.rb

@@ -39,16 +39,22 @@ module Slim
         @options[:erb] = true
       end
 
-      opts.on('-r', '--rails', 'Generate rails compatible code (Implies --compile)') do
+      opts.on('--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 library', "Load library or plugin with -r slim/plugin") do |lib|
+        require lib
+      end
+
       opts.on('-t', '--translator', 'Enable translator plugin') do
+        puts "Deprecated option: Use -r slim/translator"
         require 'slim/translator'
       end
 
       opts.on('-l', '--logic-less', 'Enable logic less plugin') do
+        puts "Deprecated option: Use -r slim/logic_less"
         require 'slim/logic_less'
       end
 
@@ -56,7 +62,7 @@ module Slim
         Engine.set_default_options :pretty => true
       end
 
-      opts.on('-o', '--option [NAME=CODE]', String, 'Set slim option') do |str|
+      opts.on('-o', '--option name=code', String, 'Set slim option') do |str|
         parts = str.split('=', 2)
         Engine.default_options[parts.first.gsub(/\A:/, '').to_sym] = eval(parts.last)
       end

data/lib/slim/controls.rb

@@ -3,7 +3,7 @@ module Slim
   class Controls < Filter
     define_options :disable_capture
 
-    IF_RE = /\A(if|unless)\b|do\s*(\|[^\|]*\|)?\s*$/
+    IF_RE = /\A(if|unless)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
 
     # Handle control expression `[:slim, :control, code, content]`
     #
@@ -48,11 +48,12 @@ module Slim
       end
     end
 
-    # Handle text expression `[:slim, :text, content]`
+    # Handle text expression `[:slim, :text, type, content]`
     #
+    # @param [Symbol] type Text type
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
-    def on_slim_text(content)
+    def on_slim_text(type, content)
       compile(content)
     end
   end

data/lib/slim/do_inserter.rb

@@ -7,7 +7,7 @@ module Slim
   #
   # @api private
   class DoInserter < Filter
-    BLOCK_REGEX = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|do\s*(\|[^\|]*\|\s*)?\Z/
+    BLOCK_REGEX = /(\A(if|unless|else|elsif|when|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^\|]*\|\s*)?\Z/
 
     # Handle control expression `[:slim, :control, code, content]`
     #

data/lib/slim/embedded.rb

@@ -30,8 +30,7 @@ module Slim
   # @api private
   class OutputProtector < Filter
     def call(exp)
-      @protect = []
-      @collected = ''
+      @protect, @collected, @tag = [], '', "%#{object_id.abs.to_s(36)}%"
       super(exp)
       @collected
     end
@@ -42,16 +41,16 @@ module Slim
     end
 
     def on_slim_output(escape, text, content)
-      @collected << "pro#{@protect.size}tect"
+      @collected << @tag
       @protect << [:slim, :output, escape, text, content]
       nil
     end
 
     def unprotect(text)
       block = [:multi]
-      while text =~ /pro(\d+)tect/
+      while text =~ /#{@tag}/
         block << [:static, $`]
-        block << @protect[$1.to_i]
+        block << @protect.shift
         text = $'
       end
       block << [:static, text]
@@ -63,25 +62,29 @@ module Slim
   class Embedded < Filter
     @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 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))
+    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)
+        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
-    end
 
-    def self.create(name, options)
-      constructor = @engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
-      constructor.call(options)
+      def create(name, options)
+        constructor = engines[name] || raise(Temple::FilterError, "Embedded engine #{name} not found")
+        constructor.call(options)
+      end
     end
 
     define_options :enable_engines, :disable_engines
@@ -252,6 +255,7 @@ module Slim
 
     # These engines are executed at compile time
     register :coffee,     JavaScriptEngine, :engine => StaticTiltEngine
+    register :opal,       JavaScriptEngine, :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

data/lib/slim/end_inserter.rb

@@ -10,7 +10,7 @@ module Slim
   #
   # @api private
   class EndInserter < Filter
-    IF_RE = /\A(if|unless|else|elsif|when|rescue|ensure)\b|do\s*(\|[^\|]*\|)?\s*$/
+    IF_RE = /\A(if|unless|else|elsif|when|rescue|ensure)\b|\bdo\s*(\|[^\|]*\|)?\s*$/
     ELSE_RE = /\A(else|elsif|when|rescue|ensure)\b/
     END_RE = /\Aend\b/
 

data/lib/slim/engine.rb

@@ -12,13 +12,14 @@ module Slim
                    :merge_attrs => {'class' => ' '},
                    :generator => Temple::Generators::ArrayBuffer,
                    :default_tag => 'div'
+    define_deprecated_options :attr_delims
 
     filter :Encoding, :encoding
     filter :RemoveBOM
-    use Slim::Parser, :file, :tabsize, :shortcut, :default_tag, :attr_delims
+    use Slim::Parser, :file, :tabsize, :shortcut, :default_tag, :attr_delims, :attr_list_delims, :code_attr_delims
     use Slim::Embedded, :enable_engines, :disable_engines, :pretty
     use Slim::Interpolation
-    use Slim::Splat::Filter, :merge_attrs, :attr_quote, :sort_attrs, :default_tag, :hyphen_attrs, :format
+    use Slim::Splat::Filter, :merge_attrs, :attr_quote, :sort_attrs, :default_tag, :hyphen_attrs, :format, :use_html_safe
     use Slim::DoInserter
     use Slim::EndInserter
     use Slim::Controls, :disable_capture

data/lib/slim/filter.rb

@@ -8,8 +8,8 @@ module Slim
   # @api private
   class Filter < Temple::HTML::Filter
     # Pass-through handler
-    def on_slim_text(content)
-      [:slim, :text, compile(content)]
+    def on_slim_text(type, content)
+      [:slim, :text, type, compile(content)]
     end
 
     # Pass-through handler

data/lib/slim/grammar.rb

@@ -4,12 +4,14 @@ module Slim
   module Grammar
     extend Temple::Grammar
 
+    TextTypes << :verbatim | :explicit | :implicit | :inline
+
     Expression <<
       [:slim, :control, String, Expression]           |
       [:slim, :output, Bool, String, Expression]      |
       [:slim, :interpolate, String]                   |
       [:slim, :embedded, String, Expression]          |
-      [:slim, :text, Expression]                      |
+      [:slim, :text, TextTypes, Expression]           |
       [:slim, :attrvalue, Bool, String]
 
     HTMLAttr <<

data/lib/slim/include.rb

@@ -0,0 +1,54 @@
+require 'slim'
+
+module Slim
+  # Handles inlined includes
+  #
+  # Slim files are compiled, non-Slim files are included as text with `#{interpolation}`
+  #
+  # @api private
+  class Include < Slim::Filter
+    define_options :file, :include_dirs => [Dir.pwd, '.']
+
+    def on_html_tag(tag, attributes, content)
+      return super if tag != 'include'
+      name = content.flatten.select {|s| String === s }.join
+      raise ArgumentError, 'Invalid include statement' unless attributes == [:html, :attrs] && !name.empty?
+      unless file = find_file(name)
+        name = "#{name}.slim" if name !~ /\.slim\Z/i
+        file = find_file(name)
+      end
+      raise Temple::FilterError, "'#{name}' not found in #{options[:include_dirs].join(':')}" unless file
+      content = File.read(file)
+      if file =~ /\.slim\Z/i
+        Thread.current[:slim_include_engine].call(content)
+      else
+        [:slim, :interpolate, content]
+      end
+    end
+
+    protected
+
+    def find_file(name)
+      current_dir = File.dirname(File.expand_path(options[:file]))
+      options[:include_dirs].map {|dir| File.expand_path(File.join(dir, name), current_dir) }.find {|file| File.file?(file) }
+    end
+  end
+
+  class Engine
+    after Slim::Parser, Slim::Include, :file, :include_dirs
+    after Slim::Include, :stop do |exp|
+      throw :stop, exp if Thread.current[:slim_include_level] > 1
+      exp
+    end
+
+    alias call_without_include call
+    def call(input)
+      Thread.current[:slim_include_engine] = self
+      Thread.current[:slim_include_level] ||= 0
+      Thread.current[:slim_include_level] += 1
+      catch(:stop) { call_without_include(input) }
+    ensure
+      Thread.current[:slim_include_engine] = nil if (Thread.current[:slim_include_level] -= 1) == 0
+    end
+  end
+end

data/lib/slim/interpolation.rb

@@ -23,7 +23,7 @@ module Slim
           string, code = parse_expression($')
           escape = code !~ /\A\{.*\}\Z/
           block << [:slim, :output, escape, escape ? code : code[1..-2], [:multi]]
-        when /\A([#\\]|[^#\\]*)/
+        when /\A([#\\]?[^#\\]*([#\\][^\\#\{][^#\\]*)*)/
           # Static text
           block << [:static, $&]
           string = $'

data/lib/slim/parser.rb

@@ -5,6 +5,8 @@ module Slim
   class Parser < Temple::Parser
     define_options :file,
                    :default_tag,
+                   :code_attr_delims,
+                   :attr_list_delims,
                    :tabsize => 4,
                    :shortcut => {
                      '#' => { :attr => 'id' },
@@ -14,7 +16,7 @@ module Slim
                      '(' => ')',
                      '[' => ']',
                      '{' => '}',
-                   }
+                    }
 
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
@@ -40,6 +42,8 @@ module Slim
 
     def initialize(opts = {})
       super
+      @attr_list_delims = options[:attr_list_delims] || options[:attr_delims]
+      @code_attr_delims = options[:code_attr_delims] || options[:attr_delims]
       tabsize = options[:tabsize]
       if tabsize > 1
         @tab_re = /\G((?: {#{tabsize}})*) {0,#{tabsize-1}}\t/
@@ -61,9 +65,12 @@ module Slim
       @attr_shortcut_re = /\A(#{keys}+)((?:#{WORD_RE}|-)*)/
       keys = Regexp.union @tag_shortcut.keys.sort_by {|k| -k.size }
       @tag_re = /\A(?:#{keys}|\*(?=[^\s]+)|(#{WORD_RE}(?:#{WORD_RE}|:|-)*#{WORD_RE}|#{WORD_RE}+))/
-      keys = Regexp.escape options[:attr_delims].keys.join
-      @delim_re = /\A[#{keys}]/
-      @attr_delim_re = /\A\s*([#{keys}])/
+      keys = Regexp.escape @code_attr_delims.keys.join
+      @code_attr_delims_re = /\A[#{keys}]/
+      keys = Regexp.escape @attr_list_delims.keys.join
+      @attr_list_delims_re = /\A\s*([#{keys}])/
+      # Access available engine keys to allow nicer one-line syntax
+      @embedded_re = /\A(#{Regexp.union(Embedded.engines.keys.map(&:to_s))}):(\s*)/
     end
 
     # Compile string to Temple expression
@@ -83,6 +90,7 @@ module Slim
     protected
 
     WORD_RE = ''.respond_to?(:encoding) ? '\p{Word}' : '\w'
+    LC_WORD_RE = '[_a-z0-9]'
     ATTR_NAME = "\\A\\s*(#{WORD_RE}(?:#{WORD_RE}|:|-)*)"
     QUOTED_ATTR_RE = /#{ATTR_NAME}\s*=(=?)\s*("|')/
     CODE_ATTR_RE = /#{ATTR_NAME}\s*=(=?)\s*/
@@ -100,7 +108,7 @@ module Slim
       #
       # We uses this information to figure out how many steps we must "jump"
       # out when we see an de-indented line.
-      @indents = [0]
+      @indents = []
 
       # Whenever we want to output something, we'll *always* output it to the
       # last stack in this array. So when there's a line that expects
@@ -138,6 +146,9 @@ module Slim
 
       indent = get_indent(@line)
 
+      # Choose first indentation yourself
+      @indents << indent if @indents.empty?
+
       # Remove the indentation
       @line.lstrip!
 
@@ -159,7 +170,7 @@ module Slim
         # This line was deindented.
         # Now we're have to go through the all the indents and figure out
         # how many levels we've deindented.
-        while indent < @indents.last
+        while indent < @indents.last && @indents.size > 1
           @indents.pop
           @stacks.pop
         end
@@ -180,7 +191,7 @@ module Slim
       case @line
       when /\A\/!( ?)/
         # HTML comment
-        @stacks.last << [:html, :comment, [:slim, :text, parse_text_block($', @indents.last + $1.size + 2)]]
+        @stacks.last << [:html, :comment, [:slim, :text, :verbatim, parse_text_block($', @indents.last + $1.size + 2)]]
       when /\A\/\[\s*(.*?)\s*\]\s*\Z/
         # HTML conditional comment
         block = [:multi]
@@ -190,9 +201,9 @@ module Slim
         # Slim comment
         parse_comment_block
       when /\A([\|'])( ?)/
-        # Found a text block.
+        # Found verbatim text block.
         trailing_ws = $1 == "'"
-        @stacks.last << [:slim, :text, parse_text_block($', @indents.last + $2.size + 1)]
+        @stacks.last << [:slim, :text, :verbatim, parse_text_block($', @indents.last + $2.size + 1)]
         @stacks.last << [:static, ' '] if trailing_ws
       when /\A</
         # Inline html
@@ -216,10 +227,10 @@ module Slim
         @stacks.last << [:slim, :output, $1.empty?, parse_broken_line, block]
         @stacks.last << [:static, ' '] if trailing_ws
         @stacks << block
-      when /\A(\w+):\s*\Z/
+      when @embedded_re
         # Embedded template detected. It is treated as block.
-        @stacks.last << [:slim, :embedded, $1, parse_text_block]
-      when /\Adoctype\s+/i
+        @stacks.last << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - $'.size + $2.size)]
+      when /\Adoctype\s+/
         # Found doctype declaration
         @stacks.last << [:html, :doctype, $'.strip]
       when @tag_re
@@ -227,11 +238,15 @@ module Slim
         @line = $' if $1
         parse_tag($&)
       else
-        syntax_error! 'Unknown line indicator'
+        unknown_line_indicator
       end
       @stacks.last << [:newline]
     end
 
+    def unknown_line_indicator
+      syntax_error! 'Unknown line indicator'
+    end
+
     def parse_comment_block
       while !@lines.empty? && (@lines.first =~ /\A\s*\Z/ || get_indent(@lines.first) > @indents.last)
         next_line
@@ -239,7 +254,7 @@ module Slim
       end
     end
 
-    def parse_text_block(first_line = nil, text_indent = nil, in_tag = false)
+    def parse_text_block(first_line = nil, text_indent = nil)
       result = [:multi]
       if !first_line || first_line.empty?
         text_indent = nil
@@ -269,11 +284,9 @@ module Slim
           # as deep as the first line.
           offset = text_indent ? indent - text_indent : 0
           if offset < 0
-            syntax_error!("Text line not indented deep enough.\n" +
-                          "The first text line defines the necessary text indentation." +
-                          (in_tag ? "\nAre you trying to nest a child tag in a tag containing text? Use | for the text block!" : ''))
+            text_indent += offset
+            offset = 0
           end
-
           result << [:newline] << [:slim, :interpolate, (text_indent ? "\n" : '') + (' ' * offset) + @line]
 
           # The indentation of first line of the text block
@@ -326,19 +339,22 @@ module Slim
       when /\A\s*:\s*/
         # Block expansion
         @line = $'
-        (@line =~ @tag_re) || syntax_error!('Expected tag')
-        @line = $' if $1
-        content = [:multi]
-        tag << content
-        i = @stacks.size
-        @stacks << content
-        parse_tag($&)
-        @stacks.delete_at(i)
+        if @line =~ @embedded_re
+          tag << [:slim, :embedded, $1, parse_text_block($', @orig_line.size - @line.size + $2.size)]
+        else
+          (@line =~ @tag_re) || syntax_error!('Expected tag')
+          @line = $' if $1
+          content = [:multi]
+          tag << content
+          i = @stacks.size
+          @stacks << content
+          parse_tag($&)
+          @stacks.delete_at(i)
+        end
       when /\A\s*=(=?)(['<>]*)/
         # Handle output code
         @line = $'
         trailing_ws2 = $2.include?('\'') || $2.include?('>')
-        leading_ws2 = $2.include?('<')
         block = [:multi]
         @stacks.last.insert(-2, [:static, ' ']) if !leading_ws && $2.include?('<')
         tag << [:slim, :output, $1 != '=', parse_broken_line, block]
@@ -353,17 +369,17 @@ module Slim
         content = [:multi]
         tag << content
         @stacks << content
-      when /\A( ?)(.*)\Z/
+      when /\A ?/
         # Text content
-        tag << [:slim, :text, parse_text_block($2, @orig_line.size - @line.size + $1.size, true)]
+        tag << [:slim, :text, :inline, parse_text_block($', @orig_line.size - $'.size)]
       end
     end
 
     def parse_attributes(attributes)
       # Check to see if there is a delimiter right after the tag name
       delimiter = nil
-      if @line =~ @attr_delim_re
-        delimiter = options[:attr_delims][$1]
+      if @line =~ @attr_list_delims_re
+        delimiter = @attr_list_delims[$1]
         @line = $'
       end
 
@@ -434,9 +450,9 @@ module Slim
             elsif @line[0] == close_delimiter[0]
               count -= 1
             end
-          elsif @line =~ @delim_re
+          elsif @line =~ @code_attr_delims_re
             count = 1
-            delimiter, close_delimiter = $&, options[:attr_delims][$&]
+            delimiter, close_delimiter = $&, @code_attr_delims[$&]
           end
           code << @line.slice!(0)
         end
@@ -448,27 +464,21 @@ module Slim
     def parse_quoted_attribute(quote)
       value, count = '', 0
 
-      until @line.empty? || (count == 0 && @line[0] == quote[0])
-        if @line =~ /\A\\\Z/
-          value << ' '
+      until count == 0 && @line[0] == quote[0]
+        if @line =~ /\A(\\)?\Z/
+          value << ($1 ? ' ' : "\n")
           expect_next_line
         else
-          if count > 0
-            if @line[0] == ?{
-              count += 1
-            elsif @line[0] == ?}
-              count -= 1
-            end
-          elsif @line =~ /\A#\{/
-            value << @line.slice!(0)
-            count = 1
+          if @line[0] == ?{
+            count += 1
+          elsif @line[0] == ?}
+            count -= 1
           end
           value << @line.slice!(0)
         end
       end
 
       syntax_error!("Expected closing brace }") if count != 0
-      syntax_error!("Expected closing quote #{quote}") if @line[0] != quote[0]
       @line.slice!(0)
 
       value
@@ -478,6 +488,11 @@ module Slim
     def syntax_error!(message)
       raise SyntaxError.new(message, options[:file], @orig_line, @lineno,
                             @orig_line && @line ? @orig_line.size - @line.size : 0)
+    rescue SyntaxError => ex
+      # HACK: Manipulate stacktrace for Rails and other frameworks
+      # to find the right file.
+      ex.backtrace.unshift "#{options[:file]}:#{@lineno}"
+      raise
     end
 
     def expect_next_line