oreorenasass 3.4.0

data/lib/sass/selector/simple.rb

@@ -0,0 +1,117 @@
+module Sass
+  module Selector
+    # The abstract superclass for simple selectors
+    # (that is, those that don't compose multiple selectors).
+    class Simple
+      # The line of the Sass template on which this selector was declared.
+      #
+      # @return [Fixnum]
+      attr_accessor :line
+
+      # The name of the file in which this selector was declared,
+      # or `nil` if it was not declared in a file (e.g. on stdin).
+      #
+      # @return [String, nil]
+      attr_accessor :filename
+
+      # @see #to_s
+      #
+      # @return [String]
+      def inspect
+        to_s
+      end
+
+      # Returns the selector string.
+      #
+      # @return [String]
+      def to_s
+        Sass::Util.abstract(self)
+      end
+
+      # Returns a hash code for this selector object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @return [Fixnum]
+      def hash
+        @_hash ||= equality_key.hash
+      end
+
+      # Checks equality between this and another object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @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 == equality_key
+      end
+      alias_method :==, :eql?
+
+      # Unifies this selector with a {SimpleSequence}'s {SimpleSequence#members members array},
+      # returning another `SimpleSequence` members array
+      # that matches both this selector and the input selector.
+      #
+      # By default, this just appends this selector to the end of the array
+      # (or returns the original array if this selector already exists in it).
+      #
+      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
+      # @return [Array<Simple>, nil] A {SimpleSequence} {SimpleSequence#members members array}
+      #   matching both `sels` and this selector,
+      #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
+      # @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(sels)
+        return sels if sels.any? {|sel2| eql?(sel2)}
+        sels_with_ix = Sass::Util.enum_with_index(sels)
+        _, i =
+          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)}
+          end
+        return sels + [self] unless i
+        sels[0...i] + [self] + sels[i..-1]
+      end
+
+      protected
+
+      # Returns the key used for testing whether selectors are equal.
+      #
+      # This is a cached version of \{#to\_s}.
+      #
+      # @return [String]
+      def equality_key
+        @equality_key ||= to_s
+      end
+
+      # Unifies two namespaces,
+      # returning a namespace that works for both of them if possible.
+      #
+      # @param ns1 [String, nil] The first namespace.
+      #   `nil` means none specified, e.g. `foo`.
+      #   The empty string means no namespace specified, e.g. `|foo`.
+      #   `"*"` means any namespace is allowed, e.g. `*|foo`.
+      # @param ns2 [String, nil] The second namespace. See `ns1`.
+      # @return [Array(String or nil, Boolean)]
+      #   The first value is the unified namespace, or `nil` for no namespace.
+      #   The second value is whether or not a namespace that works for both inputs
+      #   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 == '*'
+        [ns1 || ns2, true]
+      end
+    end
+  end
+end

data/lib/sass/selector/simple_sequence.rb

@@ -0,0 +1,325 @@
+module Sass
+  module Selector
+    # A unseparated sequence of selectors
+    # that all apply to a single element.
+    # For example, `.foo#bar[attr=baz]` is a simple sequence
+    # of the selectors `.foo`, `#bar`, and `[attr=baz]`.
+    class SimpleSequence < AbstractSequence
+      # The array of individual selectors.
+      #
+      # @return [Array<Simple>]
+      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 {Sequence#do_extend} process.
+      #
+      # @return {Set<Sequence>}
+      attr_accessor :sources
+
+      # This sequence source range.
+      #
+      # @return [Sass::Source::Range]
+      attr_accessor :source_range
+
+      # @see \{#subject?}
+      attr_writer :subject
+
+      # Returns the element or universal selector in this sequence,
+      # if it exists.
+      #
+      # @return [Element, Universal, nil]
+      def base
+        @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
+      end
+
+      def pseudo_elements
+        @pseudo_elements ||= members.select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
+      end
+
+      def selector_pseudo_classes
+        @selector_pseudo_classes ||= members.
+          select {|sel| sel.is_a?(Pseudo) && sel.type == :class && sel.selector}.
+          group_by {|sel| sel.normalized_name}
+      end
+
+      # Returns the non-base, non-pseudo-element selectors in this sequence.
+      #
+      # @return [Set<Simple>]
+      def rest
+        @rest ||= Set.new(members - [base] - pseudo_elements)
+      end
+
+      # Whether or not this compound selector is the subject of the parent
+      # selector; that is, whether it is prepended with `$` and represents the
+      # actual element that will be selected.
+      #
+      # @return [Boolean]
+      def subject?
+        @subject
+      end
+
+      # @param selectors [Array<Simple>] See \{#members}
+      # @param subject [Boolean] See \{#subject?}
+      # @param source_range [Sass::Source::Range]
+      def initialize(selectors, subject, source_range = nil)
+        @members = selectors
+        @subject = subject
+        @sources = Set.new
+        @source_range = source_range
+      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
+      # @return [CommaSequence] This selector, with parent references resolved
+      # @raise [Sass::SyntaxError] If a parent selector is invalid
+      def resolve_parent_refs(super_cseq)
+        # Parent selector only appears as the first selector in the sequence
+        unless (parent = @members.first).is_a?(Parent)
+          return CommaSequence.new([Sequence.new([self])])
+        end
+
+        return super_cseq if @members.size == 1 && parent.suffix.nil?
+
+        CommaSequence.new(super_cseq.members.map do |super_seq|
+          members = super_seq.members.dup
+          newline = members.pop if members.last == "\n"
+          unless members.last.is_a?(SimpleSequence)
+            raise Sass::SyntaxError.new("Invalid parent selector for \"#{self}\": \"" +
+              super_seq.to_s + '"')
+          end
+
+          parent_sub = members.last.members
+          unless parent.suffix.nil?
+            parent_sub = parent_sub.dup
+            parent_sub[-1] = parent_sub.last.dup
+            case parent_sub.last
+            when Sass::Selector::Class, Sass::Selector::Id, Sass::Selector::Placeholder
+              parent_sub[-1] = parent_sub.last.class.new(parent_sub.last.name + parent.suffix)
+            when Sass::Selector::Element
+              parent_sub[-1] = parent_sub.last.class.new(
+                parent_sub.last.name + parent.suffix,
+                parent_sub.last.namespace)
+            when Sass::Selector::Pseudo
+              if parent_sub.last.arg || parent_sub.last.selector
+                raise Sass::SyntaxError.new("Invalid parent selector for \"#{self}\": \"" +
+                  super_seq.to_s + '"')
+              end
+              parent_sub[-1] = Sass::Selector::Pseudo.new(
+                parent_sub.last.type,
+                parent_sub.last.name + parent.suffix,
+                nil, nil)
+            else
+              raise Sass::SyntaxError.new("Invalid parent selector for \"#{self}\": \"" +
+                super_seq.to_s + '"')
+            end
+          end
+
+          Sequence.new(members[0...-1] +
+            [SimpleSequence.new(parent_sub + @members[1..-1], subject?)] +
+            [newline].compact)
+        end)
+      end
+
+      # Non-destructively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @param extends [{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 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`.
+      # @see CommaSequence#do_extend
+      def do_extend(extends, parent_directives, replace, seen)
+        seen_with_pseudo_selectors = seen.dup
+
+        modified_original = false
+        members = Sass::Util.enum_with_index(self.members).map do |sel, i|
+          next sel unless sel.is_a?(Pseudo) && sel.selector
+          next sel if seen.include?([sel])
+          extended = sel.selector.do_extend(extends, parent_directives, replace, seen, !:original)
+          next sel if extended == sel.selector
+          extended.members.reject! {|seq| seq.has_placeholder?}
+          modified_original = true
+          result = sel.with_selector(extended)
+          seen_with_pseudo_selectors << [result]
+          result
+        end
+
+        groups = Sass::Util.group_by_to_a(extends[members.to_set]) {|ex| ex.extender}
+        groups.map! do |seq, group|
+          sels = group.map {|e| e.target}.flatten
+          # If A {@extend B} and C {...},
+          # seq is A, sels is B, and self is C
+
+          self_without_sel = Sass::Util.array_minus(members, sels)
+          group.each {|e| e.result = :failed_to_unify unless e.result == :succeeded}
+          unified = seq.members.last.unify(SimpleSequence.new(self_without_sel, subject?))
+          next unless unified
+          group.each {|e| e.result = :succeeded}
+          group.each {|e| check_directives_match!(e, parent_directives)}
+          new_seq = Sequence.new(seq.members[0...-1] + [unified])
+          new_seq.add_sources!(sources + [seq])
+          [sels, new_seq]
+        end
+        groups.compact!
+        groups.map! do |sels, seq|
+          next [] if seen.include?(sels)
+          seq.do_extend(
+            extends, parent_directives, !:replace, seen_with_pseudo_selectors + [sels], !:original)
+        end
+        groups.flatten!
+
+        if modified_original || !replace || groups.empty?
+          # First Law of Extend: the result of extending a selector should
+          # (almost) always contain the base selector.
+          #
+          # See https://github.com/nex3/sass/issues/324.
+          original = Sequence.new([SimpleSequence.new(members, @subject, source_range)])
+          original.add_sources! sources
+          groups.unshift original
+        end
+        groups.uniq!
+        groups
+      end
+
+      # Unifies this selector with another {SimpleSequence}, returning
+      # another `SimpleSequence` that is a subselector of both input
+      # selectors.
+      #
+      # @param other [SimpleSequence]
+      # @return [SimpleSequence, nil] A {SimpleSequence} matching both `sels` and this selector,
+      #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
+      # @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)
+        sseq = members.inject(other.members) do |member, sel|
+          return unless member
+          sel.unify(member)
+        end
+        return unless sseq
+        SimpleSequence.new(sseq, other.subject? || subject?)
+      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 = [])
+        return false unless base.nil? || base.eql?(their_sseq.base)
+        return false unless pseudo_elements.eql?(their_sseq.pseudo_elements)
+        our_spcs = selector_pseudo_classes
+        their_spcs = their_sseq.selector_pseudo_classes
+
+        # Some psuedo-selectors can be subselectors of non-pseudo selectors.
+        # Pull those out here so we can efficiently check against them below.
+        their_subselector_pseudos = %w[matches any nth-child nth-last-child].
+          map {|name| their_spcs[name] || []}.flatten
+
+        # If `self`'s non-pseudo simple selectors aren't a subset of `their_sseq`'s,
+        # it's definitely not a superselector. This also considers being matched
+        # by `:matches` or `:any`.
+        return false unless rest.all? do |our_sel|
+          next true if our_sel.is_a?(Pseudo) && our_sel.selector
+          next true if their_sseq.rest.include?(our_sel)
+          their_subselector_pseudos.any? do |their_pseudo|
+            their_pseudo.selector.members.all? do |their_seq|
+              next false unless their_seq.members.length == 1
+              their_sseq = their_seq.members.first
+              next false unless their_sseq.is_a?(SimpleSequence)
+              their_sseq.rest.include?(our_sel)
+            end
+          end
+        end
+
+        our_spcs.all? do |name, pseudos|
+          pseudos.all? {|pseudo| pseudo.superselector?(their_sseq, parents)}
+        end
+      end
+
+      # @see Simple#to_s
+      def to_s
+        res = @members.join
+        res << '!' if subject?
+        res
+      end
+
+      # Returns a string representation of the sequence.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        res = members.map {|m| m.inspect}.join
+        res << '!' if subject?
+        res
+      end
+
+      # Return a copy of this simple sequence with `sources` merged into the
+      # {SimpleSequence#sources} set.
+      #
+      # @param sources [Set<Sequence>]
+      # @return [SimpleSequence]
+      def with_more_sources(sources)
+        sseq = dup
+        sseq.members = members.dup
+        sseq.sources = self.sources | sources
+        sseq
+      end
+
+      private
+
+      def check_directives_match!(extend, parent_directives)
+        dirs1 = extend.directives.map {|d| d.resolved_value}
+        dirs2 = parent_directives.map {|d| d.resolved_value}
+        return if Sass::Util.subsequence?(dirs1, dirs2)
+        line = extend.node.line
+        filename = extend.node.filename
+
+        # TODO(nweiz): this should use the Sass stack trace of the extend node,
+        # not the selector.
+        raise Sass::SyntaxError.new(<<MESSAGE)
+You may not @extend an outer selector from within #{extend.directives.last.name}.
+You may only @extend selectors within the same directive.
+From "@extend #{extend.target.join(', ')}" on line #{line}#{" of #{filename}" if filename}.
+MESSAGE
+      end
+
+      def _hash
+        [base, Sass::Util.set_hash(rest)].hash
+      end
+
+      def _eql?(other)
+        other.base.eql?(base) && other.pseudo_elements == pseudo_elements &&
+          Sass::Util.set_eql?(other.rest, rest) && other.subject? == subject?
+      end
+    end
+  end
+end

data/lib/sass/selector.rb

@@ -0,0 +1,326 @@
+require 'sass/selector/simple'
+require 'sass/selector/abstract_sequence'
+require 'sass/selector/comma_sequence'
+require 'sass/selector/pseudo'
+require 'sass/selector/sequence'
+require 'sass/selector/simple_sequence'
+
+module Sass
+  # A namespace for nodes in the parse tree for selectors.
+  #
+  # {CommaSequence} is the toplevel selector,
+  # representing a comma-separated sequence of {Sequence}s,
+  # such as `foo bar, baz bang`.
+  # {Sequence} is the next level,
+  # representing {SimpleSequence}s separated by combinators (e.g. descendant or child),
+  # such as `foo bar` or `foo > bar baz`.
+  # {SimpleSequence} is a sequence of selectors that all apply to a single element,
+  # such as `foo.bar[attr=val]`.
+  # 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.
+    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.
+    class Parent < Simple
+      # The identifier following the `&`. `nil` indicates no suffix.
+      #
+      # @return [String, nil]
+      attr_reader :suffix
+
+      # @param name [String, nil] See \{#suffix}
+      def initialize(suffix = nil)
+        @suffix = suffix
+      end
+
+      # @see Selector#to_s
+      def to_s
+        "&" + (@suffix || '')
+      end
+
+      # Always raises an exception.
+      #
+      # @raise [Sass::SyntaxError] Parent selectors should be resolved before unification
+      # @see Selector#unify
+      def unify(sels)
+        raise Sass::SyntaxError.new("[BUG] Cannot unify parent selectors.")
+      end
+    end
+
+    # A class selector (e.g. `.foo`).
+    class Class < Simple
+      # The class name.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # @param name [String] The class name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_s
+      def to_s
+        "." + @name
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+
+    # An id selector (e.g. `#foo`).
+    class Id < Simple
+      # The id name.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # @param name [String] The id name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_s
+      def to_s
+        "#" + @name
+      end
+
+      # Returns `nil` if `sels` contains an {Id} selector
+      # with a different name than this one.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        return if sels.any? {|sel2| sel2.is_a?(Id) && name != sel2.name}
+        super
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE**2
+      end
+    end
+
+    # A placeholder selector (e.g. `%foo`).
+    # This exists to be replaced via `@extend`.
+    # Rulesets using this selector will not be printed, but can be extended.
+    # Otherwise, this acts just like a class selector.
+    class Placeholder < Simple
+      # The placeholder name.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # @param name [String] The placeholder name
+      def initialize(name)
+        @name = name
+      end
+
+      # @see Selector#to_s
+      def to_s
+        "%" + @name
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+
+    # A universal selector (`*` in CSS).
+    class Universal < Simple
+      # The selector namespace. `nil` means the default namespace, `""` means no
+      # namespace, `"*"` means any namespace.
+      #
+      # @return [String, nil]
+      attr_reader :namespace
+
+      # @param namespace [String, nil] See \{#namespace}
+      def initialize(namespace)
+        @namespace = namespace
+      end
+
+      # @see Selector#to_s
+      def to_s
+        @namespace ? "#{@namespace}|*" : "*"
+      end
+
+      # Unification of a universal selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # If there is no namespace specified
+      # or any namespace is specified (namespace `"*"`),
+      # then `sel` is returned without change
+      # (unless it's empty, in which case `"*"` is required).
+      #
+      # If a namespace is specified
+      # but `sel` does not specify a namespace,
+      # then the given namespace is applied to `sel`,
+      # either by adding this {Universal} selector
+      # or applying this namespace to an existing {Element} selector.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      # @todo If any branch of a CommaSequence ends up being just `"*"`,
+      #   then all other branches should be eliminated
+      #
+      # @see Selector#unify
+      def unify(sels)
+        name =
+          case sels.first
+          when Universal; :universal
+          when Element; sels.first.name
+          else
+            return [self] + sels unless namespace.nil? || namespace == '*'
+            return sels unless sels.empty?
+            return [self]
+          end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        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`).
+    class Element < Simple
+      # The element name.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The selector namespace. `nil` means the default namespace, `""` means no
+      # namespace, `"*"` means any namespace.
+      #
+      # @return [String, nil]
+      attr_reader :namespace
+
+      # @param name [String] The element name
+      # @param namespace [String, nil] See \{#namespace}
+      def initialize(name, namespace)
+        @name = name
+        @namespace = namespace
+      end
+
+      # @see Selector#to_s
+      def to_s
+        @namespace ? "#{@namespace}|#{@name}" : @name
+      end
+
+      # Unification of an element selector is somewhat complicated,
+      # especially when a namespace is specified.
+      # First, if `sel` contains another {Element} with a different \{#name},
+      # then the selectors can't be unified and `nil` is returned.
+      #
+      # Otherwise, if `sel` doesn't specify a namespace,
+      # or it specifies any namespace (via `"*"`),
+      # then it's returned with this element selector
+      # (e.g. `.foo` becomes `a.foo` or `svg|a.foo`).
+      # Similarly, if this selector doesn't specify a namespace,
+      # the namespace from `sel` is used.
+      #
+      # If both this selector *and* `sel` specify namespaces,
+      # those namespaces are unified via {Simple#unify_namespaces}
+      # and the unified namespace is used, if possible.
+      #
+      # @todo There are lots of cases that this documentation specifies;
+      #   make sure we thoroughly test **all of them**.
+      # @todo Keep track of whether a default namespace has been declared
+      #   and handle namespace-unspecified selectors accordingly.
+      #
+      # @see Selector#unify
+      def unify(sels)
+        case sels.first
+        when Universal;
+        when Element; return unless name == sels.first.name
+        else return [self] + sels
+        end
+
+        ns, accept = unify_namespaces(namespace, sels.first.namespace)
+        return unless accept
+        [Element.new(name, ns)] + sels[1..-1]
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        1
+      end
+    end
+
+    # An attribute selector (e.g. `[href^="http://"]`).
+    class Attribute < Simple
+      # The attribute name.
+      #
+      # @return [Array<String, Sass::Script::Tree::Node>]
+      attr_reader :name
+
+      # The attribute namespace. `nil` means the default namespace, `""` means
+      # no namespace, `"*"` means any namespace.
+      #
+      # @return [String, nil]
+      attr_reader :namespace
+
+      # The matching operator, e.g. `"="` or `"^="`.
+      #
+      # @return [String]
+      attr_reader :operator
+
+      # The right-hand side of the operator.
+      #
+      # @return [String]
+      attr_reader :value
+
+      # Flags for the attribute selector (e.g. `i`).
+      #
+      # @return [String]
+      attr_reader :flags
+
+      # @param name [String] The attribute name
+      # @param namespace [String, nil] See \{#namespace}
+      # @param operator [String] The matching operator, e.g. `"="` or `"^="`
+      # @param value [String] See \{#value}
+      # @param flags [String] See \{#flags}
+      # @comment
+      #   rubocop:disable ParameterLists
+      def initialize(name, namespace, operator, value, flags)
+        # rubocop:enable ParameterLists
+        @name = name
+        @namespace = namespace
+        @operator = operator
+        @value = value
+        @flags = flags
+      end
+
+      # @see Selector#to_s
+      def to_s
+        res = "["
+        res << @namespace << "|" if @namespace
+        res << @name
+        res << @operator << @value if @value
+        res << " " << @flags if @flags
+        res << "]"
+      end
+
+      # @see AbstractSequence#specificity
+      def specificity
+        SPECIFICITY_BASE
+      end
+    end
+  end
+end