haml 2.2.1 → 2.2.2

data/VERSION

@@ -1 +1 @@
-2.2.1
+2.2.2

data/extra/haml-mode.el

@@ -603,9 +603,8 @@ 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)))))
+      (while (re-search-forward (concat "^" (make-string ci ?\s)) (mark) t)
+        (replace-match (make-string (max 0 (+ ci n)) ?\s))))))
 
 (defun haml-electric-backspace (arg)
   "Delete characters or back-dent the current line.

data/lib/haml/filters.rb

@@ -100,7 +100,7 @@ module Haml
           if contains_interpolation?(text)
             return if options[:suppress_eval]
 
-            push_script <<RUBY
+            push_script <<RUBY, :escape_html => false
 find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
 RUBY
             return

data/lib/haml/helpers.rb

@@ -14,8 +14,12 @@ module Haml
     # when it shouldn't be.
     class ErrorReturn
       # @param message [String] The error message to raise when \{#to\_s} is called
-      def initialize(message)
-        @message = message
+      def initialize(method)
+        @message = <<MESSAGE
+#{method} outputs directly to the Haml template.
+Disregard its return value and use the - operator,
+or use capture_haml to get the value as a String.
+MESSAGE
       end
 
       # Raises an error.
@@ -23,6 +27,21 @@ module Haml
       # @raise [Haml::Error] The error
       def to_s
         raise Haml::Error.new(@message)
+      rescue Haml::Error => e
+        e.backtrace.shift
+
+        # If the ErrorReturn is used directly in the template,
+        # we don't want Haml's stuff to get into the backtrace,
+        # so we get rid of the format_script line.
+        #
+        # We also have to subtract one from the Haml line number
+        # since the value is passed to format_script the line after
+        # it's actually used.
+        if e.backtrace.first =~ /^\(eval\):\d+:in `format_script/
+          e.backtrace.shift
+          e.backtrace.first.gsub!(/^\(haml\):(\d+)/) {|s| "(haml):#{$1.to_i - 1}"}
+        end
+        raise e
       end
 
       # @return [String] A human-readable string representation
@@ -338,7 +357,7 @@ END
     # @param text [#to_s] The text to output
     def haml_concat(text = "")
       haml_buffer.buffer << haml_indent << text.to_s << "\n"
-      nil
+      ErrorReturn.new("haml_concat")
     end
 
     # @return [String] The indentation string for the current line
@@ -399,11 +418,7 @@ END
     # @overload haml_tag(name, text, *flags, attributes = {})
     #   @param text [#to_s] The text within the tag
     def haml_tag(name, *rest, &block)
-      ret = ErrorReturn.new(<<MESSAGE)
-haml_tag outputs directly to the Haml template.
-Disregard its return value and use the - operator,
-or use capture_haml to get the value as a String.
-MESSAGE
+      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}

data/lib/haml/html.rb

@@ -2,9 +2,60 @@ require File.dirname(__FILE__) + '/../haml'
 
 require 'haml/engine'
 require 'rubygems'
-require 'hpricot'
 require 'cgi'
 
+module Haml
+  class HTML
+    # A module containing utility methods that every Hpricot node
+    # should have.
+    module Node
+      # Returns the Haml representation of the given node.
+      #
+      # @param tabs [Fixnum] The indentation level of the resulting Haml.
+      # @option options (see Haml::HTML#initialize)
+      def to_haml(tabs, options)
+        parse_text(self.to_s, tabs)
+      end
+
+      private
+
+      def tabulate(tabs)
+        '  ' * tabs
+      end
+
+      def parse_text(text, tabs)
+        text.strip!
+        if text.empty?
+          String.new
+        else
+          lines = text.split("\n")
+
+          lines.map do |line|
+            line.strip!
+            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
+          end.join
+        end
+      end
+    end
+  end
+end
+
+# Haml monkeypatches various Hpricot classes
+# to add methods for conversion to Haml.
+module Hpricot
+  # @see Hpricot
+  module Node
+    include Haml::HTML::Node
+  end
+
+  # @see Hpricot
+  class BaseEle
+    include Haml::HTML::Node
+  end
+end
+
+require 'hpricot'
+
 module Haml
   # Converts HTML documents into Haml templates.
   # Depends on [Hpricot](http://code.whytheluckystiff.net/hpricot/) for HTML parsing.
@@ -46,67 +97,35 @@ module Haml
     end
     alias_method :to_haml, :render
 
-    # Haml monkeypatches various Hpricot classes
-    # to add methods for conversion to Haml.
-    module ::Hpricot::Node
-      # Returns the Haml representation of the given node.
-      #
-      # @param tabs [Fixnum] The indentation level of the resulting Haml.
-      # @option options (see Haml::HTML#initialize)
-      def to_haml(tabs, options)
-        parse_text(self.to_s, tabs)
-      end
-
-      private
-
-      def tabulate(tabs)
-        '  ' * tabs
-      end
-
-      def parse_text(text, tabs)
-        text.strip!
-        if text.empty?
-          String.new
-        else
-          lines = text.split("\n")
-
-          lines.map do |line|
-            line.strip!
-            "#{tabulate(tabs)}#{'\\' if Haml::Engine::SPECIAL_CHARACTERS.include?(line[0])}#{line}\n"
-          end.join
-        end
-      end
-    end
-
     TEXT_REGEXP = /^(\s*).*$/
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::Doc
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         (children || []).inject('') {|s, c| s << c.to_haml(0, options)}
       end
     end
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::XMLDecl
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         "#{tabulate(tabs)}!!! XML\n"
       end
     end
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::CData
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         "#{tabulate(tabs)}:cdata\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::DocType
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
         if attrs == nil
@@ -137,17 +156,17 @@ module Haml
       end
     end
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::Comment
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         "#{tabulate(tabs)}/\n#{parse_text(self.content, tabs + 1)}"
       end
     end
 
-    # @see Hpricot::Node
+    # @see Hpricot
     class ::Hpricot::Elem
-      # @see Hpricot::Node#to_haml
+      # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         output = "#{tabulate(tabs)}"
         if options[:rhtml] && name[0...5] == 'haml:'

data/lib/haml/precompiler.rb

@@ -571,7 +571,10 @@ END
       attributes = {}
 
       scanner.scan(/\(\s*/)
-      until (name, value = parse_new_attribute(scanner)).first.nil?
+      loop do
+        name, value = parse_new_attribute(scanner)
+        break if name.nil?
+
         if name == false
           text = (Haml::Shared.balance(line, ?(, ?)) || [line]).first
           raise Haml::SyntaxError.new("Invalid attribute list: #{text.inspect}.", last_line - 1)

data/lib/sass/engine.rb

@@ -268,6 +268,7 @@ END
           continued_rule, child = nil, continued_rule
         end
 
+        check_for_no_children(child)
         validate_and_append_child(parent, child, line, root)
       end
 
@@ -294,6 +295,22 @@ END
       end
     end
 
+    def check_for_no_children(node)
+      return unless node.is_a?(Tree::RuleNode) && node.children.empty?
+      warning = (node.rules.size == 1) ? <<SHORT : <<LONG
+WARNING:
+Selector #{node.rules.first.inspect} doesn't have any properties and will not be rendered.
+SHORT
+
+WARNING:
+Selector
+  #{node.rules.join("\n  ")}
+doesn't have any properties and will not be rendered.
+LONG
+
+      warn(warning.strip)
+    end
+
     def parse_line(parent, line, root)
       case line.text[0]
       when PROPERTY_CHAR
@@ -425,46 +442,24 @@ END
       nil
     end
 
-    # parses out the arguments between the commas and cleans up the mixin arguments
-    # returns nil if it fails to parse, otherwise an array.
-    def parse_mixin_arguments(arg_string)
-      arg_string = arg_string.strip
-      return [] if arg_string.empty?
-      return nil unless (arg_string[0] == ?( && arg_string[-1] == ?))
-      arg_string = arg_string[1...-1]
-      arg_string.split(",", -1).map {|a| a.strip}
-    end
-
     def parse_mixin_definition(line)
       name, arg_string = line.text.scan(/^=\s*([^(]+)(.*)$/).first
-      args = parse_mixin_arguments(arg_string)
-      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".", @line) if name.nil? || args.nil?
+      raise SyntaxError.new("Invalid mixin \"#{line.text[1..-1]}\".", @line) if name.nil?
+
+      offset = line.offset + line.text.size - arg_string.size
+      args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_definition_arglist
       default_arg_found = false
-      required_arg_count = 0
-      args.map! do |arg|
-        raise SyntaxError.new("Mixin arguments can't be empty.", @line) if arg.empty? || arg == "!"
-        unless arg[0] == Script::VARIABLE_CHAR
-          raise SyntaxError.new("Mixin argument \"#{arg}\" must begin with an exclamation point (!).", @line)
-        end
-        arg, default = arg.split(/\s*=\s*/, 2)
-        required_arg_count += 1 unless default
-        default_arg_found ||= default
-        raise SyntaxError.new("Invalid variable \"#{arg}\".", @line) unless arg =~ Script::VALIDATE
-        raise SyntaxError.new("Required arguments must not follow optional arguments \"#{arg}\".", @line) if default_arg_found && !default
-        default = parse_script(default, :offset => line.offset + line.text.index(default)) if default
-        [arg[1..-1], default]
-      end
       Tree::MixinDefNode.new(name, args)
     end
 
     def parse_mixin_include(line, root)
       name, arg_string = line.text.scan(/^\+\s*([^(]+)(.*)$/).first
-      args = parse_mixin_arguments(arg_string)
-      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.", @line + 1) unless line.children.empty?
-      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".", @line) if name.nil? || args.nil?
-      args.each {|a| raise SyntaxError.new("Mixin arguments can't be empty.", @line) if a.empty?}
+      raise SyntaxError.new("Invalid mixin include \"#{line.text}\".", @line) if name.nil?
 
-      Tree::MixinNode.new(name, args.map {|s| parse_script(s, :offset => line.offset + line.text.index(s))})
+      offset = line.offset + line.text.size - arg_string.size
+      args = Script::Parser.new(arg_string.strip, @line, offset).parse_mixin_include_arglist
+      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.", @line + 1) unless line.children.empty?
+      Tree::MixinNode.new(name, args)
     end
 
     def parse_script(script, options = {})

data/lib/sass/script/funcall.rb

@@ -42,7 +42,7 @@ module Sass
 
         return Functions::EvaluationContext.new(environment.options).send(name, *args)
       rescue ArgumentError => e
-        raise e unless e.backtrace.first =~ /:in `(#{name}|perform)'$/
+        raise e unless e.backtrace.first =~ /:in `(block in )?(#{name}|perform)'$/
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
     end

data/lib/sass/script/functions.rb

@@ -71,7 +71,8 @@ module Sass::Script
     #   A number between 0 and 255 inclusive
     def rgb(red, green, blue)
       [red.value, green.value, blue.value].each do |v|
-        raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive") if v <= 0 || v >= 255
+        next unless v < 0 || v > 255
+        raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
       end
       Color.new([red.value, green.value, blue.value])
     end

data/lib/sass/script/lexer.rb

@@ -28,6 +28,7 @@ module Sass
         '*' => :times,
         '/' => :div,
         '%' => :mod,
+        '=' => :single_eq,
         '(' => :lparen,
         ')' => :rparen,
         ',' => :comma,

data/lib/sass/script/parser.rb

@@ -36,10 +36,42 @@ module Sass
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse
         expr = assert_expr :expr
-        raise Sass::SyntaxError.new("Unexpected #{@lexer.peek.type} token.") unless @lexer.done?
+        assert_done
         expr
       end
 
+      # Parses the argument list for a mixin include.
+      #
+      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
+      def parse_mixin_include_arglist
+        args = []
+
+        if try_tok(:lparen)
+          args = arglist || args
+          assert_tok(:rparen)
+        end
+        assert_done
+
+        args
+      end
+
+      # Parses the argument list for a mixin definition.
+      #
+      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
+      def parse_mixin_definition_arglist
+        args = []
+
+        if try_tok(:lparen)
+          args = defn_arglist(false) || args
+          assert_tok(:rparen)
+        end
+        assert_done
+
+        args
+      end
+
       # Parses a SassScript expression.
       #
       # @overload parse(str, line, offset, filename = nil)
@@ -120,6 +152,19 @@ END
         end
       end
 
+      def defn_arglist(must_have_default)
+        return unless c = try_tok(:const)
+        var = Script::Variable.new(c.value)
+        if try_tok(:single_eq)
+          val = assert_expr(:concat)
+        elsif must_have_default
+          raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.", @line)
+        end
+
+        return [[var, val]] unless try_tok(:comma)
+        [[var, val], *defn_arglist(val)]
+      end
+
       def arglist
         return unless e = concat
         return [e] unless try_tok(:comma)
@@ -167,6 +212,11 @@ END
         peeked =  @lexer.peek
         peeked && names.include?(peeked.type) && @lexer.next
       end
+
+      def assert_done
+        return if @lexer.done?
+        raise Sass::SyntaxError.new("Unexpected #{@lexer.peek.type} token.")
+      end
     end
   end
 end

data/lib/sass/tree/mixin_def_node.rb

@@ -5,8 +5,8 @@ module Sass
     # @see Sass::Tree
     class MixinDefNode < Node
       # @param name [String] The mixin name
-      # @param args [Array<(String, Script::Node)>] The arguments for the mixin.
-      #   Each element is a tuple containing the name of the argument
+      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the mixin.
+      #   Each element is a tuple containing the variable for argument
       #   and the parse tree for the default value of the argument
       def initialize(name, args)
         @name = name

data/lib/sass/tree/mixin_node.rb

@@ -32,14 +32,14 @@ Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
 END
 
       environment = mixin.args.zip(@args).
-        inject(Sass::Environment.new(mixin.environment)) do |env, ((name, default), value)|
-        env.set_local_var(name,
+        inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
+        env.set_local_var(var.name,
           if value
             value.perform(environment)
           elsif default
             default.perform(env)
           end)
-        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter !#{name}.") unless env.var(name)
+        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
         env
       end
       mixin.tree.map {|c| c.perform(environment)}.flatten

data/test/haml/engine_test.rb

@@ -425,6 +425,19 @@ HAML
     assert_equal("<a href='#'></a>\n", render('%a(href="#")'))
   end
 
+  def test_javascript_filter_with_dynamic_interp_and_escape_html
+    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
+<script type='text/javascript'>
+  //<![CDATA[
+    & < > &
+  //]]>
+</script>
+HTML
+:javascript
+ & < > \#{"&"}
+HAML
+  end
+
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape

data/test/haml/helper_test.rb

@@ -8,6 +8,12 @@ class ActionView::Base
   end
 end
 
+module Haml::Helpers
+  def something_that_uses_haml_concat
+    haml_concat('foo').to_s
+  end
+end
+
 class HelperTest < Test::Unit::TestCase
   Post = Struct.new('Post', :body)
   
@@ -221,7 +227,29 @@ HAML
   def test_content_tag_nested
     assert_equal "<span><div>something</div></span>", render("= nested_tag", :action_view).strip
   end
-  
+
+  def test_error_return
+    assert_raise(Haml::Error, <<MESSAGE) {render("= haml_concat 'foo'")}
+haml_concat outputs directly to the Haml template.
+Disregard its return value and use the - operator,
+or use capture_haml to get the value as a String.
+MESSAGE
+  end
+
+  def test_error_return_line
+    render("%p foo\n= haml_concat 'foo'\n%p bar")
+    assert false, "Expected Haml::Error"
+  rescue Haml::Error => e
+    assert_equal 2, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+  end
+
+  def test_error_return_line_in_helper
+    render("- something_that_uses_haml_concat")
+    assert false, "Expected Haml::Error"
+  rescue Haml::Error => e
+    assert_equal 13, e.backtrace[0].scan(/:(\d+)/).first.first.to_i
+  end
+
   class ActsLikeTag
     # We want to be able to have people include monkeypatched ActionView helpers
     # without redefining is_haml?.

data/test/haml/template_test.rb

@@ -140,8 +140,16 @@ class TemplateTest < Test::Unit::TestCase
   end
 
   def test_action_view_templates_render_correctly
-    @base.content_for(:layout) {'Lorem ipsum dolor sit amet'}
-    assert_renders_correctly 'content_for_layout'
+    proc = lambda do
+      @base.content_for(:layout) {'Lorem ipsum dolor sit amet'}
+      assert_renders_correctly 'content_for_layout'
+    end
+
+    if @base.respond_to?(:with_output_buffer)
+      @base.with_output_buffer("", &proc)
+    else
+      proc.call
+    end
   end
 
   def test_instance_variables_should_work_inside_templates

data/test/sass/engine_test.rb

@@ -65,14 +65,14 @@ class SassEngineTest < Test::Unit::TestCase
     "a\n  b: c\na\n    d: e" => ["The line was indented 2 levels deeper than the previous line.", 4],
     "a\n  b: c\n  a\n        d: e" => ["The line was indented 3 levels deeper than the previous line.", 4],
     "a\n \tb: c" => ["Indentation can't use both tabs and spaces.", 2],
-    "=a(" => 'Invalid mixin "a(".',
-    "=a(b)" => 'Mixin argument "b" must begin with an exclamation point (!).',
-    "=a(,)" => "Mixin arguments can't be empty.",
-    "=a(!)" => "Mixin arguments can't be empty.",
-    "=a(!foo bar)" => "Invalid variable \"!foo bar\".",
+    "=a(" => 'Expected rparen token, was end of text.',
+    "=a(b)" => 'Expected rparen token, was ident token.',
+    "=a(,)" => "Expected rparen token, was comma token.",
+    "=a(!)" => "Syntax error in '(!)' at character 4.",
+    "=a(!foo bar)" => "Expected rparen token, was ident token.",
     "=foo\n  bar: baz\n+foo" => ["Properties aren't allowed at the root of a document.", 2],
     "a-\#{!b\n  c: d" => ["Expected end_interpolation token, was end of text.", 1],
-    "=a(!b = 1, !c)" => "Required arguments must not follow optional arguments \"!c\".",
+    "=a(!b = 1, !c)" => "Required argument !c must come before any optional arguments.",
     "=a(!b = 1)\n  :a= !b\ndiv\n  +a(1,2)" => "Mixin a takes 1 argument but 2 were passed.",
     "=a(!b)\n  :a= !b\ndiv\n  +a" => "Mixin a is missing parameter !b.",
     "@else\n  a\n    b: c" => ["@else must come after @if.", 1],
@@ -130,7 +130,7 @@ class SassEngineTest < Test::Unit::TestCase
     define_method("test_exception (#{key.inspect})") do
       line = 10
       begin
-        Sass::Engine.new(key, :filename => __FILE__, :line => line).render
+        silence_warnings {Sass::Engine.new(key, :filename => __FILE__, :line => line).render}
       rescue Sass::SyntaxError => err
         value = [value] unless value.is_a?(Array)
 
@@ -704,8 +704,41 @@ a
 SASS
   end
 
+  def test_empty_selector_warning
+    assert_warning(<<END) {render("foo bar")}
+WARNING:
+Selector "foo bar" doesn't have any properties and will not be rendered.
+END
+
+    assert_warning(<<END) {render(<<SASS)}
+WARNING:
+Selector
+  foo, bar, baz,
+  bang, bip, bop
+doesn't have any properties and will not be rendered.
+END
+foo, bar, baz,
+bang, bip, bop
+SASS
+  end
+
   # Regression tests
 
+  def test_parens_in_mixins
+    assert_equal(<<CSS, render(<<SASS))
+.foo {
+  color: #01ff7f;
+  background-color: #000102; }
+CSS
+=foo(!c1, !c2 = rgb(0, 1, 2))
+  color = !c1
+  background-color = !c2
+
+.foo
+  +foo(rgb(1,255,127))
+SASS
+  end
+
   def test_comment_beneath_prop
     assert_equal(<<RESULT, render(<<SOURCE))
 .box {

data/test/sass/functions_test.rb

@@ -91,6 +91,7 @@ class SassFunctionTest < Test::Unit::TestCase
   def test_rgb
     assert_equal("#123456", evaluate("rgb(18, 52, 86)"))
     assert_equal("#beaded", evaluate("rgb(190, 173, 237)"))
+    assert_equal("#00ff7f", evaluate("rgb(0, 255, 127)"))
 
     assert_error_message("Color value 256 must be between 0 and 255 inclusive for `rgb'",
       "rgb(256, 1, 1)")

data/test/sass/plugin_test.rb

@@ -22,8 +22,10 @@ class SassPluginTest < Test::Unit::TestCase
     FileUtils.rm_r tempfile_loc(nil,"more_")
   end
 
-  def test_templates_should_render_correctly
-    @@templates.each { |name| assert_renders_correctly(name) }
+  @@templates.each do |name|
+    define_method("test_template_renders_correctly (#{name})") do
+      assert_renders_correctly(name)
+    end
   end
 
   def test_no_update

data/test/sass/script_test.rb

@@ -243,21 +243,6 @@ WARN
     Sass::Engine.new(sass, options).render
   end
 
-  def assert_warning(message)
-    the_real_stderr, $stderr = $stderr, StringIO.new
-    yield
-    assert_equal message.strip, $stderr.string.strip
-  ensure
-    $stderr = the_real_stderr
-  end
-
-  def silence_warnings
-    the_real_stderr, $stderr = $stderr, StringIO.new
-    yield
-  ensure
-    $stderr = the_real_stderr
-  end
-
   def env(hash = {})
     env = Sass::Environment.new
     hash.each {|k, v| env.set_var(k, v)}

data/test/sass/templates/complex.sass

@@ -99,8 +99,6 @@ body
     :clear both
     .column
       :float left
-      .left
-      .middle
       .right
         :float right
   a:link, a:visited

data/test/test_helper.rb

@@ -7,7 +7,7 @@ $:.unshift lib_dir unless $:.include?(lib_dir)
 require 'haml'
 require 'sass'
 
-Sass::RAILS_LOADED = true
+Sass::RAILS_LOADED = true unless defined?(Sass::RAILS_LOADED)
 
 # required because of Sass::Plugin
 unless defined? RAILS_ROOT
@@ -26,4 +26,19 @@ class Test::Unit::TestCase
     path = File.dirname(__FILE__) + "/../.sass-cache"
     FileUtils.rm_r(path) if File.exist?(path)
   end
+
+  def assert_warning(message)
+    the_real_stderr, $stderr = $stderr, StringIO.new
+    yield
+    assert_equal message.strip, $stderr.string.strip
+  ensure
+    $stderr = the_real_stderr
+  end
+
+  def silence_warnings
+    the_real_stderr, $stderr = $stderr, StringIO.new
+    yield
+  ensure
+    $stderr = the_real_stderr
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml
 version: !ruby/object:Gem::Version 
-  version: 2.2.1
+  version: 2.2.2
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-12 00:00:00 -04:00
+date: 2009-07-20 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency