xass 0.1.0 → 0.1.1

data/lib/sass/selector/simple_sequence.rb

@@ -1,215 +0,0 @@
-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 {#do_extend} process.
-      #
-      # @return {Set<Sequence>}
-      attr_accessor :sources
-
-      # @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 - [base]).
-          select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
-      end
-
-      # Returns the non-base, non-pseudo-class 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 sources [Set<Sequence>]
-      def initialize(selectors, subject, sources = Set.new)
-        @members = selectors
-        @subject = subject
-        @sources = sources
-      end
-
-      # Resolves the {Parent} selectors within this selector
-      # by replacing them with the given parent selector,
-      # handling commas appropriately.
-      #
-      # @param super_seq [Sequence] The parent selector sequence
-      # @return [Array<SimpleSequence>] This selector, with parent references resolved.
-      #   This is an array because the parent selector is itself a {Sequence}
-      # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_seq)
-        # Parent selector only appears as the first selector in the sequence
-        return [self] unless @members.first.is_a?(Parent)
-
-        members = super_seq.members.dup
-        newline = members.pop if members.last == "\n"
-        return members if @members.size == 1
-        unless members.last.is_a?(SimpleSequence)
-          raise Sass::SyntaxError.new("Invalid parent selector: " + super_seq.to_a.join)
-        end
-
-        members[0...-1] +
-          [SimpleSequence.new(members.last.members + @members[1..-1], subject?)] +
-          [newline].compact
-      end
-
-      # 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, parent_directives)
-      # @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.
-      # @return [Array<Sequence>] A list of selectors generated
-      #   by extending this selector with `extends`.
-      # @see CommaSequence#do_extend
-      def do_extend(extends, parent_directives, seen = Set.new)
-        Sass::Util.group_by_to_a(extends.get(members.to_set)) {|ex, _| ex.extender}.map do |seq, group|
-          sels = group.map {|_, s| s}.flatten
-          # If A {@extend B} and C {...},
-          # seq is A, sels is B, and self is C
-
-          self_without_sel = Sass::Util.array_minus(self.members, sels)
-          group.each {|e, _| e.result = :failed_to_unify unless e.result == :succeeded}
-          next unless unified = seq.members.last.unify(self_without_sel, subject?)
-          group.each {|e, _| e.result = :succeeded}
-          next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?
-          new_seq = Sequence.new(seq.members[0...-1] + [unified])
-          new_seq.add_sources!(sources + [seq])
-          [sels, new_seq]
-        end.compact.map do |sels, seq|
-          seen.include?(sels) ? [] : seq.do_extend(extends, parent_directives, seen + [sels])
-        end.flatten.uniq
-      end
-
-      # Unifies this selector with another {SimpleSequence}'s {SimpleSequence#members members array},
-      # returning another `SimpleSequence`
-      # that matches both this selector and the input selector.
-      #
-      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
-      # @param subject [Boolean] Whether the {SimpleSequence} being merged is a subject.
-      # @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(sels, other_subject)
-        return unless sseq = members.inject(sels) do |member, sel|
-          return unless member
-          sel.unify(member)
-        end
-        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 sseq [SimpleSequence]
-      # @return [Boolean]
-      def superselector?(sseq)
-        (base.nil? || base.eql?(sseq.base)) &&
-          pseudo_elements.eql?(sseq.pseudo_elements) &&
-          rest.subset?(sseq.rest)
-      end
-
-      # @see Simple#to_a
-      def to_a
-        res = @members.map {|sel| sel.to_a}.flatten
-        res << '!' if subject?
-        res
-      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
-
-      # 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 = 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 true if Sass::Util.subsequence?(dirs1, dirs2)
-
-        Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING on line #{extend.node.line}#{" of #{extend.node.filename}" if extend.node.filename}:
-  @extending an outer selector from within #{extend.directives.last.name} is deprecated.
-  You may only @extend selectors within the same directive.
-  This will be an error in Sass 3.3.
-  It can only work once @extend is supported natively in the browser.
-WARNING
-        return false
-      end
-
-      def _hash
-        [base, Sass::Util.set_hash(rest)].hash
-      end
-
-      def _eql?(other)
-        other.base.eql?(self.base) && other.pseudo_elements == pseudo_elements &&
-          Sass::Util.set_eql?(other.rest, self.rest) && other.subject? == self.subject?
-      end
-    end
-  end
-end

data/lib/sass/selector.rb

@@ -1,452 +0,0 @@
-require 'sass/selector/simple'
-require 'sass/selector/abstract_sequence'
-require 'sass/selector/comma_sequence'
-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 seelctor,
-  # 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.
-    #
-    # @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.
-    class Parent < Simple
-      # @see Selector#to_a
-      def to_a
-        ["&"]
-      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 [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # @param name [Array<String, Sass::Script::Node>] The class name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_a
-      def to_a
-        [".", *@name]
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-
-    # An id selector (e.g. `#foo`).
-    class Id < Simple
-      # The id name.
-      #
-      # @return [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # @param name [Array<String, Sass::Script::Node>] The id name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_a
-      def to_a
-        ["#", *@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) && self.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 [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # @param name [Array<String, Sass::Script::Node>] The placeholder name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_a
-      def to_a
-        ["%", *@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 [Array<String, Sass::Script::Node>, nil]
-      attr_reader :namespace
-
-      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
-      def initialize(namespace)
-        @namespace = namespace
-      end
-
-      # @see Selector#to_a
-      def to_a
-        @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 [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # The selector namespace.
-      # `nil` means the default namespace,
-      # `[""]` means no namespace,
-      # `["*"]` means any namespace.
-      #
-      # @return [Array<String, Sass::Script::Node>, nil]
-      attr_reader :namespace
-
-      # @param name [Array<String, Sass::Script::Node>] The element name
-      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
-      def initialize(name, namespace)
-        @name = name
-        @namespace = namespace
-      end
-
-      # @see Selector#to_a
-      def to_a
-        @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
-
-    # Selector interpolation (`#{}` in Sass).
-    class Interpolation < Simple
-      # The script to run.
-      #
-      # @return [Sass::Script::Node]
-      attr_reader :script
-
-      # @param script [Sass::Script::Node] The script to run
-      def initialize(script)
-        @script = script
-      end
-
-      # @see Selector#to_a
-      def to_a
-        [@script]
-      end
-
-      # Always raises an exception.
-      #
-      # @raise [Sass::SyntaxError] Interpolation selectors should be resolved before unification
-      # @see Selector#unify
-      def unify(sels)
-        raise Sass::SyntaxError.new("[BUG] Cannot unify interpolation selectors.")
-      end
-    end
-
-    # An attribute selector (e.g. `[href^="http://"]`).
-    class Attribute < Simple
-      # The attribute name.
-      #
-      # @return [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # The attribute namespace.
-      # `nil` means the default namespace,
-      # `[""]` means no namespace,
-      # `["*"]` means any namespace.
-      #
-      # @return [Array<String, Sass::Script::Node>, nil]
-      attr_reader :namespace
-
-      # The matching operator, e.g. `"="` or `"^="`.
-      #
-      # @return [String]
-      attr_reader :operator
-
-      # The right-hand side of the operator.
-      #
-      # @return [Array<String, Sass::Script::Node>]
-      attr_reader :value
-
-      # Flags for the attribute selector (e.g. `i`).
-      #
-      # @return [Array<String, Sass::Script::Node>]
-      attr_reader :flags
-
-      # @param name [Array<String, Sass::Script::Node>] The attribute name
-      # @param namespace [Array<String, Sass::Script::Node>, nil] See \{#namespace}
-      # @param operator [String] The matching operator, e.g. `"="` or `"^="`
-      # @param value [Array<String, Sass::Script::Node>] See \{#value}
-      # @param value [Array<String, Sass::Script::Node>] See \{#flags}
-      def initialize(name, namespace, operator, value, flags)
-        @name = name
-        @namespace = namespace
-        @operator = operator
-        @value = value
-        @flags = flags
-      end
-
-      # @see Selector#to_a
-      def to_a
-        res = ["["]
-        res.concat(@namespace) << "|" if @namespace
-        res.concat @name
-        (res << @operator).concat @value if @value
-        (res << " ").concat @flags if @flags
-        res << "]"
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-
-    # A pseudoclass (e.g. `:visited`) or pseudoelement (e.g. `::first-line`) selector.
-    # It can have arguments (e.g. `:nth-child(2n+1)`).
-    class Pseudo < Simple
-      # Some psuedo-class-syntax selectors are actually considered
-      # pseudo-elements and must be treated differently. This is a list of such
-      # selectors
-      #
-      # @return [Array<String>]
-      ACTUALLY_ELEMENTS = %w[after before first-line first-letter]
-
-      # 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 [Array<String, Sass::Script::Node>]
-      attr_reader :name
-
-      # The argument to the selector,
-      # or `nil` if no argument was given.
-      #
-      # This may include SassScript nodes that will be run during resolution.
-      # Note that this should not include SassScript nodes
-      # after resolution has taken place.
-      #
-      # @return [Array<String, Sass::Script::Node>, nil]
-      attr_reader :arg
-
-      # @param type [Symbol] See \{#type}
-      # @param name [Array<String, Sass::Script::Node>] The name of the selector
-      # @param arg [nil, Array<String, Sass::Script::Node>] The argument to the selector,
-      #   or nil if no argument was given
-      def initialize(type, name, arg)
-        @syntactic_type = type
-        @name = name
-        @arg = arg
-      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?(name.first) ? :element : syntactic_type
-      end
-
-      # @see Selector#to_a
-      def to_a
-        res = [syntactic_type == :class ? ":" : "::"] + @name
-        (res << "(").concat(Sass::Util.strip_string_array(@arg)) << ")" if @arg
-        res
-      end
-
-      # Returns `nil` if this is a pseudoelement selector
-      # and `sels` contains a pseudoelement selector different than this one.
-      #
-      # @see Selector#unify
-      def unify(sels)
-        return if type == :element && sels.any? do |sel|
-          sel.is_a?(Pseudo) && sel.type == :element &&
-            (sel.name != self.name || sel.arg != self.arg)
-        end
-        super
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        type == :class ? SPECIFICITY_BASE : 1
-      end
-    end
-
-    # A pseudoclass selector whose argument is itself a selector
-    # (e.g. `:not(.foo)` or `:-moz-all(.foo, .bar)`).
-    class SelectorPseudoClass < Simple
-      # The name of the pseudoclass.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # The selector argument.
-      #
-      # @return [Selector::Sequence]
-      attr_reader :selector
-
-      # @param [String] The name of the pseudoclass
-      # @param [Selector::CommaSequence] The selector argument
-      def initialize(name, selector)
-        @name = name
-        @selector = selector
-      end
-
-      # @see Selector#to_a
-      def to_a
-        [":", @name, "("] + @selector.to_a + [")"]
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-  end
-end