haml-edge 2.3.100 → 2.3.148

data/.yardopts

@@ -1,5 +1,8 @@
 --readme          README.md
 --markup          markdown
 --markup-provider maruku
+--default-return  ""
+--hide-void-return
 --protected
+--no-private
 --no-highlight

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.100
+2.3.148

data/Rakefile

@@ -57,6 +57,7 @@ task :revision_file do
   end
 end
 Rake::Task[:package].prerequisites.insert(0, :revision_file)
+Rake::Task[:package].prerequisites.insert(0, :submodules)
 
 # We also need to get rid of this file after packaging.
 at_exit { File.delete('REVISION') rescue nil }
@@ -72,7 +73,6 @@ desc "Release a new Haml package to Rubyforge."
 task :release => [:check_release, :release_elpa, :package] do
   name = File.read("VERSION_NAME").strip
   version = File.read("VERSION").strip
-  sh %{rubyforge login}
   sh %{rubyforge add_release haml haml "#{name} (v#{version})" pkg/haml-#{version}.gem}
   sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.gz}
   sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.tar.bz2}
@@ -167,6 +167,18 @@ def mode_unchanged?(mode, version)
   return false
 end
 
+task :submodules do
+  if File.exist?(File.dirname(__FILE__) + "/.git")
+    sh %{git submodule sync}
+    sh %{git submodule update --init}
+  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/fssm/lib")
+    warn <<WARN
+WARNING: vendor/fssm doesn't exist, and this isn't a git repository so
+I can't get it automatically!
+WARN
+  end
+end
+
 task :release_edge do
   ensure_git_cleanup do
     puts "#{'=' * 50} Running rake release_edge"
@@ -239,7 +251,7 @@ begin
       list.exclude('lib/haml/template/*.rb')
       list.exclude('lib/haml/helpers/action_view_mods.rb')
     end.to_a
-    t.options << '--use-cache' if Rake.application.top_level_tasks.include?('redoc')
+    t.options << '--incremental' if Rake.application.top_level_tasks.include?('redoc')
     t.options += FileList.new('yard/*.rb').to_a.map {|f| ['-e', f]}.flatten
     files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
     t.options << '--files' << files.join(',')

data/VERSION

@@ -1 +1 @@
-2.3.100
+2.3.148

data/extra/haml-mode.el

@@ -4,7 +4,7 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 2.2.7
+;; Version: 2.2.18
 ;; Created: 2007-03-08
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, html
@@ -25,6 +25,13 @@
 (eval-when-compile (require 'cl))
 (require 'ruby-mode)
 
+;; Additional (optional) libraries for fontification
+(require 'css-mode nil nil)
+(require 'textile-mode nil nil)
+(require 'markdown-mode nil nil)
+(require 'javascript-mode "javascript" nil)
+
+
 ;; User definable variables
 
 (defgroup haml nil
@@ -92,22 +99,33 @@ The line containing RE is matched, as well as all lines indented beneath it."
 (defconst haml-font-lock-keywords
   `((,(haml-nested-regexp "\\(?:-#\\|/\\).*")  0 font-lock-comment-face)
     (,(haml-nested-regexp ":\\w+") 0 font-lock-string-face)
-    (haml-highlight-interpolation  1 font-lock-variable-name-face prepend)
-    (haml-highlight-ruby-tag       1 font-lock-preprocessor-face)
-    (haml-highlight-ruby-script    1 font-lock-preprocessor-face)
-    ("^ *\\(\t\\)"                 1 'haml-tab-face)
-    ("^!!!.*"                      0 font-lock-constant-face)
-    ("| *$"                        0 font-lock-string-face)))
+    (haml-highlight-ruby-filter-block     1 font-lock-preprocessor-face)
+    (haml-highlight-css-filter-block      1 font-lock-preprocessor-face)
+    (haml-highlight-textile-filter-block  1 font-lock-preprocessor-face)
+    (haml-highlight-markdown-filter-block 1 font-lock-preprocessor-face)
+    (haml-highlight-js-filter-block       1 font-lock-preprocessor-face)
+    (haml-highlight-interpolation         1 font-lock-variable-name-face prepend)
+    (haml-highlight-ruby-tag              1 font-lock-preprocessor-face)
+    (haml-highlight-ruby-script           1 font-lock-preprocessor-face)
+    ("^ *\\(\t\\)"                        1 'haml-tab-face)
+    ("^!!!.*"                             0 font-lock-constant-face)
+    ("| *$"                               0 font-lock-string-face)))
 
 (defconst haml-filter-re "^ *:\\w+")
 (defconst haml-comment-re "^ *\\(?:-\\#\\|/\\)")
 
-(defun haml-fontify-region-as-ruby (beg end)
-  "Use Ruby's font-lock variables to fontify the region between BEG and END."
+(defun haml-fontify-region (beg end keywords syntax-table syntactic-keywords)
+  "Fontify a region between BEG and END using another mode's fontification.
+
+KEYWORDS, SYNTAX-TABLE, and SYNTACTIC-KEYWORDS are the values of that mode's
+`font-lock-keywords', `font-lock-syntax-table',
+and `font-lock-syntactic-keywords', respectively."
   (save-excursion
     (save-match-data
-      (let ((font-lock-keywords ruby-font-lock-keywords)
-            (font-lock-syntactic-keywords ruby-font-lock-syntactic-keywords)
+      (let ((font-lock-keywords keywords)
+            (font-lock-syntax-table syntax-table)
+            (font-lock-syntactic-keywords syntactic-keywords)
+            (font-lock-multiline 'undecided)
             font-lock-keywords-only
             font-lock-extend-region-functions
             font-lock-keywords-case-fold-search)
@@ -115,6 +133,74 @@ The line containing RE is matched, as well as all lines indented beneath it."
         ;; so we have to move the beginning back one char
         (font-lock-fontify-region (- beg 1) end)))))
 
+(defun haml-fontify-region-as-ruby (beg end)
+  "Use Ruby's font-lock variables to fontify the region between BEG and END."
+  (haml-fontify-region beg end ruby-font-lock-keywords nil
+                       ruby-font-lock-syntactic-keywords))
+
+(defun haml-handle-filter (filter-name limit fn)
+  "If a FILTER-NAME filter is found within LIMIT, run FN on that filter.
+
+FN is passed a pair of points representing the beginning and end
+of the filtered text."
+  (when (re-search-forward (haml-nested-regexp (concat ":" filter-name)) limit t)
+    (funcall fn (+ 2 (match-beginning 2)) (match-end 2))))
+
+(defun haml-fontify-filter-region (filter-name limit &rest fontify-region-args)
+  "If a FILTER-NAME filter is found within LIMIT, fontify it.
+
+The fontification is done by passing FONTIFY-REGION-ARGS to
+`haml-fontify-region'."
+  (haml-handle-filter filter-name limit
+                      (lambda (beg end)
+                        (apply 'haml-fontify-region
+                               (append (list beg end)
+                                       fontify-region-args)))))
+
+(defun haml-highlight-ruby-filter-block (limit)
+  "If a :ruby filter is found within LIMIT, highlight it."
+  (haml-handle-filter "ruby" limit 'haml-fontify-region-as-ruby))
+
+(defun haml-highlight-css-filter-block (limit)
+  "If a :css filter is found within LIMIT, highlight it.
+
+This requires that `css-mode' is available.
+`css-mode' is included with Emacs 23."
+  (if (boundp 'css-font-lock-keywords)
+      (haml-fontify-filter-region "css" limit css-font-lock-keywords nil nil)))
+
+(defun haml-highlight-js-filter-block (limit)
+  "If a :javascript filter is found within LIMIT, highlight it.
+
+This requires that Karl Landström's \"javascript.el\" be available."
+  (if (boundp 'js-font-lock-keywords-3)
+      (haml-fontify-filter-region "javascript"
+                                  limit
+                                  js-font-lock-keywords-3
+                                  javascript-mode-syntax-table
+                                  nil)))
+
+(defun haml-highlight-textile-filter-block (limit)
+  "If a :textile filter is found within LIMIT, highlight it.
+
+This requires that `textile-mode' be available.
+
+Note that the results are not perfect, since `textile-mode' expects
+certain constructs such as \"h1.\" to be at the beginning of a line,
+and indented Haml filters always have leading whitespace."
+  (if (boundp 'textile-font-lock-keywords)
+      (haml-fontify-filter-region "textile" limit textile-font-lock-keywords nil nil)))
+
+(defun haml-highlight-markdown-filter-block (limit)
+  "If a :markdown filter is found within LIMIT, highlight it.
+
+This requires that `markdown-mode' be available."
+  (if (boundp 'markdown-mode-font-lock-keywords)
+      (haml-fontify-filter-region "markdown" limit
+                                  markdown-mode-font-lock-keywords
+                                  markdown-mode-syntax-table
+                                  nil)))
+
 (defun haml-highlight-ruby-script (limit)
   "Highlight a Ruby script expression (-, =, or ~).
 LIMIT works as it does in `re-search-forward'."

data/extra/sass-mode.el

@@ -4,11 +4,11 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 2.2.7
+;; Version: 2.2.18
 ;; Created: 2007-03-15
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, css
-;; Package-Requires: ((haml-mode "2.2.7"))
+;; Package-Requires: ((haml-mode "2.2.18"))
 
 ;;; Commentary:
 

data/lib/haml/engine.rb

@@ -88,7 +88,7 @@ module Haml
       unless ruby1_8?
         @options[:encoding] = Encoding.default_internal || "utf-8"
       end
-      @options.merge! options
+      @options.merge! options.reject {|k, v| v.nil?}
       @index = 0
 
       unless [:xhtml, :html4, :html5].include?(@options[:format])
@@ -138,7 +138,7 @@ module Haml
     #     Haml::Engine.new("%p= upcase").render(s) #=> "<p>FOOBAR</p>"
     #
     #     # s now extends Haml::Helpers
-    #     s.responds_to?(:html_attrs) #=> true
+    #     s.respond_to?(:html_attrs) #=> true
     #
     # `locals` is a hash of local variables to make available to the template.
     # For example:

data/lib/haml/exec.rb

@@ -1,5 +1,6 @@
 require 'optparse'
 require 'fileutils'
+require 'rbconfig'
 
 module Haml
   # This module handles the various Haml executables (`haml`, `sass`, `css2sass`, etc).
@@ -67,6 +68,12 @@ module Haml
           @options[:trace] = true
         end
 
+        if RbConfig::CONFIG['host_os'] =~ /mswin|windows/i
+          opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
+            @options[:unix_newlines] = true
+          end
+        end
+
         opts.on_tail("-?", "-h", "--help", "Show this message") do
           puts opts
           exit
@@ -105,6 +112,7 @@ module Haml
 
       def open_file(filename, flag = 'r')
         return if filename.nil?
+        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
         File.open(filename, flag)
       end
     end
@@ -210,13 +218,23 @@ END
       def set_opts(opts)
         super
 
+        opts.on('--watch', 'Watch files or directories for changes.',
+                           'The location of the generated CSS can be set using a colon:',
+                           '  sass --watch input.sass:output.css',
+                           '  sass --watch input-dir:output-dir') do
+          @options[:watch] = true
+        end
+        opts.on('--update', 'Compile files or directories to CSS.',
+                            'Locations are set like --watch.') do
+          @options[:update] = true
+        end
         opts.on('-t', '--style NAME',
                 'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
           @options[:for_engine][:style] = name.to_sym
         end
-        opts.on('-l', '--line-comments',
-                'Line Comments. Emit comments in the generated CSS indicating the corresponding sass line.') do
-          @options[:for_engine][:line_comments] = true
+        opts.on('-l', '--line-numbers', '--line-comments',
+                'Emit comments in the generated CSS indicating the corresponding sass line.') do
+          @options[:for_engine][:line_numbers] = true
         end
         opts.on('-i', '--interactive',
                 'Run an interactive SassScript shell.') do
@@ -225,8 +243,8 @@ END
         opts.on('-I', '--load-path PATH', 'Add a sass import path.') do |path|
           @options[:for_engine][:load_paths] << path
         end
-        opts.on('--cache-location', 'The path to put cached Sass files. Defaults to .sass-cache.') do |loc|
-          @options[:for_engine][:cache_location] = path
+        opts.on('--cache-location PATH', 'The path to put cached Sass files. Defaults to .sass-cache.') do |loc|
+          @options[:for_engine][:cache_location] = loc
         end
         opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
           @options[:for_engine][:cache] = false
@@ -236,34 +254,112 @@ END
       # Processes the options set by the command-line arguments,
       # and runs the Sass compiler appropriately.
       def process_result
-        if @options[:interactive]
-          require 'sass'
-          require 'sass/repl'
-          ::Sass::Repl.new(@options).run
-          return
+        if @args.first && @args.first.include?(':')
+          if @args.size == 1
+            @args = @args.first.split(':', 2)
+          else
+            @options[:update] = true
+          end
         end
 
+        return interactive if @options[:interactive]
+        return watch_or_update if @options[:watch] || @options[:update]
         super
-        input = @options[:input]
-        output = @options[:output]
 
-        tree =
-          if input.is_a?(File) && !@options[:check_syntax]
-            ::Sass::Files.tree_for(input.path, @options[:for_engine])
+        begin
+          input = @options[:input]
+          output = @options[:output]
+
+          tree =
+            if input.is_a?(File) && !@options[:check_syntax]
+              ::Sass::Files.tree_for(input.path, @options[:for_engine])
+            else
+              # We don't need to do any special handling of @options[:check_syntax] here,
+              # because the Sass syntax checking happens alongside evaluation
+              # and evaluation doesn't actually evaluate any code anyway.
+              ::Sass::Engine.new(input.read(), @options[:for_engine]).to_tree
+            end
+
+          input.close() if input.is_a?(File)
+
+          output.write(tree.render)
+          output.close() if output.is_a? File
+        rescue ::Sass::SyntaxError => e
+          raise e if @options[:trace]
+          raise e.sass_backtrace_str("standard input")
+        end
+      end
+
+      private
+
+      def interactive
+        require 'sass'
+        require 'sass/repl'
+        ::Sass::Repl.new(@options).run
+      end
+
+      def watch_or_update
+        require 'sass'
+        require 'sass/plugin'
+        ::Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
+
+        dirs, files = @args.map {|name| name.split(':', 2)}.
+          map {|from, to| [from, to || from.gsub(/\..*?$/, '.css')]}.
+          partition {|i, _| File.directory? i}
+        ::Sass::Plugin.options[:template_location] = dirs
+
+        ::Sass::Plugin.on_updating_stylesheet do |_, css|
+          if File.exists? css
+            puts_action :overwrite, :yellow, css
           else
-            # We don't need to do any special handling of @options[:check_syntax] here,
-            # because the Sass syntax checking happens alongside evaluation
-            # and evaluation doesn't actually evaluate any code anyway.
-            ::Sass::Engine.new(input.read(), @options[:for_engine]).to_tree
+            puts_action :create, :green, css
           end
+        end
 
-        input.close() if input.is_a?(File)
+        ::Sass::Plugin.on_creating_directory {|dirname| puts_action :directory, :green, dirname}
+        ::Sass::Plugin.on_deleting_css {|filename| puts_action :delete, :yellow, filename}
+        ::Sass::Plugin.on_compilation_error do |error, _, _|
+          unless error.is_a?(::Sass::SyntaxError)
+            if error.is_a?(Errno::ENOENT) && error.message =~ /^No such file or directory - (.*)$/ && $1 == @args[1]
+              flag = @options[:update] ? "--update" : "--watch"
+              error.message << "\n  Did you mean: sass #{flag} #{@args[0]}:#{@args[1]}"
+            end
 
-        output.write(tree.render)
-        output.close() if output.is_a? File
-      rescue ::Sass::SyntaxError => e
-        raise e if @options[:trace]
-        raise e.sass_backtrace_str("standard input")
+            raise error
+          end
+
+          puts_action :error, :red, "#{error.sass_filename} (Line #{error.sass_line}: #{error.message})"
+        end
+
+        if @options[:update]
+          ::Sass::Plugin.update_stylesheets(files)
+          return
+        end
+
+        puts ">>> Sass is watching for changes. Press Ctrl-C to stop."
+
+        ::Sass::Plugin.on_template_modified {|template| puts ">>> Change detected to: #{template}"}
+        ::Sass::Plugin.on_template_created {|template| puts ">>> New template detected: #{template}"}
+        ::Sass::Plugin.on_template_deleted {|template| puts ">>> Deleted template detected: #{template}"}
+
+        ::Sass::Plugin.watch(files)
+      end
+
+      # @private
+      COLORS = { :red => 31, :green => 32, :yellow => 33 }
+
+      def puts_action(name, color, arg)
+        printf color(color, "%11s %s\n"), name, arg
+      end
+
+      def color(color, str)
+        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
+
+        # Almost any real Unix terminal will support color,
+        # so we just filter for Windows terms (which don't set TERM)
+        # and not-real terminals, which aren't ttys.
+        return str if ENV["TERM"].empty? || !STDOUT.tty?
+        return "\e[#{COLORS[color]}m#{str}\e[0m"
       end
     end
 

data/lib/haml/filters.rb

@@ -299,7 +299,7 @@ END
       def compile(precompiler, text)
         return if precompiler.options[:suppress_eval]
         src = ::ERB.new(text).src.sub(/^#coding:.*?\n/, '').
-          sub(/^_erbout = '';/, "").gsub("\n", ';')
+          sub(/^_erbout = '';/, "")
         precompiler.send(:push_silent, src)
       end
     end

data/lib/haml/helpers/action_view_mods.rb

@@ -26,7 +26,8 @@ module ActionView
 
       def set_output_buffer_with_haml(new)
         if is_haml?
-          new = String.new(new) if Haml::Util.rails_xss_safe? && new.is_a?(ActionView::SafeBuffer)
+          new = String.new(new) if Haml::Util.rails_xss_safe? &&
+            new.is_a?(Haml::Util.rails_safe_buffer_class)
           haml_buffer.buffer = new
         else
           set_output_buffer_without_haml new

data/lib/haml/helpers/xss_mods.rb

@@ -19,45 +19,46 @@ module Haml
       def html_escape_with_haml_xss(text)
         str = text.to_s
         return text if str.html_safe?
-        html_escape_without_haml_xss(str).html_safe!
+        Haml::Util.html_safe(html_escape_without_haml_xss(str))
       end
 
       # Output is always HTML safe
       def find_and_preserve_with_haml_xss(*args, &block)
-        find_and_preserve_without_haml_xss(*args, &block).html_safe!
+        Haml::Util.html_safe(find_and_preserve_without_haml_xss(*args, &block))
       end
 
       # Output is always HTML safe
       def preserve_with_haml_xss(*args, &block)
-        preserve_without_haml_xss(*args, &block).html_safe!
+        Haml::Util.html_safe(preserve_without_haml_xss(*args, &block))
       end
 
       # Output is always HTML safe
       def list_of_with_haml_xss(*args, &block)
-        list_of_without_haml_xss(*args, &block).html_safe!
+        Haml::Util.html_safe(list_of_without_haml_xss(*args, &block))
       end
 
       # Input is escaped, output is always HTML safe
       def surround_with_haml_xss(front, back = front, &block)
-        surround_without_haml_xss(
-          haml_xss_html_escape(front),
-          haml_xss_html_escape(back),
-          &block).html_safe!
+        Haml::Util.html_safe(
+          surround_without_haml_xss(
+            haml_xss_html_escape(front),
+            haml_xss_html_escape(back),
+            &block))
       end
 
       # Input is escaped, output is always HTML safe
       def precede_with_haml_xss(str, &block)
-        precede_without_haml_xss(haml_xss_html_escape(str), &block).html_safe!
+        Haml::Util.html_safe(precede_without_haml_xss(haml_xss_html_escape(str), &block))
       end
 
       # Input is escaped, output is always HTML safe
       def succeed_with_haml_xss(str, &block)
-        succeed_without_haml_xss(haml_xss_html_escape(str), &block).html_safe!
+        Haml::Util.html_safe(succeed_without_haml_xss(haml_xss_html_escape(str), &block))
       end
 
       # Output is always HTML safe
       def capture_haml_with_haml_xss(*args, &block)
-        capture_haml_without_haml_xss(*args, &block).html_safe!
+        Haml::Util.html_safe(capture_haml_without_haml_xss(*args, &block))
       end
 
       # Input is escaped
@@ -67,7 +68,7 @@ module Haml
 
       # Output is always HTML safe
       def haml_indent_with_haml_xss
-        haml_indent_without_haml_xss.html_safe!
+        Haml::Util.html_safe(haml_indent_without_haml_xss)
       end
 
       # Input is escaped, haml_concat'ed output is always HTML safe
@@ -79,7 +80,7 @@ module Haml
 
       # Output is always HTML safe
       def escape_once_with_haml_xss(*args)
-        escape_once_without_haml_xss(*args).html_safe!
+        Haml::Util.html_safe(escape_once_without_haml_xss(*args))
       end
 
       private
@@ -93,3 +94,32 @@ module Haml
     end
   end
 end
+
+module ActionView
+  module Helpers
+    module TextHelper
+      def concat_with_haml(string)
+        if is_haml?
+          haml_buffer.buffer.concat(haml_xss_html_escape(string))
+        else
+          concat_without_haml(string)
+        end
+      end
+      alias_method :concat_without_haml, :concat
+      alias_method :concat, :concat_with_haml
+
+      # safe_concat was introduced in Rails 3.0
+      if Haml::Util.has?(:instance_method, self, :safe_concat)
+        def safe_concat_with_haml(string)
+          if is_haml?
+            haml_buffer.buffer.concat(string)
+          else
+            concat_without_haml(string)
+          end
+        end
+        alias_method :safe_concat_without_haml, :safe_concat
+        alias_method :safe_concat, :safe_concat_with_haml
+      end
+    end
+  end
+end

data/lib/haml/helpers.rb

@@ -338,22 +338,16 @@ MESSAGE
       haml_buffer.capture_position = nil
     end
 
-    # @deprecated This will be removed in version 2.4.
-    # @see #haml_concat
-    def puts(*args)
-      warn <<END
-DEPRECATION WARNING:
-The Haml #puts helper is deprecated and will be removed in version 2.4.
-Use the #haml_concat helper instead.
-END
-      haml_concat(*args)
-    end
-
     # Outputs text directly to the Haml buffer, with the proper indentation.
     #
     # @param text [#to_s] The text to output
     def haml_concat(text = "")
-      haml_buffer.buffer << haml_indent << text.to_s << "\n"
+      unless haml_buffer.options[:ugly] || haml_indent == 0
+        haml_buffer.buffer << haml_indent <<
+          text.to_s.gsub("\n", "\n" + haml_indent) << "\n"
+      else
+        haml_buffer.buffer << text.to_s << "\n"
+      end
       ErrorReturn.new("haml_concat")
     end
 
@@ -367,6 +361,11 @@ END
     # If the block is a Haml block or outputs text using \{#haml\_concat},
     # the text will be properly indented.
     #
+    # `name` can be a string using the standard Haml class/id shorthand
+    # (e.g. "span#foo.bar", "#foo").
+    # Just like standard Haml tags, these class and id values
+    # will be merged with manually-specified attributes.
+    #
     # `flags` is a list of symbol flags
     # like those that can be put at the end of a Haml tag
     # (`:/`, `:<`, and `:>`).
@@ -381,7 +380,7 @@ END
     #
     #     haml_tag :table do
     #       haml_tag :tr do
-    #         haml_tag :td, {:class => 'cell'} do
+    #         haml_tag 'td.cell' do
     #           haml_tag :strong, "strong!"
     #           haml_concat "data"
     #         end
@@ -417,13 +416,14 @@ END
     def haml_tag(name, *rest, &block)
       ret = ErrorReturn.new("haml_tag")
 
-      name = name.to_s
       text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
       flags = []
       flags << rest.shift while rest.first.is_a? Symbol
+      name, attrs = merge_name_and_attributes(name.to_s, rest.shift || {})
+
       attributes = Haml::Precompiler.build_attributes(haml_buffer.html?,
                                                       haml_buffer.options[:attr_wrapper],
-                                                      rest.shift || {})
+                                                      attrs)
 
       if text.nil? && block.nil? && (haml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
         haml_concat "<#{name}#{attributes} />"
@@ -437,8 +437,17 @@ END
 
       tag = "<#{name}#{attributes}>"
       if block.nil?
-        tag << text.to_s << "</#{name}>"
-        haml_concat tag
+        text = text.to_s
+        if text.include?("\n")
+          haml_concat tag
+          tab_up
+          haml_concat text
+          tab_down
+          haml_concat "</#{name}>"
+        else
+          tag << text << "</#{name}>"
+          haml_concat tag
+        end
         return ret
       end
 
@@ -462,6 +471,7 @@ END
     end
 
     # Characters that need to be escaped to HTML entities from user input
+    # @private
     HTML_ESCAPE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
 
     # Returns a copy of `text` with ampersands, angle brackets and quotes
@@ -512,6 +522,17 @@ END
 
     private
 
+    # Parses the tag name used for \{#haml\_tag}
+    # and merges it with the Ruby attributes hash.
+    def merge_name_and_attributes(name, attributes_hash = {})
+      # skip merging if no ids or classes found in name
+      return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
+
+      return $1 || "div", Buffer.merge_attrs(
+        Precompiler.parse_class_and_id($2),
+        Haml::Util.map_keys(attributes_hash) {|key| key.to_s})
+    end
+
     # Runs a block of code with the given buffer as the currently active buffer.
     #
     # @param buffer [Haml::Buffer] The Haml buffer to use temporarily