sass 3.3.0 → 3.4.0

data/lib/sass/scss/rx.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 module Sass
   module SCSS
     # A module containing regular expressions used
@@ -63,9 +64,9 @@ module Sass
       STRING1  = /\"((?:[^\n\r\f\\"]|\\#{NL}|#{ESCAPE})*)\"/
       STRING2  = /\'((?:[^\n\r\f\\']|\\#{NL}|#{ESCAPE})*)\'/
 
-      IDENT    = /-?#{NMSTART}#{NMCHAR}*/
+      IDENT    = /-*#{NMSTART}#{NMCHAR}*/
       NAME     = /#{NMCHAR}+/
-      NUM      = /[0-9]+|[0-9]*\.[0-9]+/
+      NUM      = //
       STRING   = /#{STRING1}|#{STRING2}/
       URLCHAR  = /[#%&*-~]|#{NONASCII}|#{ESCAPE}/
       URL      = /(#{URLCHAR}*)/
@@ -80,7 +81,7 @@ module Sass
 
       S = /[ \t\r\n\f]+/
 
-      COMMENT = %r{/\*[^*]*\*+(?:[^/][^*]*\*+)*/}
+      COMMENT = %r{/\*([^*]|\*+[^/*])*\**\*/}
       SINGLE_LINE_COMMENT = %r{//.*(\n[ \t]*//.*)*}
 
       CDO            = quote("<!--")
@@ -95,7 +96,9 @@ module Sass
 
       IMPORTANT = /!#{W}important/i
 
-      NUMBER = /#{NUM}(?:#{IDENT}|%)?/
+      UNITLESS_NUMBER = /(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?\d+)?/
+      NUMBER = /#{UNITLESS_NUMBER}(?:#{IDENT}|%)?/
+      PERCENTAGE = /#{UNITLESS_NUMBER}%/
 
       URI = /url\(#{W}(?:#{STRING}|#{URL})#{W}\)/i
       FUNCTION = /#{IDENT}\(/
@@ -118,10 +121,16 @@ module Sass
       INTERP_START = /#\{/
       ANY = /:(-[-\w]+-)?any\(/i
       OPTIONAL = /!#{W}optional/i
+      IDENT_START = /-|#{NMSTART}/
+
+      # A unit is like an IDENT, but disallows a hyphen followed by a digit.
+      # This allows "1px-2px" to be interpreted as subtraction rather than "1"
+      # with the unit "px-2px". It also allows "%".
+      UNIT = /-?#{NMSTART}(?:[a-zA-Z0-9_]|#{NONASCII}|#{ESCAPE}|-(?!\d))*|%/
 
       IDENT_HYPHEN_INTERP = /-(#\{)/
-      STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\"/
-      STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|\\#{NL}|#{ESCAPE})*)\'/
+      STRING1_NOINTERP = /\"((?:[^\n\r\f\\"#]|#(?!\{)|#{ESCAPE})*)\"/
+      STRING2_NOINTERP = /\'((?:[^\n\r\f\\'#]|#(?!\{)|#{ESCAPE})*)\'/
       STRING_NOINTERP = /#{STRING1_NOINTERP}|#{STRING2_NOINTERP}/
 
       STATIC_COMPONENT = /#{IDENT}|#{STRING_NOINTERP}|#{HEXCOLOR}|[+-]?#{NUMBER}|\!important/i

data/lib/sass/scss/static_parser.rb

@@ -41,6 +41,24 @@ module Sass
         return type, directives
       end
 
+      def parse_keyframes_selector
+        init_scanner!
+        sel = expr!(:keyframes_selector)
+        expected("keyframes selector") unless @scanner.eos?
+        sel
+      end
+
+      # @see Parser#initialize
+      # @param allow_parent_ref [Boolean] Whether to allow the
+      #   parent-reference selector, `&`, when parsing the document.
+      # @comment
+      #   rubocop:disable ParameterLists
+      def initialize(str, filename, importer, line = 1, offset = 1, allow_parent_ref = true)
+        # rubocop:enable ParameterLists
+        super(str, filename, importer, line, offset)
+        @allow_parent_ref = allow_parent_ref
+      end
+
       private
 
       def moz_document_function
@@ -52,7 +70,7 @@ module Sass
 
       def variable; nil; end
       def script_value; nil; end
-      def interpolation; nil; end
+      def interpolation(warn_for_color = false); nil; end
       def var_expr; nil; end
       def interp_string; (s = tok(STRING)) && [s]; end
       def interp_uri; (s = tok(URI)) && [s]; end
@@ -64,6 +82,285 @@ module Sass
         super
       end
 
+      def selector_comma_sequence
+        sel = selector
+        return unless sel
+        selectors = [sel]
+        ws = ''
+        while tok(/,/)
+          ws << str {ss}
+          if (sel = selector)
+            selectors << sel
+            if ws.include?("\n")
+              selectors[-1] = Selector::Sequence.new(["\n"] + selectors.last.members)
+            end
+            ws = ''
+          end
+        end
+        Selector::CommaSequence.new(selectors)
+      end
+
+      def selector_string
+        sel = selector
+        return unless sel
+        sel.to_s
+      end
+
+      def selector
+        start_pos = source_position
+        # The combinator here allows the "> E" hack
+        val = combinator || simple_selector_sequence
+        return unless val
+        nl = str {ss}.include?("\n")
+        res = []
+        res << val
+        res << "\n" if nl
+
+        while (val = combinator || simple_selector_sequence)
+          res << val
+          res << "\n" if str {ss}.include?("\n")
+        end
+        seq = Selector::Sequence.new(res.compact)
+
+        if seq.members.any? {|sseq| sseq.is_a?(Selector::SimpleSequence) && sseq.subject?}
+          location = " of #{@filename}" if @filename
+          Sass::Util.sass_warn <<MESSAGE
+DEPRECATION WARNING on line #{start_pos.line}, column #{start_pos.offset}#{location}:
+The subject selector operator "!" is deprecated and will be removed in a future release.
+This operator has been replaced by ":has()" in the CSS spec.
+For example: #{seq.subjectless}
+MESSAGE
+        end
+
+        seq
+      end
+
+      def combinator
+        tok(PLUS) || tok(GREATER) || tok(TILDE) || reference_combinator
+      end
+
+      def reference_combinator
+        return unless tok(/\//)
+        res = '/'
+        ns, name = expr!(:qualified_name)
+        res << ns << '|' if ns
+        res << name << tok!(/\//)
+        res
+      end
+
+      def simple_selector_sequence
+        start_pos = source_position
+        e = element_name || id_selector || class_selector || placeholder_selector || attrib ||
+            pseudo || parent_selector
+        return unless e
+        res = [e]
+
+        # The tok(/\*/) allows the "E*" hack
+        while (v = id_selector || class_selector || placeholder_selector ||
+                   attrib || pseudo || (tok(/\*/) && Selector::Universal.new(nil)))
+          res << v
+        end
+
+        pos = @scanner.pos
+        line = @line
+        if (sel = str? {simple_selector_sequence})
+          @scanner.pos = pos
+          @line = line
+          begin
+            # If we see "*E", don't force a throw because this could be the
+            # "*prop: val" hack.
+            expected('"{"') if res.length == 1 && res[0].is_a?(Selector::Universal)
+            throw_error {expected('"{"')}
+          rescue Sass::SyntaxError => e
+            e.message << "\n\n\"#{sel}\" may only be used at the beginning of a compound selector."
+            raise e
+          end
+        end
+
+        Selector::SimpleSequence.new(res, tok(/!/), range(start_pos))
+      end
+
+      def parent_selector
+        return unless @allow_parent_ref && tok(/&/)
+        Selector::Parent.new(tok(NAME))
+      end
+
+      def class_selector
+        return unless tok(/\./)
+        @expected = "class name"
+        Selector::Class.new(tok!(IDENT))
+      end
+
+      def id_selector
+        return unless tok(/#(?!\{)/)
+        @expected = "id name"
+        Selector::Id.new(tok!(NAME))
+      end
+
+      def placeholder_selector
+        return unless tok(/%/)
+        @expected = "placeholder name"
+        Selector::Placeholder.new(tok!(IDENT))
+      end
+
+      def element_name
+        ns, name = Sass::Util.destructure(qualified_name(:allow_star_name))
+        return unless ns || name
+
+        if name == '*'
+          Selector::Universal.new(ns)
+        else
+          Selector::Element.new(name, ns)
+        end
+      end
+
+      def qualified_name(allow_star_name = false)
+        name = tok(IDENT) || tok(/\*/) || (tok?(/\|/) && "")
+        return unless name
+        return nil, name unless tok(/\|/)
+
+        return name, tok!(IDENT) unless allow_star_name
+        @expected = "identifier or *"
+        return name, tok(IDENT) || tok!(/\*/)
+      end
+
+      def attrib
+        return unless tok(/\[/)
+        ss
+        ns, name = attrib_name!
+        ss
+
+        op = tok(/=/) ||
+             tok(INCLUDES) ||
+             tok(DASHMATCH) ||
+             tok(PREFIXMATCH) ||
+             tok(SUFFIXMATCH) ||
+             tok(SUBSTRINGMATCH)
+        if op
+          @expected = "identifier or string"
+          ss
+          val = tok(IDENT) || tok!(STRING)
+          ss
+        end
+        flags = tok(IDENT) || tok(STRING)
+        tok!(/\]/)
+
+        Selector::Attribute.new(name, ns, op, val, flags)
+      end
+
+      def attrib_name!
+        if (name_or_ns = tok(IDENT))
+          # E, E|E
+          if tok(/\|(?!=)/)
+            ns = name_or_ns
+            name = tok(IDENT)
+          else
+            name = name_or_ns
+          end
+        else
+          # *|E or |E
+          ns = tok(/\*/) || ""
+          tok!(/\|/)
+          name = tok!(IDENT)
+        end
+        return ns, name
+      end
+
+      SELECTOR_PSEUDO_CLASSES = %w[not matches current any has host host-context].to_set
+
+      PREFIXED_SELECTOR_PSEUDO_CLASSES = %w[nth-child nth-last-child].to_set
+
+      def pseudo
+        s = tok(/::?/)
+        return unless s
+        @expected = "pseudoclass or pseudoelement"
+        name = tok!(IDENT)
+        if tok(/\(/)
+          ss
+          deprefixed = deprefix(name)
+          if s == ':' && SELECTOR_PSEUDO_CLASSES.include?(deprefixed)
+            sel = selector_comma_sequence
+          elsif s == ':' && PREFIXED_SELECTOR_PSEUDO_CLASSES.include?(deprefixed)
+            arg, sel = prefixed_selector_pseudo
+          else
+            arg = expr!(:pseudo_args)
+          end
+
+          tok!(/\)/)
+        end
+        Selector::Pseudo.new(s == ':' ? :class : :element, name, arg, sel)
+      end
+
+      def pseudo_args
+        arg = expr!(:pseudo_expr)
+        while tok(/,/)
+          arg << ',' << str {ss}
+          arg.concat expr!(:pseudo_expr)
+        end
+        arg
+      end
+
+      def pseudo_expr
+        res = pseudo_expr_token
+        return unless res
+        res << str {ss}
+        while (e = pseudo_expr_token)
+          res << e << str {ss}
+        end
+        res
+      end
+
+      def pseudo_expr_token
+        tok(PLUS) || tok(/[-*]/) || tok(NUMBER) || tok(STRING) || tok(IDENT)
+      end
+
+      def prefixed_selector_pseudo
+        prefix = str do
+          expr = str {expr!(:a_n_plus_b)}
+          ss
+          return expr, nil unless tok(/of/)
+          ss
+        end
+        return prefix, expr!(:selector_comma_sequence)
+      end
+
+      def a_n_plus_b
+        if (parity = tok(/even|odd/i))
+          return parity
+        end
+
+        if tok(/[+-]?[0-9]+/)
+          ss
+          return true unless tok(/n/)
+        else
+          return unless tok(/[+-]?n/i)
+        end
+        ss
+
+        return true unless tok(/[+-]/)
+        ss
+        @expected = "number"
+        tok!(/[0-9]+/)
+        true
+      end
+
+      def keyframes_selector
+        ss
+        str do
+          return unless keyframes_selector_component
+          ss
+          while tok(/,/)
+            ss
+            expr!(:keyframes_selector_component)
+            ss
+          end
+        end
+      end
+
+      def keyframes_selector_component
+        tok(/from|to/i) || tok(PERCENTAGE)
+      end
+
       @sass_script_parser = Class.new(Sass::Script::CssParser)
       @sass_script_parser.send(:include, ScriptParser)
     end

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_a`
-    # method that returns an array of strings and script nodes.
+    # of object that respond to `#line=` and `#filename=`, as well as a `to_s`
+    # method that returns the string representation of the selector.
     class AbstractSequence
       # The line of the Sass template on which this selector was declared.
       #
@@ -62,22 +62,26 @@ module Sass
       # Whether or not this selector sequence contains a placeholder selector.
       # Checks recursively.
       def has_placeholder?
-        @has_placeholder ||=
-          members.any? {|m| m.is_a?(AbstractSequence) ? m.has_placeholder? : m.is_a?(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
       end
 
-      # Converts the selector into a string. This is the standard selector
-      # string, along with any SassScript interpolation that may exist.
+      # Returns the selector string.
       #
       # @return [String]
       def to_s
-        to_a.map {|e| e.is_a?(Sass::Script::Tree::Node) ? "\#{#{e.to_sass}}" : e}.join
+        Sass::Util.abstract(self)
       end
 
-      # Returns the specificity of the selector as an integer. The base is given
-      # by {Sass::Selector::SPECIFICITY_BASE}.
+      # Returns the specificity of the selector.
       #
-      # @return [Fixnum]
+      # The base is given by {Sass::Selector::SPECIFICITY_BASE}. This can be a
+      # number or a range representing possible specificities.
+      #
+      # @return [Fixnum, Range]
       def specificity
         _specificity(members)
       end
@@ -85,9 +89,20 @@ module Sass
       protected
 
       def _specificity(arr)
-        spec = 0
-        arr.map {|m| spec += m.is_a?(String) ? 0 : m.specificity}
-        spec
+        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)
       end
     end
   end

data/lib/sass/selector/comma_sequence.rb

@@ -53,20 +53,101 @@ 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)
+      def do_extend(extends, parent_directives = [], replace = false, seen = Set.new,
+          original = true)
         CommaSequence.new(members.map do |seq|
-          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
+          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)
+      end
+
       # Returns a string representation of the sequence.
       # This is basically the selector string.
       #
@@ -75,11 +156,9 @@ module Sass
         members.map {|m| m.inspect}.join(", ")
       end
 
-      # @see Simple#to_a
-      def to_a
-        arr = Sass::Util.intersperse(@members.map {|m| m.to_a}, ", ").flatten
-        arr.delete("\n")
-        arr
+      # @see AbstractSequence#to_s
+      def to_s
+        @members.join(", ").gsub(", \n", ",\n")
       end
 
       private