slim 0.7.0.beta.2 → 0.7.0

data/lib/slim/parser.rb

@@ -1,18 +1,23 @@
 module Slim
+  # Parses Slim code and transforms it to a Temple expression
+  # @api private
   class Parser
     class SyntaxError < StandardError
-      def initialize(message, line, lineno, column = 0)
-        @message = message
+      attr_reader :error, :file, :line, :lineno, :column
+
+      def initialize(error, file, line, lineno, column = 0)
+        @error = error
+        @file = file || '(__TEMPLATE__)'
         @line = line.strip
         @lineno = lineno
         @column = column
       end
 
       def to_s
-        %{#{@message}
-  Line #{@lineno}
-    #{@line}
-    #{' ' * @column}^
+        %{#{error}
+  #{file}, Line #{lineno}
+    #{line}
+    #{' ' * column}^
         }
       end
     end
@@ -24,6 +29,10 @@ module Slim
       @tab     = ' ' * (options[:tabsize] || 4)
     end
 
+    # Compile string to Temple expression
+    #
+    # @param [String] str Slim code
+    # @return [Array] Temple expression representing the code
     def compile(str)
       lineno = 0
       result = [:multi]
@@ -58,7 +67,7 @@ module Slim
       #     Hello
       #     World!
       #
-      text_indent, text_base_indent = nil, nil
+      block_indent, in_comment, text_indent = nil, false, nil
 
       str.each_line do |line|
         lineno += 1
@@ -69,12 +78,20 @@ module Slim
         # Handle broken lines
         if broken_line
           if broken_line[-1] == ?\\
-            broken_line << "\n#{line}"
+            broken_line << "\n" << line
             next
           end
           broken_line = nil
         end
 
+        if line.strip.empty?
+          # This happens to be an empty line, so we'll just have to make sure
+          # the generated code includes a newline (so the line numbers in the
+          # stack trace for an exception matches the ones in the template).
+          stacks.last << [:newline]
+          next
+        end
+
         # Figure out the indentation. Kinda ugly/slow way to support tabs,
         # but remember that this is only done at parsing time.
         indent = line[/^[ \t]*/].gsub("\t", @tab).size
@@ -82,41 +99,33 @@ module Slim
         # Remove the indentation
         line.lstrip!
 
-        if line.strip.empty? || line[0] == ?/
-          # This happens to be an empty line or a comment, so we'll just have to make sure
-          # the generated code includes a newline (so the line numbers in the
-          # stack trace for an exception matches the ones in the template).
-          stacks.last << [:newline]
-          next
-        end
+        # Handle blocks with multiple lines
+        if block_indent
+          if indent > block_indent
+            # This line happens to be indented deeper (or equal) than the block start character (|, ', `, /).
+            # This means that it's a part of the block.
 
-        # Handle text blocks with multiple lines
-        if text_indent
-          if indent > text_indent
-            # This line happens to be indented deeper (or equal) than the block start character (|, ', `).
-            # This means that it's a part of the text block.
+            if !in_comment
+              # The indentation of first line of the text block determines the text base indentation.
+              text_indent ||= indent
 
-            # The indentation of first line of the text block determines the text base indentation.
-            text_base_indent ||= indent
+              # The text block lines must be at least indented as deep as the first line.
+              offset = indent - text_indent
+              syntax_error! 'Unexpected text indentation', line, lineno if offset < 0
 
-            # The text block lines must be at least indented as deep as the first line.
-            offset = indent - text_base_indent
-            syntax_error! 'Unexpected text indentation', line, lineno if offset < 0
+              # Generate the additional spaces in front.
+              i = ' ' * offset
+              stacks.last << [:slim, :text, i + line]
+            end
 
-            # Generate the additional spaces in front.
-            i = ' ' * offset
-            stacks.last << [:slim, :text, i + line]
             stacks.last << [:newline]
-
-            # Mark this line as it's been indented as the text block start character.
-            indent = text_indent
-
             next
           end
 
-          # It's guaranteed that we're now *not* in a text block, because
-          # the indent will always be set to the text block start indent.
-          text_indent = text_base_indent = nil
+          # It's guaranteed that we're now *not* in a block, because
+          # the indent was less than the block start indent.
+          block_indent = text_indent = nil
+          in_comment = false
         end
 
         # If there's more stacks than indents, it means that the previous
@@ -152,20 +161,21 @@ module Slim
         end
 
         case line[0]
-        when ?|, ?', ?`
-          # Found a piece of text.
+        when ?|, ?', ?`, ?/
+          # Found a block.
 
           # We're now expecting the next line to be indented, so we'll need
           # to push a block to the stack.
           block = [:multi]
           stacks.last << block
           stacks << block
-          text_indent = indent
+          block_indent = indent
 
+          in_comment = line[0] == ?/
           line.slice!(0)
-          if !line.strip.empty?
+          if !in_comment && !line.strip.empty?
             block << [:slim, :text, line.sub(/^( )/, '')]
-            text_base_indent = text_indent + ($1 ? 2 : 1)
+            text_indent = block_indent + ($1 ? 2 : 1)
           end
         when ?-, ?=
           # Found a potential code block.
@@ -191,18 +201,24 @@ module Slim
           stacks.last << [:slim, :directive, line[1..-1].strip]
         else
           if line =~ /^(\w+):\s*$/
-            # Embedded template detected. It is treated like a text block.
+            # Embedded template detected. It is treated as block.
             block = [:slim, :embedded, $1]
-            stacks.last << block
+            stacks.last << [:newline] << block
             stacks << block
-            text_indent = indent
+            block_indent = indent
+            next
           else
             # Found a HTML tag.
-            exp, content, broken_line = parse_tag(line, lineno)
-            stacks.last << exp
-            stacks << content if content
+            tag, block, broken_line, text_indent = parse_tag(line, lineno)
+            stacks.last << tag
+            stacks << block if block
+            if text_indent
+              block_indent = indent
+              text_indent += indent
+            end
           end
         end
+        stacks.last << [:newline]
       end
 
       result
@@ -210,31 +226,32 @@ module Slim
 
     private
 
-    ATTR_REGEX = /^ ([\w-]+)=/
+    ATTR_REGEX = /^ (\w[:\w-]*)=/
     QUOTED_VALUE_REGEX = /^("[^"]+"|'[^']+')/
     ATTR_SHORTHAND = {
       '#' => 'id',
       '.' => 'class',
-    }
+    }.freeze
     DELIMITERS = {
       '(' => ')',
       '[' => ']',
       '{' => '}',
-    }
+    }.freeze
     DELIMITER_REGEX = /^([\(\[\{])/
     CLOSE_DELIMITER_REGEX = /^([\)\]\}])/
     if RUBY_VERSION > '1.9'
       CLASS_ID_REGEX = /^(#|\.)([\w\u00c0-\uFFFF][\w:\u00c0-\uFFFF-]*)/
     else
-      CLASS_ID_REGEX = /^(#|\.)([\w][\w:-]*)/
+      CLASS_ID_REGEX = /^(#|\.)(\w[\w:-]*)/
     end
 
     def parse_tag(line, lineno)
       orig_line = line
 
-      if line =~ /^(#|\.)/
+      case line
+      when /^(#|\.)/
         tag = 'div'
-      elsif line =~ /^[\w:]+/
+      when /^\w[:\w-]*/
         tag = $&
         line = $'
       else
@@ -248,7 +265,7 @@ module Slim
 
       # Find any literal class/id attributes
       while line =~ CLASS_ID_REGEX
-        attributes << [ATTR_SHORTHAND[$1], $2]
+        attributes << [ATTR_SHORTHAND[$1], false, $2]
         line = $'
       end
 
@@ -265,14 +282,14 @@ module Slim
         key = $1
         line = $'
         if line =~ QUOTED_VALUE_REGEX
-          # Value is quote (static)
+          # Value is quoted (static)
           line = $'
-          value = $1[1..-2]
+          attributes << [key, false, $1[1..-2]]
         else
           # Value is ruby code
           line, value = parse_ruby_attribute(orig_line, line, lineno, delimiter)
+          attributes << [key, true, value]
         end
-        attributes << [key, value]
       end
 
       # Find ending delimiter
@@ -285,26 +302,22 @@ module Slim
       end
 
       content = [:multi]
-      broken_line = nil
+      tag = [:slim, :tag, tag, attributes, content]
 
-      if line.strip.empty?
-        # If the line was empty there might be some indented content in the
-        # lines beneath it. We'll handle this by making this method return
-        # the block-variable. #compile will then push this onto the
-        # stacks-array.
-        block = content
-      elsif line =~ /^\s*=(=?)/
-        # Output
+      if line =~ /^\s*=(=?)/
+        # Handle output code
         block = [:multi]
         broken_line = $'.strip
         content << [:slim, :output, $1 != '=', broken_line, block]
+        [tag, block, broken_line, nil]
+      elsif !line.empty?
+        # Handle text content
+        content << [:slim, :text, line.sub(/^( )/, '')]
+        [tag, content, nil, orig_line.size - line.size + ($1 ? 1 : 0)]
       else
-        # Text content
-        line.sub!(/^ /, '')
-        content << [:slim, :text, line]
+        # Empty line
+        [tag, content, nil, nil]
       end
-
-      return [:slim, :tag, tag, attributes, content], block, broken_line
     end
 
     def parse_ruby_attribute(orig_line, line, lineno, delimiter)
@@ -344,12 +357,12 @@ module Slim
       # e.g id=[hash[:a] + hash[:b]]
       value = value[1..-2] if value =~ DELIMITER_REGEX && DELIMITERS[value[0, 1]] == value[-1, 1]
 
-      [line, '#{%s}' % value]
+      return line, value
     end
 
     # A little helper for raising exceptions.
-    def syntax_error!(*args)
-      raise SyntaxError.new(*args)
+    def syntax_error!(message, *args)
+      raise SyntaxError.new(message, @options[:file], *args)
     end
   end
 end

data/lib/slim/rails.rb

@@ -2,11 +2,12 @@ require 'slim'
 
 module ActionView
   module TemplateHandlers
+    # Slim handler for Rails 3
     class SlimHandler < TemplateHandler
       include Compilable
 
       def compile(template)
-        return Slim::Engine.new(template.source, use_html_safe: true).prepare
+        Slim::Engine.new(:use_html_safe => true).compile(template.source)
       end
     end
   end

data/lib/slim/template.rb

@@ -1,14 +1,34 @@
 module Slim
+  # Tilt template implementation for Slim
+  # @api public
   class Template < Tilt::Template
+    # Prepare Slim template
+    #
+    # Called immediately after template data is loaded.
+    #
+    # @return [void]
     def prepare
-      @src = Engine.new(options).compile(data)
+      @src = Engine.new(options.merge(:file => eval_file)).compile(data)
     end
 
+    # Process the template and return the result.
+    #
+    # Template executationis guaranteed to be performed in the scope object with the locals
+    # specified and with support for yielding to the block.
+    #
+    # @param [Object] scope Scope object where the code is evaluated
+    # @param [Hash]   locals Local variables
+    # @yield Block given to the template code
+    # @return [String] Evaluated template
     def evaluate(scope, locals, &block)
       scope.instance_eval { extend Slim::Helpers } if options[:helpers]
       super
     end
 
+    # A string containing the (Ruby) source code for the template.
+    #
+    # @param [Hash]   locals Local variables
+    # @return [String] Compiled template ruby code
     def precompiled_template(locals)
       @src
     end

data/lib/slim/version.rb

@@ -1,3 +1,3 @@
 module Slim
-  VERSION = "0.7.0.beta.2"
+  VERSION = "0.7.0"
 end

data/slim.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.name              = "slim"
   s.version           = Slim::VERSION
   s.date              = Date.today.to_s
-  s.authors           = ["Andrew Stone", "Fred Wu"]
-  s.email             = ["andy@stonean.com", "ifredwu@gmail.com"]
+  s.authors           = ["Andrew Stone", "Fred Wu", "Daniel Mendler"]
+  s.email             = ["andy@stonean.com", "ifredwu@gmail.com", "mail@daniel-mendler.de"]
   s.summary           = %q{Slim is a template language.}
   s.description       = %q{Slim is a template language whose goal is reduce the syntax to the essential parts without becoming cryptic.}
   s.homepage          = %q{http://github.com/stonean/slim}
@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_runtime_dependency(%q<escape_utils>, [">= 0.1.9"]) unless RUBY_PLATFORM == "java"
-  s.add_runtime_dependency(%q<temple>, ["~> 0.1.2"])
+  s.add_runtime_dependency(%q<temple>, ["~> 0.1.3"])
   s.add_runtime_dependency(%q<tilt>, ["~> 1.1"])
   s.add_development_dependency(%q<rake>, [">= 0.8.7"])
   s.add_development_dependency(%q<haml>, [">= 0"])
@@ -30,4 +30,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<rcov>, [">= 0"])
   s.add_development_dependency(%q<rdiscount>, [">= 0"])
   s.add_development_dependency(%q<liquid>, [">= 0"])
+  s.add_development_dependency(%q<yard>, [">= 0"])
 end

data/test/helper.rb

@@ -14,18 +14,36 @@ class TestSlim < MiniTest::Unit::TestCase
 
   def teardown
     String.send(:undef_method, :html_safe?) if String.method_defined?(:html_safe?)
+    String.send(:undef_method, :html_safe)  if String.method_defined?(:html_safe)
+    Object.send(:undef_method, :html_safe?) if Object.method_defined?(:html_safe?)
     Slim::Filter::DEFAULT_OPTIONS.delete(:use_html_safe)
   end
 
   def assert_html(expected, source, options = {})
-    assert_equal expected, Slim::Engine.new(source, options).render(@env)
+    assert_equal expected, Slim::Template.new(options[:file], options) { source }.render(@env)
   end
 
   def assert_syntax_error(message, source, options = {})
-    Slim::Engine.new(source, options).render(@env)
+    Slim::Template.new(options[:file], options) { source }.render(@env)
     raise 'Syntax error expected'
   rescue Slim::Parser::SyntaxError => ex
-    assert_equal ex.message, message
+    assert_equal message, ex.message
+  end
+
+  def assert_ruby_error(error, from, source, options = {})
+    Slim::Template.new(options[:file], options) { source }.render(@env)
+    raise 'Ruby error expected'
+  rescue error => ex
+    ex.backtrace[0] =~ /^(.*?:\d+):/
+    assert_equal from, $1
+  end
+
+  def assert_ruby_syntax_error(from, source, options = {})
+    Slim::Template.new(options[:file], options) { source }.render(@env)
+    raise 'Ruby syntax error expected'
+  rescue SyntaxError => ex
+    ex.message =~ /^(.*?:\d+):/
+    assert_equal from, $1
   end
 end
 

data/test/slim/test_code_evaluation.rb

@@ -157,13 +157,13 @@ p id=(1 + 1)*5 Test it
   def test_interpolation_in_text
     source = %q{
 p
- | #{hello_world}
+ | #{hello_world} with "quotes"
 p
  |
   A message from the compiler: #{hello_world}
 }
 
-    assert_html '<p>Hello World from @env</p><p>A message from the compiler: Hello World from @env</p>', source
+    assert_html '<p>Hello World from @env with "quotes"</p><p>A message from the compiler: Hello World from @env</p>', source
   end
 
   def test_interpolation_in_tag

data/test/slim/test_code_helpers.rb

@@ -1,6 +1,12 @@
 require 'helper'
 
 class TestSlimHelpers < TestSlim
+  class HtmlSafeString < String
+    def html_safe?
+      true
+    end
+  end
+
   def test_list_of
     source = %q{
 == list_of([1, 2, 3]) do |i|
@@ -9,4 +15,16 @@ class TestSlimHelpers < TestSlim
 
     assert_html "<li>1</li>\n<li>2</li>\n<li>3</li>", source, :helpers => true
   end
+
+  def test_list_of_with_html_safe
+    Object.send(:define_method, :html_safe?) { false }
+    String.send(:define_method, :html_safe) { HtmlSafeString.new(self) }
+
+    source = %q{
+= list_of([1, 2, 3]) do |i|
+  = i
+}
+
+    html = Slim::Template.new(:helpers => true, :use_html_safe => true) { source }.render(@env)
+  end
 end