sass 3.3.0 → 3.4.25

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

@@ -17,15 +17,16 @@ module Sass::Script::Value
     # @private
     #
     # Convert a ruby integer to a rgba components
-    # @param color [Fixnum]
-    # @return [Array<Fixnum>] Array of 4 numbers representing r,g,b and alpha
+    # @param color [Integer]
+    # @return [Array<Integer>] Array of 4 numbers representing r,g,b and alpha
     def self.int_to_rgba(color)
       rgba = (0..3).map {|n| color >> (n << 3) & 0xff}.reverse
       rgba[-1] = rgba[-1] / 255.0
       rgba
     end
 
-    ALTERNATE_COLOR_NAMES = Sass::Util.map_vals({
+    ALTERNATE_COLOR_NAMES = Sass::Util.map_vals(
+      {
         'aqua'                 => 0x00FFFFFF,
         'darkgrey'             => 0xA9A9A9FF,
         'darkslategrey'        => 0x2F4F4FFF,
@@ -35,10 +36,11 @@ module Sass::Script::Value
         'lightgrey'            => 0xD3D3D3FF,
         'lightslategrey'       => 0x778899FF,
         'slategrey'            => 0x708090FF,
-    }, &method(:int_to_rgba))
+      }, &method(:int_to_rgba))
 
     # A hash from color names to `[red, green, blue]` value arrays.
-    COLOR_NAMES = Sass::Util.map_vals({
+    COLOR_NAMES = Sass::Util.map_vals(
+      {
         'aliceblue'            => 0xF0F8FFFF,
         'antiquewhite'         => 0xFAEBD7FF,
         'aquamarine'           => 0x7FFFD4FF,
@@ -151,6 +153,7 @@ module Sass::Script::Value
         'powderblue'           => 0xB0E0E6FF,
         'purple'               => 0x800080FF,
         'red'                  => 0xFF0000FF,
+        'rebeccapurple'        => 0x663399FF,
         'rosybrown'            => 0xBC8F8FFF,
         'royalblue'            => 0x4169E1FF,
         'saddlebrown'          => 0x8B4513FF,
@@ -178,7 +181,7 @@ module Sass::Script::Value
         'whitesmoke'           => 0xF5F5F5FF,
         'yellow'               => 0xFFFF00FF,
         'yellowgreen'          => 0x9ACD32FF
-     }, &method(:int_to_rgba))
+      }, &method(:int_to_rgba))
 
     # A hash from `[red, green, blue, alpha]` value arrays to color names.
     COLOR_NAMES_REVERSE = COLOR_NAMES.invert.freeze
@@ -187,35 +190,43 @@ module Sass::Script::Value
     # different ruby implementations and versions vary on the ordering of the result of invert.
     COLOR_NAMES.update(ALTERNATE_COLOR_NAMES).freeze
 
+    # The user's original representation of the color.
+    #
+    # @return [String]
+    attr_reader :representation
+
     # Constructs an RGB or HSL color object,
     # optionally with an alpha channel.
     #
-    # The RGB values must be between 0 and 255.
-    # The saturation and lightness values must be between 0 and 100.
-    # The alpha value must be between 0 and 1.
+    # RGB values are clipped within 0 and 255.
+    # Saturation and lightness values are clipped within 0 and 100.
+    # The alpha value is clipped within 0 and 1.
     #
     # @raise [Sass::SyntaxError] if any color value isn't in the specified range
     #
     # @overload initialize(attrs)
-    #   The attributes are specified as a hash.
-    #   This hash must contain either `:hue`, `:saturation`, and `:value` keys,
-    #   or `:red`, `:green`, and `:blue` keys.
-    #   It cannot contain both HSL and RGB keys.
-    #   It may also optionally contain an `:alpha` key.
+    #   The attributes are specified as a hash. This hash must contain either
+    #   `:hue`, `:saturation`, and `:lightness` keys, or `:red`, `:green`, and
+    #   `:blue` keys. It cannot contain both HSL and RGB keys. It may also
+    #   optionally contain an `:alpha` key, and a `:representation` key
+    #   indicating the original representation of the color that the user wrote
+    #   in their stylesheet.
     #
     #   @param attrs [{Symbol => Numeric}] A hash of color attributes to values
     #   @raise [ArgumentError] if not enough attributes are specified,
     #     or both RGB and HSL attributes are specified
     #
-    # @overload initialize(rgba)
+    # @overload initialize(rgba, [representation])
     #   The attributes are specified as an array.
     #   This overload only supports RGB or RGBA colors.
     #
     #   @param rgba [Array<Numeric>] A three- or four-element array
     #     of the red, green, blue, and optionally alpha values (respectively)
     #     of the color
+    #   @param representation [String] The original representation of the color
+    #     that the user wrote in their stylesheet.
     #   @raise [ArgumentError] if not enough attributes are specified
-    def initialize(attrs, allow_both_rgb_and_hsl = false)
+    def initialize(attrs, representation = nil, allow_both_rgb_and_hsl = false)
       super(nil)
 
       if attrs.is_a?(Array)
@@ -223,11 +234,12 @@ module Sass::Script::Value
           raise ArgumentError.new("Color.new(array) expects a three- or four-element array")
         end
 
-        red, green, blue = attrs[0...3].map {|c| c.to_i}
+        red, green, blue = attrs[0...3].map {|c| Sass::Util.round(c)}
         @attrs = {:red => red, :green => green, :blue => blue}
         @attrs[:alpha] = attrs[3] ? attrs[3].to_f : 1
+        @representation = representation
       else
-        attrs = attrs.reject {|k, v| v.nil?}
+        attrs = attrs.reject {|_k, v| v.nil?}
         hsl = [:hue, :saturation, :lightness] & attrs.keys
         rgb = [:red, :green, :blue] & attrs.keys
         if !allow_both_rgb_and_hsl && !hsl.empty? && !rgb.empty?
@@ -243,21 +255,20 @@ module Sass::Script::Value
         @attrs = attrs
         @attrs[:hue] %= 360 if @attrs[:hue]
         @attrs[:alpha] ||= 1
+        @representation = @attrs.delete(:representation)
       end
 
       [:red, :green, :blue].each do |k|
         next if @attrs[k].nil?
-        @attrs[k] = @attrs[k].to_i
-        Sass::Util.check_range("#{k.to_s.capitalize} value", 0..255, @attrs[k])
+        @attrs[k] = Sass::Util.restrict(Sass::Util.round(@attrs[k]), 0..255)
       end
 
       [:saturation, :lightness].each do |k|
         next if @attrs[k].nil?
-        value = Number.new(@attrs[k], ['%']) # Get correct unit for error messages
-        @attrs[k] = Sass::Util.check_range("#{k.to_s.capitalize}", 0..100, value, '%')
+        @attrs[k] = Sass::Util.restrict(@attrs[k], 0..100)
       end
 
-      @attrs[:alpha] = Sass::Util.check_range("Alpha channel", 0..1, @attrs[:alpha])
+      @attrs[:alpha] = Sass::Util.restrict(@attrs[:alpha], 0..1)
     end
 
     # Create a new color from a valid CSS hex string.
@@ -273,14 +284,16 @@ module Sass::Script::Value
       red   = $1.ljust(2, $1).to_i(16)
       green = $2.ljust(2, $2).to_i(16)
       blue  = $3.ljust(2, $3).to_i(16)
-      attrs = {:red => red, :green => green, :blue => blue}
+
+      hex_string = "##{hex_string}" unless hex_string[0] == ?#
+      attrs = {:red => red, :green => green, :blue => blue, :representation => hex_string}
       attrs[:alpha] = alpha if alpha
       new(attrs)
     end
 
     # The red component of the color.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def red
       hsl_to_rgb!
       @attrs[:red]
@@ -288,7 +301,7 @@ module Sass::Script::Value
 
     # The green component of the color.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def green
       hsl_to_rgb!
       @attrs[:green]
@@ -296,7 +309,7 @@ module Sass::Script::Value
 
     # The blue component of the color.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def blue
       hsl_to_rgb!
       @attrs[:blue]
@@ -329,7 +342,7 @@ module Sass::Script::Value
     # The alpha channel (opacity) of the color.
     # This is 1 unless otherwise defined.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def alpha
       @attrs[:alpha].to_f
     end
@@ -344,7 +357,7 @@ module Sass::Script::Value
 
     # Returns the red, green, and blue components of the color.
     #
-    # @return [Array<Fixnum>] A frozen three-element array of the red, green, and blue
+    # @return [Array<Integer>] A frozen three-element array of the red, green, and blue
     #   values (respectively) of the color
     def rgb
       [red, green, blue].freeze
@@ -352,7 +365,7 @@ module Sass::Script::Value
 
     # Returns the red, green, blue, and alpha components of the color.
     #
-    # @return [Array<Fixnum>] A frozen four-element array of the red, green,
+    # @return [Array<Integer>] A frozen four-element array of the red, green,
     #   blue, and alpha values (respectively) of the color
     def rgba
       [red, green, blue, alpha].freeze
@@ -360,7 +373,7 @@ module Sass::Script::Value
 
     # Returns the hue, saturation, and lightness components of the color.
     #
-    # @return [Array<Fixnum>] A frozen three-element array of the
+    # @return [Array<Integer>] A frozen three-element array of the
     #   hue, saturation, and lightness values (respectively) of the color
     def hsl
       [hue, saturation, lightness].freeze
@@ -368,10 +381,10 @@ module Sass::Script::Value
 
     # Returns the hue, saturation, lightness, and alpha components of the color.
     #
-    # @return [Array<Fixnum>] A frozen four-element array of the hue,
+    # @return [Array<Integer>] A frozen four-element array of the hue,
     #   saturation, lightness, and alpha values (respectively) of the color
     def hsla
-      [hue, saturation, lightness].freeze
+      [hue, saturation, lightness, alpha].freeze
     end
 
     # The SassScript `==` operation.
@@ -410,7 +423,7 @@ module Sass::Script::Value
     # @return [Color] The new Color object
     # @raise [ArgumentError] if both RGB and HSL keys are specified
     def with(attrs)
-      attrs = attrs.reject {|k, v| v.nil?}
+      attrs = attrs.reject {|_k, v| v.nil?}
       hsl = !([:hue, :saturation, :lightness] & attrs.keys).empty?
       rgb = !([:red, :green, :blue] & attrs.keys).empty?
       if hsl && rgb
@@ -428,7 +441,7 @@ module Sass::Script::Value
       end
       attrs[:alpha] ||= alpha
 
-      Color.new(attrs, :allow_both_rgb_and_hsl)
+      Color.new(attrs, nil, :allow_both_rgb_and_hsl)
     end
 
     # The SassScript `+` operation.
@@ -549,7 +562,8 @@ module Sass::Script::Value
     # @return [String] The string representation
     def to_s(opts = {})
       return smallest if options[:style] == :compressed
-      return COLOR_NAMES_REVERSE[rgba] if COLOR_NAMES_REVERSE[rgba]
+      return representation if representation
+      return name if name
       alpha? ? rgba_str : hex_str
     end
     alias_method :to_sass, :to_s
@@ -561,13 +575,19 @@ module Sass::Script::Value
       alpha? ? rgba_str : hex_str
     end
 
+    # Returns the color's name, if it has one.
+    #
+    # @return [String, nil]
+    def name
+      COLOR_NAMES_REVERSE[rgba]
+    end
+
     private
 
     def smallest
       small_explicit_str = alpha? ? rgba_str : hex_str.gsub(/^#(.)\1(.)\2(.)\3$/, '#\1\2\3')
-      return small_explicit_str unless (color = COLOR_NAMES_REVERSE[rgba]) &&
-        color.size <= small_explicit_str.size
-      color
+      [representation, COLOR_NAMES_REVERSE[rgba], small_explicit_str].
+          compact.min_by {|str| str.size}
     end
 
     def rgba_str
@@ -580,16 +600,32 @@ module Sass::Script::Value
       "##{red}#{green}#{blue}"
     end
 
+    def operation_name(operation)
+      case operation
+      when :+
+        "add"
+      when :-
+        "subtract"
+      when :*
+        "multiply"
+      when :/
+        "divide"
+      when :%
+        "modulo"
+      end
+    end
+
     def piecewise(other, operation)
       other_num = other.is_a? Number
       if other_num && !other.unitless?
         raise Sass::SyntaxError.new(
-          "Cannot add a number with units (#{other}) to a color (#{self}).")
+          "Cannot #{operation_name(operation)} a number with units (#{other}) to a color (#{self})."
+        )
       end
 
       result = []
       (0...3).each do |i|
-        res = rgb[i].send(operation, other_num ? other.value : other.rgb[i])
+        res = rgb[i].to_f.send(operation, other_num ? other.value : other.rgb[i])
         result[i] = [[res, 255].min, 0].max
       end
 
@@ -614,7 +650,7 @@ module Sass::Script::Value
         hue_to_rgb(m1, m2, h + 1.0 / 3),
         hue_to_rgb(m1, m2, h),
         hue_to_rgb(m1, m2, h - 1.0 / 3)
-      ].map {|c| (c * 0xff).round}
+      ].map {|c| Sass::Util.round(c * 0xff)}
     end
 
     def hue_to_rgb(m1, m2, h)

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

@@ -1,6 +1,8 @@
 module Sass::Script::Value
   # Provides helper functions for creating sass values from within ruby methods.
   # @since `3.3.0`
+  # @comment
+  #   rubocop:disable ModuleLength
   module Helpers
     # Construct a Sass Boolean.
     #
@@ -121,8 +123,123 @@ 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.tr('_', '-')}: #{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.tr('_', '-')}: #{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.tr('_', '-')}: #{err}" if name
+      raise ArgumentError.new(err)
+    end
+
+    # Returns true when the literal is a string containing a calc()
+    #
+    # @param literal [Sass::Script::Value::Base] The value to check
+    # @return boolean
+    def calc?(literal)
+      literal.is_a?(Sass::Script::Value::String) && literal.value =~ /calc\(/
+    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.tr('_', '-')}: #{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}|%*/
 
@@ -135,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(/ *\/ */)
+      num_over_denominator = unit_string.split(%r{ */ *})
       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 =~ /\// && units.size == 0
+        if unit_string =~ %r{/} && 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

@@ -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/map.rb

@@ -56,7 +56,7 @@ module Sass::Script::Value
       return "()" if value.empty?
 
       to_sass = lambda do |value|
-        if value.is_a?(Map) || (value.is_a?(List) && value.separator == :comma)
+        if value.is_a?(List) && value.separator == :comma
           "(#{value.to_sass(opts)})"
         else
           value.to_sass(opts)

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 = {})
       ''