sass 3.3.0 → 3.4.0

data/lib/sass/selector/pseudo.rb

@@ -0,0 +1,256 @@
+module Sass
+  module Selector
+    # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`)
+    # selector. It can have arguments (e.g. `:nth-child(2n+1)`) which can
+    # contain selectors (e.g. `:nth-child(2n+1 of .foo)`).
+    class Pseudo < Simple
+      # Some pseudo-class-syntax selectors are actually considered
+      # pseudo-elements and must be treated differently. This is a list of such
+      # selectors.
+      #
+      # @return [Set<String>]
+      ACTUALLY_ELEMENTS = %w[after before first-line first-letter].to_set
+
+      # 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 [Symbol]
+      attr_reader :syntactic_type
+
+      # The name of the selector.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The argument to the selector,
+      # or `nil` if no argument was given.
+      #
+      # @return [String, nil]
+      attr_reader :arg
+
+      # The selector argument, or `nil` if no selector exists.
+      #
+      # If this and \{#arg\} are both set, \{#arg\} is considered a non-selector
+      # prefix.
+      #
+      # @return [CommaSequence]
+      attr_reader :selector
+
+      # @param syntactic_type [Symbol] See \{#syntactic_type}
+      # @param name [String] See \{#name}
+      # @param arg [nil, String] See \{#arg}
+      # @param selector [nil, CommaSequence] See \{#selector}
+      def initialize(syntactic_type, name, arg, selector)
+        @syntactic_type = syntactic_type
+        @name = name
+        @arg = arg
+        @selector = selector
+      end
+
+      # Returns a copy of this with \{#selector} set to \{#new\_selector}.
+      #
+      # @param new_selector [CommaSequence]
+      # @return [CommaSequence]
+      def with_selector(new_selector)
+        Pseudo.new(syntactic_type, name, arg, CommaSequence.new(new_selector.members.map do |seq|
+          next seq unless seq.members.length == 1
+          sseq = seq.members.first
+          next seq unless sseq.is_a?(SimpleSequence) && sseq.members.length == 1
+          sel = sseq.members.first
+          next seq unless sel.is_a?(Pseudo) && sel.selector
+
+          case normalized_name
+          when 'not'
+            # In theory, if there's a nested :not its contents should be
+            # unified with the return value. For example, if :not(.foo)
+            # extends .bar, :not(.bar) should become .foo:not(.bar). However,
+            # this is a narrow edge case and supporting it properly would make
+            # this code and the code calling it a lot more complicated, so
+            # it's not supported for now.
+            next [] unless sel.normalized_name == 'matches'
+            sel.selector.members
+          when 'matches', 'any', 'current', 'nth-child', 'nth-last-child'
+            # As above, we could theoretically support :not within :matches, but
+            # doing so would require this method and its callers to handle much
+            # more complex cases that likely aren't worth the pain.
+            next [] unless sel.name == name && sel.arg == arg
+            sel.selector.members
+          when 'has', 'host', 'host-context'
+            # We can't expand nested selectors here, because each layer adds an
+            # additional layer of semantics. For example, `:has(:has(img))`
+            # doesn't match `<div><img></div>` but `:has(img)` does.
+            sel
+          else
+            []
+          end
+        end.flatten))
+      end
+
+      # 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?(normalized_name) ? :element : syntactic_type
+      end
+
+      # Like \{#name\}, but without any vendor prefix.
+      #
+      # @return [String]
+      def normalized_name
+        @normalized_name ||= name.gsub(/^-[a-zA-Z0-9]+-/, '')
+      end
+
+      # @see Selector#to_s
+      def to_s
+        res = (syntactic_type == :class ? ":" : "::") + @name
+        if @arg || @selector
+          res << "("
+          res << @arg.strip if @arg
+          res << " " if @arg && @selector
+          res << @selector.to_s if @selector
+          res << ")"
+        end
+        res
+      end
+
+      # Returns `nil` if this is a pseudoelement selector
+      # and `sels` contains a pseudoelement selector different than this one.
+      #
+      # @see SimpleSequence#unify
+      def unify(sels)
+        return if type == :element && sels.any? do |sel|
+          sel.is_a?(Pseudo) && sel.type == :element &&
+            (sel.name != name || sel.arg != arg || sel.selector != selector)
+        end
+        super
+      end
+
+      # Returns whether or not this selector matches all elements
+      # that the given selector matches (as well as possibly more).
+      #
+      # @example
+      #   (.foo).superselector?(.foo.bar) #=> true
+      #   (.foo).superselector?(.bar) #=> false
+      # @param their_sseq [SimpleSequence]
+      # @param parents [Array<SimpleSequence, String>] The parent selectors of `their_sseq`, if any.
+      # @return [Boolean]
+      def superselector?(their_sseq, parents = [])
+        case normalized_name
+        when 'matches', 'any'
+          # :matches can be a superselector of another selector in one of two
+          # ways. Either its constituent selectors can be a superset of those of
+          # another :matches in the other selector, or any of its constituent
+          # selectors can individually be a superselector of the other selector.
+          (their_sseq.selector_pseudo_classes[normalized_name] || []).any? do |their_sel|
+            next false unless their_sel.is_a?(Pseudo)
+            next false unless their_sel.name == name
+            selector.superselector?(their_sel.selector)
+          end || selector.members.any? do |our_seq|
+            their_seq = Sequence.new(parents + [their_sseq])
+            our_seq.superselector?(their_seq)
+          end
+        when 'has', 'host', 'host-context'
+          # Like :matches, :has (et al) can be a superselector of another
+          # selector if its constituent selectors are a superset of those of
+          # another :has in the other selector. However, the :matches other case
+          # doesn't work, because :has refers to nested elements.
+          (their_sseq.selector_pseudo_classes[normalized_name] || []).any? do |their_sel|
+            next false unless their_sel.is_a?(Pseudo)
+            next false unless their_sel.name == name
+            selector.superselector?(their_sel.selector)
+          end
+        when 'not'
+          selector.members.all? do |our_seq|
+            their_sseq.members.any? do |their_sel|
+              if their_sel.is_a?(Element) || their_sel.is_a?(Id)
+                # `:not(a)` is a superselector of `h1` and `:not(#foo)` is a
+                # superselector of `#bar`.
+                our_sseq = our_seq.members.last
+                next false unless our_sseq.is_a?(SimpleSequence)
+                our_sseq.members.any? do |our_sel|
+                  our_sel.class == their_sel.class && our_sel != their_sel
+                end
+              else
+                next false unless their_sel.is_a?(Pseudo)
+                next false unless their_sel.name == name
+                # :not(X) is a superselector of :not(Y) exactly when Y is a
+                # superselector of X.
+                their_sel.selector.superselector?(CommaSequence.new([our_seq]))
+              end
+            end
+          end
+        when 'current'
+          (their_sseq.selector_pseudo_classes['current'] || []).any? do |their_current|
+            next false if their_current.name != name
+            # Explicitly don't check for nested superselector relationships
+            # here. :current(.foo) isn't always a superselector of
+            # :current(.foo.bar), since it matches the *innermost* ancestor of
+            # the current element that matches the selector. For example:
+            #
+            #     <div class="foo bar">
+            #       <p class="foo">
+            #         <span>current element</span>
+            #       </p>
+            #     </div>
+            #
+            # Here :current(.foo) would match the p element and *not* the div
+            # element, whereas :current(.foo.bar) would match the div and not
+            # the p.
+            selector == their_current.selector
+          end
+        when 'nth-child', 'nth-last-child'
+          their_sseq.members.any? do |their_sel|
+            # This misses a few edge cases. For example, `:nth-child(n of X)`
+            # is a superselector of `X`, and `:nth-child(2n of X)` is a
+            # superselector of `:nth-child(4n of X)`. These seem rare enough
+            # not to be worth worrying about, though.
+            next false unless their_sel.is_a?(Pseudo)
+            next false unless their_sel.name == name
+            next false unless their_sel.arg == arg
+            selector.superselector?(their_sel.selector)
+          end
+        else
+          throw "[BUG] Unknown selector pseudo class #{name}"
+        end
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        return 1 if type == :element
+        return SPECIFICITY_BASE unless selector
+        @specificity ||=
+          if normalized_name == 'not'
+            min = 0
+            max = 0
+            selector.members.each do |seq|
+              spec = seq.specificity
+              if spec.is_a?(Range)
+                min = Sass::Util.max(spec.begin, min)
+                max = Sass::Util.max(spec.end, max)
+              else
+                min = Sass::Util.max(spec, min)
+                max = Sass::Util.max(spec, max)
+              end
+            end
+            min == max ? max : (min..max)
+          else
+            min = 0
+            max = 0
+            selector.members.each do |seq|
+              spec = seq.specificity
+              if spec.is_a?(Range)
+                min = Sass::Util.min(spec.begin, min)
+                max = Sass::Util.max(spec.end, max)
+              else
+                min = Sass::Util.min(spec, min)
+                max = Sass::Util.max(spec, max)
+              end
+            end
+            min == max ? max : (min..max)
+          end
+      end
+    end
+  end
+end

data/lib/sass/selector/sequence.rb

@@ -78,48 +78,76 @@ module Sass
       # Non-destructively extends this selector with the extensions specified in a hash
       # (which should come from {Sass::Tree::Visitors::Cssize}).
       #
-      # @overload def do_extend(extends, parent_directives)
       # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
       #                                       Sass::Tree::Visitors::Cssize::Extend}]
       #   The extensions to perform on this selector
       # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
       #   The directives containing this selector.
+      # @param replace [Boolean]
+      #   Whether to replace the original selector entirely or include
+      #   it in the result.
+      # @param seen [Set<Array<Selector::Simple>>]
+      #   The set of simple sequences that are currently being replaced.
+      # @param original [Boolean]
+      #   Whether this is the original selector being extended, as opposed to
+      #   the result of a previous extension that's being re-extended.
       # @return [Array<Sequence>] A list of selectors generated
       #   by extending this selector with `extends`.
       #   These correspond to a {CommaSequence}'s {CommaSequence#members members array}.
       # @see CommaSequence#do_extend
-      def do_extend(extends, parent_directives, seen = Set.new)
+      def do_extend(extends, parent_directives, replace, seen, original)
         extended_not_expanded = members.map do |sseq_or_op|
           next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
-          extended = sseq_or_op.do_extend(extends, parent_directives, seen)
-          choices = extended.map {|seq| seq.members}
-          choices.unshift([sseq_or_op]) unless extended.any? {|seq| seq.superselector?(sseq_or_op)}
-          choices
+          extended = sseq_or_op.do_extend(extends, parent_directives, replace, seen)
+
+          # The First Law of Extend says that the generated selector should have
+          # specificity greater than or equal to that of the original selector.
+          # In order to ensure that, we record the original selector's
+          # (`extended.first`) original specificity.
+          extended.first.add_sources!([self]) if original && !has_placeholder?
+
+          extended.map {|seq| seq.members}
         end
         weaves = Sass::Util.paths(extended_not_expanded).map {|path| weave(path)}
         trim(weaves).map {|p| Sequence.new(p)}
       end
 
+      # Unifies this with another selector sequence to produce a selector
+      # that matches (a subset of) the intersection of the two inputs.
+      #
+      # @param other [Sequence]
+      # @return [CommaSequence, nil] The unified selector, or nil if unification failed.
+      # @raise [Sass::SyntaxError] If this selector cannot be unified.
+      #   This will only ever occur when a dynamic selector,
+      #   such as {Parent} or {Interpolation}, is used in unification.
+      #   Since these selectors should be resolved
+      #   by the time extension and unification happen,
+      #   this exception will only ever be raised as a result of programmer error
+      def unify(other)
+        base = members.last
+        other_base = other.members.last
+        return unless base.is_a?(SimpleSequence) && other_base.is_a?(SimpleSequence)
+        return unless (unified = other_base.unify(base))
+
+        woven = weave([members[0...-1], other.members[0...-1] + [unified]])
+        CommaSequence.new(woven.map {|w| Sequence.new(w)})
+      end
+
       # Returns whether or not this selector matches all elements
       # that the given selector matches (as well as possibly more).
       #
       # @example
       #   (.foo).superselector?(.foo.bar) #=> true
       #   (.foo).superselector?(.bar) #=> false
-      #   (.bar .foo).superselector?(.foo) #=> false
-      # @param sseq [SimpleSequence]
+      # @param cseq [Sequence]
       # @return [Boolean]
-      def superselector?(sseq)
-        return false unless members.size == 1
-        members.last.superselector?(sseq)
+      def superselector?(seq)
+        _superselector?(members, seq.members)
       end
 
-      # @see Simple#to_a
-      def to_a
-        ary = @members.map do |seq_or_op|
-          seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op
-        end
-        Sass::Util.intersperse(ary, " ").flatten.compact
+      # @see AbstractSequence#to_s
+      def to_s
+        @members.join(" ").gsub(/ ?\n ?/, "\n")
       end
 
       # Returns a string representation of the sequence.
@@ -139,6 +167,35 @@ module Sass
         members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
       end
 
+      # Converts the subject operator "!", if it exists, into a ":has()"
+      # selector.
+      #
+      # @retur [Sequence]
+      def subjectless
+        pre_subject = []
+        has = []
+        subject = nil
+        members.each do |sseq_or_op|
+          if subject
+            has << sseq_or_op
+          elsif sseq_or_op.is_a?(String) || !sseq_or_op.subject?
+            pre_subject << sseq_or_op
+          else
+            subject = sseq_or_op.dup
+            subject.members = sseq_or_op.members.dup
+            subject.subject = false
+            has = []
+          end
+        end
+
+        return self unless subject
+
+        unless has.empty?
+          subject.members << Pseudo.new(:class, 'has', nil, CommaSequence.new([Sequence.new(has)]))
+        end
+        Sequence.new(pre_subject + [subject])
+      end
+
       private
 
       # Conceptually, this expands "parenthesized selectors". That is, if we
@@ -157,6 +214,7 @@ module Sass
         prefixes = [[]]
 
         path.each do |current|
+          next if current.empty?
           current = current.dup
           last_current = [current.pop]
           prefixes = Sass::Util.flatten(prefixes.map do |prefix|
@@ -290,7 +348,7 @@ module Sass
             elsif sel2.superselector?(sel1)
               res.unshift sel1, '~'
             else
-              merged = sel1.unify(sel2.members, sel2.subject?)
+              merged = sel1.unify(sel2)
               res.unshift [
                 [sel1, '~', sel2, '~'],
                 [sel2, '~', sel1, '~'],
@@ -307,7 +365,7 @@ module Sass
             if tilde_sel.superselector?(plus_sel)
               res.unshift plus_sel, '+'
             else
-              merged = plus_sel.unify(tilde_sel.members, tilde_sel.subject?)
+              merged = plus_sel.unify(tilde_sel)
               res.unshift [
                 [tilde_sel, '~', plus_sel, '+'],
                 ([merged, '+'] if merged)
@@ -320,7 +378,7 @@ module Sass
             res.unshift sel1, op1
             seq2.push sel2, op2
           elsif op1 == op2
-            merged = sel1.unify(sel2.members, sel2.subject?)
+            merged = sel1.unify(sel2)
             return unless merged
             res.unshift merged, op1
           else
@@ -410,12 +468,12 @@ module Sass
           seq1.first.is_a?(String) || seq2.first.is_a?(String)
         # More complex selectors are never superselectors of less complex ones
         return if seq1.size > seq2.size
-        return seq1.first.superselector?(seq2.last) if seq1.size == 1
+        return seq1.first.superselector?(seq2.last, seq2[0...-1]) if seq1.size == 1
 
         _, si = Sass::Util.enum_with_index(seq2).find do |e, i|
           return if i == seq2.size - 1
           next if e.is_a?(String)
-          seq1.first.superselector?(e)
+          seq1.first.superselector?(e, seq2[0...i])
         end
         return unless si
 
@@ -473,7 +531,15 @@ module Sass
         # separate sequences should limit the quadratic behavior.
         seqses.each_with_index do |seqs1, i|
           result[i] = seqs1.reject do |seq1|
-            max_spec = _sources(seq1).map {|seq| seq.specificity}.max || 0
+            # The maximum specificity of the sources that caused [seq1] to be
+            # generated. In order for [seq1] to be removed, there must be
+            # another selector that's a superselector of it *and* that has
+            # specificity greater or equal to this.
+            max_spec = _sources(seq1).map do |seq|
+              spec = seq.specificity
+              spec.is_a?(Range) ? spec.max : spec
+            end.max || 0
+
             result.any? do |seqs2|
               next if seqs1.equal?(seqs2)
               # Second Law of Extend: the specificity of a generated selector
@@ -481,7 +547,11 @@ module Sass
               # selector.
               #
               # See https://github.com/nex3/sass/issues/324.
-              seqs2.any? {|seq2| _specificity(seq2) >= max_spec && _superselector?(seq2, seq1)}
+              seqs2.any? do |seq2|
+                spec2 = _specificity(seq2)
+                spec2 = spec2.begin if spec2.is_a?(Range)
+                spec2 >= max_spec && _superselector?(seq2, seq1)
+              end
             end
           end
         end

data/lib/sass/selector/simple.rb

@@ -14,28 +14,18 @@ module Sass
       # @return [String, nil]
       attr_accessor :filename
 
-      # Returns a representation of the node as an array of strings and
-      # potentially {Sass::Script::Tree::Node}s (if there's interpolation in the
-      # selector). When the interpolation is resolved and the strings are joined
-      # together, this will be the string representation of this node.
-      #
-      # @return [Array<String, Sass::Script::Tree::Node>]
-      def to_a
-        Sass::Util.abstract(self)
-      end
-
-      # Returns a string representation of the node.
-      # This is basically the selector string.
+      # @see #to_s
       #
       # @return [String]
       def inspect
-        to_a.map {|e| e.is_a?(Sass::Script::Tree::Node) ? "\#{#{e.to_sass}}" : e}.join
+        to_s
       end
 
-      # @see \{#inspect}
+      # Returns the selector string.
+      #
       # @return [String]
       def to_s
-        inspect
+        Sass::Util.abstract(self)
       end
 
       # Returns a hash code for this selector object.
@@ -58,7 +48,7 @@ module Sass
       # @param other [Object] The object to test equality against
       # @return [Boolean] Whether or not this is equal to `other`
       def eql?(other)
-        other.class == self.class && other.hash == hash && other.equality_key.eql?(equality_key)
+        other.class == self.class && other.hash == hash && other.equality_key == equality_key
       end
       alias_method :==, :eql?
 
@@ -83,10 +73,10 @@ module Sass
         return sels if sels.any? {|sel2| eql?(sel2)}
         sels_with_ix = Sass::Util.enum_with_index(sels)
         _, i =
-          if is_a?(Pseudo) || is_a?(SelectorPseudoClass)
+          if is_a?(Pseudo)
             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)}
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo)}
           end
         return sels + [self] unless i
         sels[0...i] + [self] + sels[i..-1]
@@ -96,12 +86,11 @@ module Sass
 
       # Returns the key used for testing whether selectors are equal.
       #
-      # This is based on \{#to\_a}, with adjacent strings merged so that
-      # selectors constructed in different ways are considered equivalent.
+      # This is a cached version of \{#to\_s}.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       def equality_key
-        @equality_key ||= Sass::Util.merge_adjacent_strings(to_a)
+        @equality_key ||= to_s
       end
 
       # Unifies two namespaces,
@@ -118,9 +107,9 @@ module Sass
       #   could be found at all.
       #   If the second value is `false`, the first should be ignored.
       def unify_namespaces(ns1, ns2)
-        return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == ['*'] || ns2.nil? || ns2 == ['*']
-        return ns2, true if ns1 == ['*']
-        return ns1, true if ns2 == ['*']
+        return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == '*' || ns2.nil? || ns2 == '*'
+        return ns2, true if ns1 == '*'
+        return ns1, true if ns2 == '*'
         [ns1 || ns2, true]
       end
     end