sass 3.7.4 → 4.0.0.alpha.1

data/lib/sass/script/value/helpers.rb

@@ -66,35 +66,26 @@ module Sass::Script::Value
       Number.new(number, *parse_unit_string(unit_string))
     end
 
-    # @overload list(*elements, separator:, bracketed: false)
+    # @overload list(*elements, separator)
     #   Create a space-separated list from the arguments given.
     #   @param elements [Array<Sass::Script::Value::Base>] Each argument will be a list element.
     #   @param separator [Symbol] Either :space or :comma.
-    #   @param bracketed [Boolean] Whether the list uses square brackets.
     #   @return [Sass::Script::Value::List] The space separated list.
     #
-    # @overload list(array, separator:, bracketed: false)
+    # @overload list(array, separator)
     #   Create a space-separated list from the array given.
     #   @param array [Array<Sass::Script::Value::Base>] A ruby array of Sass values
     #     to make into a list.
-    #   @param separator [Symbol] Either :space or :comma.
-    #   @param bracketed [Boolean] Whether the list uses square brackets.
     #   @return [Sass::Script::Value::List] The space separated list.
-    def list(*elements, separator: nil, bracketed: false)
-      # Support passing separator as the last value in elements for
-      # backwards-compatibility.
-      if separator.nil?
-        if elements.last.is_a?(Symbol)
-          separator = elements.pop
-        else
-          raise ArgumentError.new("A separator of :space or :comma must be specified.")
-        end
+    def list(*elements)
+      unless elements.last.is_a?(Symbol)
+        raise ArgumentError.new("A list type of :space or :comma must be specified.")
       end
-
+      separator = elements.pop
       if elements.size == 1 && elements.first.is_a?(Array)
         elements = elements.first
       end
-      Sass::Script::Value::List.new(elements, separator: separator, bracketed: bracketed)
+      Sass::Script::Value::List.new(elements, separator)
     end
 
     # Construct a Sass map.
@@ -148,7 +139,7 @@ module Sass::Script::Value
         Sass::SCSS::StaticParser.new(str, nil, nil, 1, 1, allow_parent_ref).parse_selector
       rescue Sass::SyntaxError => e
         err = "#{value.inspect} is not a valid selector: #{e}"
-        err = "$#{name.to_s.tr('_', '-')}: #{err}" if name
+        err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
         raise ArgumentError.new(err)
       end
     end
@@ -172,7 +163,7 @@ module Sass::Script::Value
       return seq if selector.members.length == 1
 
       err = "#{value.inspect} is not a complex selector"
-      err = "$#{name.to_s.tr('_', '-')}: #{err}" if name
+      err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
       raise ArgumentError.new(err)
     end
 
@@ -199,35 +190,18 @@ module Sass::Script::Value
       end
 
       err = "#{value.inspect} is not a compound selector"
-      err = "$#{name.to_s.tr('_', '-')}: #{err}" if name
+      err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
       raise ArgumentError.new(err)
     end
 
-    # Returns true when the literal is a string containing a calc().
-    #
-    # Use \{#special_number?} in preference to this.
+    # Returns true when the literal is a string containing a calc()
     #
     # @param literal [Sass::Script::Value::Base] The value to check
-    # @return Boolean
+    # @return boolean
     def calc?(literal)
-      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /calc\(/
-    end
-
-    # Returns true when the literal is a string containing a var().
-    #
-    # @param literal [Sass::Script::Value::Base] The value to check
-    # @return Boolean
-    def var?(literal)
-      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /var\(/
-    end
-
-    # Returns whether the literal is a special CSS value that may evaluate to a
-    # number, such as `calc()` or `var()`.
-    #
-    # @param literal [Sass::Script::Value::Base] The value to check
-    # @return Boolean
-    def special_number?(literal)
-      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /(calc|var)\(/
+      if literal.is_a?(Sass::Script::Value::String)
+        literal.value =~ /calc\(/
+      end
     end
 
     private
@@ -241,7 +215,7 @@ module Sass::Script::Value
 
       err = "#{value.inspect} is not a valid selector: it must be a string,\n" +
         "a list of strings, or a list of lists of strings"
-      err = "$#{name.to_s.tr('_', '-')}: #{err}" if name
+      err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
       raise ArgumentError.new(err)
     end
 
@@ -278,14 +252,14 @@ module Sass::Script::Value
     def parse_unit_string(unit_string)
       denominator_units = numerator_units = Sass::Script::Value::Number::NO_UNITS
       return numerator_units, denominator_units unless unit_string && unit_string.length > 0
-      num_over_denominator = unit_string.split(%r{ */ *})
+      num_over_denominator = unit_string.split(/ *\/ */)
       unless (1..2).include?(num_over_denominator.size)
         raise ArgumentError.new("Malformed unit string: #{unit_string}")
       end
       numerator_units = num_over_denominator[0].split(/ *\* */)
       denominator_units = (num_over_denominator[1] || "").split(/ *\* */)
       [[numerator_units, "numerator"], [denominator_units, "denominator"]].each do |units, name|
-        if unit_string =~ %r{/} && units.size == 0
+        if unit_string =~ /\// && units.size == 0
           raise ArgumentError.new("Malformed unit string: #{unit_string}")
         end
         if units.any? {|unit| unit !~ VALID_UNIT}

data/lib/sass/script/value/list.rb

@@ -14,20 +14,13 @@ module Sass::Script::Value
     # @return [Symbol]
     attr_reader :separator
 
-    # Whether the list is surrounded by square brackets.
-    #
-    # @return [Boolean]
-    attr_reader :bracketed
-
     # Creates a new list.
     #
     # @param value [Array<Value>] See \{#value}
     # @param separator [Symbol] See \{#separator}
-    # @param bracketed [Boolean] See \{#bracketed}
-    def initialize(value, separator: nil, bracketed: false)
+    def initialize(value, separator)
       super(value)
       @separator = separator
-      @bracketed = bracketed
     end
 
     # @see Value#options=
@@ -40,30 +33,24 @@ module Sass::Script::Value
     def eq(other)
       Sass::Script::Value::Bool.new(
         other.is_a?(List) && value == other.value &&
-        separator == other.separator && bracketed == other.bracketed)
+        separator == other.separator)
     end
 
     def hash
-      @hash ||= [value, separator, bracketed].hash
+      @hash ||= [value, separator].hash
     end
 
     # @see Value#to_s
     def to_s(opts = {})
-      if !bracketed && value.empty?
-        raise Sass::SyntaxError.new("#{inspect} isn't a valid CSS value.")
-      end
-
-      members = value.
+      raise Sass::SyntaxError.new("() isn't a valid CSS value.") if value.empty?
+      value.
         reject {|e| e.is_a?(Null) || e.is_a?(List) && e.value.empty?}.
-        map {|e| e.to_s(opts)}
-
-      contents = members.join(sep_str)
-      bracketed ? "[#{contents}]" : contents
+        map {|e| e.to_s(opts)}.join(sep_str)
     end
 
     # @see Value#to_sass
     def to_sass(opts = {})
-      return bracketed ? "[]" : "()" if value.empty?
+      return "()" if value.empty?
       members = value.map do |v|
         if element_needs_parens?(v)
           "(#{v.to_sass(opts)})"
@@ -71,26 +58,19 @@ module Sass::Script::Value
           v.to_sass(opts)
         end
       end
-
-      if separator == :comma && members.length == 1
-        return "#{bracketed ? '[' : '('}#{members.first},#{bracketed ? ']' : ')'}"
-      end
-
-      contents = members.join(sep_str(nil))
-      bracketed ? "[#{contents}]" : contents
+      return "(#{members.first},)" if members.length == 1 && separator == :comma
+      members.join(sep_str(nil))
     end
 
     # @see Value#to_h
     def to_h
-      return {} if value.empty?
+      return Sass::Util.ordered_hash if value.empty?
       super
     end
 
     # @see Value#inspect
     def inspect
-      (bracketed ? '[' : '(') +
-        value.map {|e| e.inspect}.join(sep_str(nil)) +
-        (bracketed ? ']' : ')')
+      "(#{value.map {|e| e.inspect}.join(sep_str(nil))})"
     end
 
     # Asserts an index is within the list.
@@ -114,10 +94,9 @@ module Sass::Script::Value
 
     def element_needs_parens?(element)
       if element.is_a?(List)
-        return false if element.value.length < 2
-        return false if element.bracketed
-        precedence = Sass::Script::Parser.precedence_of(separator || :space)
-        return Sass::Script::Parser.precedence_of(element.separator || :space) <= precedence
+        return false if element.value.empty?
+        precedence = Sass::Script::Parser.precedence_of(separator)
+        return Sass::Script::Parser.precedence_of(element.separator) <= precedence
       end
 
       return false unless separator == :space

data/lib/sass/script/value/map.rb

@@ -12,7 +12,7 @@ module Sass::Script::Value
     #
     # @param hash [Hash<Node, Node>]
     def initialize(hash)
-      super(hash)
+      super(Sass::Util.ordered_hash(hash))
     end
 
     # @see Value#options=
@@ -32,7 +32,7 @@ module Sass::Script::Value
     # @see Value#to_a
     def to_a
       value.map do |k, v|
-        list = List.new([k, v], separator: :space)
+        list = List.new([k, v], :space)
         list.options = options
         list
       end

data/lib/sass/script/value/number.rb

@@ -34,35 +34,33 @@ module Sass::Script::Value
     attr_accessor :original
 
     def self.precision
-      Thread.current[:sass_numeric_precision] || Thread.main[:sass_numeric_precision] || 10
+      @precision ||= 5
     end
 
     # Sets the number of digits of precision
     # For example, if this is `3`,
     # `3.1415926` will be printed as `3.142`.
-    # The numeric precision is stored as a thread local for thread safety reasons.
-    # To set for all threads, be sure to set the precision on the main thread.
     def self.precision=(digits)
-      Thread.current[:sass_numeric_precision] = digits.round
-      Thread.current[:sass_numeric_precision_factor] = nil
-      Thread.current[:sass_numeric_epsilon] = nil
+      @precision = digits.round
+      @precision_factor = 10.0**@precision
+      @epsilon = 1 / (@precision_factor * 10)
     end
 
     # the precision factor used in numeric output
     # it is derived from the `precision` method.
     def self.precision_factor
-      Thread.current[:sass_numeric_precision_factor] ||= 10.0**precision
+      @precision_factor ||= 10.0**precision
     end
 
     # Used in checking equality of floating point numbers. Any
     # numbers within an `epsilon` of each other are considered functionally equal.
     # The value for epsilon is one tenth of the current numeric precision.
     def self.epsilon
-      Thread.current[:sass_numeric_epsilon] ||= 1 / (precision_factor * 10)
+      @epsilon ||= 1 / (precision_factor * 10)
     end
 
     # Used so we don't allocate two new arrays for each new number.
-    NO_UNITS = []
+    NO_UNITS  = []
 
     # @param value [Numeric] The value of the number
     # @param numerator_units [::String, Array<::String>] See \{#numerator\_units}
@@ -73,7 +71,6 @@ module Sass::Script::Value
       super(value)
       @numerator_units = numerator_units
       @denominator_units = denominator_units
-      @options = nil
       normalize!
     end
 
@@ -189,7 +186,6 @@ module Sass::Script::Value
     # @raise [Sass::UnitConversionError] if `other` has incompatible units
     def mod(other)
       if other.is_a?(Number)
-        return Number.new(Float::NAN) if other.value == 0
         operate(other, :%)
       else
         raise NoMethodError.new(nil, :mod)
@@ -293,21 +289,14 @@ module Sass::Script::Value
       # and confusing.
       str = ("%0.#{self.class.precision}f" % value).gsub(/0*$/, '') if str.include?('e')
 
-      # Sometimes numeric formatting will result in a decimal number with a trailing zero (x.0)
-      if str =~ /(.*)\.0$/
-        str = $1
-      end
-
-      # We omit a leading zero before the decimal point in compressed mode.
       if @options && options[:style] == :compressed
         str.sub!(/^(-)?0\./, '\1.')
       end
-
       unitless? ? str : "#{str}#{unit_str}"
     end
     alias_method :to_sass, :inspect
 
-    # @return [Integer] The integer value of the number
+    # @return [Fixnum] The integer value of the number
     # @raise [Sass::SyntaxError] if the number isn't an integer
     def to_i
       super unless int?
@@ -414,7 +403,7 @@ module Sass::Script::Value
       if num.is_a?(Float) && (num.infinite? || num.nan?)
         num
       elsif basically_equal?(num % 1, 0.0)
-        num.round
+        num.to_i
       else
         ((num * precision_factor).round / precision_factor).to_f
       end
@@ -473,10 +462,11 @@ module Sass::Script::Value
         sans_common_units(@numerator_units, @denominator_units)
 
       @denominator_units.each_with_index do |d, i|
-        next unless convertable?(d) && (u = @numerator_units.find {|n| convertable?([n, d])})
-        @value /= conversion_factor(d, u)
-        @denominator_units.delete_at(i)
-        @numerator_units.delete_at(@numerator_units.index(u))
+        if convertable?(d) && (u = @numerator_units.find(&method(:convertable?)))
+          @value /= conversion_factor(d, u)
+          @denominator_units.delete_at(i)
+          @numerator_units.delete_at(@numerator_units.index(u))
+        end
       end
     end
 
@@ -511,8 +501,8 @@ module Sass::Script::Value
       },
       {
         'dpi'  => Rational(1),
-        'dpcm' => Rational(254, 100),
-        'dppx' => Rational(96)
+        'dpcm' => Rational(1, 2.54),
+        'dppx' => Rational(1, 96)
       }
     ]
 

data/lib/sass/script/value/string.rb

@@ -2,8 +2,6 @@
 module Sass::Script::Value
   # A SassScript object representing a CSS string *or* a CSS identifier.
   class String < Base
-    @@interpolation_deprecation = Sass::Deprecation.new
-
     # The Ruby value of the string.
     #
     # @return [String]
@@ -78,13 +76,9 @@ module Sass::Script::Value
     #
     # @param value [String] See \{#value}
     # @param type [Symbol] See \{#type}
-    # @param deprecated_interp_equivalent [String?]
-    #   If this was created via a potentially-deprecated string interpolation,
-    #   this is the replacement expression that should be suggested to the user.
-    def initialize(value, type = :identifier, deprecated_interp_equivalent = nil)
+    def initialize(value, type = :identifier)
       super(value)
       @type = type
-      @deprecated_interp_equivalent = deprecated_interp_equivalent
     end
 
     # @see Value#plus
@@ -108,29 +102,6 @@ module Sass::Script::Value
       to_s(opts.merge(:sass => true))
     end
 
-    def separator
-      check_deprecated_interp
-      super
-    end
-
-    def to_a
-      check_deprecated_interp
-      super
-    end
-
-    # Prints a warning if this string was created using potentially-deprecated
-    # interpolation.
-    def check_deprecated_interp
-      return unless @deprecated_interp_equivalent
-
-      @@interpolation_deprecation.warn(source_range.file, source_range.start_pos.line, <<WARNING)
-\#{} interpolation near operators will be simplified in a future version of Sass.
-To preserve the current behavior, use quotes:
-
-  #{@deprecated_interp_equivalent}
-WARNING
-    end
-
     def inspect
       String.quote(value)
     end

data/lib/sass/scss.rb

@@ -1,4 +1,6 @@
 require 'sass/scss/rx'
+require 'sass/scss/script_lexer'
+require 'sass/scss/script_parser'
 require 'sass/scss/parser'
 require 'sass/scss/static_parser'
 require 'sass/scss/css_parser'

data/lib/sass/scss/css_parser.rb

@@ -47,15 +47,11 @@ module Sass
       def keyframes_ruleset
         start_pos = source_position
         return unless (selector = keyframes_selector)
-        block(
-          node(
-            Sass::Tree::KeyframeRuleNode.new(
-              Sass::Util.strip_except_escapes(selector)),
-            start_pos),
-          :ruleset)
+        block(node(Sass::Tree::KeyframeRuleNode.new(selector.strip), start_pos), :ruleset)
       end
 
-      @sass_script_parser = Sass::Script::CssParser
+      @sass_script_parser = Class.new(Sass::Script::CssParser)
+      @sass_script_parser.send(:include, ScriptParser)
     end
   end
 end

data/lib/sass/scss/parser.rb

@@ -16,20 +16,21 @@ module Sass
       #   warnings and source maps.
       # @param importer [Sass::Importers::Base] The importer used to import the
       #   file being parsed. Used for source maps.
-      # @param line [Integer] The 1-based line on which the source string appeared,
+      # @param line [Fixnum] The 1-based line on which the source string appeared,
       #   if it's part of another document.
-      # @param offset [Integer] The 1-based character (not byte) offset in the line on
+      # @param offset [Fixnum] The 1-based character (not byte) offset in the line on
       #   which the source string starts. Used for error reporting and sourcemap
       #   building.
+      # @comment
+      #   rubocop:disable ParameterLists
       def initialize(str, filename, importer, line = 1, offset = 1)
+        # rubocop:enable ParameterLists
         @template = str
         @filename = filename
         @importer = importer
         @line = line
         @offset = offset
         @strs = []
-        @expected = nil
-        @throw_error = false
       end
 
       # Parses an SCSS document.
@@ -99,18 +100,6 @@ module Sass
         condition
       end
 
-      # Parses a custom property value.
-      #
-      # @return [Array<String, Sass::Script;:Tree::Node>] The interpolated value.
-      # @raise [Sass::SyntaxError] if there's a syntax error in the value,
-      #   or if it doesn't take up the entire input string.
-      def parse_declaration_value
-        init_scanner!
-        value = declaration_value
-        expected('"}"') unless value && @scanner.eos?
-        value
-      end
-
       private
 
       include Sass::SCSS::RX
@@ -128,7 +117,7 @@ module Sass
           if @template.is_a?(StringScanner)
             @template
           else
-            Sass::Util::MultibyteStringScanner.new(@template.tr("\r", ""))
+            Sass::Util::MultibyteStringScanner.new(@template.gsub("\r", ""))
           end
       end
 
@@ -203,7 +192,7 @@ module Sass
       def directive
         start_pos = source_position
         return unless tok(/@/)
-        name = ident!
+        name = tok!(IDENT)
         ss
 
         if (dir = special_directive(name, start_pos))
@@ -240,14 +229,14 @@ module Sass
       end
 
       def mixin_directive(start_pos)
-        name = ident!
+        name = tok! IDENT
         args, splat = sass_script(:parse_mixin_definition_arglist)
         ss
         block(node(Sass::Tree::MixinDefNode.new(name, args, splat), start_pos), :directive)
       end
 
       def include_directive(start_pos)
-        name = ident!
+        name = tok! IDENT
         args, keywords, splat, kwarg_splat = sass_script(:parse_mixin_include_arglist)
         ss
         include_node = node(
@@ -266,7 +255,7 @@ module Sass
       end
 
       def function_directive(start_pos)
-        name = ident!
+        name = tok! IDENT
         args, splat = sass_script(:parse_function_definition_arglist)
         ss
         block(node(Sass::Tree::FunctionNode.new(name, args, splat), start_pos), :function)
@@ -286,7 +275,7 @@ module Sass
 
       def for_directive(start_pos)
         tok!(/\$/)
-        var = ident!
+        var = tok! IDENT
         ss
 
         tok!(/from/)
@@ -303,12 +292,12 @@ module Sass
 
       def each_directive(start_pos)
         tok!(/\$/)
-        vars = [ident!]
+        vars = [tok!(IDENT)]
         ss
         while tok(/,/)
           ss
           tok!(/\$/)
-          vars << ident!
+          vars << tok!(IDENT)
           ss
         end
 
@@ -407,8 +396,7 @@ module Sass
         ss
         media = media_query_list
         if str =~ %r{^(https?:)?//} || media || supports || use_css_import?
-          return node(
-            Sass::Tree::CssImportNode.new(
+          return node(Sass::Tree::CssImportNode.new(
               Sass::Script::Value::String.quote(str), media.to_a, supports), start_pos)
         end
 
@@ -477,23 +465,12 @@ module Sass
         return unless tok(/\(/)
         res = ['(']
         ss
-        stop_at = Set[:single_eq, :lt, :lte, :gt, :gte]
-        res << sass_script(:parse_until, stop_at)
+        res << sass_script(:parse)
 
         if tok(/:/)
           res << ': '
           ss
           res << sass_script(:parse)
-        elsif comparison1 = tok(/=|[<>]=?/)
-          res << ' ' << comparison1 << ' '
-          ss
-          res << sass_script(:parse_until, stop_at)
-          if ((comparison1 == ">" || comparison1 == ">=") && comparison2 = tok(/>=?/)) ||
-             ((comparison1 == "<" || comparison1 == "<=") && comparison2 = tok(/<=?/))
-            res << ' ' << comparison2 << ' '
-            ss
-            res << sass_script(:parse_until, stop_at)
-          end
         end
         res << tok!(/\)/)
         ss
@@ -534,7 +511,7 @@ module Sass
 
       def moz_document_function
         val = interp_uri || _interp_string(:url_prefix) ||
-          _interp_string(:domain) || function(false) || interpolation
+          _interp_string(:domain) || function(!:allow_var) || interpolation
         return unless val
         ss
         val
@@ -553,10 +530,10 @@ module Sass
       end
 
       def at_root_directive_list
-        return unless (first = ident)
+        return unless (first = tok(IDENT))
         arr = [first]
         ss
-        while (e = ident)
+        while (e = tok(IDENT))
           arr << e
           ss
         end
@@ -583,7 +560,7 @@ module Sass
       def supports_clause
         return unless tok(/supports\(/i)
         ss
-        supports = import_supports_condition
+        supports = supports_condition
         ss
         tok!(/\)/)
         supports
@@ -593,10 +570,6 @@ module Sass
         supports_negation || supports_operator || supports_interpolation
       end
 
-      def import_supports_condition
-        supports_condition || supports_declaration
-      end
-
       def supports_negation
         return unless tok(/not/i)
         ss
@@ -616,13 +589,6 @@ module Sass
         cond
       end
 
-      def supports_declaration
-          name = sass_script(:parse)
-          tok!(/:/); ss
-          value = sass_script(:parse)
-          Sass::Supports::Declaration.new(name, value)
-      end
-
       def supports_condition_in_parens
         interp = supports_interpolation
         return interp if interp
@@ -631,9 +597,11 @@ module Sass
           tok!(/\)/); ss
           cond
         else
-          decl = supports_declaration
+          name = sass_script(:parse)
+          tok!(/:/); ss
+          value = sass_script(:parse)
           tok!(/\)/); ss
-          decl
+          Sass::Supports::Declaration.new(name, value)
         end
       end
 
@@ -647,12 +615,12 @@ module Sass
       def variable
         return unless tok(/\$/)
         start_pos = source_position
-        name = ident!
+        name = tok!(IDENT)
         ss; tok!(/:/); ss
 
         expr = sass_script(:parse)
         while tok(/!/)
-          flag_name = ident!
+          flag_name = tok!(IDENT)
           if flag_name == 'default'
             guarded ||= true
           elsif flag_name == 'global'
@@ -672,15 +640,14 @@ module Sass
         # are disallowed by the CSS spec,
         # but they're included here for compatibility
         # with some proprietary MS properties
-        str {ss if tok(%r{[/,:.=]})}
+        str {ss if tok(/[\/,:.=]/)}
       end
 
       def ruleset
         start_pos = source_position
         return unless (rules = almost_any_value)
-        block(
-          node(
-            Sass::Tree::RuleNode.new(rules, range(start_pos)), start_pos), :ruleset)
+        block(node(
+          Sass::Tree::RuleNode.new(rules, range(start_pos)), start_pos), :ruleset)
       end
 
       def block(node, context)
@@ -755,9 +722,8 @@ module Sass
           selector << additional_selector
         end
 
-        block(
-          node(
-            Sass::Tree::RuleNode.new(merge(selector), range(start_pos)), start_pos), :ruleset)
+        block(node(
+          Sass::Tree::RuleNode.new(merge(selector), range(start_pos)), start_pos), :ruleset)
       end
 
       # Tries to parse a declaration, and returns the value parsed so far if it
@@ -790,12 +756,6 @@ module Sass
         mid = [str {ss}]
         return name + mid unless tok(/:/)
         mid << ':'
-
-        # If this is a CSS variable, parse it as a property no matter what.
-        if name.first.is_a?(String) && name.first.start_with?("--")
-          return css_variable_declaration(name, name_start_pos, name_end_pos)
-        end
-
         return name + mid + [':'] if tok(/:/)
         mid << str {ss}
         post_colon_whitespace = !mid.last.empty?
@@ -831,7 +791,7 @@ module Sass
         ss
         require_block = tok?(/\{/)
 
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, [value], :new),
+        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new),
                     name_start_pos, value_end_pos)
         node.name_source_range = range(name_start_pos, name_end_pos)
         node.value_source_range = range(value_start_pos, value_end_pos)
@@ -840,21 +800,13 @@ module Sass
         nested_properties! node
       end
 
-      def css_variable_declaration(name, name_start_pos, name_end_pos)
-        value_start_pos = source_position
-        value = declaration_value
-        value_end_pos = source_position
-
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new),
-                    name_start_pos, value_end_pos)
-        node.name_source_range = range(name_start_pos, name_end_pos)
-        node.value_source_range = range(value_start_pos, value_end_pos)
-        node
-      end
-
-      # This production consumes values that could be a selector, an expression,
-      # or a combination of both. It respects strings and comments and supports
-      # interpolation. It will consume up to "{", "}", ";", or "!".
+      # This production is similar to the CSS [`<any-value>`][any-value]
+      # production, but as the name implies, not quite the same. It's meant to
+      # consume values that could be a selector, an expression, or a combination
+      # of both. It respects strings and comments and supports interpolation. It
+      # will consume up to "{", "}", ";", or "!".
+      #
+      # [any-value]: http://dev.w3.org/csswg/css-variables/#typedef-any-value
       #
       # Values consumed by this production will usually be parsed more
       # thoroughly once interpolation has been resolved.
@@ -874,9 +826,6 @@ module Sass
           |
             (?!url\()
             [^"'/\#!;\{\}] # "
-          |
-            # interp_uri will handle most url() calls, but not ones that take strings
-            url\(#{W}(?=")
           |
             /(?![/*])
           |
@@ -888,60 +837,6 @@ module Sass
                 interpolation(:warn_for_color)
       end
 
-      def declaration_value(top_level: true)
-        return unless (tok = declaration_value_token(top_level))
-        value = [tok]
-        while (tok = declaration_value_token(top_level))
-          value << tok
-        end
-        merge(value)
-      end
-
-      def declaration_value_token(top_level)
-        # This comes, more or less, from the [token consumption algorithm][].
-        # However, since we don't have to worry about the token semantics, we
-        # just consume everything until we come across a token with special
-        # semantics.
-        #
-        # [token consumption algorithm]: https://drafts.csswg.org/css-syntax-3/#consume-token.
-        result = tok(%r{
-          (
-            (?!
-              url\(
-            )
-            [^()\[\]{}"'#/ \t\r\n\f#{top_level ? ";" : ""}]
-          |
-            \#(?!\{)
-          |
-            /(?!\*)
-          )+
-        }xi) || interp_string || interp_uri || interpolation || tok(COMMENT)
-        return result if result
-
-        # Fold together multiple characters of whitespace that don't include
-        # newlines. The value only cares about the tokenization, so this is safe
-        # as long as we don't delete whitespace entirely. It's important that we
-        # fold here rather than post-processing, since we aren't allowed to fold
-        # whitespace within strings and we lose that context later on.
-        if (ws = tok(S))
-          return ws.include?("\n") ? ws.gsub(/\A[^\n]*/, '') : ' '
-        end
-
-        if tok(/\(/)
-          value = declaration_value(top_level: false)
-          tok!(/\)/)
-          ['(', *value, ')']
-        elsif tok(/\[/)
-          value = declaration_value(top_level: false)
-          tok!(/\]/)
-          ['[', *value, ']']
-        elsif tok(/\{/)
-          value = declaration_value(top_level: false)
-          tok!(/\}/)
-          ['{', *value, '}']
-        end
-      end
-
       def declaration
         # This allows the "*prop: val", ":prop: val", "#prop: val", and ".prop:
         # val" hacks.
@@ -967,7 +862,7 @@ module Sass
         ss
         require_block = tok?(/\{/)
 
-        node = node(Sass::Tree::PropNode.new(name.flatten.compact, [value], :new),
+        node = node(Sass::Tree::PropNode.new(name.flatten.compact, value, :new),
                     name_start_pos, value_end_pos)
         node.name_source_range = range(name_start_pos, name_end_pos)
         node.value_source_range = range(value_start_pos, value_end_pos)
@@ -990,11 +885,8 @@ module Sass
         # 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))
-          # If val ends with escaped whitespace, leave it be.
-          str = Sass::Script::Tree::Literal.new(
-            Sass::Script::Value::String.new(
-              Sass::Util.strip_except_escapes(val)))
+        if (val = tok(STATIC_VALUE, true))
+          str = Sass::Script::Tree::Literal.new(Sass::Script::Value::String.new(val.strip))
           str.line = start_pos.line
           str.source_range = range(start_pos)
           return str
@@ -1051,7 +943,7 @@ module Sass
       def var_expr
         return unless tok(/\$/)
         line = @line
-        var = Sass::Script::Tree::Variable.new(ident!)
+        var = Sass::Script::Tree::Variable.new(tok!(IDENT))
         var.line = line
         var
       end
@@ -1089,27 +981,11 @@ module Sass
         res
       end
 
-      def ident
-        (ident = tok(IDENT)) && Sass::Util.normalize_ident_escapes(ident)
-      end
-
-      def ident!
-        Sass::Util.normalize_ident_escapes(tok!(IDENT))
-      end
-
-      def name
-        (name = tok(NAME)) && Sass::Util.normalize_ident_escapes(name)
-      end
-
-      def name!
-        Sass::Util.normalize_ident_escapes(tok!(NAME))
-      end
-
-      def interp_ident
-        val = ident || interpolation(:warn_for_color) || tok(IDENT_HYPHEN_INTERP)
+      def interp_ident(start = IDENT)
+        val = tok(start) || interpolation(:warn_for_color) || tok(IDENT_HYPHEN_INTERP, true)
         return unless val
         res = [val]
-        while (val = name || interpolation(:warn_for_color))
+        while (val = tok(NAME) || interpolation(:warn_for_color))
           res << val
         end
         res
@@ -1123,7 +999,7 @@ module Sass
       end
 
       def str
-        @strs.push String.new("")
+        @strs.push ""
         yield
         @strs.last
       ensure
@@ -1151,7 +1027,8 @@ module Sass
         node
       end
 
-      @sass_script_parser = Sass::Script::Parser
+      @sass_script_parser = Class.new(Sass::Script::Parser)
+      @sass_script_parser.send(:include, ScriptParser)
 
       class << self
         # @private
@@ -1160,7 +1037,7 @@ module Sass
 
       def sass_script(*args)
         parser = self.class.sass_script_parser.new(@scanner, @line, @offset,
-          :filename => @filename, :importer => @importer, :allow_extra_text => true)
+                                                   :filename => @filename, :importer => @importer)
         result = parser.send(*args)
         unless @strs.empty?
           # Convert to CSS manually so that comments are ignored.
@@ -1185,7 +1062,7 @@ module Sass
         :media_expr => "media expression (e.g. (min-device-width: 800px))",
         :at_root_query => "@at-root query (e.g. (without: media))",
         :at_root_directive_list => '* or identifier',
-        :declaration_value => "expression (e.g. fr, 2n+1)",
+        :pseudo_args => "expression (e.g. fr, 2n+1)",
         :interp_ident => "identifier",
         :qualified_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
@@ -1200,9 +1077,9 @@ module Sass
         :keyframes_selector => "keyframes selector (e.g. 10%)"
       }
 
-      TOK_NAMES = Hash[Sass::SCSS::RX.constants.map do |c|
+      TOK_NAMES = Sass::Util.to_hash(Sass::SCSS::RX.constants.map do |c|
         [Sass::SCSS::RX.const_get(c), c.downcase]
-      end].merge(
+      end).merge(
         IDENT => "identifier",
         /[;{}]/ => '";"',
         /\b(without|with)\b/ => '"with" or "without"'
@@ -1225,7 +1102,7 @@ module Sass
 
         unless name
           # Display basic regexps as plain old strings
-          source = rx.source.gsub(%r{\\/}, '/')
+          source = rx.source.gsub(/\\\//, '/')
           string = rx.source.gsub(/\\(.)/, '\1')
           name = source == Regexp.escape(string) ? string.inspect : rx.inspect
         end
@@ -1256,20 +1133,14 @@ module Sass
         line = @line
         offset = @offset
         expected = @expected
-
-        logger = Sass::Logger::Delayed.install!
         if catch(:_sass_parser_error) {yield; false}
           @scanner.pos = pos
           @line = line
           @offset = offset
           @expected = expected
           {:pos => pos, :line => line, :expected => @expected, :block => block}
-        else
-          logger.flush
-          nil
         end
       ensure
-        logger.uninstall! if logger
         @throw_error = old_throw_error
       end
 
@@ -1314,24 +1185,35 @@ module Sass
       # This is important because `#tok` is called all the time.
       NEWLINE = "\n"
 
-      def tok(rx)
+      def tok(rx, last_group_lookahead = false)
         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
 
-        return unless res
-
-        newline_count = res.count(NEWLINE)
-        if newline_count > 0
-          @line += newline_count
-          @offset = res[res.rindex(NEWLINE)..-1].size
-        else
-          @offset += res.size
-        end
+          newline_count = res.count(NEWLINE)
+          if newline_count > 0
+            @line += newline_count
+            @offset = res[res.rindex(NEWLINE)..-1].size
+          else
+            @offset += res.size
+          end
 
-        @expected = nil
-        if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT
-          @strs.each {|s| s << res}
+          @expected = nil
+          if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT
+            @strs.each {|s| s << res}
+          end
+          res
         end
-        res
       end
 
       # Remove a vendor prefix from `str`.