haml-edge 2.3.209 → 2.3.210

data/test/haml/util/subset_map_test.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class SubsetMapTest < Test::Unit::TestCase
+  def setup
+    @ssm = Haml::Util::SubsetMap.new
+    @ssm[Set[1, 2]] = "Foo"
+    @ssm[Set["fizz", "fazz"]] = "Bar"
+
+    @ssm[Set[:foo, :bar]] = "Baz"
+    @ssm[Set[:foo, :bar, :baz]] = "Bang"
+
+    @ssm[Set[:bip, :bop, :blip]] = "Qux"
+    @ssm[Set[:bip, :bop]] = "Thram"
+  end
+
+  def test_equal_keys
+    assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2])
+    assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz"])
+  end
+
+  def test_subset_keys
+    assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2, "fuzz"])
+    assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz", 3])
+  end
+
+  def test_superset_keys
+    assert_equal [], @ssm.get(Set[1])
+    assert_equal [], @ssm.get(Set[2])
+    assert_equal [], @ssm.get(Set["fizz"])
+    assert_equal [], @ssm.get(Set["fazz"])
+  end
+
+  def test_disjoint_keys
+    assert_equal [], @ssm.get(Set[3, 4])
+    assert_equal [], @ssm.get(Set["fuzz", "frizz"])
+    assert_equal [], @ssm.get(Set["gran", 15])
+  end
+
+  def test_semi_disjoint_keys
+    assert_equal [], @ssm.get(Set[2, 3])
+    assert_equal [], @ssm.get(Set["fizz", "fuzz"])
+    assert_equal [], @ssm.get(Set[1, "fazz"])
+  end
+
+  def test_empty_key_set
+    assert_raise(ArgumentError) {@ssm[Set[]] = "Fail"}
+  end
+
+  def test_empty_key_get
+    assert_equal [], @ssm.get(Set[])
+  end
+
+  def test_multiple_subsets
+    assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, "fizz", "fazz"])
+    assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, 3, "fizz", "fazz", "fuzz"])
+
+    assert_equal [["Baz", Set[:foo, :bar]]], @ssm.get(Set[:foo, :bar])
+    assert_equal [["Baz", Set[:foo, :bar]], ["Bang", Set[:foo, :bar, :baz]]], @ssm.get(Set[:foo, :bar, :baz])
+  end
+
+  def test_bracket_bracket
+    assert_equal ["Foo"], @ssm[Set[1, 2, "fuzz"]]
+    assert_equal ["Baz", "Bang"], @ssm[Set[:foo, :bar, :baz]]
+  end
+
+  def test_order_preserved
+    @ssm[Set[10, 11, 12]] = 1
+    @ssm[Set[10, 11]] = 2
+    @ssm[Set[11]] = 3
+    @ssm[Set[11, 12]] = 4
+    @ssm[Set[9, 10, 11, 12, 13]] = 5
+    @ssm[Set[10, 13]] = 6
+
+    assert_equal(
+      [[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]],
+        [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]],
+      @ssm.get(Set[9, 10, 11, 12, 13]))
+  end
+
+  def test_multiple_equal_values
+    @ssm[Set[11, 12]] = 1
+    @ssm[Set[12, 13]] = 2
+    @ssm[Set[13, 14]] = 1
+    @ssm[Set[14, 15]] = 1
+
+    assert_equal(
+      [[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]],
+      @ssm.get(Set[11, 12, 13, 14, 15]))
+  end
+end

data/test/haml/util_test.rb

@@ -66,6 +66,24 @@ class UtilTest < Test::Unit::TestCase
       merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))
   end
 
+  def test_intersperse
+    assert_equal(["foo", " ", "bar", " ", "baz"],
+      intersperse(%w[foo bar baz], " "))
+    assert_equal([], intersperse([], " "))
+  end
+
+  def test_substitute
+    assert_equal(["foo", "bar", "baz", 3, 4],
+      substitute([1, 2, 3, 4], [1, 2], ["foo", "bar", "baz"]))
+    assert_equal([1, "foo", "bar", "baz", 4],
+      substitute([1, 2, 3, 4], [2, 3], ["foo", "bar", "baz"]))
+    assert_equal([1, 2, "foo", "bar", "baz"],
+      substitute([1, 2, 3, 4], [3, 4], ["foo", "bar", "baz"]))
+
+    assert_equal([1, "foo", "bar", "baz", 2, 3, 4],
+      substitute([1, 2, 2, 2, 3, 4], [2, 2], ["foo", "bar", "baz"]))
+  end
+
   def test_strip_string_array
     assert_equal(["foo ", " bar ", " baz"],
       strip_string_array([" foo ", " bar ", " baz "]))
@@ -75,6 +93,13 @@ class UtilTest < Test::Unit::TestCase
       strip_string_array([" foo ", " bar ", :baz]))
   end
 
+  def test_paths
+    assert_equal([[1, 3, 5], [2, 3, 5], [1, 4, 5], [2, 4, 5]],
+      paths([[1, 2], [3, 4], [5]]))
+    assert_equal([[]], paths([]))
+    assert_equal([[1, 2, 3]], paths([[1], [2], [3]]))
+  end
+
   def test_silence_warnings
     old_stderr, $stderr = $stderr, StringIO.new
     warn "Out"

data/test/sass/conversion_test.rb

@@ -183,7 +183,7 @@ SASS
   def test_multiline_properties
     assert_scss_to_sass <<SASS, <<SCSS
 foo bar
-  baz: bip bam boon
+  baz: bip   bam         boon
 SASS
 foo bar {
   baz:
@@ -194,7 +194,7 @@ SCSS
 
     assert_scss_to_scss <<OUT, <<IN
 foo bar {
-  baz: bip bam boon; }
+  baz: bip   bam         boon; }
 OUT
 foo bar {
   baz:
@@ -915,7 +915,7 @@ SCSS
     assert_selector_renders['> E']
     assert_selector_renders['+ E']
     assert_selector_renders['~ E']
-    assert_selector_renders['>> E']
+    assert_selector_renders['> > E']
 
     assert_selector_renders['E*']
     assert_selector_renders['E*.foo']
@@ -1031,6 +1031,26 @@ div
 SASS
   end
 
+  def test_sass2_var_in_property_interpolation
+assert_sass_to_scss <<SCSS, <<SASS
+foo {
+  a: b \#{$c} d; }
+SCSS
+foo
+  a: b \#{!c} d
+SASS
+  end
+
+  def test_sass2_var_in_selector_interpolation
+assert_sass_to_scss <<SCSS, <<SASS
+foo-\#{$c} {
+  a: b; }
+SCSS
+foo-\#{!c}
+  a: b
+SASS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/engine_test.rb

@@ -592,6 +592,36 @@ END
     assert_equal("@a{b:c;#d{e:f}g:h}\n", render(to_render, :style => :compressed))
   end
 
+  def test_property_hacks
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  _name: val;
+  *name: val;
+  #name: val;
+  .name: val;
+  name: val; }
+CSS
+foo
+  _name: val
+  *name: val
+  #name: val
+  .name: val
+  name: val
+SASS
+  end
+
+  def test_properties_with_space_after_colon
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  bar: baz;
+  bizz: bap; }
+CSS
+foo
+  bar : baz
+  bizz	: bap
+SASS
+  end
+
   def test_line_annotations
     assert_equal(<<CSS, render(<<SASS, :line_comments => true, :style => :compact))
 /* line 2, test_line_annotations_inline.sass */
@@ -980,6 +1010,19 @@ a-\#{$a}
 SASS
   end
 
+  def test_complex_property_interpolation
+    assert_equal(<<CSS, render(<<SASS))
+a-1 {
+  b-2 3-fizzap18: c-3; }
+CSS
+$a: 1
+$b: 2
+$c: 3
+a-\#{$a}
+  b-\#{$b $c}-\#{fizzap + ($c + 15)}: c-\#{$a + $b}
+SASS
+  end
+
   def test_if_directive
     assert_equal("a {\n  b: 1; }\n", render(<<SASS))
 $var: true
@@ -994,16 +1037,16 @@ SASS
   def test_for
     assert_equal(<<CSS, render(<<SASS))
 a-0 {
-  2i: 0; }
+  two-i: 0; }
 
 a-1 {
-  2i: 2; }
+  two-i: 2; }
 
 a-2 {
-  2i: 4; }
+  two-i: 4; }
 
 a-3 {
-  2i: 6; }
+  two-i: 6; }
 
 b-1 {
   j-1: 0; }
@@ -1020,7 +1063,7 @@ CSS
 $a: 3
 @for $i from 0 to $a + 1
   a-\#{$i}
-    2i: 2 * $i
+    two-i: 2 * $i
 
 @for $j from 1 through 4
   b-\#{$j}
@@ -1348,7 +1391,7 @@ SASS
 
   def test_attribute_selector_with_spaces
     assert_equal(<<CSS, render(<<SASS))
-a b[foo = bar] {
+a b[foo=bar] {
   c: d; }
 CSS
 a
@@ -1542,7 +1585,7 @@ SASS
 
   def test_interpolation_doesnt_deep_unquote_strings
     assert_equal(<<CSS, render(<<SASS))
-.foo-"bar" "baz" {
+.foo- "bar" "baz" {
   a: b; }
 CSS
 .foo-\#{"bar" "baz"}