sass4 4.0.0

data/lib/sass/selector/comma_sequence.rb

@@ -0,0 +1,195 @@
+module Sass
+  module Selector
+    # A comma-separated sequence of selectors.
+    class CommaSequence < AbstractSequence
+      @@compound_extend_deprecation = Sass::Deprecation.new
+
+      # The comma-separated selector sequences
+      # represented by this class.
+      #
+      # @return [Array<Sequence>]
+      attr_reader :members
+
+      # @param seqs [Array<Sequence>] See \{#members}
+      def initialize(seqs)
+        @members = seqs
+      end
+
+      # Resolves the {Parent} selectors within this selector
+      # by replacing them with the given parent selector,
+      # handling commas appropriately.
+      #
+      # @param super_cseq [CommaSequence] The parent selector
+      # @param implicit_parent [Boolean] Whether the the parent
+      #   selector should automatically be prepended to the resolved
+      #   selector if it contains no parent refs.
+      # @return [CommaSequence] This selector, with parent references resolved
+      # @raise [Sass::SyntaxError] If a parent selector is invalid
+      def resolve_parent_refs(super_cseq, implicit_parent = true)
+        if super_cseq.nil?
+          if contains_parent_ref?
+            raise Sass::SyntaxError.new(
+              "Base-level rules cannot contain the parent-selector-referencing character '&'.")
+          end
+          return self
+        end
+
+        CommaSequence.new(Sass::Util.flatten_vertically(@members.map do |seq|
+          seq.resolve_parent_refs(super_cseq, implicit_parent).members
+        end))
+      end
+
+      # Returns whether there's a {Parent} selector anywhere in this sequence.
+      #
+      # @return [Boolean]
+      def contains_parent_ref?
+        @members.any? {|sel| sel.contains_parent_ref?}
+      end
+
+      # Non-destrucively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @todo Link this to the reference documentation on `@extend`
+      #   when such a thing exists.
+      #
+      # @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 [CommaSequence] A copy of this selector,
+      #   with extensions made according to `extends`
+      def do_extend(extends, parent_directives = [], replace = false, seen = Set.new,
+          original = true)
+        CommaSequence.new(members.map do |seq|
+          seq.do_extend(extends, parent_directives, replace, seen, original)
+        end.flatten)
+      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 cseq [CommaSequence]
+      # @return [Boolean]
+      def superselector?(cseq)
+        cseq.members.all? {|seq1| members.any? {|seq2| seq2.superselector?(seq1)}}
+      end
+
+      # Populates a subset map that can then be used to extend
+      # selectors. This registers an extension with this selector as
+      # the extender and `extendee` as the extendee.
+      #
+      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
+      #                                       Sass::Tree::Visitors::Cssize::Extend}]
+      #   The subset map representing the extensions to perform.
+      # @param extendee [CommaSequence] The selector being extended.
+      # @param extend_node [Sass::Tree::ExtendNode]
+      #   The node that caused this extension.
+      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
+      #   The parent directives containing `extend_node`.
+      # @param allow_compound_target [Boolean]
+      #   Whether `extendee` is allowed to contain compound selectors.
+      # @raise [Sass::SyntaxError] if this extension is invalid.
+      def populate_extends(extends, extendee, extend_node = nil, parent_directives = [],
+          allow_compound_target = false)
+        extendee.members.each do |seq|
+          if seq.members.size > 1
+            raise Sass::SyntaxError.new("Can't extend #{seq}: can't extend nested selectors")
+          end
+
+          sseq = seq.members.first
+          if !sseq.is_a?(Sass::Selector::SimpleSequence)
+            raise Sass::SyntaxError.new("Can't extend #{seq}: invalid selector")
+          elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
+            raise Sass::SyntaxError.new("Can't extend #{seq}: can't extend parent selectors")
+          end
+
+          sel = sseq.members
+          if !allow_compound_target && sel.length > 1
+            @@compound_extend_deprecation.warn(sseq.filename, sseq.line, <<WARNING)
+Extending a compound selector, #{sseq}, is deprecated and will not be supported in a future release.
+Consider "@extend #{sseq.members.join(', ')}" instead.
+See http://bit.ly/ExtendCompound for details.
+WARNING
+          end
+
+          members.each do |member|
+            unless member.members.last.is_a?(Sass::Selector::SimpleSequence)
+              raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
+            end
+
+            extends[sel] = Sass::Tree::Visitors::Cssize::Extend.new(
+              member, sel, extend_node, parent_directives, false)
+          end
+        end
+      end
+
+      # Unifies this with another comma selector to produce a selector
+      # that matches (a subset of) the intersection of the two inputs.
+      #
+      # @param other [CommaSequence]
+      # @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)
+        results = members.map {|seq1| other.members.map {|seq2| seq1.unify(seq2)}}.flatten.compact
+        results.empty? ? nil : CommaSequence.new(results.map {|cseq| cseq.members}.flatten)
+      end
+
+      # Returns a SassScript representation of this selector.
+      #
+      # @return [Sass::Script::Value::List]
+      def to_sass_script
+        Sass::Script::Value::List.new(members.map do |seq|
+          Sass::Script::Value::List.new(seq.members.map do |component|
+            next if component == "\n"
+            Sass::Script::Value::String.new(component.to_s)
+          end.compact, separator: :space)
+        end, separator: :comma)
+      end
+
+      # Returns a string representation of the sequence.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        members.map {|m| m.inspect}.join(", ")
+      end
+
+      # @see AbstractSequence#to_s
+      def to_s(opts = {})
+        @members.map do |m|
+          next if opts[:placeholder] == false && m.invisible?
+          m.to_s(opts)
+        end.compact.
+          join(opts[:style] == :compressed ? "," : ", ").
+          gsub(", \n", ",\n")
+      end
+
+      private
+
+      def _hash
+        members.hash
+      end
+
+      def _eql?(other)
+        other.class == self.class && other.members.eql?(members)
+      end
+    end
+  end
+end

data/lib/sass/selector/pseudo.rb

@@ -0,0 +1,291 @@
+# coding: utf-8
+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
+
+      def unique?
+        type == :class && normalized_name == 'root'
+      end
+
+      # Whether or not this selector should be hidden due to containing a
+      # placeholder.
+      def invisible?
+        # :not() is a special case—if you eliminate all the placeholders from
+        # it, it should match anything.
+        name != 'not' && @selector && @selector.members.all? {|s| s.invisible?}
+      end
+
+      # Returns a copy of this with \{#selector} set to \{#new\_selector}.
+      #
+      # @param new_selector [CommaSequence]
+      # @return [Array<Simple>]
+      def with_selector(new_selector)
+        result = 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.
+              # Support :has, :host, :host-context, :slotted within :not
+              if sel.normalized_name == 'matches'
+                sel.selector.members
+              elsif %w(has host host-context slotted).include?(sel.normalized_name)
+                # For :has, :host, :host-context, :slotted, we need to preserve the selector
+                # as-is to maintain the semantic meaning
+                sel
+              else
+                []
+              end
+            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', 'slotted'
+              # 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))
+
+        # Older browsers support :not but only with a single complex selector.
+        # In order to support those browsers, we break up the contents of a :not
+        # unless it originally contained a selector list.
+        return [result] unless normalized_name == 'not'
+        return [result] if selector.members.length > 1
+        result.selector.members.map do |seq|
+          Pseudo.new(syntactic_type, name, arg, CommaSequence.new([seq]))
+        end
+      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(opts = {})
+        # :not() is a special case, because :not(<nothing>) should match
+        # everything.
+        return '' if name == 'not' && @selector && @selector.members.all? {|m| m.invisible?}
+
+        res = (syntactic_type == :class ? ":" : "::") + @name
+        if @arg || @selector
+          res << "("
+          res << Sass::Util.strip_except_escapes(@arg) if @arg
+          res << " " if @arg && @selector
+          res << @selector.to_s(opts) 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', 'slotted'
+          # 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