haml-edge 2.3.93 → 2.3.94

data/lib/sass/tree/rule_node.rb

@@ -39,15 +39,53 @@ module Sass::Tree
     #
     # would be
     #
-    #     [[[:parent, "foo"], ["bar"], ["baz"]],
-    #      [["bip"], [:parent, "bop"], ["bup"]]]
+    #     [[[:parent, ".foo"], ["bar"], ["baz"]],
+    #      [["bip"], [:parent, ".bop"], ["bup"]]]
     #
     # @return [Array<Array<Array<String|Symbol>>>]
     attr_accessor :parsed_rules
 
+    # The CSS selectors for this rule,
+    # with all nesting and parent references resolved.
+    # It's only set once {Tree::Node#cssize} has been called.
+    #
+    # The first level of arrays represents distinct lines in the Sass file;
+    # the second level represents comma-separated selectors.
+    # For example,
+    #
+    #     foo bar, baz,
+    #     bang, bip bop, blip
+    #
+    # would be
+    #
+    #     [["foo bar", "baz"],
+    #      ["bang", "bip bop", "blip"]]
+    #
+    # @return [Array<Array<String>>]
+    attr_accessor :resolved_rules
+
+    # How deep this rule is indented
+    # relative to a base-level rule.
+    # This is only greater than 0 in the case that:
+    #
+    # * This node is in a CSS tree
+    # * The style is :nested
+    # * This is a child rule of another rule
+    # * The parent rule has properties, and thus will be rendered
+    #
+    # @return [Fixnum]
+    attr_accessor :tabs
+
+    # Whether or not this rule is the last rule in a nested group.
+    # This is only set in a CSS tree.
+    #
+    # @return [Boolean]
+    attr_accessor :group_end
+
     # @param rule [String] The first CSS rule. See \{#rules}
     def initialize(rule)
       @rules = [rule]
+      @tabs = 0
       super()
     end
 
@@ -77,15 +115,9 @@ module Sass::Tree
     # Computes the CSS for the rule.
     #
     # @param tabs [Fixnum] The level of indentation for the CSS
-    # @param super_rules [Array<Array<String>>] The rules for the parent node
-    #   (see \{#rules}), or `nil` if there are no parents
     # @return [String] The resulting CSS
-    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
-    def _to_s(tabs, super_rules = nil)
-      resolved_rules = resolve_parent_refs(super_rules)
-
-      properties = []
-      sub_rules = []
+    def _to_s(tabs)
+      tabs = tabs + self.tabs
 
       rule_separator = style == :compressed ? ',' : ', '
       line_separator = [:nested, :expanded].include?(style) ? ",\n" : rule_separator
@@ -96,54 +128,38 @@ module Sass::Tree
         per_rule_indent + line.join(rule_separator)
       end.join(line_separator)
 
-      children.each do |child|
-        next if child.invisible?
-        if child.is_a? RuleNode
-          sub_rules << child
-        else
-          properties << child
-        end
-      end
-
       to_return = ''
-      if !properties.empty?
-        old_spaces = '  ' * (tabs - 1)
-        spaces = '  ' * tabs
-        if @options[:line_comments] && style != :compressed
-          to_return << "#{old_spaces}/* line #{line}"
-
-          if filename
-            relative_filename = if @options[:css_filename]
-              begin
-                Pathname.new(filename).relative_path_from(  
-                  Pathname.new(File.dirname(@options[:css_filename]))).to_s
-              rescue ArgumentError
-                nil
-              end
+      old_spaces = '  ' * (tabs - 1)
+      spaces = '  ' * tabs
+      if @options[:line_comments] && style != :compressed
+        to_return << "#{old_spaces}/* line #{line}"
+
+        if filename
+          relative_filename = if @options[:css_filename]
+            begin
+              Pathname.new(filename).relative_path_from(
+                Pathname.new(File.dirname(@options[:css_filename]))).to_s
+            rescue ArgumentError
+              nil
             end
-            relative_filename ||= filename
-            to_return << ", #{relative_filename}"
           end
-
-          to_return << " */\n"
+          relative_filename ||= filename
+          to_return << ", #{relative_filename}"
         end
 
-        if style == :compact
-          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
-          to_return << "#{total_rule} { #{properties} }\n"
-        elsif style == :compressed
-          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
-          to_return << "#{total_rule}{#{properties}}"
-        else
-          properties = properties.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
-          end_props = (style == :expanded ? "\n" + old_spaces : ' ')
-          to_return << "#{total_rule} {\n#{properties}#{end_props}}\n"
-        end
+        to_return << " */\n"
       end
 
-      tabs += 1 unless properties.empty? || style != :nested
-      sub_rules.each do |sub|
-        to_return << sub.to_s(tabs, resolved_rules)
+      if style == :compact
+        properties = children.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+        to_return << "#{total_rule} { #{properties} }#{"\n" if group_end}"
+      elsif style == :compressed
+        properties = children.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
+        to_return << "#{total_rule}{#{properties}}"
+      else
+        properties = children.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+        end_props = (style == :expanded ? "\n" + old_spaces : ' ')
+        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if group_end}"
       end
 
       to_return
@@ -159,6 +175,37 @@ module Sass::Tree
       super
     end
 
+    # Converts nested rules into a flat list of rules.
+    #
+    # @param parent [RuleNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {RuleNode}
+    def _cssize(parent)
+      node = super
+      rules = node.children.select {|c| c.is_a?(RuleNode)}
+      props = node.children.reject {|c| c.is_a?(RuleNode) || c.invisible?}
+
+      unless props.empty?
+        node.children = props
+        rules.each {|r| r.tabs += 1} if style == :nested
+        rules.unshift(node)
+      end
+
+      rules.last.group_end = true unless parent || rules.empty?
+
+      rules
+    end
+
+    # Resolves parent references and nested selectors,
+    # and updates the indentation based on the parent's indentation.
+    #
+    # @param parent [RuleNode, nil] The parent node of this node,
+    #   or nil if the parent isn't a {RuleNode}
+    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
+    def cssize!(parent)
+      self.resolved_rules = resolve_parent_refs(parent && parent.resolved_rules)
+      super
+    end
+
     private
 
     def resolve_parent_refs(super_rules)

data/test/haml/engine_test.rb

@@ -586,6 +586,16 @@ HTML
 HAML
   end
 
+  def test_if_without_content_and_else
+    assert_equal(<<HTML, render(<<HAML))
+foo
+HTML
+- if false
+- else
+  foo
+HAML
+  end
+
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape

data/test/haml/util_test.rb

@@ -54,6 +54,13 @@ class UtilTest < Test::Unit::TestCase
       powerset([1, 2, 3]))
   end
 
+  def test_restrict
+    assert_equal(0.5, restrict(0.5, 0..1))
+    assert_equal(1, restrict(2, 0..1))
+    assert_equal(1.3, restrict(2, 0..1.3))
+    assert_equal(0, restrict(-1, 0..1))
+  end
+
   def test_merge_adjacent_strings
     assert_equal(["foo bar baz", :bang, "biz bop", 12],
       merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))

data/test/sass/engine_test.rb

@@ -32,11 +32,6 @@ MSG
     "a\n  b=c: d" => 'Invalid property: "b=c: d".',
     "a: b" => 'Properties aren\'t allowed at the root of a document.',
     ":a b" => 'Properties aren\'t allowed at the root of a document.',
-    "a:" => 'Properties aren\'t allowed at the root of a document.',
-    ":a" => <<MSG,
-Properties aren't allowed at the root of a document.
-If ":a" should be a selector, use "\\:a" instead.
-MSG
     "!" => 'Invalid variable: "!".',
     "!a" => 'Invalid variable: "!a".',
     "! a" => 'Invalid variable: "! a".',
@@ -189,15 +184,15 @@ SASS
   end
 
   def test_imported_exception
-    [1, 2, 3].each do |i|
+    [1, 2, 3, 4].each do |i|
       begin
         Sass::Engine.new("@import bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
       rescue Sass::SyntaxError => err
         assert_equal(2, err.sass_line)
         assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
 
-        assert_equal(err.sass_filename, err.sass_backtrace.first[:filename])
-        assert_equal(err.sass_line, err.sass_backtrace.first[:line])
+        assert_hash_has(err.sass_backtrace.first,
+          :filename => err.sass_filename, :line => err.sass_line)
 
         assert_nil(err.sass_backtrace[1][:filename])
         assert_equal(1, err.sass_backtrace[1][:line])
@@ -211,15 +206,15 @@ SASS
   end
 
   def test_double_imported_exception
-    [1, 2, 3].each do |i|
+    [1, 2, 3, 4].each do |i|
       begin
         Sass::Engine.new("@import nested_bork#{i}", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
       rescue Sass::SyntaxError => err
         assert_equal(2, err.sass_line)
         assert_match(/(\/|^)bork#{i}\.sass$/, err.sass_filename)
 
-        assert_equal(err.sass_filename, err.sass_backtrace.first[:filename])
-        assert_equal(err.sass_line, err.sass_backtrace.first[:line])
+        assert_hash_has(err.sass_backtrace.first,
+          :filename => err.sass_filename, :line => err.sass_line)
 
         assert_match(/(\/|^)nested_bork#{i}\.sass$/, err.sass_backtrace[1][:filename])
         assert_equal(2, err.sass_backtrace[1][:line])
@@ -236,6 +231,96 @@ SASS
     end
   end
 
+  def test_mixin_exception
+    render(<<SASS)
+=error-mixin(!a)
+  color = !a * 1em * 1px
+
+=outer-mixin(!a)
+  +error-mixin(!a)
+
+.error
+  +outer-mixin(12)
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_equal(2, err.sass_line)
+    assert_equal(test_filename, err.sass_filename)
+    assert_equal("error-mixin", err.sass_mixin)
+
+    assert_hash_has(err.sass_backtrace.first, :line => err.sass_line,
+      :filename => err.sass_filename, :mixin => err.sass_mixin)
+    assert_hash_has(err.sass_backtrace[1], :line => 5,
+      :filename => test_filename, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => test_filename, :mixin => nil)
+
+    assert_equal("#{test_filename}:2:in `error-mixin'", err.backtrace.first)
+    assert_equal("#{test_filename}:5:in `outer-mixin'", err.backtrace[1])
+    assert_equal("#{test_filename}:8", err.backtrace[2])
+  end
+
+  def test_mixin_callsite_exception
+    render(<<SASS)
+=one-arg-mixin(!a)
+  color = !a
+
+=outer-mixin(!a)
+  +one-arg-mixin(!a, 12)
+
+.error
+  +outer-mixin(12)
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_hash_has(err.sass_backtrace.first, :line => 5,
+      :filename => test_filename, :mixin => "one-arg-mixin")
+    assert_hash_has(err.sass_backtrace[1], :line => 5,
+      :filename => test_filename, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => test_filename, :mixin => nil)
+  end
+
+  def test_mixin_exception_cssize
+    render(<<SASS)
+=parent-ref-mixin
+  & foo
+    a: b
+
+=outer-mixin
+  +parent-ref-mixin
+
++outer-mixin
+SASS
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_hash_has(err.sass_backtrace.first, :line => 2,
+      :filename => test_filename, :mixin => "parent-ref-mixin")
+    assert_hash_has(err.sass_backtrace[1], :line => 6,
+      :filename => test_filename, :mixin => "outer-mixin")
+    assert_hash_has(err.sass_backtrace[2], :line => 8,
+      :filename => test_filename, :mixin => nil)
+  end
+
+  def test_mixin_and_import_exception
+    Sass::Engine.new("@import nested_mixin_bork", :load_paths => [File.dirname(__FILE__) + '/templates/']).render
+    assert(false, "Exception not raised")
+  rescue Sass::SyntaxError => err
+    assert_match(/(\/|^)nested_mixin_bork\.sass$/, err.sass_backtrace.first[:filename])
+    assert_hash_has(err.sass_backtrace.first, :mixin => "error-mixin", :line => 4)
+
+    assert_match(/(\/|^)mixin_bork\.sass$/, err.sass_backtrace[1][:filename])
+    assert_hash_has(err.sass_backtrace[1], :mixin => "outer-mixin", :line => 2)
+
+    assert_match(/(\/|^)mixin_bork\.sass$/, err.sass_backtrace[2][:filename])
+    assert_hash_has(err.sass_backtrace[2], :mixin => nil, :line => 5)
+
+    assert_match(/(\/|^)nested_mixin_bork\.sass$/, err.sass_backtrace[3][:filename])
+    assert_hash_has(err.sass_backtrace[3], :mixin => nil, :line => 6)
+
+    assert_hash_has(err.sass_backtrace[4], :filename => nil, :mixin => nil, :line => 1)
+  end
+
   def test_exception_css_with_offset
     opts = {:full_exception => true, :line => 362}
     render(("a\n  b: c\n" * 10) + "d\n  e:\n" + ("f\n  g: h\n" * 10), opts)
@@ -261,6 +346,67 @@ CSS
     assert(false, "Exception not raised for test_exception_css_with_offset")
   end
 
+  def test_exception_css_with_mixins
+    opts = {:full_exception => true}
+    render(<<SASS, opts)
+=error-mixin(!a)
+  color = !a * 1em * 1px
+
+=outer-mixin(!a)
+  +error-mixin(!a)
+
+.error
+  +outer-mixin(12)
+SASS
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..13].join("\n"))
+/*
+Syntax error: 12em*px isn't a valid CSS value.
+        on line 2 of test_exception_css_with_mixins_inline.sass, in `error-mixin'
+        from line 5 of test_exception_css_with_mixins_inline.sass, in `outer-mixin'
+        from line 8 of test_exception_css_with_mixins_inline.sass
+
+1: =error-mixin(!a)
+2:   color = !a * 1em * 1px
+3: 
+4: =outer-mixin(!a)
+5:   +error-mixin(!a)
+6: 
+7: .error
+CSS
+  else
+    assert(false, "Exception not raised")
+  end
+
+  def test_cssize_exception_css
+    opts = {:full_exception => true}
+    render(<<SASS, opts)
+.filler
+  stuff: stuff!
+
+a: b
+
+.more.filler
+  a: b
+SASS
+  rescue Sass::SyntaxError => e
+    assert_equal(<<CSS, Sass::SyntaxError.exception_to_css(e, opts).split("\n")[0..11].join("\n"))
+/*
+Syntax error: Properties aren't allowed at the root of a document.
+        on line 4 of test_cssize_exception_css_inline.sass
+
+1: .filler
+2:   stuff: stuff!
+3: 
+4: a: b
+5: 
+6: .more.filler
+7:   a: b
+CSS
+  else
+    assert(false, "Exception not raised")
+  end
+
   def test_css_import
     assert_equal("@import url(./fonts.css) screen;\n", render("@import url(./fonts.css) screen"))
     assert_equal("@import \"./fonts.css\" screen;\n", render("@import \"./fonts.css\" screen"))
@@ -1000,7 +1146,11 @@ SASS
   end
 
   private
-  
+
+  def assert_hash_has(hash, expected)
+    expected.each {|k, v| assert_equal(v, hash[k])}
+  end
+
   def render(sass, options = {})
     munge_filename options
     Sass::Engine.new(sass, options).render

data/test/sass/functions_test.rb

@@ -196,18 +196,19 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_opacify
-    assert_equal("rgba(0, 0, 0, 0.75)", evaluate("opacify(rgba(0, 0, 0, 0.5), 50%)"))
-    assert_equal("rgba(0, 0, 0, 0.8)", evaluate("opacify(rgba(0, 0, 0, 0.2), 75)"))
-    assert_equal("rgba(0, 0, 0, 0.28)", evaluate("fade-in(rgba(0, 0, 0, 0.2), 10px)"))
-    assert_equal("black", evaluate("fade_in(rgba(0, 0, 0, 0.2), 100%)"))
+    assert_equal("rgba(0, 0, 0, 0.75)", evaluate("opacify(rgba(0, 0, 0, 0.5), 0.25)"))
+    assert_equal("rgba(0, 0, 0, 0.3)", evaluate("opacify(rgba(0, 0, 0, 0.2), 0.1)"))
+    assert_equal("rgba(0, 0, 0, 0.7)", evaluate("fade-in(rgba(0, 0, 0, 0.2), 0.5px)"))
+    assert_equal("black", evaluate("fade_in(rgba(0, 0, 0, 0.2), 0.8)"))
+    assert_equal("black", evaluate("opacify(rgba(0, 0, 0, 0.2), 1)"))
     assert_equal("rgba(0, 0, 0, 0.2)", evaluate("opacify(rgba(0, 0, 0, 0.2), 0%)"))
   end
 
   def test_opacify_tests_bounds
-    assert_error_message("Amount -3012% must be between 0% and 100% for `opacify'",
-      "opacify(rgba(0, 0, 0, 0.2), -3012%)")
-    assert_error_message("Amount 101 must be between 0% and 100% for `opacify'",
-      "opacify(rgba(0, 0, 0, 0.2), 101)")
+    assert_error_message("Amount -0.001 must be between 0 and 1 for `opacify'",
+      "opacify(rgba(0, 0, 0, 0.2), -0.001)")
+    assert_error_message("Amount 1.001 must be between 0 and 1 for `opacify'",
+      "opacify(rgba(0, 0, 0, 0.2), 1.001)")
   end
 
   def test_opacify_tests_types
@@ -216,18 +217,19 @@ class SassFunctionTest < Test::Unit::TestCase
   end
 
   def test_transparentize
-    assert_equal("rgba(0, 0, 0, 0.25)", evaluate("transparentize(rgba(0, 0, 0, 0.5), 50%)"))
-    assert_equal("rgba(0, 0, 0, 0.05)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 75)"))
-    assert_equal("rgba(0, 0, 0, 0.18)", evaluate("fade-out(rgba(0, 0, 0, 0.2), 10px)"))
-    assert_equal("rgba(0, 0, 0, 0)", evaluate("fade_out(rgba(0, 0, 0, 0.2), 100%)"))
-    assert_equal("rgba(0, 0, 0, 0.2)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 0%)"))
+    assert_equal("rgba(0, 0, 0, 0.3)", evaluate("transparentize(rgba(0, 0, 0, 0.5), 0.2)"))
+    assert_equal("rgba(0, 0, 0, 0.1)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 0.1)"))
+    assert_equal("rgba(0, 0, 0, 0.2)", evaluate("fade-out(rgba(0, 0, 0, 0.5), 0.3px)"))
+    assert_equal("rgba(0, 0, 0, 0)", evaluate("fade_out(rgba(0, 0, 0, 0.2), 0.2)"))
+    assert_equal("rgba(0, 0, 0, 0)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 1)"))
+    assert_equal("rgba(0, 0, 0, 0.2)", evaluate("transparentize(rgba(0, 0, 0, 0.2), 0)"))
   end
 
   def test_transparentize_tests_bounds
-    assert_error_message("Amount -3012% must be between 0% and 100% for `transparentize'",
-      "transparentize(rgba(0, 0, 0, 0.2), -3012%)")
-    assert_error_message("Amount 101 must be between 0% and 100% for `transparentize'",
-      "transparentize(rgba(0, 0, 0, 0.2), 101)")
+    assert_error_message("Amount -0.001 must be between 0 and 1 for `transparentize'",
+      "transparentize(rgba(0, 0, 0, 0.2), -0.001)")
+    assert_error_message("Amount 1.001 must be between 0 and 1 for `transparentize'",
+      "transparentize(rgba(0, 0, 0, 0.2), 1.001)")
   end
 
   def test_transparentize_tests_types