slim 1.3.0 → 1.3.2

data/lib/slim/end_inserter.rb

@@ -24,7 +24,7 @@ module Slim
 
       exps.each do |exp|
         if control?(exp)
-          raise 'Explicit end statements are forbidden' if exp[2] =~ END_REGEX
+          raise(Temple::FilterError, 'Explicit end statements are forbidden') if exp[2] =~ END_REGEX
 
           # Two control code in a row. If this one is *not*
           # an else block, we should close the previous one.

data/lib/slim/engine.rb

@@ -4,29 +4,35 @@ module Slim
   class Engine < Temple::Engine
     # This overwrites some Temple default options or sets default options for Slim specific filters.
     # 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.
-    set_default_options :pretty => false,
-                        :sort_attrs => true,
-                        :attr_wrapper => '"',
-                        :attr_delimiter => {'class' => ' '},
-                        :remove_empty_attrs => true,
-                        :generator => Temple::Generators::ArrayBuffer,
-                        :default_tag => 'div'
+    # `define_options` when you have to override some default settings.
+    define_options :pretty => false,
+                   :sort_attrs => true,
+                   :attr_wrapper => '"',
+                   :attr_delimiter => {'class' => ' '},
+                   :generator => Temple::Generators::ArrayBuffer,
+                   :default_tag => 'div'
 
-    use Slim::Parser, :file, :tabsize, :encoding, :shortcut, :default_tag
+    # TODO: Remove these options in 1.4.0
+    define_deprecated_options :remove_empty_attrs, :chain
+
+    use Slim::Parser, :file, :tabsize, :encoding, :shortcut, :default_tag, :escape_quoted_attrs
     use Slim::EmbeddedEngine, :enable_engines, :disable_engines, :pretty
     use Slim::Interpolation
     use Slim::EndInserter
-    use Slim::Compiler, :disable_capture, :attr_delimiter, :attr_wrapper, :sort_attrs, :remove_empty_attrs, :default_tag
-    html :AttributeMerger, :attr_delimiter
+    use Slim::ControlStructures, :disable_capture
+    use Slim::SplatAttributes, :attr_delimiter, :attr_wrapper, :sort_attrs, :default_tag
     html :AttributeSorter, :sort_attrs
-    html :AttributeRemover, :remove_empty_attrs
+    html :AttributeMerger, :attr_delimiter
+    use Slim::BooleanAttributes, :attr_delimiter
     html :Pretty, :format, :attr_wrapper, :pretty, :indent
     filter :Escapable, :use_html_safe, :disable_escape
     filter :ControlFlow
     filter :MultiFlattener
-    use(:Optimizer) { (options[:streaming] ? Temple::Filters::StaticMerger :
-                       Temple::Filters::DynamicInliner).new }
-    use(:Generator) { options[:generator].new(options) }
+    use :Optimizer do
+      (options[:streaming] ? Temple::Filters::StaticMerger : Temple::Filters::DynamicInliner).new
+    end
+    use :Generator do
+      options[:generator].new(options.to_hash.reject {|k,v| !options[:generator].default_options.valid_keys.include?(k) })
+    end
   end
 end

data/lib/slim/filter.rb

@@ -31,11 +31,5 @@ module Slim
     def on_slim_attrs(*attrs)
       [:slim, :attrs, *attrs.map {|a| compile(a) }]
     end
-
-    # Pass-through handler
-    def on_slim_tag(name, attrs, content = nil)
-      tag = [:slim, :tag, name, compile(attrs)]
-      content ? (tag << compile(content)) : tag
-    end
   end
 end

data/lib/slim/grammar.rb

@@ -10,14 +10,9 @@ module Slim
       [:slim, :interpolate, String]                   |
       [:slim, :embedded, String, Expression]          |
       [:slim, :text, Expression]                      |
-      [:slim, :tag, String, SlimAttrs, 'Expression?']
+      [:slim, :attrvalue, Bool, String]
 
-    SlimAttrs <<
-      [:slim, :attrs, 'SlimAttr*']
-
-    SlimAttr <<
-      HTMLAttr                             |
-      [:slim, :attr, String, Bool, String] |
+    HTMLAttr <<
       [:slim, :splat, String]
   end
 end

data/lib/slim/interpolation.rb

@@ -45,7 +45,7 @@ module Slim
         i += 1
       end
 
-      raise "Text interpolation: Expected closing }" if count != 0
+      raise(Temple::FilterError, "Text interpolation: Expected closing }") if count != 0
 
       return string[i..-1], string[0, i-1]
     end

data/lib/slim/logic_less/filter.rb

@@ -1,16 +1,16 @@
 module Slim
-  # Handle logic-less mode
+  # Handle logic less mode
   # This filter can be activated with the option "logic_less"
   # @api private
   class LogicLess < Filter
-    set_default_options :logic_less => true,
-                        :dictionary => 'self',
-                        :dictionary_access => :wrapped # :symbol, :string, :wrapped
+    define_options :logic_less => true,
+                   :dictionary => 'self',
+                   :dictionary_access => :wrapped # :symbol, :string, :wrapped
 
     def initialize(opts = {})
       super
       unless [:string, :symbol, :wrapped].include?(options[:dictionary_access])
-        raise "Invalid dictionary access #{options[:dictionary_access].inspect}"
+        raise ArgumentError, "Invalid dictionary access #{options[:dictionary_access].inspect}"
       end
     end
 
@@ -37,7 +37,7 @@ module Slim
     end
 
     def on_slim_output(escape, name, content)
-      raise 'Output statements with content are forbidden in logic less mode' if !empty_exp?(content)
+      raise(Temple::FilterError, 'Output statements with content are forbidden in logic less mode') if !empty_exp?(content)
       [:slim, :output, escape, access(name), content]
     end
 
@@ -50,11 +50,11 @@ module Slim
     end
 
     def on_dynamic(code)
-      raise 'Embedded code is forbidden in logic less mode'
+      raise Temple::FilterError, 'Embedded code is forbidden in logic less mode'
     end
 
     def on_code(code)
-      raise 'Embedded code is forbidden in logic less mode'
+      raise Temple::FilterError, 'Embedded code is forbidden in logic less mode'
     end
 
     protected

data/lib/slim/logic_less/wrapper.rb

@@ -1,6 +1,6 @@
 module Slim
   class LogicLess
-    # For logic-less mode, objects can be encased in the Wrapper class.
+    # For logic less mode, objects can be encased in the Wrapper class.
     # @api private
     class Wrapper
       attr_reader :value, :parent

data/lib/slim/parser.rb

@@ -1,15 +1,16 @@
 module Slim
   # Parses Slim code and transforms it to a Temple expression
   # @api private
-  class Parser
-    include Temple::Mixins::Options
-
-    set_default_options :tabsize => 4,
-                        :encoding => 'utf-8',
-                        :shortcut => {
-                          '#' => 'id',
-                          '.' => 'class'
-                        }
+  class Parser < Temple::Parser
+    define_options :file,
+                   :default_tag,
+                   :escape_quoted_attrs => false,
+                   :tabsize => 4,
+                   :encoding => 'utf-8',
+                   :shortcut => {
+                     '#' => 'id',
+                     '.' => 'class'
+                   }
 
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
@@ -26,22 +27,22 @@ module Slim
         line = @line.strip
         column = @column + line.size - @line.size
         %{#{error}
-  #{file}, Line #{lineno}
+  #{file}, Line #{lineno}, Column #{@column}
     #{line}
     #{' ' * column}^
 }
       end
     end
 
-    def initialize(options = {})
+    def initialize(opts = {})
       super
-      @tab = ' ' * @options[:tabsize]
+      @tab = ' ' * options[:tabsize]
       @shortcut = {}
-      @options[:shortcut].each do |k,v|
+      options[:shortcut].each do |k,v|
         @shortcut[k] = if v =~ /\A([^\s]+)\s+([^\s]+)\Z/
                          [$1, $2]
                        else
-                         [@options[:default_tag], v]
+                         [options[:default_tag], v]
                        end
       end
       shortcut = "[#{Regexp.escape @shortcut.keys.join}]"
@@ -72,7 +73,7 @@ module Slim
       result
     end
 
-    private
+    protected
 
     DELIMITERS = {
       '(' => ')',
@@ -82,8 +83,8 @@ module Slim
 
     DELIMITER_REGEX = /\A[#{Regexp.escape DELIMITERS.keys.join}]/
     ATTR_NAME = '\A\s*(\w[:\w-]*)'
-    QUOTED_ATTR_REGEX = /#{ATTR_NAME}=("|')/
-    CODE_ATTR_REGEX = /#{ATTR_NAME}=/
+    QUOTED_ATTR_REGEX = /#{ATTR_NAME}=(=?)("|')/
+    CODE_ATTR_REGEX = /#{ATTR_NAME}=(=?)/
 
     def reset(lines = nil, stacks = nil)
       # Since you can indent however you like in Slim, we need to keep a list
@@ -176,25 +177,28 @@ module Slim
 
     def parse_line_indicators
       case @line
+      when /\A\/!( ?)/
+        # HTML comment
+        @stacks.last << [:html, :comment, [:slim, :text, parse_text_block($', @indents.last + $1.size + 2)]]
+      when /\A\/\[\s*(.*?)\s*\]\s*\Z/
+        # HTML conditional comment
+        block = [:multi]
+        @stacks.last << [:html, :condcomment, $1, block]
+        @stacks << block
       when /\A\//
-        # Found a comment block.
-        if @line =~ %r{\A/!( ?)(.*)\Z}
-          # HTML comment
-          @stacks.last << [:html, :comment, [:slim, :text, parse_text_block($2, @indents.last + $1.size + 2)]]
-        elsif @line =~ %r{\A/\[\s*(.*?)\s*\]\s*\Z}
-          # HTML conditional comment
-          block = [:multi]
-          @stacks.last << [:html, :condcomment, $1, block]
-          @stacks << block
-        else
-          # Slim comment
-          parse_comment_block
-        end
-      when /\A([\|'])( ?)(.*)\Z/
+        # Slim comment
+        parse_comment_block
+      when /\A([\|'])( ?)/
         # Found a text block.
         trailing_ws = $1 == "'"
-        @stacks.last << [:slim, :text, parse_text_block($3, @indents.last + $2.size + 1)]
+        @stacks.last << [:slim, :text, parse_text_block($', @indents.last + $2.size + 1)]
         @stacks.last << [:static, ' '] if trailing_ws
+      when /\A</
+        # Inline html
+        # @stacks.last << parse_text_block(@line, @indents.last + 1)
+        block = [:multi]
+        @stacks.last << [:multi, [:slim, :interpolate, @line], block]
+        @stacks << block
       when /\A-/
         # Found a code block.
         # We expect the line to be broken or the next line to be indented.
@@ -289,7 +293,7 @@ module Slim
     end
 
     def parse_tag(tag)
-      tag = [:slim, :tag, @shortcut[tag] ? @shortcut[tag][0] : tag, parse_attributes]
+      tag = [:html, :tag, @shortcut[tag] ? @shortcut[tag][0] : tag, parse_attributes]
       @stacks.last << tag
 
       case @line
@@ -325,7 +329,7 @@ module Slim
     end
 
     def parse_attributes
-      attributes = [:slim, :attrs]
+      attributes = [:html, :attrs]
 
       # Find any shortcut attributes
       while @line =~ @shortcut_regex
@@ -356,20 +360,21 @@ module Slim
         when QUOTED_ATTR_REGEX
           # Value is quoted (static)
           @line = $'
-          attributes << [:html, :attr, $1, [:slim, :interpolate, parse_quoted_attribute($2)]]
+          attributes << [:html, :attr, $1,
+                         [:escape, options[:escape_quoted_attrs] && $2.empty?,
+                          [:slim, :interpolate, parse_quoted_attribute($3)]]]
         when CODE_ATTR_REGEX
           # Value is ruby code
           @line = $'
-          escape = @line[0] != ?=
-          @line.slice!(0) unless escape
           name = $1
+          escape = $2.empty?
           value = parse_ruby_code(delimiter)
           # Remove attribute wrapper which doesn't belong to the ruby code
           # e.g id=[hash[:a] + hash[:b]]
           value = value[1..-2] if value =~ DELIMITER_REGEX &&
             DELIMITERS[$&] == value[-1, 1]
           syntax_error!('Invalid empty attribute') if value.empty?
-          attributes << [:slim, :attr, name, escape, value]
+          attributes << [:html, :attr, name, [:slim, :attrvalue, escape, value]]
         else
           break unless delimiter
 
@@ -377,7 +382,7 @@ module Slim
           when boolean_attr_regex
             # Boolean attribute
             @line = $'
-            attributes << [:slim, :attr, $1, false, 'true']
+            attributes << [:html, :attr, $1, [:slim, :attrvalue, false, 'true']]
           when end_regex
             # Find ending delimiter
             @line = $'
@@ -389,11 +394,8 @@ module Slim
 
             # Attributes span multiple lines
             @stacks.last << [:newline]
-            orig_line, lineno = @orig_line, @lineno
-            next_line || syntax_error!("Expected closing delimiter #{delimiter}",
-                                       :orig_line => orig_line,
-                                       :lineno => lineno,
-                                       :column => orig_line.size)
+            syntax_error!("Expected closing delimiter #{delimiter}") if @lines.empty?
+            next_line
           end
         end
       end
@@ -442,19 +444,16 @@ module Slim
       end
 
       syntax_error!("Expected closing brace }") if count != 0
+      syntax_error!("Expected closing quote #{quote}") if @line[0] != quote[0]
       @line.slice!(0)
+
       value
     end
 
     # Helper for raising exceptions
-    def syntax_error!(message, args = {})
-      args[:orig_line] ||= @orig_line
-      args[:line] ||= @line
-      args[:lineno] ||= @lineno
-      args[:column] ||= args[:orig_line] && args[:line] ?
-                        args[:orig_line].size - args[:line].size : 0
-      raise SyntaxError.new(message, options[:file],
-                            args[:orig_line], args[:lineno], args[:column])
+    def syntax_error!(message)
+      raise SyntaxError.new(message, options[:file], @orig_line, @lineno,
+                            @orig_line && @line ? @orig_line.size - @line.size : 0)
     end
   end
 end

data/lib/slim/splat_attributes.rb

@@ -0,0 +1,112 @@
+module Slim
+  # @api private
+  class SplatAttributes < Filter
+    define_options :attr_delimiter, :attr_wrapper, :sort_attrs, :default_tag
+
+    def call(exp)
+      @attr_delimiter, @splat_used = unique_name, false
+      exp = compile(exp)
+      if @splat_used
+        [:multi, [:code, "#{@attr_delimiter} = #{@options[:attr_delimiter].inspect}"], exp]
+      else
+        exp
+      end
+    end
+
+    # Handle tag expression `[:html, :tag, name, attrs, content]`
+    #
+    # @param [String] name Tag name
+    # @param [Array] attrs Temple expression
+    # @param [Array] content Temple expression
+    # @return [Array] Compiled temple expression
+    def on_html_tag(name, attrs, content = nil)
+      return super if name != '*'
+      hash, merger, formatter = splat_attributes(attrs[2..-1])
+      tmp = unique_name
+      tag = [:multi,
+             merger,
+             [:code, "#{tmp} = #{hash}.delete('tag').to_s"],
+             [:if, "#{tmp}.empty?",
+              [:code, "#{tmp} = #{@options[:default_tag].inspect}"]],
+             [:static, '<'],
+             [:dynamic, "#{tmp}"],
+             formatter]
+      tag << if content
+               [:multi,
+                [:static, '>'],
+                compile(content),
+                [:static, '</'],
+                [:dynamic, "#{tmp}"],
+                [:static, '>']]
+             else
+               [:static, '/>']
+             end
+    end
+
+    # Handle attributes expression `[:html, :attrs, *attrs]`
+    #
+    # @param [Array] attrs Array of temple expressions
+    # @return [Array] Compiled temple expression
+    def on_html_attrs(*attrs)
+      return super if attrs.all? {|attr| attr[1] != :splat}
+      hash, merger, formatter = splat_attributes(attrs)
+      [:multi, merger, formatter]
+    end
+
+    protected
+
+    def splat_attributes(attrs)
+      @splat_used = true
+
+      hash, name, value, tmp = unique_name, unique_name, unique_name, unique_name
+
+      merger = [:multi, [:code, "#{hash} = {}"]]
+      attrs.each do |attr|
+        merger << if attr[0] == :html && attr[1] == :attr
+          [:multi,
+           [:capture, tmp, compile(attr[3])],
+           [:code, "(#{hash}[#{attr[2].inspect}] ||= []) << #{tmp}"]]
+        elsif attr[0] == :slim
+          if attr[1] == :attr
+            [:code, "(#{hash}[#{attr[2].inspect}] ||= []) << (#{attr[4]})"]
+          elsif attr[1] == :splat
+            [:code, "(#{attr[2]}).each {|#{name},#{value}| (#{hash}[#{name}.to_s] ||= []) << (#{value}) }"]
+          else
+            attr
+          end
+        else
+          attr
+        end
+      end
+
+      merger << [:block, "#{hash}.each do |#{name},#{value}|",
+                 [:multi,
+                  [:code, "#{value}.flatten!"],
+                  [:if, "#{value}.size > 1 && !#{@attr_delimiter}[#{name}]",
+                   [:code, %{raise("Multiple #\{#{name}\} attributes specified")}]],
+                  [:code, "#{value}.compact!"],
+                  [:case, "#{value}.size",
+                   ['0',
+                    [:code, "#{hash}[#{name}] = nil"]],
+                   ['1',
+                    [:case, "#{value}.first",
+                     ['true', [:code, "#{hash}[#{name}] = #{name}"]],
+                     ['false, nil', [:code, "#{hash}[#{name}] = nil"]],
+                     [:else, [:code, "#{hash}[#{name}] = #{value}.first"]]]],
+                   [:else,
+                    [:code, "#{hash}[#{name}] = #{value}.join(#{@attr_delimiter}[#{name}].to_s)"]]]]]
+
+      attr = [:if, value,
+              [:multi,
+               [:static, ' '],
+               [:dynamic, name],
+               [:static, "=#{options[:attr_wrapper]}"],
+               [:escape, true, [:dynamic, value]],
+               [:static, options[:attr_wrapper]]]]
+      enumerator = options[:sort_attrs] ? "#{hash}.sort_by {|#{name},#{value}| #{name} }" : hash
+      formatter = [:block, "#{enumerator}.each do |#{name},#{value}|", attr]
+
+      return hash, merger, formatter
+    end
+  end
+end