sass 3.2.10 → 3.2.11

data/README.md

@@ -1,4 +1,4 @@
-# Sass
+# Sass [![Gem Version](https://badge.fury.io/rb/sass.png)](http://badge.fury.io/rb/sass)
 
 **Sass makes CSS fun again**. Sass is an extension of CSS3,
 adding nested rules, variables, mixins, selector inheritance, and more.
@@ -56,7 +56,7 @@ to `config.ru`.
 Then any Sass files in `public/stylesheets/sass`
 will be compiled into CSS files in `public/stylesheets` on every request.
 
-To use Sass programatically,
+To use Sass programmatically,
 check out the [YARD documentation](http://sass-lang.com/docs/yardoc/).
 
 ## Formatting

data/VERSION

@@ -1 +1 @@
-3.2.10
+3.2.11

data/VERSION_DATE

@@ -1 +1 @@
-27 July 2013 01:11:34 UTC
+28 September 2013 01:15:19 UTC

data/lib/sass/cache_stores/filesystem.rb

@@ -36,7 +36,7 @@ module Sass
         # return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
         # return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
         FileUtils.mkdir_p(File.dirname(compiled_filename))
-        File.open(compiled_filename, "wb") do |f|
+        Sass::Util.atomic_create_and_write_file(compiled_filename) do |f|
           f.puts(version)
           f.puts(sha)
           f.write(contents)

data/lib/sass/exec.rb

@@ -293,8 +293,16 @@ END
           @options[:for_engine][:cache] = false
         end
 
-        unless ::Sass::Util.ruby1_8?
-          opts.on('-E encoding', 'Specify the default encoding for Sass files.') do |encoding|
+        encoding_desc = if ::Sass::Util.ruby1_8?
+          'Does not work in ruby 1.8.'
+        else
+          'Specify the default encoding for Sass files.'
+        end
+        opts.on('-E encoding', encoding_desc) do |encoding|
+          if ::Sass::Util.ruby1_8?
+            $stderr.puts "Specifying the encoding is not supported in ruby 1.8."
+            exit 1
+          else
             Encoding.default_external = encoding
           end
         end
@@ -612,7 +620,6 @@ END
         end
         @options[:output] ||= @options[:input]
 
-        from = @options[:from]
         if @options[:to] == @options[:from] && !@options[:in_place]
           fmt = @options[:from]
           raise "Error: converting from #{fmt} to #{fmt} without --in-place"

data/lib/sass/plugin/staleness_checker.rb

@@ -24,11 +24,13 @@ module Sass
     #   as its instance-level caches are never explicitly expired.
     class StalenessChecker
       @dependencies_cache = {}
+      @dependency_cache_mutex = Mutex.new
 
       class << self
         # TODO: attach this to a compiler instance.
         # @private
         attr_accessor :dependencies_cache
+        attr_reader :dependency_cache_mutex
       end
 
       # Creates a new StalenessChecker
@@ -37,8 +39,6 @@ module Sass
       # @param options [{Symbol => Object}]
       #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
       def initialize(options)
-        @dependencies = self.class.dependencies_cache
-
         # URIs that are being actively checked for staleness. Protects against
         # import loops.
         @actively_checking = Set.new
@@ -131,7 +131,7 @@ module Sass
           begin
             mtime = importer.mtime(uri, @options)
             if mtime.nil?
-              @dependencies.delete([uri, importer])
+              with_dependency_cache {|cache| cache.delete([uri, importer])}
               nil
             else
               mtime
@@ -140,11 +140,14 @@ module Sass
       end
 
       def dependencies(uri, importer)
-        stored_mtime, dependencies = Sass::Util.destructure(@dependencies[[uri, importer]])
+        stored_mtime, dependencies =
+          with_dependency_cache {|cache| Sass::Util.destructure(cache[[uri, importer]])}
 
         if !stored_mtime || stored_mtime < mtime(uri, importer)
           dependencies = compute_dependencies(uri, importer)
-          @dependencies[[uri, importer]] = [mtime(uri, importer), dependencies]
+          with_dependency_cache do |cache|
+            cache[[uri, importer]] = [mtime(uri, importer), dependencies]
+          end
         end
 
         dependencies
@@ -178,6 +181,17 @@ module Sass
       def tree(uri, importer)
         @parse_trees[[uri, importer]] ||= importer.find(uri, @options).to_tree
       end
+
+      # Get access to the global dependency cache in a threadsafe manner.
+      # Inside the block, no other thread can access the dependency cache.
+      #
+      # @yieldparam cache [Hash] The hash that is the global dependency cache
+      # @return The value returned by the block to which this method yields
+      def with_dependency_cache
+        StalenessChecker.dependency_cache_mutex.synchronize do
+          yield StalenessChecker.dependencies_cache
+        end
+      end
     end
   end
 end

data/lib/sass/script/functions.rb

@@ -36,7 +36,7 @@ module Sass::Script
   # : Creates a {Color} from hue, saturation, and lightness values.
   #
   # \{#hsla hsla($hue, $saturation, $lightness, $alpha)}
-  # : Creates a {Color} from hue, saturation, lightness, lightness, and alpha
+  # : Creates a {Color} from hue, saturation, lightness, and alpha
   #   values.
   #
   # \{#hue hue($color)}
@@ -461,7 +461,7 @@ module Sass::Script
     end
     declare :hsl, [:hue, :saturation, :lightness]
 
-    # Creates a {Color} from hue, saturation, lightness, lightness, and alpha
+    # Creates a {Color} from hue, saturation, lightness, and alpha
     # values. Uses the algorithm from the [CSS3 spec][].
     #
     # [CSS3 spec]: http://www.w3.org/TR/css3-color/#hsl-color
@@ -1488,7 +1488,7 @@ module Sass::Script
     end
     declare :if, [:condition, :if_true, :if_false]
 
-    # This function only exists as a workaround for IE7's [`content:counter`
+    # This function only exists as a workaround for IE7's [`content: counter`
     # bug][bug]. It works identically to any other plain-CSS function, except it
     # avoids adding spaces between the argument commas.
     #
@@ -1503,6 +1503,21 @@ module Sass::Script
     end
     declare :counter, [], :var_args => true
 
+    # This function only exists as a workaround for IE7's [`content: counters`
+    # bug][bug]. It works identically to any other plain-CSS function, except it
+    # avoids adding spaces between the argument commas.
+    #
+    # [bug]: http://jes.st/2013/ie7s-css-breaking-content-counter-bug/
+    #
+    # @example
+    #   counters(item, ".") => counters(item,".")
+    # @overload counters($args...)
+    # @return [String]
+    def counters(*args)
+      Sass::Script::String.new("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
+    end
+    declare :counters, [], :var_args => true
+
     private
 
     # This method implements the pattern of transforming a numeric value into

data/lib/sass/script/list.rb

@@ -49,7 +49,8 @@ module Sass::Script
       return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.reject {|e| e.is_a?(Null)}.map do |v|
-        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
+        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence ||
+            separator == :space && v.is_a?(UnaryOperation) && (v.operator == :minus || v.operator == :plus)
           "(#{v.to_sass(opts)})"
         else
           v.to_sass(opts)

data/lib/sass/script/operation.rb

@@ -35,7 +35,6 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
-      pred = Sass::Script::Parser.precedence_of(@operator)
       o1 = operand_to_sass @operand1, :left, opts
       o2 = operand_to_sass @operand2, :right, opts
       sep =

data/lib/sass/script/unary_operation.rb

@@ -4,9 +4,14 @@ module Sass::Script
   #
   # Currently only `-`, `/`, and `not` are unary operators.
   class UnaryOperation < Node
-    # @param operand [Script::Node] The parse-tree node
-    #   for the object of the operator
-    # @param operator [Symbol] The operator to perform
+    # @return [Symbol] The operation to perform
+    attr_reader :operator
+
+    # @return [Script::Node] The parse-tree node for the object of the operator
+    attr_reader :operand
+
+    # @param operand [Script::Node] See \{#operand}
+    # @param operator [Symbol] See \{#operator}
     def initialize(operand, operator)
       @operand = operand
       @operator = operator

data/lib/sass/scss/parser.rb

@@ -1045,6 +1045,7 @@ MESSAGE
         :qualified_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
         :_selector => "selector",
+        :selector_comma_sequence => "selector",
         :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",
         :moz_document_function => "matching function (e.g. url-prefix(), domain())",

data/lib/sass/selector.rb

@@ -346,19 +346,19 @@ module Sass
     # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
     # It can have arguments (e.g. `:nth-child(2n+1)`).
     class Pseudo < Simple
-      # The type of the selector.
-      # `:class` if this is a pseudoclass selector,
-      # `:element` if it's a pseudoelement.
+      # Some psuedo-class-syntax selectors are actually considered
+      # pseudo-elements and must be treated differently. This is a list of such
+      # selectors
       #
-      # @return [Symbol]
-      attr_reader :type
+      # @return [Array<String>]
+      ACTUALLY_ELEMENTS = %w[after before first-line first-letter]
 
-      # Some psuedo-class-syntax selectors (`:after` and `:before)
-      # are actually considered pseudo-elements
-      # and must be at the end of the selector to function properly.
+      # Like \{#type}, but returns the type of selector this looks like, rather
+      # than the type it is semantically. This only differs from type for
+      # selectors in \{ACTUALLY\_ELEMENTS}.
       #
-      # @return [Array<String>]
-      FINAL_SELECTORS = %w[after before]
+      # @return [Symbol]
+      attr_reader :syntactic_type
 
       # The name of the selector.
       #
@@ -380,18 +380,22 @@ module Sass
       # @param arg [nil, Array<String, Sass::Script::Node>] The argument to the selector,
       #   or nil if no argument was given
       def initialize(type, name, arg)
-        @type = type
+        @syntactic_type = type
         @name = name
         @arg = arg
       end
 
-      def final?
-        type == :class && FINAL_SELECTORS.include?(name.first)
+      # The type of the selector. `:class` if this is a pseudoclass selector,
+      # `:element` if it's a pseudoelement.
+      #
+      # @return [Symbol]
+      def type
+        ACTUALLY_ELEMENTS.include?(name.first) ? :element : syntactic_type
       end
 
       # @see Selector#to_a
       def to_a
-        res = [@type == :class ? ":" : "::"] + @name
+        res = [syntactic_type == :class ? ":" : "::"] + @name
         (res << "(").concat(Sass::Util.strip_string_array(@arg)) << ")" if @arg
         res
       end
@@ -405,7 +409,6 @@ module Sass
           sel.is_a?(Pseudo) && sel.type == :element &&
             (sel.name != self.name || sel.arg != self.arg)
         end
-        return sels + [self] if final?
         super
       end
 

data/lib/sass/selector/sequence.rb

@@ -255,7 +255,7 @@ module Sass
           # is a supersequence of the other, use that, otherwise give up.
           lcs = Sass::Util.lcs(ops1, ops2)
           return unless lcs == ops1 || lcs == ops2
-          res.unshift *(ops1.size > ops2.size ? ops1 : ops2).reverse
+          res.unshift(*(ops1.size > ops2.size ? ops1 : ops2).reverse)
           return res
         end
 

data/lib/sass/selector/simple.rb

@@ -85,7 +85,7 @@ module Sass
         sels_with_ix = Sass::Util.enum_with_index(sels)
         _, i =
           if self.is_a?(Pseudo) || self.is_a?(SelectorPseudoClass)
-            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.final? || sels.last.type == :element)}
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.type == :element)}
           else
             sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
           end

data/lib/sass/selector/simple_sequence.rb

@@ -37,11 +37,16 @@ module Sass
         @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
       end
 
-      # Returns the non-base selectors in this sequence.
+      def pseudo_elements
+        @pseudo_elements ||= (members - [base]).
+          select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
+      end
+
+      # Returns the non-base, non-pseudo-class selectors in this sequence.
       #
       # @return [Set<Simple>]
       def rest
-        @rest ||= Set.new(base ? members[1..-1] : members)
+        @rest ||= Set.new(members - [base] - pseudo_elements)
       end
 
       # Whether or not this compound selector is the subject of the parent
@@ -129,9 +134,9 @@ module Sass
       #   by the time extension and unification happen,
       #   this exception will only ever be raised as a result of programmer error
       def unify(sels, other_subject)
-        return unless sseq = members.inject(sels) do |sseq, sel|
-          return unless sseq
-          sel.unify(sseq)
+        return unless sseq = members.inject(sels) do |member, sel|
+          return unless member
+          sel.unify(member)
         end
         SimpleSequence.new(sseq, other_subject || subject?)
       end
@@ -145,7 +150,9 @@ module Sass
       # @param sseq [SimpleSequence]
       # @return [Boolean]
       def superselector?(sseq)
-        (base.nil? || base.eql?(sseq.base)) && rest.subset?(sseq.rest)
+        (base.nil? || base.eql?(sseq.base)) &&
+          pseudo_elements.eql?(sseq.pseudo_elements) &&
+          rest.subset?(sseq.rest)
       end
 
       # @see Simple#to_a
@@ -197,8 +204,8 @@ WARNING
       end
 
       def _eql?(other)
-        other.base.eql?(self.base) && Sass::Util.set_eql?(other.rest, self.rest) &&
-          other.subject? == self.subject?
+        other.base.eql?(self.base) && other.pseudo_elements == pseudo_elements &&
+          Sass::Util.set_eql?(other.rest, self.rest) && other.subject? == self.subject?
       end
     end
   end

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

@@ -124,12 +124,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
       end
 
       sel = sseq.members
-      parent.resolved_rules.members.each do |seq|
-        if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
-          raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
+      parent.resolved_rules.members.each do |member|
+        if !member.members.last.is_a?(Sass::Selector::SimpleSequence)
+          raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
         end
 
-        @extends[sel] = Extend.new(seq, sel, node, @parent_directives.dup, :not_found)
+        @extends[sel] = Extend.new(member, sel, node, @parent_directives.dup, :not_found)
       end
     end
 

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

@@ -160,7 +160,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
       to_return = ''
       old_spaces = '  ' * @tabs
-      spaces = '  ' * (@tabs + 1)
       if node.style != :compressed
         if node.options[:debug_info] && !@in_directive
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"

data/lib/sass/util.rb

@@ -868,6 +868,29 @@ MSG
       end
     end
 
+    # This creates a temp file and yields it for writing. When the
+    # write is complete, the file is moved into the desired location.
+    # The atomicity of this operation is provided by the filesystem's
+    # rename operation.
+    #
+    # @param filename [String] The file to write to.
+    # @yieldparam tmpfile [Tempfile] The temp file that can be written to.
+    # @return The value returned by the block.
+    def atomic_create_and_write_file(filename)
+      require 'tempfile'
+      tmpfile = Tempfile.new(File.basename(filename), File.dirname(filename))
+      tmp_path = tmpfile.path
+      tmpfile.binmode if tmpfile.respond_to?(:binmode)
+      result = yield tmpfile
+      File.rename tmpfile.path, filename
+      result
+    ensure
+      # close and remove the tempfile if it still exists,
+      # presumably due to an error during write
+      tmpfile.close if tmpfile
+      tmpfile.unlink if tmpfile
+    end
+
     private
 
     # Calculates the memoization table for the Least Common Subsequence algorithm.

data/test/sass/conversion_test.rb

@@ -1692,6 +1692,23 @@ foo {
 SCSS
   end
 
+  def test_ambiguous_negation
+    assert_renders(<<SASS, <<SCSS, :indent => '    ')
+foo
+    ok: -$foo
+    comma: 10px, -$foo
+    needs-parens: 10px (-$foo)
+    no-parens: a 50px + 60px b
+SASS
+foo {
+    ok: -$foo;
+    comma: 10px, -$foo;
+    needs-parens: 10px (-$foo);
+    no-parens: a 50px + 60px b;
+}
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/extend_test.rb

@@ -1172,6 +1172,41 @@ SCSS
 
   # Regression Tests
 
+  def test_pseudo_element_superselector
+    # Pseudo-elements shouldn't be removed in superselector calculations.
+    assert_equal <<CSS, render(<<SCSS)
+a#bar, a#bar::fblthp {
+  a: b; }
+CSS
+%x#bar {a: b} // Add an id to make the results have high specificity
+%y, %y::fblthp {@extend %x}
+a {@extend %y}
+SCSS
+
+    # Pseudo-classes can be removed when the second law allows.
+    assert_equal <<CSS, render(<<SCSS)
+a#bar {
+  a: b; }
+CSS
+%x#bar {a: b}
+%y, %y:fblthp {@extend %x}
+a {@extend %y}
+SCSS
+
+    # A few pseudo-elements can be written as pseudo-elements for historical
+    # reasons. See http://www.w3.org/TR/selectors4/#pseudo-elements.
+    %w[first-line first-letter before after].each do |pseudo|
+      assert_equal <<CSS, render(<<SCSS)
+a#bar, a#bar:#{pseudo} {
+  a: b; }
+CSS
+%x#bar {a: b}
+%y, %y:#{pseudo} {@extend %x}
+a {@extend %y}
+SCSS
+    end
+  end
+
   def test_nested_sibling_extend
     assert_equal <<CSS, render(<<SCSS)
 .parent .bar, .parent .foo {

data/test/sass/functions_test.rb

@@ -1046,6 +1046,12 @@ MSG
     assert_equal('counter(item,".")', evaluate('counter(item,".")'))
   end
 
+  def test_counters
+    assert_equal("counters(foo)", evaluate("counters(foo)"))
+    assert_equal('counters(item,".")', evaluate('counters(item, ".")'))
+    assert_equal('counters(item,".")', evaluate('counters(item,".")'))
+  end
+
   def test_keyword_args_rgb
     assert_equal(%Q{white}, evaluate("rgb($red: 255, $green: 255, $blue: 255)"))
   end

data/test/sass/util_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 require 'pathname'
+require 'tmpdir'
 
 class UtilTest < Test::Unit::TestCase
   include Sass::Util
@@ -310,4 +311,51 @@ class UtilTest < Test::Unit::TestCase
       "UtilTest::FooBar must implement #foo") {FooBar.new.foo}
   end
 
+  def test_atomic_writes
+    # when using normal writes, this test fails about 90% of the time.
+    filename = File.join(Dir.tmpdir, "test_atomic")
+    5.times do
+      writes_to_perform = %w(1 2 3 4 5 6 7 8 9).map {|i| "#{i}\n" * 100_000}
+      threads = writes_to_perform.map do |to_write|
+        Thread.new do
+          # To see this test fail with a normal write,
+          # change to the standard file open mechanism:
+          # open(filename, "w") do |f|
+          atomic_create_and_write_file(filename) do |f|
+            f.write(to_write)
+          end
+        end
+      end
+      loop do
+        contents = File.exist?(filename) ? File.read(filename) : nil
+        next if contents.nil? || contents.size == 0
+        unless writes_to_perform.include?(contents)
+          if contents.size != writes_to_perform.first.size
+            fail "Incomplete write detected: was #{contents.size} characters, " +
+                 "should have been #{writes_to_perform.first.size}"
+          else
+            fail "Corrupted read/write detected"
+          end
+        end
+        break if threads.all? {|t| !t.alive?}
+      end
+      threads.each {|t| t.join}
+    end
+  end
+
+  class FakeError < RuntimeError; end
+
+  def test_atomic_writes_handles_exceptions
+    filename = File.join(Dir.tmpdir, "test_atomic_exception")
+    FileUtils.rm_f(filename)
+    tmp_filename = nil
+    assert_raises FakeError do
+      atomic_create_and_write_file(filename) do |f|
+        tmp_filename = f.path
+        raise FakeError.new "Borken"
+      end
+    end
+    assert !File.exist?(filename)
+    assert !File.exist?(tmp_filename)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sass
 version: !ruby/object:Gem::Version
-  version: 3.2.10
+  version: 3.2.11
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-27 00:00:00.000000000 Z
+date: 2013-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard