sass 3.3.14 → 3.4.0.rc.1

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}*)/
@@ -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.rb

@@ -1,6 +1,7 @@
 require 'sass/selector/simple'
 require 'sass/selector/abstract_sequence'
 require 'sass/selector/comma_sequence'
+require 'sass/selector/pseudo'
 require 'sass/selector/sequence'
 require 'sass/selector/simple_sequence'
 
@@ -27,19 +28,19 @@ module Sass
     # The function of this is to be replaced by the parent selector
     # in the nested hierarchy.
     class Parent < Simple
-      # The identifier following the `&`. Often empty.
+      # The identifier following the `&`. `nil` indicates no suffix.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String, nil]
       attr_reader :suffix
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] See \{#suffix}
-      def initialize(suffix = [])
+      # @param name [String, nil] See \{#suffix}
+      def initialize(suffix = nil)
         @suffix = suffix
       end
 
-      # @see Selector#to_a
-      def to_a
-        ["&", *@suffix]
+      # @see Selector#to_s
+      def to_s
+        "&" + (@suffix || '')
       end
 
       # Always raises an exception.
@@ -55,17 +56,17 @@ module Sass
     class Class < Simple
       # The class name.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :name
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] The class name
+      # @param name [String] The class name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_a
-      def to_a
-        [".", *@name]
+      # @see Selector#to_s
+      def to_s
+        "." + @name
       end
 
       # @see AbstractSequence#specificity
@@ -78,17 +79,17 @@ module Sass
     class Id < Simple
       # The id name.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :name
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] The id name
+      # @param name [String] The id name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_a
-      def to_a
-        ["#", *@name]
+      # @see Selector#to_s
+      def to_s
+        "#" + @name
       end
 
       # Returns `nil` if `sels` contains an {Id} selector
@@ -113,17 +114,17 @@ module Sass
     class Placeholder < Simple
       # The placeholder name.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :name
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] The placeholder name
+      # @param name [String] The placeholder name
       def initialize(name)
         @name = name
       end
 
-      # @see Selector#to_a
-      def to_a
-        ["%", *@name]
+      # @see Selector#to_s
+      def to_s
+        "%" + @name
       end
 
       # @see AbstractSequence#specificity
@@ -134,22 +135,20 @@ module Sass
 
     # A universal selector (`*` in CSS).
     class Universal < Simple
-      # The selector namespace.
-      # `nil` means the default namespace,
-      # `[""]` means no namespace,
-      # `["*"]` means any namespace.
+      # The selector namespace. `nil` means the default namespace, `""` means no
+      # namespace, `"*"` means any namespace.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>, nil]
+      # @return [String, nil]
       attr_reader :namespace
 
-      # @param namespace [Array<String, Sass::Script::Tree::Node>, nil] See \{#namespace}
+      # @param namespace [String, nil] See \{#namespace}
       def initialize(namespace)
         @namespace = namespace
       end
 
-      # @see Selector#to_a
-      def to_a
-        @namespace ? @namespace + ["|*"] : ["*"]
+      # @see Selector#to_s
+      def to_s
+        @namespace ? "#{@namespace}|*" : "*"
       end
 
       # Unification of a universal selector is somewhat complicated,
@@ -183,7 +182,7 @@ module Sass
           when Universal; :universal
           when Element; sels.first.name
           else
-            return [self] + sels unless namespace.nil? || namespace == ['*']
+            return [self] + sels unless namespace.nil? || namespace == '*'
             return sels unless sels.empty?
             return [self]
           end
@@ -203,27 +202,25 @@ module Sass
     class Element < Simple
       # The element name.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :name
 
-      # The selector namespace.
-      # `nil` means the default namespace,
-      # `[""]` means no namespace,
-      # `["*"]` means any namespace.
+      # The selector namespace. `nil` means the default namespace, `""` means no
+      # namespace, `"*"` means any namespace.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>, nil]
+      # @return [String, nil]
       attr_reader :namespace
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] The element name
-      # @param namespace [Array<String, Sass::Script::Tree::Node>, nil] See \{#namespace}
+      # @param name [String] The element name
+      # @param namespace [String, nil] See \{#namespace}
       def initialize(name, namespace)
         @name = name
         @namespace = namespace
       end
 
-      # @see Selector#to_a
-      def to_a
-        @namespace ? @namespace + ["|"] + @name : @name
+      # @see Selector#to_s
+      def to_s
+        @namespace ? "#{@namespace}|#{@name}" : @name
       end
 
       # Unification of an element selector is somewhat complicated,
@@ -266,32 +263,6 @@ module Sass
       end
     end
 
-    # Selector interpolation (`#{}` in Sass).
-    class Interpolation < Simple
-      # The script to run.
-      #
-      # @return [Sass::Script::Tree::Node]
-      attr_reader :script
-
-      # @param script [Sass::Script::Tree::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.
@@ -299,12 +270,10 @@ module Sass
       # @return [Array<String, Sass::Script::Tree::Node>]
       attr_reader :name
 
-      # The attribute namespace.
-      # `nil` means the default namespace,
-      # `[""]` means no namespace,
-      # `["*"]` means any namespace.
+      # The attribute namespace. `nil` means the default namespace, `""` means
+      # no namespace, `"*"` means any namespace.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>, nil]
+      # @return [String, nil]
       attr_reader :namespace
 
       # The matching operator, e.g. `"="` or `"^="`.
@@ -314,19 +283,19 @@ module Sass
 
       # The right-hand side of the operator.
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :value
 
       # Flags for the attribute selector (e.g. `i`).
       #
-      # @return [Array<String, Sass::Script::Tree::Node>]
+      # @return [String]
       attr_reader :flags
 
-      # @param name [Array<String, Sass::Script::Tree::Node>] The attribute name
-      # @param namespace [Array<String, Sass::Script::Tree::Node>, nil] See \{#namespace}
+      # @param name [String] The attribute name
+      # @param namespace [String, nil] See \{#namespace}
       # @param operator [String] The matching operator, e.g. `"="` or `"^="`
-      # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
-      # @param flags [Array<String, Sass::Script::Tree::Node>] See \{#flags}
+      # @param value [String] See \{#value}
+      # @param flags [String] See \{#flags}
       # @comment
       #   rubocop:disable ParameterLists
       def initialize(name, namespace, operator, value, flags)
@@ -338,13 +307,13 @@ module Sass
         @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
+      # @see Selector#to_s
+      def to_s
+        res = "["
+        res << @namespace << "|" if @namespace
+        res << @name
+        res << @operator << @value if @value
+        res << " " << @flags if @flags
         res << "]"
       end
 
@@ -353,111 +322,5 @@ module Sass
         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::Tree::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::Tree::Node>, nil]
-      attr_reader :arg
-
-      # @param type [Symbol] See \{#type}
-      # @param name [Array<String, Sass::Script::Tree::Node>] The name of the selector
-      # @param arg [nil, Array<String, Sass::Script::Tree::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 != name || sel.arg != 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 name [String] The name of the pseudoclass
-      # @param selector [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