sass 3.3.0 → 3.4.25

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

@@ -34,25 +34,35 @@ module Sass::Script::Value
     attr_accessor :original
 
     def self.precision
-      @precision ||= 5
+      Thread.current[:sass_numeric_precision] || Thread.main[:sass_numeric_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)
-      @precision = digits.round
-      @precision_factor = 10.0**@precision
+      Thread.current[:sass_numeric_precision] = digits.round
+      Thread.current[:sass_numeric_precision_factor] = nil
+      Thread.current[:sass_numeric_epsilon] = nil
     end
 
     # the precision factor used in numeric output
     # it is derived from the `precision` method.
     def self.precision_factor
-      @precision_factor ||= 10.0**precision
+      Thread.current[:sass_numeric_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)
     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}
@@ -63,6 +73,7 @@ module Sass::Script::Value
       super(value)
       @numerator_units = numerator_units
       @denominator_units = denominator_units
+      @options = nil
       normalize!
     end
 
@@ -200,7 +211,7 @@ module Sass::Script::Value
       rescue Sass::UnitConversionError
         return Bool::FALSE
       end
-      Bool.new(this.value == other.value)
+      Bool.new(basically_equal?(this.value, other.value))
     end
 
     def hash
@@ -211,7 +222,7 @@ module Sass::Script::Value
     # Hash-equality must be transitive, so it just compares the exact value,
     # numerator units, and denominator units.
     def eql?(other)
-      value == other.value && numerator_units == other.numerator_units &&
+      basically_equal?(value, other.value) && numerator_units == other.numerator_units &&
         denominator_units == other.denominator_units
     end
 
@@ -271,6 +282,8 @@ module Sass::Script::Value
     #
     # @return [String] The representation
     def inspect(opts = {})
+      return original if original
+
       value = self.class.round(self.value)
       str = value.to_s
 
@@ -279,20 +292,30 @@ 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 [Fixnum] The integer value of the number
+    # @return [Integer] The integer value of the number
     # @raise [Sass::SyntaxError] if the number isn't an integer
     def to_i
       super unless int?
-      value
+      value.to_i
     end
 
     # @return [Boolean] Whether or not this number is an integer.
     def int?
-      value % 1 == 0.0
+      basically_equal?(value % 1, 0.0)
     end
 
     # @return [Boolean] Whether or not this number has no units.
@@ -373,12 +396,24 @@ module Sass::Script::Value
 
     private
 
+    # @private
+    # @see Sass::Script::Number.basically_equal?
+    def basically_equal?(num1, num2)
+      self.class.basically_equal?(num1, num2)
+    end
+
+    # Checks whether two numbers are within an epsilon of each other.
+    # @return [Boolean]
+    def self.basically_equal?(num1, num2)
+      (num1 - num2).abs < epsilon
+    end
+
     # @private
     def self.round(num)
       if num.is_a?(Float) && (num.infinite? || num.nan?)
         num
-      elsif num % 1 == 0.0
-        num.to_i
+      elsif basically_equal?(num % 1, 0.0)
+        num.round
       else
         ((num * precision_factor).round / precision_factor).to_f
       end
@@ -437,33 +472,79 @@ module Sass::Script::Value
         sans_common_units(@numerator_units, @denominator_units)
 
       @denominator_units.each_with_index do |d, i|
-        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
+        next unless 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
 
-    # A hash of unit names to their index in the conversion table
-    CONVERTABLE_UNITS = %w(in cm pc mm pt px).inject({}) {|m, v| m[v] = m.size; m}
-
-    #                    in   cm    pc          mm          pt          px
-    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
+    # This is the source data for all the unit logic. It's pre-processed to make
+    # it efficient to figure out whether a set of units is mutually compatible
+    # and what the conversion ratio is between two units.
+    #
+    # These come from http://www.w3.org/TR/2012/WD-css3-values-20120308/.
+    relative_sizes = [
+      {
+        'in' => Rational(1),
+        'cm' => Rational(1, 2.54),
+        'pc' => Rational(1, 6),
+        'mm' => Rational(1, 25.4),
+        'q' => Rational(1, 101.6),
+        'pt' => Rational(1, 72),
+        'px' => Rational(1, 96)
+      },
+      {
+        'deg'  => Rational(1, 360),
+        'grad' => Rational(1, 400),
+        'rad'  => Rational(1, 2 * Math::PI),
+        'turn' => Rational(1)
+      },
+      {
+        's'  => Rational(1),
+        'ms' => Rational(1, 1000)
+      },
+      {
+        'Hz'  => Rational(1),
+        'kHz' => Rational(1000)
+      },
+      {
+        'dpi'  => Rational(1),
+        'dpcm' => Rational(254, 100),
+        'dppx' => Rational(96)
+      }
+    ]
+
+    # A hash from each known unit to the set of units that it's mutually
+    # convertible with.
+    MUTUALLY_CONVERTIBLE = {}
+    relative_sizes.map do |values|
+      set = values.keys.to_set
+      values.keys.each {|name| MUTUALLY_CONVERTIBLE[name] = set}
+    end
+
+    # A two-dimensional hash from two units to the conversion ratio between
+    # them. Multiply `X` by `CONVERSION_TABLE[X][Y]` to convert it to `Y`.
+    CONVERSION_TABLE = {}
+    relative_sizes.each do |values|
+      values.each do |(name1, value1)|
+        CONVERSION_TABLE[name1] ||= {}
+        values.each do |(name2, value2)|
+          value = value1 / value2
+          CONVERSION_TABLE[name1][name2] = value.denominator == 1 ? value.to_i : value.to_f
+        end
+      end
+    end
 
     def conversion_factor(from_unit, to_unit)
-      res = CONVERSION_TABLE[CONVERTABLE_UNITS[from_unit]][CONVERTABLE_UNITS[to_unit]]
-      return 1.0 / conversion_factor(to_unit, from_unit) if res.nil?
-      res
+      CONVERSION_TABLE[from_unit][to_unit]
     end
 
     def convertable?(units)
-      Array(units).all? {|u| CONVERTABLE_UNITS.include?(u)}
+      units = Array(units).to_set
+      return true if units.empty?
+      return false unless (mutually_convertible = MUTUALLY_CONVERTIBLE[units.first])
+      units.subset?(mutually_convertible)
     end
 
     def sans_common_units(units1, units2)

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

@@ -1,6 +1,9 @@
+# -*- coding: utf-8 -*-
 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]
@@ -13,37 +16,123 @@ module Sass::Script::Value
     # @return [Symbol] `:string` or `:identifier`
     attr_reader :type
 
+    def self.value(contents)
+      contents.gsub("\\\n", "").gsub(/\\(?:([0-9a-fA-F]{1,6})\s?|(.))/) do
+        next $2 if $2
+        # Handle unicode escapes as per CSS Syntax Level 3 section 4.3.8.
+        code_point = $1.to_i(16)
+        if code_point == 0 || code_point > 0x10FFFF ||
+            (code_point >= 0xD800 && code_point <= 0xDFFF)
+          '�'
+        else
+          [code_point].pack("U")
+        end
+      end
+    end
+
+    # Returns the quoted string representation of `contents`.
+    #
+    # @options opts :quote [String]
+    #   The preferred quote style for quoted strings. If `:none`, strings are
+    #   always emitted unquoted. If `nil`, quoting is determined automatically.
+    # @options opts :sass [String]
+    #   Whether to quote strings for Sass source, as opposed to CSS. Defaults to `false`.
+    def self.quote(contents, opts = {})
+      quote = opts[:quote]
+
+      # Short-circuit if there are no characters that need quoting.
+      unless contents =~ /[\n\\"']|\#\{/
+        quote ||= '"'
+        return "#{quote}#{contents}#{quote}"
+      end
+
+      if quote.nil?
+        if contents.include?('"')
+          if contents.include?("'")
+            quote = '"'
+          else
+            quote = "'"
+          end
+        else
+          quote = '"'
+        end
+      end
+
+      # Replace single backslashes with multiples.
+      contents = contents.gsub("\\", "\\\\\\\\")
+
+      # Escape interpolation.
+      contents = contents.gsub('#{', "\\\#{") if opts[:sass]
+
+      if quote == '"'
+        contents = contents.gsub('"', "\\\"")
+      else
+        contents = contents.gsub("'", "\\'")
+      end
+
+      contents = contents.gsub(/\n(?![a-fA-F0-9\s])/, "\\a").gsub("\n", "\\a ")
+      "#{quote}#{contents}#{quote}"
+    end
+
     # Creates a new string.
     #
     # @param value [String] See \{#value}
     # @param type [Symbol] See \{#type}
-    def initialize(value, type = :identifier)
+    # @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)
       super(value)
       @type = type
+      @deprecated_interp_equivalent = deprecated_interp_equivalent
     end
 
     # @see Value#plus
     def plus(other)
-      other_str = other.is_a?(Sass::Script::Value::String) ? other.value : other.to_s
-      Sass::Script::Value::String.new(value + other_str, type)
+      other_value = if other.is_a?(Sass::Script::Value::String)
+                      other.value
+                    else
+                      other.to_s(:quote => :none)
+                    end
+      Sass::Script::Value::String.new(value + other_value, type)
     end
 
     # @see Value#to_s
     def to_s(opts = {})
-      if @type == :identifier
-        return @value.gsub(/\n\s*/, " ")
-      end
-
-      return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}
-      return "'#{value.gsub("'", "\\'")}'" if opts[:quote] == %q{'}
-      return "\"#{value}\"" unless value.include?('"')
-      return "'#{value}'" unless value.include?("'")
-      "\"#{value.gsub('"', "\\\"")}\"" # '
+      return @value.gsub(/\n\s*/, ' ') if opts[:quote] == :none || @type == :identifier
+      String.quote(value, opts)
     end
 
     # @see Value#to_sass
     def to_sass(opts = {})
-      to_s
+      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
   end
 end

data/lib/sass/script/value.rb

@@ -5,7 +5,6 @@ require 'sass/script/value/string'
 require 'sass/script/value/number'
 require 'sass/script/value/color'
 require 'sass/script/value/bool'
-require 'sass/script/value/deprecated_false'
 require 'sass/script/value/null'
 require 'sass/script/value/list'
 require 'sass/script/value/arg_list'

data/lib/sass/script.rb

@@ -16,12 +16,12 @@ module Sass
     # Parses a string of SassScript
     #
     # @param value [String] The SassScript
-    # @param line [Fixnum] The number of the line on which the SassScript appeared.
+    # @param line [Integer] The number of the line on which the SassScript appeared.
     #   Used for error reporting
-    # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
+    # @param offset [Integer] The number of characters in on `line` that the SassScript started.
     #   Used for error reporting
     # @param options [{Symbol => Object}] An options hash;
-    #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+    #   see {file:SASS_REFERENCE.md#Options the Sass options documentation}
     # @return [Script::Tree::Node] The root node of the parse tree
     def self.parse(value, line, offset, options = {})
       Parser.parse(value, line, offset, options)

data/lib/sass/scss/css_parser.rb

@@ -11,9 +11,16 @@ module Sass
 
       def placeholder_selector; nil; end
       def parent_selector; nil; end
-      def interpolation; nil; end
+      def interpolation(warn_for_color = false); nil; end
       def use_css_import?; true; end
 
+      def block_contents(node, context)
+        if node.is_a?(Sass::Tree::DirectiveNode) && node.normalized_name == '@keyframes'
+          context = :keyframes
+        end
+        super(node, context)
+      end
+
       def block_child(context)
         case context
         when :ruleset
@@ -22,15 +29,28 @@ module Sass
           directive || ruleset
         when :directive
           directive || declaration_or_ruleset
+        when :keyframes
+          keyframes_ruleset
         end
       end
 
-      def nested_properties!(node, space)
+      def nested_properties!(node)
         expected('expression (e.g. 1px, bold)')
       end
 
-      @sass_script_parser = Class.new(Sass::Script::CssParser)
-      @sass_script_parser.send(:include, ScriptParser)
+      def ruleset
+        start_pos = source_position
+        return unless (selector = selector_comma_sequence)
+        block(node(Sass::Tree::RuleNode.new(selector, range(start_pos)), start_pos), :ruleset)
+      end
+
+      def keyframes_ruleset
+        start_pos = source_position
+        return unless (selector = keyframes_selector)
+        block(node(Sass::Tree::KeyframeRuleNode.new(selector.strip), start_pos), :ruleset)
+      end
+
+      @sass_script_parser = Sass::Script::CssParser
     end
   end
 end