sass 3.1.21 → 3.2.0.alpha.3

data/lib/sass/script/list.rb

@@ -24,13 +24,6 @@ module Sass::Script
       @separator = separator
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@value', value.map {|c| c.deep_copy})
-      node
-    end
-
     # @see Node#eq
     def eq(other)
       Sass::Script::Bool.new(
@@ -46,7 +39,6 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
-      return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.map do |v|
         if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence

data/lib/sass/script/literal.rb

@@ -33,11 +33,6 @@ module Sass::Script
       []
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      dup
-    end
-
     # Returns the options hash for this node.
     #
     # @return [{Symbol => Object}]
@@ -55,6 +50,26 @@ The #options attribute is not set on this #{self.class}.
 MSG
     end
 
+    # The SassScript `and` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of a logical and:
+    #   `other` if this literal isn't a false {Bool},
+    #   and this literal otherwise
+    def and(other)
+      to_bool ? other : self
+    end
+
+    # The SassScript `or` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of the logical or:
+    #   this literal if it isn't a false {Bool},
+    #   and `other` otherwise
+    def or(other)
+      to_bool ? self : other
+    end
+
     # The SassScript `==` operation.
     # **Note that this returns a {Sass::Script::Bool} object,
     # not a Ruby boolean**.

data/lib/sass/script/node.rb

@@ -57,14 +57,6 @@ module Sass::Script
       Sass::Util.abstract(self)
     end
 
-    # Returns a deep clone of this node.
-    # The child nodes are cloned, but options are not.
-    #
-    # @return [Node]
-    def deep_copy
-      Sass::Util.abstract(self)
-    end
-
     protected
 
     # Converts underscores to dashes if the :dasherize option is set.

data/lib/sass/script/number.rb

@@ -35,34 +35,11 @@ module Sass::Script
     # @return [Boolean, nil]
     attr_accessor :original
 
-    def self.precision
-      @precision ||= 3
-    end
-
-    # Sets the number of digits of precision
-    # For example, if this is `3`,
+    # The precision with which numbers will be printed to CSS files.
+    # For example, if this is `1000.0`,
     # `3.1415926` will be printed as `3.142`.
-    def self.precision=(digits)
-      @precision = digits.round
-      @precision_factor = 10.0**@precision
-    end
-
-    # the precision factor used in numeric output
-    # it is derived from the `precision` method.
-    def self.precision_factor
-      @precision_factor ||= 10.0**precision
-    end
-
-    # Handles the deprecation warning for the PRECISION constant
-    # This can be removed in 3.2.
-    def self.const_missing(const)
-      if const == :PRECISION
-        Sass::Util.sass_warn("Sass::Script::Number::PRECISION is deprecated and will be removed in a future release. Use Sass::Script::Number.precision_factor instead.")
-        const_set(:PRECISION, self.precision_factor)
-      else
-        super
-      end
-    end
+    # @api public
+    PRECISION = 1000.0
 
     # Used so we don't allocate two new arrays for each new number.
     NO_UNITS  = []
@@ -360,7 +337,7 @@ module Sass::Script
       elsif num % 1 == 0.0
         num.to_i
       else
-        ((num * self.precision_factor).round / self.precision_factor).to_f
+        (num * PRECISION).round / PRECISION
       end
     end
 
@@ -422,13 +399,12 @@ module Sass::Script
     end
 
     # A hash of unit names to their index in the conversion table
-    CONVERTABLE_UNITS = {"in" => 0,        "cm" => 1,    "pc" => 2,    "mm" => 3,   "pt" => 4,  "px" => 5    }
-    CONVERSION_TABLE = [[ 1,                2.54,         6,            25.4,        72        , 96          ], # in
-                        [ nil,              1,            2.36220473,   10,          28.3464567, 37.795275591], # cm
-                        [ nil,              nil,          1,            4.23333333,  12        , 16          ], # pc
-                        [ nil,              nil,          nil,          1,           2.83464567, 3.7795275591], # mm
-                        [ nil,              nil,          nil,          nil,         1         , 1.3333333333], # pt
-                        [ nil,              nil,          nil,          nil,         nil       , 1           ]] # px
+    CONVERTABLE_UNITS = {"in" => 0,        "cm" => 1,    "pc" => 2,    "mm" => 3,   "pt" => 4}
+    CONVERSION_TABLE = [[ 1,                2.54,         6,            25.4,        72        ], # in
+                        [ nil,              1,            2.36220473,   10,          28.3464567], # cm
+                        [ nil,              nil,          1,            4.23333333,  12        ], # pc
+                        [ nil,              nil,          nil,          1,           2.83464567], # mm
+                        [ nil,              nil,          nil,          nil,         1         ]] # pt
 
     def conversion_factor(from_unit, to_unit)
       res = CONVERSION_TABLE[CONVERTABLE_UNITS[from_unit]][CONVERTABLE_UNITS[to_unit]]

data/lib/sass/script/operation.rb

@@ -55,14 +55,6 @@ module Sass::Script
       [@operand1, @operand2]
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@operand1', @operand1.deep_copy)
-      node.instance_variable_set('@operand2', @operand2.deep_copy)
-      node
-    end
-
     protected
 
     # Evaluates the operation.
@@ -72,14 +64,6 @@ module Sass::Script
     # @raise [Sass::SyntaxError] if the operation is undefined for the operands
     def _perform(environment)
       literal1 = @operand1.perform(environment)
-
-      # Special-case :and and :or to support short-circuiting.
-      if @operator == :and
-        return literal1.to_bool ? @operand2.perform(environment) : literal1
-      elsif @operator == :or
-        return literal1.to_bool ? literal1 : @operand2.perform(environment)
-      end
-
       literal2 = @operand2.perform(environment)
 
       begin

data/lib/sass/script/parser.rb

@@ -182,11 +182,7 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}) and return interp
               return unless e = #{sub}
               while tok = try_tok(#{ops.map {|o| o.inspect}.join(', ')})
-                if interp = try_op_before_interp(tok, e)
-                  return interp unless other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
-                  return other_interp
-                end
-
+                interp = try_op_before_interp(tok, e) and return interp
                 line = @lexer.line
                 e = Operation.new(e, assert_expr(#{sub.inspect}), tok.type)
                 e.line = line
@@ -221,10 +217,7 @@ RUBY
         return unless e = interpolation
         arr = [e]
         while tok = try_tok(:comma)
-          if interp = try_op_before_interp(tok, e)
-            return interp unless other_interp = try_ops_after_interp([:comma], :expr, interp)
-            return other_interp
-          end
+          interp = try_op_before_interp(tok, e) and return interp
           arr << assert_expr(:interpolation)
         end
         arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
@@ -242,15 +235,15 @@ RUBY
         interpolation(interp)
       end
 
-      def try_ops_after_interp(ops, name, prev = nil)
+      def try_ops_after_interp(ops, name)
         return unless @lexer.after_interpolation?
         return unless op = try_tok(*ops)
-        interp = try_op_before_interp(op, prev) and return interp
+        interp = try_op_before_interp(op) and return interp
 
         wa = @lexer.whitespace?
         str = Script::String.new(Lexer::OPERATORS_REVERSE[op.type])
         str.line = @lexer.line
-        interp = Script::Interpolation.new(prev, str, assert_expr(name), !:wb, wa, :originally_text)
+        interp = Script::Interpolation.new(nil, str, assert_expr(name), !:wb, wa, :originally_text)
         interp.line = @lexer.line
         return interp
       end

data/lib/sass/script/string_interpolation.rb

@@ -60,15 +60,6 @@ module Sass::Script
       [@before, @mid, @after].compact
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@before', @before.deep_copy) if @before
-      node.instance_variable_set('@mid', @mid.deep_copy)
-      node.instance_variable_set('@after', @after.deep_copy) if @after
-      node
-    end
-
     protected
 
     # Evaluates the interpolation.

data/lib/sass/script/unary_operation.rb

@@ -38,13 +38,6 @@ module Sass::Script
       [@operand]
     end
 
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@operand', @operand.deep_copy)
-      node
-    end
-
     protected
 
     # Evaluates the operation.

data/lib/sass/script/variable.rb

@@ -21,6 +21,7 @@ module Sass
 
       # @return [String] A string representation of the variable
       def inspect(opts = {})
+        return "!important" if name == "important"
         "$#{dasherize(name, opts)}"
       end
       alias_method :to_sass, :inspect
@@ -33,11 +34,6 @@ module Sass
         []
       end
 
-      # @see Node#deep_copy
-      def deep_copy
-        dup
-      end
-
       protected
 
       # Evaluates the variable.

data/lib/sass/scss/parser.rb

@@ -1,3 +1,4 @@
+require 'strscan'
 require 'set'
 
 module Sass
@@ -8,12 +9,10 @@ module Sass
       # @param str [String, StringScanner] The source document to parse.
       #   Note that `Parser` *won't* raise a nice error message if this isn't properly parsed;
       #   for that, you should use the higher-level {Sass::Engine} or {Sass::CSS}.
-      # @param filename [String] The name of the file being parsed. Used for warnings.
       # @param line [Fixnum] The line on which the source string appeared,
-      #   if it's part of another document.
-      def initialize(str, filename, line = 1)
+      #   if it's part of another document
+      def initialize(str, line = 1)
         @template = str
-        @filename = filename
         @line = line
         @strs = []
       end
@@ -49,7 +48,7 @@ module Sass
           if @template.is_a?(StringScanner)
             @template
           else
-            Sass::Util::MultibyteStringScanner.new(@template.gsub("\r", ""))
+            StringScanner.new(@template.gsub("\r", ""))
           end
       end
 
@@ -88,35 +87,19 @@ module Sass
       end
 
       def process_comment(text, node)
-        silent = text =~ /^\/\//
-        line = @line - text.count("\n")
-        if loud = text =~ %r{^/[/*]!}
-          value = Sass::Engine.parse_interp(text, line, @scanner.pos - text.size, :filename => @filename)
-          value[0].slice!(2) # get rid of the "!"
-        else
-          value = [text]
-        end
-
-        if silent
-          value = Sass::Util.with_extracted_values(value) do |str|
-            str.sub(/^\s*\/\//, '/*').gsub(/^\s*\/\//, ' *') + ' */'
-          end
-        else
-          value.unshift(@scanner.
-            string[0...@scanner.pos].
-            reverse[/.*?\*\/(.*?)($|\Z)/, 1].
-            reverse.gsub(/[^\s]/, ' '))
-        end
-
-        comment = Sass::Tree::CommentNode.new(value, silent, loud)
-        comment.line = line
+        single_line = text =~ /^\/\//
+        pre_str = single_line ? "" : @scanner.
+          string[0...@scanner.pos].
+          reverse[/.*?\*\/(.*?)($|\Z)/, 1].
+          reverse.gsub(/[^\s]/, ' ')
+        text = text.sub(/^\s*\/\//, '/*').gsub(/^\s*\/\//, ' *') + ' */' if single_line
+        comment = Sass::Tree::CommentNode.new(pre_str + text, single_line)
+        comment.line = @line - text.count("\n")
         node << comment
       end
 
       DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
-        :each, :while, :if, :else, :extend, :import, :media, :charset, :_moz_document]
-
-      PREFIXED_DIRECTIVES = Set[:supports]
+        :each, :while, :if, :else, :extend, :import, :media, :charset]
 
       def directive
         return unless tok(/@/)
@@ -125,19 +108,13 @@ module Sass
 
         if dir = special_directive(name)
           return dir
-        elsif dir = prefixed_directive(name)
-          return dir
         end
 
         # Most at-rules take expressions (e.g. @import),
         # but some (e.g. @page) take selector-like arguments
         val = str {break unless expr}
         val ||= CssParser.new(@scanner, @line).parse_selector_string
-        directive_body("@#{name} #{val}")
-      end
-
-      def directive_body(value)
-        node = node(Sass::Tree::DirectiveNode.new(value.strip))
+        node = node(Sass::Tree::DirectiveNode.new("@#{name} #{val}".strip))
 
         if tok(/\{/)
           node.has_children = true
@@ -153,11 +130,6 @@ module Sass
         DIRECTIVES.include?(sym) && send("#{sym}_directive")
       end
 
-      def prefixed_directive(name)
-        sym = name.gsub(/^-[a-z0-9]+-/i, '').gsub('-', '_').to_sym
-        PREFIXED_DIRECTIVES.include?(sym) && send("#{sym}_directive", name)
-      end
-
       def mixin_directive
         name = tok! IDENT
         args = sass_script(:parse_mixin_definition_arglist)
@@ -268,7 +240,7 @@ module Sass
       end
 
       def extend_directive
-        node(Sass::Tree::ExtendNode.new(expr!(:selector_sequence)))
+        node(Sass::Tree::ExtendNode.new(expr!(:selector)))
       end
 
       def import_directive
@@ -299,23 +271,20 @@ module Sass
       def use_css_import?; false; end
 
       def media_directive
-        block(node(Sass::Tree::MediaNode.new(media_query_list)), :directive)
+        val = str {media_query_list}.strip
+        block(node(Sass::Tree::MediaNode.new(val)), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
       def media_query_list
-        has_q = false
-        q = str {has_q = media_query}
-
-        return unless has_q
-        queries = [q.strip]
+        return unless media_query
 
         ss
         while tok(/,/)
-          ss; queries << str {expr!(:media_query)}.strip; ss
+          ss; expr!(:media_query); ss
         end
 
-        queries
+        true
       end
 
       def media_query
@@ -359,76 +328,6 @@ module Sass
         node(Sass::Tree::CharsetNode.new(name))
       end
 
-      # The document directive is specified in
-      # http://www.w3.org/TR/css3-conditional/, but Gecko allows the
-      # `url-prefix` and `domain` functions to omit quotation marks, contrary to
-      # the standard.
-      #
-      # We could parse all document directives according to Mozilla's syntax,
-      # but if someone's using e.g. @-webkit-document we don't want them to
-      # think WebKit works sans quotes.
-      def _moz_document_directive
-        value = str do
-          begin
-            ss
-            expr!(:moz_document_function)
-          end while tok(/,/)
-        end
-        directive_body("@-moz-document #{value}")
-      end
-
-      def moz_document_function
-        return unless tok(URI) || tok(URL_PREFIX) || tok(DOMAIN) || function
-        ss
-      end
-
-      # http://www.w3.org/TR/css3-conditional/
-      def supports_directive(name)
-        value = str {expr!(:supports_condition)}
-        directive_body("@#{name} #{value}")
-      end
-
-      def supports_condition
-        supports_negation || supports_operator || supports_declaration_condition
-      end
-
-      def supports_negation
-        return unless tok(/not/i)
-        ss
-        expr!(:supports_condition_in_parens)
-      end
-
-      def supports_operator
-        return unless supports_condition_in_parens
-        tok!(/and|or/i)
-        begin
-          ss
-          expr!(:supports_condition_in_parens)
-        end while tok(/and|or/i)
-        true
-      end
-
-      def supports_condition_in_parens
-        return unless tok(/\(/); ss
-        if supports_condition
-          tok!(/\)/); ss
-        else
-          supports_declaration_body
-        end
-      end
-
-      def supports_declaration_condition
-        return unless tok(/\(/); ss
-        supports_declaration_body
-      end
-
-      def supports_declaration_body
-        tok!(IDENT); ss
-        tok!(/:/); ss
-        expr!(:expr); ss
-        tok!(/\)/); ss
-      end
-
       def variable
         return unless tok(/\$/)
         name = tok!(IDENT)
@@ -522,7 +421,7 @@ module Sass
       end
 
       def selector_sequence
-        if sel = tok(STATIC_SELECTOR, true)
+        if sel = tok(STATIC_SELECTOR)
           return [sel]
         end
 
@@ -588,30 +487,21 @@ module Sass
         res = [e]
 
         # The tok(/\*/) allows the "E*" hack
-        while v = id_selector || class_selector || attrib || negation || pseudo ||
-            interpolation_selector || (tok(/\*/) && Selector::Universal.new(nil))
+        while v = element_name || id_selector || class_selector ||
+            attrib || negation || pseudo || interpolation_selector ||
+            (tok(/\*/) && Selector::Universal.new(nil))
           res << v
         end
 
-        pos = @scanner.pos
-        line = @line
-        if sel = str? {simple_selector_sequence}
-          @scanner.pos = pos
-          @line = line
-
-          if sel =~ /^&/
-            begin
-              throw_error {expected('"{"')}
-            rescue Sass::SyntaxError => e
-              e.message << "\n\n\"#{sel}\" may only be used at the beginning of a selector."
-              raise e
-            end
-          else
-            Sass::Util.sass_warn(<<MESSAGE)
-DEPRECATION WARNING:
-On line #{@line}#{" of \"#{@filename}\"" if @filename}, after "#{self.class.prior_snippet(@scanner)}"
-Starting in Sass 3.2, "#{sel}" may only be used at the beginning of a selector.
+        if tok?(/&/)
+          begin
+            expected('"{"')
+          rescue Sass::SyntaxError => e
+            e.message << "\n\n" << <<MESSAGE
+In Sass 3, the parent selector & can only be used where element names are valid,
+since it could potentially be replaced by an element name.
 MESSAGE
+            raise e
           end
         end
 
@@ -669,10 +559,14 @@ MESSAGE
             tok(SUBSTRINGMATCH)
           @expected = "identifier or string"
           ss
-          val = interp_ident || expr!(:interp_string)
+          if val = tok(IDENT)
+            val = [val]
+          else
+            val = expr!(:interp_string)
+          end
           ss
         end
-        tok!(/\]/)
+        tok(/\]/)
 
         Selector::Attribute.new(merge(name), merge(ns), op, merge(val))
       end
@@ -762,7 +656,7 @@ MESSAGE
         # we don't parse it at all, and instead return a plain old string
         # containing the value.
         # This results in a dramatic speed increase.
-        if val = tok(STATIC_VALUE, true)
+        if val = tok(STATIC_VALUE)
           return space, Sass::Script::String.new(val.strip)
         end
         return space, sass_script(:parse)
@@ -851,7 +745,7 @@ MESSAGE
       end
 
       def interp_ident(start = IDENT)
-        return unless val = tok(start) || interpolation || tok(IDENT_HYPHEN_INTERP, true)
+        return unless val = tok(start) || interpolation
         res = [val]
         while val = tok(NAME) || interpolation
           res << val
@@ -872,14 +766,8 @@ MESSAGE
       end
 
       def str?
-        pos = @scanner.pos
-        line = @line
         @strs.push ""
-        throw_error {yield} && @strs.last
-      rescue Sass::SyntaxError => e
-        @scanner.pos = pos
-        @line = line
-        nil
+        yield && @strs.last
       ensure
         @strs.pop
       end
@@ -920,9 +808,6 @@ MESSAGE
         :selector_comma_sequence => "selector",
         :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",
-        :moz_document_function => "matching function (e.g. url-prefix(), domain())",
-        :supports_condition => "@supports condition (e.g. (display: flexbox))",
-        :supports_condition_in_parens => "@supports condition (e.g. (display: flexbox))",
       }
 
       TOK_NAMES = Sass::Util.to_hash(
@@ -961,13 +846,6 @@ MESSAGE
         raise Sass::SyntaxError.new(msg, :line => @line)
       end
 
-      def throw_error
-        old_throw_error, @throw_error = @throw_error, false
-        yield
-      ensure
-        @throw_error = old_throw_error
-      end
-
       def catch_error(&block)
         old_throw_error, @throw_error = @throw_error, true
         pos = @scanner.pos
@@ -987,7 +865,7 @@ MESSAGE
         if @throw_err
           throw :_sass_parser_error, err
         else
-          @scanner = Sass::Util::MultibyteStringScanner.new(@scanner.string)
+          @scanner = StringScanner.new(@scanner.string)
           @scanner.pos = err[:pos]
           @line = err[:line]
           @expected = err[:expected]
@@ -997,6 +875,16 @@ MESSAGE
 
       # @private
       def self.expected(scanner, expected, line)
+        pos = scanner.pos
+
+        after = scanner.string[0...pos]
+        # Get rid of whitespace between pos and the last token,
+        # but only if there's a newline in there
+        after.gsub!(/\s*\n\s*$/, '')
+        # Also get rid of stuff before the last newline
+        after.gsub!(/.*\n/, '')
+        after = "..." + after[-15..-1] if after.size > 18
+
         was = scanner.rest.dup
         # Get rid of whitespace between pos and the next token,
         # but only if there's a newline in there
@@ -1006,42 +894,17 @@ MESSAGE
         was = was[0...15] + "..." if was.size > 18
 
         raise Sass::SyntaxError.new(
-          "Invalid CSS after \"#{prior_snippet(scanner)}\": expected #{expected}, was \"#{was}\"",
+          "Invalid CSS after \"#{after}\": expected #{expected}, was \"#{was}\"",
           :line => line)
       end
 
-      # @private
-      def self.prior_snippet(scanner)
-        pos = scanner.pos
-
-        after = scanner.string[0...pos]
-        # Get rid of whitespace between pos and the last token,
-        # but only if there's a newline in there
-        after.gsub!(/\s*\n\s*$/, '')
-        # Also get rid of stuff before the last newline
-        after.gsub!(/.*\n/, '')
-        after = "..." + after[-15..-1] if after.size > 18
-        after
-      end
-
       # Avoid allocating lots of new strings for `#tok`.
       # This is important because `#tok` is called all the time.
       NEWLINE = "\n"
 
-      def tok(rx, last_group_lookahead = false)
+      def tok(rx)
         res = @scanner.scan(rx)
         if res
-          # This fixes https://github.com/nex3/sass/issues/104, which affects
-          # Ruby 1.8.7 and REE. This fix is to replace the ?= zero-width
-          # positive lookahead operator in the Regexp (which matches without
-          # consuming the matched group), with a match that does consume the
-          # group, but then rewinds the scanner and removes the group from the
-          # end of the matched string. This fix makes the assumption that the
-          # matched group will always occur at the end of the match.
-          if last_group_lookahead && @scanner[-1]
-            @scanner.pos -= @scanner[-1].length
-            res.slice!(-@scanner[-1].length..-1)
-          end
           @line += res.count(NEWLINE)
           @expected = nil
           if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT