oreorenasass 3.4.4 → 3.4.5

data/lib/sass/selector/simple.rb

@@ -14,18 +14,29 @@ module Sass
       # @return [String, nil]
       attr_accessor :filename
 
-      # @see #to_s
+      # Returns a representation of the node
+      # as an array of strings and potentially {Sass::Script::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::Node>]
+      def to_a
+        Sass::Util.abstract(self)
+      end
+
+      # Returns a string representation of the node.
+      # This is basically the selector string.
       #
       # @return [String]
       def inspect
-        to_s
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
-      # Returns the selector string.
-      #
+      # @see \{#inspect}
       # @return [String]
       def to_s
-        Sass::Util.abstract(self)
+        inspect
       end
 
       # Returns a hash code for this selector object.
@@ -36,7 +47,7 @@ module Sass
       #
       # @return [Fixnum]
       def hash
-        @_hash ||= equality_key.hash
+        @_hash ||= to_a.hash
       end
 
       # Checks equality between this and another object.
@@ -48,7 +59,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 == equality_key
+        other.class == self.class && other.hash == self.hash && other.to_a.eql?(to_a)
       end
       alias_method :==, :eql?
 
@@ -73,26 +84,17 @@ module Sass
         return sels if sels.any? {|sel2| eql?(sel2)}
         sels_with_ix = Sass::Util.enum_with_index(sels)
         _, i =
-          if is_a?(Pseudo)
+          if self.is_a?(Pseudo) || self.is_a?(SelectorPseudoClass)
             sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.type == :element)}
           else
-            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo)}
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
           end
         return sels + [self] unless i
-        sels[0...i] + [self] + sels[i..-1]
+        return 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.
       #
@@ -107,10 +109,10 @@ 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 == '*'
-        [ns1 || ns2, true]
+        return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == ['*'] || ns2.nil? || ns2 == ['*']
+        return ns2, true if ns1 == ['*']
+        return ns1, true if ns2 == ['*']
+        return ns1 || ns2, true
       end
     end
   end

data/lib/sass/selector/simple_sequence.rb

@@ -21,16 +21,11 @@ module Sass
       # 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.
+      # This is populated during the {#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
 
@@ -43,16 +38,11 @@ module Sass
       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}
+        @pseudo_elements ||= (members - [base]).
+          select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
       end
 
-      # Returns the non-base, non-pseudo-element selectors in this sequence.
+      # Returns the non-base, non-pseudo-class selectors in this sequence.
       #
       # @return [Set<Simple>]
       def rest
@@ -70,143 +60,74 @@ module Sass
 
       # @param selectors [Array<Simple>] See \{#members}
       # @param subject [Boolean] See \{#subject?}
-      # @param source_range [Sass::Source::Range]
-      def initialize(selectors, subject, source_range = nil)
+      # @param sources [Set<Sequence>]
+      def initialize(selectors, subject, sources = Set.new)
         @members = selectors
         @subject = subject
-        @sources = Set.new
-        @source_range = source_range
+        @sources = sources
       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
+      # @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_cseq)
+      def resolve_parent_refs(super_seq)
         # 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 [self] unless @members.first.is_a?(Parent)
 
-        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
+        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
 
-          Sequence.new(members[0...-1] +
-            [SimpleSequence.new(parent_sub + @members[1..-1], subject?)] +
-            [newline].compact)
-        end)
+        members[0...-1] +
+          [SimpleSequence.new(members.last.members + @members[1..-1], subject?)] +
+          [newline].compact
       end
 
-      # Non-destructively extends this selector with the extensions specified in a hash
+      # 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.
-      # @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
+      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(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)}
+          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
-        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.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}, returning
-      # another `SimpleSequence` that is a subselector of both input
-      # selectors.
+      # Unifies this selector with another {SimpleSequence}'s {SimpleSequence#members members array},
+      # returning another `SimpleSequence`
+      # that matches both this selector and the input selector.
       #
-      # @param other [SimpleSequence]
+      # @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.
@@ -215,13 +136,12 @@ module Sass
       #   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|
+      def unify(sels, other_subject)
+        return unless sseq = members.inject(sels) do |member, sel|
           return unless member
           sel.unify(member)
         end
-        return unless sseq
-        SimpleSequence.new(sseq, other.subject? || subject?)
+        SimpleSequence.new(sseq, other_subject || subject?)
       end
 
       # Returns whether or not this selector matches all elements
@@ -230,44 +150,17 @@ module Sass
       # @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.
+      # @param sseq [SimpleSequence]
       # @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
+      def superselector?(sseq)
+        (base.nil? || base.eql?(sseq.base)) &&
+          pseudo_elements.eql?(sseq.pseudo_elements) &&
+          rest.subset?(sseq.rest)
       end
 
-      # @see Simple#to_s
-      def to_s
-        res = @members.join
+      # @see Simple#to_a
+      def to_a
+        res = @members.map {|sel| sel.to_a}.flatten
         res << '!' if subject?
         res
       end
@@ -277,13 +170,11 @@ module Sass
       #
       # @return [String]
       def inspect
-        res = members.map {|m| m.inspect}.join
-        res << '!' if subject?
-        res
+        members.map {|m| m.inspect}.join
       end
 
       # Return a copy of this simple sequence with `sources` merged into the
-      # {SimpleSequence#sources} set.
+      # {#sources} set.
       #
       # @param sources [Set<Sequence>]
       # @return [SimpleSequence]
@@ -299,17 +190,16 @@ module Sass
       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
+        return true if Sass::Util.subsequence?(dirs1, dirs2)
 
-        # 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
+        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
@@ -317,8 +207,8 @@ MESSAGE
       end
 
       def _eql?(other)
-        other.base.eql?(base) && other.pseudo_elements == pseudo_elements &&
-          Sass::Util.set_eql?(other.rest, rest) && other.subject? == subject?
+        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

data/lib/sass/shared.rb

@@ -44,7 +44,7 @@ module Sass
         str << scanner.matched
         count += 1 if scanner.matched[-1] == start
         count -= 1 if scanner.matched[-1] == finish
-        return [str, scanner.rest] if count == 0
+        return [str.strip, scanner.rest] if count == 0
       end
     end
 

data/lib/sass/supports.rb

@@ -4,7 +4,7 @@ module Sass::Supports
   class Condition
     # Runs the SassScript in the supports condition.
     #
-    # @param environment [Sass::Environment] The environment in which to run the script.
+    # @param env [Sass::Environment] The environment in which to run the script.
     def perform(environment); Sass::Util.abstract(self); end
 
     # Returns the CSS for this condition.
@@ -81,12 +81,12 @@ module Sass::Supports
 
     def left_parens(str)
       return "(#{str})" if @left.is_a?(Negation)
-      str
+      return str
     end
 
     def right_parens(str)
       return "(#{str})" if @right.is_a?(Negation) || @right.is_a?(Operator)
-      str
+      return str
     end
   end
 
@@ -127,25 +127,26 @@ module Sass::Supports
 
     def parens(str)
       return "(#{str})" if @condition.is_a?(Negation) || @condition.is_a?(Operator)
-      str
+      return str
     end
   end
 
   # A declaration condition (e.g. `(feature: value)`).
   class Declaration < Condition
-    # @return [Sass::Script::Tree::Node] The feature name.
+    # The feature name.
+    #
+    # @param [Sass::Script::Node]
     attr_accessor :name
 
-    # @!attribute resolved_name
-    #   The name of the feature after any SassScript has been resolved.
-    #   Only set once \{Tree::Visitors::Perform} has been run.
+    # The name of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
     #
-    #   @return [String]
+    # @return [String]
     attr_accessor :resolved_name
 
     # The feature value.
     #
-    # @return [Sass::Script::Tree::Node]
+    # @param [Sass::Script::Node]
     attr_accessor :value
 
     # The value of the feature after any SassScript has been resolved.
@@ -189,7 +190,7 @@ module Sass::Supports
   class Interpolation < Condition
     # The SassScript expression in the interpolation.
     #
-    # @return [Sass::Script::Tree::Node]
+    # @param [Sass::Script::Node]
     attr_accessor :value
 
     # The value of the expression after it's been resolved.
@@ -203,7 +204,8 @@ module Sass::Supports
     end
 
     def perform(env)
-      @resolved_value = value.perform(env).to_s(:quote => :none)
+      val = value.perform(env)
+      @resolved_value = val.is_a?(Sass::Script::String) ? val.value : val.to_s
     end
 
     def to_css
@@ -211,7 +213,7 @@ module Sass::Supports
     end
 
     def to_src(options)
-      @value.to_sass(options)
+      "\#{#{@value.to_sass(options)}}"
     end
 
     def deep_copy