slim 1.1.1 → 1.2.0

data/.travis.yml

@@ -4,6 +4,7 @@ rvm:
   - ruby-head
   - jruby
   - rbx-18mode
+  - rbx-19mode
 env:
   - "TASK=test"
   - "TASK=test TEMPLE=master"

data/CHANGES

@@ -1,3 +1,15 @@
+1.2.0
+
+  * Add option :shortcut which configures attribute shortcuts
+    Default setting:
+      Slim::Parser.default_options[:shortcut] = {'#' => 'id', '.' => 'class', '*' => '*'}
+    Define custom shortcut attribute (e.g. a@ajax-link renders <a role="ajax-link"></a>)
+      Slim::Parser.default_options[:shortcut] = {'@' => 'role'}
+    Define custom shortcut attribute with tag (e.g. @ajax-link renders <a role="ajax-link"></a>)
+      Slim::Parser.default_options[:shortcut] = {'@' => 'a role'}
+  * Add syntax for splat attributes (#109)
+  * Support for dynamic tags, e.g. *{:tag => 'img', :src => 'image.jpg'}
+
 1.1.1
 
   * Evaluating a html attribute now happens only once (#219)

data/README.md

@@ -41,11 +41,16 @@ If you want to use the Slim template directly, you can use the Tilt interface:
 
 ## Syntax Highlighters
 
-Syntax highlight support for __Emacs__ is included in the `extra` folder. There are also [Vim](https://github.com/bbommarito/vim-slim) and [Textmate](https://github.com/fredwu/ruby-slim-tmbundle) plugins.
+There are plugins for Vim, Emacs, Textmate and Espresso text editor:
+
+* [Vim](https://github.com/bbommarito/vim-slim)
+* [Textmate](https://github.com/fredwu/ruby-slim-tmbundle)
+* [Emacs](https://github.com/minad/emacs-slim)
+* [Espresso text editor](https://github.com/CiiDub/Slim-Sugar)
 
 ## Template Converters
 
-For Haml, there is a [Haml2Slim converter](https://github.com/fredwu/haml2slim). Please check out the [issue tracker](https://github.com/stonean/slim/issues) to see the status of the varies converters.
+For Haml, there is a [Haml2Slim converter](https://github.com/fredwu/haml2slim). For HTML, there is a [HTML2Slim converter](https://github.com/joaomilho/html2slim).
 
 ## The syntax
 
@@ -124,7 +129,7 @@ Here's a quick example to demonstrate what a Slim template looks like:
 
 #### `/!`
 
-> Use the forward slash immediately followed by an exclamation mark for html comments (`<!-- -->`).
+> Use the forward slash immediately followed by an exclamation mark for html comments (` <!-- --> `).
 
 
 ### Things to know
@@ -388,8 +393,19 @@ This project is released under the MIT license.
 
 ## Slim related projects
 
-* [Vim files](https://github.com/bbommarito/vim-slim)
+* [Temple](https://github.com/judofyr/slim)
+
+* [Vim syntax highlighting](https://github.com/bbommarito/vim-slim)
+* [Emacs syntax highlighting](https://github.com/minad/emacs-slim)
 * [Textmate bundle](https://github.com/fredwu/ruby-slim-tmbundle)
+* [Slim support for the Espresso text editor from MacRabbits](https://github.com/CiiDub/Slim-Sugar)
+
 * [Haml2Slim converter](https://github.com/fredwu/haml2slim)
+* [Html2Slim converter](https://github.com/joaomilho/html2slim)
+
 * [Rails 3 Generators](https://github.com/leogalmeida/slim-rails)
+
+* [Skim (Slim for Javascript)](https://github.com/jfirebaugh/skim)
 * [Slim for Clojure](https://github.com/chaslemley/slim.clj)
+* [Hamlet.rb (Similar template language)](https://github.com/gregwebs/hamlet.rb)
+* [Coffee script plugin for Slim](https://github.com/yury/coffee-views)

data/lib/slim/compiler.rb

@@ -1,7 +1,16 @@
 module Slim
-  # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
+    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 control expression `[:slim, :control, code, content]`
     #
     # @param [String] ruby code
@@ -19,7 +28,11 @@ module Slim
     # @param [Array] content Temple expression
     # @return [Array] Compiled temple expression
     def on_slim_condcomment(condition, content)
-      [:html, :comment, [:multi, [:static, "[#{condition}]>"], compile(content), [:static, '<![endif]']]]
+      [:html, :comment,
+       [:multi,
+        [:static, "[#{condition}]>"],
+        compile(content),
+        [:static, '<![endif]']]]
     end
 
     # Handle output expression `[:slim, :output, escape, code, content]`
@@ -54,6 +67,53 @@ module Slim
       end
     end
 
+    # Handle tag expression `[:slim, :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_slim_tag(name, attrs, content = nil)
+      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
+      else
+        tag = [:html, :tag, name, compile(attrs)]
+        content ? (tag << compile(content)) : tag
+      end
+    end
+
+    # Handle attributes expression `[:slim, :attrs, *attrs]`
+    #
+    # @param [Array] *attrs Array of temple expressions
+    # @return [Array] Compiled temple expression
+    def on_slim_attrs(*attrs)
+      if attrs.any? {|attr| attr[1] == :splat}
+        hash, merger, formatter = splat_attributes(attrs)
+        [:multi, merger, formatter]
+      else
+        [:html, :attrs, *attrs.map {|a| compile(a) }]
+      end
+    end
+
     # Handle attribute expression `[:slim, :attr, escape, code]`
     #
     # @param [Boolean] escape Escape html
@@ -62,10 +122,8 @@ module Slim
     def on_slim_attr(name, escape, code)
       value = case code
       when 'true'
-        escape = false
         [:static, name]
       when 'false', 'nil'
-        escape = false
         [:multi]
       else
         tmp = unique_name
@@ -75,15 +133,67 @@ module Slim
           ['true', [:static, name]],
           ['false, nil', [:multi]],
           [:else,
-           [:dynamic,
+           [:escape, escape, [:dynamic,
             if delimiter = options[:attr_delimiter][name]
               "#{tmp}.respond_to?(:join) ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"
             else
               tmp
             end
-           ]]]]
+           ]]]]]
       end
-      [:html, :attr, name, [:escape, escape, value]]
+      [:html, :attr, name, value]
+    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}.keys.each do |#{name}|",
+                 [:multi,
+                  [:code, "#{value} = #{hash}[#{name}]"],
+                  [:code, "#{value}.flatten!"],
+                  [:block, "#{value}.map! do |#{tmp}|",
+                   [:case, tmp,
+                    ['true', [:code, name]],
+                    ['false, nil', [:multi]],
+                    [:else, [:code, tmp]]]],
+                  [:if, "#{value}.size > 1 && !#{@attr_delimiter}[#{name}]",
+                   [:code, "raise(\"Multiple #\{#{name}\} attributes specified\")"]],
+                  [:code, "#{hash}[#{name}] = #{value}.compact.join(#{@attr_delimiter}[#{name}].to_s)"]]]
+
+      attr = [:multi,
+              [:static, ' '],
+              [:dynamic, name],
+              [:static, "=#{options[:attr_wrapper]}"],
+              [:escape, true, [:dynamic, value]],
+              [:static, options[:attr_wrapper]]]
+      attr = [:if, "!#{value}.empty?", attr] if options[:remove_empty_attrs]
+      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

data/lib/slim/embedded_engine.rb

@@ -179,6 +179,7 @@ module Slim
     register :rdoc,       InterpolateTiltEngine
     register :creole,     InterpolateTiltEngine
     register :wiki,       InterpolateTiltEngine
+    register :mediawiki,  InterpolateTiltEngine
 
     # These engines are executed at compile time
     register :coffee,     TagEngine,  :tag => :script, :attributes => { :type => 'text/javascript' },  :engine => StaticTiltEngine

data/lib/slim/engine.rb

@@ -9,10 +9,12 @@ module Slim
     #
     # This overwrites some temple default options.
     set_default_options :pretty => false,
+                        :sort_attrs => true,
                         :attr_wrapper => '"',
                         :attr_delimiter => {'class' => ' '},
-                        :generator => Temple::Generators::ArrayBuffer
-
+                        :remove_empty_attrs => true,
+                        :generator => Temple::Generators::ArrayBuffer,
+                        :default_tag => 'div'
     #
     # Document all supported options with purpose, type etc.
     #
@@ -22,6 +24,7 @@ module Slim
     # Integer     | :tabsize           | 4                             | Number of whitespaces per tab (used by the parser)
     # String      | :encoding          | "utf-8"                       | Set encoding of template
     # String      | :default_tag       | "div"                         | Default tag to be used if tag name is omitted
+    # Hash        | :shortcut          | {'.' => 'class', ...}         | Attribute shortcuts
     # String list | :enable_engines    | All enabled                   | List of enabled embedded engines (whitelist)
     # String list | :disable_engines   | None disabled                 | List of disabled embedded engines (blacklist)
     # Boolean     | :sections          | false                         | Enable sections mode (logic-less)
@@ -56,12 +59,12 @@ module Slim
     # 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.
     #
-    use Slim::Parser, :file, :tabsize, :encoding, :default_tag
+    use Slim::Parser, :file, :tabsize, :encoding, :shortcut, :default_tag
     use Slim::EmbeddedEngine, :enable_engines, :disable_engines, :pretty
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
-    use Slim::Compiler, :disable_capture, :attr_delimiter
+    use Slim::Compiler, :disable_capture, :attr_delimiter, :attr_wrapper, :sort_attrs, :remove_empty_attrs, :default_tag
     html :AttributeMerger, :attr_delimiter
     html :AttributeSorter, :sort_attrs
     html :AttributeRemover, :remove_empty_attrs

data/lib/slim/filter.rb

@@ -26,5 +26,16 @@ module Slim
     def on_slim_output(code, escape, content)
       [:slim, :output, code, escape, compile(content)]
     end
+
+    # Pass-through handler
+    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

@@ -5,14 +5,19 @@ module Slim
     extend Temple::Grammar
 
     Expression <<
-      [:slim, :control, String, Expression]       |
-      [:slim, :condcomment, String, Expression]   |
-      [:slim, :output, Bool, String, Expression]  |
-      [:slim, :interpolate, String]               |
-      [:slim, :embedded, String, Expression]
+      [:slim, :control, String, Expression]           |
+      [:slim, :condcomment, String, Expression]       |
+      [:slim, :output, Bool, String, Expression]      |
+      [:slim, :interpolate, String]                   |
+      [:slim, :embedded, String, Expression]          |
+      [:slim, :tag, String, SlimAttrs, 'Expression?']
 
-    HTMLAttr <<
-      [:slim, :attr, String, Bool, String]
+    SlimAttrs <<
+      [:slim, :attrs, 'SlimAttr*']
 
+    SlimAttr <<
+      HTMLAttr                             |
+      [:slim, :attr, String, Bool, String] |
+      [:slim, :splat, String]
   end
 end

data/lib/slim/interpolation.rb

@@ -16,7 +16,7 @@ module Slim
         case string
         when /\A\\#\{/
           # Escaped interpolation
-          # HACK: Use :slim :output because this is used by InterpolateTiltEngine
+          # Use [:slim, :output] because this is used by InterpolateTiltEngine
           # to filter out protected strings (Issue #141).
           block << [:slim, :output, false, '\'#{\'', [:multi]]
           string = $'

data/lib/slim/parser.rb

@@ -4,9 +4,12 @@ module Slim
   class Parser
     include Temple::Mixins::Options
 
-    set_default_options :tabsize  => 4,
+    set_default_options :tabsize => 4,
                         :encoding => 'utf-8',
-                        :default_tag => 'div'
+                        :shortcut => {
+                          '#' => 'id',
+                          '.' => 'class'
+                        }
 
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
@@ -33,6 +36,17 @@ module Slim
     def initialize(options = {})
       super
       @tab = ' ' * @options[:tabsize]
+      @shortcut = {}
+      @options[:shortcut].each do |k,v|
+        @shortcut[k] = if v =~ /\A([^\s]+)\s+([^\s]+)\Z/
+                         [$1, $2]
+                       else
+                         [@options[:default_tag], v]
+                       end
+      end
+      shortcut = "[#{Regexp.escape @shortcut.keys.join}]"
+      @shortcut_regex = /\A(#{shortcut})(\w[\w-]*\w|\w+)/
+      @tag_regex = /\A(?:#{shortcut}|\*(?=[^\s]+)|(\w[\w:-]*\w|\w+))/
     end
 
     # Compile string to Temple expression
@@ -66,15 +80,10 @@ module Slim
       '{' => '}',
     }.freeze
 
-    ATTR_SHORTCUT = {
-      '#' => 'id',
-      '.' => 'class',
-    }.freeze
-
-    DELIMITER_REGEX = /\A[\(\[\{]/
-    ATTR_NAME_REGEX = '\A\s*(\w[:\w-]*)'
-    CLASS_ID_REGEX = /\A(#|\.)(\w[\w-]*\w|\w+)/
-    TAG_REGEX = /\A([#\.]|\w[\w:-]*\w|\w+)/
+    DELIMITER_REGEX = /\A[#{Regexp.escape DELIMITERS.keys.join}]/
+    ATTR_NAME = '\A\s*(\w[:\w-]*)'
+    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
@@ -208,8 +217,9 @@ module Slim
       when /\Adoctype\s+/i
         # Found doctype declaration
         @stacks.last << [:html, :doctype, $'.strip]
-      when TAG_REGEX
+      when @tag_regex
         # Found a HTML tag.
+        @line = $' if $1
         parse_tag($&)
       else
         syntax_error! 'Unknown line indicator'
@@ -279,25 +289,20 @@ module Slim
     end
 
     def parse_tag(tag)
-      if tag == '#' || tag == '.'
-        tag = options[:default_tag]
-      else
-        @line.slice!(0, tag.size)
-      end
-
-      tag = [:html, :tag, tag, parse_attributes]
+      tag = [:slim, :tag, @shortcut[tag] ? @shortcut[tag][0] : tag, parse_attributes]
       @stacks.last << tag
 
       case @line
       when /\A\s*:\s*/
         # Block expansion
         @line = $'
-        (@line =~ TAG_REGEX) || syntax_error!('Expected tag')
+        (@line =~ @tag_regex) || syntax_error!('Expected tag')
+        @line = $' if $1
         content = [:multi]
         tag << content
         i = @stacks.size
         @stacks << content
-        parse_tag($1)
+        parse_tag($&)
         @stacks.delete_at(i)
       when /\A\s*=(=?)('?)/
         # Handle output code
@@ -321,13 +326,14 @@ module Slim
     end
 
     def parse_attributes
-      attributes = [:html, :attrs]
+      attributes = [:slim, :attrs]
+      attribute = nil
 
-      # Find any literal class/id attributes
-      while @line =~ CLASS_ID_REGEX
+      # Find any shortcut attributes
+      while @line =~ @shortcut_regex
         # The class/id attribute is :static instead of :slim :text,
         # because we don't want text interpolation in .class or #id shortcut
-        attributes << [:html, :attr, ATTR_SHORTCUT[$1], [:static, $2]]
+        attributes << [:html, :attr, @shortcut[$1][1], [:static, $2]]
         @line = $'
       end
 
@@ -338,54 +344,67 @@ module Slim
         @line.slice!(0)
       end
 
-      orig_line = @orig_line
-      lineno = @lineno
+      if delimiter
+        boolean_attr_regex = /#{ATTR_NAME}(?=(\s|#{Regexp.escape delimiter}))/
+        end_regex = /\A\s*#{Regexp.escape delimiter}/
+      end
+
       while true
-        # Parse attributes
-        attr_regex = delimiter ? /#{ATTR_NAME_REGEX}(=|\s|(?=#{Regexp.escape delimiter}))/ : /#{ATTR_NAME_REGEX}=/
-        while @line =~ attr_regex
+        case @line
+        when /\A\s*\*(?=[^\s]+)/
+          # Splat attribute
+          @line = $'
+          attributes << [:slim, :splat, parse_ruby_code(delimiter)]
+        when QUOTED_ATTR_REGEX
+          # Value is quoted (static)
           @line = $'
+          attributes << [:html, :attr, $1, [:slim, :interpolate, parse_quoted_attribute($2)]]
+        when CODE_ATTR_REGEX
+          # Value is ruby code
+          @line = $'
+          escape = @line[0] != ?=
+          @line.slice!(0) unless escape
           name = $1
-          if delimiter && $2 != '='
-            attributes << [:slim, :attr, name, false, 'true']
-          elsif @line =~ /\A["']/
-            # Value is quoted (static)
+          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]
+        else
+          break unless delimiter
+
+          case @line
+          when boolean_attr_regex
+            # Boolean attribute
             @line = $'
-            attributes << [:html, :attr, name, [:slim, :interpolate, parse_quoted_attribute($&)]]
+            attributes << [:slim, :attr, $1, false, 'true']
+          when end_regex
+            # Find ending delimiter
+            @line = $'
+            break
           else
-            # Value is ruby code
-            escape = @line[0] != ?=
-            @line.slice!(0) unless escape
-            attributes << [:slim, :attr, name, escape, parse_ruby_attribute(delimiter)]
+            # Found something where an attribute should be
+            @line.lstrip!
+            syntax_error!('Expected attribute') unless @line.empty?
+
+            # 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)
           end
         end
-
-        # No ending delimiter, attribute end
-        break unless delimiter
-
-        # Find ending delimiter
-        if @line =~ /\A\s*#{Regexp.escape delimiter}/
-          @line = $'
-          break
-        end
-
-        # Found something where an attribute should be
-        @line.lstrip!
-        syntax_error!('Expected attribute') unless @line.empty?
-
-        # Attributes span multiple lines
-        @stacks.last << [:newline]
-        next_line || syntax_error!("Expected closing delimiter #{delimiter}",
-                                   :orig_line => orig_line,
-                                   :lineno => lineno,
-                                   :column => orig_line.size)
       end
 
       attributes
     end
 
-    def parse_ruby_attribute(outer_delimiter)
-      value, count, delimiter, close_delimiter = '', 0, nil, nil
+    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}]/
@@ -401,18 +420,10 @@ module Slim
           count = 1
           delimiter, close_delimiter = $&, DELIMITERS[$&]
         end
-        value << @line.slice!(0)
+        code << @line.slice!(0)
       end
-
-      syntax_error!("Expected closing attribute delimiter #{close_delimiter}") if count != 0
-      syntax_error!('Invalid empty attribute') if value.empty?
-
-      # 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]
-
-      value
+      syntax_error!("Expected closing delimiter #{close_delimiter}") if count != 0
+      code
     end
 
     def parse_quoted_attribute(quote)