sass 3.3.0.rc.2 → 3.3.0.rc.3

data/lib/sass/tree/visitors/deep_copy.rb

@@ -1,6 +1,5 @@
 # A visitor for copying the full structure of a Sass tree.
 class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
-
   protected
 
   def visit(node)

data/lib/sass/tree/visitors/perform.rb

@@ -55,15 +55,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
         splat_sep = splat.separator
       end
 
-      keywords = keywords.dup
       env = Sass::Environment.new(callable.environment)
       callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
-        if value && keywords.include?(var.underscored_name)
+        if value && keywords.has_key?(var.name)
           raise Sass::SyntaxError.new("#{desc} was passed argument $#{var.name} " +
                                       "both by position and by name.")
         end
 
-        value ||= keywords.delete(var.underscored_name)
+        value ||= keywords.delete(var.name)
         value ||= default && default.perform(env)
         raise Sass::SyntaxError.new("#{desc} is missing argument #{var.inspect}.") unless value
         env.set_local_var(var.name, value)
@@ -71,7 +70,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
       if callable.splat
         rest = args[callable.args.length..-1] || []
-        arg_list = Sass::Script::Value::ArgList.new(rest, keywords.dup, splat_sep)
+        arg_list = Sass::Script::Value::ArgList.new(rest, keywords, splat_sep)
         arg_list.options = env.options
         env.set_local_var(callable.splat.name, arg_list)
       end
@@ -113,7 +112,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
           args = splat.to_a
         end
       end
-      kwargs ||= Sass::Util.ordered_hash
+      kwargs ||= Sass::Util::NormalizedMap.new
       kwargs.update(performed_keywords)
 
       if kwarg_splat
@@ -243,12 +242,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     to.assert_int!
 
     to = to.coerce(from.numerator_units, from.denominator_units)
-    range = Range.new(from.to_i, to.to_i, node.exclusive)
+    direction = from.to_i > to.to_i ? -1 : 1
+    range = Range.new(direction * from.to_i, direction * to.to_i, node.exclusive)
 
     with_environment Sass::Environment.new(@environment) do
       range.map do |i|
         @environment.set_local_var(node.var,
-          Sass::Script::Value::Number.new(i, from.numerator_units, from.denominator_units))
+          Sass::Script::Value::Number.new(direction * i,
+            from.numerator_units, from.denominator_units))
         node.children.map {|c| visit(c)}
       end.flatten
     end
@@ -314,12 +315,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   # Runs a mixin.
   def visit_mixin(node)
-    include_loop = true
-    if @environment.stack.frames.any? {|f| f.is_mixin? && f.name == node.name}
-      handle_include_loop!(node)
-    end
-    include_loop = false
-
     @environment.stack.with_mixin(node.filename, node.line, node.name) do
       mixin = @environment.mixin(node.name)
       raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin
@@ -342,10 +337,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       end
     end
   rescue Sass::SyntaxError => e
-    unless include_loop
-      e.modify_backtrace(:mixin => node.name, :line => node.line)
-      e.add_backtrace(:line => node.line)
-    end
+    e.modify_backtrace(:mixin => node.name, :line => node.line)
+    e.add_backtrace(:line => node.line)
     raise e
   end
 
@@ -421,10 +414,12 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads the new variable value into the environment.
   def visit_variable(node)
     env = @environment
+    identifier = [node.name, node.filename, node.line]
     if node.global
       env = env.global_env
-    elsif env.parent && env.is_var_global?(node.name) && !node.global_warning_given
-      node.global_warning_given = true
+    elsif env.parent && env.is_var_global?(node.name) &&
+        !env.global_env.global_warning_given.include?(identifier)
+      env.global_env.global_warning_given.add(identifier)
       var_expr = "$#{node.name}: #{node.expr.to_sass(env.options)} !global"
       var_expr << " !default" if node.guarded
       location = "on line #{node.line}"
@@ -515,31 +510,6 @@ WARNING
     run_interp_no_strip(text).strip
   end
 
-  def handle_include_loop!(node)
-    msg = "An @include loop has been found:"
-    content_count = 0
-    mixins = @environment.stack.frames.select {|f| f.is_mixin?}.reverse!.map! {|f| f.name}
-    mixins = mixins.select do |name|
-      if name == '@content'
-        content_count += 1
-        false
-      elsif content_count > 0
-        content_count -= 1
-        false
-      else
-        true
-      end
-    end
-
-    return unless mixins.include?(node.name)
-    raise Sass::SyntaxError.new("#{msg} #{node.name} includes itself") if mixins.size == 1
-
-    msg << "\n" << Sass::Util.enum_cons(mixins.reverse + [node.name], 2).map do |m1, m2|
-      "    #{m1} includes #{m2}"
-    end.join("\n")
-    raise Sass::SyntaxError.new(msg)
-  end
-
   def handle_import_loop!(node)
     msg = "An @import loop has been found:"
     files = @environment.stack.frames.select {|f| f.is_import?}.map {|f| f.filename}.compact

data/lib/sass/util.rb

@@ -74,6 +74,7 @@ module Sass
       # We don't delegate to map_hash for performance here
       # because map_hash does more than is necessary.
       rv = hash.class.new
+      hash = hash.as_stored if hash.is_a?(NormalizedMap)
       hash.each do |k, v|
         rv[k] = yield(v)
       end
@@ -99,7 +100,7 @@ module Sass
       rv = hash.class.new
       hash.each do |k, v|
         new_key, new_value = yield(k, v)
-        rv.delete(k)
+        new_key = hash.denormalize(new_key) if hash.is_a?(NormalizedMap) && new_key == k
         rv[new_key] = new_value
       end
       rv
@@ -170,6 +171,19 @@ module Sass
       enum.inject([]) {|a, e| a << e << val}[0...-1]
     end
 
+    def slice_by(enum)
+      results = []
+      enum.each do |value|
+        key = yield(value)
+        if !results.empty? && results.last.first == key
+          results.last.last << value
+        else
+          results << [key, [value]]
+        end
+      end
+      results
+    end
+
     # Substitutes a sub-array of one array with another sub-array.
     #
     # @param ary [Array] The array in which to make the substitution
@@ -487,6 +501,15 @@ module Sass
       version_geq(ActionPack::VERSION::STRING, version)
     end
 
+    # Returns whether this environment is using Listen
+    # version 2.0.0 or greater.
+    #
+    # @return [Boolean]
+    def listen_geq_2?
+      require 'listen/version'
+      version_geq(::Listen::VERSION, '2.0.0')
+    end
+
     # Returns an ActionView::Template* class.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -537,15 +560,10 @@ module Sass
       @jruby = RUBY_PLATFORM =~ /java/
     end
 
-    # @see #jruby_version-class_method
-    def jruby_version
-      Sass::Util.jruby_version
-    end
-
     # Returns an array of ints representing the JRuby version number.
     #
     # @return [Array<Fixnum>]
-    def self.jruby_version
+    def jruby_version
       @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
     end
 
@@ -651,7 +669,6 @@ module Sass
       (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*flatten(pairs_or_hash, 1)]
     end
 
-
     # Checks that the encoding of a string is valid in Ruby 1.9
     # and cleans up potential encoding gotchas like the UTF-8 BOM.
     # If it's not, yields an error string describing the invalid character
@@ -844,6 +861,24 @@ MSG
       arr.inject([]) {|res, e| e.is_a?(Array) ? res.concat(flatten(e, n - 1)) : res << e}
     end
 
+    # Flattens the first level of nested arrays in `arrs`. Unlike
+    # `Array#flatten`, this orders the result by taking the first
+    # values from each array in order, then the second, and so on.
+    #
+    # @param arrs [Array] The array to flatten.
+    # @return [Array] The flattened array.
+    def flatten_vertically(arrs)
+      result = []
+      arrs = arrs.map {|sub| sub.is_a?(Array) ? sub.dup : Array(sub)}
+      until arrs.empty?
+        arrs.reject! do |arr|
+          result << arr.shift
+          arr.empty?
+        end
+      end
+      result
+    end
+
     # Returns the hash code for a set in a cross-version manner.
     # Aggravatingly, this is order-dependent in Ruby 1.8.6.
     #
@@ -1040,6 +1075,20 @@ MSG
       URI_ESCAPE.escape string
     end
 
+    # A cross-platform implementation of `File.absolute_path`.
+    #
+    # @param path [String]
+    # @param dir_string [String] The directory to consider [path] relative to.
+    # @return [String] The absolute version of `path`.
+    def absolute_path(path, dir_string = nil)
+      # Ruby 1.8 doesn't support File.absolute_path.
+      return File.absolute_path(path, dir_string) unless ruby1_8?
+
+      # File.expand_path expands "~", which we don't want.
+      return File.expand_path(path, dir_string) unless path[0] == ?~
+      File.expand_path(File.join(".", path), dir_string)
+    end
+
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.
@@ -1091,7 +1140,6 @@ MSG
 
     # rubocop:disable LineLength
 
-
     # Calculates the memoization table for the Least Common Subsequence algorithm.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS)
     def lcs_table(x, y)
@@ -1112,10 +1160,8 @@ MSG
       end
       c
     end
-
     # rubocop:disable ParameterLists, LineLength
 
-
     # Computes a single longest common subsequence for arrays x and y.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS)
     def lcs_backtrace(c, x, y, i, j, &block)
@@ -1129,9 +1175,10 @@ MSG
       lcs_backtrace(c, x, y, i - 1, j, &block)
     end
 
-    (Sass::Util.methods - Module.methods).each {|method| module_function method}
+    singleton_methods.each {|method| module_function method}
   end
 end
 
 require 'sass/util/multibyte_string_scanner'
 require 'sass/util/normalized_map'
+require 'sass/util/cross_platform_random'

data/lib/sass/util/cross_platform_random.rb

@@ -0,0 +1,19 @@
+module Sass
+  module Util
+    # Ruby 1.8 doesn't support an actual Random class with a settable seed.
+    class CrossPlatformRandom
+      def initialize(seed = nil)
+        if Sass::Util.ruby1_8?
+          srand(seed) if seed
+        else
+          @random = seed ? ::Random.new(seed) : ::Random.new
+        end
+      end
+
+      def rand(*args)
+        return @random.rand(*args) if @random
+        Kernel.rand(*args)
+      end
+    end
+  end
+end

data/lib/sass/util/normalized_map.rb

@@ -9,9 +9,11 @@ module Sass
     require 'sass/util/ordered_hash' if ruby1_8?
     class NormalizedMap
       # Create a normalized map
-      def initialize
+      def initialize(map = nil)
         @key_strings = {}
         @map = Util.ruby1_8? ? OrderedHash.new : {}
+
+        map.each {|key, value| self[key] = value} if map
       end
 
       # Specifies how to transform the key.
@@ -21,6 +23,15 @@ module Sass
         key.tr("-", "_")
       end
 
+      # Returns the version of `key` as it was stored before
+      # normalization. If `key` isn't in the map, returns it as it was
+      # passed in.
+      #
+      # @return [String]
+      def denormalize(key)
+        @key_strings[normalize(key)] || key
+      end
+
       # @private
       def []=(k, v)
         normalized = normalize(k)
@@ -93,6 +104,11 @@ module Sass
         @map.sort_by {|k, v| yield k, v}
       end
 
+      def update(map)
+        map = map.as_stored if map.is_a?(NormalizedMap)
+        map.each {|k, v| self[k] = v}
+      end
+
       def method_missing(method, *args, &block)
         if Sass.tests_running
           raise ArgumentError.new("The method #{method} must be implemented explicitly")

data/test/sass/compiler_test.rb

@@ -9,6 +9,7 @@ class CompilerTest < Test::Unit::TestCase
     attr_accessor :options
     attr_accessor :directories
     attr_reader :start_called
+    attr_reader :thread
 
     def initialize(*args, &on_filesystem_event)
       self.options = args.last.is_a?(Hash) ? args.pop : {}
@@ -39,10 +40,19 @@ class CompilerTest < Test::Unit::TestCase
       @run_during_start = run_during_start
     end
 
+    # used for Listen < 2.0
     def start!
       @run_during_start.call(self) if @run_during_start
     end
 
+    # used for Listen >= 2.0
+    def start
+      @thread = Thread.new {@run_during_start.call(self) if @run_during_start}
+    end
+
+    def stop
+    end
+
     def reset_events!
       @modified = []
       @added = []

data/test/sass/conversion_test.rb

@@ -499,6 +499,29 @@ foo
 SASS
   end
 
+  def test_loud_comment_containing_silent_comment
+    assert_scss_to_sass <<SASS, <<SCSS
+/*
+ *// foo bar
+SASS
+/*
+// foo bar
+*/
+SCSS
+  end
+
+  def test_silent_comment_containing_loud_comment
+    assert_scss_to_sass <<SASS, <<SCSS
+// /*
+//  * foo bar
+//  */
+SASS
+// /*
+//  * foo bar
+//  */
+SCSS
+  end
+
   def test_immediately_preceding_comments
     assert_renders <<SASS, <<SCSS
 /* Foo
@@ -1009,6 +1032,19 @@ foo {
 SCSS
   end
 
+  def test_mixin_include_with_hyphen_conversion_keyword_arg
+    assert_renders <<SASS, <<SCSS
+foo
+  +foo-bar($a-b_c: val)
+  a: blip
+SASS
+foo {
+  @include foo-bar($a-b_c: val);
+  a: blip;
+}
+SCSS
+  end
+
   def test_argless_function_definition
     assert_renders <<SASS, <<SCSS
 @function foo()

data/test/sass/css2sass_test.rb

@@ -265,6 +265,25 @@ CSS
 
   # Regressions
 
+  def test_empty_rule
+    assert_equal(<<SASS, css2sass(<<CSS))
+a
+SASS
+a {}
+CSS
+  end
+
+  def test_empty_rule_with_selector_combinator
+    assert_equal(<<SASS, css2sass(<<CSS))
+a
+  color: red
+  > b
+SASS
+a {color: red}
+a > b {}
+CSS
+  end
+
   def test_nesting_within_media
     assert_equal(<<SASS, css2sass(<<CSS))
 @media all

data/test/sass/engine_test.rb

@@ -67,7 +67,7 @@ MSG
     "$a: 1b <= 2c" => "Incompatible units: 'c' and 'b'.",
     "$a: 1b >= 2c" => "Incompatible units: 'c' and 'b'.",
     "a\n  b: 1b * 2c" => "2b*c isn't a valid CSS value.",
-    "a\n  b: 1b % 2c" => "Cannot modulo by a number with units: 2c.",
+    "a\n  b: 1b % 2c" => "Incompatible units: 'c' and 'b'.",
     "$a: 2px + #ccc" => "Cannot add a number with units (2px) to a color (#cccccc).",
     "$a: #ccc + 2px" => "Cannot add a number with units (2px) to a color (#cccccc).",
     "& a\n  :b c" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 1],
@@ -158,19 +158,19 @@ MSG
     "$var: true\n@while $var\n  @extend .bar\n  $var: false" => ["Extend directives may only be used within rules.", 3],
     "@for $i from 0 to 1\n  @extend .bar" => ["Extend directives may only be used within rules.", 2],
     "@mixin foo\n  @extend .bar\n@include foo" => ["Extend directives may only be used within rules.", 2],
-    "foo\n  &a\n    b: c" => ["Invalid CSS after \"&\": expected \"{\", was \"a\"\n\n\"a\" may only be used at the beginning of a compound selector.", 2],
-    "foo\n  &1\n    b: c" => ["Invalid CSS after \"&\": expected \"{\", was \"1\"\n\n\"1\" may only be used at the beginning of a compound selector.", 2],
     "foo %\n  a: b" => ['Invalid CSS after "foo %": expected placeholder name, was ""', 1],
     "=foo\n  @content error" => "Invalid content directive. Trailing characters found: \"error\".",
     "=foo\n  @content\n    b: c" => "Illegal nesting: Nothing may be nested beneath @content directives.",
     "@content" => '@content may only be used within a mixin.',
     "=simple\n  .simple\n    color: red\n+simple\n  color: blue" => ['Mixin "simple" does not accept a content block.', 4],
     "@import \"foo\" // bar" => "Invalid CSS after \"\"foo\" \": expected media query list, was \"// bar\"",
+    "@at-root\n  a: b" => "Properties are only allowed within rules, directives, mixin includes, or other properties.",
 
     # Regression tests
     "a\n  b:\n    c\n    d" => ["Illegal nesting: Only properties may be nested beneath properties.", 3],
     "& foo\n  bar: baz\n  blat: bang" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 1],
     "a\n  b: c\n& foo\n  bar: baz\n  blat: bang" => ["Base-level rules cannot contain the parent-selector-referencing character '&'.", 3],
+    "@" => "Invalid directive: '@'.",
   }
 
   def teardown
@@ -467,89 +467,25 @@ SASS
     assert_hash_has(err.sass_backtrace[4], :filename => nil, :mixin => nil, :line => 1)
   end
 
-  def test_basic_mixin_loop_exception
-    render <<SASS
-@mixin foo
-  @include foo
-@include foo
-SASS
-    assert(false, "Exception not raised")
-  rescue Sass::SyntaxError => err
-    assert_equal("An @include loop has been found: foo includes itself", err.message)
-    assert_hash_has(err.sass_backtrace[0], :mixin => "foo", :line => 2)
-  end
-
-  def test_double_mixin_loop_exception
-    render <<SASS
-@mixin foo
-  @include bar
-@mixin bar
-  @include foo
-@include foo
-SASS
-    assert(false, "Exception not raised")
-  rescue Sass::SyntaxError => err
-    assert_equal(<<MESSAGE.rstrip, err.message)
-An @include loop has been found:
-    foo includes bar
-    bar includes foo
-MESSAGE
-    assert_hash_has(err.sass_backtrace[0], :mixin => "bar", :line => 4)
-    assert_hash_has(err.sass_backtrace[1], :mixin => "foo", :line => 2)
-  end
-
-  def test_deep_mixin_loop_exception
-    render <<SASS
-@mixin foo
-  @include bar
-
-@mixin bar
-  @include baz
-
-@mixin baz
-  @include foo
+  def test_recursive_mixin
+    assert_equal <<CSS, render(<<SASS)
+.foo .bar .baz {
+  color: blue; }
+.foo .bar .qux {
+  color: red; }
+.foo .zap {
+  color: green; }
+CSS
+@mixin map-to-rule($map-or-color)
+  @if type-of($map-or-color) == map
+    @each $key, $value in $map-or-color
+      .\#{$key}
+        @include map-to-rule($value)
+  @else
+    color: $map-or-color
 
-@include foo
-SASS
-    assert(false, "Exception not raised")
-  rescue Sass::SyntaxError => err
-    assert_equal(<<MESSAGE.rstrip, err.message)
-An @include loop has been found:
-    foo includes bar
-    bar includes baz
-    baz includes foo
-MESSAGE
-    assert_hash_has(err.sass_backtrace[0], :mixin => "baz", :line => 8)
-    assert_hash_has(err.sass_backtrace[1], :mixin => "bar", :line => 5)
-    assert_hash_has(err.sass_backtrace[2], :mixin => "foo", :line => 2)
-  end
-
-  def test_mixin_loop_with_content
-    render <<SASS
-=foo
-  @content
-=bar
-  +foo
-    +bar
-+bar
+@include map-to-rule((foo: (bar: (baz: blue, qux: red), zap: green)))
 SASS
-    assert(false, "Exception not raised")
-  rescue Sass::SyntaxError => err
-    assert_equal("An @include loop has been found: bar includes itself", err.message)
-    assert_hash_has(err.sass_backtrace[0], :mixin => "@content", :line => 5)
-  end
-
-  def test_basic_import_loop_exception
-    import = filename_for_test
-    importer = MockImporter.new
-    importer.add_import(import, "@import '#{import}'")
-
-    engine = Sass::Engine.new("@import '#{import}'", :filename => import,
-      :load_paths => [importer])
-
-    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) {engine.render}
-An @import loop has been found: #{import} imports itself
-ERR
   end
 
   def test_double_import_loop_exception
@@ -2282,6 +2218,36 @@ CSS
 SASS
   end
 
+  def test_double_media_bubbling_with_surrounding_rules
+    assert_equal <<CSS, render(<<SASS)
+@media (min-width: 0) {
+  a {
+    a: a; }
+
+  b {
+    before: b;
+    after: b; } }
+  @media (min-width: 0) and (max-width: 5000px) {
+    b {
+      x: x; } }
+
+@media (min-width: 0) {
+  c {
+    c: c; } }
+CSS
+@media (min-width: 0)
+  a
+    a: a
+  b
+    before: b
+    @media (max-width: 5000px)
+      x: x
+    after: b
+  c
+    c: c
+SASS
+  end
+
   def test_rule_media_rule_bubbling
     assert_equal <<CSS, render(<<SASS)
 @media bar {
@@ -2308,9 +2274,10 @@ SASS
   @media print {
     .outside {
       color: black; } }
-    @media print and (a: b) {
-      .outside .inside {
-        border: 1px solid black; } }
+  @media print and (a: b) {
+    .outside .inside {
+      border: 1px solid black; } }
+
   .outside .middle {
     display: block; }
 CSS
@@ -2588,24 +2555,6 @@ body
 SASS
   end
 
-  def test_tricky_mixin_loop_exception
-    render <<SASS
-@mixin foo($a)
-  @if $a
-    @include foo(false)
-    @include foo(true)
-  @else
-    a: b
-
-a
-  @include foo(true)
-SASS
-    assert(false, "Exception not raised")
-  rescue Sass::SyntaxError => err
-    assert_equal("An @include loop has been found: foo includes itself", err.message)
-    assert_hash_has(err.sass_backtrace[0], :mixin => "foo", :line => 3)
-  end
-
   def test_interpolated_comment_in_mixin
     assert_equal <<CSS, render(<<SASS)
 /*! color: red */