RubyGems - slim - Versions diffs - 0.9.4 → 1.0.0 - Mend

slim 0.9.4 → 1.0.0

Files changed (21) hide show

data/CHANGES +8 -1
data/README.md +9 -5
data/lib/slim/compiler.rb +20 -23
data/lib/slim/embedded_engine.rb +86 -25
data/lib/slim/end_inserter.rb +2 -2
data/lib/slim/engine.rb +1 -2
data/lib/slim/grammar.rb +1 -2
data/lib/slim/interpolation.rb +8 -6
data/lib/slim/parser.rb +295 -258
data/lib/slim/sections.rb +1 -1
data/lib/slim/version.rb +1 -1
data/test/helper.rb +4 -0
data/test/slim/test_code_evaluation.rb +31 -6
data/test/slim/test_code_output.rb +22 -3
data/test/slim/test_embedded_engines.rb +7 -2
data/test/slim/test_html_structure.rb +79 -10
data/test/slim/test_parser_errors.rb +22 -13
data/test/slim/test_ruby_errors.rb +11 -0
data/test_ruby_errors.rb +191 -0
metadata +107 -111
data/lib/slim/rails.rb +0 -3

data/CHANGES CHANGED Viewed

@@ -1,6 +1,13 @@
-master
+1.0
   * Fixed html attribute issue in sections mode (#127)
+  * Obsolete directive syntax removed
+  * Syntax for trailing whitespace added (==' and =')
+  * Deprecated file 'slim/rails.rb' removed
+  * Parsing of #{interpolation} in markdown fixed
+  * Support for attributes which span multiple lines
+  * Dynamic attributes with value true/false are interpreted as boolean
+  * Support boolean attributes without value e.g. option(selected id="abc")
 0.9.3

data/README.md CHANGED Viewed

@@ -41,7 +41,7 @@ If you want to use the Slim template directly, you can use the Tilt interface:
 ## Syntax Highlighters
-Syntax highlight support for __Vim__ (very beta) and __Emacs__ are included in the `extra` folder. There is also a [Textmate bundle](https://github.com/fredwu/ruby-slim-textmate-bundle).
+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.
 ## Template Converters
@@ -106,13 +106,17 @@ Here's a quick example to demonstrate what a Slim template looks like:
 > The equal sign tells Slim it's a Ruby call that produces output to add to the buffer (similar to Erb and Haml).
+#### `='`
+> Same as the single equal sign (`=`), except that it adds a trailing whitespace.
 #### `==`
-> Same as the single equal sign, but does not go through the `escape_html` method.
+> Same as the single equal sign (`=`), but does not go through the `escape_html` method.
-#### `!`
+#### `=='`
-> This is a directive.  Most common example: `! doctype html # renders <!doctype html>`
+> Same as the double equal sign (`==`), except that it adds a trailing whitespace.
 #### `/`
@@ -341,7 +345,7 @@ This project is released under the MIT license.
 ## Slim related projects
 * [Vim files](https://github.com/bbommarito/vim-slim)
-* [Textmate bundle](https://github.com/fredwu/ruby-slim-textmate-bundle)
+* [Textmate bundle](https://github.com/fredwu/ruby-slim-tmbundle)
 * [Haml2Slim converter](https://github.com/fredwu/haml2slim)
 * [Rails 3 Generators](https://github.com/leogalmeida/slim-rails)
 * [Slim for Clojure](https://github.com/chaslemley/slim.clj)

data/lib/slim/compiler.rb CHANGED Viewed

@@ -2,8 +2,6 @@ module Slim
   # Compiles Slim expressions into Temple::HTML expressions.
   # @api private
   class Compiler < Filter
-    set_default_options :bool_attrs => %w(selected)
     # Handle control expression `[:slim, :control, code, content]`
     #
     # @param [String] ruby code
@@ -56,35 +54,34 @@ module Slim
       end
     end
-    # Handle directive expression `[:slim, :directive, type, args]`
-    #
-    # @param [String] type Directive type
-    # @return [Array] Compiled temple expression
-    def on_slim_directive(type, args)
-      case type
-      when 'doctype'
-        [:html, :doctype, args]
-      else
-        raise "Invalid directive #{type}"
-      end
-    end
     # Handle attribute expression `[:slim, :attr, escape, code]`
     #
     # @param [Boolean] escape Escape html
     # @param [String] code Ruby code
     # @return [Array] Compiled temple expression
     def on_slim_attr(name, escape, code)
-      if options[:bool_attrs].include?(name)
+      value = case code
+      when 'true'
         escape = false
-        value = [:dynamic, "(#{code}) ? #{name.inspect} : nil"]
-      elsif delimiter = options[:attr_delimiter][name]
-        tmp = unique_name
-        value = [:multi,
-                 [:code, "#{tmp} = #{code}"],
-                 [:dynamic, "#{tmp}.respond_to?(:join) ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"]]
+        [:static, name]
+      when 'false', 'nil'
+        escape = false
+        [:multi]
       else
-        value = [:dynamic, code]
+        tmp = unique_name
+        [:multi,
+         [:code, "#{tmp} = #{code}"],
+         [:case, tmp,
+          ['true', [:static, name]],
+          ['false, nil', [:static, '']],
+          [:else,
+           [:dynamic,
+            if delimiter = options[:attr_delimiter][name]
+              "#{tmp}.respond_to?(:join) ? #{tmp}.flatten.compact.join(#{delimiter.inspect}) : #{tmp}"
+            else
+              code
+            end
+           ]]]]
       end
       [:html, :attr, name,  [:escape, escape, value]]
     end

data/lib/slim/embedded_engine.rb CHANGED Viewed

@@ -1,4 +1,63 @@
 module Slim
+  # @api private
+  class CollectText < Filter
+    def call(exp)
+      @collected = ''
+      super(exp)
+      @collected
+    end
+    def on_slim_interpolate(text)
+      @collected << text
+      nil
+    end
+  end
+  # @api private
+  class CollectNewlines < Filter
+    def call(exp)
+      @collected = [:multi]
+      super(exp)
+      @collected
+    end
+    def on_newline
+      @collected << [:newline]
+      nil
+    end
+  end
+  # @api private
+  class ProtectOutput < Filter
+    def call(exp)
+      @protect = []
+      @collected = ''
+      super(exp)
+      @collected
+    end
+    def on_static(text)
+      @collected << text
+      nil
+    end
+    def on_slim_output(escape, text, content)
+      @collected << "pro#{@protect.size}tect"
+      @protect << [:slim, :output, escape, text, content]
+      nil
+    end
+    def unprotect(text)
+      block = [:multi]
+      while text =~ /pro(\d+)tect/
+        block << [:static, $`]
+        block << @protect[$1.to_i]
+        text = $'
+      end
+      block << [:static, text]
+    end
+  end
   # Temple filter which processes embedded engines
   # @api private
   class EmbeddedEngine < Filter
@@ -34,23 +93,17 @@ module Slim
       engine.new(Temple::ImmutableHash.new(local_options, filtered_options))
     end
-    def collect_text(body)
-      body[1..-1].inject('') do |text, exp|
-        exp[0] == :slim && exp[1] == :interpolate ? (text << exp[2]) : text
-      end
-    end
-    def collect_newlines(body)
-      body[1..-1].inject([:multi]) do |multi, exp|
-        exp[0] == :newline ? (multi << exp) : multi
-      end
-    end
     # Basic tilt engine
-    class TiltEngine < EmbeddedEngine
+    class TiltEngine < Filter
       def on_slim_embedded(engine, body)
         engine = Tilt[engine] || raise("Tilt engine #{engine} is not available.")
-        [:multi, render(engine, collect_text(body)), collect_newlines(body)]
+        [:multi, render(engine, collect_text(body)), CollectNewlines.new.call(body)]
+      end
+      protected
+      def collect_text(body)
+        CollectText.new.call(body)
       end
     end
@@ -64,7 +117,7 @@ module Slim
     end
     # Sass engine which supports :pretty option
-    class SassEngine < StaticTiltEngine
+    class SassEngine < TiltEngine
       protected
       def render(engine, text)
@@ -75,7 +128,7 @@ module Slim
     end
     # Tilt-based engine which is fully dynamically evaluated during runtime (Slow and uncached)
-    class DynamicTiltEngine < StaticTiltEngine
+    class DynamicTiltEngine < TiltEngine
       protected
       # Code to collect local variables
@@ -87,7 +140,7 @@ module Slim
     end
     # Tilt-based engine which is precompiled
-    class PrecompiledTiltEngine < StaticTiltEngine
+    class PrecompiledTiltEngine < TiltEngine
       protected
       def render(engine, text)
@@ -97,24 +150,32 @@ module Slim
     end
     # Static template with interpolated ruby code
-    class InterpolateTiltEngine < StaticTiltEngine
-      protected
+    class InterpolateTiltEngine < TiltEngine
+      def initialize(opts = {})
+        super
+        @protect = ProtectOutput.new
+      end
+      def collect_text(body)
+        text = Interpolation.new.call(body)
+        @protect.call(text)
+      end
       def render(engine, text)
-        [:slim, :interpolate, engine.new { text }.render]
+        @protect.unprotect(engine.new { text }.render)
       end
     end
     # ERB engine (uses the Temple ERB implementation)
-    class ERBEngine < EmbeddedEngine
+    class ERBEngine < Filter
       def on_slim_embedded(engine, body)
-        Temple::ERB::Parser.new.call(collect_text(body))
+        Temple::ERB::Parser.new.call(CollectText.new.call(body))
       end
     end
     # Tag wrapper engine
     # Generates a html tag and wraps another engine (specified via :engine option)
-    class TagEngine < EmbeddedEngine
+    class TagEngine < Filter
       def on_slim_embedded(engine, body)
         content = options[:engine] ? options[:engine].new(options).on_slim_embedded(engine, body) : [:multi, body]
         [:html, :tag, options[:tag], [:html, :attrs, *options[:attributes].map {|k, v| [:html, :attr, k, [:static, v]] }], content]
@@ -122,9 +183,9 @@ module Slim
     end
     # Embeds ruby code
-    class RubyEngine < EmbeddedEngine
+    class RubyEngine < Filter
       def on_slim_embedded(engine, body)
-        [:code, "\n" + collect_text(body)]
+        [:code, "\n" + CollectText.new.call(body)]
       end
     end

data/lib/slim/end_inserter.rb CHANGED Viewed

@@ -10,8 +10,8 @@ module Slim
   #
   # @api private
   class EndInserter < Filter
-    ELSE_REGEX = /^else|elsif|when\b/
-    END_REGEX = /^end\b/
+    ELSE_REGEX = /\Aelse|elsif|when\b/
+    END_REGEX = /\Aend\b/
     # Handle multi expression `[:multi, *exps]`
     #

data/lib/slim/engine.rb CHANGED Viewed

@@ -33,7 +33,6 @@ module Slim
     # Symbol      | :format            | :html5                        | HTML output format
     # String      | :attr_wrapper      | '"'                           | Character to wrap attributes in html (can be ' or ")
     # Hash        | :attr_delimiter    | {'class' => ' '}              | Joining character used if multiple html attributes are supplied (e.g. id1_id2)
-    # String list | :bool_attrs        | %w(selected)                  | List of boolean attributes
     # Boolean     | :pretty            | false                         | Pretty html indenting (This is slower!)
     # Class       | :generator         | ArrayBuffer/RailsOutputBuffer | Temple code generator (default generator generates array buffer)
     #
@@ -58,7 +57,7 @@ module Slim
     use Slim::Interpolation
     use Slim::Sections, :sections, :dictionary, :dictionary_access
     use Slim::EndInserter
-    use Slim::Compiler, :disable_capture, :attr_delimiter, :bool_attrs
+    use Slim::Compiler, :disable_capture, :attr_delimiter
     use Temple::HTML::Pretty, :format, :attr_wrapper, :attr_delimiter, :pretty
     filter :Escapable, :use_html_safe, :disable_escape
     filter :ControlFlow

data/lib/slim/grammar.rb CHANGED Viewed

@@ -9,8 +9,7 @@ module Slim
       [:slim, :condcomment, String, Expression]   |
       [:slim, :output, Bool, String, Expression]  |
       [:slim, :interpolate, String]               |
-      [:slim, :embedded, String, Expression]      |
-      [:slim, :directive, Value('doctype'), String]
+      [:slim, :embedded, String, Expression]
     HTMLAttr <<
       [:slim, :attr, String, Bool, String]

data/lib/slim/interpolation.rb CHANGED Viewed

@@ -14,16 +14,18 @@ module Slim
       block = [:multi]
       until string.empty?
         case string
-        when /^\\#\{/
+        when /\A\\#\{/
           # Escaped interpolation
-          block << [:static, '#{']
+          # HACK: Use :slim :output because this is used by InterpolateTiltEngine
+          # to filter out protected strings (Issue #141).
+          block << [:slim, :output, false, '\'#{\'', [:multi]]
           string = $'
-        when /^#\{/
+        when /\A#\{/
           # Interpolation
           string, code = parse_expression($')
-          escape = code !~ /^\{.*\}$/
+          escape = code !~ /\A\{.*\}\Z/
           block << [:slim, :output, escape, escape ? code : code[1..-2], [:multi]]
-        when /^([^#]+|#)/
+        when /\A([^#]+|#)/
           # Static text
           block << [:static, $&]
           string = $'
@@ -38,7 +40,7 @@ module Slim
       stack, code = [], ''
       until string.empty?
-        if stack.empty? && string =~ /^\}/
+        if stack.empty? && string =~ /\A\}/
           # Stack is empty, this means we are finished
           # if the next character is a closing bracket
           string.slice!(0)

data/lib/slim/parser.rb CHANGED Viewed

@@ -10,20 +10,22 @@ module Slim
     class SyntaxError < StandardError
       attr_reader :error, :file, :line, :lineno, :column
-      def initialize(error, file, line, lineno, column = 0)
+      def initialize(error, file, line, lineno, column)
         @error = error
         @file = file || '(__TEMPLATE__)'
-        @line = line.strip
+        @line = line.to_s
         @lineno = lineno
         @column = column
       end
       def to_s
+        line = @line.strip
+        column = @column + line.size - @line.size
         %{#{error}
   #{file}, Line #{lineno}
     #{line}
     #{' ' * column}^
-        }
+}
       end
     end
@@ -35,7 +37,7 @@ module Slim
     # Compile string to Temple expression
     #
     # @param [String] str Slim code
-    # @return [Array] Temple expression representing the code
+    # @return [Array] Temple expression representing the code]]
     def call(str)
       # Set string encoding if option is set
       if options[:encoding] && str.respond_to?(:encoding)
@@ -46,9 +48,39 @@ module Slim
         str.force_encoding(old_enc) unless str.valid_encoding?
       end
-      lineno = 0
       result = [:multi]
+      reset(str.split($/), [result])
+      parse_line while next_line
+      reset
+      result
+    end
+    DELIMITERS = {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+    }.freeze
+    DELIMITER_REGEX = /\A[\(\[\{]/
+    CLOSE_DELIMITER_REGEX = /\A[\)\]\}]/
+    private
+    ATTR_NAME_REGEX = '\A\s*(\w[:\w-]*)'
+    QUOTED_VALUE_REGEX = /\A("[^"]*"|'[^']*')/
+    ATTR_SHORTCUT = {
+      '#' => 'id',
+      '.' => 'class',
+    }.freeze
+    if RUBY_VERSION > '1.9'
+      CLASS_ID_REGEX = /\A(#|\.)([\w\u00c0-\uFFFF][\w:\u00c0-\uFFFF-]*)/
+    else
+      CLASS_ID_REGEX = /\A(#|\.)(\w[\w:-]*)/
+    end
+    def reset(lines = nil, stacks = nil)
       # Since you can indent however you like in Slim, we need to keep a list
       # of how deeply indented you are. For instance, in a template like this:
       #
@@ -61,302 +93,295 @@ 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 = [0]
       # 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
       # indentation, we simply push a new stack onto this array. When it
       # processes the next line, the content will then be outputted into that
       # stack.
-      stacks = [result]
-      # String buffer used for broken line (Lines ending with \)
-      broken_line = nil
-      # We have special treatment for text blocks:
-      #
-      #   |
-      #     Hello
-      #     World!
-      #
-      block_indent, text_indent, in_comment = nil, nil, false
-      str.each_line do |line|
-        lineno += 1
+      @stacks = stacks
-        # Remove the newline at the end
-        line.chomp!
-        # Handle broken lines
-        if broken_line
-          if broken_line[-1] == ?\\
-            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
+      @lineno = 0
+      @lines = lines
+      @line = @orig_line = nil
+    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
+    def next_line
+      if @lines.empty?
+        @orig_line = @line = nil
+      else
+        @orig_line = @lines.shift
+        @lineno += 1
+        @line = @orig_line.dup
+      end
+    end
-        # Remove the indentation
-        line.lstrip!
+    def get_indent(line)
+      # Figure out the indentation. Kinda ugly/slow way to support tabs,
+      # but remember that this is only done at parsing time.
+      line[/\A[ \t]*/].gsub("\t", @tab).size
+    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.
+    def parse_line
+      if @line.strip.empty?
+        @stacks.last << [:newline]
+        return
+      end
-            unless in_comment
-              # The indentation of first line of the text block determines the text base indentation.
-              newline = text_indent ? "\n" : ''
-              text_indent ||= indent
+      indent = get_indent(@line)
-              # 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
+      # Remove the indentation
+      @line.lstrip!
-              # Generate the additional spaces in front.
-              stacks.last << [:slim, :interpolate, newline + (' ' * offset) + line]
-            end
+      # If there's more stacks than indents, it means that the previous
+      # line is expecting this line to be indented.
+      expecting_indentation = @stacks.size > @indents.size
-            stacks.last << [:newline]
-            next
-          end
+      if indent > @indents.last
+        # This line was actually indented, so we'll have to check if it was
+        # supposed to be indented or not.
+        syntax_error!('Unexpected indentation') unless expecting_indentation
-          # 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
+        @indents << indent
+      else
+        # This line was *not* indented more than the line before,
+        # so we'll just forget about the stack that the previous line pushed.
+        @stacks.pop if expecting_indentation
+        # 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
+          @indents.pop
+          @stacks.pop
         end
-        # If there's more stacks than indents, it means that the previous
-        # line is expecting this line to be indented.
-        expecting_indentation = stacks.size > indents.size
-        if indent > indents.last
-          # This line was actually indented, so we'll have to check if it was
-          # supposed to be indented or not.
-          syntax_error! 'Unexpected indentation', line, lineno unless expecting_indentation
-          indents << indent
-        else
-          # This line was *not* indented more than the line before,
-          # so we'll just forget about the stack that the previous line pushed.
-          stacks.pop if expecting_indentation
-          # 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
-            indents.pop
-            stacks.pop
-          end
+        # This line's indentation happens lie "between" two other line's
+        # indentation:
+        #
+        #   hello
+        #       world
+        #     this      # <- This should not be possible!
+        syntax_error!('Malformed indentation') if indent != @indents.last
+      end
-          # This line's indentation happens lie "between" two other line's
-          # indentation:
-          #
-          #   hello
-          #       world
-          #     this      # <- This should not be possible!
-          syntax_error! 'Malformed indentation', line, lineno if indents.last < indent
-        end
+      parse_line_indicators
+    end
-        case line[0]
-        when ?/
-          # Found a comment block.
-          block = [:multi]
-          stacks.last << if line =~ %r{^/!( ?)(.*)$}
-                           # HTML comment
-                           block_indent = indent
-                           text_indent = block_indent + ($1 ? 2 : 1)
-                           block << [:slim, :interpolate, $2] if $2
-                           [:html, :comment, block]
-                         elsif line =~ %r{^/\[\s*(.*?)\s*\]\s*$}
-                           # HTML conditional comment
-                           [:slim, :condcomment, $1, block]
-                         else
-                           # Slim comment
-                           block_indent = indent
-                           in_comment = true
-                           block
-                         end
-          stacks << block
-        when ?|, ?'
-          # Found a text block.
-          # We're now expecting the next line to be indented, so we'll need
-          # to push a block to the stack.
-          block = [:multi]
-          block_indent = indent
-          stacks.last << (line.slice!(0) == ?' ?
-                          [:multi, block, [:static, ' ']] : block)
-          stacks << block
-          unless line.strip.empty?
-            block << [:slim, :interpolate, line.sub(/^( )/, '')]
-            text_indent = block_indent + ($1 ? 2 : 1)
-          end
-        when ?-
-          # Found a code block.
-          # We expect the line to be broken or the next line to be indented.
+    def parse_line_indicators
+      case @line
+      when /\A\//
+        # Found a comment block.
+        if @line =~ %r{\A/!( ?)(.*)\Z}
+          # HTML comment
           block = [:multi]
-          broken_line = line[1..-1].strip
-          stacks.last << [:slim, :control, broken_line, block]
-          stacks << block
-        when ?=
-          # Found an output block.
-          # We expect the line to be broken or the next line to be indented.
+          @stacks.last <<  [:html, :comment, block]
+          @stacks << block
+          @stacks.last << [:slim, :interpolate, $2] if $2
+          parse_text_block($1 ? 2 : 1)
+        elsif @line =~ %r{\A/\[\s*(.*?)\s*\]\s*\Z}
+          # HTML conditional comment
           block = [:multi]
-          escape = line[1] != ?=
-          broken_line = escape ? line[1..-1].strip : line[2..-1].strip
-          stacks.last << [:slim, :output, escape, broken_line, block]
-          stacks << block
-        when ?!
-          # Found a directive (currently only used for doctypes)
-          directive = line[1..-1].strip.split(/\s+/, 2)
-          stacks.last << [:slim, :directive, directive[0].downcase, directive[1]]
+          @stacks.last << [:slim, :condcomment, $1, block]
+          @stacks << block
         else
-          if line =~ /^(\w+):\s*$/
-            # Embedded template detected. It is treated as block.
-            block = [:multi]
-            stacks.last << [:newline] << [:slim, :embedded, $1, block]
-            stacks << block
-            block_indent = indent
-            next
-          elsif line =~ /^doctype\s+/i
-            stacks.last << [:slim, :directive, 'doctype', $'.strip]
-          else
-            # Found a HTML tag.
-            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
+          # Slim comment
+          parse_comment_block
         end
-        stacks.last << [:newline]
+      when /\A[\|']/
+        # Found a text block.
+        trailing_ws = @line.slice!(0) == ?'
+        if @line.strip.empty?
+          parse_text_block
+        else
+          @stacks.last << [:slim, :interpolate, @line.sub(/\A( )/, '')]
+          parse_text_block($1 ? 2 : 1)
+        end
+        @stacks.last << [:static, ' '] if trailing_ws
+      when /\A-/
+        # Found a code block.
+        # We expect the line to be broken or the next line to be indented.
+        block = [:multi]
+        @line.slice!(0)
+        @stacks.last << [:slim, :control, parse_broken_line, block]
+        @stacks << block
+      when /\A=/
+        # Found an output block.
+        # We expect the line to be broken or the next line to be indented.
+        @line =~ /\A=(=?)('?)/
+        @line = $'
+        block = [:multi]
+        @stacks.last << [:slim, :output, $1.empty?, parse_broken_line, block]
+        @stacks.last << [:static, ' '] unless $2.empty?
+        @stacks << block
+      when /\A(\w+):\s*\Z/
+        # Embedded template detected. It is treated as block.
+        block = [:multi]
+        @stacks.last << [:newline] << [:slim, :embedded, $1, block]
+        @stacks << block
+        parse_text_block
+        return # Don't append newline
+      when /\Adoctype\s+/i
+        # Found doctype declaration
+        @stacks.last << [:html, :doctype, $'.strip]
+      when /\A([#\.]|\w[:\w-]*)/
+        # Found a HTML tag.
+        parse_tag($&)
+      else
+        syntax_error! 'Unknown line indicator'
       end
+      @stacks.last << [:newline]
+    end
-      result
+    def parse_comment_block
+      until @lines.empty? || get_indent(@lines.first) <= @indents.last
+        next_line
+        @stacks.last << [:newline]
+      end
     end
-    DELIMITERS = {
-      '(' => ')',
-      '[' => ']',
-      '{' => '}',
-    }.freeze
-    DELIMITER_REGEX = /^[\(\[\{]/
-    CLOSE_DELIMITER_REGEX = /^[\)\]\}]/
+    def parse_text_block(offset = nil)
+      text_indent = offset ? @indents.last + offset : nil
-    private
+      until @lines.empty?
+        indent = get_indent(@lines.first)
+        break if indent <= @indents.last
-    ATTR_REGEX = /^\s+(\w[:\w-]*)=/
-    QUOTED_VALUE_REGEX = /^("[^"]*"|'[^']*')/
-    ATTR_SHORTHAND = {
-      '#' => 'id',
-      '.' => 'class',
-    }.freeze
+        next_line
-    if RUBY_VERSION > '1.9'
-      CLASS_ID_REGEX = /^(#|\.)([\w\u00c0-\uFFFF][\w:\u00c0-\uFFFF-]*)/
-    else
-      CLASS_ID_REGEX = /^(#|\.)(\w[\w:-]*)/
+        # The indentation of first line of the text block
+        # determines the text base indentation.
+        newline = text_indent ? "\n" : ''
+        text_indent ||= indent
+        # The text block lines must be at least indented
+        # as deep as the first line.
+        if indent < text_indent
+          @line.lstrip!
+          syntax_error!('Unexpected text indentation')
+        end
+        @line.slice!(0, text_indent)
+        # Generate the additional spaces in front.
+        @stacks.last  << [:newline] << [:slim, :interpolate, newline + @line]
+      end
     end
-    def parse_tag(line, lineno)
-      orig_line = line
+    def parse_broken_line
+      broken_line = @line.strip
+      while broken_line[-1] == ?\\
+        next_line || syntax_error!('Unexpected end of file')
+        broken_line << "\n" << @line.strip
+      end
+      broken_line
+    end
-      case line
-      when /^[#\.]/
+    def parse_tag(tag)
+      size = @line.size
+      if tag == '#' || tag == '.'
         tag = 'div'
-      when /^\w[:\w-]*/
-        tag = $&
-        line = $'
       else
-        syntax_error! 'Unknown line indicator', orig_line, lineno
+        @line.slice!(0, tag.size)
       end
+      tag = [:html, :tag, tag, parse_attributes]
+      @stacks.last << tag
+      case @line
+      when /\A\s*=(=?)/
+        # Handle output code
+        block = [:multi]
+        @line = $'
+        content = [:slim, :output, $1 != '=', parse_broken_line, block]
+        tag << content
+        @stacks << block
+      when /\A\s*\//
+        # Closed tag. Do nothing
+      when /\A\s*\Z/
+        # Empty content
+        content = [:multi]
+        tag << content
+        @stacks << content
+      else
+        # Text content
+        content = [:multi, [:slim, :interpolate, @line.sub(/\A( )/, '')]]
+        tag << content
+        @stacks << content
+        parse_text_block(size - @line.size + ($1 ? 1 : 0))
+      end
+    end
+    def parse_attributes
       # Now we'll have to find all the attributes. We'll store these in an
       # nested array: [[name, value], [name2, value2]]. The value is a piece
       # of Ruby code.
       attributes = [:html, :attrs]
       # Find any literal class/id attributes
-      while line =~ CLASS_ID_REGEX
+      while @line =~ CLASS_ID_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_SHORTHAND[$1], [:static, $2]]
-        line = $'
+        attributes << [:html, :attr, ATTR_SHORTCUT[$1], [:static, $2]]
+        @line = $'
       end
       # Check to see if there is a delimiter right after the tag name
-      delimiter = ''
-      if line =~ DELIMITER_REGEX
+      delimiter = nil
+      if @line =~ DELIMITER_REGEX
         delimiter = DELIMITERS[$&]
-        # Replace the delimiter with a space so we can continue parsing as normal.
-        line[0] = ?\s
+        @line.slice!(0)
       end
-      # Parse attributes
-      while line =~ ATTR_REGEX
-        name = $1
-        line = $'
-        if line =~ QUOTED_VALUE_REGEX
-          # Value is quoted (static)
-          line = $'
-          attributes << [:html, :attr, name, [:slim, :interpolate, $1[1..-2]]]
-        else
-          # Value is ruby code
-          escape = line[0] != ?=
-          line, code = parse_ruby_attribute(orig_line, escape ? line : line[1..-1], lineno, delimiter)
-          attributes << [:slim, :attr, name, escape, code]
+      orig_line = @orig_line
+      lineno = @lineno
+      while true
+        # Parse attributes
+        attr_regex = delimiter ? /#{ATTR_NAME_REGEX}(=|\s|(?=#{Regexp.escape delimiter}))/ : /#{ATTR_NAME_REGEX}=/
+        while @line =~ attr_regex
+          @line = $'
+          name = $1
+          if delimiter && $2 != '='
+            attributes << [:slim, :attr, name, false, 'true']
+          elsif @line =~ QUOTED_VALUE_REGEX
+            # Value is quoted (static)
+            @line = $'
+            attributes << [:html, :attr, name, [:slim, :interpolate, $1[1..-2]]]
+          else
+            # Value is ruby code
+            escape = @line[0] != ?=
+            @line.slice!(0) unless escape
+            attributes << [:slim, :attr, name, escape, parse_ruby_attribute(delimiter)]
+          end
         end
-      end
-      # Find ending delimiter
-      unless delimiter.empty?
-        if line =~ /^\s*#{Regexp.escape delimiter}/
-          line = $'
-        else
-          syntax_error! "Expected closing delimiter #{delimiter}", orig_line, lineno, orig_line.size - line.size
+        # No ending delimiter, attribute end
+        break unless delimiter
+        # Find ending delimiter
+        if @line =~ /\A\s*#{Regexp.escape delimiter}/
+          @line = $'
+          break
         end
-      end
-      content = [:multi]
-      tag = [:html, :tag, tag, attributes, content]
+        # Found something where an attribute should be
+        @line.lstrip!
+        syntax_error!('Expected attribute') unless @line.empty?
-      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 =~ /^\s*\//
-        # Closed tag
-        tag.pop
-        [tag, block, nil, nil]
-      elsif line =~ /^\s*$/
-        # Empty line
-        [tag, content, nil, nil]
-      else
-        # Handle text content
-        content << [:slim, :interpolate, line.sub(/^( )/, '')]
-        [tag, content, nil, orig_line.size - line.size + ($1 ? 1 : 0)]
+        # 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
+      return attributes
     end
-    def parse_ruby_attribute(orig_line, line, lineno, delimiter)
+    def parse_ruby_attribute(delimiter)
       # Delimiter stack
       stack = []
@@ -364,41 +389,53 @@ module Slim
       value = ''
       # Attribute ends with space or attribute delimiter
-      end_regex = /^[\s#{Regexp.escape delimiter}]/
+      end_regex = /\A[\s#{Regexp.escape delimiter.to_s}]/
-      until line.empty?
-        if stack.empty? && line =~ end_regex
+      until @line.empty?
+        if stack.empty? && @line =~ end_regex
           # Stack is empty, this means we left the attribute value
           # if next character is space or attribute delimiter
           break
-        elsif line =~ DELIMITER_REGEX
+        elsif @line =~ DELIMITER_REGEX
           # Delimiter found, push it on the stack
           stack << DELIMITERS[$&]
-          value << line.slice!(0)
-        elsif line =~ CLOSE_DELIMITER_REGEX
+          value << @line.slice!(0)
+        elsif @line =~ CLOSE_DELIMITER_REGEX
           # Closing delimiter found, pop it from the stack if everything is ok
-          syntax_error! "Unexpected closing #{$&}", orig_line, lineno if stack.empty?
-          syntax_error! "Expected closing #{stack.last}", orig_line, lineno if stack.last != $&
-          value << line.slice!(0)
+          syntax_error!("Unexpected closing #{$&}") if stack.empty?
+          syntax_error!("Expected closing #{stack.last}") if stack.last != $&
+          value << @line.slice!(0)
           stack.pop
         else
-          value << line.slice!(0)
+          value << @line.slice!(0)
         end
       end
-      syntax_error! "Expected closing attribute delimiter #{stack.last}", orig_line, lineno unless stack.empty?
-      syntax_error! 'Invalid empty attribute', orig_line, lineno if value.empty?
+      unless stack.empty?
+        syntax_error!("Expected closing attribute delimiter #{stack.last}")
+      end
+      if value.empty?
+        syntax_error!('Invalid empty attribute')
+      end
       # 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 = value[1..-2] if value =~ DELIMITER_REGEX &&
+        DELIMITERS[$&] == value[-1, 1]
-      return line, value
+      return value
     end
     # Helper for raising exceptions
-    def syntax_error!(message, *args)
-      raise SyntaxError.new(message, options[:file], *args)
+    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])
     end
   end
 end