color_contrast_calc 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eca556d535a8e8eda4ad0bf84e1891447b7065823b18cce4b4695f5a7e2beb6
-  data.tar.gz: 2548294c153d699792adceb71818b4a670da7f5faca6e48d67a1f511ae389f91
+  metadata.gz: 599083b4c4ea4f652dd649dfc78bf9b15e7322496fa757830e04cbfff1618897
+  data.tar.gz: 1a551dd81a0042938f7afbd6e6df33f435a09cfc6990a77711258e90d3b93e02
 SHA512:
-  metadata.gz: cf7971d631606c8cd89f2c23661cb873f73874877c2668e742683c044f634b508262aca2745077831104bdaeeefb123ee30ca303c9cffbef2bc4298bb7518b35
-  data.tar.gz: 67851e719c99d0c047e86f8634c4c7b5ad6511c924b80f2246197bd01e7781c0ff6959dd05f16dba44a43792c916857c4fd698db4081bb6a06a242af5b0dbd1c
+  metadata.gz: 77b7e9bc36cef897660f4dda625e10c658fb48b91608ea13a68f9d6c0b395e668f08d2e4af812f58146724ad4846c479b1bc833bbd338def9549dc4113c44ff2
+  data.tar.gz: 777fbeed77cbc3b645be5e0a28ae5db2c9c7e1ea7dd38e2a582ca3d9133d01f0b1017b1e253c0171f333ab5b43d5e2933d57c3a696f6be297826ca20b724e7e1

data/README.ja.md

@@ -157,6 +157,29 @@ Contrast ratio between yellow and black: 19.555999999999997
 Contrast level: AAA
 ```
 
+#### 1.4: [実験的対応] 透明色間のコントラスト比の計算
+
+透明色間の計算のために``ColorContrastCalc.contrast_ratio_with_opacity()``が
+提供されています。
+
+このメソッドは3つの引数として、前景色と背景色、省略可能な基調色、を取ります。
+
+3番目の基調色は他の2色の下に配置され、完全に不透明なことが期待される点にご注意下さい。
+
+例:
+
+```bash
+irb -r color_contrast_calc
+irb(main):001:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)', 'white')
+=> 1.1828076947731336
+irb(main):002:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)') # 3番目の色のデフォルト値は白です。
+=> 1.1828076947731336
+irb(main):003:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)', 'black')
+=> 4.78414518008597
+irb(main):004:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0)', 'rgb(0 255 0 / 0.5)', 'black') # 完全に不透明な色について不透明度を指定する必要はありません。
+=> 4.78414518008597
+```
+
 ### 例2: ある色に対し十分なコントラスト比のある色を見つける
 
 2色の組み合わせのうち、一方の色のbrightness/lightnessを変化させることで十分な

data/README.md

@@ -157,6 +157,32 @@ Contrast ratio between yellow and black: 19.555999999999997
 Contrast level: AAA
 ```
 
+
+#### 1.4: [Experimental] Calculate the contrast ratio between transparent colors
+
+``ColorContrastCalc.contrast_ratio_with_opacity()`` is provided for the
+calculation.
+
+The method takes three arguments, foreground color, background color and an
+optional base color.
+
+Please note that the third color is placed below the other two colors and
+expects to be fully opaque.
+
+For example:
+
+```bash
+irb -r color_contrast_calc
+irb(main):001:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)', 'white')
+=> 1.1828076947731336
+irb(main):002:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)') # The default value for the third parameter is white.
+=> 1.1828076947731336
+irb(main):003:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0 / 1.0)', 'rgb(0 255 0 / 0.5)', 'black')
+=> 4.78414518008597
+irb(main):004:0> ColorContrastCalc.contrast_ratio_with_opacity('rgb(255 255 0)', 'rgb(0 255 0 / 0.5)', 'black') # For a fully opaque color, you don't need to specify the opacity.
+=> 4.78414518008597
+```
+
 ### Example 2: Find colors that have enough contrast ratio with a given color
 
 If you want to find a combination of colors with sufficient contrast

data/color_contrast_calc.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   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.79'
-  spec.add_development_dependency 'yard', '~> 0.9.9'
+  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'
 end

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'
 
@@ -63,18 +64,44 @@ module ColorContrastCalc
   # Please note that this method may be slow, as it internally creates
   # Color instances.
   #
-  # @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%)", "hwb(60deg 0% 0%)"
-  #   or [255, 255, 0].
-  # @param color2 [String, Array<Integer>] RGB color given as a string or
-  #   an array of integers.
+  # @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.

data/lib/color_contrast_calc/color.rb

@@ -70,7 +70,12 @@ module ColorContrastCalc
       # @return [Color] Instance of Color
 
       def from_hsl(hsl, name = nil)
-        rgb = Utils.hsl_to_rgb(hsl)
+        if hsl.length == 4
+          rgb = Utils.hsl_to_rgb(hsl[0, 3])
+          return Color.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)
       end
@@ -96,14 +101,21 @@ module ColorContrastCalc
           raise InvalidColorRepresentationError.from_value(color_value)
         end
 
-        return color_from_rgb(color_value, name) if color_value.is_a?(Array)
-
-        if /\A(?:rgb|hsl|hwb)/i =~ color_value
-          return color_from_func(color_value, name)
+        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.
       #
@@ -128,6 +140,24 @@ module ColorContrastCalc
         color_from(color_value, name)
       end
 
+      def opaque?(color_value)
+        color_value[-1] == 1.0
+      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)
+        end
+
+        return color_from_rgb(rgba_value[0, 3], name) if opaque?(rgba_value)
+
+        Color.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.from_value(rgb_value)
@@ -141,11 +171,15 @@ module ColorContrastCalc
 
       def color_from_func(color_value, name = nil)
         conv = ColorFunctionParser.parse(color_value)
-        if conv.scheme == ColorFunctionParser::Scheme::HSL
+        if conv.scheme == ColorFunctionParser::Scheme::HSL ||
+           conv.scheme == ColorFunctionParser::Scheme::HSLA
           return from_hsl(conv.to_a, name || color_value)
         end
 
-        color_from_rgb(conv.rgb, name || color_value)
+        name ||= color_value
+
+        return color_from_rgb(conv.rgb, name) if conv.opaque?
+        color_from_rgba(conv.rgba, name)
       end
 
       private :color_from_func
@@ -180,7 +214,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.
@@ -193,7 +227,8 @@ 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)

data/lib/color_contrast_calc/color_function_parser.rb

@@ -15,7 +15,9 @@ module ColorContrastCalc
 
     module Scheme
       RGB = 'rgb'
+      RGBA = 'rgba'
       HSL = 'hsl'
+      HSLA = 'hsla'
       HWB = 'hwb'
     end
 
@@ -68,10 +70,10 @@ module ColorContrastCalc
 
       # @private
       def validate_units(parameters, original_value = nil)
-        @config[:units].each_with_index do |unit, i|
-          passed_unit = parameters[i][:unit]
+        parameters.each_with_index do |param, i|
+          passed_unit = param[:unit]
 
-          unless unit.include? passed_unit
+          unless @config[:units][i].include? passed_unit
             raise InvalidColorRepresentationError,
                   error_message(parameters, passed_unit, i, original_value)
           end
@@ -85,6 +87,7 @@ module ColorContrastCalc
         {
           scheme: Scheme::RGB,
           units: [
+            [nil, PERCENT],
             [nil, PERCENT],
             [nil, PERCENT],
             [nil, PERCENT]
@@ -99,7 +102,8 @@ module ColorContrastCalc
           units: [
             [nil, DEG, GRAD, RAD, TURN],
             [PERCENT],
-            [PERCENT]
+            [PERCENT],
+            [nil, PERCENT]
           ]
         }
       end
@@ -111,14 +115,17 @@ module ColorContrastCalc
           units: [
             [nil, DEG, GRAD, RAD, TURN],
             [PERCENT],
-            [PERCENT]
+            [PERCENT],
+            [nil, PERCENT]
           ]
         }
       end
 
       VALIDATORS = {
         Scheme::RGB => RGB,
+        Scheme::RGBA => RGB,
         Scheme::HSL => HSL,
+        Scheme::HSLA => HSL,
         Scheme::HWB => HWB
       }.freeze
 
@@ -138,7 +145,7 @@ module ColorContrastCalc
     # so do not rely on the current class name and its interfaces.
     # They may change in the future.
 
-    class Converter
+    class ColorFunction
       UNIT_CONV = {
         Unit::PERCENT => proc do |n, base|
           if base == 255
@@ -174,19 +181,44 @@ module ColorContrastCalc
       # ColorFunctionParser.parse() and the manual creation of
       # instances of this class by end users is not expected.
 
-      def initialize(parsed_value, original_value)
+      def initialize(parsed_value)
         @scheme = parsed_value[:scheme]
         @params = parsed_value[:parameters]
-        @source = original_value
+        @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.
       #
@@ -208,40 +240,66 @@ module ColorContrastCalc
         @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 == 1.0
+      end
+
       # @private
       class Rgb < self
         def normalize_params
-          @params.map do |param|
-            UNIT_CONV[param[:unit]][param[:number], 255]
-          end
+          @params.map {|param| convert_unit(param, 255) }
         end
 
-        alias rgb to_a
+        alias rgb color_components
+
+        public :rgb
       end
 
       # @private
       class Hsl < self
         def normalize_params
-          @params.map do |param|
-            UNIT_CONV[param[:unit]][param[:number]]
-          end
+          @params.map {|param| convert_unit(param) }
         end
 
         def rgb
-          Utils.hsl_to_rgb(to_a)
+          Utils.hsl_to_rgb(color_components)
         end
       end
 
       # @private
       class Hwb < self
         def normalize_params
-          @params.map do |param|
-            UNIT_CONV[param[:unit]][param[:number]]
-          end
+          @params.map {|param| convert_unit(param) }
         end
 
         def rgb
-          Utils.hwb_to_rgb(to_a)
+          Utils.hwb_to_rgb(color_components)
         end
       end
 
@@ -249,12 +307,12 @@ module ColorContrastCalc
       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::RGB, Scheme::RGBA
+          Rgb.new(parsed_value)
+        when Scheme::HSL, Scheme::HSLA
+          Hsl.new(parsed_value)
         when Scheme::HWB
-          Hwb.new(parsed_value, original_value)
+          Hwb.new(parsed_value)
         end
       end
     end
@@ -262,12 +320,50 @@ module ColorContrastCalc
     # @private
     module TokenRe
       SPACES = /\s+/.freeze
-      SCHEME = /(rgb|hsl|hwb)/i.freeze
+      SCHEME = /rgba?|hsla?|hwb/i.freeze
       OPEN_PAREN = /\(/.freeze
       CLOSE_PAREN = /\)/.freeze
       COMMA = /,/.freeze
-      NUMBER = /(\d+)(:?\.\d+)?/.freeze
-      UNIT = /(%|deg|grad|rad|turn)/.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.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
@@ -295,25 +391,23 @@ module ColorContrastCalc
       end
 
       def format_error_message(scanner, re)
-        out = StringIO.new
-        color_value = scanner.string
+        ErrorReporter.format_error_message(scanner, re)
+      end
 
-        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}"
+      private :format_error_message
 
-        out.string
+      def source_until_current_pos(scanner)
+        scanner.string[0, scanner.charpos]
       end
 
-      private :format_error_message
+      private :source_until_current_pos
 
-      def print_error_pos!(out, color_value, pos)
-        out.puts 'An error occurred at:'
-        out.puts color_value
-        out.print "#{' ' * pos}^"
+      def fix_value!(parsed_value, scanner)
+        parsed_value[:source] = source_until_current_pos(scanner).strip
+        parsed_value
       end
 
-      private :print_error_pos!
+      private :fix_value!
 
       def read_token!(scanner, re)
         skip_spaces!(scanner)
@@ -362,11 +456,36 @@ module ColorContrastCalc
 
         parsed_value[:parameters].last[:unit] = unit if unit
 
-        read_comma!(scanner, parsed_value)
+        read_separator!(scanner, parsed_value)
       end
 
       private :read_unit!
 
+      def read_separator!(scanner, parsed_value)
+        if next_spaces_as_separator?(scanner)
+          return 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)
+      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)
@@ -377,14 +496,15 @@ module ColorContrastCalc
 
       private :next_spaces_as_separator?
 
-      def read_comma!(scanner, parsed_value)
-        if next_spaces_as_separator?(scanner)
-          return read_number!(scanner, parsed_value)
-        end
+      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)
 
-        return parsed_value if read_close_paren!(scanner)
+        return fix_value!(parsed_value, scanner) if read_close_paren!(scanner)
 
         read_token!(scanner, TokenRe::COMMA)
         read_number!(scanner, parsed_value)
@@ -395,17 +515,13 @@ module ColorContrastCalc
 
     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)
+        return fix_value!(parsed_value, scanner) if read_close_paren!(scanner)
 
         read_number!(scanner, parsed_value)
       end
@@ -417,7 +533,7 @@ module ColorContrastCalc
         # 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)
+        ErrorReporter.print_error_pos!(out, color_value, scanner.charpos)
         out.puts
         out.string
       end
@@ -440,15 +556,15 @@ module ColorContrastCalc
 
     ##
     # Parse an RGB/HSL/HWB function and store the result as an instance of
-    # ColorFunctionParser::Converter.
+    # ColorFunctionParser::ColorFunction.
     #
     # @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
+    # @return [ColorFunction] An instance of ColorFunctionParser::ColorFunction
 
     def self.parse(color_value)
       parsed_value = MAIN_PARSER.read_scheme!(StringScanner.new(color_value))
-      Converter.create(parsed_value, color_value)
+      ColorFunction.create(parsed_value, color_value)
     end
 
     ##
@@ -459,5 +575,15 @@ module ColorContrastCalc
     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

data/lib/color_contrast_calc/converter.rb

@@ -29,6 +29,58 @@ module ColorContrastCalc
       vals.map {|val| val.round.clamp(0, 255) }
     end
 
+    module AlphaCompositing
+      module Rgba
+        BLACK = [0, 0, 0, 1.0].freeze
+        WHITE = [255, 255, 255, 1.0].freeze
+      end
+
+      ##
+      # Return a pair of RGBA colors created from two other RGBA
+      # colors placed on a base color.
+      #
+      # The calculation is based on the definition found at
+      # https://www.w3.org/TR/compositing-1/#simplealphacompositing
+      # @param foreground [Array<Integer, Float>] RGBA value
+      # @param background [Array<Integer, Float>] RGBA value
+      # @param base [Array<Integer, Float>] RGBA value
+      # @return [Hash] A pair of RGBA values with :foreground and
+      #   :background as its keys
+
+      def self.compose(foreground, background, base = Rgba::WHITE)
+        back = calc(background, base)
+        fore = calc(foreground, back)
+
+        {
+          foreground: normalize(fore),
+          background: normalize(back)
+        }
+      end
+
+      def self.normalize(raw_rgba)
+        rgb = Converter.rgb_map(raw_rgba[0, 3], &:round)
+        rgb.push(raw_rgba.last)
+      end
+
+      private_class_method :normalize
+
+      def self.calc(source, backdrop)
+        return source if source.last == 1
+
+        fore = source.dup
+        af = fore.pop
+        back = backdrop.dup
+        ab = back.pop
+
+        composed = fore.zip(back).map {|f, b| f * af + b * ab * (1 - af) }
+        a_composed = af + ab * (1 - af)
+
+        composed.push a_composed
+      end
+
+      private_class_method :calc
+    end
+
     module Contrast
       ##
       # Return contrast adjusted RGB value of passed color.

data/lib/color_contrast_calc/transparency_calc.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'color_contrast_calc/converter'
+require 'color_contrast_calc/checker'
+
+module ColorContrastCalc
+  ##
+  # Provides methods to calculate the contrast ratio between transparent colors.
+  #
+  # Colors are given as RGBA values represented as arrays of Float.
+  # Note that during the process of calculation, each of RGB components
+  # is treated as a Float, though some of them may be rounded up/down in the
+  # final return value.
+
+  module TransparencyCalc
+    include Converter::AlphaCompositing::Rgba
+
+    def self.contrast_ratio(foreground, background, base = WHITE)
+      colors = [foreground, background]
+
+      rgb_colors = if colors.all? {|color| opaque?(color) }
+                     colors.map {|color| to_rgb(color) }
+                   else
+                     to_opaque_rgbs(foreground, background, base)
+                   end
+
+      Checker.contrast_ratio(*rgb_colors)
+    end
+
+    def self.opaque?(rgba)
+      rgba[-1] == 1.0
+    end
+
+    private_class_method :opaque?
+
+    def self.to_rgb(rgba)
+      rgba[0, 3]
+    end
+
+    private_class_method :to_rgb
+
+    def self.compose(foreground, background, base)
+      Converter::AlphaCompositing.compose(foreground, background, base)
+    end
+
+    private_class_method :compose
+
+    def self.to_opaque_rgbs(foreground, background, base)
+      composed = compose(foreground, background, base)
+      %i[foreground background].map {|key| to_rgb(composed[key]) }
+    end
+
+    private_class_method :to_opaque_rgbs
+  end
+end

data/lib/color_contrast_calc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: color_contrast_calc
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-13 00:00:00.000000000 Z
+date: 2020-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,56 +30,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.79'
+        version: '0.80'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.79'
+        version: '0.80'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.9
+        version: 0.9.24
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.9
+        version: 0.9.24
 description: 
 email:
 - hashimoto.naoki@gmail.com
@@ -120,6 +120,7 @@ files:
 - lib/color_contrast_calc/shim.rb
 - lib/color_contrast_calc/sorter.rb
 - lib/color_contrast_calc/threshold_finder.rb
+- lib/color_contrast_calc/transparency_calc.rb
 - lib/color_contrast_calc/utils.rb
 - lib/color_contrast_calc/version.rb
 homepage: https://github.com/nico-hn/color_contrast_calc_rb/