sass 3.3.0 → 3.4.0

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

@@ -121,8 +121,115 @@ module Sass::Script::Value
     end
     alias_method :identifier, :unquoted_string
 
+    # Parses a user-provided selector.
+    #
+    # @param value [Sass::Script::Value::String, Sass::Script::Value::List]
+    #   The selector to parse. This can be either a string, a list of
+    #   strings, or a list of lists of strings as returned by `&`.
+    # @param name [Symbol, nil]
+    #   If provided, the name of the selector argument. This is used
+    #   for error reporting.
+    # @param allow_parent_ref [Boolean]
+    #   Whether the parsed selector should allow parent references.
+    # @return [Sass::Selector::CommaSequence] The parsed selector.
+    # @throw [ArgumentError] if the parse failed for any reason.
+    def parse_selector(value, name = nil, allow_parent_ref = false)
+      str = normalize_selector(value, name)
+      begin
+        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.gsub('_', '-')}: #{err}" if name
+        raise ArgumentError.new(err)
+      end
+    end
+
+    # Parses a user-provided complex selector.
+    #
+    # A complex selector can contain combinators but cannot contain commas.
+    #
+    # @param value [Sass::Script::Value::String, Sass::Script::Value::List]
+    #   The selector to parse. This can be either a string or a list of
+    #   strings.
+    # @param name [Symbol, nil]
+    #   If provided, the name of the selector argument. This is used
+    #   for error reporting.
+    # @param allow_parent_ref [Boolean]
+    #   Whether the parsed selector should allow parent references.
+    # @return [Sass::Selector::Sequence] The parsed selector.
+    # @throw [ArgumentError] if the parse failed for any reason.
+    def parse_complex_selector(value, name = nil, allow_parent_ref = false)
+      selector = parse_selector(value, name, allow_parent_ref)
+      return seq if selector.members.length == 1
+
+      err = "#{value.inspect} is not a complex selector"
+      err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
+      raise ArgumentError.new(err)
+    end
+
+    # Parses a user-provided compound selector.
+    #
+    # A compound selector cannot contain combinators or commas.
+    #
+    # @param value [Sass::Script::Value::String] The selector to parse.
+    # @param name [Symbol, nil]
+    #   If provided, the name of the selector argument. This is used
+    #   for error reporting.
+    # @param allow_parent_ref [Boolean]
+    #   Whether the parsed selector should allow parent references.
+    # @return [Sass::Selector::SimpleSequence] The parsed selector.
+    # @throw [ArgumentError] if the parse failed for any reason.
+    def parse_compound_selector(value, name = nil, allow_parent_ref = false)
+      assert_type value, :String, name
+      selector = parse_selector(value, name, allow_parent_ref)
+      seq = selector.members.first
+      sseq = seq.members.first
+      if selector.members.length == 1 && seq.members.length == 1 &&
+          sseq.is_a?(Sass::Selector::SimpleSequence)
+        return sseq
+      end
+
+      err = "#{value.inspect} is not a compound selector"
+      err = "$#{name.to_s.gsub('_', '-')}: #{err}" if name
+      raise ArgumentError.new(err)
+    end
+
     private
 
+    # Converts a user-provided selector into string form or throws an
+    # ArgumentError if it's in an invalid format.
+    def normalize_selector(value, name)
+      if (str = selector_to_str(value))
+        return str
+      end
+
+      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.gsub('_', '-')}: #{err}" if name
+      raise ArgumentError.new(err)
+    end
+
+    # Converts a user-provided selector into string form or returns
+    # `nil` if it's in an invalid format.
+    def selector_to_str(value)
+      return value.value if value.is_a?(Sass::Script::String)
+      return unless value.is_a?(Sass::Script::List)
+
+      if value.separator == :comma
+        return value.to_a.map do |complex|
+          next complex.value if complex.is_a?(Sass::Script::String)
+          return unless complex.is_a?(Sass::Script::List) && complex.separator == :space
+          return unless (str = selector_to_str(complex))
+          str
+        end.join(', ')
+      end
+
+      value.to_a.map do |compound|
+        return unless compound.is_a?(Sass::Script::String)
+        compound.value
+      end.join(' ')
+    end
+
     # @private
     VALID_UNIT = /#{Sass::SCSS::RX::NMSTART}#{Sass::SCSS::RX::NMCHAR}|%*/
 

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

@@ -65,24 +65,9 @@ module Sass::Script::Value
     # @see Value#to_h
     def to_h
       return Sass::Util.ordered_hash if value.empty?
-      return @map ||= Sass::Util.to_hash(value.map {|e| e.to_a}) if is_pseudo_map?
       super
     end
 
-    # Returns whether a warning still needs to be printed for this list being used as a map.
-    #
-    # @return [Boolean]
-    def needs_map_warning?
-      !@value.empty? && !@map
-    end
-
-    # Returns whether this is a list of pairs that can be used as a map.
-    #
-    # @return [Boolean]
-    def is_pseudo_map?
-      @is_pseudo_map ||= value.all? {|e| e.is_a?(Sass::Script::Value::List) && e.to_a.length == 2}
-    end
-
     # @see Value#inspect
     def inspect
       "(#{value.map {|e| e.inspect}.join(sep_str(nil))})"

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

@@ -25,11 +25,6 @@ module Sass::Script::Value
       true
     end
 
-    def neq(other)
-      return other.neq(self) if other.is_a?(DeprecatedFalse)
-      super
-    end
-
     # @return [String] '' (An empty string)
     def to_s(opts = {})
       ''

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

@@ -271,6 +271,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
 
@@ -445,25 +447,71 @@ module Sass::Script::Value
       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),
+        '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(1, 2.54),
+        'dppx' => Rational(1, 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,3 +1,4 @@
+# -*- coding: utf-8 -*-
 module Sass::Script::Value
   # A SassScript object representing a CSS string *or* a CSS identifier.
   class String < Base
@@ -13,6 +14,52 @@ 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
+
+    def self.quote(contents, quote = nil)
+      # 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("\\", "\\\\\\\\")
+
+      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}
@@ -24,26 +71,27 @@ module Sass::Script::Value
 
     # @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
+      Sass::Script::Value::String.quote(value, opts[:quote])
     end
 
     # @see Value#to_sass
     def to_sass(opts = {})
       to_s
     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/scss/css_parser.rb

@@ -11,7 +11,7 @@ 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_child(context)
@@ -25,10 +25,16 @@ module Sass
         end
       end
 
-      def nested_properties!(node, space)
+      def nested_properties!(node)
         expected('expression (e.g. 1px, bold)')
       end
 
+      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
+
       @sass_script_parser = Class.new(Sass::Script::CssParser)
       @sass_script_parser.send(:include, ScriptParser)
     end