sass 3.4.25 → 3.5.0.pre.rc.1

data/lib/sass/script/lexer.rb

@@ -19,13 +19,13 @@ module Sass
       # `source_range`: \[`Sass::Source::Range`\]
       # : The range in the source file in which the token appeared.
       #
-      # `pos`: \[`Integer`\]
+      # `pos`: \[`Fixnum`\]
       # : The scanner position at which the SassScript token appeared.
       Token = Struct.new(:type, :value, :source_range, :pos)
 
       # The line number of the lexer's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def line
         return @line unless @tok
         @tok.source_range.start_pos.line
@@ -34,7 +34,7 @@ module Sass
       # The number of bytes into the current line
       # of the lexer's current position (1-based).
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def offset
         return @offset unless @tok
         @tok.source_range.start_pos.offset
@@ -51,6 +51,8 @@ module Sass
         ':' => :colon,
         '(' => :lparen,
         ')' => :rparen,
+        '[' => :lsquare,
+        ']' => :rsquare,
         ',' => :comma,
         'and' => :and,
         'or' => :or,
@@ -142,12 +144,12 @@ module Sass
       }
 
       # @param str [String, StringScanner] The source text to lex
-      # @param line [Integer] The 1-based line on which the SassScript appears.
+      # @param line [Fixnum] The 1-based line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Integer] The 1-based character (not byte) offset in the line in the source.
+      # @param offset [Fixnum] The 1-based character (not byte) offset in the line in the source.
       #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash;
-      #   see {file:SASS_REFERENCE.md#Options the Sass options documentation}
+      #   see {file:SASS_REFERENCE.md#options the Sass options documentation}
       def initialize(str, line, offset, options)
         @scanner = str.is_a?(StringScanner) ? str : Sass::Util::MultibyteStringScanner.new(str)
         @line = line

data/lib/sass/script/parser.rb

@@ -1,5 +1,4 @@
 require 'sass/script/lexer'
-require 'sass/script/css_variable_warning'
 
 module Sass
   module Script
@@ -8,25 +7,25 @@ module Sass
     class Parser
       # The line number of the parser's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def line
         @lexer.line
       end
 
       # The column number of the parser's current position.
       #
-      # @return [Integer]
+      # @return [Fixnum]
       def offset
         @lexer.offset
       end
 
       # @param str [String, StringScanner] The source text to parse
-      # @param line [Integer] The line on which the SassScript appears.
+      # @param line [Fixnum] The line on which the SassScript appears.
       #   Used for error reporting and sourcemap building
-      # @param offset [Integer] The character (not byte) offset where the script starts in the line.
+      # @param offset [Fixnum] The character (not byte) offset where the script starts in the line.
       #   Used for error reporting and sourcemap building
       # @param options [{Symbol => Object}] An options hash; see
-      #   {file:SASS_REFERENCE.md#Options the Sass options documentation}.
+      #   {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
       #   This supports an additional `:allow_extra_text` option that controls
       #   whether the parser throws an error when extra text is encountered
       #   after the parsed construct.
@@ -35,7 +34,6 @@ module Sass
         @allow_extra_text = options.delete(:allow_extra_text)
         @lexer = lexer_class.new(str, line, offset, options)
         @stop_at = nil
-        @css_variable_warning = nil
       end
 
       # Parses a SassScript expression within an interpolated segment (`#{}`).
@@ -64,23 +62,13 @@ module Sass
 
       # Parses a SassScript expression.
       #
-      # @param css_variable [Boolean] Whether this is the value of a CSS variable.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
-      def parse(css_variable = false)
-        if css_variable
-          @css_variable_warning = CssVariableWarning.new
-        end
-
+      def parse
         expr = assert_expr :expr
         assert_done
         expr.options = @options
         check_for_interpolation expr
-
-        if css_variable
-          @css_variable_warning.value = expr
-        end
-
         expr
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
@@ -127,7 +115,7 @@ module Sass
           a.options = @options
         end
 
-        keywords.each do |_k, v|
+        keywords.each do |_, v|
           check_for_interpolation v
           v.options = @options
         end
@@ -232,12 +220,12 @@ module Sass
 
       # Parses a SassScript expression.
       #
+      # @overload parse(str, line, offset, filename = nil)
       # @return [Script::Tree::Node] The root node of the parse tree
       # @see Parser#initialize
       # @see Parser#parse
-      def self.parse(value, line, offset, options = {})
-        css_variable = options.delete :css_variable
-        new(value, line, offset, options).parse(css_variable)
+      def self.parse(*args)
+        new(*args).parse
       end
 
       PRECEDENCE = [
@@ -250,8 +238,6 @@ module Sass
 
       ASSOCIATIVE = [:plus, :times]
 
-      VALID_CSS_OPS = [:comma, :single_eq, :space, :div]
-
       class << self
         # Returns an integer representing the precedence
         # of the given operator.
@@ -291,10 +277,6 @@ module Sass
                   return other_interp
                 end
 
-                if @css_variable_warning && !VALID_CSS_OPS.include?(tok.type)
-                  @css_variable_warning.warn!
-                end
-
                 e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type),
                          e.source_range.start_pos)
               end
@@ -310,8 +292,6 @@ RUBY
               interp = try_op_before_interp(tok)
               return interp if interp
               start_pos = source_position
-
-              @css_variable_warning.warn! if @css_variable_warning
               node(Tree::UnaryOperation.new(assert_expr(:unary_#{op}), :#{op}), start_pos)
             end
 RUBY
@@ -338,7 +318,6 @@ RUBY
         return list e, start_pos unless @lexer.peek && @lexer.peek.type == :colon
 
         pair = map_pair(e)
-        @css_variable_warning.warn! if @css_variable_warning
         map = node(Sass::Script::Tree::MapLiteral.new([pair]), start_pos)
         while try_tok(:comma)
           pair = map_pair
@@ -364,7 +343,7 @@ RUBY
       def list(first, start_pos)
         return first unless @lexer.peek && @lexer.peek.type == :comma
 
-        list = node(Sass::Script::Tree::ListLiteral.new([first], :comma), start_pos)
+        list = node(Sass::Script::Tree::ListLiteral.new([first], separator: :comma), start_pos)
         while (tok = try_tok(:comma))
           element_before_interp = list.elements.length == 1 ? list.elements.first : list
           if (interp = try_op_before_interp(tok, element_before_interp))
@@ -401,7 +380,7 @@ RUBY
           Script::Tree::Interpolation.new(
             prev, str, nil, wb, false, :originally_text => true, :deprecation => deprecation),
           (prev || str).source_range.start_pos)
-        interpolation(interp)
+        interpolation(first: interp)
       end
 
       def try_ops_after_interp(ops, name, prev = nil)
@@ -431,17 +410,17 @@ RUBY
         interp
       end
 
-      def interpolation(first = space)
-        e = first
+      def interpolation(first: nil, inner: :space)
+        e = first || send(inner)
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
           char_before = @lexer.char(interp.pos - 1)
-          mid = without_css_variable_warning {assert_expr :expr}
+          mid = assert_expr :expr
           assert_tok :end_interpolation
           wa = @lexer.whitespace?
           char_after = @lexer.char
 
-          after = space
+          after = send(inner)
           before_deprecation = e.is_a?(Script::Tree::Interpolation) ? e.deprecation : :none
           after_deprecation = after.is_a?(Script::Tree::Interpolation) ? after.deprecation : :none
 
@@ -500,7 +479,7 @@ RUBY
         if arr.size == 1
           arr.first
         else
-          node(Sass::Script::Tree::ListLiteral.new(arr, :space), start_pos)
+          node(Sass::Script::Tree::ListLiteral.new(arr, separator: :space), start_pos)
         end
       end
 
@@ -549,12 +528,12 @@ RUBY
         else
           return [], nil unless try_tok(:lparen)
         end
-        return [], nil if try_tok(:rparen)
 
         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)
@@ -585,12 +564,8 @@ RUBY
       def arglist(subexpr, description)
         args = []
         keywords = Sass::Util::NormalizedMap.new
-        e = send(subexpr)
-
-        return [args, keywords] unless e
-
         splat = nil
-        loop do
+        while (e = send(subexpr))
           if @lexer.peek && @lexer.peek.type == :colon
             name = e
             @lexer.expected!("comma") unless name.is_a?(Tree::Variable)
@@ -611,13 +586,12 @@ RUBY
             elsif !keywords.empty?
               raise SyntaxError.new("Positional arguments must come before keyword arguments.")
             end
-
             args << e if e
           end
 
           return args, keywords, splat unless try_tok(:comma)
-          e = assert_expr(subexpr, description)
         end
+        return args, keywords
       end
 
       def raw
@@ -628,10 +602,10 @@ RUBY
 
       def special_fun
         first = try_tok(:special_fun)
-        return paren unless first
+        return square_list unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = without_css_variable_warning {assert_expr :expr}
+        mid = assert_expr :expr
         assert_tok :end_interpolation
         last = assert_expr(:special_fun)
         node(
@@ -639,6 +613,50 @@ RUBY
           first.source_range.start_pos)
       end
 
+      def square_list
+        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
+            elements = [e]
+
+            while (e = space)
+              elements << e
+              break unless try_tok(:comma)
+            end
+            separator = :comma
+          else
+            separator = :space if elements.length > 1
+          end
+        else
+          elements = []
+        end
+
+        assert_tok(:rsquare)
+        end_pos = source_position
+
+        node(Sass::Script::Tree::ListLiteral.new(elements, separator: separator, bracketed: true),
+             start_pos, end_pos)
+      end
+
       def paren
         return variable unless try_tok(:lparen)
         start_pos = source_position
@@ -646,17 +664,13 @@ RUBY
         e.force_division! if e
         end_pos = source_position
         assert_tok(:rparen)
-
-        @css_variable_warning.warn! if @css_variable_warning
-        e || node(Sass::Script::Tree::ListLiteral.new([], nil), start_pos, end_pos)
+        e || node(Sass::Script::Tree::ListLiteral.new([]), start_pos, end_pos)
       end
 
       def variable
         start_pos = source_position
         c = try_tok(:const)
         return string unless c
-
-        @css_variable_warning.warn! if @css_variable_warning
         node(Tree::Variable.new(*c.value), start_pos)
       end
 
@@ -665,7 +679,7 @@ RUBY
         return number unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:string_interpolation)
-        mid = without_css_variable_warning {assert_expr :expr}
+        mid = assert_expr :expr
         assert_tok :end_interpolation
         last = assert_expr(:string)
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
@@ -683,7 +697,6 @@ RUBY
       def selector
         tok = try_tok(:selector)
         return literal unless tok
-        @css_variable_warning.warn! if @css_variable_warning
         node(tok.value, tok.source_range.start_pos)
       end
 
@@ -723,10 +736,14 @@ RUBY
         @lexer.expected!(names.map {|tok| Lexer::TOKEN_NAMES[tok] || tok}.join(" or "))
       end
 
-      def try_tok(name)
+      def peek_tok(name)
         # Avoids an array allocation caused by argument globbing in the try_toks method.
         peeked = @lexer.peek
-        peeked && name == peeked.type && @lexer.next
+        peeked && name == peeked.type
+      end
+
+      def try_tok(name)
+        peek_tok(name) && @lexer.next
       end
 
       def try_toks(*names)
@@ -771,27 +788,12 @@ RUBY
             range(source_range_or_start_pos, end_pos)
           end
 
-        node.css_variable_warning = @css_variable_warning
         node.line = source_range.start_pos.line
         node.source_range = source_range
         node.filename = @options[:filename]
         node
       end
 
-      # Runs the given block without CSS variable warnings enabled.
-      #
-      # CSS warnings don't apply within interpolation, so this is used to
-      # disable them.
-      #
-      # @yield []
-      def without_css_variable_warning
-        old_css_variable_warning = @css_variable_warning
-        @css_variable_warning = nil
-        yield
-      ensure
-        @css_variable_warning = old_css_variable_warning
-      end
-
       # Checks a script node for any immediately-deprecated interpolations, and
       # emits warnings for them.
       #
@@ -818,9 +820,8 @@ RUBY
         location = "on line #{interpolation.line}"
         location << " of #{interpolation.filename}" if interpolation.filename
         Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING #{location}:
-\#{} interpolation near operators will be simplified in a future version of Sass.
-To preserve the current behavior, use quotes:
+DEPRECATION WARNING #{location}: \#{} interpolation near operators will be simplified
+in a future version of Sass. To preserve the current behavior, use quotes:
 
   #{interpolation.to_quoted_equivalent.to_sass}
 

data/lib/sass/script/tree/funcall.rb

@@ -13,6 +13,11 @@ module Sass::Script::Tree
     # @return [String]
     attr_reader :name
 
+    # The callable to be invoked
+    #
+    # @return [Sass::Callable] or nil if no callable is provided.
+    attr_reader :callable
+
     # The arguments to the function.
     #
     # @return [Array<Node>]
@@ -39,13 +44,19 @@ module Sass::Script::Tree
     # @return [Node?]
     attr_accessor :kwarg_splat
 
-    # @param name [String] See \{#name}
+    # @param name_or_callable [String, Sass::Callable] See \{#name}
     # @param args [Array<Node>] See \{#args}
     # @param keywords [Sass::Util::NormalizedMap<Node>] See \{#keywords}
     # @param splat [Node] See \{#splat}
     # @param kwarg_splat [Node] See \{#kwarg_splat}
-    def initialize(name, args, keywords, splat, kwarg_splat)
-      @name = name
+    def initialize(name_or_callable, args, keywords, splat, kwarg_splat)
+      if name_or_callable.is_a?(Sass::Callable)
+        @callable = name_or_callable
+        @name = name_or_callable.name
+      else
+        @callable = nil
+        @name = name_or_callable
+      end
       @args = args
       @keywords = keywords
       @splat = splat
@@ -56,8 +67,7 @@ module Sass::Script::Tree
     # @return [String] A string representation of the function call
     def inspect
       args = @args.map {|a| a.inspect}.join(', ')
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-          map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
       # rubocop:disable RedundantSelf
       if self.splat
         splat = args.empty? && keywords.empty? ? "" : ", "
@@ -77,8 +87,7 @@ module Sass::Script::Tree
       end
 
       args = @args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-        map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
+      keywords = @keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
 
       # rubocop:disable RedundantSelf
       if self.splat
@@ -120,27 +129,31 @@ module Sass::Script::Tree
     # @return [Sass::Script::Value] The SassScript object that is the value of the function call
     # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
     def _perform(environment)
-      args = Sass::Util.enum_with_index(@args).
+      args = @args.each_with_index.
         map {|a, i| perform_arg(a, environment, signature && signature.args[i])}
       keywords = Sass::Util.map_hash(@keywords) do |k, v|
         [k, perform_arg(v, environment, k.tr('-', '_'))]
       end
       splat = Sass::Tree::Visitors::Perform.perform_splat(
         @splat, keywords, @kwarg_splat, environment)
-      if (fn = environment.function(@name))
-        css_variable_warning.warn! if css_variable_warning
-        return without_original(perform_sass_fn(fn, args, splat, environment))
+
+      fn = @callable || environment.function(@name)
+
+      if fn && fn.origin == :stylesheet
+        environment.stack.with_function(filename, line, name) do
+          return without_original(perform_sass_fn(fn, args, splat, environment))
+        end
       end
 
       args = construct_ruby_args(ruby_name, args, splat, environment)
 
-      if Sass::Script::Functions.callable?(ruby_name)
-        css_variable_warning.warn! if css_variable_warning
-
+      if Sass::Script::Functions.callable?(ruby_name) && (!fn || fn.origin == :builtin)
         local_environment = Sass::Environment.new(environment.global_env, environment.options)
         local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
-        result = opts(Sass::Script::Functions::EvaluationContext.new(
-          local_environment).send(ruby_name, *args))
+        result = local_environment.stack.with_function(filename, line, name) do
+          opts(Sass::Script::Functions::EvaluationContext.new(
+            local_environment).send(ruby_name, *args))
+        end
         without_original(result)
       else
         opts(to_literal(args))
@@ -206,6 +219,7 @@ module Sass::Script::Tree
         raise Sass::SyntaxError.new(
           "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
       elsif keywords.empty?
+        args << {} if signature.var_kwargs
         return args
       end
 
@@ -271,30 +285,21 @@ module Sass::Script::Tree
           message = "wrong number of arguments (#{given} for #{expected})"
         end
       elsif Sass::Util.jruby?
-        if Sass::Util.jruby1_6?
-          should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
-            # The one case where JRuby does include the Ruby name of the function
-            # is manually-thrown ArgumentErrors, which are indistinguishable from
-            # legitimate ArgumentErrors. We treat both of these as
-            # Sass::SyntaxErrors even though it can hide Ruby errors.
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-        else
-          should_maybe_raise =
-            e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
-          given, expected = $1, $2
-        end
+        should_maybe_raise =
+          e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
+        given, expected = $1, $2
 
         if should_maybe_raise
           # JRuby 1.7 includes __send__ before send and _perform.
           trace = e.backtrace.dup
-          raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
+          raise e if trace.shift !~ /:in `__send__'$/
 
           # JRuby (as of 1.7.2) doesn't put the actual method
           # for which the argument error was thrown in the backtrace, so we
           # detect whether our send threw an argument error.
           if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
             raise e
-          elsif !Sass::Util.jruby1_6?
+          else
             # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
             message = "wrong number of arguments (#{given} for #{expected})"
           end