haml 2.0.2 → 2.0.3

data/lib/sass/constant/number.rb

@@ -8,7 +8,7 @@ module Sass::Constant  # :nodoc:
     def parse(value)
       first, second, unit = value.scan(Literal::NUMBER)[0]
       @value = first.empty? ? second.to_i : "#{first}#{second}".to_f
-      @unit = unit unless unit.empty?
+      @unit = unit.empty? ? nil : unit
     end
 
     def plus(other)

data/lib/sass/css.rb

@@ -18,7 +18,7 @@ module Sass
     end
 
     class ValueNode
-      def to_sass(tabs)
+      def to_sass(tabs, opts = {})
         "#{value}\n"
       end
     end
@@ -40,6 +40,12 @@ module Sass
         "#{'  ' * tabs}#{opts[:alternate] ? '' : ':'}#{name}#{opts[:alternate] ? ':' : ''} #{value}\n"
       end
     end
+
+    class DirectiveNode
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{value}#{children.map {|c| c.to_sass(tabs + 1, opts)}}\n"
+      end
+    end
   end
 
   # This class is based on the Ruby 1.9 ordered hashes.
@@ -118,7 +124,7 @@ module Sass
     # containing the CSS template.
     def render
       begin
-        build_tree.to_sass(@options).lstrip
+        build_tree.to_sass(@options).strip + "\n"
       rescue Exception => err
         line = @template.string[0...@template.pos].split("\n").size
 
@@ -132,7 +138,6 @@ module Sass
     def build_tree
       root = Tree::Node.new(nil)
       whitespace
-      directives         root
       rules              root
       expand_commas      root
       parent_ref_rules   root
@@ -142,37 +147,33 @@ module Sass
       root
     end
 
-    def directives(root)
-      while @template.scan(/@/)
-        name = @template.scan /[^\s;]+/
-        whitespace
-        value = @template.scan /[^;]+/
-        assert_match /;/
+    def rules(root)
+      while r = rule
+        root << r
         whitespace
-
-        if name == "import" && value =~ /^(url\()?"?([^\s\(\)\"]+)\.css"?\)?$/
-          value = $2
-        end
-
-        root << Tree::ValueNode.new("@#{name} #{value};", nil)
       end
     end
 
-    def rules(root)
-      rules = []
-      while @template.scan(/[^\{\s]+/)
-        rules << @template[0]
-        whitespace
+    def rule
+      return unless rule = @template.scan(/[^\{\};]+/)
+      rule.strip!
+      directive = rule[0] == ?@
 
-        if @template.scan(/\{/)
-          result = Tree::RuleNode.new(rules.join(' '), nil)
-          root << result
-          rules = []
+      if directive
+        node = Tree::DirectiveNode.new(rule, nil)
+        return node if @template.scan(/;/)
 
-          whitespace
-          attributes(result)
-        end
+        assert_match /\{/
+        whitespace
+
+        rules(node)
+        return node
       end
+
+      assert_match /\{/
+      node = Tree::RuleNode.new(rule, nil)
+      attributes(node)
+      return node
     end
 
     def attributes(rule)

data/lib/sass/error.rb

@@ -4,7 +4,7 @@ module Sass
   # and the Sass file that was being parsed (if applicable).
   # It also provides a handy way to rescue only exceptions raised
   # because of a faulty template.
-  class SyntaxError < Exception
+  class SyntaxError < StandardError
     # The line of the Sass template on which the exception was thrown.
     attr_accessor :sass_line
 

data/lib/sass/plugin.rb

@@ -34,6 +34,13 @@ module Sass
         @@options.merge!(value)
       end
 
+      # Get the options ready to be passed to the Sass::Engine
+      def engine_options(additional_options = {})
+        opts = options.dup.merge(additional_options)
+        opts[:load_paths] = load_paths(opts)
+        opts
+      end
+
       # Checks each stylesheet in <tt>options[:css_location]</tt>
       # to see if it needs updating,
       # and updates it using the corresponding template
@@ -53,10 +60,7 @@ module Sass
             File.delete(css) if File.exists?(css)
 
             filename = template_filename(name)
-            l_options = @@options.dup
-            l_options[:filename] = filename
-            l_options[:load_paths] = load_paths
-            engine = Engine.new(File.read(filename), l_options)
+            engine = Engine.new(File.read(filename), engine_options(:filename => filename))
             result = begin
                        engine.render
                      rescue Exception => e
@@ -64,7 +68,7 @@ module Sass
                      end
 
             # Create any directories that might be necessary
-            dirs = [l_options[:css_location]]
+            dirs = [options[:css_location]]
             name.split("/")[0...-1].each { |dir| dirs << "#{dirs[-1]}/#{dir}" }
             dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
 
@@ -78,8 +82,8 @@ module Sass
 
       private
 
-      def load_paths
-        (options[:load_paths] || []) + [options[:template_location]]
+      def load_paths(opts = options)
+        (opts[:load_paths] || []) + [options[:template_location]]
       end
 
       def exception_string(e)

data/lib/sass/plugin/merb.rb

@@ -6,7 +6,7 @@ unless defined?(Sass::MERB_LOADED)
     root = MERB_ROOT
     env  = MERB_ENV
   else
-    root = Merb.root
+    root = Merb.root.to_s
     env  = Merb.environment
   end
 

data/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/test/haml/engine_test.rb

@@ -2,7 +2,7 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class EngineTest < Test::Unit::TestCase
-  # A map of erroneous Sass documents to the error messages they should produce.
+  # A map of erroneous Haml documents to the error messages they should produce.
   # The error messages may be arrays;
   # if so, the second element should be the line number that should be reported for the error.
   # If this isn't provided, the tests will assume the line number should be the last line of the document.
@@ -34,13 +34,7 @@ END
     "%a/ b" => "Self-closing tags can't have content.",
     " %p foo" => "Indenting at the beginning of the document is illegal.",
     "  %p foo" => "Indenting at the beginning of the document is illegal.",
-    "- end" => <<END.rstrip,
-You don't need to use "- end" in Haml. Use indentation instead:
-- if foo?
-  %strong Foo!
-- else
-  Not foo.
-END
+    "- end" => "You don't need to use \"- end\" in Haml. Use indentation instead:\n- if foo?\n  %strong Foo!\n- else\n  Not foo.",
     " \n\t\n %p foo" => ["Indenting at the beginning of the document is illegal.", 3],
 
     # Regression tests
@@ -64,9 +58,19 @@ END
   def render(text, options = {}, &block)
     scope  = options.delete(:scope)  || Object.new
     locals = options.delete(:locals) || {}
-    Haml::Engine.new(text, options).to_html(scope, locals, &block)
+    engine(text, options).to_html(scope, locals, &block)
   end
-
+  
+  def engine(text, options = {})
+    unless options[:filename]
+      # use caller method name as fake filename. useful for debugging
+      i = -1
+      caller[i+=1] =~ /`(.+?)'/ until $1 and $1.index('test_') == 0
+      options[:filename] = "(#{$1})"
+    end
+    Haml::Engine.new(text, options)
+  end
+  
   def test_empty_render_should_remain_empty
     assert_equal('', render(''))
   end
@@ -99,7 +103,7 @@ END
   end
 
   def test_multi_render
-    engine = Haml::Engine.new("%strong Hi there!")
+    engine = engine("%strong Hi there!")
     assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
     assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
     assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
@@ -190,6 +194,10 @@ SOURCE
     assert_equal("<p>foo &amp; bar</p>\n", render("%p&= 'foo & bar'", :escape_html => false))
   end
 
+  def test_ampersand_equals_should_escape_before_preserve
+    assert_equal("<textarea>foo&#x000A;bar</textarea>\n", render('%textarea&= "foo\nbar"', :escape_html => false))
+  end
+
   def test_bang_equals_should_not_escape
     assert_equal("<p>\n  foo & bar\n</p>\n", render("%p\n  != 'foo & bar'", :escape_html => true))
   end
@@ -266,14 +274,14 @@ SOURCE
       render("\n\n = abc", :filename => 'test', :line => 2)
     rescue Exception => e
       assert_kind_of Haml::SyntaxError, e
-      assert_match /test:4/, e.backtrace.first
+      assert_match(/test:4/, e.backtrace.first)
     end
 
     begin
       render("\n\n= 123\n\n= nil[]", :filename => 'test', :line => 2)
     rescue Exception => e
       assert_kind_of NoMethodError, e
-      assert_match /test:6/, e.backtrace.first
+      assert_match(/test:6/, e.backtrace.first)
     end
   end
 
@@ -360,12 +368,15 @@ SOURCE
   def test_exceptions
     EXCEPTION_MAP.each do |key, value|
       begin
-        render(key)
+        render(key, :filename => "(exception test for #{key.inspect})")
       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(value.first, err.message, "Line: #{key}")
-        assert_equal(value[1] || key.split("\n").length, err.backtrace[0].gsub('(haml):', '').to_i, "Line: #{key}")
+        assert_equal(expected_message, err.message, "Line: #{key}")
+        assert_equal(line_no, line_reported, "Line: #{key}")
       else
         assert(false, "Exception not raised for\n#{key}")
       end
@@ -375,7 +386,7 @@ SOURCE
   def test_exception_line
     render("a\nb\n!!!\n  c\nd")
   rescue Haml::SyntaxError => e
-    assert_equal("(haml):4", e.backtrace[0])
+    assert_equal("(test_exception_line):4", e.backtrace[0])
   else
     assert(false, '"a\nb\n!!!\n  c\nd" doesn\'t produce an exception')
   end
@@ -383,7 +394,7 @@ SOURCE
   def test_exception
     render("%p\n  hi\n  %a= undefined\n= 12")
   rescue Exception => e
-    assert_match("(haml):3", e.backtrace[0])
+    assert_match("(test_exception):3", e.backtrace[0])
   else
     # Test failed... should have raised an exception
     assert(false)
@@ -392,7 +403,7 @@ SOURCE
   def test_compile_error
     render("a\nb\n- fee)\nc")
   rescue Exception => e
-    assert_match(/^compile error\n\(haml\):3: syntax error/i, e.message)
+    assert_match(/^compile error\n\(test_compile_error\):3: syntax error/i, e.message)
   else
     assert(false,
            '"a\nb\n- fee)\nc" doesn\'t produce an exception!')
@@ -409,76 +420,6 @@ SOURCE
                  render("/[if !(IE 6)|(IE 7)] Bracket: ]"))
   end
 
-  def test_no_bluecloth
-    Kernel.module_eval do
-      def gem_original_require_with_bluecloth(file)
-        raise LoadError if file == 'bluecloth'
-        gem_original_require_without_bluecloth(file)
-      end
-      alias_method :gem_original_require_without_bluecloth, :gem_original_require
-      alias_method :gem_original_require, :gem_original_require_with_bluecloth
-    end
-
-    begin
-      assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n",
-                   Haml::Engine.new(":markdown\n  Foo\n  ===\n  - a\n  - b").to_html)
-    rescue Haml::Error => e
-      if e.message == "Can't run Markdown filter; required 'bluecloth' or 'redcloth', but none were found"
-        puts "\nCouldn't require 'bluecloth' or 'redcloth'; skipping a test."
-      else
-        raise e
-      end
-    end
-
-    Kernel.module_eval do
-      alias_method :gem_original_require, :gem_original_require_without_bluecloth
-    end
-  end
-
-  def test_no_redcloth
-    Kernel.module_eval do
-      def gem_original_require_with_redcloth(file)
-        raise LoadError if file == 'redcloth'
-        gem_original_require_without_redcloth(file)
-      end
-      alias_method :gem_original_require_without_redcloth, :gem_original_require
-      alias_method :gem_original_require, :gem_original_require_with_redcloth
-    end
-
-    begin
-      Haml::Engine.new(":redcloth\n  _foo_").to_html
-    rescue Haml::Error
-    else
-      assert(false, "No exception raised!")
-    end
-
-    Kernel.module_eval do
-      alias_method :gem_original_require, :gem_original_require_without_redcloth
-    end
-  end
-
-  def test_no_redcloth_or_bluecloth
-    Kernel.module_eval do
-      def gem_original_require_with_redcloth_and_bluecloth(file)
-        raise LoadError if file == 'redcloth' || file == 'bluecloth'
-        gem_original_require_without_redcloth_and_bluecloth(file)
-      end
-      alias_method :gem_original_require_without_redcloth_and_bluecloth, :gem_original_require
-      alias_method :gem_original_require, :gem_original_require_with_redcloth_and_bluecloth
-    end
-
-    begin
-      Haml::Engine.new(":markdown\n  _foo_").to_html
-    rescue Haml::Error
-    else
-      assert(false, "No exception raised!")
-    end
-
-    Kernel.module_eval do
-      alias_method :gem_original_require, :gem_original_require_without_redcloth_and_bluecloth
-    end    
-  end
-
   def test_empty_filter
     assert_equal(<<END, render(':javascript'))
 <script type='text/javascript'>
@@ -537,28 +478,28 @@ END
 
   def test_yield_should_work_with_def_method
     s = "foo"
-    Haml::Engine.new("= yield\n= upcase").def_method(s, :render)
+    engine("= yield\n= upcase").def_method(s, :render)
     assert_equal("12\nFOO\n", s.render { 12 })
   end
 
   def test_def_method_with_module
-    Haml::Engine.new("= yield\n= upcase").def_method(String, :render_haml)
+    engine("= yield\n= upcase").def_method(String, :render_haml)
     assert_equal("12\nFOO\n", "foo".render_haml { 12 })
   end
 
   def test_def_method_locals
     obj = Object.new
-    Haml::Engine.new("%p= foo\n.bar{:baz => baz}= boom").def_method(obj, :render, :foo, :baz, :boom)
+    engine("%p= foo\n.bar{:baz => baz}= boom").def_method(obj, :render, :foo, :baz, :boom)
     assert_equal("<p>1</p>\n<div baz='2' class='bar'>3</div>\n", obj.render(:foo => 1, :baz => 2, :boom => 3))
   end
 
   def test_render_proc_locals
-    proc = Haml::Engine.new("%p= foo\n.bar{:baz => baz}= boom").render_proc(Object.new, :foo, :baz, :boom)
+    proc = engine("%p= foo\n.bar{:baz => baz}= boom").render_proc(Object.new, :foo, :baz, :boom)
     assert_equal("<p>1</p>\n<div baz='2' class='bar'>3</div>\n", proc[:foo => 1, :baz => 2, :boom => 3])
   end
 
   def test_render_proc_with_binding
-    assert_equal("FOO\n", Haml::Engine.new("= upcase").render_proc("foo".instance_eval{binding}).call)
+    assert_equal("FOO\n", engine("= upcase").render_proc("foo".instance_eval{binding}).call)
   end
 
   def test_ugly_true
@@ -585,7 +526,7 @@ END
   end
 
   def test_arbitrary_output_option
-    assert_raise(Haml::Error, "Invalid output format :html1") { Haml::Engine.new("%br", :format => :html1) }
+    assert_raise(Haml::Error, "Invalid output format :html1") { engine("%br", :format => :html1) }
   end
 
   # HTML 4.0
@@ -614,7 +555,7 @@ END
 
   # because anything before the doctype triggers quirks mode in IE
   def test_xml_prolog_and_doctype_dont_result_in_a_leading_whitespace_in_html
-    assert_no_match /^\s+/, render("!!! xml\n!!!", :format => :html4)
+    assert_no_match(/^\s+/, render("!!! xml\n!!!", :format => :html4))
   end
 
   # HTML5

data/test/haml/html2haml_test.rb

@@ -52,7 +52,8 @@ class Html2HamlTest < Test::Unit::TestCase
     end
 
     def assert_equal_attributes(expected, result)
-      assert_equal *[expected, result].map { |s| s.gsub!(/\{ (.+) \}/, ''); $1.split(', ').sort }
+      expected_attr, result_attr = [expected, result].map { |s| s.gsub!(/\{ (.+) \}/, ''); $1.split(', ').sort }
+      assert_equal expected_attr, result_attr
       assert_equal expected, result
     end
 end

data/test/haml/results/filters.xhtml

@@ -1,24 +1,9 @@
 <style>
-  p {
-    border-style: dotted;
-    border-width: 22px;
-    border-color: #ff00ff; }
+  p { border-style: dotted; border-width: 22px; border-color: #ff00ff; }
   
-  h1 {
-    font-weight: normal; }
+  h1 { font-weight: normal; }
 </style>
 TESTING HAHAHAHA!
-<h1>Foo</h1>
-
-
-	<pre><code>This is preformatted!&#x000A;Look at that!&#x000A;Wowie-zowie!</code></pre>
-
-
-	<p><strong>boldilicious!</strong></p>
-<h1>Yeah</h1>
-
-
-	<p><em>pretty much the same as above</em></p>
 <p>
   <script type='text/javascript'>
     //<![CDATA[
@@ -67,12 +52,6 @@ This
 
 </ul>
 <div class='res'>178</div>
-<p>
-  <p>I like preserved text:</p>
-  
-  
-  	<pre><code>Foo&#x000A;  Bar!&#x000A;Baz</code></pre>
-</p>
 <ul>
 <li>Foo</li>
 <li>Bar</li>