oreorenasass 3.4.4 → 3.4.5

data/lib/sass/selector/abstract_sequence.rb

@@ -3,8 +3,8 @@ module Sass
     # The abstract parent class of the various selector sequence classes.
     #
     # All subclasses should implement a `members` method that returns an array
-    # of object that respond to `#line=` and `#filename=`, as well as a `to_s`
-    # method that returns the string representation of the selector.
+    # of object that respond to `#line=` and `#filename=`, as well as a `to_a`
+    # method that returns an array of strings and script nodes.
     class AbstractSequence
       # The line of the Sass template on which this selector was declared.
       #
@@ -55,33 +55,29 @@ 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 && _eql?(other)
+        other.class == self.class && other.hash == self.hash && _eql?(other)
       end
       alias_method :==, :eql?
 
       # Whether or not this selector sequence contains a placeholder selector.
       # Checks recursively.
       def has_placeholder?
-        @has_placeholder ||= members.any? do |m|
-          next m.has_placeholder? if m.is_a?(AbstractSequence)
-          next m.selector && m.selector.has_placeholder? if m.is_a?(Pseudo)
-          m.is_a?(Placeholder)
-        end
+        @has_placeholder ||=
+          members.any? {|m| m.is_a?(AbstractSequence) ? m.has_placeholder? : m.is_a?(Placeholder)}
       end
 
-      # Returns the selector string.
+      # Converts the selector into a string. This is the standard selector
+      # string, along with any SassScript interpolation that may exist.
       #
       # @return [String]
       def to_s
-        Sass::Util.abstract(self)
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
       end
 
-      # Returns the specificity of the selector.
+      # Returns the specificity of the selector as an integer. The base is given
+      # by {Sass::Selector::SPECIFICITY_BASE}.
       #
-      # The base is given by {Sass::Selector::SPECIFICITY_BASE}. This can be a
-      # number or a range representing possible specificities.
-      #
-      # @return [Fixnum, Range]
+      # @return [Fixnum]
       def specificity
         _specificity(members)
       end
@@ -89,20 +85,9 @@ module Sass
       protected
 
       def _specificity(arr)
-        min = 0
-        max = 0
-        arr.each do |m|
-          next if m.is_a?(String)
-          spec = m.specificity
-          if spec.is_a?(Range)
-            min += spec.begin
-            max += spec.end
-          else
-            min += spec
-            max += spec
-          end
-        end
-        min == max ? min : (min..max)
+        spec = 0
+        arr.map {|m| spec += m.is_a?(String) ? 0 : m.specificity}
+        spec
       end
     end
   end

data/lib/sass/selector/comma_sequence.rb

@@ -18,28 +18,24 @@ module Sass
       # 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)
+      def resolve_parent_refs(super_cseq)
         if super_cseq.nil?
           if @members.any? do |sel|
-               sel.members.any? do |sel_or_op|
-                 sel_or_op.is_a?(SimpleSequence) &&
-                   sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
-               end
-             end
-            raise Sass::SyntaxError.new(
-              "Base-level rules cannot contain the parent-selector-referencing character '&'.")
+              sel.members.any? do |sel_or_op|
+                sel_or_op.is_a?(SimpleSequence) && sel_or_op.members.any? {|ssel| ssel.is_a?(Parent)}
+              end
+            end
+            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))
+        CommaSequence.new(
+          super_cseq.members.map do |super_seq|
+            @members.map {|seq| seq.resolve_parent_refs(super_seq)}
+          end.flatten)
       end
 
       # Non-destrucively extends this selector with the extensions specified in a hash
@@ -53,99 +49,18 @@ module Sass
       #   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)
+      def do_extend(extends, parent_directives)
         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`.
-      # @raise [Sass::SyntaxError] if this extension is invalid.
-      def populate_extends(extends, extendee, extend_node = nil, parent_directives = [])
-        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
-          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, :not_found)
-          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, :space)
-        end, :comma)
+            extended = seq.do_extend(extends, parent_directives)
+            # First Law of Extend: the result of extending a selector should
+            # always contain the base selector.
+            #
+            # See https://github.com/nex3/sass/issues/324.
+            extended.unshift seq unless seq.has_placeholder? || extended.include?(seq)
+            extended
+          end.flatten)
       end
 
       # Returns a string representation of the sequence.
@@ -156,9 +71,11 @@ module Sass
         members.map {|m| m.inspect}.join(", ")
       end
 
-      # @see AbstractSequence#to_s
-      def to_s
-        @members.join(", ").gsub(", \n", ",\n")
+      # @see Simple#to_a
+      def to_a
+        arr = Sass::Util.intersperse(@members.map {|m| m.to_a}, ", ").flatten
+        arr.delete("\n")
+        arr
       end
 
       private
@@ -168,7 +85,7 @@ module Sass
       end
 
       def _eql?(other)
-        other.class == self.class && other.members.eql?(members)
+        other.class == self.class && other.members.eql?(self.members)
       end
     end
   end

data/lib/sass/selector/sequence.rb

@@ -33,8 +33,7 @@ module Sass
       # @return [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>]
       attr_reader :members
 
-      # @param seqs_and_ops [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>]
-      #   See \{#members}
+      # @param seqs_and_ops [Array<SimpleSequence, String|Array<Sass::Tree::Node, String>>] See \{#members}
       def initialize(seqs_and_ops)
         @members = seqs_and_ops
       end
@@ -43,94 +42,51 @@ module Sass
       # 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
+      # @param super_seq [Sequence] The parent selector sequence
+      # @return [Sequence] This selector, with parent references resolved
       # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_cseq, implicit_parent)
+      def resolve_parent_refs(super_seq)
         members = @members.dup
         nl = (members.first == "\n" && members.shift)
-        contains_parent_ref = members.any? do |seq_or_op|
-          seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
-        end
-        return CommaSequence.new([self]) if !implicit_parent && !contains_parent_ref
-
-        unless contains_parent_ref
+        unless members.any? do |seq_or_op|
+            seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
+          end
           old_members, members = members, []
           members << nl if nl
           members << SimpleSequence.new([Parent.new], false)
           members += old_members
         end
 
-        CommaSequence.new(Sass::Util.paths(members.map do |sseq_or_op|
-          next [sseq_or_op] unless sseq_or_op.is_a?(SimpleSequence)
-          sseq_or_op.resolve_parent_refs(super_cseq).members
-        end).map do |path|
-          Sequence.new(path.map do |seq_or_op|
-            next seq_or_op unless seq_or_op.is_a?(Sequence)
-            seq_or_op.members
+        Sequence.new(
+          members.map do |seq_or_op|
+            next seq_or_op unless seq_or_op.is_a?(SimpleSequence)
+            seq_or_op.resolve_parent_refs(super_seq)
           end.flatten)
-        end)
       end
 
       # Non-destructively extends this selector with the extensions specified in a hash
       # (which should come from {Sass::Tree::Visitors::Cssize}).
       #
+      # @overload def do_extend(extends, parent_directives)
       # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
       #                                       Sass::Tree::Visitors::Cssize::Extend}]
       #   The extensions to perform on this selector
       # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
       #   The directives containing this selector.
-      # @param replace [Boolean]
-      #   Whether to replace the original selector entirely or include
-      #   it in the result.
-      # @param seen [Set<Array<Selector::Simple>>]
-      #   The set of simple sequences that are currently being replaced.
-      # @param original [Boolean]
-      #   Whether this is the original selector being extended, as opposed to
-      #   the result of a previous extension that's being re-extended.
       # @return [Array<Sequence>] A list of selectors generated
       #   by extending this selector with `extends`.
       #   These correspond to a {CommaSequence}'s {CommaSequence#members members array}.
       # @see CommaSequence#do_extend
-      def do_extend(extends, parent_directives, replace, seen, original)
+      def do_extend(extends, parent_directives, seen = Set.new)
         extended_not_expanded = members.map do |sseq_or_op|
           next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
-          extended = sseq_or_op.do_extend(extends, parent_directives, replace, seen)
-
-          # The First Law of Extend says that the generated selector should have
-          # specificity greater than or equal to that of the original selector.
-          # In order to ensure that, we record the original selector's
-          # (`extended.first`) original specificity.
-          extended.first.add_sources!([self]) if original && !has_placeholder?
-
-          extended.map {|seq| seq.members}
+          extended = sseq_or_op.do_extend(extends, parent_directives, seen)
+          choices = extended.map {|seq| seq.members}
+          choices.unshift([sseq_or_op]) unless extended.any? {|seq| seq.superselector?(sseq_or_op)}
+          choices
         end
         weaves = Sass::Util.paths(extended_not_expanded).map {|path| weave(path)}
-        trim(weaves).map {|p| Sequence.new(p)}
-      end
-
-      # Unifies this with another selector sequence to produce a selector
-      # that matches (a subset of) the intersection of the two inputs.
-      #
-      # @param other [Sequence]
-      # @return [CommaSequence, nil] The unified selector, or nil if unification failed.
-      # @raise [Sass::SyntaxError] If this selector cannot be unified.
-      #   This will only ever occur when a dynamic selector,
-      #   such as {Parent} or {Interpolation}, is used in unification.
-      #   Since these selectors should be resolved
-      #   by the time extension and unification happen,
-      #   this exception will only ever be raised as a result of programmer error
-      def unify(other)
-        base = members.last
-        other_base = other.members.last
-        return unless base.is_a?(SimpleSequence) && other_base.is_a?(SimpleSequence)
-        return unless (unified = other_base.unify(base))
-
-        woven = weave([members[0...-1], other.members[0...-1] + [unified]])
-        CommaSequence.new(woven.map {|w| Sequence.new(w)})
+        Sass::Util.flatten(trim(weaves), 1).map {|p| Sequence.new(p)}
       end
 
       # Returns whether or not this selector matches all elements
@@ -139,15 +95,18 @@ module Sass
       # @example
       #   (.foo).superselector?(.foo.bar) #=> true
       #   (.foo).superselector?(.bar) #=> false
-      # @param cseq [Sequence]
+      #   (.bar .foo).superselector?(.foo) #=> false
+      # @param sseq [SimpleSequence]
       # @return [Boolean]
-      def superselector?(seq)
-        _superselector?(members, seq.members)
+      def superselector?(sseq)
+        return false unless members.size == 1
+        members.last.superselector?(sseq)
       end
 
-      # @see AbstractSequence#to_s
-      def to_s
-        @members.join(" ").gsub(/ ?\n ?/, "\n")
+      # @see Simple#to_a
+      def to_a
+        ary = @members.map {|seq_or_op| seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op}
+        Sass::Util.intersperse(ary, " ").flatten.compact
       end
 
       # Returns a string representation of the sequence.
@@ -167,63 +126,31 @@ module Sass
         members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
       end
 
-      # Converts the subject operator "!", if it exists, into a ":has()"
-      # selector.
-      #
-      # @retur [Sequence]
-      def subjectless
-        pre_subject = []
-        has = []
-        subject = nil
-        members.each do |sseq_or_op|
-          if subject
-            has << sseq_or_op
-          elsif sseq_or_op.is_a?(String) || !sseq_or_op.subject?
-            pre_subject << sseq_or_op
-          else
-            subject = sseq_or_op.dup
-            subject.members = sseq_or_op.members.dup
-            subject.subject = false
-            has = []
-          end
-        end
-
-        return self unless subject
-
-        unless has.empty?
-          subject.members << Pseudo.new(:class, 'has', nil, CommaSequence.new([Sequence.new(has)]))
-        end
-        Sequence.new(pre_subject + [subject])
-      end
-
       private
 
-      # Conceptually, this expands "parenthesized selectors". That is, if we
-      # have `.A .B {@extend .C}` and `.D .C {...}`, this conceptually expands
-      # into `.D .C, .D (.A .B)`, and this function translates `.D (.A .B)` into
-      # `.D .A .B, .A .D .B`. For thoroughness, `.A.D .B` would also be
-      # required, but including merged selectors results in exponential output
-      # for very little gain.
+      # Conceptually, this expands "parenthesized selectors".
+      # That is, if we have `.A .B {@extend .C}` and `.D .C {...}`,
+      # this conceptually expands into `.D .C, .D (.A .B)`,
+      # and this function translates `.D (.A .B)` into `.D .A .B, .A.D .B, .D .A .B`.
       #
-      # @param path [Array<Array<SimpleSequence or String>>]
-      #   A list of parenthesized selector groups.
+      # @param path [Array<Array<SimpleSequence or String>>] A list of parenthesized selector groups.
       # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
       def weave(path)
         # This function works by moving through the selector path left-to-right,
-        # building all possible prefixes simultaneously.
-        prefixes = [[]]
+        # building all possible prefixes simultaneously. These prefixes are
+        # `befores`, while the remaining parenthesized suffixes is `afters`.
+        befores = [[]]
+        afters = path.dup
 
-        path.each do |current|
-          next if current.empty?
-          current = current.dup
+        until afters.empty?
+          current = afters.shift.dup
           last_current = [current.pop]
-          prefixes = Sass::Util.flatten(prefixes.map do |prefix|
-            sub = subweave(prefix, current)
-            next [] unless sub
-            sub.map {|seqs| seqs + last_current}
-          end, 1)
+          befores = Sass::Util.flatten(befores.map do |before|
+              next [] unless sub = subweave(before, current)
+              sub.map {|seqs| seqs + last_current}
+            end, 1)
         end
-        prefixes
+        return befores
       end
 
       # This interweaves two lists of selectors,
@@ -249,10 +176,8 @@ module Sass
         return [seq1] if seq2.empty?
 
         seq1, seq2 = seq1.dup, seq2.dup
-        init = merge_initial_ops(seq1, seq2)
-        return unless init
-        fin = merge_final_ops(seq1, seq2)
-        return unless fin
+        return unless init = merge_initial_ops(seq1, seq2)
+        return unless fin = merge_final_ops(seq1, seq2)
         seq1 = group_selectors(seq1)
         seq2 = group_selectors(seq2)
         lcs = Sass::Util.lcs(seq2, seq1) do |s1, s2|
@@ -297,7 +222,7 @@ module Sass
         # merged successfully
         lcs = Sass::Util.lcs(ops1, ops2)
         return unless lcs == ops1 || lcs == ops2
-        (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
+        return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
       end
 
       # Extracts final selector combinators (`"+"`, `">"`, `"~"`) and the
@@ -313,8 +238,6 @@ module Sass
       #   be nil. Otherwise, this will contained the merged selector. Array
       #   elements are [Sass::Util#paths]-style options; conceptually, an "or"
       #   of multiple selectors.
-      # @comment
-      #   rubocop:disable MethodLength
       def merge_final_ops(seq1, seq2, res = [])
         ops1, ops2 = [], []
         ops1 << seq1.pop while seq1.last.is_a?(String)
@@ -348,7 +271,7 @@ module Sass
             elsif sel2.superselector?(sel1)
               res.unshift sel1, '~'
             else
-              merged = sel1.unify(sel2)
+              merged = sel1.unify(sel2.members, sel2.subject?)
               res.unshift [
                 [sel1, '~', sel2, '~'],
                 [sel2, '~', sel1, '~'],
@@ -365,7 +288,7 @@ module Sass
             if tilde_sel.superselector?(plus_sel)
               res.unshift plus_sel, '+'
             else
-              merged = plus_sel.unify(tilde_sel)
+              merged = plus_sel.unify(tilde_sel.members, tilde_sel.subject?)
               res.unshift [
                 [tilde_sel, '~', plus_sel, '+'],
                 ([merged, '+'] if merged)
@@ -378,8 +301,7 @@ module Sass
             res.unshift sel1, op1
             seq2.push sel2, op2
           elsif op1 == op2
-            merged = sel1.unify(sel2)
-            return unless merged
+            return unless merged = sel1.unify(sel2.members, sel2.subject?)
             res.unshift merged, op1
           else
             # Unknown selector combinators can't be unified
@@ -396,8 +318,6 @@ module Sass
           return merge_final_ops(seq1, seq2, res)
         end
       end
-      # @comment
-      #   rubocop:enable MethodLength
 
       # Takes initial subsequences of `seq1` and `seq2` and returns all
       # orderings of those subsequences. The initial subsequences are determined
@@ -449,7 +369,7 @@ module Sass
           end while !tail.empty? && head.last.is_a?(String) || tail.first.is_a?(String)
           newseq << head
         end
-        newseq
+        return newseq
       end
 
       # Given two selector sequences, returns whether `seq1` is a
@@ -468,25 +388,25 @@ module Sass
           seq1.first.is_a?(String) || seq2.first.is_a?(String)
         # More complex selectors are never superselectors of less complex ones
         return if seq1.size > seq2.size
-        return seq1.first.superselector?(seq2.last, seq2[0...-1]) if seq1.size == 1
+        return seq1.first.superselector?(seq2.last) if seq1.size == 1
 
         _, si = Sass::Util.enum_with_index(seq2).find do |e, i|
           return if i == seq2.size - 1
           next if e.is_a?(String)
-          seq1.first.superselector?(e, seq2[0...i])
+          seq1.first.superselector?(e)
         end
         return unless si
 
         if seq1[1].is_a?(String)
-          return unless seq2[si + 1].is_a?(String)
+          return unless seq2[si+1].is_a?(String)
           # .foo ~ .bar is a superselector of .foo + .bar
-          return unless seq1[1] == "~" ? seq2[si + 1] != ">" : seq1[1] == seq2[si + 1]
-          return _superselector?(seq1[2..-1], seq2[si + 2..-1])
-        elsif seq2[si + 1].is_a?(String)
-          return unless seq2[si + 1] == ">"
-          return _superselector?(seq1[1..-1], seq2[si + 2..-1])
+          return unless seq1[1] == "~" ? seq2[si+1] != ">" : seq1[1] == seq2[si+1]
+          return _superselector?(seq1[2..-1], seq2[si+2..-1])
+        elsif seq2[si+1].is_a?(String)
+          return unless seq2[si+1] == ">"
+          return _superselector?(seq1[1..-1], seq2[si+2..-1])
         else
-          return _superselector?(seq1[1..-1], seq2[si + 1..-1])
+          return _superselector?(seq1[1..-1], seq2[si+1..-1])
         end
       end
 
@@ -501,8 +421,7 @@ module Sass
       # @param seq2 [Array<SimpleSequence or String>]
       # @return [Boolean]
       def parent_superselector?(seq1, seq2)
-        base = Sass::Selector::SimpleSequence.new([Sass::Selector::Placeholder.new('<temp>')],
-                                                  false)
+        base = Sass::Selector::SimpleSequence.new([Sass::Selector::Placeholder.new('<temp>')], false)
         _superselector?(seq1 + [base], seq2 + [base])
       end
 
@@ -516,11 +435,11 @@ module Sass
       # the other. The more specific selector is removed.
       #
       # @param seqses [Array<Array<Array<SimpleSequence or String>>>]
-      # @return [Array<Array<SimpleSequence or String>>]
+      # @return [Array<Array<Array<SimpleSequence or String>>>]
       def trim(seqses)
         # Avoid truly horrific quadratic behavior. TODO: I think there
         # may be a way to get perfect trimming without going quadratic.
-        return Sass::Util.flatten(seqses, 1) if seqses.size > 100
+        return seqses if seqses.size > 100
 
         # Keep the results in a separate array so we can be sure we aren't
         # comparing against an already-trimmed selector. This ensures that two
@@ -531,15 +450,7 @@ module Sass
         # separate sequences should limit the quadratic behavior.
         seqses.each_with_index do |seqs1, i|
           result[i] = seqs1.reject do |seq1|
-            # The maximum specificity of the sources that caused [seq1] to be
-            # generated. In order for [seq1] to be removed, there must be
-            # another selector that's a superselector of it *and* that has
-            # specificity greater or equal to this.
-            max_spec = _sources(seq1).map do |seq|
-              spec = seq.specificity
-              spec.is_a?(Range) ? spec.max : spec
-            end.max || 0
-
+            max_spec = _sources(seq1).map {|seq| seq.specificity}.max || 0
             result.any? do |seqs2|
               next if seqs1.equal?(seqs2)
               # Second Law of Extend: the specificity of a generated selector
@@ -547,15 +458,11 @@ module Sass
               # selector.
               #
               # See https://github.com/nex3/sass/issues/324.
-              seqs2.any? do |seq2|
-                spec2 = _specificity(seq2)
-                spec2 = spec2.begin if spec2.is_a?(Range)
-                spec2 >= max_spec && _superselector?(seq2, seq1)
-              end
+              seqs2.any? {|seq2| _specificity(seq2) >= max_spec && _superselector?(seq2, seq1)}
             end
           end
         end
-        Sass::Util.flatten(result, 1)
+        result
       end
 
       def _hash
@@ -563,7 +470,7 @@ module Sass
       end
 
       def _eql?(other)
-        other.members.reject {|m| m == "\n"}.eql?(members.reject {|m| m == "\n"})
+        other.members.reject {|m| m == "\n"}.eql?(self.members.reject {|m| m == "\n"})
       end
 
       private