haml 2.0.7 → 2.0.8

data/Rakefile

@@ -13,7 +13,11 @@ end
 
 # ----- Default: Testing ------
 
-task :default => :test
+if ENV["RUN_CODE_RUN"] == "true"
+  task :default => :"test:rails_compatibility"
+else
+  task :default => :test
+end
 
 require 'rake/testtask'
 
@@ -148,3 +152,33 @@ END
     RubyProf.const_get("#{(ENV['OUTPUT'] || 'Flat').capitalize}Printer").new(result).print 
   end
 rescue LoadError; end
+
+# ----- Testing Multiple Rails Versions -----
+
+rails_versions = [
+  "v2.3.0",
+  "v2.2.2",
+  "v2.1.2",
+  "v2.0.5"
+]
+
+namespace :test do
+  desc "Test all supported versions of rails. This takes a while."
+  task :rails_compatibility do
+    `rm -rf test/rails`
+    puts "Checking out rails. Please wait."
+    `git clone git://github.com/rails/rails.git test/rails` rescue nil
+    begin
+      rails_versions.each do |version|
+        Dir.chdir "test/rails" do
+          `git checkout #{version}`
+        end
+        puts "Testing Rails #{version}"
+        Rake::Task['test'].reenable
+        Rake::Task['test'].execute
+      end
+    ensure
+      `rm -rf test/rails`
+    end
+  end
+end

data/VERSION

@@ -1 +1 @@
-2.0.7
+2.0.8

data/extra/haml-mode.el

@@ -0,0 +1,331 @@
+;;; haml-mode.el -- Major mode for editing Haml files
+;;; Written by Nathan Weizenbaum
+
+;;; Because Haml's indentation schema is similar
+;;; to that of YAML and Python, many indentation-related
+;;; functions are similar to those in yaml-mode and python-mode.
+
+;;; To install, save this somewhere and add the following to your .emacs file:
+;;;
+;;; (add-to-list 'load-path "/path/to/haml-mode.el")
+;;; (require 'haml-mode nil 't)
+;;; (add-to-list 'auto-mode-alist '("\\.haml$" . haml-mode))
+;;;
+
+;;; Code:
+
+(eval-when-compile (require 'cl))
+
+;; User definable variables
+
+(defgroup haml nil
+  "Support for the Haml template language."
+  :group 'languages
+  :prefix "haml-")
+
+(defcustom haml-mode-hook nil
+  "Hook run when entering Haml mode."
+  :type 'hook
+  :group 'haml)
+
+(defcustom haml-indent-offset 2
+  "Amount of offset per level of indentation."
+  :type 'integer
+  :group 'haml)
+
+(defcustom haml-backspace-backdents-nesting t
+  "Non-nil to have `haml-electric-backspace' re-indent all code
+nested beneath the backspaced line be re-indented along with the
+line itself."
+  :type 'boolean
+  :group 'haml)
+
+(defface haml-tab-face
+  '((((class color)) (:background "hotpink"))
+    (t (:reverse-video t)))
+  "Face to use for highlighting tabs in Haml files."
+  :group 'faces
+  :group 'haml)
+
+(defvar haml-indent-function 'haml-indent-p
+  "This function should look at the current line and return true
+if the next line could be nested within this line.")
+
+(defvar haml-block-openers
+  `("^ *\\([%\\.#][^ \t]*\\)\\(\\[.*\\]\\)?\\({.*}\\)?\\(\\[.*\\]\\)?[ \t]*$"
+    "^ *[-=].*do[ \t]*\\(|.*|[ \t]*\\)?$"
+    ,(concat "^ *-[ \t]*\\("
+             (regexp-opt '("else" "elsif" "rescue" "ensure" "when"))
+             "\\)")
+    "^ */\\(\\[.*\\]\\)?[ \t]*$"
+    "^ *-#"
+    "^ *:")
+  "A list of regexps that match lines of Haml that could have
+text nested beneath them.")
+
+;; Font lock
+
+(defconst haml-font-lock-keywords
+  '(("^ *\\(\t\\)"               1 'haml-tab-face)
+    ("^!!!.*"                    0 font-lock-constant-face)
+    ("\\('[^']*'\\)"             1 font-lock-string-face append)
+    ("\\(\"[^\"]*\"\\)"          1 font-lock-string-face append)
+    ("&?:\\w+"                   0 font-lock-constant-face append)
+    ("@[a-z0-9_]+"               0 font-lock-variable-name-face append)
+    ("| *$"                      0 font-lock-string-face)
+    ("^[ \t]*\\(/.*\\)$"         1 font-lock-comment-face append)
+    ("^ *\\(#[a-z0-9_]+\/?\\)"   1 font-lock-keyword-face)
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)" 1 font-lock-type-face)
+    ("^ *\\(%[a-z0-9_]+\/?\\)"   1 font-lock-function-name-face)
+    ("^ *\\(#[a-z0-9_]+\/?\\)"   (1 font-lock-keyword-face)
+     ("\\.[a-z0-9_]+" nil nil    (0 font-lock-type-face)))
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)" (1 font-lock-type-face)
+     ("\\.[a-z0-9_]+" nil nil    (0 font-lock-type-face)))
+    ("^ *\\(\\.[a-z0-9_]+\/?\\)" (1 font-lock-type-face)
+     ("\\#[a-z0-9_]+" nil nil    (0 font-lock-keyword-face)))
+    ("^ *\\(%[a-z0-9_]+\/?\\)"   (1 font-lock-function-name-face)
+     ("\\.[a-z0-9_]+" nil nil    (0 font-lock-type-face)))
+    ("^ *\\(%[a-z0-9_]+\/?\\)"   (1 font-lock-function-name-face)
+     ("\\#[a-z0-9_]+" nil nil    (0 font-lock-keyword-face)))
+    ("^ *\\([~=-] .*\\)"         1 font-lock-preprocessor-face prepend)
+    ("^ *[\\.#%a-z0-9_]+\\([~=-] .*\\)"     1 font-lock-preprocessor-face prepend)
+    ("^ *[\\.#%a-z0-9_]+\\({[^}]+}\\)"      1 font-lock-preprocessor-face prepend)
+    ("^ *[\\.#%a-z0-9_]+\\(\\[[^]]+\\]\\)"  1 font-lock-preprocessor-face prepend)))
+
+;; Mode setup
+
+(defvar haml-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    (modify-syntax-entry ?: "." table)
+    (modify-syntax-entry ?_ "w" table)
+    table)
+  "Syntax table in use in haml-mode buffers.")
+
+(defvar haml-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [backspace] 'haml-electric-backspace)
+    (define-key map "\C-?" 'haml-electric-backspace)
+    (define-key map "\C-\M-f" 'haml-forward-sexp)
+    (define-key map "\C-\M-b" 'haml-backward-sexp)
+    (define-key map "\C-\M-u" 'haml-up-list)
+    (define-key map "\C-\M-d" 'haml-down-list)
+    (define-key map "\C-C\C-k" 'haml-kill-line-and-indent)
+    map))
+
+;;;###autoload
+(define-derived-mode haml-mode fundamental-mode "Haml"
+  "Major mode for editing Haml files.
+
+\\{haml-mode-map}"
+  (set-syntax-table haml-mode-syntax-table)
+  (set (make-local-variable 'indent-line-function) 'haml-indent-line)
+  (set (make-local-variable 'indent-region-function) 'haml-indent-region)
+  (set (make-local-variable 'forward-sexp-function) 'haml-forward-sexp)
+  (setq indent-tabs-mode nil)
+  (setq font-lock-defaults '((haml-font-lock-keywords) nil t)))
+
+;; Navigation
+
+(defun haml-forward-through-whitespace (&optional backward)
+  "Move the point forward at least one line, until it reaches
+either the end of the buffer or a line with no whitespace.
+
+If `backward' is non-nil, move the point backward instead."
+  (let ((arg (if backward -1 1))
+        (endp (if backward 'bobp 'eobp)))
+    (loop do (forward-line arg)
+          while (and (not (funcall endp))
+                     (looking-at "^[ \t]*$")))))
+
+(defun haml-at-indent-p ()
+  "Returns whether or not the point is at the first
+non-whitespace character in a line or whitespace preceding that
+character."
+  (let ((opoint (point)))
+    (save-excursion
+      (back-to-indentation)
+      (>= (point) opoint))))
+
+(defun haml-forward-sexp (&optional arg)
+  "Move forward across one nested expression.
+With `arg', do it that many times.  Negative arg -N means move
+backward across N balanced expressions.
+
+A sexp in Haml is defined as a line of Haml code as well as any
+lines nested beneath it."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (if (and (< arg 0) (not (haml-at-indent-p)))
+      (back-to-indentation)
+    (while (/= arg 0)
+      (let ((indent (current-indentation)))
+        (loop do (haml-forward-through-whitespace (< arg 0))
+              while (and (not (eobp))
+                         (not (bobp))
+                         (> (current-indentation) indent)))
+        (back-to-indentation)
+      (setq arg (+ arg (if (> arg 0) -1 1)))))))
+
+(defun haml-backward-sexp (&optional arg)
+  "Move backward across one nested expression.
+With ARG, do it that many times.  Negative arg -N means move
+forward across N balanced expressions.
+
+A sexp in Haml is defined as a line of Haml code as well as any
+lines nested beneath it."
+  (interactive "p")
+  (haml-forward-sexp (if arg (- arg) -1)))
+
+(defun haml-up-list (&optional arg)
+  "Move out of one level of nesting.
+With ARG, do this that many times."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (while (> arg 0)
+    (let ((indent (current-indentation)))
+      (loop do (haml-forward-through-whitespace t)
+            while (and (not (bobp))
+                       (>= (current-indentation) indent)))
+      (setq arg (- arg 1))))
+  (back-to-indentation))
+
+(defun haml-down-list (&optional arg)
+  "Move down one level of nesting.
+With ARG, do this that many times."
+  (interactive "p")
+  (or arg (setq arg 1))
+  (while (> arg 0)
+    (let ((indent (current-indentation)))
+      (haml-forward-through-whitespace)
+      (when (<= (current-indentation) indent)
+        (haml-forward-through-whitespace t)
+        (back-to-indentation)
+        (error "Nothing is nested beneath this line"))
+      (setq arg (- arg 1))))
+  (back-to-indentation))
+
+(defun haml-mark-sexp-but-not-next-line ()
+  "Marks the next Haml sexp, but puts the mark at the end of the
+last line of the sexp rather than the first non-whitespace
+character of the next line."
+  (mark-sexp)
+  (set-mark
+   (save-excursion
+     (goto-char (mark))
+     (forward-line -1)
+     (end-of-line)
+     (point))))
+
+;; Indentation and electric keys
+
+(defun haml-indent-p ()
+  "Returns true if the current line can have lines nested beneath it."
+  (loop for opener in haml-block-openers
+        if (looking-at opener) return t
+        finally return nil))
+
+(defun haml-compute-indentation ()
+  "Calculate the maximum sensible indentation for the current line."
+  (save-excursion
+    (beginning-of-line)
+    (if (bobp) 0
+      (haml-forward-through-whitespace t)
+      (+ (current-indentation)
+         (if (funcall haml-indent-function) haml-indent-offset
+           0)))))
+
+(defun haml-indent-region (start end)
+  "Indent each nonblank line in the region.
+This is done by indenting the first line based on
+`haml-compute-indentation' and preserving the relative
+indentation of the rest of the region.
+
+If this command is used multiple times in a row, it will cycle
+between possible indentations."
+  (save-excursion
+    (goto-char end)
+    (setq end (point-marker))
+    (goto-char start)
+    (let (this-line-column current-column
+          (next-line-column
+           (if (and (equal last-command this-command) (/= (current-indentation) 0))
+               (* (/ (- (current-indentation) 1) haml-indent-offset) haml-indent-offset)
+             (haml-compute-indentation))))
+      (while (< (point) end)
+        (setq this-line-column next-line-column
+              current-column (current-indentation))
+        ;; Delete whitespace chars at beginning of line
+        (delete-horizontal-space)
+        (unless (eolp)
+          (setq next-line-column (save-excursion
+                                   (loop do (forward-line 1)
+                                         while (and (not (eobp)) (looking-at "^[ \t]*$")))
+                                   (+ this-line-column
+                                      (- (current-indentation) current-column))))
+          ;; Don't indent an empty line
+          (unless (eolp) (indent-to this-line-column)))
+        (forward-line 1)))
+    (move-marker end nil)))
+
+(defun haml-indent-line ()
+  "Indent the current line.
+The first time this command is used, the line will be indented to the
+maximum sensible indentation.  Each immediately subsequent usage will
+back-dent the line by `haml-indent-offset' spaces.  On reaching column
+0, it will cycle back to the maximum sensible indentation."
+  (interactive "*")
+  (let ((ci (current-indentation))
+        (cc (current-column))
+        (need (haml-compute-indentation)))
+    (save-excursion
+      (beginning-of-line)
+      (delete-horizontal-space)
+      (if (and (equal last-command this-command) (/= ci 0))
+          (indent-to (* (/ (- ci 1) haml-indent-offset) haml-indent-offset))
+        (indent-to need)))
+      (if (< (current-column) (current-indentation))
+          (forward-to-indentation 0))))
+
+(defun haml-reindent-region-by (n)
+  "Add N spaces to the beginning of each line in the region.
+If N is negative, will remove the spaces instead.  Assumes all
+lines in the region have indentation >= that of the first line."
+  (let ((ci (current-indentation)))
+    (save-excursion
+      (replace-regexp (concat "^" (make-string ci ? ))
+                      (make-string (max 0 (+ ci n)) ? )
+                      nil (point) (mark)))))
+
+(defun haml-electric-backspace (arg)
+  "Delete characters or back-dent the current line.
+If invoked following only whitespace on a line, will back-dent
+the line and all nested lines to the immediately previous
+multiple of `haml-indent-offset' spaces.
+
+Set `haml-backspace-backdents-nesting' to nil to just back-dent
+the current line."
+  (interactive "*p")
+  (if (or (/= (current-indentation) (current-column))
+          (bolp)
+          (looking-at "^[ \t]+$"))
+      (backward-delete-char arg)
+    (let ((ci (current-column)))
+      (beginning-of-line)
+      (if haml-backspace-backdents-nesting
+          (haml-mark-sexp-but-not-next-line)
+        (set-mark (save-excursion (end-of-line) (point))))
+      (haml-reindent-region-by (* (- arg) haml-indent-offset))
+      (back-to-indentation)
+      (pop-mark))))
+
+(defun haml-kill-line-and-indent ()
+  "Kill the current line, and re-indent all lines nested beneath it."
+  (interactive)
+  (beginning-of-line)
+  (haml-mark-sexp-but-not-next-line)
+  (kill-line 1)
+  (haml-reindent-region-by (* -1 haml-indent-offset)))
+
+;; Setup/Activation
+
+(provide 'haml-mode)

data/extra/sass-mode.el

@@ -0,0 +1,89 @@
+;;; sass-mode.el -- Major mode for editing Sass files
+;;; Written by Nathan Weizenbaum
+
+;;; Because Sass's indentation schema is similar
+;;; to that of YAML and Python, many indentation-related
+;;; functions are similar to those in yaml-mode and python-mode.
+
+;;; To install, save this somewhere and add the following to your .emacs file:
+;;;
+;;; (add-to-list 'load-path "/path/to/sass-mode.el")
+;;; (require 'sass-mode nil 't)
+;;; (add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))
+;;;
+
+;;; Code:
+
+(require 'haml-mode)
+
+;; User definable variables
+
+(defgroup sass nil
+  "Support for the Sass template language."
+  :group 'languages
+  :prefix "sass-")
+
+(defcustom sass-mode-hook nil
+  "Hook run when entering Sass mode."
+  :type 'hook
+  :group 'sass)
+
+(defcustom sass-indent-offset 2
+  "Amount of offset per level of indentation."
+  :type 'integer
+  :group 'sass)
+
+(defvar sass-non-block-openers
+  '("^ *:[^ \t]+[ \t]+[^ \t]"
+    "^ *[^ \t:]+[ \t]*[=:][ \t]*[^ \t]")
+  "A list of regexps that match lines of Sass that couldn't have
+text nested beneath them.")
+
+;; Font lock
+
+(defconst sass-font-lock-keywords
+  '(("^ *\\(\t\\)"                            1 'haml-tab-face)
+    ("^@.*"                                   0 font-lock-constant-face)
+    ("\\(\'[^']*'\\)"                         1 font-lock-string-face append)
+    ("\\(\"[^\"]*\"\\)"                       1 font-lock-string-face append)
+    ("\\(#[0-9a-fA-F]\\{3\\}\\{1,2\\}\\>\\)"  1 font-lock-string-face append)
+    ("\\(:[A-Za-z-]+\\|[A-Za-z-]+:\\)"        0 font-lock-constant-face append)
+    ("![a-z0-9_-]+"                           0 font-lock-variable-name-face append)
+    ("^ *\\(/[/*].*\\)$"                      1 font-lock-comment-face append)
+    ("\\(?:^\\|,\\) *\\(#[a-z0-9_-]+\/?\\)"   1 font-lock-keyword-face)
+    ("\\(?:^\\|,\\) *\\(\\.[a-z0-9_-]+\/?\\)" 1 font-lock-type-face)
+    ("\\(?:^\\|,\\) *\\(&\\|[a-z0-9_]+\/?\\)" 1 font-lock-function-name-face)
+    ("\\([=]\\)"                              0 font-lock-preprocessor-face prepend)
+    ("\\(?:^\\|,\\) *\\(#[a-z0-9_]+\/?\\)"    (1 font-lock-keyword-face)
+     ("\\.[a-z0-9_-]+" nil nil                (0 font-lock-type-face)))
+    ("\\(?:^\\|,\\) *\\(\\.[a-z0-9_]+\/?\\)"  (1 font-lock-type-face)
+     ("\\.[a-z0-9_-]+" nil nil                (0 font-lock-type-face)))
+    ("\\(?:^\\|,\\) *\\(\\.[a-z0-9_]+\/?\\)"  (1 font-lock-type-face)
+     ("\\#[a-z0-9_-]+" nil nil                (0 font-lock-keyword-face)))
+    ("\\(?:^\\|,\\) *\\(&\\|[a-z0-9_]+\/?\\)" (1 font-lock-function-name-face)
+     ("\\.[a-z0-9_-]+" nil nil                (0 font-lock-type-face)))
+    ("\\(?:^\\|,\\) *\\(&\\|[a-z0-9_]+\/?\\)" (1 font-lock-function-name-face)
+     ("\\#[a-z0-9_-]+" nil nil                (0 font-lock-keyword-face)))))
+
+;; Constants
+
+;; Mode setup
+
+;;;###autoload
+(define-derived-mode sass-mode haml-mode "Sass"
+  "Major mode for editing Sass files."
+  (set (make-local-variable 'haml-indent-function) 'sass-indent-p)
+  (set (make-local-variable 'haml-indent-offset) sass-indent-offset)
+  (setq font-lock-defaults '(sass-font-lock-keywords nil t)))
+
+;; Indentation
+
+(defun sass-indent-p ()
+  "Returns true if the current line can have lines nested beneath it."
+  (loop for opener in sass-non-block-openers
+        unless (looking-at opener) return t
+        return nil))
+
+;; Setup/Activation
+
+(provide 'sass-mode)

data/lib/haml.rb

@@ -1,6 +1,8 @@
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 
+require 'haml/version'
+
 # = Haml (XHTML Abstraction Markup Language)
 #
 # Haml is a markup language
@@ -994,52 +996,11 @@ $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 #                           See also Whitespace Preservation, above.
 #
 module Haml
-  # Returns a hash representing the version of Haml.
-  # The :major, :minor, and :teeny keys have their respective numbers.
-  # The :string key contains a human-readable string representation of the version.
-  # If Haml is checked out from Git,
-  # the :rev key will have the revision hash.
-  def self.version
-    return @@version if defined?(@@version)
-
-    numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
-    @@version = {
-      :major => numbers[0],
-      :minor => numbers[1],
-      :teeny => numbers[2]
-    }
-    @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
-
-    if File.exists?(scope('REVISION'))
-      rev = File.read(scope('REVISION')).strip
-      rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
-    end
-
-    if rev.nil? && File.exists?(scope('.git/HEAD'))
-      rev = File.read(scope('.git/HEAD')).strip
-      if rev =~ /^ref: (.*)$/
-        rev = File.read(scope(".git/#{$1}")).strip
-      end
-    end
 
-    if rev
-      @@version[:rev] = rev
-      unless rev[0] == ?(
-        @@version[:string] << "."
-        @@version[:string] << rev[0...7]
-      end
-    end
-
-    @@version
-  end
-
-  # Returns the path of file relative to the Haml root.
-  def self.scope(file) # :nodoc:
-    File.join(File.dirname(__FILE__), '..', file)
-  end
+  extend Haml::Version
 
   # A string representing the version of Haml.
-  # A more fine-grained representation is generated by Haml.version.
+  # A more fine-grained representation is available from Haml.version.
   VERSION = version[:string] unless defined?(Haml::VERSION)
 
   # This method is called by init.rb,

data/lib/haml/exec.rb

@@ -42,8 +42,8 @@ module Haml
         # SyntaxErrors have weird line reporting
         # when there's trailing whitespace,
         # which there is for Haml documents.
-        return exception.message.scan(/:(\d+)/)[0] if exception.is_a?(::SyntaxError)
-        exception.backtrace[0].scan(/:(\d+)/)[0]
+        return exception.message.scan(/:(\d+)/).first.first if exception.is_a?(::SyntaxError)
+        exception.backtrace[0].scan(/:(\d+)/).first.first
       end
 
       private

data/lib/haml/filters.rb

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

data/lib/haml/helpers.rb

@@ -269,10 +269,9 @@ module Haml
           min_tabs = min_tabs > tabs ? tabs : min_tabs
         end
 
-        result = captured.map do |line|
+        captured.map do |line|
           line[min_tabs..-1]
-        end
-        result.to_s
+        end.join
       end
     end
 

data/lib/haml/html.rb

@@ -79,7 +79,7 @@ module Haml
     class ::Hpricot::Doc
       def to_haml(tabs = 0)
         output = ''
-        children.each { |child| output += child.to_haml(0) }
+        children.each { |child| output += child.to_haml(0) } if children
         output
       end
     end
@@ -148,13 +148,9 @@ module Haml
           output += haml_attributes if attributes.length > 0
         end
 
-        output += "\n"
-
-        self.children.each do |child|
-          output += child.to_haml(tabs + 1)
+        (self.children || []).inject(output + "\n") do |output, child|
+          output + child.to_haml(tabs + 1)
         end
-
-        output
       end
 
       private

data/lib/haml/util.rb

@@ -11,5 +11,13 @@ module Haml
     def has?(attr, klass, method)
       klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
     end
+
+    def each_char(str, &block)
+      if ruby1_8?
+        str.each_byte(&block)
+      else
+        str.each_char(&block)
+      end
+    end
   end
 end

data/lib/haml/version.rb

@@ -0,0 +1,47 @@
+module Haml
+  module Version
+    # Returns a hash representing the version of Haml.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # If Haml is checked out from Git,
+    # the :rev key will have the revision hash.
+    def version
+      return @@version if defined?(@@version)
+
+      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
+      @@version = {
+        :major => numbers[0],
+        :minor => numbers[1],
+        :teeny => numbers[2]
+      }
+      @@version[:string] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
+
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
+      end
+
+      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+
+      if rev
+        @@version[:rev] = rev
+        unless rev[0] == ?(
+          @@version[:string] << "."
+          @@version[:string] << rev[0...7]
+        end
+      end
+
+      @@version
+    end
+
+    # Returns the path of file relative to the Haml root.
+    def scope(file) # :nodoc:
+      File.expand_path File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+  end
+end

data/lib/sass.rb

@@ -1,6 +1,8 @@
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 
+require 'haml/version'
+
 # = Sass (Syntactically Awesome StyleSheets)
 #
 # Sass is a meta-language on top of CSS
@@ -857,7 +859,14 @@ $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 #                               This defaults to the working directory and, in Rails or Merb,
 #                               whatever <tt>:template_location</tt> is.
 #
-module Sass; end
+module Sass
+  extend Haml::Version
+
+  # A string representing the version of Sass.
+  # A more fine-grained representation is available from Sass.version.
+  VERSION = version[:string] unless defined?(Sass::VERSION)
+
+end
 
 require 'sass/engine'
 require 'sass/plugin' if defined?(Merb::Plugins)

data/lib/sass/constant.rb

@@ -40,6 +40,8 @@ module Sass
     SECOND_ORDER = [:plus, :minus]
 
     class << self
+      include Haml::Util
+
       def parse(value, constants, line)
         begin
           operationalize(parenthesize(tokenize(value)), constants).to_s
@@ -68,7 +70,7 @@ module Sass
           ''
         end
 
-        value.each_byte do |byte|
+        each_char(value) do |byte|
           unless escaped
             if byte == ESCAPE_CHAR
               escaped = true

data/test/haml/engine_test.rb

@@ -492,7 +492,7 @@ HAML
   def test_compile_error
     render("a\nb\n- fee)\nc")
   rescue Exception => e
-    assert_match(/^compile error\n\(test_compile_error\):3: syntax error/i, e.message)
+    assert_match(/\(test_compile_error\):3: syntax error/i, e.message)
   else
     assert(false,
            '"a\nb\n- fee)\nc" doesn\'t produce an exception!')

data/test/haml/helper_test.rb

@@ -9,7 +9,6 @@ class ActionView::Base
 end
 
 class HelperTest < Test::Unit::TestCase
-  include Haml::Helpers
   Post = Struct.new('Post', :body)
   
   def setup
@@ -28,14 +27,14 @@ class HelperTest < Test::Unit::TestCase
   end
 
   def test_flatten
-    assert_equal("FooBar", flatten("FooBar"))
+    assert_equal("FooBar", Haml::Helpers.flatten("FooBar"))
 
-    assert_equal("FooBar", flatten("Foo\rBar"))
+    assert_equal("FooBar", Haml::Helpers.flatten("Foo\rBar"))
 
-    assert_equal("Foo&#x000A;Bar", flatten("Foo\nBar"))
+    assert_equal("Foo&#x000A;Bar", Haml::Helpers.flatten("Foo\nBar"))
 
     assert_equal("Hello&#x000A;World!&#x000A;YOU ARE FLAT?&#x000A;OMGZ!",
-                 flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
+      Haml::Helpers.flatten("Hello\nWorld!\nYOU ARE \rFLAT?\n\rOMGZ!"))
   end
 
   def test_list_of_should_render_correctly

data/test/haml/results/filters.xhtml

@@ -52,11 +52,6 @@ This
 
 </ul>
 <div class='res'>178</div>
-<ul>
-<li>Foo</li>
-<li>Bar</li>
-<li>BAZ!</li>
-</ul>
 Text!
 Hello, World!
 How are you doing today?

data/test/haml/results/standard.xhtml

@@ -31,7 +31,7 @@
       <li>f</li>
     </ul>
     <div class='of_divs_with_underscore' id='combo'>with this text</div>
-    hello
+    foo
     <div class='footer'>
       <strong class='shout'>
         This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid. 

data/test/haml/results/whitespace_handling.xhtml

@@ -36,7 +36,10 @@
 </div>
 <div class='foo'>
   13
-  <textarea>&#x000A;a</textarea><textarea>&#x000A;b</textarea><textarea>&#x000A;c</textarea>
+    <textarea>
+  a
+  </textarea>
+<textarea>&#x000A;a</textarea>
 </div>
 <div id='whitespace_test'>
   <div class='text_area_test_area'>

data/test/haml/rhtml/standard.rhtml

@@ -23,7 +23,7 @@
           "multiline       " +
           "tags!           " +
           "A pipe (|) even!"  %>
-      <%= [1, 2, 3].collect { |n| "PipesIgnored|" } %>
+      <%= [1, 2, 3].collect { |n| "PipesIgnored|" }.join %>
       <%= [1, 2, 3].collect { |n|
           n.to_s
         }.join("|") %>
@@ -41,8 +41,8 @@
       <li><%= a %>
       <% end %>
     <div class='of_divs_with_underscore' id='combo'><%= @should_eval = "with this text" %></div>
-    <%= [ 104, 101, 108, 108, 111 ].map do |byte|
-      byte.chr
+    <%= "foo".each_line do |line|
+      nil
     end %>
     <div class='footer'>
       <strong class='shout'>

data/test/haml/template_test.rb

@@ -20,7 +20,18 @@ module Haml::Helpers
   end
 end
 
+class Egocentic
+  def method_missing(*args)
+    self
+  end
+end
+
 class DummyController
+  attr_accessor :logger
+  def initialize
+    @logger = Egocentic.new
+  end
+    
   def self.controller_path
     ''
   end
@@ -36,31 +47,36 @@ class TemplateTest < Test::Unit::TestCase
   TEMPLATES << 'partial_layout' unless ActionPack::VERSION::MAJOR < 2
 
   def setup
+    @base = create_base
+
+    # filters template uses :sass
+    Sass::Plugin.options.update(:line_comments => true, :style => :compact)
+  end
+
+  def create_base
     vars = { 'article' => Article.new, 'foo' => 'value one' }
     
     unless Haml::Util.has?(:instance_method, ActionView::Base, :finder)
-      @base = ActionView::Base.new(TEMPLATE_PATH, vars)
+      base = ActionView::Base.new(TEMPLATE_PATH, vars)
     else
       # Rails 2.1.0
-      @base = ActionView::Base.new([], vars)
-      @base.finder.append_view_path(TEMPLATE_PATH)
+      base = ActionView::Base.new([], vars)
+      base.finder.append_view_path(TEMPLATE_PATH)
     end
     
-    if Haml::Util.has?(:private_method, @base, :evaluate_assigns)
-      @base.send(:evaluate_assigns)
+    if Haml::Util.has?(:private_method, base, :evaluate_assigns)
+      base.send(:evaluate_assigns)
     else
       # Rails 2.2
-      @base.send(:_evaluate_assigns_and_ivars)
+      base.send(:_evaluate_assigns_and_ivars)
     end
 
     # This is used by form_for.
     # It's usually provided by ActionController::Base.
-    def @base.protect_against_forgery?; false; end
-    
-    # filters template uses :sass
-    Sass::Plugin.options.update(:line_comments => true, :style => :compact)
-    
-    @base.controller = DummyController.new
+    def base.protect_against_forgery?; false; end
+
+    base.controller = DummyController.new
+    base
   end
 
   def render(text)
@@ -148,7 +164,9 @@ class TemplateTest < Test::Unit::TestCase
   def test_haml_options
     Haml::Template.options = { :suppress_eval => true }
     assert_equal({ :suppress_eval => true }, Haml::Template.options)
+    old_base, @base = @base, create_base
     assert_renders_correctly("eval_suppressed")
+    @base = old_base
     Haml::Template.options = {}
   end
 

data/test/haml/templates/filters.haml

@@ -53,11 +53,6 @@
 
 .res= res
 
-:markdown
-  *  Foo
-  *  Bar
-  *  BAZ!
-
 = "Text!"
 
 - var = "Hello"

data/test/haml/templates/standard.haml

@@ -19,7 +19,7 @@
         "multiline       " + |      
         "tags!           " + |
         "A pipe (|) even!"   |
-      = [1, 2, 3].collect { |n| "PipesIgnored|" }
+      = [1, 2, 3].collect { |n| "PipesIgnored|" }.join
       = [1, 2, 3].collect { |n|     |
           n.to_s                    |
         }.join("|")                 |
@@ -36,7 +36,7 @@
       - ('a'..'f').each do |a|
         %li= a
     #combo.of_divs_with_underscore= @should_eval = "with this text"
-    = [ 104, 101, 108, 108, 111 ].map do |byte|
-      - byte.chr
+    = "foo".each_line do |line|
+      - nil
     .footer
       %strong.shout= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid. \nSo, I'm just making it *really* long. God, I hope this works"

data/test/haml/templates/standard_ugly.haml

@@ -19,7 +19,7 @@
         "multiline       " + |      
         "tags!           " + |
         "A pipe (|) even!"   |
-      = [1, 2, 3].collect { |n| "PipesIgnored|" }
+      = [1, 2, 3].collect { |n| "PipesIgnored|" }.join
       = [1, 2, 3].collect { |n|     |
           n.to_s                    |
         }.join("|")                 |
@@ -36,7 +36,7 @@
       - ('a'..'f').each do |a|
         %li= a
     #combo.of_divs_with_underscore= @should_eval = "with this text"
-    = [ 104, 101, 108, 108, 111 ].map do |byte|
-      - byte.chr
+    = "foo".each_line do |line|
+      - nil
     .footer
       %strong.shout= "This is a really long ruby quote. It should be loved and wrapped because its more than 50 characters. This value may change in the future and this test may look stupid. \nSo, I'm just making it *really* long. God, I hope this works"

data/test/haml/templates/whitespace_handling.haml

@@ -12,8 +12,8 @@
   %p~ "foo\nbar"
 .foo
   ~ 13
-  ~ ['a', 'b', 'c'].map do |a|
-    - "<textarea>\n#{a}\n</textarea>"
+  ~ "<textarea>\na\n</textarea>".each_line do |l|
+    - haml_concat l.strip
 #whitespace_test
   = test_partial "text_area", :value => "Oneline"
   = test_partial "text_area", :value => "Two\nlines"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml
 version: !ruby/object:Gem::Version 
-  version: 2.0.7
+  version: 2.0.8
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-22 00:00:00 -08:00
+date: 2009-02-13 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -61,6 +61,7 @@ files:
 - lib/haml/error.rb
 - lib/haml/template.rb
 - lib/haml/engine.rb
+- lib/haml/version.rb
 - lib/haml/template
 - lib/haml/template/patch.rb
 - lib/haml/template/plugin.rb
@@ -184,6 +185,8 @@ files:
 - test/haml/engine_test.rb
 - test/test_helper.rb
 - test/rails
+- extra/haml-mode.el
+- extra/sass-mode.el
 - Rakefile
 - init.rb
 - FAQ