sass 3.6.0 → 3.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 82509c4a444a2c000d6f55f2d47502dcb94b70e903da358f22e00869cd292d35
-  data.tar.gz: 79d675357ab4eefa7cb6960d489de1ee2f2c73e901b8142865db5cdf54821357
+SHA1:
+  metadata.gz: e9abf6343867b108ab17ccfa5170666b2a45f904
+  data.tar.gz: b5744bc72de099acd9ead2a0df936c122b80eab7
 SHA512:
-  metadata.gz: 701b7fdcc0f1a03af08ef639680040b307f2e5e3210cd785434ec8296ccfb5a10dc1258906914fdacf73414a3c8aaeaa5179d545faa524b6e450cc39c0980069
-  data.tar.gz: 8db9b3fa129857550a352af2973cd9795874645ef8fc869a6c1c13643e01fbd98cacd79e11af9a88004f630847ec0b3ea6db8ddeb7baec847068c2ec47f160fc
+  metadata.gz: 2a4f75cb603cc8c249e13a5d20d35b84302a98834e3a768a38c3fefffdc8b3ab52217c118855ea087ce12ec24a5327302e5516e02112c122456299ad7aacf446
+  data.tar.gz: a56c6e88b050deba0d2d2b6c74c784e5c71337e6b6a1f0ce5432aa9d75395fe27654b6ff9e9d5f3fa91abc5d02a800337c67710f6bb06143f514a024f24e995e

data/CONTRIBUTING.md

@@ -18,7 +18,7 @@ is regularly merged into the one below: `stable` into `next`, `next` into
 `master`.
 
 * The `stable` branch is the default—it's what GitHub shows if you go to
-  [sass/sass](https://github.com/sass/sass), and it's the default place for pull
+  [sass/ruby-sass](https://github.com/sass/ruby-sass), and it's the default place for pull
   requests to go. This branch is where we work on the next patch release. Bug
   fixes and documentation improvements belong here, but not new features.
 

data/README.md

@@ -1,3 +1,13 @@
+## Ruby Sass is Deprecated!
+
+Ruby Sass is in a sunset period where only critical bugs and CSS compatibility
+issues will be fixed. It will be completely unmaintained as of 26 March 2019.
+See [the Sass website][] for details, and consider switching to the [`sassc`
+gem][]
+
+[the Sass website]: https://sass-lang.com/ruby-sass
+[`sassc` gem]: https://rubygems.org/gems/sassc
+
 # Sass [![Travis Build Status](https://travis-ci.org/sass/ruby-sass.svg?branch=next)](https://travis-ci.org/sass/ruby-sass) [![Gem Version](https://badge.fury.io/rb/sass.svg)](http://badge.fury.io/rb/sass) [![Inline docs](http://inch-ci.org/github/sass/sass.svg)](http://inch-ci.org/github/sass/sass)
 
 **Sass makes CSS fun again**. Sass is an extension of CSS,

data/VERSION

@@ -1 +1 @@
-3.6.0
+3.7.0

data/VERSION_DATE

@@ -1 +1 @@
-19 September 2018 17:19:09 UTC
+06 November 2018 23:08:31 UTC

data/lib/sass/script/css_parser.rb

@@ -24,7 +24,10 @@ module Sass
       end
 
       # Short-circuit all the SassScript-only productions
-      alias_method :interpolation, :space
+      def interpolation(first: nil, inner: :space)
+        first || send(inner)
+      end
+
       alias_method :or_expr, :div
       alias_method :unary_div, :ident
       alias_method :paren, :string

data/lib/sass/script/functions.rb

@@ -664,15 +664,11 @@ module Sass::Script
       assert_type green, :Number, :green
       assert_type blue, :Number, :blue
 
-      color_attrs = [red, green, blue].map do |c|
-        if c.is_unit?("%")
-          c.value * 255 / 100.0
-        elsif c.unitless?
-          c.value
-        else
-          raise ArgumentError.new("Expected #{c} to be unitless or have a unit of % but got #{c}")
-        end
-      end
+      color_attrs = [
+        percentage_or_unitless(red, 255, "red"),
+        percentage_or_unitless(green, 255, "green"),
+        percentage_or_unitless(blue, 255, "blue")
+      ]
 
       # Don't store the string representation for function-created colors, both
       # because it's not very useful and because some functions aren't supported
@@ -737,8 +733,7 @@ module Sass::Script
           unquoted_string("rgba(#{color.red}, #{color.green}, #{color.blue}, #{alpha})")
         else
           assert_type alpha, :Number, :alpha
-          check_alpha_unit alpha, 'rgba'
-          color.with(:alpha => alpha.value)
+          color.with(:alpha => percentage_or_unitless(alpha, 1, "alpha"))
         end
       when 3
         if var?(args[0]) || var?(args[1]) || var?(args[2])
@@ -840,7 +835,6 @@ module Sass::Script
       assert_type saturation, :Number, :saturation
       assert_type lightness, :Number, :lightness
       assert_type alpha, :Number, :alpha
-      check_alpha_unit alpha, 'hsla'
 
       h = hue.value
       s = saturation.value
@@ -850,7 +844,8 @@ module Sass::Script
       # because it's not very useful and because some functions aren't supported
       # on older browsers.
       Sass::Script::Value::Color.new(
-        :hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
+        :hue => h, :saturation => s, :lightness => l,
+        :alpha => percentage_or_unitless(alpha, 1, "alpha"))
     end
     declare :hsla, [:hue, :saturation, :lightness, :alpha]
     declare :hsla, [:hue, :saturation, :lightness]
@@ -2911,19 +2906,14 @@ WARNING
       color.with(attr => color.send(attr).send(op, amount.value))
     end
 
-    def check_alpha_unit(alpha, function)
-      return if alpha.unitless?
-
-      if alpha.is_unit?("%")
-        Sass::Util.sass_warn(<<WARNING)
-DEPRECATION WARNING: Passing a percentage as the alpha value to #{function}() will be
-interpreted differently in future versions of Sass. For now, use #{alpha.value} instead.
-WARNING
+    def percentage_or_unitless(number, max, name)
+      if number.unitless?
+        value = number.value
+      elsif number.is_unit?("%")
+        value = max * number.value / 100.0;
       else
-        Sass::Util.sass_warn(<<WARNING)
-DEPRECATION WARNING: Passing a number with units as the alpha value to #{function}() is
-deprecated and will be an error in future versions of Sass. Use #{alpha.value} instead.
-WARNING
+        raise ArgumentError.new(
+          "$#{name}: Expected #{number} to have no units or \"%\"");
       end
     end
   end

data/lib/sass/script/lexer.rb

@@ -190,6 +190,14 @@ module Sass
         @scanner.string[pos, 1]
       end
 
+      # Consumes and returns single raw character from the input stream.
+      #
+      # @return [String]
+      def next_char
+        unpeek!
+        scan(/./)
+      end
+
       # Returns the next token without moving the lexer forward.
       #
       # @return [Token] The next token
@@ -200,6 +208,7 @@ module Sass
       # Rewinds the underlying StringScanner
       # to before the token returned by \{#peek}.
       def unpeek!
+        raise "[BUG] Can't unpeek before a queued token!" if @next_tok
         return unless @tok
         @scanner.pos = @tok.pos
         @line = @tok.source_range.start_pos.line
@@ -243,6 +252,30 @@ module Sass
         @scanner.string[old_pos...new_pos]
       end
 
+      # Runs a block, and rewinds the state of the lexer to the beginning of the
+      # block if it returns `nil` or `false`.
+      def try
+        old_pos = @scanner.pos
+        old_line = @line
+        old_offset = @offset
+        old_interpolation_stack = @interpolation_stack.dup
+        old_prev = @prev
+        old_tok = @tok
+        old_next_tok = @next_tok
+
+        result = yield
+        return result if result
+
+        @scanner.pos = old_pos
+        @line = old_line
+        @offset = old_offset
+        @interpolation_stack = old_interpolation_stack
+        @prev = old_prev
+        @tok = old_tok
+        @next_tok = old_next_tok
+        nil
+      end
+
       private
 
       def read_token
@@ -266,10 +299,14 @@ module Sass
       end
 
       def token
-        if after_interpolation? && (interp = @interpolation_stack.pop)
-          interp_type, interp_value = interp
+        if after_interpolation?
+          interp_type, interp_value = @interpolation_stack.pop
           if interp_type == :special_fun
             return special_fun_body(interp_value)
+          elsif interp_type.nil?
+            if @scanner.string[@scanner.pos - 1] == '}' && scan(REGULAR_EXPRESSIONS[:ident])
+              return [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1], start: false)]
+            end
           else
             raise "[BUG]: Unknown interp_type #{interp_type}" unless interp_type == :string
             return string(interp_value, true)
@@ -287,13 +324,12 @@ module Sass
 
       def _variable(rx)
         return unless scan(rx)
-
-        [:const, @scanner[2]]
+        [:const, Sass::Util.normalize_ident_escapes(@scanner[2])]
       end
 
       def ident
         return unless scan(REGULAR_EXPRESSIONS[:ident])
-        [@scanner[2] ? :funcall : :ident, @scanner[1]]
+        [@scanner[2] ? :funcall : :ident, Sass::Util.normalize_ident_escapes(@scanner[1])]
       end
 
       def string(re, open)
@@ -349,7 +385,9 @@ MESSAGE
 
         value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
         value *= 10**@scanner[3].to_i if @scanner[3]
-        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
+        units = @scanner[4]
+        units = Sass::Util::normalize_ident_escapes(units) if units
+        script_number = Script::Value::Number.new(value, Array(units))
         [:number, script_number]
       end
 
@@ -373,7 +411,7 @@ MESSAGE
            @scanner[0].length == 7 || @scanner[0].length == 9)
           return [:color, Script::Value::Color.from_hex(@scanner[0])]
         end
-        [:ident, @scanner[0]]
+        [:ident, Sass::Util.normalize_ident_escapes(@scanner[0])]
       end
 
       def color

data/lib/sass/script/parser.rb

@@ -78,7 +78,7 @@ module Sass
       # Parses a SassScript expression,
       # ending it when it encounters one of the given identifier tokens.
       #
-      # @param tokens [#include?(String)] A set of strings that delimit the expression.
+      # @param tokens [#include?(String | Symbol)] A set of strings or symbols that delimit the expression.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
       def parse_until(tokens)
@@ -270,7 +270,11 @@ module Sass
               interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect})
               return interp if interp
               return unless e = #{sub}
-              while tok = try_toks(#{ops.map {|o| o.inspect}.join(', ')})
+
+              while tok = peek_toks(#{ops.map {|o| o.inspect}.join(', ')})
+                return e if @stop_at && @stop_at.include?(tok.type)
+                @lexer.next
+
                 if interp = try_op_before_interp(tok, e)
                   other_interp = try_ops_after_interp(#{ops.inspect}, #{name.inspect}, interp)
                   return interp unless other_interp
@@ -386,8 +390,11 @@ RUBY
 
       def try_ops_after_interp(ops, name, prev = nil)
         return unless @lexer.after_interpolation?
-        op = try_toks(*ops)
+        op = peek_toks(*ops)
         return unless op
+        return if @stop_at && @stop_at.include?(op.type)
+        @lexer.next
+
         interp = try_op_before_interp(op, prev, :after_interp)
         return interp if interp
 
@@ -416,7 +423,7 @@ RUBY
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
           char_before = @lexer.char(interp.pos - 1)
-          mid = assert_expr :expr
+          mid = without_stop_at {assert_expr :expr}
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
           char_after = @lexer.char
@@ -497,7 +504,7 @@ RUBY
       unary :not, :ident
 
       def ident
-        return funcall unless @lexer.peek && @lexer.peek.type == :ident
+        return css_min_max unless @lexer.peek && @lexer.peek.type == :ident
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
@@ -514,6 +521,122 @@ RUBY
         end
       end
 
+      def css_min_max
+        @lexer.try do
+          next unless tok = try_tok(:funcall)
+          next unless %w[min max].include?(tok.value.downcase)
+          next unless contents = min_max_contents
+          node(array_to_interpolation(["#{tok.value}(", *contents]),
+               tok.source_range.start_pos, source_position)
+        end || funcall
+      end
+
+      def min_max_contents(allow_comma: true)
+        result = []
+        loop do
+          if tok = try_tok(:number)
+            result << tok.value.to_s
+          elsif value = min_max_interpolation
+            result << value
+          elsif value = min_max_calc
+            result << value.value
+          elsif value = min_max_function ||
+                        min_max_parens ||
+                        nested_min_max
+            result.concat value
+          else
+            return
+          end
+
+          if try_tok(:rparen)
+            result << ")"
+            return result
+          elsif tok = try_tok(:plus) || try_tok(:minus) || try_tok(:times) || try_tok(:div)
+            result << " #{Lexer::OPERATORS_REVERSE[tok.type]} "
+          elsif allow_comma && try_tok(:comma)
+            result << ", "
+          else
+            return
+          end
+        end
+      end
+
+      def min_max_interpolation
+        without_stop_at do
+          tok = try_tok(:begin_interpolation)
+          return unless tok
+          expr = without_stop_at {assert_expr :expr}
+          assert_tok :end_interpolation
+          expr
+        end
+      end
+
+      def min_max_function
+        return unless tok = peek_tok(:funcall)
+        return unless %w[calc env var].include?(tok.value.downcase)
+        @lexer.next
+        result = [tok.value, '(', *declaration_value, ')']
+        assert_tok :rparen
+        result
+      end
+
+      def min_max_calc
+        return unless tok = peek_tok(:special_fun)
+        return unless tok.value.value.downcase.start_with?("calc(")
+        @lexer.next.value
+      end
+
+      def min_max_parens
+        return unless try_tok :lparen
+        return unless contents = min_max_contents(allow_comma: false)
+        ['(', *contents]
+      end
+
+      def nested_min_max
+        return unless tok = peek_tok(:funcall)
+        return unless %w[min max].include?(tok.value.downcase)
+        @lexer.next
+        return unless contents = min_max_contents
+        [tok.value, '(', *contents]
+      end
+
+      def declaration_value
+        result = []
+        brackets = []
+        loop do
+          result << @lexer.str do
+            until @lexer.done? ||
+                  peek_toks(:begin_interpolation,
+                            :end_interpolation,
+                            :lcurly,
+                            :lparen,
+                            :lsquare,
+                            :rparen,
+                            :rsquare)
+              @lexer.next || @lexer.next_char
+            end
+          end
+
+          if try_tok(:begin_interpolation)
+            result << assert_expr(:expr)
+            assert_tok :end_interpolation
+          elsif tok = try_toks(:lcurly, :lparen, :lsquare)
+            brackets << case tok.type
+                        when :lcurly; :end_interpolation
+                        when :lparen; :rparen
+                        when :lsquare; :rsquare
+                        end
+            result << Lexer::OPERATORS_REVERSE[tok.type]
+          elsif brackets.empty?
+            return result
+          else
+            bracket = brackets.pop
+            assert_tok bracket
+            result << Lexer::OPERATORS_REVERSE[bracket]
+          end
+        end
+      end
+
       def funcall
         tok = try_tok(:funcall)
         return raw unless tok
@@ -530,28 +653,30 @@ RUBY
           return [], nil unless try_tok(:lparen)
         end
 
-        res = []
-        splat = nil
-        must_have_default = false
-        loop do
-          break if peek_tok(:rparen)
-          c = assert_tok(:const)
-          var = node(Script::Tree::Variable.new(c.value), c.source_range)
-          if try_tok(:colon)
-            val = assert_expr(:space)
-            must_have_default = true
-          elsif try_tok(:splat)
-            splat = var
-            break
-          elsif must_have_default
-            raise SyntaxError.new(
-              "Required argument #{var.inspect} must come before any optional arguments.")
+        without_stop_at do
+          res = []
+          splat = nil
+          must_have_default = false
+          loop do
+            break if peek_tok(:rparen)
+            c = assert_tok(:const)
+            var = node(Script::Tree::Variable.new(c.value), c.source_range)
+            if try_tok(:colon)
+              val = assert_expr(:space)
+              must_have_default = true
+            elsif try_tok(:splat)
+              splat = var
+              break
+            elsif must_have_default
+              raise SyntaxError.new(
+                "Required argument #{var.inspect} must come before any optional arguments.")
+            end
+            res << [var, val]
+            break unless try_tok(:comma)
           end
-          res << [var, val]
-          break unless try_tok(:comma)
+          assert_tok(:rparen)
+          return res, splat
         end
-        assert_tok(:rparen)
-        return res, splat
       end
 
       def fn_arglist
@@ -563,36 +688,38 @@ RUBY
       end
 
       def arglist(subexpr, description)
-        args = []
-        keywords = Sass::Util::NormalizedMap.new
-        splat = nil
-        while (e = send(subexpr))
-          if @lexer.peek && @lexer.peek.type == :colon
-            name = e
-            @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
-            assert_tok(:colon)
-            value = assert_expr(subexpr, description)
-
-            if keywords[name.name]
-              raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
-            end
+        without_stop_at do
+          args = []
+          keywords = Sass::Util::NormalizedMap.new
+          splat = nil
+          while (e = send(subexpr))
+            if @lexer.peek && @lexer.peek.type == :colon
+              name = e
+              @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
+              assert_tok(:colon)
+              value = assert_expr(subexpr, description)
+
+              if keywords[name.name]
+                raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+              end
 
-            keywords[name.name] = value
-          else
-            if try_tok(:splat)
-              return args, keywords, splat, e if splat
-              splat, e = e, nil
-            elsif splat
-              raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
-            elsif !keywords.empty?
-              raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              keywords[name.name] = value
+            else
+              if try_tok(:splat)
+                return args, keywords, splat, e if splat
+                splat, e = e, nil
+              elsif splat
+                raise SyntaxError.new("Only keyword arguments may follow variable arguments (...).")
+              elsif !keywords.empty?
+                raise SyntaxError.new("Positional arguments must come before keyword arguments.")
+              end
+              args << e if e
             end
-            args << e if e
-          end
 
-          return args, keywords, splat unless try_tok(:comma)
+            return args, keywords, splat unless try_tok(:comma)
+          end
+          return args, keywords
         end
-        return args, keywords
       end
 
       def raw
@@ -606,7 +733,7 @@ RUBY
         return square_list unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = assert_expr :expr
+        mid = without_stop_at {assert_expr :expr}
         assert_tok :end_interpolation
         last = assert_expr(:special_fun)
         node(
@@ -618,54 +745,58 @@ RUBY
         start_pos = source_position
         return paren unless try_tok(:lsquare)
 
-        space_start_pos = source_position
-        e = interpolation(inner: :or_expr)
-        separator = nil
-        if e
-          elements = [e]
-          while (e = interpolation(inner: :or_expr))
-            elements << e
-          end
-
-          # If there's a comma after a space-separated list, it's actually a
-          # space-separated list nested in a comma-separated list.
-          if try_tok(:comma)
-            e = if elements.length == 1
-                  elements.first
-                else
-                  node(
-                    Sass::Script::Tree::ListLiteral.new(elements, separator: :space),
-                    space_start_pos)
-                end
+        without_stop_at do
+          space_start_pos = source_position
+          e = interpolation(inner: :or_expr)
+          separator = nil
+          if e
             elements = [e]
-
-            while (e = space)
+            while (e = interpolation(inner: :or_expr))
               elements << e
-              break unless try_tok(:comma)
             end
-            separator = :comma
+
+            # If there's a comma after a space-separated list, it's actually a
+            # space-separated list nested in a comma-separated list.
+            if try_tok(:comma)
+              e = if elements.length == 1
+                    elements.first
+                  else
+                    node(
+                      Sass::Script::Tree::ListLiteral.new(elements, separator: :space),
+                      space_start_pos)
+                  end
+              elements = [e]
+
+              while (e = space)
+                elements << e
+                break unless try_tok(:comma)
+              end
+              separator = :comma
+            else
+              separator = :space if elements.length > 1
+            end
           else
-            separator = :space if elements.length > 1
+            elements = []
           end
-        else
-          elements = []
-        end
 
-        assert_tok(:rsquare)
-        end_pos = source_position
+          assert_tok(:rsquare)
+          end_pos = source_position
 
-        node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
-             start_pos, end_pos)
+          node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
+               start_pos, end_pos)
+        end
       end
 
       def paren
         return variable unless try_tok(:lparen)
-        start_pos = source_position
-        e = map
-        e.force_division! if e
-        end_pos = source_position
-        assert_tok(:rparen)
-        e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
+        without_stop_at do
+          start_pos = source_position
+          e = map
+          e.force_division! if e
+          end_pos = source_position
+          assert_tok(:rparen)
+          e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
+        end
       end
 
       def variable
@@ -682,7 +813,7 @@ RUBY
         return str unless try_tok(:string_interpolation)
         mid = assert_expr :expr
         assert_tok :end_interpolation
-        last = assert_expr(:string)
+        last = without_stop_at {assert_expr(:string)}
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
       end
 
@@ -740,7 +871,12 @@ RUBY
       def peek_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type
+        peeked && name == peeked.type && peeked
+      end
+
+      def peek_toks(*names)
+        peeked = @lexer.peek
+        peeked && names.include?(peeked.type) && peeked
       end
 
       def try_tok(name)
@@ -748,8 +884,7 @@ RUBY
       end
 
       def try_toks(*names)
-        peeked = @lexer.peek
-        peeked && names.include?(peeked.type) && @lexer.next
+        peek_toks(*names) && @lexer.next
       end
 
       def assert_done
@@ -763,6 +898,14 @@ RUBY
         end
       end
 
+      def without_stop_at
+        old_stop_at = @stop_at
+        @stop_at = nil
+        yield
+      ensure
+        @stop_at = old_stop_at
+      end
+
       # @overload node(value, source_range)
       #   @param value [Sass::Script::Value::Base]
       #   @param source_range [Sass::Source::Range]
@@ -795,6 +938,29 @@ RUBY
         node
       end
 
+      # Converts an array of strings and expressions to a string interoplation
+      # object.
+      #
+      # @param array [Array<Script::Tree:Node | String>]
+      # @return [Script::Tree::StringInterpolation]
+      def array_to_interpolation(array)
+        Sass::Util.merge_adjacent_strings(array).reverse.inject(nil) do |after, value|
+          if value.is_a?(::String)
+            literal = Sass::Script::Tree::Literal.new(
+              Sass::Script::Value::String.new(value))
+            next literal unless after
+            Sass::Script::Tree::StringInterpolation.new(literal, after.mid, after.after)
+          else
+            Sass::Script::Tree::StringInterpolation.new(
+              Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')),
+              value,
+              after || Sass::Script::Tree::Literal.new(
+                Sass::Script::Value::String.new('')))
+          end
+        end
+      end
+
       # Checks a script node for any immediately-deprecated interpolations, and
       # emits warnings for them.
       #