sass 3.3.0 → 3.4.0

data/lib/sass/script/lexer.rb

@@ -82,6 +82,8 @@ module Sass
       # with identifier names.
       IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
 
+      PARSEABLE_NUMBER = /(?:(\d*\.\d+)|(\d+))(?:[eE]([+-]?\d+))?(#{UNIT})?/
+
       # A hash of regular expressions that are used for tokenizing.
       REGULAR_EXPRESSIONS = {
         :whitespace => /\s+/,
@@ -89,9 +91,11 @@ module Sass
         :single_line_comment => SINGLE_LINE_COMMENT,
         :variable => /(\$)(#{IDENT})/,
         :ident => /(#{IDENT})(\()?/,
-        :number => /(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
-        :unary_minus_number => /-(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
+        :number => PARSEABLE_NUMBER,
+        :unary_minus_number => /-#{PARSEABLE_NUMBER}/,
         :color => HEXCOLOR,
+        :id => /##{IDENT}/,
+        :selector => /&/,
         :ident_op => /(#{Regexp.union(*IDENT_OP_NAMES.map do |s|
           Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")
         end)})/,
@@ -102,7 +106,7 @@ module Sass
         private
 
         def string_re(open, close)
-          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/
+          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/m
         end
       end
 
@@ -246,13 +250,19 @@ module Sass
       end
 
       def token
-        if after_interpolation? && (interp_type = @interpolation_stack.pop)
-          return string(interp_type, true)
+        if after_interpolation? && (interp = @interpolation_stack.pop)
+          interp_type, interp_value = interp
+          if interp_type == :special_fun
+            return special_fun_body(interp_value)
+          else
+            raise "[BUG]: Unknown interp_type #{interp_type}" unless interp_type == :string
+            return string(interp_value, true)
+          end
         end
 
-        variable || string(:double, false) || string(:single, false) || number || color ||
-          string(:uri, false) || raw(UNICODERANGE) || special_fun || special_val || ident_op ||
-          ident || op
+        variable || string(:double, false) || string(:single, false) || number || id || color ||
+          selector || string(:uri, false) || raw(UNICODERANGE) || special_fun || special_val ||
+          ident_op || ident || op
       end
 
       def variable
@@ -271,18 +281,28 @@ module Sass
       end
 
       def string(re, open)
+        line, offset = @line, @offset
         return unless scan(STRING_REGULAR_EXPRESSIONS[re][open])
+        if @scanner[0] =~ /([^\\]|^)\n/
+          filename = @options[:filename]
+          Sass::Util.sass_warn <<MESSAGE
+DEPRECATION WARNING on line #{line}, column #{offset}#{" of #{filename}" if filename}:
+Unescaped multiline strings are deprecated and will be removed in a future version of Sass.
+To include a newline in a string, use "\\a" or "\\a " as in CSS.
+MESSAGE
+        end
+
         if @scanner[2] == '#{' # '
           @scanner.pos -= 2 # Don't actually consume the #{
           @offset -= 2
-          @interpolation_stack << re
+          @interpolation_stack << [:string, re]
         end
         str =
           if re == :uri
             url = "#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}"
             Script::Value::String.new(url)
           else
-            Script::Value::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
+            Script::Value::String.new(Sass::Script::Value::String.value(@scanner[1]), :string)
           end
         [:string, str]
       end
@@ -296,10 +316,12 @@ module Sass
         # minus logic in the parser instead.
         if @scanner.peek(1) == '-'
           return if @scanner.pos == 0
-          @scanner.pos -= 1
-          # Don't use @scanner.scan so we don't mess up the match data.
-          unary_minus_allowed = @scanner.peek(1) =~ /\s/
-          @scanner.pos += 1
+          unary_minus_allowed =
+            case @scanner.string[@scanner.pos - 1, 1]
+            when /\s/; true
+            when '/'; @scanner.pos != 1 && @scanner.string[@scanner.pos - 2, 1] == '*'
+            else; false
+            end
 
           return unless unary_minus_allowed
           return unless scan(REGULAR_EXPRESSIONS[:unary_minus_number])
@@ -310,33 +332,76 @@ module Sass
         end
 
         value = (@scanner[1] ? @scanner[1].to_f : @scanner[2].to_i) * (minus ? -1 : 1)
-        script_number = Script::Value::Number.new(value, Array(@scanner[3]))
+        value *= 10**@scanner[3].to_i if @scanner[3]
+        script_number = Script::Value::Number.new(value, Array(@scanner[4]))
         [:number, script_number]
       end
 
+      def id
+        # Colors and ids are tough to tell apart, because they overlap but
+        # neither is a superset of the other. "#xyz" is an id but not a color,
+        # "#000" is a color but not an id, "#abc" is both, and "#0" is neither.
+        # We need to handle all these cases correctly.
+        #
+        # To do so, we first try to parse something as an id. If this works and
+        # the id is also a valid color, we return the color. Otherwise, we
+        # return the id. If it didn't parse as an id, we then try to parse it as
+        # a color. If *this* works, we return the color, and if it doesn't we
+        # give up and throw an error.
+        #
+        # IDs in properties are used in the Basic User Interface Module
+        # (http://www.w3.org/TR/css3-ui/).
+        return unless scan(REGULAR_EXPRESSIONS[:id])
+        if @scanner[0] =~ /^\#[0-9a-fA-F]+$/ && (@scanner[0].length == 4 || @scanner[0].length == 7)
+          return [:color, Script::Value::Color.from_hex(@scanner[0])]
+        end
+        [:ident, @scanner[0]]
+      end
+
       def color
-        s = scan(REGULAR_EXPRESSIONS[:color])
-        return unless s
-        raise Sass::SyntaxError.new(<<MESSAGE.rstrip) unless s.size == 4 || s.size == 7
-Colors must have either three or six digits: '#{s}'
-MESSAGE
-        script_color = Script::Value::Color.from_hex(s)
+        return unless @scanner.match?(REGULAR_EXPRESSIONS[:color])
+        return unless @scanner[0].length == 4 || @scanner[0].length == 7
+        script_color = Script::Value::Color.from_hex(scan(REGULAR_EXPRESSIONS[:color]))
         [:color, script_color]
       end
 
+      def selector
+        start_pos = source_position
+        return unless scan(REGULAR_EXPRESSIONS[:selector])
+        script_selector = Script::Tree::Selector.new
+        script_selector.source_range = range(start_pos)
+        [:selector, script_selector]
+      end
+
       def special_fun
-        str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
-        return unless str1
-        str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
-        c = str2.count("\n")
-        old_line = @line
-        old_offset = @offset
-        @line += c
-        @offset = c == 0 ? @offset + str2.size : str2[/\n([^\n]*)/, 1].size + 1
-        [:special_fun,
-         Sass::Util.merge_adjacent_strings(
-            [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
-         str1.size + str2.size]
+        prefix = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
+        return unless prefix
+        special_fun_body(1, prefix)
+      end
+
+      def special_fun_body(parens, prefix = nil)
+        str = prefix || ''
+        while (scanned = scan(/.*?([()]|\#\{)/m))
+          str << scanned
+          if scanned[-1] == ?(
+            parens += 1
+            next
+          elsif scanned[-1] == ?)
+            parens -= 1
+            next unless parens == 0
+          else
+            raise "[BUG] Unreachable" unless @scanner[1] == '#{' # '
+            str.slice!(-2..-1)
+            @scanner.pos -= 2 # Don't actually consume the #{
+            @offset -= 2
+            @interpolation_stack << [:special_fun, parens]
+          end
+
+          return [:special_fun, Sass::Script::Value::String.new(str)]
+        end
+
+        scan(/.*/)
+        expected!('")"')
       end
 
       def special_val
@@ -368,7 +433,7 @@ MESSAGE
         return unless str
         c = str.count("\n")
         @line += c
-        @offset = (c == 0 ? @offset + str.size : str.size - str.rindex("\n") + 1)
+        @offset = (c == 0 ? @offset + str.size : str.size - str.rindex("\n"))
         str
       end
 

data/lib/sass/script/parser.rb

@@ -36,13 +36,19 @@ module Sass
       # which signals the end of an interpolated segment,
       # it returns rather than throwing an error.
       #
+      # @param warn_for_color [Boolean] Whether raw color values passed to
+      #   interoplation should cause a warning.
       # @return [Script::Tree::Node] The root node of the parse tree
       # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
-      def parse_interpolated
+      def parse_interpolated(warn_for_color = false)
+        # Start two characters back to compensate for #{
+        start_pos = Sass::Source::Position.new(line, offset - 2)
         expr = assert_expr :expr
         assert_tok :end_interpolation
+        expr = Sass::Script::Tree::Interpolation.new(
+          nil, expr, nil, !:wb, !:wa, !:originally_text, warn_for_color)
         expr.options = @options
-        expr
+        node(expr, start_pos)
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -226,8 +232,8 @@ module Sass
                   return other_interp
                 end
 
-                start_pos = source_position
-                e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type), start_pos)
+                e = node(Tree::Operation.new(e, assert_expr(#{sub.inspect}), tok.type),
+                         e.source_range.start_pos)
               end
               e
             end
@@ -340,7 +346,8 @@ RUBY
         e = first
         while (interp = try_tok(:begin_interpolation))
           wb = @lexer.whitespace?(interp)
-          mid = parse_interpolated
+          mid = assert_expr :expr
+          assert_tok :end_interpolation
           wa = @lexer.whitespace?
           e = node(
             Script::Tree::Interpolation.new(e, mid, space, wb, wa),
@@ -382,7 +389,7 @@ RUBY
 
         name = @lexer.next
         if (color = Sass::Script::Value::Color::COLOR_NAMES[name.value.downcase])
-          literal_node(Sass::Script::Value::Color.new(color), name.source_range)
+          literal_node(Sass::Script::Value::Color.new(color, name.value), name.source_range)
         elsif name.value == "true"
           literal_node(Sass::Script::Value::Bool.new(true), name.source_range)
         elsif name.value == "false"
@@ -487,22 +494,14 @@ RUBY
       end
 
       def special_fun
-        start_pos = source_position
-        tok = try_tok(:special_fun)
-        return paren unless tok
-        first = literal_node(Script::Value::String.new(tok.value.first),
-          start_pos, start_pos.after(tok.value.first))
-        Sass::Util.enum_slice(tok.value[1..-1], 2).inject(first) do |l, (i, r)|
-          end_pos = i.source_range.end_pos
-          end_pos = end_pos.after(r) if r
-          node(
-            Script::Tree::Interpolation.new(
-              l, i,
-              r && literal_node(Script::Value::String.new(r),
-                i.source_range.end_pos, end_pos),
-              false, false),
-            start_pos, end_pos)
-        end
+        first = try_tok(:special_fun)
+        return paren unless first
+        str = literal_node(first.value, first.source_range)
+        return str unless try_tok(:begin_interpolation)
+        mid = parse_interpolated
+        last = assert_expr(:special_fun)
+        node(Tree::Interpolation.new(str, mid, last, false, false),
+            first.source_range.start_pos)
       end
 
       def paren
@@ -530,7 +529,8 @@ RUBY
         return number unless first
         str = literal_node(first.value, first.source_range)
         return str unless try_tok(:begin_interpolation)
-        mid = parse_interpolated
+        mid = assert_expr :expr
+        assert_tok :end_interpolation
         last = assert_expr(:string)
         node(Tree::StringInterpolation.new(str, mid, last), first.source_range.start_pos)
       end
@@ -563,6 +563,7 @@ RUBY
         :mixin_arglist => "mixin argument",
         :fn_arglist => "function argument",
         :splat => "...",
+        :special_fun => '")"',
       }
 
       def assert_expr(name, expected = nil)

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

@@ -214,7 +214,7 @@ module Sass::Script::Tree
         elsif deprecated_argname && keywords.has_key?(deprecated_argname)
           deprecated_argname = keywords.denormalize(deprecated_argname)
           Sass::Util.sass_warn("DEPRECATION WARNING: The `$#{deprecated_argname}' argument for " +
-            "`#{name}()' has been renamed to `$#{argname}'.")
+            "`#{@name}()' has been renamed to `$#{argname}'.")
           keywords.delete(deprecated_argname)
         else
           raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")

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

@@ -23,6 +23,10 @@ module Sass::Script::Tree
     #   SassScript.
     attr_reader :originally_text
 
+    # @return [Boolean] Whether a color value passed to the interpolation should
+    #   generate a warning.
+    attr_reader :warn_for_color
+
     # Interpolation in a property is of the form `before #{mid} after`.
     #
     # @param before [Node] See {Interpolation#before}
@@ -31,9 +35,10 @@ module Sass::Script::Tree
     # @param wb [Boolean] See {Interpolation#whitespace_before}
     # @param wa [Boolean] See {Interpolation#whitespace_after}
     # @param originally_text [Boolean] See {Interpolation#originally_text}
+    # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
     # @comment
     #   rubocop:disable ParameterLists
-    def initialize(before, mid, after, wb, wa, originally_text = false)
+    def initialize(before, mid, after, wb, wa, originally_text = false, warn_for_color = false)
       # rubocop:enable ParameterLists
       @before = before
       @mid = mid
@@ -41,6 +46,7 @@ module Sass::Script::Tree
       @whitespace_before = wb
       @whitespace_after = wa
       @originally_text = originally_text
+      @warn_for_color = warn_for_color
     end
 
     # @return [String] A human-readable s-expression representation of the interpolation
@@ -90,8 +96,20 @@ module Sass::Script::Tree
       res = ""
       res << @before.perform(environment).to_s if @before
       res << " " if @before && @whitespace_before
+
       val = @mid.perform(environment)
-      res << (val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s)
+      if @warn_for_color && val.is_a?(Sass::Script::Value::Color) && val.name
+        alternative = Operation.new(Sass::Script::Value::String.new("", :string), @mid, :plus)
+        Sass::Util.sass_warn <<MESSAGE
+WARNING on line #{line}, column #{source_range.start_pos.offset}#{" of #{filename}" if filename}:
+You probably don't mean to use the color value `#{val}' in interpolation here.
+It may end up represented as #{val.inspect}, which will likely produce invalid CSS.
+Always quote color names when using them as strings (for example, "#{val}").
+If you really want to use the color value here, use `#{alternative.to_sass}'.
+MESSAGE
+      end
+
+      res << val.to_s(:quote => :none)
       res << " " if @after && @whitespace_after
       res << @after.perform(environment).to_s if @after
       opts(Sass::Script::Value::String.new(res))

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

@@ -0,0 +1,26 @@
+module Sass::Script::Tree
+  # A SassScript node that will resolve to the current selector.
+  class Selector < Node
+    def initialize; end
+
+    def children
+      []
+    end
+
+    def to_sass(opts = {})
+      '&'
+    end
+
+    def deep_copy
+      dup
+    end
+
+    protected
+
+    def _perform(environment)
+      selector = environment.selector
+      return opts(Sass::Script::Value::Null.new) unless selector
+      opts(selector.to_sass_script)
+    end
+  end
+end

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

@@ -81,7 +81,7 @@ module Sass::Script::Tree
       before = @before.perform(environment)
       res << before.value
       mid = @mid.perform(environment)
-      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s)
+      res << (mid.is_a?(Sass::Script::Value::String) ? mid.value : mid.to_s(:quote => :none))
       res << @after.perform(environment).value
       opts(Sass::Script::Value::String.new(res, before.type))
     end

data/lib/sass/script/tree.rb

@@ -13,3 +13,4 @@ require 'sass/script/tree/string_interpolation'
 require 'sass/script/tree/literal'
 require 'sass/script/tree/list_literal'
 require 'sass/script/tree/map_literal'
+require 'sass/script/tree/selector'

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

@@ -20,7 +20,8 @@ module Sass::Script::Value
     #
     # @param value [Object] The object for \{#value}
     def initialize(value = nil)
-      @value = value.freeze
+      value.freeze unless value.nil? || value == true || value == false
+      @value = value
     end
 
     # Sets the options hash for this node,
@@ -95,10 +96,8 @@ MSG
     # @return [Script::Value::String] A string containing both values
     #   without any separation
     def plus(other)
-      if other.is_a?(Sass::Script::Value::String)
-        return Sass::Script::Value::String.new(to_s + other.value, other.type)
-      end
-      Sass::Script::Value::String.new(to_s + other.to_s)
+      type = other.is_a?(Sass::Script::Value::String) ? other.type : :identifier
+      Sass::Script::Value::String.new(to_s(:quote => :none) + other.to_s(:quote => :none), type)
     end
 
     # The SassScript `-` operation.
@@ -212,6 +211,9 @@ MSG
     # Returns the string representation of this value
     # as it would be output to the CSS document.
     #
+    # @options opts :quote [String]
+    #   The preferred quote style for quoted strings. If `:none`, strings are
+    #   always emitted unquoted.
     # @return [String]
     def to_s(opts = {})
       Sass::Util.abstract(self)

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

@@ -20,11 +20,6 @@ module Sass::Script::Value
       value ? TRUE : FALSE
     end
 
-    def eq(other)
-      return other.eq(self) if other.is_a?(DeprecatedFalse)
-      super
-    end
-
     # The Ruby value of the boolean.
     #
     # @return [Boolean]

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

@@ -151,6 +151,7 @@ module Sass::Script::Value
         'powderblue'           => 0xB0E0E6FF,
         'purple'               => 0x800080FF,
         'red'                  => 0xFF0000FF,
+        'rebeccapurple'        => 0x663399FF,
         'rosybrown'            => 0xBC8F8FFF,
         'royalblue'            => 0x4169E1FF,
         'saddlebrown'          => 0x8B4513FF,
@@ -187,35 +188,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 `:value` 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)
@@ -226,6 +235,7 @@ module Sass::Script::Value
         red, green, blue = attrs[0...3].map {|c| c.to_i}
         @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?}
         hsl = [:hue, :saturation, :lightness] & attrs.keys
@@ -243,21 +253,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(@attrs[k].to_i, 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,7 +282,9 @@ 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
@@ -428,7 +439,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 +560,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 +573,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