color_contrast_calc 0.5.0 → 0.9.0

data/lib/color_contrast_calc.rb

@@ -5,6 +5,7 @@ require 'color_contrast_calc/utils'
 require 'color_contrast_calc/converter'
 require 'color_contrast_calc/checker'
 require 'color_contrast_calc/threshold_finder'
+require 'color_contrast_calc/transparency_calc'
 require 'color_contrast_calc/color'
 require 'color_contrast_calc/sorter'
 
@@ -12,12 +13,14 @@ module ColorContrastCalc
   ##
   # Return an instance of Color.
   #
-  # As +color_value+, you can pass a predefined color name, or an
-  # RGB value represented as an array of integers or a hex code such
-  # as [255, 255, 0] or "#ffff00". +name+ is assigned to the returned
-  # instance.
+  # As +color_value+, you can pass a predefined color name, an
+  # RGB value represented as an array of integers like [255, 255, 0],
+  # or a string such as a hex code like "#ffff00". +name+ is assigned
+  # to the returned instance.
   # @param color_value [String, Array<Integer>] Name of a predefined
-  #   color, hex color code or RGB value
+  #   color, hex color code, rgb/hsl/hwb functions or RGB value.
+  #   Yellow, for example, can be given as [255, 255, 0], "#ffff00",
+  #   "rgb(255, 255, 255)", "hsl(60deg, 100% 50%)" or "hwb(60deg 0% 0%)".
   # @param name [String] Without specifying a name, a color keyword name
   #   (if exists) or the value of normalized hex color code is assigned
   #   to Color#name
@@ -52,6 +55,79 @@ module ColorContrastCalc
     Sorter.sort(colors, color_order, key_mapper)
   end
 
+  ##
+  # Calculate the contrast ratio of given colors.
+  #
+  # The definition of contrast ratio is given at
+  # {https://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef}
+  #
+  # Please note that this method may be slow, as it internally creates
+  # Color instances.
+  #
+  # @param color1 [String, Array<Integer>, Color] color given as a string,
+  #   an array of integers or a Color instance. Yellow, for example, can be
+  #   given as "#ffff00", "#ff0", "rgb(255, 255, 0)", "hsl(60deg, 100%, 50%)",
+  #   "hwb(60deg 0% 0%)" or [255, 255, 0].
+  # @param color2 [String, Array<Integer>, Color] color given as a string,
+  #   an array of integers or a Color instance.
+  # @return [Float] Contrast ratio
+
+  def self.contrast_ratio(color1, color2)
+    Color.as_color(color1).contrast_ratio_against(Color.as_color(color2))
+  end
+
+  ##
+  # Calculate the contrast ratio of transparent colors.
+  #
+  # For the calculation, you have to specify three colors because
+  # when both of two colors to be compared are transparent,
+  # the third color put under them filters through them.
+  #
+  # @param foreground [String, Array<Integer>, Color] The uppermost
+  #   color such as "rgb(255, 255, 0, 0.5)" or "hsl(60 100% 50% / 50%)"
+  # @param background [String, Array<Integer>, Color] The color placed
+  #   between the others
+  # @param base [String, Array<Integer>, Color] The color placed in
+  #   the bottom. When the backgound is completely opaque, this color
+  #   is ignored.
+  # @return [Float] Contrast ratio
+
+  def self.contrast_ratio_with_opacity(foreground, background,
+                                       base = Color::WHITE)
+    params = [foreground, background, base].map do |c|
+      color = Color.as_color(c)
+      color.rgb + [color.opacity]
+    end
+
+    TransparencyCalc.contrast_ratio(*params)
+  end
+
+  ##
+  # Select from two colors the one of which the contrast ratio is higher
+  # than the other's, against a given color.
+  #
+  # Note that this method is tentatively provided and may be changed later
+  # including its name.
+  #
+  # @param color [String, Array<Integer>, Color] A color against which
+  #   the contrast ratio of other two colors will be calculated
+  # @param light_base [String, Array<Integer>, Color] One of two colors
+  #   which will be returned depending their contrast ratio: This one
+  #   will be returned when the contast ratio of the colors happen to
+  #   be same.
+  # @param dark_base [String, Array<Integer>, Color] One of two colors
+  #   which will be returned depending their contrast ratio
+  # @return [String, Array<Integer>, Color] One of the values
+  #   specified as +light_base+ and +dark_base+
+
+  def self.higher_contrast_base_color_for(color,
+                                          light_base: Color::WHITE,
+                                          dark_base: Color::BLACK)
+    ratio_with_light = contrast_ratio(color, light_base)
+    ratio_with_dark = contrast_ratio(color, dark_base)
+    ratio_with_light < ratio_with_dark ? dark_base : light_base
+  end
+
   ##
   # Return an array of named colors.
   #

data/lib/color_contrast_calc/color.rb

@@ -2,16 +2,13 @@
 
 require 'color_contrast_calc/utils'
 require 'color_contrast_calc/checker'
+require 'color_contrast_calc/invalid_color_representation_error'
 require 'color_contrast_calc/threshold_finder'
+require 'color_contrast_calc/color_function_parser'
 require 'color_contrast_calc/deprecated'
 require 'json'
 
 module ColorContrastCalc
-  ##
-  # Error raised if creating a Color instance with invalid value.
-
-  class InvalidColorRepresentationError < StandardError; end
-
   ##
   # Represent specific colors.
   #
@@ -48,8 +45,7 @@ module ColorContrastCalc
       # @return [Color] Instance of Color
 
       def from_rgb(rgb, name = nil)
-        !name && List::HEX_TO_COLOR[Utils.rgb_to_hex(rgb)] ||
-          Color.new(rgb, name)
+        !name && List::HEX_TO_COLOR[Utils.rgb_to_hex(rgb)] || new(rgb, name)
       end
 
       ##
@@ -61,8 +57,7 @@ module ColorContrastCalc
 
       def from_hex(hex, name = nil)
         normalized_hex = Utils.normalize_hex(hex)
-        !name && List::HEX_TO_COLOR[normalized_hex] ||
-          Color.new(normalized_hex, name)
+        !name && List::HEX_TO_COLOR[normalized_hex] || new(normalized_hex, name)
       end
 
       ##
@@ -73,45 +68,61 @@ module ColorContrastCalc
       # @return [Color] Instance of Color
 
       def from_hsl(hsl, name = nil)
-        rgb = Utils.hsl_to_rgb(hsl)
-        !name && List::HEX_TO_COLOR[Utils.rgb_to_hex(rgb)] ||
-          Color.new(rgb, name)
+        if hsl.length == 4
+          rgb = Utils.hsl_to_rgb(hsl[0, 3])
+          return new(rgb.push(hsl.last), name) unless opaque?(hsl)
+        end
+
+        rgb ||= Utils.hsl_to_rgb(hsl)
+        !name && List::HEX_TO_COLOR[Utils.rgb_to_hex(rgb)] || new(rgb, name)
       end
 
       ##
       # Return an instance of Color.
       #
-      # As +color_value+, you can pass a predefined color name, or an
-      # RGB value represented as an array of integers or a hex code such
-      # as [255, 255, 0] or "#ffff00". +name+ is assigned to the returned
-      # instance.
+      # As +color_value+, you can pass a predefined color name, an
+      # RGB value represented as an array of integers like [255, 255, 0],
+      # or a string such as a hex code like "#ffff00". +name+ is assigned
+      # to the returned instance.
       # @param color_value [String, Array<Integer>] Name of a predefined
-      #   color, hex color code or RGB value
+      #   color, hex color code, rgb/hsl/hwb functions or RGB value.
+      #   Yellow, for example, can be given as [255, 255, 0], "#ffff00",
+      #   "rgb(255, 255, 255)", "hsl(60deg, 100% 50%)" or "hwb(60deg 0% 0%)".
       # @param name [String] Without specifying a name, a color keyword name
       #   (if exists) or the value of normalized hex color code is assigned
       #   to Color#name
       # @return [Color] Instance of Color
 
       def color_from(color_value, name = nil)
-        error_message = 'A color should be given as an array or string.'
-
         if !color_value.is_a?(String) && !color_value.is_a?(Array)
-          raise InvalidColorRepresentationError, error_message
+          raise InvalidColorRepresentationError.from_value(color_value)
         end
 
-        return color_from_rgb(color_value, name) if color_value.is_a?(Array)
+        if color_value.is_a?(Array)
+          return color_from_rgba(color_value, name) if color_value.length == 4
+          return color_from_rgb(color_value, name)
+        end
+
+        return color_from_func(color_value, name) if function?(color_value)
         color_from_str(color_value, name)
       end
 
+      def function?(color_value)
+        /\A(?:rgba?|hsla?|hwb)/i =~ color_value
+      end
+
+      private :function?
+
       ##
       # Return an instance of Color.
       #
       # As +color_value+, you can pass a Color instance, a predefined color
-      # name, or an RGB value represented as an array of integers or a hex
-      # code such as [255, 255, 0] or "#ffff00". +name+ is assigned to the
-      # returned instance.
-      # @param color_value [Color, String, Array<Integer>] An instance of
-      #   Color, a name of a predefined, color, hex color code or RGB value
+      # name, an RGB value represented as an array of integers like
+      # [255, 255, 0], or a string such as a hex code like "#ffff00".
+      #  +name+ is assigned to the returned instance.
+      # @param color_value [String, Array<Integer>] An instance of Color,
+      #   a predefined color name, hex color code, rgb/hsl/hwb functions
+      #   or RGB value
       # @param name [String] Without specifying a name, a color keyword name
       #   (if exists) or the value of normalized hex color code is assigned
       #   to Color#name
@@ -126,31 +137,60 @@ module ColorContrastCalc
         color_from(color_value, name)
       end
 
-      def color_from_rgb(rgb_value, name = nil)
-        error_message = 'An RGB value should be given in form of [r, g, b].'
+      def opaque?(color_value)
+        color_value[-1] == Utils::MAX_OPACITY
+      end
+
+      private :opaque?
+
+      def color_from_rgba(rgba_value, name = nil)
+        unless Utils.valid_rgb?(rgba_value[0, 3])
+          raise InvalidColorRepresentationError.from_value(rgba_value)
+        end
+
+        return color_from_rgb(rgba_value[0, 3], name) if opaque?(rgba_value)
+
+        new(rgba_value, name)
+      end
+
+      private :color_from_rgba
 
+      def color_from_rgb(rgb_value, name = nil)
         unless Utils.valid_rgb?(rgb_value)
-          raise InvalidColorRepresentationError, error_message
+          raise InvalidColorRepresentationError.from_value(rgb_value)
         end
 
         hex_code = Utils.rgb_to_hex(rgb_value)
-        !name && List::HEX_TO_COLOR[hex_code] || Color.new(rgb_value, name)
+        !name && List::HEX_TO_COLOR[hex_code] || new(rgb_value, name)
       end
 
       private :color_from_rgb
 
-      def color_from_str(color_value, name = nil)
-        error_message = 'A hex code is in form of "#xxxxxx" where 0 <= x <= f.'
+      def color_from_func(color_value, name = nil)
+        conv = ColorFunctionParser.parse(color_value)
+        if conv.scheme == ColorFunctionParser::Scheme::HSL ||
+           conv.scheme == ColorFunctionParser::Scheme::HSLA
+          return from_hsl(conv.to_a, name || color_value)
+        end
+
+        name ||= color_value
 
+        return color_from_rgb(conv.rgb, name) if conv.opaque?
+        color_from_rgba(conv.rgba, name)
+      end
+
+      private :color_from_func
+
+      def color_from_str(color_value, name = nil)
         named_color = !name && List::NAME_TO_COLOR[color_value]
         return named_color if named_color
 
         unless Utils.valid_hex?(color_value)
-          raise InvalidColorRepresentationError, error_message
+          raise InvalidColorRepresentationError.from_value(color_value)
         end
 
         hex_code = Utils.normalize_hex(color_value)
-        !name && List::HEX_TO_COLOR[hex_code] || Color.new(hex_code, name)
+        !name && List::HEX_TO_COLOR[hex_code] || new(hex_code, name)
       end
 
       private :color_from_str
@@ -171,7 +211,7 @@ module ColorContrastCalc
     # @!attribute [r] relative_luminance
     #   @return [Float] Relative luminance of the color
 
-    attr_reader :rgb, :hex, :name, :relative_luminance
+    attr_reader :rgb, :hex, :name, :relative_luminance, :opacity
 
     ##
     # Create a new instance of Color.
@@ -184,12 +224,19 @@ module ColorContrastCalc
     # @return [Color] New instance of Color
 
     def initialize(rgb, name = nil)
-      @rgb = rgb.is_a?(String) ? Utils.hex_to_rgb(rgb) : rgb
+      @rgb = rgb.is_a?(String) ? Utils.hex_to_rgb(rgb) : rgb.dup
+      @opacity = @rgb.length == 4 ? @rgb.pop : 1.0
       @hex = Utils.rgb_to_hex(@rgb)
       @name = name || common_name
       @relative_luminance = Checker.relative_luminance(@rgb)
     end
 
+    def create(rgb, name = nil)
+      self.class.new(rgb, name)
+    end
+
+    private :create
+
     ##
     # Return HSL value of the color.
     #
@@ -204,6 +251,20 @@ module ColorContrastCalc
       @hsl ||= Utils.rgb_to_hsl(@rgb)
     end
 
+    ##
+    # Return HWB value of the color.
+    #
+    # The value is calculated from the RGB value, so if you create
+    # the instance by Color.color_from method, the value used to
+    # create the color does not necessarily correspond to the value
+    # of this property.
+    #
+    # @return [Array<Float>] HWB value represented as an array of numbers
+
+    def hwb
+      @hwb ||= Utils.rgb_to_hwb(@rgb)
+    end
+
     ##
     # Return a {https://www.w3.org/TR/SVG/types.html#ColorKeywords
     # color keyword name} when the name corresponds to the hex code
@@ -212,8 +273,7 @@ module ColorContrastCalc
     # @return [String] Color keyword name or hex color code
 
     def common_name
-      named_color = List::HEX_TO_COLOR[@hex]
-      named_color && named_color.name || @hex
+      List::HEX_TO_COLOR[@hex]&.name || @hex
     end
 
     ##
@@ -294,6 +354,18 @@ module ColorContrastCalc
       generate_new_color(Converter::Grayscale, ratio, name)
     end
 
+    ##
+    # Return a complementary color of the original color.
+    #
+    # @param name [String] You can name the color to be created.
+    #   Without this option, the value of normalized hex color
+    #   code is assigned instead.
+    # @return [Color] New  complementary color
+    def complementary(name = nil)
+      minmax = rgb.minmax.reduce {|min, max| min + max }
+      create(rgb.map {|c| minmax - c }, name)
+    end
+
     ##
     # Try to find a color who has a satisfying contrast ratio.
     #
@@ -307,8 +379,8 @@ module ColorContrastCalc
     #   of +other_color+
 
     def find_brightness_threshold(other_color, level = Checker::Level::AA)
-      other_color = Color.new(other_color) unless other_color.is_a? Color
-      Color.new(ThresholdFinder::Brightness.find(rgb, other_color.rgb, level))
+      other_color = create(other_color) unless other_color.is_a? Color
+      create(ThresholdFinder::Brightness.find(rgb, other_color.rgb, level))
     end
 
     ##
@@ -324,8 +396,8 @@ module ColorContrastCalc
     #   of +other_color+
 
     def find_lightness_threshold(other_color, level = Checker::Level::AA)
-      other_color = Color.new(other_color) unless other_color.is_a? Color
-      Color.new(ThresholdFinder::Lightness.find(rgb, other_color.rgb, level))
+      other_color = create(other_color) unless other_color.is_a? Color
+      create(ThresholdFinder::Lightness.find(rgb, other_color.rgb, level))
     end
 
     ##
@@ -466,7 +538,7 @@ module ColorContrastCalc
 
     def generate_new_color(calc, ratio, name = nil)
       new_rgb = calc.calc_rgb(rgb, ratio)
-      self.class.new(new_rgb, name)
+      create(new_rgb, name)
     end
 
     private :generate_new_color

data/lib/color_contrast_calc/color_function_parser.rb

@@ -0,0 +1,649 @@
+# frozen_string_literal: true
+
+require 'strscan'
+require 'stringio'
+require 'color_contrast_calc/utils'
+require 'color_contrast_calc/invalid_color_representation_error'
+
+module ColorContrastCalc
+  ##
+  # Module that converts RGB/HSL/HWB functions into data apt for calculation.
+
+  module ColorFunctionParser
+    ##
+    # Define types of color functions.
+
+    module Scheme
+      RGB = 'rgb'
+      RGBA = 'rgba'
+      HSL = 'hsl'
+      HSLA = 'hsla'
+      HWB = 'hwb'
+    end
+
+    ##
+    # Supported units
+
+    module Unit
+      PERCENT = '%'
+      DEG = 'deg'
+      GRAD = 'grad'
+      RAD = 'rad'
+      TURN = 'turn'
+    end
+
+    ##
+    # Validate the unit of each parameter in a color functions.
+
+    class Validator
+      include Unit
+
+      POS = %w[1st 2nd 3rd].freeze
+
+      private_constant :POS
+
+      def initialize
+        @config = yield
+        @scheme = @config[:scheme]
+      end
+
+      def format_to_function(parameters)
+        params = parameters.map {|param| "#{param[:number]}#{param[:unit]}" }
+        "#{@scheme}(#{params.join(' ')})"
+      end
+
+      private :format_to_function
+
+      def error_message(parameters, passed_unit, pos, original_value = nil)
+        color_func = original_value || format_to_function(parameters)
+
+        if passed_unit
+          return format('"%s" is not allowed for %s.',
+                        passed_unit, format_to_function(parameters))
+        end
+
+        format('A unit is required for the %s parameter of %s.',
+               POS[pos], color_func)
+      end
+
+      private :error_message
+
+      # @private
+      def validate_units(parameters, original_value = nil)
+        parameters.each_with_index do |param, i|
+          passed_unit = param[:unit]
+
+          unless @config[:units][i].include? passed_unit
+            raise InvalidColorRepresentationError,
+                  error_message(parameters, passed_unit, i, original_value)
+          end
+        end
+
+        true
+      end
+
+      # @private
+      RGB = Validator.new do
+        {
+          scheme: Scheme::RGB,
+          units: [
+            [nil, PERCENT],
+            [nil, PERCENT],
+            [nil, PERCENT],
+            [nil, PERCENT]
+          ]
+        }
+      end
+
+      # @private
+      HSL = Validator.new do
+        {
+          scheme: Scheme::HSL,
+          units: [
+            [nil, DEG, GRAD, RAD, TURN],
+            [PERCENT],
+            [PERCENT],
+            [nil, PERCENT]
+          ]
+        }
+      end
+
+      # @private
+      HWB = Validator.new do
+        {
+          scheme: Scheme::HWB,
+          units: [
+            [nil, DEG, GRAD, RAD, TURN],
+            [PERCENT],
+            [PERCENT],
+            [nil, PERCENT]
+          ]
+        }
+      end
+
+      VALIDATORS = {
+        Scheme::RGB => RGB,
+        Scheme::RGBA => RGB,
+        Scheme::HSL => HSL,
+        Scheme::HSLA => HSL,
+        Scheme::HWB => HWB
+      }.freeze
+
+      private_constant :VALIDATORS
+
+      def self.validate(parsed_value, original_value = nil)
+        scheme = parsed_value[:scheme]
+        params = parsed_value[:parameters]
+        VALIDATORS[scheme].validate_units(params, original_value)
+      end
+    end
+
+    ##
+    # Hold information about a parsed RGB/HSL/HWB function.
+    #
+    # This class is intended to be used internally in ColorFunctionParser,
+    # so do not rely on the current class name and its interfaces.
+    # They may change in the future.
+
+    class ColorFunction
+      UNIT_CONV = {
+        Unit::PERCENT => proc do |n, base|
+          if base == 255
+            (n.to_f * base / 100.0).round
+          else
+            n.to_f
+          end
+        end,
+        Unit::DEG => proc {|n| n.to_f },
+        Unit::GRAD => proc {|n| n.to_f * 9 / 10 },
+        Unit::TURN => proc {|n| n.to_f * 360 },
+        Unit::RAD => proc {|n| n.to_f * 180 / Math::PI }
+      }
+
+      UNIT_CONV.default = proc {|n| /\./ =~ n ? n.to_f : n.to_i }
+      UNIT_CONV.freeze
+
+      private_constant :UNIT_CONV
+
+      ##
+      # @!attribute [r] scheme
+      #   @return [String] Type of function: 'rgb' or 'hsl'
+      # @!attribute [r] source
+      #   @return [String] The original RGB/HSL/HWB function before
+      #     the conversion
+
+      attr_reader :scheme, :source
+
+      ##
+      # @private
+      #
+      # Parameters passed to this method is generated by
+      # ColorFunctionParser.parse() and the manual creation of
+      # instances of this class by end users is not expected.
+
+      def initialize(parsed_value)
+        @scheme = parsed_value[:scheme]
+        @params = parsed_value[:parameters]
+        @source = parsed_value[:source]
+        @normalized = normalize_params
+        normalize_opacity!(@normalized)
+      end
+
+      def convert_unit(param, base = nil)
+        UNIT_CONV[param[:unit]][param[:number], base]
+      end
+
+      private :convert_unit
+
+      def normalize_params
+        raise NotImplementedError, 'Overwrite the method in a subclass'
+      end
+
+      private :normalize_params
+
+      def color_components
+        return @normalized if @normalized.length == 3
+        @normalized[0, 3]
+      end
+
+      private :color_components
+
+      def normalize_opacity!(normalized)
+        return unless @params.length == 4
+
+        param = @params.last
+        n = param[:number]
+        base = param[:unit] == Unit::PERCENT ? 100 : 1
+        normalized[-1] = n.to_f / base
+      end
+
+      private :normalize_opacity!
+
+      ##
+      # Return the RGB value gained from a RGB/HSL/HWB function.
+      #
+      # @return [Array<Integer>] RGB value represented as an array
+
+      def rgb
+        raise NotImplementedError, 'Overwrite the method in a subclass'
+      end
+
+      ##
+      # Return the parameters of a RGB/HSL/HWB function as an array of
+      # Integer/Float.
+      # The unit for H, S, L is assumed to be deg, %, % respectively.
+      #
+      # @return [Array<Integer, Float>] RGB/HSL/HWB value represented
+      #   as an array
+
+      def to_a
+        @normalized
+      end
+
+      ##
+      # Return the opacity of a color presented as a RGB/HSL/HWB
+      # function. The returned value is normalized to a floating number
+      # between 0 and 1.
+      #
+      # @return [Float] Normalized opacity
+
+      def opacity
+        @opacity ||= @normalized.length == 3 ? 1.0 : @normalized.last
+      end
+
+      ##
+      # Return the RGBA value gained from a RGB/HSL/HWB function.
+      # The opacity is normalized to a floating number between 0 and 1.
+      #
+      # @return [Array<Integer, Float>] RGBA value represented as an array.
+
+      def rgba
+        rgb + [opacity]
+      end
+
+      ##
+      # Return true when the Color is completely opaque.
+      #
+      # @return [true, false] return true when the opacity equals 1.0
+
+      def opaque?
+        opacity == Utils::MAX_OPACITY
+      end
+
+      # @private
+      class Rgb < self
+        def normalize_params
+          @params.map {|param| convert_unit(param, 255) }
+        end
+
+        alias rgb color_components
+
+        public :rgb
+      end
+
+      # @private
+      class Hsl < self
+        def normalize_params
+          @params.map {|param| convert_unit(param) }
+        end
+
+        def rgb
+          Utils.hsl_to_rgb(color_components)
+        end
+      end
+
+      # @private
+      class Hwb < self
+        def normalize_params
+          @params.map {|param| convert_unit(param) }
+        end
+
+        def rgb
+          Utils.hwb_to_rgb(color_components)
+        end
+      end
+
+      # @private
+      def self.create(parsed_value, original_value)
+        Validator.validate(parsed_value, original_value)
+        case parsed_value[:scheme]
+        when Scheme::RGB, Scheme::RGBA
+          Rgb.new(parsed_value)
+        when Scheme::HSL, Scheme::HSLA
+          Hsl.new(parsed_value)
+        when Scheme::HWB
+          Hwb.new(parsed_value)
+        end
+      end
+    end
+
+    # @private
+    module TokenRe
+      SPACES = /\s+/.freeze
+      SCHEME = /rgba?|hsla?|hwb/i.freeze
+      OPEN_PAREN = /\(/.freeze
+      CLOSE_PAREN = /\)/.freeze
+      COMMA = /,/.freeze
+      SLASH = %r{/}.freeze
+      NUMBER = /(?:\d+)(?:\.\d+)?|\.\d+/.freeze
+      UNIT = /%|deg|grad|rad|turn/.freeze
+    end
+
+    # @private
+    module ErrorReporter
+      MAX_SOURCE_LENGTH = 60
+
+      private_constant :MAX_SOURCE_LENGTH
+
+      def self.compose_error_message(scanner, message)
+        color_value = sanitized_source(scanner)
+        out = StringIO.new
+        out.print message
+        out.print ' '
+        ErrorReporter.print_error_pos!(out, color_value, scanner.charpos)
+        out.puts
+        out.string
+      end
+
+      def self.format_error_message(scanner, re)
+        out = StringIO.new
+        color_value = sanitized_source(scanner)
+
+        out.print format('"%s" is not a valid code. ', color_value)
+        print_error_pos!(out, color_value, scanner.charpos)
+        out.puts " while searching with #{re}"
+
+        out.string
+      end
+
+      def self.print_error_pos!(out, color_value, pos)
+        out.puts 'An error occurred at:'
+        out.puts color_value
+        out.print "#{' ' * pos}^"
+      end
+
+      def self.sanitized_source(scanner)
+        src = scanner.string
+        parsed = src[0, scanner.charpos]
+        max_src = src[0, MAX_SOURCE_LENGTH]
+
+        return max_src if /\A[[:ascii:]&&[:^cntrl:]]+\Z/.match(max_src)
+
+        suspicious_chars = max_src[parsed.length, MAX_SOURCE_LENGTH]
+        "#{parsed}#{suspicious_chars.inspect[1..-2]}"
+      end
+
+      private_class_method :sanitized_source
+    end
+
+    class Parser
+      class << self
+        attr_accessor :parsers, :main, :value, :function
+      end
+
+      def skip_spaces!(scanner)
+        scanner.scan(TokenRe::SPACES)
+      end
+
+      private :skip_spaces!
+
+      def read_scheme!(scanner)
+        scheme = read_token!(scanner, TokenRe::SCHEME).downcase
+
+        parsed_value = {
+          scheme: scheme,
+          parameters: []
+        }
+
+        parser = Parser.parsers[scheme] || self
+
+        parser.read_open_paren!(scanner, parsed_value)
+      end
+
+      def format_error_message(scanner, re)
+        ErrorReporter.format_error_message(scanner, re)
+      end
+
+      private :format_error_message
+
+      def source_until_current_pos(scanner)
+        scanner.string[0, scanner.charpos]
+      end
+
+      private :source_until_current_pos
+
+      def fix_value!(parsed_value, scanner)
+        parsed_value[:source] = source_until_current_pos(scanner).strip
+        parsed_value
+      end
+
+      private :fix_value!
+
+      def read_token!(scanner, re)
+        skip_spaces!(scanner)
+        token = scanner.scan(re)
+
+        return token if token
+
+        error_message = format_error_message(scanner, re)
+        raise InvalidColorRepresentationError, error_message
+      end
+
+      private :read_token!
+
+      def read_open_paren!(scanner, parsed_value)
+        read_token!(scanner, TokenRe::OPEN_PAREN)
+
+        read_parameters!(scanner, parsed_value)
+      end
+
+      protected :read_open_paren!
+
+      def read_close_paren!(scanner)
+        scanner.scan(TokenRe::CLOSE_PAREN)
+      end
+
+      private :read_close_paren!
+
+      def read_parameters!(scanner, parsed_value)
+        read_number!(scanner, parsed_value)
+      end
+
+      private :read_parameters!
+
+      def read_number!(scanner, parsed_value)
+        number = read_token!(scanner, TokenRe::NUMBER)
+
+        parsed_value[:parameters].push({ number: number, unit: nil })
+
+        read_unit!(scanner, parsed_value)
+      end
+
+      protected :read_number!
+
+      def read_unit!(scanner, parsed_value)
+        unit = scanner.scan(TokenRe::UNIT)
+
+        parsed_value[:parameters].last[:unit] = unit if unit
+
+        read_separator!(scanner, parsed_value)
+      end
+
+      private :read_unit!
+
+      def read_separator!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          return Parser.function.read_number!(scanner, parsed_value)
+        end
+
+        Parser.value.read_comma!(scanner, parsed_value)
+      end
+
+      private :read_separator!
+
+      def check_next_token(scanner, re)
+        cur_pos = scanner.pos
+        skip_spaces!(scanner)
+        result = scanner.check(re)
+        scanner.pos = cur_pos
+        result
+      end
+
+      private :check_next_token
+
+      def next_spaces_as_separator?(scanner)
+        cur_pos = scanner.pos
+        spaces = skip_spaces!(scanner)
+        next_token_is_number = scanner.check(TokenRe::NUMBER)
+        scanner.pos = cur_pos
+        spaces && next_token_is_number
+      end
+
+      private :next_spaces_as_separator?
+
+      def read_comma!(scanner, parsed_value)
+        skip_spaces!(scanner)
+
+        return fix_value!(parsed_value, scanner) if read_close_paren!(scanner)
+
+        read_token!(scanner, TokenRe::COMMA)
+        read_number!(scanner, parsed_value)
+      end
+
+      protected :read_comma!
+    end
+
+    class ValueParser < Parser
+      def read_separator!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          error_message = report_wrong_separator!(scanner, parsed_value)
+          raise InvalidColorRepresentationError, error_message
+        end
+
+        read_comma!(scanner, parsed_value)
+      end
+
+      def report_wrong_separator!(scanner, parsed_value)
+        scheme = parsed_value[:scheme].upcase
+        template = '" " and "," as a separator should not be used mixedly in %s functions.'
+        message = format(template, scheme)
+        ErrorReporter.compose_error_message(scanner, message)
+      end
+
+      private :report_wrong_separator!
+    end
+
+    class FunctionParser < Parser
+      def read_separator!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          error_if_opacity_separator_expected(scanner, parsed_value)
+          read_number!(scanner, parsed_value)
+        elsif opacity_separator_is_next?(scanner, parsed_value)
+          read_opacity!(scanner, parsed_value)
+        else
+          read_comma!(scanner, parsed_value)
+        end
+      end
+
+      private :read_separator!
+
+      def error_if_opacity_separator_expected(scanner, parsed_value)
+        return unless parsed_value[:parameters].length == 3
+
+        error_message = report_wrong_opacity_separator!(scanner, parsed_value)
+        raise InvalidColorRepresentationError, error_message
+      end
+
+      private :error_if_opacity_separator_expected
+
+      def report_wrong_opacity_separator!(scanner, parsed_value)
+        scheme = parsed_value[:scheme].upcase
+        message = "\"/\" is expected as a separator for opacity in #{scheme} functions."
+        ErrorReporter.compose_error_message(scanner, message)
+      end
+
+      private :report_wrong_opacity_separator!
+
+      def opacity_separator_is_next?(scanner, parsed_value)
+        parsed_value[:parameters].length == 3 &&
+          check_next_token(scanner, TokenRe::SLASH)
+      end
+
+      private :opacity_separator_is_next?
+
+      def read_opacity!(scanner, parsed_value)
+        read_token!(scanner, TokenRe::SLASH)
+        read_number!(scanner, parsed_value)
+      end
+
+      private :read_opacity!
+
+      def read_comma!(scanner, parsed_value)
+        skip_spaces!(scanner)
+
+        if scanner.check(TokenRe::COMMA)
+          wrong_separator_error(scanner, parsed_value)
+        end
+
+        return fix_value!(parsed_value, scanner) if read_close_paren!(scanner)
+
+        read_number!(scanner, parsed_value)
+      end
+
+      def report_wrong_separator!(scanner, parsed_value)
+        scheme = parsed_value[:scheme].upcase
+        message = "\",\" is not a valid separator for #{scheme} functions."
+        ErrorReporter.compose_error_message(scanner, message)
+      end
+
+      private :report_wrong_separator!
+
+      def wrong_separator_error(scanner, parsed_value)
+        error_message = report_wrong_separator!(scanner, parsed_value)
+        raise InvalidColorRepresentationError, error_message
+      end
+
+      private :wrong_separator_error
+    end
+
+    Parser.parsers = {
+      Scheme::HWB => FunctionParser.new
+    }
+
+    Parser.main = Parser.new
+    Parser.value = ValueParser.new
+    Parser.function = FunctionParser.new
+
+    ##
+    # Parse an RGB/HSL/HWB function and store the result as an instance of
+    # ColorFunctionParser::ColorFunction.
+    #
+    # @param color_value [String] RGB/HSL/HWB function defined at
+    #   https://www.w3.org/TR/2019/WD-css-color-4-20191105/
+    # @return [ColorFunction] An instance of ColorFunctionParser::ColorFunction
+
+    def self.parse(color_value)
+      parsed_value = Parser.main.read_scheme!(StringScanner.new(color_value))
+      ColorFunction.create(parsed_value, color_value)
+    end
+
+    ##
+    # Return An RGB value gained from an RGB/HSL/HWB function.
+    #
+    # @return [Array<Integer>] RGB value represented as an array
+
+    def self.to_rgb(color_value)
+      parse(color_value).rgb
+    end
+
+    ##
+    # Return An RGBA value gained from an RGB/HSL/HWB function.
+    # The opacity is normalized to a floating number between 0 and 1.
+    #
+    # @return [Array<Integer, Float>] RGBA value represented as an array
+
+    def self.to_rgba(color_value)
+      parse(color_value).rgba
+    end
+  end
+end