sass 3.2.0.alpha.96 → 3.2.0.alpha.99

data/REVISION

@@ -1 +1 @@
-71e121eea2e0cd0b5752f4a7ffdce70b16fcbf58
+052db34a7f6d34fa0ed364f6c38923dedcd95cd6

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.96
+3.2.0.alpha.99

data/lib/sass/engine.rb

@@ -8,6 +8,7 @@ require 'sass/tree/comment_node'
 require 'sass/tree/prop_node'
 require 'sass/tree/directive_node'
 require 'sass/tree/media_node'
+require 'sass/tree/supports_node'
 require 'sass/tree/css_import_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
@@ -41,6 +42,7 @@ require 'sass/error'
 require 'sass/importers'
 require 'sass/shared'
 require 'sass/media'
+require 'sass/supports'
 
 module Sass
 

data/lib/sass/scss/parser.rb

@@ -425,36 +425,50 @@ module Sass
 
       # http://www.w3.org/TR/css3-conditional/
       def supports_directive(name)
-        value = str {expr!(:supports_condition)}
-        directive_body(["@#{name} #{value}".strip])
+        condition = expr!(:supports_condition)
+        node = node(Sass::Tree::SupportsNode.new(name, condition))
+
+        tok!(/\{/)
+        node.has_children = true
+        block_contents(node, :directive)
+        tok!(/\}/)
+
+        node
       end
 
       def supports_condition
-        supports_negation || supports_operator || supports_declaration_condition
+        supports_negation || supports_operator || supports_interpolation
       end
 
       def supports_negation
         return unless tok(/not/i)
         ss
-        expr!(:supports_condition_in_parens)
+        Sass::Supports::Negation.new(expr!(:supports_condition_in_parens))
       end
 
       def supports_operator
-        return unless supports_condition_in_parens
-        tok!(/and|or/i)
+        return unless cond = supports_condition_in_parens
+        return cond unless op = tok(/and|or/i)
         begin
           ss
-          expr!(:supports_condition_in_parens)
-        end while tok(/and|or/i)
-        true
+          cond = Sass::Supports::Operator.new(
+            cond, expr!(:supports_condition_in_parens), op)
+        end while op = tok(/and|or/i)
+        cond
       end
 
       def supports_condition_in_parens
+        interp = supports_interpolation and return interp
         return unless tok(/\(/); ss
-        if supports_condition
+        if cond = supports_condition
           tok!(/\)/); ss
+          cond
         else
-          supports_declaration_body
+          name = sass_script(:parse)
+          tok!(/:/); ss
+          value = sass_script(:parse)
+          tok!(/\)/); ss
+          Sass::Supports::Declaration.new(name, value)
         end
       end
 
@@ -463,11 +477,10 @@ module Sass
         supports_declaration_body
       end
 
-      def supports_declaration_body
-        tok!(IDENT); ss
-        tok!(/:/); ss
-        expr!(:expr); ss
-        tok!(/\)/); ss
+      def supports_interpolation
+        return unless interp = interpolation
+        ss
+        Sass::Supports::Interpolation.new(interp)
       end
 
       def variable

data/lib/sass/selector.rb

@@ -18,6 +18,13 @@ module Sass
   # Finally, {Simple} is the superclass of the simplest selectors,
   # such as `.foo` or `#bar`.
   module Selector
+    # The base used for calculating selector specificity. The spec says this
+    # should be "sufficiently high"; it's extremely unlikely that any single
+    # selector sequence will contain 1,000 simple selectors.
+    #
+    # @type [Fixnum]
+    SPECIFICITY_BASE = 1_000
+
     # A parent-referencing selector (`&` in Sass).
     # The function of this is to be replaced by the parent selector
     # in the nested hierarchy.
@@ -52,6 +59,11 @@ module Sass
       def to_a
         [".", *@name]
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
     end
 
     # An id selector (e.g. `#foo`).
@@ -79,6 +91,11 @@ module Sass
         return if sels.any? {|sel2| sel2.is_a?(Id) && self.name != sel2.name}
         super
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE**2
+      end
     end
 
     # A placeholder selector (e.g. `%foo`).
@@ -100,6 +117,11 @@ module Sass
       def to_a
         ["%", *@name]
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        0
+      end
     end
 
     # A universal selector (`*` in CSS).
@@ -162,6 +184,11 @@ module Sass
         return unless accept
         [name == :universal ? Universal.new(ns) : Element.new(name, ns)] + sels[1..-1]
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        0
+      end
     end
 
     # An element selector (e.g. `h1`).
@@ -224,6 +251,11 @@ module Sass
         return unless accept
         [Element.new(name, ns)] + sels[1..-1]
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        1
+      end
     end
 
     # Selector interpolation (`#{}` in Sass).
@@ -296,6 +328,11 @@ module Sass
         (res << @operator).concat @value if @value
         res << "]"
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
     end
 
     # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
@@ -363,6 +400,11 @@ module Sass
         return sels + [self] if final?
         super
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        type == :class ? SPECIFICITY_BASE : 1
+      end
     end
 
     # A pseudoclass selector whose argument is itself a selector
@@ -389,6 +431,11 @@ module Sass
       def to_a
         [":", @name, "("] + @selector.to_a + [")"]
       end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
     end
   end
 end

data/lib/sass/selector/abstract_sequence.rb

@@ -73,6 +73,22 @@ module Sass
       def to_s
         to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
+
+      # Returns the specificity of the selector as an integer. The base is given
+      # by {Sass::Selector::SPECIFICITY_BASE}.
+      #
+      # @return [Fixnum]
+      def specificity
+        _specificity(members)
+      end
+
+      protected
+
+      def _specificity(arr)
+        spec = 0
+        arr.map {|m| spec += m.is_a?(String) ? 0 : m.specificity}
+        spec
+      end
     end
   end
 end

data/lib/sass/selector/comma_sequence.rb

@@ -49,7 +49,15 @@ module Sass
       # @return [CommaSequence] A copy of this selector,
       #   with extensions made according to `extends`
       def do_extend(extends)
-        CommaSequence.new(members.map {|seq| seq.do_extend(extends)}.flatten)
+        CommaSequence.new(members.map do |seq|
+            extended = seq.do_extend(extends)
+            # First Law of Extend: the result of extending a selector should
+            # always contain the base selector.
+            #
+            # See https://github.com/nex3/sass/issues/324.
+            extended.unshift seq unless seq.has_placeholder? || extended.include?(seq)
+            extended
+          end.flatten)
       end
 
       # Returns a string representation of the sequence.

data/lib/sass/selector/sequence.rb

@@ -115,6 +115,15 @@ module Sass
         members.map {|m| m.inspect}.join(" ")
       end
 
+      # Add to the {SimpleSequence#sources} sets of the child simple sequences.
+      # This destructively modifies this sequence's members array, but not the
+      # child simple sequences.
+      #
+      # @param sources [Set<Sequence>]
+      def add_sources!(sources)
+        members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
+      end
+
       private
 
       # Conceptually, this expands "parenthesized selectors".
@@ -430,9 +439,16 @@ module Sass
         # separate sequences should limit the quadratic behavior.
         seqses.map do |seqs1|
           seqs1.reject do |seq1|
+            min_spec = 0
+            _sources(seq1).map {|seq| min_spec += seq.specificity}
             seqses.any? do |seqs2|
-              next if seqs1.object_id == seqs2.object_id
-              seqs2.any? {|seq2| _superselector?(seq2, seq1)}
+              next if seqs1.equal?(seqs2)
+              # Second Law of Extend: the specificity of a generated selector
+              # should never be less than the specificity of the extending
+              # selector.
+              #
+              # See https://github.com/nex3/sass/issues/324.
+              seqs2.any? {|seq2| _specificity(seq2) >= min_spec && _superselector?(seq2, seq1)}
             end
           end
         end
@@ -448,6 +464,12 @@ module Sass
 
       private
 
+      def _sources(seq)
+        s = Set.new
+        seq.map {|sseq_or_op| s.merge sseq_or_op.sources if sseq_or_op.is_a?(SimpleSequence)}
+        s
+      end
+
       def extended_not_expanded_to_s(extended_not_expanded)
         extended_not_expanded.map do |choices|
           choices = choices.map do |sel|

data/lib/sass/selector/simple_sequence.rb

@@ -8,7 +8,23 @@ module Sass
       # The array of individual selectors.
       #
       # @return [Array<Simple>]
-      attr_reader :members
+      attr_accessor :members
+
+      # The extending selectors that caused this selector sequence to be
+      # generated. For example:
+      #
+      #     a.foo { ... }
+      #     b.bar {@extend a}
+      #     c.baz {@extend b}
+      #
+      # The generated selector `b.foo.bar` has `{b.bar}` as its `sources` set,
+      # and the generated selector `c.foo.bar.baz` has `{b.bar, c.baz}` as its
+      # `sources` set.
+      #
+      # This is populated during the {#do_extend} process.
+      #
+      # @return {Set<Sequence>}
+      attr_accessor :sources
 
       # Returns the element or universal selector in this sequence,
       # if it exists.
@@ -26,8 +42,10 @@ module Sass
       end
 
       # @param selectors [Array<Simple>] See \{#members}
-      def initialize(selectors)
+      # @param sources [Set<Sequence>]
+      def initialize(selectors, sources = Set.new)
         @members = selectors
+        @sources = sources
       end
 
       # Resolves the {Parent} selectors within this selector
@@ -54,7 +72,7 @@ module Sass
       # Non-destrucively extends this selector with the extensions specified in a hash
       # (which should come from {Sass::Tree::Visitors::Cssize}).
       #
-      # @overload def do_extend(extends)
+      # @overload def do_extend(extends, sources)
       # @param extends [{Selector::Simple => Selector::Sequence}]
       #   The extensions to perform on this selector
       # @return [Array<Sequence>] A list of selectors generated
@@ -68,9 +86,10 @@ module Sass
 
           self_without_sel = self.members - sels
           next unless unified = seq.members.last.unify(self_without_sel)
-          [sels, seq.members[0...-1] + [unified]]
+          new_seq = Sequence.new(seq.members[0...-1] + [unified])
+          new_seq.add_sources!(sources + [seq])
+          [sels, new_seq]
         end.compact.map do |sels, seq|
-          seq = Sequence.new(seq)
           seen.include?(sels) ? [] : seq.do_extend(extends, seen + [sels])
         end.flatten.uniq
       end
@@ -121,6 +140,18 @@ module Sass
         members.map {|m| m.inspect}.join
       end
 
+      # Return a copy of this simple sequence with `sources` merged into the
+      # {#sources} set.
+      #
+      # @param sources [Set<Sequence>]
+      # @return [SimpleSequence]
+      def with_more_sources(sources)
+        sseq = dup
+        sseq.members = members.dup
+        sseq.sources.merge sources
+        sseq
+      end
+
       private
 
       def _hash

data/lib/sass/supports.rb

@@ -0,0 +1,229 @@
+# A namespace for the `@supports` condition parse tree.
+module Sass::Supports
+  # The abstract superclass of all Supports conditions.
+  class Condition
+    # Runs the SassScript in the supports condition.
+    #
+    # @param env [Sass::Environment] The environment in which to run the script.
+    def perform(environment); Sass::Util.abstract(self); end
+
+    # Returns the CSS for this condition.
+    #
+    # @return [String]
+    def to_css; Sass::Util.abstract(self); end
+
+    # Returns the Sass/CSS code for this condition.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options); Sass::Util.abstract(self); end
+
+    # Returns a deep copy of this condition and all its children.
+    #
+    # @return [Condition]
+    def deep_copy; Sass::Util.abstract(self); end
+
+    # Sets the options hash for the script nodes in the supports condition.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options); Sass::Util.abstract(self); end
+  end
+
+  # An operator condition (e.g. `CONDITION1 and CONDITION2`).
+  class Operator < Condition
+    # The left-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :left
+
+    # The right-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :right
+
+    # The operator ("and" or "or").
+    #
+    # @return [String]
+    attr_accessor :op
+
+    def initialize(left, right, op)
+      @left = left
+      @right = right
+      @op = op
+    end
+
+    def perform(env)
+      @left.perform(env)
+      @right.perform(env)
+    end
+
+    def to_css
+      "#{left_parens @left.to_css} #{op} #{right_parens @right.to_css}"
+    end
+
+    def to_src(options)
+      "#{left_parens @left.to_src(options)} #{op} #{right_parens @right.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.left = @left.deep_copy
+      copy.right = @right.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @left.options = options
+      @right.options = options
+    end
+
+    private
+
+    def left_parens(str)
+      return "(#{str})" if @left.is_a?(Negation)
+      return str
+    end
+
+    def right_parens(str)
+      return "(#{str})" if @right.is_a?(Negation) || @right.is_a?(Operator)
+      return str
+    end
+  end
+
+  # A negation condition (`not CONDITION`).
+  class Negation < Condition
+    # The condition being negated.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :condition
+
+    def initialize(condition)
+      @condition = condition
+    end
+
+    def perform(env)
+      @condition.perform(env)
+    end
+
+    def to_css
+      "not #{parens @condition.to_css}"
+    end
+
+    def to_src(options)
+      "not #{parens @condition.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.condition = condition.deep_copy
+      copy
+    end
+
+    def options=(options)
+      condition.options = options
+    end
+
+    private
+
+    def parens(str)
+      return "(#{str})" if @condition.is_a?(Negation) || @condition.is_a?(Operator)
+      return str
+    end
+  end
+
+  # A declaration condition (e.g. `(feature: value)`).
+  class Declaration < Condition
+    # The feature name.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :name
+
+    # The name of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The feature value.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :value
+
+    # The value of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def perform(env)
+      @resolved_name = name.perform(env)
+      @resolved_value = value.perform(env)
+    end
+
+    def to_css
+      "(#{@resolved_name}: #{@resolved_value})"
+    end
+
+    def to_src(options)
+      "(#{@name.to_sass(options)}: #{@value.to_sass(options)})"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.name = @name.deep_copy
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @name.options = options
+      @value.options = options
+    end
+  end
+
+  # An interpolation condition (e.g. `#{$var}`).
+  class Interpolation < Condition
+    # The SassScript expression in the interpolation.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :value
+
+    # The value of the expression after it's been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def perform(env)
+      val = value.perform(env)
+      @resolved_value = val.is_a?(Sass::Script::String) ? val.value : val.to_s
+    end
+
+    def to_css
+      @resolved_value
+    end
+
+    def to_src(options)
+      "\#{#{@value.to_sass(options)}}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @value.options = options
+    end
+  end
+end