slim 1.3.9 → 2.0.0

data/lib/slim/engine.rb

@@ -5,37 +5,23 @@ module Slim
     # 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
     # `define_options` when you have to override some default settings.
-    define_options :attr_quote,
-                   :merge_attrs,
-                   :pretty => false,
+    define_options :pretty => false,
                    :sort_attrs => true,
-                   :generator => Temple::Generators::ArrayBuffer,
-                   :default_tag => 'div',
                    :attr_quote => '"',
                    :merge_attrs => {'class' => ' '},
-                   :escape_quoted_attrs => false
-
-    # Removed in 2.0
-    define_deprecated_options :remove_empty_attrs,
-                              :chain,
-                              :escape_quoted_attrs,
-                              :attr_wrapper,
-                              :attr_delimiter
-
-    def initialize(opts = {})
-      super
-      deprecated = {}
-      deprecated[:merge_attrs] = options[:attr_delimiter] if options.include? :attr_delimiter
-      deprecated[:attr_quote] = options[:attr_wrapper] if options.include? :attr_wrapper
-      @options = Temple::ImmutableHash.new(deprecated, @options) unless deprecated.empty?
-    end
+                   :encoding => 'utf-8',
+                   :generator => Temple::Generators::ArrayBuffer,
+                   :default_tag => 'div'
 
-    use Slim::Parser, :file, :tabsize, :encoding, :shortcut, :default_tag, :escape_quoted_attrs
+    filter :Encoding, :encoding
+    filter :RemoveBOM
+    use Slim::Parser, :file, :tabsize, :shortcut, :default_tag
     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
+    use Slim::DoInserter
     use Slim::EndInserter
     use Slim::Controls, :disable_capture
-    use Slim::SplatAttributes, :merge_attrs, :attr_quote, :sort_attrs, :default_tag
     html :AttributeSorter, :sort_attrs
     html :AttributeMerger, :merge_attrs
     use Slim::CodeAttributes, :merge_attrs

data/lib/slim/erb_converter.rb

@@ -0,0 +1,14 @@
+require 'slim'
+
+module Slim
+  # Slim to ERB converter
+  #
+  # @example Conversion
+  #   Slim::ERBConverter.new(options).call(slim_code) # outputs erb_code
+  #
+  # @api public
+  class ERBConverter < Engine
+    replace :Optimizer, Temple::Filters::CodeMerger
+    replace :Generator, Temple::Generators::ERB
+  end
+end

data/lib/slim/filter.rb

@@ -23,8 +23,8 @@ module Slim
     end
 
     # Pass-through handler
-    def on_slim_output(code, escape, content)
-      [:slim, :output, code, escape, compile(content)]
+    def on_slim_output(escape, code, content)
+      [:slim, :output, escape, code, compile(content)]
     end
   end
 end

data/lib/slim/logic_less/context.rb

@@ -45,6 +45,10 @@ module Slim
         yield if !value || (value.respond_to?(:empty?) && value.empty?)
       end
 
+      def to_s
+        scope.to_s
+      end
+
       private
 
       class Scope
@@ -89,6 +93,10 @@ module Slim
           @parent[name] if @parent
         end
 
+        def to_s
+          @dict.to_s
+        end
+
         private
 
         def has_key?(name)

data/lib/slim/logic_less/filter.rb

@@ -12,17 +12,11 @@ module Slim
 
     def initialize(opts = {})
       super
-      access = options[:dictionary_access]
-      if access == :wrapped
-        warn 'Slim::LogicLess - Wrapped dictionary access is deprecated and unsupported in Slim 2.0'
-        access = DEFAULT_ACCESS_ORDER
-      else
-        access = [access].flatten.compact
-        access.each do |type|
-          raise ArgumentError, "Invalid dictionary access #{type.inspect}" unless DEFAULT_ACCESS_ORDER.include?(type)
-        end
-        raise ArgumentError, 'Option dictionary access is missing' if access.empty?
+      access = [options[:dictionary_access]].flatten.compact
+      access.each do |type|
+        raise ArgumentError, "Invalid dictionary access #{type.inspect}" unless DEFAULT_ACCESS_ORDER.include?(type)
       end
+      raise ArgumentError, 'Option dictionary access is missing' if access.empty?
       @access = access.inspect
     end
 
@@ -73,7 +67,14 @@ module Slim
     private
 
     def access(name)
-      name == 'yield' ? name : "#{@context}[#{name.to_sym.inspect}]"
+      case name
+      when 'yield'
+        'yield'
+      when 'self'
+        "#{@context}.to_s"
+      else
+        "#{@context}[#{name.to_sym.inspect}]"
+      end
     end
   end
 end

data/lib/slim/parser.rb

@@ -1,12 +1,11 @@
+# coding: utf-8
 module Slim
   # Parses Slim code and transforms it to a Temple expression
   # @api private
   class Parser < Temple::Parser
     define_options :file,
                    :default_tag,
-                   :escape_quoted_attrs,
                    :tabsize => 4,
-                   :encoding => 'utf-8',
                    :shortcut => {
                      '#' => { :attr => 'id' },
                      '.' => { :attr => 'class' }
@@ -46,16 +45,15 @@ module Slim
       end
       @tag_shortcut, @attr_shortcut = {}, {}
       options[:shortcut].each do |k,v|
-        v = deprecated_shortcut(v) if String === v
         raise ArgumentError, 'Shortcut requires :tag and/or :attr' unless (v[:attr] || v[:tag]) && (v.keys - [:attr, :tag]).empty?
         @tag_shortcut[k] = v[:tag] || options[:default_tag]
         if v.include?(:attr)
           @attr_shortcut[k] = v[:attr]
-          raise ArgumentError, 'You can only use special characters for attribute shortcuts' if k =~ /[\w-]/
+          raise ArgumentError, 'You can only use special characters for attribute shortcuts' if k =~ /(#{WORD_RE}|-)/
         end
       end
-      @attr_shortcut_regex = /\A(#{Regexp.union @attr_shortcut.keys})(\w[\w-]*\w|\w+)/
-      @tag_regex = /\A(?:#{Regexp.union @tag_shortcut.keys}|\*(?=[^\s]+)|(\w[\w:-]*\w|\w+))/
+      @attr_shortcut_re = /\A(#{Regexp.union @attr_shortcut.keys})(#{WORD_RE}(?:#{WORD_RE}|-)*#{WORD_RE}|#{WORD_RE}+)/
+      @tag_re = /\A(?:#{Regexp.union @tag_shortcut.keys}|\*(?=[^\s]+)|(#{WORD_RE}(?:#{WORD_RE}|:|-)*#{WORD_RE}|#{WORD_RE}+))/
     end
 
     # Compile string to Temple expression
@@ -63,8 +61,6 @@ module Slim
     # @param [String] str Slim code
     # @return [Array] Temple expression representing the code]]
     def call(str)
-      str = remove_bom(set_encoding(str))
-
       result = [:multi]
       reset(str.split(/\r?\n/), [result])
 
@@ -76,57 +72,18 @@ module Slim
 
     protected
 
-    DELIMITERS = {
+    DELIMS = {
       '(' => ')',
       '[' => ']',
       '{' => '}',
     }.freeze
 
-    ATTR_DELIM_REGEX = /\A\s*[#{Regexp.escape DELIMITERS.keys.join}]/
-    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_20 = /#{ATTR_NAME}\s*=(=?)\s*("|')/
-    CODE_ATTR_REGEX_20 = /#{ATTR_NAME}\s*=(=?)\s*/
-
-    # Convert deprecated string shortcut to hash
-    def deprecated_shortcut(v)
-      warn "Slim :shortcut string values are deprecated and unsupported in Slim 2.0, use hash like { '#' => { :tag => 'div', :attr => 'id' } }"
-      if v =~ /\A([^\s]+)\s+([^\s]+)\Z/
-        { :tag => $1, :attr => $2 }
-      else
-        { :attr => v }
-      end
-    end
-
-    # Set string encoding if option is set
-    def set_encoding(s)
-      if options[:encoding] && s.respond_to?(:encoding)
-        old_enc = s.encoding
-        s = s.dup if s.frozen?
-        s.force_encoding(options[:encoding])
-        # Fall back to old encoding if new encoding is invalid
-        unless s.valid_encoding?
-          s.force_encoding(old_enc)
-          s.force_encoding(Encoding::BINARY) unless s.valid_encoding?
-        end
-      end
-      s
-    end
-
-    # Remove unicode byte order mark from string
-    def remove_bom(s)
-      if s.respond_to?(:encoding)
-        if s.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?/
-          s.gsub(Regexp.new("\\A\uFEFF".encode(s.encoding.name)), '')
-        else
-          s
-        end
-      else
-        s.gsub(/\A\xEF\xBB\xBF/, '')
-      end
-    end
+    WORD_RE = ''.respond_to?(:encoding) ? '\p{Word}' : '\w'
+    DELIM_RE = /\A[#{Regexp.escape DELIMS.keys.join}]/
+    ATTR_DELIM_RE = /\A\s*([#{Regexp.escape DELIMS.keys.join}])/
+    ATTR_NAME = "\\A\\s*(#{WORD_RE}(?:#{WORD_RE}|:|-)*)"
+    QUOTED_ATTR_RE = /#{ATTR_NAME}\s*=(=?)\s*("|')/
+    CODE_ATTR_RE = /#{ATTR_NAME}\s*=(=?)\s*/
 
     def reset(lines = nil, stacks = nil)
       # Since you can indent however you like in Slim, we need to keep a list
@@ -237,7 +194,6 @@ module Slim
         @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
@@ -248,14 +204,15 @@ module Slim
         block = [:multi]
         @stacks.last << [:slim, :control, parse_broken_line, block]
         @stacks << block
-      when /\A=/
+      when /\A=(=?)(['<>]*)/
         # Found an output block.
         # We expect the line to be broken or the next line to be indented.
-        @line =~ /\A=(=?)('?)/
         @line = $'
+        trailing_ws = $2.include?('\'') || $2.include?('>')
         block = [:multi]
+        @stacks.last << [:static, ' '] if $2.include?('<')
         @stacks.last << [:slim, :output, $1.empty?, parse_broken_line, block]
-        @stacks.last << [:static, ' '] unless $2.empty?
+        @stacks.last << [:static, ' '] if trailing_ws
         @stacks << block
       when /\A(\w+):\s*\Z/
         # Embedded template detected. It is treated as block.
@@ -263,7 +220,7 @@ module Slim
       when /\Adoctype\s+/i
         # Found doctype declaration
         @stacks.last << [:html, :doctype, $'.strip]
-      when @tag_regex
+      when @tag_re
         # Found a HTML tag.
         @line = $' if $1
         parse_tag($&)
@@ -340,14 +297,33 @@ module Slim
         tag = @tag_shortcut[tag]
       end
 
-      tag = [:html, :tag, tag, parse_attributes]
+      # Find any shortcut attributes
+      attributes = [:html, :attrs]
+      while @line =~ @attr_shortcut_re
+        # The class/id attribute is :static instead of :slim :interpolate,
+        # because we don't want text interpolation in .class or #id shortcut
+        attributes << [:html, :attr, @attr_shortcut[$1], [:static, $2]]
+        @line = $'
+      end
+
+      @line =~ /\A[<>']*/
+      @line = $'
+      trailing_ws = $&.include?('\'') || $&.include?('>')
+      leading_ws = $&.include?('<')
+
+      parse_attributes(attributes)
+
+      tag = [:html, :tag, tag, attributes]
+
+      @stacks.last << [:static, ' '] if leading_ws
       @stacks.last << tag
+      @stacks.last << [:static, ' '] if trailing_ws
 
       case @line
       when /\A\s*:\s*/
         # Block expansion
         @line = $'
-        (@line =~ @tag_regex) || syntax_error!('Expected tag')
+        (@line =~ @tag_re) || syntax_error!('Expected tag')
         @line = $' if $1
         content = [:multi]
         tag << content
@@ -355,12 +331,14 @@ module Slim
         @stacks << content
         parse_tag($&)
         @stacks.delete_at(i)
-      when /\A\s*=(=?)('?)/
+      when /\A\s*=(=?)(['<>]*)/
         # Handle output code
         @line = $'
+        trailing_ws2 = $2.include?('\'') || $2.include?('>')
         block = [:multi]
+        @stacks.last << [:static, ' '] if !leading_ws && $2.include?('<')
         tag << [:slim, :output, $1 != '=', parse_broken_line, block]
-        @stacks.last << [:static, ' '] unless $2.empty?
+        @stacks.last << [:static, ' '] if !trailing_ws && trailing_ws2
         @stacks << block
       when /\A\s*\/\s*/
         # Closed tag. Do nothing
@@ -377,31 +355,17 @@ module Slim
       end
     end
 
-    def parse_attributes
-      attributes = [:html, :attrs]
-
-      # Find any shortcut attributes
-      while @line =~ @attr_shortcut_regex
-        # The class/id attribute is :static instead of :slim :interpolate,
-        # because we don't want text interpolation in .class or #id shortcut
-        attributes << [:html, :attr, @attr_shortcut[$1], [:static, $2]]
-        @line = $'
-      end
-
+    def parse_attributes(attributes)
       # Check to see if there is a delimiter right after the tag name
       delimiter = nil
-      if @line =~ ATTR_DELIM_REGEX
-        if $&.size > 1
-          warn "#{options[:file]}:#{@lineno} - spaces around attribute delimiters will be allowed in Slim 2.0. Your code is incompatible."
-        else
-          delimiter = DELIMITERS[$&]
-          @line.slice!(0)
-        end
+      if @line =~ ATTR_DELIM_RE
+        delimiter = DELIMS[$1]
+        @line = $'
       end
 
       if delimiter
-        boolean_attr_regex = /#{ATTR_NAME}(?=(\s|#{Regexp.escape delimiter}|\Z))/
-        end_regex = /\A\s*#{Regexp.escape delimiter}/
+        boolean_attr_re = /#{ATTR_NAME}(?=(\s|#{Regexp.escape delimiter}|\Z))/
+        end_re = /\A\s*#{Regexp.escape delimiter}/
       end
 
       while true
@@ -410,46 +374,28 @@ module Slim
           # Splat attribute
           @line = $'
           attributes << [:slim, :splat, parse_ruby_code(delimiter)]
-        when QUOTED_ATTR_REGEX
+        when QUOTED_ATTR_RE
           # Value is quoted (static)
           @line = $'
-          name = $1
-          escape = $2.empty?
-          quote = $3
-          value = parse_quoted_attribute(quote)
-          if escape && !options[:escape_quoted_attrs] && value =~ /&(amp|quot|gt|lt);/
-            warn "#{options[:file]}:#{@lineno} - quoted attribute value '#{value}' might be double escaped in Slim 2.0. Remove manually escaped entities and set :escape_quoted_attrs => true! :escaped_quoted_attrs is activated on Slim 2.0 by default."
-          end
-          attributes << [:html, :attr, name,
-                         [:escape, options[:escape_quoted_attrs] && escape,
-                          [:slim, :interpolate, value]]]
-        when CODE_ATTR_REGEX
+          attributes << [:html, :attr, $1,
+                         [:escape, $2.empty?, [:slim, :interpolate, parse_quoted_attribute($3)]]]
+        when CODE_ATTR_RE
           # Value is ruby code
           @line = $'
           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]]
-          if value =~ /\A[\[\{]/ && DELIMITERS[$&] == value[-1, 1]
-            warn "#{options[:file]}:#{@lineno} - ruby attribute value #{value} with curly braces/brackets is deprecated and unsupported in Slim 2.0. Use parentheses!"
-            value = value[1..-2]
-          end
           syntax_error!('Invalid empty attribute') if value.empty?
           attributes << [:html, :attr, name, [:slim, :attrvalue, escape, value]]
         else
-          if @line =~ QUOTED_ATTR_REGEX_20 || @line =~ CODE_ATTR_REGEX_20
-            warn "#{options[:file]}:#{@lineno} - you have spaces around =, this will be interpreted as attribute in Slim 2.0."
-          end
-
           break unless delimiter
 
           case @line
-          when boolean_attr_regex
+          when boolean_attr_re
             # Boolean attribute
             @line = $'
             attributes << [:html, :attr, $1, [:slim, :attrvalue, false, 'true']]
-          when end_regex
+          when end_re
             # Find ending delimiter
             @line = $'
             break
@@ -465,17 +411,15 @@ module Slim
           end
         end
       end
-
-      attributes
     end
 
     def parse_ruby_code(outer_delimiter)
       code, count, delimiter, close_delimiter = '', 0, nil, nil
 
       # Attribute ends with space or attribute delimiter
-      end_regex = /\A[\s#{Regexp.escape outer_delimiter.to_s}]/
+      end_re = /\A[\s#{Regexp.escape outer_delimiter.to_s}]/
 
-      until @line.empty? || (count == 0 && @line =~ end_regex)
+      until @line.empty? || (count == 0 && @line =~ end_re)
         if @line =~ /\A[,\\]\Z/
           code << @line << "\n"
           expect_next_line
@@ -486,9 +430,9 @@ module Slim
             elsif @line[0] == close_delimiter[0]
               count -= 1
             end
-          elsif @line =~ DELIMITER_REGEX
+          elsif @line =~ DELIM_RE
             count = 1
-            delimiter, close_delimiter = $&, DELIMITERS[$&]
+            delimiter, close_delimiter = $&, DELIMS[$&]
           end
           code << @line.slice!(0)
         end