haml-edge 2.3.179 → 2.3.180

data/lib/sass/tree/rule_node.rb

@@ -10,30 +10,23 @@ module Sass::Tree
     # @private
     PARENT = '&'
 
-    # The CSS selectors for this rule.
-    # Each string is a selector line, and the lines are meant to be separated by commas.
-    # For example,
-    #
-    #     foo, bar, baz,
-    #     bip, bop, bup
-    #
-    # would be
-    #
-    #     ["foo, bar, baz",
-    #      "bip, bop, bup"]
+    # The CSS selector for this rule,
+    # interspersed with {Sass::Script::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
     #
-    # @return [Array<String>]
-    attr_accessor :rules
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :rule
 
     # The CSS selectors for this rule,
     # parsed for commas and parent-references.
     # It's only set once {Tree::Node#perform} has been called.
     #
-    # It's an array of arrays of arrays.
-    # The first level of arrays represents distinct lines in the Sass file;
-    # the second level represents comma-separated selectors;
-    # the third represents structure within those selectors,
+    # It's an array of arrays.
+    # The first level of arrays comma-separated selectors;
+    # the second represents structure within those selectors,
     # currently only parent-refs (represented by `:parent`).
+    # Newlines are represented as literal `\n` characters in the strings.
     # For example,
     #
     #     &.foo, bar, baz,
@@ -41,18 +34,18 @@ module Sass::Tree
     #
     # would be
     #
-    #     [[[:parent, ".foo"], ["bar"], ["baz"]],
-    #      [["bip"], [:parent, ".bop"], ["bup"]]]
+    #     [[:parent, ".foo"], ["bar"], ["baz"],
+    #      ["\nbip"], [:parent, ".bop"], ["bup"]]
     #
-    # @return [Array<Array<Array<String|Symbol>>>]
+    # @return [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.
+    # Each element is a distinct selector, separated by commas.
+    # Newlines are represented as literal `\n` characters in the strings.
     # For example,
     #
     #     foo bar, baz,
@@ -60,10 +53,9 @@ module Sass::Tree
     #
     # would be
     #
-    #     [["foo bar", "baz"],
-    #      ["bang", "bip bop", "blip"]]
+    #     ["foo bar", "baz", "\nbang", "bip bop", "blip"]
     #
-    # @return [Array<Array<String>>]
+    # @return [Array<String>]
     attr_accessor :resolved_rules
 
     # How deep this rule is indented
@@ -84,9 +76,11 @@ module Sass::Tree
     # @return [Boolean]
     attr_accessor :group_end
 
-    # @param rule [String] The first CSS rule. See \{#rules}
+    # @param rule [Array<String, Sass::Script::Node>]
+    #   The CSS rule. See \{#rule}
     def initialize(rule)
-      @rules = [rule]
+      @rule = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(rule))
       @tabs = 0
       super()
     end
@@ -97,19 +91,48 @@ module Sass::Tree
     # @return [Boolean] Whether or not this node and the other object
     #   are the same
     def ==(other)
-      self.class == other.class && rules == other.rules && super
+      self.class == other.class && rule == other.rule && super
     end
 
     # Adds another {RuleNode}'s rules to this one's.
     #
     # @param node [RuleNode] The other node
     def add_rules(node)
-      @rules += node.rules
+      @rule = Haml::Util.strip_string_array(
+        Haml::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
     end
 
     # @return [Boolean] Whether or not this rule is continued on the next line
     def continued?
-      @rules.last[-1] == ?,
+      last = @rule.last
+      last.is_a?(String) && last[-1] == ?,
+    end
+
+    # @see Node#to_sass
+    def to_sass(tabs, opts = {})
+      name = rule.map do |r|
+        if r.is_a?(String)
+          r.gsub(/(,[ \t]*)?\n\s*/) {$1 ? $1 + "\n" : " "}
+        else
+          "\#{#{r.to_sass}}"
+        end
+      end.join
+      name = "\\" + name if name[0] == ?:
+      name.gsub(/^/, '  ' * tabs) + children_to_src(tabs, opts, :sass)
+    end
+
+    def to_scss(tabs, opts = {})
+      name = rule.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass}}"}.
+        join.gsub(/^[ \t]*/, '  ' * tabs)
+
+      res = name + children_to_src(tabs, opts, :scss)
+
+      if children.last.is_a?(CommentNode) && children.last.silent
+        res.slice!(-3..-1)
+        res << "\n" << ('  ' * tabs) << "}\n"
+      end
+
+      res
     end
 
     protected
@@ -122,12 +145,17 @@ module Sass::Tree
       tabs = tabs + self.tabs
 
       rule_separator = style == :compressed ? ',' : ', '
-      line_separator = [:nested, :expanded].include?(style) ? ",\n" : rule_separator
+      line_separator =
+        case style
+          when :nested, :expanded; "\n"
+          when :compressed; ""
+          else; " "
+        end
       rule_indent = '  ' * (tabs - 1)
       per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
 
-      total_rule = total_indent + resolved_rules.map do |line|
-        per_rule_indent + line.join(rule_separator)
+      total_rule = total_indent + resolved_rules.join(rule_separator).split("\n").map do |line|
+        per_rule_indent + line.strip
       end.join(line_separator)
 
       to_return = ''
@@ -157,13 +185,13 @@ module Sass::Tree
       end
 
       if style == :compact
-        properties = children.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+        properties = children.map { |a| a.to_s(1) }.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(';')
+        properties = children.map { |a| a.to_s(1) }.join(';')
         to_return << "#{total_rule}{#{properties}}"
       else
-        properties = children.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+        properties = children.map { |a| a.to_s(tabs + 1) }.join("\n")
         end_props = (style == :expanded ? "\n" + old_spaces : ' ')
         to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if group_end}"
       end
@@ -177,7 +205,7 @@ module Sass::Tree
     # @param environment [Sass::Environment] The lexical environment containing
     #   variable and mixin values
     def perform!(environment)
-      @parsed_rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      @parsed_rules = parse_selector(run_interp(@rule, environment))
       super
     end
 
@@ -226,32 +254,29 @@ module Sass::Tree
 
     def resolve_parent_refs(super_rules)
       if super_rules.nil?
-        return @parsed_rules.map do |line|
-          line.map do |rule|
-            if rule.include?(:parent)
-              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.")
-            end
+        return @parsed_rules.map do |rule|
+          if rule.include?(:parent)
+            raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.")
+          end
 
-            rule.join
-          end.compact
+          rule.join
         end
       end
 
       new_rules = []
-      super_rules.each do |super_line|
-        @parsed_rules.each do |line|
+      super_rules.each do |super_rule|
+        @parsed_rules.each do |rule|
           new_rules << []
 
-          super_line.each do |super_rule|
-            line.each do |rule|
-              rule = [:parent, " ", *rule] unless rule.include?(:parent)
+          # An initial newline of the child rule
+          # should be moved to the beginning of the entire rule
+          rule.first.slice!(0) if nl = (rule.first.is_a?(String) && rule.first[0] == ?\n)
+          rule = [nl ? "\n" : "", :parent, " ", *rule] unless rule.include?(:parent)
 
-              new_rules.last << rule.map do |segment|
-                next segment unless segment == :parent
-                super_rule
-              end.join
-            end
-          end
+          new_rules.last << rule.map do |segment|
+            next segment unless segment == :parent
+            super_rule
+          end.join
         end
       end
       new_rules
@@ -267,7 +292,10 @@ module Sass::Tree
         when '&'; rules.last << :parent
         when ','
           scanner.scan(/\s*/)
-          rules << [] if scanner.rest?
+          if scanner.rest?
+            rules << []
+            rules.last << "\n" if scanner.matched.include?("\n")
+          end
         when '"'
           rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
           # We don't want to enforce that strings are closed,
@@ -286,11 +314,11 @@ module Sass::Tree
     def debug_info_rule
       node = DirectiveNode.new("@media -sass-debug-info")
       debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
-        rule = RuleNode.new(nil)
+        rule = RuleNode.new([""])
         rule.resolved_rules = [[k.to_s.gsub(/[^\w-]/, "\\\\\\0")]]
-        val = v.to_s.gsub(/[^\w-]/, "\\\\\\0").
-          gsub(/^[\d-]/) {|c| "\\%04x " % Haml::Util.ord(c)}
-        prop = PropNode.new("font-family", val, :new)
+        prop = PropNode.new("", "", :new)
+        prop.resolved_name = "font-family"
+        prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
         rule << prop
         node << rule
       end

data/lib/sass/tree/variable_node.rb

@@ -16,17 +16,21 @@ module Sass
 
       protected
 
+      def to_src(tabs, opts, fmt)
+        "#{'  ' * tabs}$#{@name}: #{@expr.to_sass}#{' !default' if @guarded}#{semi fmt}\n"
+      end
+
       # Loads the new variable value into the environment.
       #
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
       def _perform(environment)
-        if @guarded && environment.var(@name).nil?
-          environment.set_var(@name, @expr.perform(environment))
-        elsif !@guarded
-          environment.set_var(@name, @expr.perform(environment))
+        return [] if @guarded && !environment.var(@name).nil?
+        val = @expr.perform(environment)
+        if @expr.context == :equals && val.is_a?(Sass::Script::String)
+          val = Sass::Script::String.new(val.value)
         end
-
+        environment.set_var(@name, val)
         []
       end
     end

data/lib/sass/tree/while_node.rb

@@ -13,6 +13,10 @@ module Sass::Tree
 
     protected
 
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@while #{@expr.to_sass}" + children_to_src(tabs, opts, fmt)
+    end
+
     # Runs the child nodes until the continue expression becomes false.
     #
     # @param environment [Sass::Environment] The lexical environment containing

data/test/haml/results/filters.xhtml

@@ -1,6 +1,6 @@
 <style>
   /* line 1 */
-  p { border-style: dotted; border-width: 22px; border-color: #ff00ff; }
+  p { border-style: dotted; border-width: 22px; border-color: fuchsia; }
   
   /* line 6 */
   h1 { font-weight: normal; }

data/test/haml/util_test.rb

@@ -66,6 +66,15 @@ class UtilTest < Test::Unit::TestCase
       merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))
   end
 
+  def test_strip_string_array
+    assert_equal(["foo ", " bar ", " baz"],
+      strip_string_array([" foo ", " bar ", " baz "]))
+    assert_equal([:foo, " bar ", " baz"],
+      strip_string_array([:foo, " bar ", " baz "]))
+    assert_equal(["foo ", " bar ", :baz],
+      strip_string_array([" foo ", " bar ", :baz]))
+  end
+
   def test_silence_warnings
     old_stderr, $stderr = $stderr, StringIO.new
     warn "Out"
@@ -76,6 +85,20 @@ class UtilTest < Test::Unit::TestCase
     $stderr = old_stderr
   end
 
+  def test_haml_warn
+    assert_warning("Foo!") {haml_warn "Foo!"}
+  end
+
+  def test_silence_haml_warnings
+    old_stderr, $stderr = $stderr, StringIO.new
+    silence_haml_warnings {warn "Out"}
+    assert_equal("Out\n", $stderr.string)
+    silence_haml_warnings {haml_warn "In"}
+    assert_equal("Out\n", $stderr.string)
+  ensure
+    $stderr = old_stderr
+  end
+
   def test_has
     assert(has?(:instance_method, String, :chomp!))
     assert(has?(:private_instance_method, Haml::Engine, :set_locals))
@@ -86,6 +109,11 @@ class UtilTest < Test::Unit::TestCase
       enum_with_index(%w[foo bar baz]).map {|s, i| "#{s}#{i}"})
   end
 
+  def test_enum_cons
+    assert_equal(%w[foobar barbaz],
+      enum_cons(%w[foo bar baz], 2).map {|s1, s2| "#{s1}#{s2}"})
+  end
+
   def test_ord
     assert_equal(102, ord("f"))
     assert_equal(98, ord("bar"))

data/test/sass/conversion_test.rb

@@ -0,0 +1,884 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ConversionTest < Test::Unit::TestCase
+  def test_basic
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz: bang
+  bip: bop
+SASS
+foo bar {
+  baz: bang;
+  bip: bop; }
+SCSS
+    assert_renders <<SASS, <<SCSS, :old => true
+foo bar
+  :baz bang
+  :bip bop
+SASS
+foo bar {
+  baz: bang;
+  bip: bop; }
+SCSS
+  end
+
+  def test_nesting
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz bang
+    baz: bang
+    bip: bop
+  blat: boo
+SASS
+foo bar {
+  baz bang {
+    baz: bang;
+    bip: bop; }
+  blat: boo; }
+SCSS
+  end
+
+  def test_nesting_with_parent_ref
+    assert_renders <<SASS, <<SCSS
+foo bar
+  &:hover
+    baz: bang
+SASS
+foo bar {
+  &:hover {
+    baz: bang; } }
+SCSS
+  end
+
+  def test_selector_interpolation
+    assert_renders <<SASS, <<SCSS
+foo \#{$bar + "baz"}.bip
+  baz: bang
+SASS
+foo \#{$bar + "baz"}.bip {
+  baz: bang; }
+SCSS
+  end
+
+  def test_multiline_selector_with_commas
+    assert_renders <<SASS, <<SCSS
+foo bar,
+baz bang
+  baz: bang
+SASS
+foo bar,
+baz bang {
+  baz: bang; }
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+blat
+  foo bar,
+  baz bang
+    baz: bang
+SASS
+blat {
+  foo bar,
+  baz bang {
+    baz: bang; } }
+SCSS
+  end
+
+  def test_multiline_selector_without_commas
+    assert_scss_to_sass <<SASS, <<SCSS
+foo bar baz bang
+  baz: bang
+SASS
+foo bar
+baz bang {
+  baz: bang; }
+SCSS
+
+    assert_scss_to_scss <<SCSS
+foo bar
+baz bang {
+  baz: bang; }
+SCSS
+  end
+
+  def test_escaped_selector
+    assert_renders <<SASS, <<SCSS
+foo bar
+  \\:hover
+    baz: bang
+SASS
+foo bar {
+  :hover {
+    baz: bang; } }
+SCSS
+  end
+
+  def test_property_name_interpolation
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz\#{$bang}bip\#{$bop}: 12
+SASS
+foo bar {
+  baz\#{$bang}bip\#{$bop}: 12; }
+SCSS
+  end
+
+  def test_property_name_interpolation
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz\#{$bang}bip\#{$bop}: 12
+SASS
+foo bar {
+  baz\#{$bang}bip\#{$bop}: 12; }
+SCSS
+  end
+
+  def test_property_value_interpolation
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz: 12 \#{$bang} bip \#{"bop"} blat
+SASS
+foo bar {
+  baz: 12 \#{$bang} bip \#{"bop"} blat; }
+SCSS
+  end
+
+  def test_dynamic_properties
+    assert_renders <<SASS, <<SCSS
+foo bar
+  baz: 12 $bang "bip"
+SASS
+foo bar {
+  baz: 12 $bang "bip"; }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+foo bar {
+  baz: 12 $bang bip; }
+SCSS
+foo bar
+  baz= 12 $bang "bip"
+SASS
+  end
+
+  def test_dynamic_properties_with_old
+    assert_renders <<SASS, <<SCSS, :old => true
+foo bar
+  :baz 12 $bang "bip"
+SASS
+foo bar {
+  baz: 12 $bang "bip"; }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS, :old => true
+foo bar {
+  baz: 12 $bang bip; }
+SCSS
+foo bar
+  :baz= 12 $bang "bip"
+SASS
+  end
+
+  def test_multiline_properties
+    assert_scss_to_sass <<SASS, <<SCSS
+foo bar
+  baz: bip bam boon
+SASS
+foo bar {
+  baz:
+    bip
+  bam
+        boon; }
+SCSS
+
+    assert_scss_to_scss <<OUT, <<IN
+foo bar {
+  baz: bip bam boon; }
+OUT
+foo bar {
+  baz:
+    bip
+  bam
+        boon; }
+IN
+  end
+
+  def test_multiline_dynamic_properties
+    assert_scss_to_sass <<SASS, <<SCSS
+foo bar
+  baz: $bip "bam" 12px
+SASS
+foo bar {
+  baz:
+    $bip
+  "bam"
+        12px; }
+SCSS
+
+    assert_scss_to_scss <<OUT, <<IN
+foo bar {
+  baz: $bip "bam" 12px; }
+OUT
+foo bar {
+  baz:
+    $bip
+  "bam"
+        12px; }
+IN
+  end
+
+  def test_silent_comments
+    assert_renders <<SASS, <<SCSS
+// foo
+
+// bar
+
+// baz
+
+foo bar
+  a: b
+SASS
+// foo
+
+// bar
+
+// baz
+
+foo bar {
+  a: b; }
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+// foo
+   bar
+     baz
+   bang
+
+foo bar
+  a: b
+SASS
+// foo
+// bar
+//   baz
+// bang
+
+foo bar {
+  a: b; }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+// foo
+// bar
+//   baz
+// bang
+
+foo bar {
+  a: b; }
+SCSS
+// foo
+// bar
+//   baz
+// bang
+
+foo bar
+  a: b
+SASS
+  end
+
+  def test_loud_comments
+    assert_renders <<SASS, <<SCSS
+/* foo
+
+/* bar
+
+/* baz
+
+foo bar
+  a: b
+SASS
+/* foo */
+
+/* bar */
+
+/* baz */
+
+foo bar {
+  a: b; }
+SCSS
+
+    assert_scss_to_sass <<SASS, <<SCSS
+/* foo
+   bar
+     baz
+   bang
+
+foo bar
+  a: b
+SASS
+/* foo
+   bar
+     baz
+   bang */
+
+foo bar {
+  a: b; }
+SCSS
+
+    assert_scss_to_scss <<SCSS
+/* foo
+   bar
+     baz
+   bang */
+
+foo bar {
+  a: b; }
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+/* foo
+   bar
+     baz
+   bang
+
+foo bar
+  a: b
+SASS
+/* foo
+ * bar
+ *   baz
+ * bang */
+
+foo bar {
+  a: b; }
+SCSS
+  end
+
+  def test_loud_comments_with_weird_indentation
+    assert_scss_to_sass <<SASS, <<SCSS
+foo
+  /*      foo
+     bar
+         baz
+  a: b
+SASS
+foo {
+  /* foo
+bar
+    baz */
+  a: b; }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+foo {
+  /*      foo
+   * bar
+   *     baz */
+  a: b; }
+SCSS
+foo
+  /*      foo
+     bar
+         baz
+  a: b
+SASS
+  end
+
+  def test_immediately_preceding_comments
+    assert_renders <<SASS, <<SCSS
+/* Foo
+   Bar
+   Baz
+.foo#bar
+  a: b
+SASS
+/* Foo
+ * Bar
+ * Baz */
+.foo#bar {
+  a: b; }
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+// Foo
+   Bar
+   Baz
+=foo
+  a: b
+SASS
+// Foo
+// Bar
+// Baz
+@mixin foo {
+  a: b; }
+SCSS
+  end
+
+  def test_debug
+    assert_renders <<SASS, <<SCSS
+foo
+  @debug 12px
+  bar: baz
+SASS
+foo {
+  @debug 12px;
+  bar: baz; }
+SCSS
+  end
+
+  def test_directive_without_children
+    assert_renders <<SASS, <<SCSS
+foo
+  @foo #bar "baz"
+  bar: baz
+SASS
+foo {
+  @foo #bar "baz";
+  bar: baz; }
+SCSS
+  end
+
+  def test_directive_with_prop_children
+    assert_renders <<SASS, <<SCSS
+foo
+  @foo #bar "baz"
+    a: b
+    c: d
+
+  bar: baz
+SASS
+foo {
+  @foo #bar "baz" {
+    a: b;
+    c: d; }
+
+  bar: baz; }
+SCSS
+  end
+
+  def test_directive_with_rule_children
+    assert_renders <<SASS, <<SCSS
+foo
+  @foo #bar "baz"
+    #blat
+      a: b
+    .bang
+      c: d
+      e: f
+
+  bar: baz
+SASS
+foo {
+  @foo #bar "baz" {
+    #blat {
+      a: b; }
+    .bang {
+      c: d;
+      e: f; } }
+
+  bar: baz; }
+SCSS
+  end
+
+  def test_directive_with_rule_and_prop_children
+    assert_renders <<SASS, <<SCSS
+foo
+  @foo #bar "baz"
+    g: h
+    #blat
+      a: b
+    .bang
+      c: d
+      e: f
+    i: j
+
+  bar: baz
+SASS
+foo {
+  @foo #bar "baz" {
+    g: h;
+    #blat {
+      a: b; }
+    .bang {
+      c: d;
+      e: f; }
+    i: j; }
+
+  bar: baz; }
+SCSS
+  end
+
+  def test_for
+    assert_renders <<SASS, <<SCSS
+foo
+  @for $a from $b to $c
+    a: b
+  @for $c from 1 to 16
+    d: e
+    f: g
+SASS
+foo {
+  @for $a from $b to $c {
+    a: b; }
+  @for $c from 1 to 16 {
+    d: e;
+    f: g; } }
+SCSS
+  end
+
+  def test_while
+    assert_renders <<SASS, <<SCSS
+foo
+  @while flaz($a + $b)
+    a: b
+  @while 1
+    d: e
+    f: g
+SASS
+foo {
+  @while flaz($a + $b) {
+    a: b; }
+  @while 1 {
+    d: e;
+    f: g; } }
+SCSS
+  end
+
+  def test_if
+    assert_renders <<SASS, <<SCSS
+foo
+  @if $foo or $bar
+    a: b
+  @if $baz
+    d: e
+  @else if $bang
+    f: g
+  @else
+    h: i
+SASS
+foo {
+  @if $foo or $bar {
+    a: b; }
+  @if $baz {
+    d: e; }
+  @else if $bang {
+    f: g; }
+  @else {
+    h: i; } }
+SCSS
+  end
+
+  def test_import
+    assert_renders <<SASS, <<SCSS
+@import foo
+
+foo
+  bar: baz
+SASS
+@import "foo";
+
+foo {
+  bar: baz; }
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+@import foo.css
+
+foo
+  bar: baz
+SASS
+@import "foo.css";
+
+foo {
+  bar: baz; }
+SCSS
+  end
+
+  def test_import_as_directive_in_sass
+    assert_sass_to_sass '@import "foo.css"'
+    assert_sass_to_sass '@import url(foo.css)'
+  end
+
+  def test_import_as_directive_in_scss
+    assert_renders <<SASS, <<SCSS
+@import "foo.css" print
+SASS
+@import "foo.css" print;
+SCSS
+
+    assert_renders <<SASS, <<SCSS
+@import url(foo.css) screen, print
+SASS
+@import url(foo.css) screen, print;
+SCSS
+  end
+
+  def test_adjacent_imports
+    assert_renders <<SASS, <<SCSS
+@import foo.sass
+@import bar.scss
+@import baz
+SASS
+@import "foo.sass";
+@import "bar.scss";
+@import "baz";
+SCSS
+  end
+
+  def test_non_adjacent_imports
+    assert_renders <<SASS, <<SCSS
+@import foo.sass
+
+@import bar.scss
+
+@import baz
+SASS
+@import "foo.sass";
+
+@import "bar.scss";
+
+@import "baz";
+SCSS
+  end
+
+  def test_argless_mixin_definition
+    assert_renders <<SASS, <<SCSS
+=foo-bar
+  baz
+    a: b
+SASS
+@mixin foo-bar {
+  baz {
+    a: b; } }
+SCSS
+
+    assert_scss_to_sass <<SASS, <<SCSS
+=foo-bar
+  baz
+    a: b
+SASS
+@mixin foo-bar() {
+  baz {
+    a: b; } }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+@mixin foo-bar {
+  baz {
+    a: b; } }
+SCSS
+=foo-bar()
+  baz
+    a: b
+SASS
+  end
+
+  def test_mixin_definition_without_defaults
+    assert_renders <<SASS, <<SCSS
+=foo-bar($baz, $bang)
+  baz
+    a: $baz $bang
+SASS
+@mixin foo-bar($baz, $bang) {
+  baz {
+    a: $baz $bang; } }
+SCSS
+  end
+
+  def test_mixin_definition_with_defaults
+    assert_renders <<SASS, <<SCSS
+=foo-bar($baz, $bang: 12px)
+  baz
+    a: $baz $bang
+SASS
+@mixin foo-bar($baz, $bang: 12px) {
+  baz {
+    a: $baz $bang; } }
+SCSS
+
+    assert_scss_to_sass <<SASS, <<SCSS
+=foo-bar($baz, $bang: foo)
+  baz
+    a: $baz $bang
+SASS
+@mixin foo-bar($baz, $bang = "foo") {
+  baz {
+    a: $baz $bang; } }
+SCSS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+@mixin foo-bar($baz, $bang: foo) {
+  baz {
+    a: $baz $bang; } }
+SCSS
+=foo-bar($baz, $bang = "foo")
+  baz
+    a: $baz $bang
+SASS
+  end
+
+  def test_argless_mixin_include
+    assert_renders <<SASS, <<SCSS
+foo
+  +foo-bar
+  a: blip
+SASS
+foo {
+  @include foo-bar;
+  a: blip; }
+SCSS
+  end
+
+  def test_mixin_include
+    assert_renders <<SASS, <<SCSS
+foo
+  +foo-bar(12px, "blaz")
+  a: blip
+SASS
+foo {
+  @include foo-bar(12px, "blaz");
+  a: blip; }
+SCSS
+  end
+
+  def test_variable_definition
+    assert_renders <<SASS, <<SCSS
+$var1: 12px + 15px
+
+foo
+  $var2: flaz(#abcdef)
+  val: $var1 $var2
+SASS
+$var1: 12px + 15px;
+
+foo {
+  $var2: flaz(#abcdef);
+  val: $var1 $var2; }
+SCSS
+
+    assert_sass_to_scss '$var: 12px $bar baz;', '$var = 12px $bar "baz"'
+  end
+
+  def test_guarded_variable_definition
+    assert_renders <<SASS, <<SCSS
+$var1: 12px + 15px !default
+
+foo
+  $var2: flaz(#abcdef) !default
+  val: $var1 $var2
+SASS
+$var1: 12px + 15px !default;
+
+foo {
+  $var2: flaz(#abcdef) !default;
+  val: $var1 $var2; }
+SCSS
+
+    assert_sass_to_scss '$var: 12px $bar baz !default;', '$var ||= 12px $bar "baz"'
+  end
+
+  # Sass 3 Deprecation conversions
+
+  def test_simple_quoted_strings_unquoted_with_equals
+    assert_sass_to_scss '$var: 1px foo + bar baz;', '!var = 1px "foo" + "bar" baz'
+    assert_sass_to_scss '$var: -foo-bar;', '!var = "-foo-bar"'
+  end
+
+  def test_complex_quoted_strings_explicitly_unquoted_with_equals
+    assert_sass_to_scss '$var: 1px unquote("foo + bar") baz;', '!var = 1px "foo + bar" baz'
+    assert_sass_to_scss "$var: unquote('foo\"bar');", '!var = "foo\"bar"'
+  end
+
+  def test_division_asserted_with_equals
+    assert_sass_to_scss <<SCSS, <<SASS
+foo {
+  a: (1px / 2px); }
+SCSS
+foo
+  a = 1px / 2px
+SASS
+  end
+
+  def test_division_not_asserted_with_equals_when_unnecessary
+    assert_sass_to_scss <<SCSS, <<SASS
+$var: 1px / 2px;
+
+foo {
+  a: $var; }
+SCSS
+!var = 1px / 2px
+
+foo
+  a = !var
+SASS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+$var: 1px;
+
+foo {
+  a: $var / 2px; }
+SCSS
+!var = 1px
+
+foo
+  a = !var / 2px
+SASS
+
+    assert_sass_to_scss <<SCSS, <<SASS
+foo {
+  a: 1 + 1px / 2px; }
+SCSS
+foo
+  a = 1 + 1px / 2px
+SASS
+  end
+
+  private
+
+  def assert_sass_to_sass(sass, options = {})
+    assert_equal(sass.rstrip, to_sass(sass, options).rstrip,
+      "Expected Sass to transform to itself")
+  end
+
+  def assert_scss_to_sass(sass, scss, options = {})
+    assert_equal(sass.rstrip, to_sass(scss, options.merge(:syntax => :scss)).rstrip,
+      "Expected SCSS to transform to Sass")
+  end
+
+  def assert_scss_to_scss(scss, in_scss = nil, options = nil)
+    if in_scss.is_a?(Hash)
+      options = in_scss
+      in_scss = nil
+    end
+
+    in_scss ||= scss
+    options ||= {}
+
+    assert_equal(scss.rstrip, to_scss(in_scss, options.merge(:syntax => :scss)).rstrip,
+      "Expected SCSS to transform to #{scss == in_scss ? 'itself' : 'SCSS'}k")
+  end
+
+  def assert_sass_to_scss(scss, sass, options = {})
+    assert_equal(scss.rstrip, to_scss(sass, options).rstrip,
+      "Expected Sass to transform to SCSS")
+  end
+
+  def assert_renders(sass, scss, options = {})
+    assert_sass_to_sass(sass, options)
+    assert_scss_to_sass(sass, scss, options)
+    assert_scss_to_scss(scss, options)
+    assert_sass_to_scss(scss, sass, options)
+  end
+
+  def to_sass(scss, options = {})
+    Haml::Util.silence_haml_warnings do
+      Sass::Engine.new(scss, options).to_tree.to_sass(options)
+    end
+  end
+
+  def to_scss(sass, options = {})
+    Haml::Util.silence_haml_warnings do
+      Sass::Engine.new(sass, options).to_tree.to_scss(options)
+    end
+  end
+end