color_contrast_calc 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f14c1b61fcfcbab962811f5d6c2bee98841b5fc88aedbe3cdcb1f66747c7735
-  data.tar.gz: 60c833fd6e0374f319172ff40307f496f3d3e31b7ae7e77b01105f2283855776
+  metadata.gz: 4eca556d535a8e8eda4ad0bf84e1891447b7065823b18cce4b4695f5a7e2beb6
+  data.tar.gz: 2548294c153d699792adceb71818b4a670da7f5faca6e48d67a1f511ae389f91
 SHA512:
-  metadata.gz: 2406be8e787bc8730cc4297429f37081a21cfde4acd5fc82f53703eccce10f0d1868ce8072ee4f592c2ea7a4a8372c4ca7bdfa97a6866b4d632f30b7c2a49675
-  data.tar.gz: 226e05b5b73f8f19e7589bed424cb1eb6c14dabfa1b87b2b8e1db84c646ce4110ad3cbd93970746a9df1d8df41fa5286801fea849168ac260e76724d55ab4cca
+  metadata.gz: cf7971d631606c8cd89f2c23661cb873f73874877c2668e742683c044f634b508262aca2745077831104bdaeeefb123ee30ca303c9cffbef2bc4298bb7518b35
+  data.tar.gz: 67851e719c99d0c047e86f8634c4c7b5ad6511c924b80f2246197bd01e7781c0ff6959dd05f16dba44a43792c916857c4fd698db4081bb6a06a242af5b0dbd1c

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.2
+  TargetRubyVersion: 2.3
 Layout/SpaceInsideBlockBraces:
   SpaceBeforeBlockParameters: false
 Layout/EmptyLineAfterGuardClause:
@@ -12,5 +12,5 @@ Style/FormatStringToken:
   Enabled: false
 Style/AccessModifierDeclarations:
   EnforcedStyle: inline
-Naming/UncommunicativeMethodParamName:
+Naming/MethodParameterName:
   MinNameLength: 1

data/README.ja.md

@@ -47,8 +47,8 @@ Or install it yourself as:
 require 'color_contrast_calc'
 
 # Create an instance of Color from a hex code
-# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)' or 'hsl(0deg, 100%, 50%)'
-# instead of '#ff0000')
+# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)', 'hsl(0deg, 100%, 50%)' or
+# hwb(60deg 0% 0%) instead of '#ff0000')
 red = ColorContrastCalc.color_from('#ff0000')
 puts red.class
 puts red.name
@@ -70,6 +70,17 @@ red
 
 ```
 
+#### `ColorContrastCalc.color_from()`の引数に使える色の表現
+
+`ColorContrastCalc.color_from()`の第1引数は以下の形式で指定できます。
+
+* RGB値の16進数表記: #ff0, #ffff00, #FF0, etc.
+* RGB値の関数形式表記: rgb(255, 255, 0), rgb(255 255 0), etc.
+* Integerの配列で表したRGB値: [255, 255, 0], etc.
+* HSL値の関数形式表記: hsl(60deg, 100%, 50%), hsl(60 100% 50%), etc.
+* [実験的対応] HWB値の関数形式表記: hwb(60deg 0% 0%), hwb(60 0% 0%), etc.
+* [拡張カラーキーワード](https://www.w3.org/TR/css-color-3/#svg-color): white, black, red, etc.
+
 ### 例1: 2つの色のコントラスト比を計算する
 
 #### 1.1: 最も簡便なやり方

data/README.md

@@ -46,8 +46,8 @@ Save the following code as `color_instance.rb`:
 require 'color_contrast_calc'
 
 # Create an instance of Color from a hex code
-# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)' or 'hsl(0deg, 100%, 50%)'
-# instead of '#ff0000')
+# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)', 'hsl(0deg, 100%, 50%)' or
+# hwb(60deg 0% 0%) instead of '#ff0000')
 red = ColorContrastCalc.color_from('#ff0000')
 puts red.class
 puts red.name
@@ -69,6 +69,17 @@ red
 
 ```
 
+#### Color units for the argument of `ColorContrastCalc.color_from()`
+
+The following formats are supported for the first argument of `ColorContrastCalc.color_from()`.
+
+* RGB values in hexadecimal notation: #ff0, #ffff00, #FF0, etc.
+* RGB values in functional notation: rgb(255, 255, 0), rgb(255 255 0), etc.
+* RGB values as an Array of Integers: [255, 255, 0], etc.
+* HSL colors in functional notation: hsl(60deg, 100%, 50%), hsl(60 100% 50%), etc.
+* [Experimental] HWB colors in functional notation: hwb(60deg 0% 0%), hwb(60 0% 0%), etc.
+* [Extended color keywords](https://www.w3.org/TR/css-color-3/#svg-color): white, black, red, etc.
+
 ### Example 1: Calculate the contrast ratio between two colors
 
 #### 1.1: The easiest way

data/color_contrast_calc.gemspec

@@ -26,6 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.49.1'
+  spec.add_development_dependency 'rubocop', '~> 0.79'
   spec.add_development_dependency 'yard', '~> 0.9.9'
 end

data/examples/color_instance.rb

@@ -3,8 +3,8 @@ require 'color_contrast_calc'
 require 'color_contrast_calc'
 
 # Create an instance of Color from a hex code
-# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)' or 'hsl(0deg, 100%, 50%)'
-# instead of '#ff0000')
+# (You can pass 'red', [255, 0, 0], 'rgb(255, 0, 0)', 'hsl(0deg, 100%, 50%)' or
+# hwb(60deg 0% 0%) instead of '#ff0000')
 red = ColorContrastCalc.color_from('#ff0000')
 puts red.class
 puts red.name

data/lib/color_contrast_calc.rb

@@ -12,12 +12,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, rgb/hsl functions 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
@@ -63,7 +65,8 @@ module ColorContrastCalc
   #
   # @param color1 [String, Array<Integer>] RGB color given as a string or
   #   an array of integers. Yellow, for example, can be given as "#ffff00",
-  #   "#ff0", "rgb(255, 255, 0)", "hsl(60deg, 100%, 50%)" or [255, 255, 0].
+  #   "#ff0", "rgb(255, 255, 0)", "hsl(60deg, 100%, 50%)", "hwb(60deg 0% 0%)"
+  #   or [255, 255, 0].
   # @param color2 [String, Array<Integer>] RGB color given as a string or
   #   an array of integers.
   # @return [Float] Contrast ratio
@@ -72,6 +75,32 @@ module ColorContrastCalc
     Color.as_color(color1).contrast_ratio_against(Color.as_color(color2))
   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

@@ -78,12 +78,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, rgb/hsl functions 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
@@ -96,7 +98,7 @@ module ColorContrastCalc
 
         return color_from_rgb(color_value, name) if color_value.is_a?(Array)
 
-        if /\A(?:rgb|hsl)/i =~ color_value
+        if /\A(?:rgb|hsl|hwb)/i =~ color_value
           return color_from_func(color_value, name)
         end
         color_from_str(color_value, name)
@@ -106,11 +108,12 @@ module ColorContrastCalc
       # 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
@@ -138,11 +141,11 @@ module ColorContrastCalc
 
       def color_from_func(color_value, name = nil)
         conv = ColorFunctionParser.parse(color_value)
-        if conv.scheme == ColorFunctionParser::Scheme::RGB
-          return color_from_rgb(conv.to_a, name || color_value)
+        if conv.scheme == ColorFunctionParser::Scheme::HSL
+          return from_hsl(conv.to_a, name || color_value)
         end
 
-        from_hsl(conv.to_a, name || color_value)
+        color_from_rgb(conv.rgb, name || color_value)
       end
 
       private :color_from_func

data/lib/color_contrast_calc/color_function_parser.rb

@@ -7,7 +7,7 @@ require 'color_contrast_calc/invalid_color_representation_error'
 
 module ColorContrastCalc
   ##
-  # Module that converts RGB/HSL functions into data apt for calculation.
+  # Module that converts RGB/HSL/HWB functions into data apt for calculation.
 
   module ColorFunctionParser
     ##
@@ -16,21 +16,154 @@ module ColorContrastCalc
     module Scheme
       RGB = 'rgb'
       HSL = 'hsl'
+      HWB = 'hwb'
     end
 
     ##
-    # Hold information about a parsed RGB/HSL function.
+    # 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)
+        @config[:units].each_with_index do |unit, i|
+          passed_unit = parameters[i][:unit]
+
+          unless unit.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]
+          ]
+        }
+      end
+
+      # @private
+      HSL = Validator.new do
+        {
+          scheme: Scheme::HSL,
+          units: [
+            [nil, DEG, GRAD, RAD, TURN],
+            [PERCENT],
+            [PERCENT]
+          ]
+        }
+      end
+
+      # @private
+      HWB = Validator.new do
+        {
+          scheme: Scheme::HWB,
+          units: [
+            [nil, DEG, GRAD, RAD, TURN],
+            [PERCENT],
+            [PERCENT]
+          ]
+        }
+      end
+
+      VALIDATORS = {
+        Scheme::RGB => RGB,
+        Scheme::HSL => 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 Converter
+      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 function before the conversion
+      #   @return [String] The original RGB/HSL/HWB function before
+      #     the conversion
 
       attr_reader :scheme, :source
 
@@ -55,7 +188,7 @@ module ColorContrastCalc
       private :normalize_params
 
       ##
-      # Return the RGB value gained from a RGB/HSL function.
+      # Return the RGB value gained from a RGB/HSL/HWB function.
       #
       # @return [Array<Integer>] RGB value represented as an array
 
@@ -64,11 +197,12 @@ module ColorContrastCalc
       end
 
       ##
-      # Return the parameters of a RGB/HSL function as an array of
+      # 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 value represented as an array
+      # @return [Array<Integer, Float>] RGB/HSL/HWB value represented
+      #   as an array
 
       def to_a
         @normalized
@@ -78,11 +212,7 @@ module ColorContrastCalc
       class Rgb < self
         def normalize_params
           @params.map do |param|
-            if param[:unit] == '%'
-              (param[:number] * 255.0 / 100).round
-            else
-              param[:number].to_i
-            end
+            UNIT_CONV[param[:unit]][param[:number], 255]
           end
         end
 
@@ -93,7 +223,7 @@ module ColorContrastCalc
       class Hsl < self
         def normalize_params
           @params.map do |param|
-            param[:number].to_f
+            UNIT_CONV[param[:unit]][param[:number]]
           end
         end
 
@@ -102,13 +232,29 @@ module ColorContrastCalc
         end
       end
 
+      # @private
+      class Hwb < self
+        def normalize_params
+          @params.map do |param|
+            UNIT_CONV[param[:unit]][param[:number]]
+          end
+        end
+
+        def rgb
+          Utils.hwb_to_rgb(to_a)
+        end
+      end
+
       # @private
       def self.create(parsed_value, original_value)
+        Validator.validate(parsed_value, original_value)
         case parsed_value[:scheme]
         when Scheme::RGB
           Rgb.new(parsed_value, original_value)
         when Scheme::HSL
           Hsl.new(parsed_value, original_value)
+        when Scheme::HWB
+          Hwb.new(parsed_value, original_value)
         end
       end
     end
@@ -116,127 +262,197 @@ module ColorContrastCalc
     # @private
     module TokenRe
       SPACES = /\s+/.freeze
-      SCHEME = /(rgb|hsl)/i.freeze
+      SCHEME = /(rgb|hsl|hwb)/i.freeze
       OPEN_PAREN = /\(/.freeze
       CLOSE_PAREN = /\)/.freeze
       COMMA = /,/.freeze
       NUMBER = /(\d+)(:?\.\d+)?/.freeze
-      UNIT = /(%|deg)/.freeze
+      UNIT = /(%|deg|grad|rad|turn)/.freeze
     end
 
-    def self.format_error_message(scanner, re)
-      out = StringIO.new
-      color_value = scanner.string
-      [
-        format('"%s" is not a valid code. An error occurred at:', color_value),
-        color_value,
-        "#{' ' * scanner.charpos}^ while searching with #{re}"
-      ].each do |line|
-        out.puts line
+    class Parser
+      class << self
+        attr_accessor :parsers
       end
 
-      out.string
-    end
+      def skip_spaces!(scanner)
+        scanner.scan(TokenRe::SPACES)
+      end
 
-    private_class_method :format_error_message
+      private :skip_spaces!
 
-    def self.skip_spaces!(scanner)
-      scanner.scan(TokenRe::SPACES)
-    end
+      def read_scheme!(scanner)
+        scheme = read_token!(scanner, TokenRe::SCHEME).downcase
 
-    private_class_method :skip_spaces!
+        parsed_value = {
+          scheme: scheme,
+          parameters: []
+        }
 
-    def self.read_token!(scanner, re)
-      skip_spaces!(scanner)
-      token = scanner.scan(re)
+        parser = Parser.parsers[scheme] || self
 
-      return token if token
+        parser.read_open_paren!(scanner, parsed_value)
+      end
 
-      error_message = format_error_message(scanner, re)
-      raise InvalidColorRepresentationError, error_message
-    end
+      def format_error_message(scanner, re)
+        out = StringIO.new
+        color_value = scanner.string
 
-    private_class_method :read_token!
+        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}"
 
-    def self.read_scheme!(scanner)
-      scheme = read_token!(scanner, TokenRe::SCHEME)
+        out.string
+      end
 
-      parsed_value = {
-        scheme: scheme.downcase,
-        parameters: []
-      }
+      private :format_error_message
 
-      read_open_paren!(scanner, parsed_value)
-    end
+      def print_error_pos!(out, color_value, pos)
+        out.puts 'An error occurred at:'
+        out.puts color_value
+        out.print "#{' ' * pos}^"
+      end
 
-    private_class_method :read_scheme!
+      private :print_error_pos!
 
-    def self.read_open_paren!(scanner, parsed_value)
-      read_token!(scanner, TokenRe::OPEN_PAREN)
+      def read_token!(scanner, re)
+        skip_spaces!(scanner)
+        token = scanner.scan(re)
 
-      read_parameters!(scanner, parsed_value)
-    end
+        return token if token
 
-    private_class_method :read_open_paren!
+        error_message = format_error_message(scanner, re)
+        raise InvalidColorRepresentationError, error_message
+      end
 
-    def self.read_close_paren!(scanner)
-      scanner.scan(TokenRe::CLOSE_PAREN)
-    end
+      private :read_token!
 
-    private_class_method :read_close_paren!
+      def read_open_paren!(scanner, parsed_value)
+        read_token!(scanner, TokenRe::OPEN_PAREN)
 
-    def self.read_parameters!(scanner, parsed_value)
-      read_number!(scanner, parsed_value)
-    end
+        read_parameters!(scanner, parsed_value)
+      end
 
-    private_class_method :read_parameters!
+      protected :read_open_paren!
 
-    def self.read_number!(scanner, parsed_value)
-      number = read_token!(scanner, TokenRe::NUMBER)
+      def read_close_paren!(scanner)
+        scanner.scan(TokenRe::CLOSE_PAREN)
+      end
 
-      parsed_value[:parameters].push({ number: number, unit: nil })
+      private :read_close_paren!
 
-      read_unit!(scanner, parsed_value)
-    end
+      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 })
 
-    private_class_method :read_number!
+        read_unit!(scanner, parsed_value)
+      end
+
+      private :read_number!
 
-    def self.read_unit!(scanner, parsed_value)
-      unit = scanner.scan(TokenRe::UNIT)
+      def read_unit!(scanner, parsed_value)
+        unit = scanner.scan(TokenRe::UNIT)
 
-      parsed_value[:parameters].last[:unit] = unit if unit
+        parsed_value[:parameters].last[:unit] = unit if unit
+
+        read_comma!(scanner, parsed_value)
+      end
+
+      private :read_unit!
+
+      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
 
-      read_comma!(scanner, parsed_value)
+      private :next_spaces_as_separator?
+
+      def read_comma!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          return read_number!(scanner, parsed_value)
+        end
+
+        skip_spaces!(scanner)
+
+        return parsed_value if read_close_paren!(scanner)
+
+        read_token!(scanner, TokenRe::COMMA)
+        read_number!(scanner, parsed_value)
+      end
+
+      private :read_comma!
     end
 
-    private_class_method :read_unit!
+    class FunctionParser < Parser
+      def read_comma!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          return read_number!(scanner, parsed_value)
+        end
+
+        skip_spaces!(scanner)
+
+        if scanner.check(TokenRe::COMMA)
+          wrong_separator_error(scanner, parsed_value)
+        end
+
+        return parsed_value if read_close_paren!(scanner)
 
-    def self.read_comma!(scanner, parsed_value)
-      skip_spaces!(scanner)
+        read_number!(scanner, parsed_value)
+      end
+
+      def report_wrong_separator!(scanner, parsed_value)
+        out = StringIO.new
+        color_value = scanner.string
+        scheme = parsed_value[:scheme].upcase
+        # The trailing space after the first message is intentional,
+        # because it is immediately followed by another message.
+        out.print "\",\" is not a valid separator for #{scheme} functions. "
+        print_error_pos!(out, color_value, scanner.charpos)
+        out.puts
+        out.string
+      end
 
-      return parsed_value if read_close_paren!(scanner)
+      private :report_wrong_separator!
 
-      read_token!(scanner, TokenRe::COMMA)
-      read_number!(scanner, parsed_value)
+      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
 
-    private_class_method :read_comma!
+    Parser.parsers = {
+      Scheme::HWB => FunctionParser.new
+    }
+
+    MAIN_PARSER = Parser.new
 
     ##
-    # Parse an RGB/HSL function and store the result as an instance of
+    # Parse an RGB/HSL/HWB function and store the result as an instance of
     # ColorFunctionParser::Converter.
     #
-    # @param color_value [String] RGB/HSL function defined at
-    #   https://www.w3.org/TR/css-color-4/
+    # @param color_value [String] RGB/HSL/HWB function defined at
+    #   https://www.w3.org/TR/2019/WD-css-color-4-20191105/
     # @return [Converter] An instance of ColorFunctionParser::Converter
 
     def self.parse(color_value)
-      parsed_value = read_scheme!(StringScanner.new(color_value))
+      parsed_value = MAIN_PARSER.read_scheme!(StringScanner.new(color_value))
       Converter.create(parsed_value, color_value)
     end
 
     ##
-    # Return An RGB value gained from an RGB/HSL function.
+    # Return An RGB value gained from an RGB/HSL/HWB function.
     #
     # @return [Array<Integer>] RGB value represented as an array
 

data/lib/color_contrast_calc/data/color_keywords.json

@@ -118,6 +118,7 @@
   ["plum", "#dda0dd"],
   ["powderblue", "#b0e0e6"],
   ["purple", "#800080"],
+  ["rebeccapurple", "#663399"],
   ["red", "#ff0000"],
   ["rosybrown", "#bc8f8f"],
   ["royalblue", "#4169e1"],

data/lib/color_contrast_calc/deprecated.rb

@@ -6,7 +6,7 @@ module ColorContrastCalc
 
   module Deprecated
     def self.warn(old_method, new_method)
-      STDERR.puts "##{old_method} is deprecated. Use ##{new_method} instead"
+      Kernel.warn "##{old_method} is deprecated. Use ##{new_method} instead"
     end
 
     module Color

data/lib/color_contrast_calc/invalid_color_representation_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ColorContrastCalc
   ##
   # Error raised if creating a Color instance with invalid value.

data/lib/color_contrast_calc/utils.rb

@@ -236,6 +236,40 @@ module ColorContrastCalc
     def self.uppercase?(str)
       !/[[:lower:]]/.match?(str)
     end
+
+    module Hwb
+      ##
+      # ref: https://www.w3.org/TR/2019/WD-css-color-4-20191105/
+
+      def normalize_hwb(hwb)
+        h, w, b = hwb
+
+        achromatic_percent = w + b
+        denominator = achromatic_percent > 100 ? achromatic_percent : 100
+
+        normalized_w = w.to_f / denominator
+        normalized_b = b.to_f / denominator
+
+        [h, normalized_w, normalized_b]
+      end
+
+      private :normalize_hwb
+
+      def hwb_to_rgb(hwb)
+        hue, white, black = normalize_hwb(hwb)
+        rgb = Utils.hsl_to_rgb([hue, 100, 50])
+
+        rgb.map do |c|
+          ((c * (1.0 - white - black)) + white * 255).round
+        end
+      end
+
+      def rgb_to_hwb(_rgb)
+        raise Notimplementederror, 'Must be implemented later'
+      end
+    end
+
+    extend Hwb
   end
 
   ##

data/lib/color_contrast_calc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ColorContrastCalc
-  VERSION = '0.6.1'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: color_contrast_calc
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-05 00:00:00.000000000 Z
+date: 2020-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: '0.79'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.49.1
+        version: '0.79'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement