color_contrast_calc 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 599083b4c4ea4f652dd649dfc78bf9b15e7322496fa757830e04cbfff1618897
-  data.tar.gz: 1a551dd81a0042938f7afbd6e6df33f435a09cfc6990a77711258e90d3b93e02
+  metadata.gz: 07b766d958883d015466220f97ed047512e0fc6dd2a51288b5274c6b0287f0fe
+  data.tar.gz: 1e740d3598c423f07efb3632b31bf155dbf337f8f9265ede39f3b12bd3e50456
 SHA512:
-  metadata.gz: 77b7e9bc36cef897660f4dda625e10c658fb48b91608ea13a68f9d6c0b395e668f08d2e4af812f58146724ad4846c479b1bc833bbd338def9549dc4113c44ff2
-  data.tar.gz: 777fbeed77cbc3b645be5e0a28ae5db2c9c7e1ea7dd38e2a582ca3d9133d01f0b1017b1e253c0171f333ab5b43d5e2933d57c3a696f6be297826ca20b724e7e1
+  metadata.gz: 7d3becf7316ad107082efb72a1e777fb23272a4fe73239170296e55e978d7d0935ad23e7b0a9203c0dc94164ac2dca5efc5763139c49e19cf116c50c28539e1c
+  data.tar.gz: 6e3e1efa303a5ea42e56fd4011ccee3cd19677f0ae770a279c9a4b6ffa9340bb63d5d192224b4f7b18a1364e2b299ecab878dee3a76aa657843ee333a619341b

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.4
 Layout/SpaceInsideBlockBraces:
   SpaceBeforeBlockParameters: false
 Layout/EmptyLineAfterGuardClause:

data/.travis.yml

@@ -1,11 +1,18 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3
-  - 2.4
   - 2.5
   - 2.6
   - 2.7
+  - 3.0
   - ruby-head
-  - jruby-head
 before_install: gem install bundler -v '~>2.0'
+jobs:
+  include:
+  - rvm: 2.4
+    before_install:
+      - yes | gem update --system --force
+      - gem install bundler
+  - rvm: jruby-head
+    before_install:
+      - bundle add rake --version "13.0.0"

data/README.ja.md

@@ -289,32 +289,40 @@ The grayscale of #ffa500 is #acacac.
 ```ruby
 require 'color_contrast_calc'
 
-color_names = ['red', 'yellow', 'lime', 'cyan', 'fuchsia', 'blue']
-colors = color_names.map {|c| ColorContrastCalc.color_from(c) }
+color_names = ['red', 'lime', 'cyan', 'yellow', 'fuchsia', 'blue']
 
 # Sort by hSL order.  An uppercase for a component of color means
 # that component should be sorted in descending order.
 
-hsl_ordered = ColorContrastCalc.sort(colors, 'hSL')
-puts("Colors sorted in the order of hSL: #{hsl_ordered.map(&:name)}")
+hsl_ordered = ColorContrastCalc.sort(color_names, 'hSL')
+puts("Colors sorted in the order of hSL: #{hsl_ordered}")
 
 # Sort by RGB order.
 
-rgb_ordered = ColorContrastCalc.sort(colors, 'RGB')
-puts("Colors sorted in the order of RGB: #{rgb_ordered.map(&:name)}")
+rgb_ordered = ColorContrastCalc.sort(color_names, 'RGB')
+puts("Colors sorted in the order of RGB: #{rgb_ordered}")
 
 # You can also change the precedence of components.
 
-grb_ordered = ColorContrastCalc.sort(colors, 'GRB')
-puts("Colors sorted in the order of GRB: #{grb_ordered.map(&:name)}")
+grb_ordered = ColorContrastCalc.sort(color_names, 'GRB')
+puts("Colors sorted in the order of GRB: #{grb_ordered}")
 
 # And you can directly sort hex color codes.
 
 ## Hex color codes that correspond to the color_names given above.
-hex_codes = ['#ff0000', '#ff0', '#00ff00', '#0ff', '#f0f', '#0000FF']
+hex_codes = ['#ff0000', '#00ff00', '#0ff', '#ff0', '#f0f', '#0000FF']
 
 hsl_ordered = ColorContrastCalc.sort(hex_codes, 'hSL')
 puts("Colors sorted in the order of hSL: #{hsl_ordered}")
+
+# If you want to sort colors in different notations,
+# you should specify a key_mapper.
+
+colors = ['rgb(255 0 0)', 'hsl(120 100% 50%)', '#0ff', 'hwb(60 0% 0%)', [255, 0, 255], '#0000ff']
+
+key_mapper = proc {|c| ColorContrastCalc.color_from(c) }
+colors_in_hsl_order = ColorContrastCalc.sort(colors, 'hSL', key_mapper)
+puts("Colors sorted in the order of hSL: #{colors_in_hsl_order}")
 ```
 
 以下のように実行します:
@@ -325,6 +333,7 @@ Colors sorted in the order of hSL: ["red", "yellow", "lime", "cyan", "blue", "fu
 Colors sorted in the order of RGB: ["yellow", "fuchsia", "red", "cyan", "lime", "blue"]
 Colors sorted in the order of GRB: ["yellow", "cyan", "lime", "fuchsia", "red", "blue"]
 Colors sorted in the order of hSL: ["#ff0000", "#ff0", "#00ff00", "#0ff", "#0000FF", "#f0f"]
+Colors sorted in the order of hSL: ["rgb(255 0 0)", "hwb(60 0% 0%)", "hsl(120 100% 50%)", "#0ff", "#0000ff", [255, 0, 255]]
 ```
 
 ### 例5: 定義済みの色のリスト

data/README.md

@@ -292,32 +292,40 @@ For example, save the following code as `sort_colors.rb`:
 ```ruby
 require 'color_contrast_calc'
 
-color_names = ['red', 'yellow', 'lime', 'cyan', 'fuchsia', 'blue']
-colors = color_names.map {|c| ColorContrastCalc.color_from(c) }
+color_names = ['red', 'lime', 'cyan', 'yellow', 'fuchsia', 'blue']
 
 # Sort by hSL order.  An uppercase for a component of color means
 # that component should be sorted in descending order.
 
-hsl_ordered = ColorContrastCalc.sort(colors, 'hSL')
-puts("Colors sorted in the order of hSL: #{hsl_ordered.map(&:name)}")
+hsl_ordered = ColorContrastCalc.sort(color_names, 'hSL')
+puts("Colors sorted in the order of hSL: #{hsl_ordered}")
 
 # Sort by RGB order.
 
-rgb_ordered = ColorContrastCalc.sort(colors, 'RGB')
-puts("Colors sorted in the order of RGB: #{rgb_ordered.map(&:name)}")
+rgb_ordered = ColorContrastCalc.sort(color_names, 'RGB')
+puts("Colors sorted in the order of RGB: #{rgb_ordered}")
 
 # You can also change the precedence of components.
 
-grb_ordered = ColorContrastCalc.sort(colors, 'GRB')
-puts("Colors sorted in the order of GRB: #{grb_ordered.map(&:name)}")
+grb_ordered = ColorContrastCalc.sort(color_names, 'GRB')
+puts("Colors sorted in the order of GRB: #{grb_ordered}")
 
 # And you can directly sort hex color codes.
 
 ## Hex color codes that correspond to the color_names given above.
-hex_codes = ['#ff0000', '#ff0', '#00ff00', '#0ff', '#f0f', '#0000FF']
+hex_codes = ['#ff0000', '#00ff00', '#0ff', '#ff0', '#f0f', '#0000FF']
 
 hsl_ordered = ColorContrastCalc.sort(hex_codes, 'hSL')
 puts("Colors sorted in the order of hSL: #{hsl_ordered}")
+
+# If you want to sort colors in different notations,
+# you should specify a key_mapper.
+
+colors = ['rgb(255 0 0)', 'hsl(120 100% 50%)', '#0ff', 'hwb(60 0% 0%)', [255, 0, 255], '#0000ff']
+
+key_mapper = proc {|c| ColorContrastCalc.color_from(c) }
+colors_in_hsl_order = ColorContrastCalc.sort(colors, 'hSL', key_mapper)
+puts("Colors sorted in the order of hSL: #{colors_in_hsl_order}")
 ```
 
 Then execute the script:
@@ -328,6 +336,7 @@ Colors sorted in the order of hSL: ["red", "yellow", "lime", "cyan", "blue", "fu
 Colors sorted in the order of RGB: ["yellow", "fuchsia", "red", "cyan", "lime", "blue"]
 Colors sorted in the order of GRB: ["yellow", "cyan", "lime", "fuchsia", "red", "blue"]
 Colors sorted in the order of hSL: ["#ff0000", "#ff0", "#00ff00", "#0ff", "#0000FF", "#f0f"]
+Colors sorted in the order of hSL: ["rgb(255 0 0)", "hwb(60 0% 0%)", "hsl(120 100% 50%)", "#0ff", "#0000ff", [255, 0, 255]]
 ```
 
 ### Example 5: Lists of predefined colors

data/color_contrast_calc.gemspec

@@ -7,7 +7,7 @@ require 'color_contrast_calc/version'
 Gem::Specification.new do |spec|
   spec.name          = 'color_contrast_calc'
   spec.version       = ColorContrastCalc::VERSION
-  spec.required_ruby_version = ">= 2.2"
+  spec.required_ruby_version = ">= 2.4"
   spec.authors       = ['HASHIMOTO, Naoki']
   spec.email         = ['hashimoto.naoki@gmail.com']
 
@@ -23,9 +23,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) {|f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'bundler', '~> 2.1'
   spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.9'
-  spec.add_development_dependency 'rubocop', '~> 0.80'
-  spec.add_development_dependency 'yard', '~> 0.9.24'
+  spec.add_development_dependency 'rspec', '~> 3.10'
+  spec.add_development_dependency 'rubocop', '~> 1.7'
+  spec.add_development_dependency 'yard', '~> 0.9'
 end

data/examples/sort_colors.rb

@@ -2,29 +2,37 @@
 
 require 'color_contrast_calc'
 
-color_names = ['red', 'yellow', 'lime', 'cyan', 'fuchsia', 'blue']
-colors = color_names.map {|c| ColorContrastCalc.color_from(c) }
+color_names = ['red', 'lime', 'cyan', 'yellow', 'fuchsia', 'blue']
 
 # Sort by hSL order.  An uppercase for a component of color means
 # that component should be sorted in descending order.
 
-hsl_ordered = ColorContrastCalc.sort(colors, 'hSL')
-puts("Colors sorted in the order of hSL: #{hsl_ordered.map(&:name)}")
+hsl_ordered = ColorContrastCalc.sort(color_names, 'hSL')
+puts("Colors sorted in the order of hSL: #{hsl_ordered}")
 
 # Sort by RGB order.
 
-rgb_ordered = ColorContrastCalc.sort(colors, 'RGB')
-puts("Colors sorted in the order of RGB: #{rgb_ordered.map(&:name)}")
+rgb_ordered = ColorContrastCalc.sort(color_names, 'RGB')
+puts("Colors sorted in the order of RGB: #{rgb_ordered}")
 
 # You can also change the precedence of components.
 
-grb_ordered = ColorContrastCalc.sort(colors, 'GRB')
-puts("Colors sorted in the order of GRB: #{grb_ordered.map(&:name)}")
+grb_ordered = ColorContrastCalc.sort(color_names, 'GRB')
+puts("Colors sorted in the order of GRB: #{grb_ordered}")
 
 # And you can directly sort hex color codes.
 
 ## Hex color codes that correspond to the color_names given above.
-hex_codes = ['#ff0000', '#ff0', '#00ff00', '#0ff', '#f0f', '#0000FF']
+hex_codes = ['#ff0000', '#00ff00', '#0ff', '#ff0', '#f0f', '#0000FF']
 
 hsl_ordered = ColorContrastCalc.sort(hex_codes, 'hSL')
 puts("Colors sorted in the order of hSL: #{hsl_ordered}")
+
+# If you want to sort colors in different notations,
+# you should specify a key_mapper.
+
+colors = ['rgb(255 0 0)', 'hsl(120 100% 50%)', '#0ff', 'hwb(60 0% 0%)', [255, 0, 255], '#0000ff']
+
+key_mapper = proc {|c| ColorContrastCalc.color_from(c) }
+colors_in_hsl_order = ColorContrastCalc.sort(colors, 'hSL', key_mapper)
+puts("Colors sorted in the order of hSL: #{colors_in_hsl_order}")

data/lib/color_contrast_calc/color.rb

@@ -45,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
 
       ##
@@ -58,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
 
       ##
@@ -72,12 +70,11 @@ module ColorContrastCalc
       def from_hsl(hsl, name = nil)
         if hsl.length == 4
           rgb = Utils.hsl_to_rgb(hsl[0, 3])
-          return Color.new(rgb.push(hsl.last), name) unless opaque?(hsl)
+          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)] ||
-          Color.new(rgb, name)
+        !name && List::HEX_TO_COLOR[Utils.rgb_to_hex(rgb)] || new(rgb, name)
       end
 
       ##
@@ -141,19 +138,19 @@ module ColorContrastCalc
       end
 
       def opaque?(color_value)
-        color_value[-1] == 1.0
+        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(rgb_value)
+          raise InvalidColorRepresentationError.from_value(rgba_value)
         end
 
         return color_from_rgb(rgba_value[0, 3], name) if opaque?(rgba_value)
 
-        Color.new(rgba_value, name)
+        new(rgba_value, name)
       end
 
       private :color_from_rgba
@@ -164,7 +161,7 @@ module ColorContrastCalc
         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
@@ -193,7 +190,7 @@ module ColorContrastCalc
         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
@@ -234,6 +231,12 @@ module ColorContrastCalc
       @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.
     #
@@ -248,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
@@ -256,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
 
     ##
@@ -347,7 +363,7 @@ module ColorContrastCalc
     # @return [Color] New  complementary color
     def complementary(name = nil)
       minmax = rgb.minmax.reduce {|min, max| min + max }
-      self.class.new(rgb.map {|c| minmax - c }, name)
+      create(rgb.map {|c| minmax - c }, name)
     end
 
     ##
@@ -363,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
 
     ##
@@ -380,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
 
     ##
@@ -522,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

@@ -267,7 +267,7 @@ module ColorContrastCalc
       # @return [true, false] return true when the opacity equals 1.0
 
       def opaque?
-        opacity == 1.0
+        opacity == Utils::MAX_OPACITY
       end
 
       # @private
@@ -335,6 +335,16 @@ module ColorContrastCalc
 
       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)
@@ -368,7 +378,7 @@ module ColorContrastCalc
 
     class Parser
       class << self
-        attr_accessor :parsers
+        attr_accessor :parsers, :main, :value, :function
       end
 
       def skip_spaces!(scanner)
@@ -449,7 +459,7 @@ module ColorContrastCalc
         read_unit!(scanner, parsed_value)
       end
 
-      private :read_number!
+      protected :read_number!
 
       def read_unit!(scanner, parsed_value)
         unit = scanner.scan(TokenRe::UNIT)
@@ -463,15 +473,10 @@ module ColorContrastCalc
 
       def read_separator!(scanner, parsed_value)
         if next_spaces_as_separator?(scanner)
-          return read_number!(scanner, parsed_value)
+          return Parser.function.read_number!(scanner, parsed_value)
         end
 
-        if parsed_value[:parameters].length == 3 &&
-           check_next_token(scanner, TokenRe::SLASH)
-          return read_opacity!(scanner, parsed_value)
-        end
-
-        read_comma!(scanner, parsed_value)
+        Parser.value.read_comma!(scanner, parsed_value)
       end
 
       private :read_separator!
@@ -496,11 +501,6 @@ module ColorContrastCalc
 
       private :next_spaces_as_separator?
 
-      def read_opacity!(scanner, parsed_value)
-        read_token!(scanner, TokenRe::SLASH)
-        read_number!(scanner, parsed_value)
-      end
-
       def read_comma!(scanner, parsed_value)
         skip_spaces!(scanner)
 
@@ -510,10 +510,74 @@ module ColorContrastCalc
         read_number!(scanner, parsed_value)
       end
 
-      private :read_comma!
+      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)
 
@@ -527,15 +591,9 @@ module ColorContrastCalc
       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. "
-        ErrorReporter.print_error_pos!(out, color_value, scanner.charpos)
-        out.puts
-        out.string
+        message = "\",\" is not a valid separator for #{scheme} functions."
+        ErrorReporter.compose_error_message(scanner, message)
       end
 
       private :report_wrong_separator!
@@ -552,7 +610,9 @@ module ColorContrastCalc
       Scheme::HWB => FunctionParser.new
     }
 
-    MAIN_PARSER = Parser.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
@@ -563,7 +623,7 @@ module ColorContrastCalc
     # @return [ColorFunction] An instance of ColorFunctionParser::ColorFunction
 
     def self.parse(color_value)
-      parsed_value = MAIN_PARSER.read_scheme!(StringScanner.new(color_value))
+      parsed_value = Parser.main.read_scheme!(StringScanner.new(color_value))
       ColorFunction.create(parsed_value, color_value)
     end
 

data/lib/color_contrast_calc/invalid_color_representation_error.rb

@@ -7,6 +7,10 @@ module ColorContrastCalc
   class InvalidColorRepresentationError < StandardError
     module Template
       RGB = 'An RGB value should be in form of [r, g, b], but %s.'
+      RGBA = <<~RGBA_MESSAGE
+        An RGB value should be in form of [r, g, b, opacity]
+        (r, g, b should be in the range between 0 and 255), but %s.
+      RGBA_MESSAGE
       COLOR_NAME = '%s seems to be an undefined color name.'
       HEX = 'A hex code #xxxxxx where 0 <= x <= f is expected, but %s.'
       UNEXPECTED = 'A color should be given as an array or string, but %s.'
@@ -22,7 +26,7 @@ module ColorContrastCalc
     def self.select_message_template(value)
       case value
       when Array
-        Template::RGB
+        value.length == 3 ? Template::RGB : Template::RGBA
       when String
         may_be_name?(value) ? Template::COLOR_NAME : Template::HEX
       else

data/lib/color_contrast_calc/sorter.rb

@@ -18,6 +18,7 @@ module ColorContrastCalc
     module ColorComponent
       RGB = 'rgb'.chars
       HSL = 'hsl'.chars
+      HWB = 'hwb'.chars
     end
 
     module CompFunc
@@ -45,6 +46,9 @@ module ColorContrastCalc
       # The function returned by Sorter.compile_compare_function() expects
       # hex color codes as key values when this constants is specified.
       HEX = :hex
+      # The function returned by Sorter.compile_compare_function() expects
+      # color functions as key values when this constants is specified.
+      FUNCTION = :function
       # @private
       CLASS_TO_TYPE = {
         Color => COLOR,
@@ -62,14 +66,157 @@ module ColorContrastCalc
 
       def self.guess(color, key_mapper = nil)
         key = key_mapper ? key_mapper[color] : color
+        return FUNCTION if non_hex_code_string?(key)
         CLASS_TO_TYPE[key.class]
       end
+
+      def self.non_hex_code_string?(color)
+        color.is_a?(String) && !Utils.valid_hex?(color)
+      end
+
+      private_class_method :non_hex_code_string?
+    end
+
+    class CompareFunctionCompiler
+      def initialize(converters = nil)
+        @converters = converters
+      end
+
+      def compile(color_order)
+        order = parse_color_order(color_order)
+        create_proc(order, color_order)
+      end
+
+      # @private
+
+      def parse_color_order(color_order)
+        ordered_components = select_ordered_components(color_order)
+        pos = color_component_pos(color_order, ordered_components)
+        funcs = []
+        pos.each_with_index do |ci, i|
+          c = color_order[i]
+          funcs[ci] = Utils.uppercase?(c) ? CompFunc::DESCEND : CompFunc::ASCEND
+        end
+        { pos: pos, funcs: funcs }
+      end
+
+      def select_ordered_components(color_order)
+        case color_order
+        when /[hsl]{3}/i
+          ColorComponent::HSL
+        when /[hwb]{3}/i
+          ColorComponent::HWB
+        else
+          ColorComponent::RGB
+        end
+      end
+
+      private :select_ordered_components
+
+      # @private
+
+      def color_component_pos(color_order, ordered_components)
+        color_order.downcase.chars.map do |component|
+          ordered_components.index(component)
+        end
+      end
+
+      def create_proc(order, color_order)
+        if @converters
+          conv = select_converter(color_order)
+          proc {|color1, color2| compare(conv[color1], conv[color2], order) }
+        else
+          proc {|color1, color2| compare(color1, color2, order) }
+        end
+      end
+
+      private :create_proc
+
+      # @private
+
+      def compare_components(color1, color2, order)
+        funcs = order[:funcs]
+        order[:pos].each do |i|
+          result = funcs[i][color1[i], color2[i]]
+          return result unless result.zero?
+        end
+
+        0
+      end
+
+      alias compare compare_components
+
+      def select_converter(color_order)
+        scheme = select_scheme(color_order)
+        @converters[scheme]
+      end
+
+      private :select_converter
+
+      def select_scheme(color_order)
+        case color_order
+        when /[hsl]{3}/i
+          :hsl
+        when /[hwb]{3}/i
+          :hwb
+        else
+          :rgb
+        end
+      end
+
+      private :select_scheme
+    end
+
+    class CachingCompiler < CompareFunctionCompiler
+      def create_proc(order, color_order)
+        converter = select_converter(color_order)
+        cache = {}
+
+        proc do |color1, color2|
+          c1 = to_components(color1, converter, cache)
+          c2 = to_components(color2, converter, cache)
+
+          compare(c1, c2, order)
+        end
+      end
+
+      def to_components(color, converter, cache)
+        cached_components = cache[color]
+        return cached_components if cached_components
+
+        components = converter[color]
+        cache[color] = components
+
+        components
+      end
+
+      private :to_components
     end
 
-    # @private shorthands for Utils.hex_to_rgb() and .hex_to_hsl()
-    HEX_TO_COMPONENTS = {
+    hex_to_components = {
+      # shorthands for Utils.hex_to_rgb() and .hex_to_hsl()
       rgb: Utils.method(:hex_to_rgb),
-      hsl: Utils.method(:hex_to_hsl)
+      hsl: Utils.method(:hex_to_hsl),
+      hwb: Utils.method(:hex_to_hwb)
+    }
+
+    function_to_components = {
+      rgb: proc {|func| ColorContrastCalc.color_from(func).rgb },
+      hsl: proc {|func| ColorContrastCalc.color_from(func).hsl },
+      hwb: proc {|func| ColorContrastCalc.color_from(func).hwb }
+    }
+
+    color_to_components = {
+      rgb: proc {|color| color.rgb },
+      hsl: proc {|color| color.hsl },
+      hwb: proc {|color| color.hwb }
+    }
+
+    COMPARE_FUNCTION_COMPILERS = {
+      KeyTypes::COLOR => CompareFunctionCompiler.new(color_to_components),
+      KeyTypes::COMPONENTS => CompareFunctionCompiler.new,
+      KeyTypes::HEX => CachingCompiler.new(hex_to_components),
+      KeyTypes::FUNCTION => CachingCompiler.new(function_to_components)
     }.freeze
 
     ##
@@ -114,14 +261,7 @@ module ColorContrastCalc
                                       key_mapper = nil, &key_mapper_block)
       key_mapper = key_mapper_block if !key_mapper && key_mapper_block
 
-      case key_type
-      when KeyTypes::COLOR
-        compare = compile_color_compare_function(color_order)
-      when KeyTypes::COMPONENTS
-        compare = compile_components_compare_function(color_order)
-      when KeyTypes::HEX
-        compare = compile_hex_compare_function(color_order)
-      end
+      compare = COMPARE_FUNCTION_COMPILERS[key_type].compile(color_order)
 
       compose_function(compare, key_mapper)
     end
@@ -135,101 +275,5 @@ module ColorContrastCalc
         compare_function[key_mapper[color1], key_mapper[color2]]
       end
     end
-
-    # @private
-
-    def self.color_component_pos(color_order, ordered_components)
-      color_order.downcase.chars.map do |component|
-        ordered_components.index(component)
-      end
-    end
-
-    # @private
-
-    def self.parse_color_order(color_order)
-      ordered_components = ColorComponent::RGB
-      ordered_components = ColorComponent::HSL if hsl_order?(color_order)
-      pos = color_component_pos(color_order, ordered_components)
-      funcs = []
-      pos.each_with_index do |ci, i|
-        c = color_order[i]
-        funcs[ci] = Utils.uppercase?(c) ? CompFunc::DESCEND : CompFunc::ASCEND
-      end
-      { pos: pos, funcs: funcs }
-    end
-
-    # @private
-
-    def self.hsl_order?(color_order)
-      /[hsl]{3}/i.match?(color_order)
-    end
-
-    # @private
-
-    def self.compare_color_components(color1, color2, order)
-      funcs = order[:funcs]
-      order[:pos].each do |i|
-        result = funcs[i][color1[i], color2[i]]
-        return result unless result.zero?
-      end
-
-      0
-    end
-
-    # @private
-
-    def self.compile_components_compare_function(color_order)
-      order = parse_color_order(color_order)
-
-      proc do |color1, color2|
-        compare_color_components(color1, color2, order)
-      end
-    end
-
-    # @private
-
-    def self.compile_hex_compare_function(color_order)
-      order = parse_color_order(color_order)
-      converter = HEX_TO_COMPONENTS[:rgb]
-      converter = HEX_TO_COMPONENTS[:hsl] if hsl_order?(color_order)
-      cache = {}
-
-      proc do |hex1, hex2|
-        color1 = hex_to_components(hex1, converter, cache)
-        color2 = hex_to_components(hex2, converter, cache)
-
-        compare_color_components(color1, color2, order)
-      end
-    end
-
-    # @private
-
-    def self.hex_to_components(hex, converter, cache)
-      cached_components = cache[hex]
-      return cached_components if cached_components
-
-      components = converter[hex]
-      cache[hex] = components
-
-      components
-    end
-
-    private_class_method :hex_to_components
-
-    # @private
-
-    def self.compile_color_compare_function(color_order)
-      order = parse_color_order(color_order)
-
-      if hsl_order?(color_order)
-        proc do |color1, color2|
-          compare_color_components(color1.hsl, color2.hsl, order)
-        end
-      else
-        proc do |color1, color2|
-          compare_color_components(color1.rgb, color2.rgb, order)
-        end
-      end
-    end
   end
 end

data/lib/color_contrast_calc/transparency_calc.rb

@@ -28,7 +28,7 @@ module ColorContrastCalc
     end
 
     def self.opaque?(rgba)
-      rgba[-1] == 1.0
+      rgba[-1] == Utils::MAX_OPACITY
     end
 
     private_class_method :opaque?

data/lib/color_contrast_calc/utils.rb

@@ -12,6 +12,9 @@ module ColorContrastCalc
   module Utils
     using Shim unless //.respond_to? :match?
 
+    MIN_OPACITY = 0
+    MAX_OPACITY = 1.0
+
     HSL_UPPER_LIMIT = [360, 100, 100].freeze
 
     private_constant :HSL_UPPER_LIMIT
@@ -196,11 +199,9 @@ module ColorContrastCalc
     # @return [true, false] true if a valid HSL value is passed
 
     def self.valid_hsl?(hsl)
-      return false unless hsl.length == 3
-      hsl.each_with_index do |c, i|
-        return false if !c.is_a?(Numeric) || c < 0 || c > HSL_UPPER_LIMIT[i]
+      hsl.length == 3 && hsl.each_with_index.all? do |c, i|
+        c.is_a?(Numeric) && c >= 0 && c <= HSL_UPPER_LIMIT[i]
       end
-      true
     end
 
     ##
@@ -238,10 +239,10 @@ module ColorContrastCalc
     end
 
     module Hwb
-      ##
-      # ref: https://www.w3.org/TR/2019/WD-css-color-4-20191105/
+      HWB_UPPER_LIMIT = [360, 100, 100].freeze
 
       def normalize_hwb(hwb)
+        # https://www.w3.org/TR/2019/WD-css-color-4-20191105/
         h, w, b = hwb
 
         achromatic_percent = w + b
@@ -255,6 +256,12 @@ module ColorContrastCalc
 
       private :normalize_hwb
 
+      ##
+      # Convert an HWB value to an RGB value.
+      #
+      # @param hwb [Array<Float>] HWB value represented as an array of numbers
+      # @return [Array<Integer>] RGB value represented as an array of integers
+
       def hwb_to_rgb(hwb)
         hue, white, black = normalize_hwb(hwb)
         rgb = Utils.hsl_to_rgb([hue, 100, 50])
@@ -264,8 +271,51 @@ module ColorContrastCalc
         end
       end
 
-      def rgb_to_hwb(_rgb)
-        raise Notimplementederror, 'Must be implemented later'
+      ##
+      # Convert an HWB value to hex color code.
+      #
+      # @param hwb [Array<Float>] HWB value represented as an array of numbers
+      # @return [String] Hex color code such as "#ffff00"
+
+      def hwb_to_hex(hwb)
+        rgb_to_hex(hwb_to_rgb(hwb))
+      end
+
+      ##
+      # Convert an RGB value to an HWB value.
+      #
+      # @param rgb [Array<Integer>] RGB value represented as an array of
+      #   integers
+      # @return [Array<Float>] HWB value represented as an array of numbers
+
+      def rgb_to_hwb(rgb)
+        # https://www.w3.org/TR/2020/WD-css-color-4-20201112/
+        hsl = Utils.rgb_to_hsl(rgb)
+        white = rgb.min
+        black = 255 - rgb.max
+        [hsl[0], white * 100 / 255.0, black * 100 / 255.0]
+      end
+
+      ##
+      # Convert hex color code to an HWB value.
+      #
+      # @param hex_code [String] Hex color code such as "#ffff00"
+      # @return [Array<Float>] HWB value represented as an array of numbers
+
+      def hex_to_hwb(hex_code)
+        rgb_to_hwb(Utils.hex_to_rgb(hex_code))
+      end
+
+      ##
+      # Check if a given array is a valid representation of HWB color.
+      #
+      # @param hwb [Array<Float>] HWB value represented as an array of numbers
+      # @return [true, false] true if a valid HWB value is passed
+
+      def valid_hwb?(hwb)
+        hwb.length == 3 && hwb.each_with_index.all? do |c, i|
+          c.is_a?(Numeric) && c >= 0 && c <= HWB_UPPER_LIMIT[i]
+        end
       end
     end
 

data/lib/color_contrast_calc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: color_contrast_calc
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2021-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -44,42 +44,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.24
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.24
+        version: '0.9'
 description: 
 email:
 - hashimoto.naoki@gmail.com
@@ -135,15 +135,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Utility that helps you choose colors with sufficient contrast, WCAG 2.0 in