sass 3.2.0.alpha.60 → 3.2.0.alpha.61

data/REVISION

@@ -1 +1 @@
-3b7b3977a280d7117d185295abde521a6860f893
+f03f995506891014aea1df1a16672298469b3966

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.60
+3.2.0.alpha.61

data/lib/sass/cache_stores/filesystem.rb

@@ -53,6 +53,7 @@ module Sass
       # @param key [String]
       # @return [String] The path to the cache file.
       def path_to(key)
+        key = key.gsub(/[<>:\\|?*%]/) {|c| "%%%03d" % Sass::Util.ord(c)}
         File.join(cache_location, key)
       end
     end

data/lib/sass/engine.rb

@@ -224,7 +224,7 @@ module Sass
     # If you're compiling a single Sass file from the filesystem,
     # use \{Sass::Engine.for\_file}.
     # If you're compiling multiple files from the filesystem,
-    # use {Sass::Plugin.
+    # use {Sass::Plugin}.
     #
     # @param template [String] The Sass template.
     #   This template can be encoded using any encoding

data/lib/sass/media.rb

@@ -51,6 +51,20 @@ module Sass::Media
     def to_src(options)
       queries.map {|q| q.to_src(options)}.join(', ')
     end
+
+    # Returns a deep copy of this query list and all its children.
+    #
+    # @return [QueryList]
+    def deep_copy
+      QueryList.new(queries.map {|q| q.deep_copy})
+    end
+
+    # Sets the options hash for the script nodes in the media query.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      queries.each {|q| q.options = options}
+    end
   end
 
   # A single media query.
@@ -164,6 +178,25 @@ module Sass::Media
       src << expressions.map {|e| e.to_src(options)}.join(' and ')
       src
     end
+
+    # Returns a deep copy of this query and all its children.
+    #
+    # @return [Query]
+    def deep_copy
+      Query.new(
+        modifier.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        expressions.map {|q| q.deep_copy})
+    end
+
+    # Sets the options hash for the script nodes in the media query.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      modifier.each {|m| m.options = options if m.is_a?(Sass::Script::Node)}
+      type.each {|t| t.options = options if t.is_a?(Sass::Script::Node)}
+      expressions.each {|e| e.options = options}
+    end
   end
 
   # A media query expression.
@@ -232,6 +265,23 @@ module Sass::Media
       src << ')'
       src
     end
+
+    # Returns a deep copy of this expression.
+    #
+    # @return [Expression]
+    def deep_copy
+      Expression.new(
+        name.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        value.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c})
+    end
+
+    # Sets the options hash for the script nodes in the expression.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options)
+      name.each {|n| n.options = options if n.is_a?(Sass::Script::Node)}
+      value.each {|v| v.options = options if v.is_a?(Sass::Script::Node)}
+    end
   end
 
   # Converts an interpolation array that may represent a single variable to source.

data/lib/sass/script/funcall.rb

@@ -36,7 +36,7 @@ module Sass
       # @return [String] A string representation of the function call
       def inspect
         args = @args.map {|a| a.inspect}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
         "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -44,7 +44,7 @@ module Sass
       # @see Node#to_sass
       def to_sass(opts = {})
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = @keywords.sort_by {|k, v| k}.
+        keywords = Sass::Util.hash_to_a(@keywords).
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
         "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end

data/lib/sass/script/literal.rb

@@ -55,26 +55,6 @@ The #options attribute is not set on this #{self.class}.
 MSG
     end
 
-    # The SassScript `and` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of a logical and:
-    #   `other` if this literal isn't a false {Bool},
-    #   and this literal otherwise
-    def and(other)
-      to_bool ? other : self
-    end
-
-    # The SassScript `or` operation.
-    #
-    # @param other [Literal] The right-hand side of the operator
-    # @return [Literal] The result of the logical or:
-    #   this literal if it isn't a false {Bool},
-    #   and `other` otherwise
-    def or(other)
-      to_bool ? self : other
-    end
-
     # The SassScript `==` operation.
     # **Note that this returns a {Sass::Script::Bool} object,
     # not a Ruby boolean**.

data/lib/sass/script/operation.rb

@@ -72,6 +72,14 @@ module Sass::Script
     # @raise [Sass::SyntaxError] if the operation is undefined for the operands
     def _perform(environment)
       literal1 = @operand1.perform(environment)
+
+      # Special-case :and and :or to support short-circuiting.
+      if @operator == :and
+        return literal1.to_bool ? @operand2.perform(environment) : literal1
+      elsif @operator == :or
+        return literal1.to_bool ? literal1 : @operand2.perform(environment)
+      end
+
       literal2 = @operand2.perform(environment)
 
       begin

data/lib/sass/selector.rb

@@ -379,7 +379,7 @@ module Sass
       attr_reader :selector
 
       # @param [String] The name of the pseudoclass
-      # @param [Selector::Sequence] The selector argument
+      # @param [Selector::CommaSequence] The selector argument
       def initialize(name, selector)
         @name = name
         @selector = selector

data/lib/sass/selector/sequence.rb

@@ -124,15 +124,15 @@ module Sass
       # @param path [Array<Array<SimpleSequence or String>>] A list of parenthesized selector groups.
       # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
       def weave(path)
+        # This function works by moving through the selector path left-to-right,
+        # building all possible prefixes simultaneously. These prefixes are
+        # `befores`, while the remaining parenthesized suffixes is `afters`.
         befores = [[]]
         afters = path.dup
 
         until afters.empty?
           current = afters.shift.dup
           last_current = [current.pop]
-          while !current.empty? && last_current.first.is_a?(String) || current.last.is_a?(String)
-            last_current.unshift(current.pop)
-          end
           befores = Sass::Util.flatten(befores.map do |before|
               next [] unless sub = subweave(before, current)
               sub.map {|seqs| seqs + last_current}
@@ -150,6 +150,12 @@ module Sass
       # `.foo .baz .bar .bang`, `.foo .baz .bar.bang`, `.foo .baz .bang .bar`,
       # and so on until `.baz .bang .foo .bar`.
       #
+      # Semantically, for selectors A and B, this returns all selectors `AB_i`
+      # such that the union over all i of elements matched by `AB_i X` is
+      # identical to the intersection of all elements matched by `A X` and all
+      # elements matched by `B X`. Some `AB_i` are elided to reduce the size of
+      # the output.
+      #
       # @param seq1 [Array<SimpleSequence or String>]
       # @param seq2 [Array<SimpleSequence or String>]
       # @return [Array<Array<SimpleSequence or String>>]
@@ -157,31 +163,34 @@ module Sass
         return [seq2] if seq1.empty?
         return [seq1] if seq2.empty?
 
+        seq1, seq2 = seq1.dup, seq2.dup
         return unless init = merge_initial_ops(seq1, seq2)
+        return unless fin = merge_final_ops(seq1, seq2)
         seq1 = group_selectors(seq1)
         seq2 = group_selectors(seq2)
         lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|
           next s1 if s1 == s2
           next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)
-          next s2 if subweave_superselector?(s1, s2)
-          next s1 if subweave_superselector?(s2, s1)
+          next s2 if superselector?(s1, s2)
+          next s1 if superselector?(s2, s1)
         end
 
         diff = [[init]]
         until lcs.empty?
-          diff << chunks(seq1, seq2) {|s| subweave_superselector?(s.first, lcs.first)} << [lcs.shift]
+          diff << chunks(seq1, seq2) {|s| superselector?(s.first, lcs.first)} << [lcs.shift]
           seq1.shift
           seq2.shift
         end
         diff << chunks(seq1, seq2) {|s| s.empty?}
+        diff += fin.map {|sel| sel.is_a?(Array) ? sel : [sel]}
         diff.reject! {|c| c.empty?}
 
         Sass::Util.paths(diff).map {|p| p.flatten}
       end
 
-      # Extracts initial selector operators (`"+"`, `">"`, `"~"`, and `"\n"`)
+      # Extracts initial selector combinators (`"+"`, `">"`, `"~"`, and `"\n"`)
       # from two sequences and merges them together into a single array of
-      # selector operators.
+      # selector combinators.
       #
       # @param seq1 [Array<SimpleSequence or String>]
       # @param seq2 [Array<SimpleSequence or String>]
@@ -204,6 +213,100 @@ module Sass
         return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
       end
 
+      # Extracts final selector combinators (`"+"`, `">"`, `"~"`) and the
+      # selectors to which they apply from two sequences and merges them
+      # together into a single array.
+      #
+      # @param seq1 [Array<SimpleSequence or String>]
+      # @param seq2 [Array<SimpleSequence or String>]
+      # @return [Array<SimpleSequence or String or
+      #     Array<Array<SimpleSequence or String>>]
+      #   If there are no trailing combinators to be merged, this will be the
+      #   empty array. If the trailing combinators cannot be merged, this will
+      #   be nil. Otherwise, this will contained the merged selector. Array
+      #   elements are [Sass::Util#paths]-style options; conceptually, an "or"
+      #   of multiple selectors.
+      def merge_final_ops(seq1, seq2, res = [])
+        ops1, ops2 = [], []
+        ops1 << seq1.pop while seq1.last.is_a?(String)
+        ops2 << seq2.pop while seq2.last.is_a?(String)
+
+        # Not worth the headache of trying to preserve newlines here. The most
+        # important use of newlines is at the beginning of the selector to wrap
+        # across lines anyway.
+        ops1.reject! {|o| o == "\n"}
+        ops2.reject! {|o| o == "\n"}
+
+        return res if ops1.empty? && ops2.empty?
+        if ops1.size > 1 || ops2.size > 1
+          # If there are multiple operators, something hacky's going on. If one
+          # 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
+          return res
+        end
+
+        # This code looks complicated, but it's actually just a bunch of special
+        # cases for interactions between different combinators.
+        op1, op2 = ops1.first, ops2.first
+        if op1 && op2
+          sel1 = seq1.pop
+          sel2 = seq2.pop
+          if op1 == '~' && op2 == '~'
+            if superselector?([sel1], [sel2])
+              res.unshift sel2, '~'
+            elsif superselector?([sel2], [sel1])
+              res.unshift sel1, '~'
+            else
+              merged = sel1.unify(sel2.members)
+              res.unshift [
+                [sel1, '~', sel2, '~'],
+                [sel2, '~', sel1, '~'],
+                ([merged, '~'] if merged)
+              ].compact
+            end
+          elsif (op1 == '~' && op2 == '+') || (op1 == '+' && op2 == '~')
+            if op1 == '~'
+              tilde_sel, plus_sel = sel1, sel2
+            else
+              tilde_sel, plus_sel = sel2, sel1
+            end
+
+            if superselector?([tilde_sel], [plus_sel])
+              res.unshift plus_sel, '+'
+            else
+              merged = plus_sel.unify(tilde_sel.members)
+              res.unshift [
+                [tilde_sel, '~', plus_sel, '+'],
+                ([merged, '+'] if merged)
+              ].compact
+            end
+          elsif op1 == '>' && %w[~ +].include?(op2)
+            res.unshift sel2, op2
+            seq1.push sel1, op1
+          elsif op2 == '>' && %w[~ +].include?(op1)
+            res.unshift sel1, op1
+            seq2.push sel2, op2
+          elsif op1 == op2
+            return unless merged = sel1.unify(sel2.members)
+            res.unshift merged, op1
+          else
+            # Unknown selector combinators can't be unified
+            return
+          end
+          return merge_final_ops(seq1, seq2, res)
+        elsif op1
+          seq2.pop if op1 == '>' && seq2.last && superselector?([seq2.last], [seq1.last])
+          res.unshift seq1.pop, op1
+          return merge_final_ops(seq1, seq2, res)
+        else # op2
+          seq1.pop if op2 == '>' && seq1.last && superselector?([seq1.last], [seq2.last])
+          res.unshift seq2.pop, op2
+          return merge_final_ops(seq1, seq2, res)
+        end
+      end
+
       # Takes initial subsequences of `seq1` and `seq2` and returns all
       # orderings of those subsequences. The initial subsequences are determined
       # by a block.
@@ -223,6 +326,7 @@ module Sass
       #   cutting off some initial subsequence.
       # @yieldreturn [Boolean] Whether or not to cut off the initial subsequence
       #   here.
+      # @return [Array<Array>] All possible orderings of the initial subsequences.
       def chunks(seq1, seq2)
         chunk1 = []
         chunk1 << seq1.shift until yield seq1
@@ -257,25 +361,33 @@ module Sass
       end
 
       # Given two sequences of simple selectors, returns whether `sseq1` is a
-      # superselector of `sseq2`.
+      # superselector of `sseq2`; that is, whether `sseq1` matches every element
+      # `sseq2` matches.
+      #
+      # Both `sseq1` and `sseq2` are of the form
+      # `SimpleSelector (String SimpleSelector)* String*`, although selectors
+      # with a trailing operator are considered to be neither superselectors nor
+      # subselectors.
       #
-      # @param sseq1 [Array<SimpleSelector or String>]
-      # @param sseq2 [Array<SimpleSelector or String>]
+      # @param sseq1 [Array<SimpleSequence or String>]
+      # @param sseq2 [Array<SimpleSequence or String>]
       # @return [Boolean]
-      def subweave_superselector?(sseq1, sseq2)
+      def superselector?(sseq1, sseq2)
+        sseq1 = sseq1.reject {|e| e == "\n"}
+        sseq2 = sseq2.reject {|e| e == "\n"}
+        # Selectors with trailing operators are neither superselectors nor
+        # subselectors.
+        return if sseq1.last.is_a?(String) || sseq2.last.is_a?(String)
         if sseq1.size > 1
           # More complex selectors are never superselectors of less complex ones
           return unless sseq2.size > 1
           # .foo ~ .bar is a superselector of .foo + .bar
           return unless sseq1[1] == "~" ? sseq2[1] != ">" : sseq2[1] == sseq1[1]
           return unless sseq1.first.superselector?(sseq2.first)
-          return true if sseq1.size == 2
-          return false if sseq2.size == 2
-          return subweave_superselector?(sseq1[2..-1], sseq2[2..-1])
+          return superselector?(sseq1[2..-1], sseq2[2..-1])
         elsif sseq2.size > 1
           return true if sseq2[1] == ">" && sseq1.first.superselector?(sseq2.first)
-          return false if sseq2.size == 2
-          return subweave_superselector?(sseq1, sseq2[2..-1])
+          return superselector?(sseq1, sseq2[2..-1])
         else
           sseq1.first.superselector?(sseq2.first)
         end

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

@@ -168,7 +168,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_mixin(node)
     unless node.args.empty? && node.keywords.empty?
       args = node.args.map {|a| a.to_sass(@options)}.join(", ")
-      keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+      keywords = Sass::Util.hash_to_a(node.keywords).
+        map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"

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

@@ -52,12 +52,27 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   def visit_root(node)
     yield
 
-    # In Ruby 1.9 we can make all @charset nodes invisible
-    # and infer the final @charset from the encoding of the final string.
-    if Sass::Util.ruby1_8? && parent.nil?
-      charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-      node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-      node.children.unshift charset if charset
+    if parent.nil?
+      # In Ruby 1.9 we can make all @charset nodes invisible
+      # and infer the final @charset from the encoding of the final string.
+      if Sass::Util.ruby1_8?
+        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
+        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
+        node.children.unshift charset if charset
+      end
+
+      imports = Sass::Util.extract!(node.children) do |c|
+        c.is_a?(Sass::Tree::DirectiveNode) && !c.is_a?(Sass::Tree::MediaNode) &&
+          c.resolved_value =~ /^@import /i
+      end
+      charset_and_index = Sass::Util.ruby1_8? &&
+        node.children.each_with_index.find {|c, _| c.is_a?(Sass::Tree::CharsetNode)}
+      if charset_and_index
+        index = charset_and_index.last
+        node.children = node.children[0..index] + imports + node.children[index+1..-1]
+      else
+        node.children = imports + node.children
+      end
     end
 
     return node, @extends

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

@@ -84,4 +84,14 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
     node.expr = node.expr.deep_copy
     yield
   end
+
+  def visit_directive(node)
+    node.value = node.value.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
+    yield
+  end
+
+  def visit_media(node)
+    node.query = query.deep_copy
+    yield
+  end
 end