haml 2.2.5 → 2.2.6

data/Rakefile

@@ -25,6 +25,7 @@ Rake::TestTask.new do |t|
   t.libs << 'lib'
   test_files = FileList['test/**/*_test.rb']
   test_files.exclude('test/rails/*')
+  test_files.exclude('test/haml/spec/*')
   t.test_files = test_files
   t.verbose = true
 end
@@ -69,11 +70,10 @@ task :install => [:package] do
   sh %{#{sudo} #{gem} install --no-ri pkg/haml-#{File.read('VERSION').strip}}
 end
 
-desc "Release a new Haml package to Rubyforge. Requires the NAME and VERSION flags."
-task :release => [:package] do
+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
-  raise "VERSION_NAME must not be 'Bleeding Edge'" if name == "Bleeding Edge"
   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}
@@ -81,6 +81,87 @@ task :release => [:package] do
   sh %{rubyforge add_file    haml haml "#{name} (v#{version})" pkg/haml-#{version}.zip}
 end
 
+# Releases haml-mode.el and sass-mode.el to ELPA.
+task :release_elpa do
+  require 'tlsmail'
+  require 'time'
+
+  version = File.read("VERSION").strip
+
+  haml_unchanged = mode_unchanged?(:haml, version)
+  sass_unchanged = mode_unchanged?(:sass, version)
+  next if haml_unchanged && sass_unchanged
+  raise "haml-mode.el and sass-mode.el are out of sync." if haml_unchanged ^ sass_unchanged
+
+  rev = File.read('.git/HEAD').strip
+  if rev =~ /^ref: (.*)$/
+    rev = File.read(".git/#{$1}").strip
+  end
+
+  from = `git config user.email`.strip
+  raise "Don't know how to send emails except via Gmail" unless from =~ /@gmail.com$/
+
+  to = "elpa@tromey.com"
+  Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
+  Net::SMTP.start('smtp.gmail.com', 587, 'gmail.com', from, read_password("GMail Password"), :login) do |smtp|
+    smtp.send_message(<<CONTENT, from, to)
+From: Nathan Weizenbaum <#{from}>
+To: #{to}
+Subject: Submitting haml-mode and sass-mode #{version}
+Date: #{Time.now.rfc2822}
+
+haml-mode and sass-mode #{version} are packaged and ready to be included in ELPA.
+They can be downloaded from:
+
+  http://github.com/nex3/haml/raw/#{rev}/extra/haml-mode.el
+  http://github.com/nex3/haml/raw/#{rev}/extra/sass-mode.el
+CONTENT
+  end
+end
+
+# Ensures that the version have been updated for a new release.
+task :check_release do
+  version = File.read("VERSION").strip
+  raise "There have been changes since current version (#{version})" if changed_since?(version)
+  raise "VERSION_NAME must not be 'Bleeding Edge'" if File.read("VERSION_NAME") == "Bleeding Edge"
+end
+
+# Reads a password from the command line.
+#
+# @param name [String] The prompt to use to read the password
+def read_password(prompt)
+  require 'readline'
+  system "stty -echo"
+  Readline.readline("#{prompt}: ").strip
+ensure
+  system "stty echo"
+  puts
+end
+
+# Returns whether or not the repository, or specific files,
+# has/have changed since a given revision.
+#
+# @param rev [String] The revision to check against
+# @param files [Array<String>] The files to check.
+#   If this is empty, checks the entire repository
+def changed_since?(rev, *files)
+  IO.popen("git diff --exit-code #{rev} #{files.join(' ')}") {}
+  return !$?.success?
+end
+
+# Returns whether or not the given Emacs mode file (haml or sass)
+# has changed since the given version.
+#
+# @param mode [String, Symbol] The name of the mode
+# @param version [String] The version number
+def mode_unchanged?(mode, version)
+  mode_version = File.read("extra/#{mode}-mode.el").scan(/^;; Version: (.*)$/).first.first
+  return false if mode_version == version
+  return true unless changed_since?(mode_version, "extra/#{mode}-mode.el")
+  raise "#{mode}-mode.el version is #{version.inspect}, but it has changed as of #{version.inspect}"
+  return false
+end
+
 task :release_edge do
   ensure_git_cleanup do
     puts "#{'=' * 50} Running rake release_edge"

data/VERSION

@@ -1 +1 @@
-2.2.5
+2.2.6

data/extra/haml-mode.el

@@ -4,8 +4,10 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 1.0
-;; Keywords: markup, language
+;; Version: 2.2.6
+;; Created: 2007-03-08
+;; By: Nathan Weizenbaum
+;; Keywords: markup, language, html
 
 ;;; Commentary:
 
@@ -41,9 +43,9 @@
   :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."
+  "Non-nil to have `haml-electric-backspace' re-indent blocks of code.
+This means that all code nested beneath the backspaced line is
+re-indented along with the line itself."
   :type 'boolean
   :group 'haml)
 
@@ -55,7 +57,8 @@ line itself."
   :group 'haml)
 
 (defvar haml-indent-function 'haml-indent-p
-  "This function should look at the current line and return t
+  "A function for checking if nesting is allowed.
+This function should look at the current line and return t
 if the next line could be nested within this line.
 
 The function can also return a positive integer to indicate
@@ -75,12 +78,15 @@ a specific level to which the current line could be indented.")
     "^ */\\(\\[.*\\]\\)?[ \t]*$"
     "^ *-#"
     "^ *:")
-  "A list of regexps that match lines of Haml that could have
-text nested beneath them.")
+  "A list of regexps that match lines of Haml that open blocks.
+That is, a Haml line that can have text nested beneath it should
+be matched by a regexp in this list.")
 
 ;; Font lock
 
 (defun haml-nested-regexp (re)
+  "Create a regexp to match a block starting with RE.
+The line containing RE is matched, as well as all lines indented beneath it."
   (concat "^\\( *\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?"))
 
 (defconst haml-font-lock-keywords
@@ -110,12 +116,14 @@ text nested beneath them.")
         (font-lock-fontify-region (- beg 1) end)))))
 
 (defun haml-highlight-ruby-script (limit)
-  "Highlight a Ruby script expression (-, =, or ~)."
+  "Highlight a Ruby script expression (-, =, or ~).
+LIMIT works as it does in `re-search-forward'."
   (when (re-search-forward "^ *\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t)
     (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2))))
 
 (defun haml-highlight-ruby-tag (limit)
   "Highlight Ruby code within a Haml tag.
+LIMIT works as it does in `re-search-forward'.
 
 This highlights the tag attributes and object refs of the tag,
 as well as the script expression (-, =, or ~) following the tag.
@@ -189,13 +197,15 @@ For example, this will highlight all of the following:
     t))
 
 (defun haml-move (re)
-  "Try matching and moving to the end of a regular expression."
+  "Try matching and moving to the end of regular expression RE.
+Returns non-nil if the expression was sucessfully matched."
   (when (looking-at re)
     (goto-char (match-end 0))
     t))
 
 (defun haml-highlight-interpolation (limit)
-  "Highlight Ruby interpolation (#{foo})."
+  "Highlight Ruby interpolation (#{foo}).
+LIMIT works as it does in `re-search-forward'."
   (when (re-search-forward "\\(#{\\)" limit t)
     (save-match-data
       (forward-char -1)
@@ -209,8 +219,8 @@ For example, this will highlight all of the following:
       t)))
 
 (defun haml-limited-forward-sexp (limit &optional arg)
-  "Move forward using `forward-sexp' or to limit,
-whichever comes first."
+  "Move forward using `forward-sexp' or to LIMIT, whichever comes first.
+With ARG, do it that many times."
   (let (forward-sexp-function)
     (condition-case err
         (save-restriction
@@ -278,7 +288,7 @@ whichever comes first."
     (modify-syntax-entry ?: "." table)
     (modify-syntax-entry ?_ "w" table)
     table)
-  "Syntax table in use in haml-mode buffers.")
+  "Syntax table in use in `haml-mode' buffers.")
 
 (defvar haml-mode-map
   (let ((map (make-sparse-keymap)))
@@ -337,7 +347,8 @@ whichever comes first."
     (haml-reindent-region-by (- haml-indent-offset))))
 
 (defun haml-replace-region (start end)
-  "Replaces the current block of Haml code with the HTML equivalent."
+  "Replace the current block of Haml code with the HTML equivalent.
+Called from a program, START and END specify the region to indent."
   (interactive "r")
   (save-excursion
     (goto-char end)
@@ -349,9 +360,10 @@ whichever comes first."
     (shell-command-on-region start end "haml" "haml-output" t)))
 
 (defun haml-output-region (start end)
-  "Displays the HTML output for the current block of Haml code."
+  "Displays the HTML output for the current block of Haml code.
+Called from a program, START and END specify the region to indent."
   (interactive "r")
-  (kill-new (buffer-substring start end)) 
+  (kill-new (buffer-substring start end))
   (with-temp-buffer
     (yank)
     (haml-indent-region (point-min) (point-max))
@@ -365,10 +377,11 @@ whichever comes first."
 ;; Navigation
 
 (defun haml-forward-through-whitespace (&optional backward)
-  "Move the point forward at least one line, until it reaches
+  "Move the point forward through any whitespace.
+The point will move 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."
+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)
@@ -376,9 +389,7 @@ If `backward' is non-nil, move the point backward instead."
                      (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."
+  "Return non-nil if the point is before any text on the line."
   (let ((opoint (point)))
     (save-excursion
       (back-to-indentation)
@@ -386,7 +397,7 @@ character."
 
 (defun haml-forward-sexp (&optional arg)
   "Move forward across one nested expression.
-With `arg', do it that many times.  Negative arg -N means move
+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
@@ -443,14 +454,14 @@ With ARG, do this that many times."
   (back-to-indentation))
 
 (defun haml-mark-sexp ()
-  "Marks the next Haml block."
+  "Mark the next Haml block."
   (let ((forward-sexp-function 'haml-forward-sexp))
     (mark-sexp)))
 
 (defun haml-mark-sexp-but-not-next-line ()
-  "Marks the next Haml block, 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 the next Haml block, but not the next line.
+Put the mark at the end of the last line of the sexp rather than
+the first non-whitespace character of the next line."
   (haml-mark-sexp)
   (set-mark
    (save-excursion
@@ -507,7 +518,7 @@ beginning the hash."
     (when (eq (char-before) ?,) (return-from haml-unclosed-attr-hash-p t))
     (re-search-backward "(\\|^")
     (haml-move "(")
-    (haml-parse-new-attr-hash)))  
+    (haml-parse-new-attr-hash)))
 
 (defun* haml-parse-new-attr-hash (&optional (fn (lambda (type beg end) ())))
   "Parse a new-style attribute hash on this line, and returns
@@ -549,7 +560,8 @@ and BEG and END delimit that text in the buffer."
   "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.
+indentation of the rest of the region.  START and END specify the
+region to indent.
 
 If this command is used multiple times in a row, it will cycle
 between possible indentations."
@@ -610,7 +622,8 @@ lines in the region have indentation >= that of the first line."
   "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.
+multiple of `haml-indent-offset' spaces.  With ARG, do it that
+many times.
 
 Set `haml-backspace-backdents-nesting' to nil to just back-dent
 the current line."

data/extra/sass-mode.el

@@ -4,8 +4,10 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 1.0
-;; Keywords: markup, language
+;; Version: 2.2.6
+;; Created: 2007-03-15
+;; By: Nathan Weizenbaum
+;; Keywords: markup, language, css
 
 ;;; Commentary:
 
@@ -42,8 +44,9 @@
 (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.")
+  "A list of regexps that match lines of Sass that don't open blocks.
+That is, a Sass line that can't have text nested beneath it
+should be matched by a regexp in this list.")
 
 ;; Font lock
 
@@ -93,18 +96,18 @@ text nested beneath them.")
     ("\\(\\w+\\)\s*="  1 font-lock-variable-name-face sass-highlight-script-after-match)
     ("\\(:\\w+\\)\s*=" 1 font-lock-variable-name-face sass-highlight-script-after-match)
     (".*"      sass-highlight-selector))
-  "A list of full-line Sass syntax to highlight,
-used by `sass-highlight-line'.
+  "A list of full-line Sass syntax to highlight, used by `sass-highlight-line'.
 
 Each item is either of the form (REGEXP SUBEXP FACE), (REGEXP FN),
-or (REGEXP SUBEXP FACE FN). Each REGEXP is run successively on the
+or (REGEXP SUBEXP FACE FN).  Each REGEXP is run successively on the
 beginning of non-whitespace on the current line until one matches.
 If it has SUBEXP and FACE, then SUBEXP is highlighted using FACE.
 If it has FN, FN is run.")
 
 (defun sass-highlight-line (limit)
-  "Highlight a single line using some Sass single-line syntax,
-taken from `sass-line-keywords'."
+  "Highlight a single line using some Sass single-line syntax.
+This syntax is taken from `sass-line-keywords'.
+LIMIT is the limit of the search."
   (save-match-data
     (when (re-search-forward "^ *\\(.+\\)$" limit t)
       (goto-char (match-beginning 1))
@@ -121,8 +124,7 @@ taken from `sass-line-keywords'."
             (return t)))))))
 
 (defun sass-highlight-selector ()
-  "Highlight a CSS selector starting at `point'
-and ending at `end-of-line'."
+  "Highlight a CSS selector starting at `point' and ending at `end-of-line'."
   (let ((font-lock-keywords sass-selector-font-lock-keywords)
         font-lock-multiline)
     (font-lock-fontify-region
@@ -139,10 +141,12 @@ and ending at `end-of-line'."
         (font-lock-fontify-region beg end)))))
 
 (defun sass-highlight-script-after-match ()
+  "Highlight a section of SassScript after the last match."
   (end-of-line)
   (sass-highlight-script (match-end 0) (point)))
 
 (defun sass-highlight-directive ()
+  "Highlight a Sass directive."
   (goto-char (match-end 0))
   (block nil
     (case (intern (match-string 1))
@@ -188,7 +192,7 @@ and ending at `end-of-line'."
 ;; Indentation
 
 (defun sass-indent-p ()
-  "Returns t if the current line can have lines nested beneath it."
+  "Return non-nil 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))

data/lib/haml/exec.rb

@@ -73,7 +73,7 @@ module Haml
         end
 
         opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml #{::Haml.version[:string]}")
+          puts("Haml/Sass #{::Haml.version[:string]}")
           exit
         end
       end
@@ -364,7 +364,8 @@ END
           require 'haml/html'
         rescue LoadError => err
           dep = err.message.scan(/^no such file to load -- (.*)/)[0]
-          puts "Required dependency #{dep} not found!"
+          raise err if @options[:trace] || dep.nil? || dep.empty?
+          $stderr.puts "Required dependency #{dep} not found!\n  Use --trace for backtrace."
           exit 1
         end
       end

data/lib/haml/precompiler.rb

@@ -465,8 +465,8 @@ END
         return unless key = scanner.scan(LITERAL_VALUE_REGEX)
         return unless scanner.scan(/\s*=>\s*/)
         return unless value = scanner.scan(LITERAL_VALUE_REGEX)
+        return unless scanner.scan(/\s*(?:,|$)\s*/)
         attributes[eval(key).to_s] = eval(value).to_s
-        scanner.scan(/[,\s]*/)
       end
       text.count("\n").times { newline }
       attributes

data/lib/haml/util.rb

@@ -15,7 +15,7 @@ module Haml
     # @param file [String] The filename relative to the Haml root
     # @return [String] The filename relative to the the working directory
     def scope(file)
-      File.join(File.dirname(File.dirname(File.dirname(__FILE__))), file)
+      File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
     end
 
     # Converts an array of `[key, value]` pairs to a hash.

data/test/haml/engine_test.rb

@@ -54,6 +54,12 @@ class EngineTest < Test::Unit::TestCase
     "%p(foo 'bar')" => "Invalid attribute list: \"(foo 'bar')\".",
     "%p(foo 'bar'\nbaz='bang')" => ["Invalid attribute list: \"(foo 'bar'\".", 1],
     "%p(foo='bar'\nbaz 'bang'\nbip='bop')" => ["Invalid attribute list: \"(foo='bar' baz 'bang'\".", 2],
+    "%p{:foo => 'bar' :bar => 'baz'}" => :compile,
+    "%p{:foo => }" => :compile,
+    "%p{=> 'bar'}" => :compile,
+    "%p{:foo => 'bar}" => :compile,
+    "%p{'foo => 'bar'}" => :compile,
+    "%p{:foo => 'bar\"}" => :compile,
 
     # Regression tests
     "- raise 'foo'\n\n\n\nbar" => ["foo", 1],
@@ -727,18 +733,22 @@ HAML
     assert_equal("<a b='2' />\nc\n", render("%a{'b' => 1 + 1}/\n= 'c'\n"))
   end
 
-  def test_exceptions
-    EXCEPTION_MAP.each do |key, value|
+  EXCEPTION_MAP.each do |key, value|
+    define_method("test_exception (#{key.inspect})") do
       begin
-        render(key, :filename => "(exception test for #{key.inspect})")
+        render(key, :filename => __FILE__)
       rescue Exception => err
         value = [value] unless value.is_a?(Array)
         expected_message, line_no = value
         line_no ||= key.split("\n").length
-        line_reported = err.backtrace[0].gsub(/\(.+\):/, '').to_i
 
-        assert_equal(expected_message, err.message, "Line: #{key}")
-        assert_equal(line_no, line_reported, "Line: #{key}")
+        if expected_message == :compile
+          assert_match(/^compile error\n/, err.message, "Line: #{key}")
+        else
+          assert_equal(expected_message, err.message, "Line: #{key}")
+        end
+
+        assert_match(/^#{Regexp.escape(__FILE__)}:#{line_no}/, err.backtrace[0], "Line: #{key}")
       else
         assert(false, "Exception not raised for\n#{key}")
       end

data/test/haml/spec/README.md

@@ -2,8 +2,8 @@
 
 Haml Spec provides a basic suite of tests for Haml interpreters.
 
-It is intented for developers who are creating or maintaining an
-implementation of the [Haml](http://haml-lang.com) markup language.
+It is intented for developers who are creating or maintaining an implementation
+of the [Haml](http://haml-lang.com) markup language.
 
 At the moment, there are test runners for the [original Haml](http://github.com/nex3/haml)
 in Ruby, and for [Lua Haml](http://github.com/norman/lua-haml). Support for
@@ -12,19 +12,35 @@ are interested in using it.
 
 ## The Tests ##
 
-The tests are kept in JSON format for portability across languages.
-Each test is a simple key/value pair of input and expected output.
-The test suite only provides tests for features which are portable,
-therefore no tests for script are provided, nor for external filters
-such as :markdown or :textile.
+The tests are kept in JSON format for portability across languages.  Each test
+is a JSON object with expected input, output, local variables and configuration
+parameters (see below).  The test suite only provides tests for features which
+are portable, therefore no tests for script are provided, nor for external
+filters such as :markdown or :textile.
+
+The one major exception to this are the tests for interpolation, which you may
+need to modify with a regular expression to run under PHP or Perl, which
+require a symbol before variable names. These tests are included despite being
+less than 100% portable because interpolation is an important part of Haml and
+can be tricky to implement.
 
 ## Running the Tests ##
 
 ### Ruby ###
 
-The Ruby test uses RSpec, so just install the gem and run `spec ruby_haml_spec.rb`.
-I have only tested it against Ruby 1.9; if you want to run it on an older Ruby
-you'll need to install the "json" gem.
+In order to make it as easy as possible for non-Ruby programmers to run the
+Ruby Haml tests, the Ruby test runner uses test/unit, rather than something
+fancier like Rspec.  To run them you probably only need to install `haml`, and
+possibly `ruby` if your platform doesn't come with it by default. If you're
+using Ruby 1.8.x, you'll also need to install `json`:
+
+    sudo gem install haml
+    # for Ruby 1.8.x; check using "ruby --version" if unsure
+    sudo gem install json
+
+Then, running the Ruby test suite is easy:
+
+    ruby ruby_haml_test.rb
 
 ### Lua ###
 
@@ -35,19 +51,47 @@ run `tsc lua_haml_spec.lua`.
 
 ## Contributing ##
 
-You can access the Git repo at:
+### Getting it ###
 
-    http://github.com/norman/haml-spec
+You can access the [Git repository](http://github.com/norman/haml-spec) at:
 
-As long as any test you add run against Ruby's Haml and are not redundant,
-I'll be very happy to add them.
+    git://github.com/norman/haml-spec.git
 
-## License ##
+Patches are *very* welcome, as are test runners for your Haml implementation.
 
-This project is released under the [WTFPL](http://sam.zoy.org/wtfpl/)
-in order to be as usable as possible in any project, commercial or free.
+As long as any test you add run against Ruby Haml and are not redundant, I'll
+be very happy to add them.
+
+### Test JSON format ###
+
+    "test name" : {
+      "haml" : "haml input",
+      "html" : "expected html output",
+      "result" : "expected test result",
+      "locals" : "local vars",
+      "config" : "config params"
+    }
+
+* test name: This should be a *very* brief description of what's being tested. It can
+  be used by the test runners to name test methods, or to exclude certain tests from being
+  run.
+* haml: The Haml code to be evaluated. Always required.
+* html: The HTML output that should be generated. Required unless "result" is "error".
+* result: Can be "pass" or "error". If it's absent, then "pass" is assumed. If it's "error",
+  then the goal of the test is to make sure that malformed Haml code generates an error.
+* locals: An object containing local variables needed for the test.
+* config: An object containing configuration parameters used to run the test.
+  The configuration parameters should be usable directly by Ruby's Haml with no
+  modification.  If your implementation uses config parameters with different
+  names, you may need to process them to make them match your implementation.
+  If your implementation has options that do not exist in Ruby's Haml, then you
+  should add tests for this in your implementation's test rather than here.
+
+## License ##
 
+  This project is released under the [WTFPL](http://sam.zoy.org/wtfpl/) in order
+  to be as usable as possible in any project, commercial or free.
 
 ## Author ##
 
-[Norman Clarke](mailto:norman@njclarke.com)
+  [Norman Clarke](mailto:norman@njclarke.com)

data/test/haml/spec/lua_haml_spec.lua

@@ -11,27 +11,20 @@ local function get_tests(filename)
   end
 end
 
-local fh = assert(io.open(get_tests("tests.json")))
+local fh = assert(io.open(get_tests("tests-new.json")))
 local input = fh:read '*a'
 fh:close()
 
 local contexts = json.decode(input)
 
-local locals = {
-  var   = "value",
-  first = "a",
-  last  = "z"
-}
-
-describe("The LuaHaml Renderer", function()
-  for context, expectations in pairs(contexts) do
-    describe("When handling " .. context, function()
-      for input, expectation in pairs(expectations) do
-        it(string.format("should render '%s' as '%s'", string.gsub(input, "\n", "\\n"),
-            string.gsub(expectation, "\n", "\\n")), function()
-            assert_equal(haml.render(input, {}, locals), expectation)
+describe("LuaHaml", function()
+   for context, expectations in pairs(contexts) do
+     describe("When handling " .. context, function()
+      for name, exp in pairs(expectations) do
+        it(string.format("should correctly render %s", name), function()
+            assert_equal(haml.render(exp.haml, exp.config or {}, exp.locals or {}), exp.html)
         end)
       end
-    end)
-  end
+     end)
+   end
 end)

data/test/haml/spec/ruby_haml_test.rb

@@ -0,0 +1,19 @@
+require "test/unit"
+require "json"
+require "haml"
+
+class HamlTest < Test::Unit::TestCase
+  contexts = JSON.parse(File.read(File.dirname(__FILE__) + "/tests.json"))
+  contexts.each do |context|
+    context[1].each do |name, test|
+      class_eval(<<-EOTEST)
+        def test_#{name.gsub(/\s+|[^a-zA-Z0-9_]/, "_")}
+          locals = Hash[*(#{test}["locals"] || {}).collect {|k, v| [k.to_sym, v] }.flatten]
+          options = Hash[*(#{test}["config"] || {}).collect {|k, v| [k.to_sym, v.to_sym] }.flatten]
+          engine = Haml::Engine.new(#{test}["haml"], options)
+          assert_equal(engine.render(Object.new, locals).chomp, #{test}["html"])
+        end
+      EOTEST
+    end
+  end
+end

data/test/haml/spec/tests.json

@@ -1,105 +1,488 @@
 {
-  "headers": {
-    "!!! XML":      "<?xml version='1.0' encoding='utf-8' ?>",
-    "!!!":          "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">",
-    "!!! 1.1":      "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">",
-    "!!! frameset": "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">",
-    "!!! mobile":   "<!DOCTYPE html PUBLIC \"-//WAPFORUM//DTD XHTML Mobile 1.2//EN\" \"http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd\">",
-    "!!! basic":    "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML Basic 1.1//EN\" \"http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd\">"
+  "headers" : {
+
+    "an XHTML XML prolog" : {
+      "haml" : "!!! XML",
+      "html" : "<?xml version='1.0' encoding='utf-8' ?>"
+    },
+
+    "an XHTML default (transitional) doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"
+    },
+
+    "an XHTML 1.1 doctype" : {
+      "haml" : "!!! 1.1",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">"
+    },
+
+    "an XHTML 1.2 mobile doctype" : {
+      "haml" : "!!! mobile",
+      "html" : "<!DOCTYPE html PUBLIC \"-//WAPFORUM//DTD XHTML Mobile 1.2//EN\" \"http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd\">"
+    },
+
+    "an XHTML 1.1 basic doctype" : {
+      "haml" : "!!! basic",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML Basic 1.1//EN\" \"http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd\">"
+    },
+
+    "an XHTML 1.0 frameset doctype" : {
+      "haml" : "!!! frameset",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Frameset//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd\">"
+    },
+
+    "an HTML 5 XML prolog (silent)" : {
+      "haml" : "!!! XML",
+      "html" : "",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "an HTML 5 doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html>",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "an HTML 4 XML prolog (silent)" : {
+      "haml" : "!!! XML",
+      "html" : "",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 default (transitional) doctype" : {
+      "haml" : "!!!",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 frameset doctype" : {
+      "haml" : "!!! frameset",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" \"http://www.w3.org/TR/html4/frameset.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "an HTML 4 strict doctype" : {
+      "haml" : "!!! strict",
+      "html" : "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">",
+      "config" : {
+        "format" : "html4"
+      }
+    }
+
   },
 
   "basic Haml tags and CSS": {
-    "%p":               "<p></p>",
-    "%meta":            "<meta />",
-    "#id1":             "<div id='id1'></div>",
-    ".class1":          "<div class='class1'></div>",
-    "%p.class1":        "<p class='class1'></p>",
-    "%p.class1.class2": "<p class='class1 class2'></p>",
-    "%p#id1":           "<p id='id1'></p>",
-    "%p#id1#id2":       "<p id='id2'></p>",
-    "%p.class1#id1":    "<p class='class1' id='id1'></p>",
-    "%p#id1.class1":    "<p class='class1' id='id1'></p>"
+
+    "a simple Haml tag" : {
+      "haml" : "%p",
+      "html" : "<p></p>"
+    },
+
+    "a self-closing tag (XHTML)" : {
+      "haml" : "%meta",
+      "html" : "<meta />"
+    },
+
+    "a self-closing tag (HTML4)" : {
+      "haml" : "%meta",
+      "html" : "<meta>",
+      "config" : {
+        "format" : "html4"
+      }
+    },
+
+    "a self-closing tag (HTML5)" : {
+      "haml" : "%meta",
+      "html" : "<meta>",
+      "config" : {
+        "format" : "html5"
+      }
+    },
+
+    "a tag with a CSS class" : {
+      "haml" : "%p.class1",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with multiple CSS classes" : {
+      "haml" : "%p.class1.class2",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with a CSS id" : {
+      "haml" : "%p#id1",
+      "html" : "<p id='id1'></p>"
+    },
+
+    "a tag with multiple CSS id's" : {
+      "haml" : "%p#id1#id2",
+      "html" : "<p id='id2'></p>"
+    },
+
+    "a tag with a class followed by an id" : {
+      "haml" : "%p.class1#id1",
+      "html" : "<p class='class1' id='id1'></p>"
+    },
+
+    "a tag with an id followed by a class" : {
+      "haml" : "%p#id1.class1",
+      "html" : "<p class='class1' id='id1'></p>"
+    },
+
+    "an implicit div with a CSS id" : {
+      "haml" : "#id1",
+      "html" : "<div id='id1'></div>"
+    },
+
+    "an implicit div with a CSS class" : {
+      "haml" : ".class1",
+      "html" : "<div class='class1'></div>"
+    }
+
   },
 
-  "tags with unusual HTML characters": {
-    "%ns:tag":     "<ns:tag></ns:tag>",
-    "%snake_case": "<snake_case></snake_case>",
-    "%dashed-tag": "<dashed-tag></dashed-tag>",
-    "%camelCase":  "<camelCase></camelCase>",
-    "%PascalCase": "<PascalCase></PascalCase>"
+  "tags with unusual HTML characters" : {
+
+    "a tag with colons" : {
+      "haml" : "%ns:tag",
+      "html" : "<ns:tag></ns:tag>"
+    },
+
+    "a tag with underscores" : {
+      "haml" : "%snake_case",
+      "html" : "<snake_case></snake_case>"
+    },
+
+    "a tag with dashes" : {
+      "haml" : "%dashed-tag",
+      "html" : "<dashed-tag></dashed-tag>"
+    },
+
+    "a tag with camelCase" : {
+      "haml" : "%camelCase",
+      "html" : "<camelCase></camelCase>"
+    },
+
+    "a tag with PascalCase" : {
+      "haml" : "%PascalCase",
+      "html" : "<PascalCase></PascalCase>"
+    }
   },
 
-  "tags with unusual CSS identifiers": {
-    ".123": "<div class='123'></div>",
-    ".__":  "<div class='__'></div>",
-    ".--":  "<div class='--'></div>"
+  "tags with unusual CSS identifiers" : {
+
+    "an all-numeric class" : {
+      "haml" : ".123",
+      "html" : "<div class='123'></div>"
+    },
+
+    "a class with underscores" : {
+      "haml" : ".__",
+      "html" : "<div class='__'></div>"
+    },
+
+    "a class with dashes" : {
+      "haml" : ".--",
+      "html" : "<div class='--'></div>"
+    }
+
   },
 
-  "tags with inline content": {
-    "%p hello":        "<p>hello</p>",
-    "%p.class1 hello": "<p class='class1'>hello</p>"
+  "tags with inline content" : {
+
+    "a simple tag" : {
+      "haml" : "%p hello",
+      "html" : "<p>hello</p>"
+    },
+
+    "a tag with CSS" : {
+      "haml" : "%p.class1 hello",
+      "html" : "<p class='class1'>hello</p>"
+    }
+
   },
 
-  "tags with nested content": {
-    "%p\n  hello": "<p>\n  hello\n</p>"
+  "tags with nested content" : {
+
+    "a simple tag" : {
+      "haml" : "%p\n  hello",
+      "html" : "<p>\n  hello\n</p>"
+    },
+
+    "a tag with CSS" : {
+      "haml" : "%p.class1\n  hello",
+      "html" : "<p class='class1'>\n  hello\n</p>"
+    }
+
   },
 
-  "tags with portable-style attributes": {
-    "%p(a='b')":                 "<p a='b'></p>",
-    "%p(a='b' c='d')":           "<p a='b' c='d'></p>",
-    "%p(a='b'\n  c='d')":        "<p a='b' c='d'></p>",
-    "%p(class='class1')":        "<p class='class1'></p>",
-    "%p.class2(class='class1')": "<p class='class1 class2'></p>",
-    "%p#id(id='1')":             "<p id='id_1'></p>",
-    ".hello(class=var)":         "<div class='hello value'></div>",
-    ".b(class=last)":            "<div class='b z'></div>",
-    ".b(class=first)":           "<div class='a b'></div>"
+  "tags with HTML-style attributes": {
+
+    "one attribute" : {
+      "haml" : "%p(a='b')",
+      "html" : "<p a='b'></p>"
+    },
+
+    "multiple attributes" : {
+      "haml" : "%p(a='b' c='d')",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "attributes separated with newlines" : {
+      "haml" : "%p(a='b'\n  c='d')",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "an interpolated attribute" : {
+      "haml" : "%p(a=\"#{var}\")",
+      "html" : "<p a='value'></p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "'class' as an attribute" : {
+      "haml" : "%p(class='class1')",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with a CSS class and 'class' as an attribute" : {
+      "haml" : "%p.class2(class='class1')",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with 'id' as an attribute" : {
+      "haml" : "%p(id='1')",
+      "html" : "<p id='1'></p>"
+    },
+
+    "a tag with a CSS id and 'id' as an attribute" : {
+      "haml" : "%p#id(id='1')",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a variable attribute" : {
+      "haml" : "%p(class=var)",
+      "html" : "<p class='hello'></p>",
+      "locals" : {
+        "var" : "hello"
+      }
+    },
+
+    "a tag with a CSS class and 'class' as a variable attribute" : {
+      "haml" : ".hello(class=var)",
+      "html" : "<div class='hello world'></div>",
+      "locals" : {
+        "var" : "world"
+      }
+    },
+
+    "a tag multiple CSS classes (sorted correctly)" : {
+      "haml" : ".z(class=var)",
+      "html" : "<div class='a z'></div>",
+      "locals" : {
+        "var" : "a"
+      }
+    }
+
   },
 
   "tags with Ruby-style attributes": {
-    "%p{:a => 'b'}":                  "<p a='b'></p>",
-    "%p{ :a => 'b' }":                "<p a='b'></p>",
-    "%p{ :a => 'b', 'c' => 'd' }":    "<p a='b' c='d'></p>",
-    "%p{ :a => 'b',\n  'c' => 'd' }": "<p a='b' c='d'></p>",
-    "%p{ :a => var}":                 "<p a='value'></p>",
-    "%p#id{ :id => '1' }":            "<p id='id_1'></p>",
-    "%p#id{ :id => 1 }":              "<p id='id_1'></p>",
-    "%p{ :a => \"#{var}\"}":          "<p a='value'></p>",
-    ".b{ :class => last }":           "<div class='b z'></div>",
-    ".b{ :class => first }":          "<div class='a b'></div>"
-  },
 
-  "inline comments": {
-    "-# hello\n%p": "<p></p>"
+    "one attribute" : {
+      "haml" : "%p{:a => 'b'}",
+      "html" : "<p a='b'></p>"
+    },
+
+    "attributes hash with whitespace" : {
+      "haml" : "%p{  :a  =>  'b'  }",
+      "html" : "<p a='b'></p>"
+    },
+
+    "an interpolated attribute" : {
+      "haml" : "%p{:a =>\"#{var}\"}",
+      "html" : "<p a='value'></p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "multiple attributes" : {
+      "haml" : "%p{ :a => 'b', 'c' => 'd' }",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "attributes separated with newlines" : {
+      "haml" : "%p{ :a => 'b',\n  'c' => 'd' }",
+      "html" : "<p a='b' c='d'></p>"
+    },
+
+    "'class' as an attribute" : {
+      "haml" : "%p{:class => 'class1'}",
+      "html" : "<p class='class1'></p>"
+    },
+
+    "a tag with a CSS class and 'class' as an attribute" : {
+      "haml" : "%p.class2{:class => 'class1'}",
+      "html" : "<p class='class1 class2'></p>"
+    },
+
+    "a tag with 'id' as an attribute" : {
+      "haml" : "%p{:id => '1'}",
+      "html" : "<p id='1'></p>"
+    },
+
+    "a tag with a CSS id and 'id' as an attribute" : {
+      "haml" : "%p#id{:id => '1'}",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a CSS id and a numeric 'id' as an attribute" : {
+      "haml" : "%p#id{:id => 1}",
+      "html" : "<p id='id_1'></p>"
+    },
+
+    "a tag with a variable attribute" : {
+      "haml" : "%p{:class => var}",
+      "html" : "<p class='hello'></p>",
+      "locals" : {
+        "var" : "hello"
+      }
+    },
+
+    "a tag with a CSS class and 'class' as a variable attribute" : {
+      "haml" : ".hello{:class => var}",
+      "html" : "<div class='hello world'></div>",
+      "locals" : {
+        "var" : "world"
+      }
+    },
+
+    "a tag multiple CSS classes (sorted correctly)" : {
+      "haml" : ".z{:class => var}",
+      "html" : "<div class='a z'></div>",
+      "locals" : {
+        "var" : "a"
+      }
+    },
+
+    "an interpolated attribute" : {
+      "haml" : "%p{:a =>\"#{var}\"}",
+      "html" : "<p a='value'></p>",
+      "locals" : {
+        "var" : "value"
+      }
+    }
+
   },
 
-  "silent comments": {
-    "-# nothing\n%p":           "<p></p>",
-    "-# nothing\n  nested\n%p": "<p></p>"
+  "silent comments" : {
+
+    "an inline comment" : {
+      "haml" : "-# hello",
+      "html" : ""
+    },
+
+    "a nested comment" : {
+      "haml" : "-#\n  hello",
+      "html" : ""
+    }
+
   },
 
-  "markup comments": {
-    "/ comment":                "<!-- comment -->",
-    "/\n  comment\n  comment2": "<!--\n  comment\n  comment2\n-->"
+  "markup comments" : {
+
+    "an inline comment" : {
+      "haml" : "/ comment",
+      "html" : "<!-- comment -->"
+    },
+
+    "a nested comment" : {
+      "haml" : "/\n  comment\n  comment2",
+      "html" : "<!--\n  comment\n  comment2\n-->"
+    }
   },
 
   "conditional comments": {
-    "/[if IE]\n  %p a": "<!--[if IE]>\n  <p>a</p>\n<![endif]-->"
+    "a conditional comment" : {
+      "haml" : "/[if IE]\n  %p a",
+      "html" : "<!--[if IE]>\n  <p>a</p>\n<![endif]-->"
+    }
   },
 
   "internal filters": {
-    ":escaped\n  <&\">":        "&lt;&amp;&quot;&gt;",
-    ":preserve\n  hello\n\n%p": "hello&#x000A;\n<p></p>",
-    ":plain\n  hello\n\n%p":    "hello\n<p></p>",
-    ":javascript\n  a();\n%p":  "<script type='text/javascript'>\n  //<![CDATA[\n    a();\n  //]]>\n</script>\n<p></p>"
+
+    "content in an 'escaped' filter" : {
+      "haml" : ":escaped\n  <&\">",
+      "html" : "&lt;&amp;&quot;&gt;"
+    },
+
+    "content in a 'preserve' filter" : {
+      "haml" : ":preserve\n  hello\n\n%p",
+      "html" : "hello&#x000A;\n<p></p>"
+    },
+
+    "content in a 'plain' filter" : {
+      "haml" : ":plain\n  hello\n\n%p",
+      "html" : "hello\n<p></p>"
+    },
+
+    "content in a 'javascript' filter" : {
+      "haml" : ":javascript\n  a();\n%p",
+      "html" : "<script type='text/javascript'>\n  //<![CDATA[\n    a();\n  //]]>\n</script>\n<p></p>"
+    }
+
   },
 
   "interpolation": {
-    "%p= \"#{var}\"":                        "<p>value</p>",
-    "%p #{var}":                             "<p>value</p>",
-    "%p \\#{var}":                           "<p>#{var}</p>",
-    "%p \\\\#{var}":                         "<p>\\value</p>",
-    ":plain\n  #{var} interpolated: #{var}": "value interpolated: value"
+
+    "interpolation inside code" : {
+      "haml" : "%p= \"#{var}\"",
+      "html" : "<p>value</p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "interpolation inside inline content" : {
+      "haml" : "%p #{var}",
+      "html" : "<p>value</p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "no interpolation when escaped" : {
+      "haml" : "%p \\#{var}",
+      "html" : "<p>#{var}</p>"
+    },
+
+    "interpolation when the escape character is escaped" : {
+      "haml" : "%p \\\\#{var}",
+      "html" : "<p>\\value</p>",
+      "locals" : {
+        "var" : "value"
+      }
+    },
+
+    "interpolation inside filtered content" : {
+      "haml" : ":plain\n  #{var} interpolated: #{var}",
+      "html" : "value interpolated: value",
+      "locals" : {
+        "var" : "value"
+      }
+    }
+
   }
 
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml
 version: !ruby/object:Gem::Version 
-  version: 2.2.5
+  version: 2.2.6
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-18 00:00:00 -07:00
+date: 2009-09-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -199,7 +199,7 @@ files:
 - test/haml/templates/action_view.haml
 - test/haml/spec/tests.json
 - test/haml/spec/lua_haml_spec.lua
-- test/haml/spec/ruby_haml_spec.rb
+- test/haml/spec/ruby_haml_test.rb
 - test/haml/spec/README.md
 - test/haml/results/content_for_layout.xhtml
 - test/haml/results/just_stuff.xhtml
@@ -281,4 +281,5 @@ test_files:
 - test/haml/template_test.rb
 - test/haml/html2haml_test.rb
 - test/haml/helper_test.rb
+- test/haml/spec/ruby_haml_test.rb
 - test/haml/engine_test.rb

data/test/haml/spec/ruby_haml_spec.rb

@@ -1,24 +0,0 @@
-require "json"
-require "haml"
-contexts = JSON.parse(File.read(File.dirname(__FILE__) + "/tests.json"))
-
-locals = {
-  :var   => "value",
-  :first => "a",
-  :last  => "z"
-}
-
-contexts.each do |context|
-  name = context[0]
-  expectations = context[1]
-  describe "When handling #{name}," do
-    expectations.each do |input, expected|
-      it "should render \"#{input}\" as \"#{expected}\"" do
-        engine = Haml::Engine.new(input)
-        engine.render(Object.new, locals).chomp.should == expected
-      end
-    end
-  end
-end
-
-