color_contrast_calc 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4b26adb4fda2262eea7f261682ab051b808f2a0
-  data.tar.gz: d021fedafd96acdf28e7b2e9e1757380546d8408
+  metadata.gz: 624186d8778091959fe8526cba79cbe56708c16d
+  data.tar.gz: 2961fad47dfc7afa4b4893dd3d7b0995a97e5601
 SHA512:
-  metadata.gz: 922f5d4c9914fd92473b135ddec0f92eab3c8b121acebbfecae1f489ce8e1f1ba693b3f37404b4e2198fccdf1144e049aa265dfd7cba32e977be5a20aaef5c8c
-  data.tar.gz: 29538d2de8d60496a1b800071311502710dc1b1d01a8e0c5746303db3c33da3836c66f092a1e391f86a10b6c33ea433508daeb0d5db612aa36a246a1e03c8bba
+  metadata.gz: a28e5639b5db61cb0a722a1802b6969d1bb2c20d60783efd9242094f76e984987bd16330d37ac2f36f480c25b81b2679617035159dde4f74798c101a7b7e0de8
+  data.tar.gz: 5f95b64878aba232ed3923849de80776c33229a899fb76014ed397fa3918f89ab869cc690546cbe49ee68f8f970944f4e315ef23beb29fdfae0391f26b1efdcc

data/.rubocop.yml

@@ -1,6 +1,6 @@
 AllCops:
   TargetRubyVersion: 2.2
-Style/SpaceInsideBlockBraces:
+Layout/SpaceInsideBlockBraces:
   SpaceBeforeBlockParameters: false
 Metrics/BlockLength:
   Exclude: ["spec/**/*", "test/**/*"]

data/README.ja.md

@@ -208,7 +208,8 @@ The grayscale of #ffa500 is #acacac.
 
 ### 例4: 色をソートする
 
-`ColorContrastCalc::Sorter.sort`を使って色のソートができます。
+`ColorContrastCalc::Sorter.sort`もしくはその別名`ColorContrastCalc.sort`
+を使って色のソートができます。
 
 またこのメソッドの2番目の引数でソート順を指定することもできます。
 

data/README.md

@@ -207,7 +207,8 @@ are available for `ColorContrastCalc::Color`:
 
 ### Example 4: Sort colors
 
-You can sort colors using a method `ColorContrastCalc::Sorter.sort`.
+You can sort colors using a method `ColorContrastCalc::Sorter.sort` or
+its alias `ColorContrastCalc.sort`.
 
 And by passing the second argument to this method, you can also specify
 the sort order.

data/lib/color_contrast_calc/checker.rb

@@ -25,13 +25,20 @@ module ColorContrastCalc
       AAA = 'AAA'
     end
 
+    ##
+    # The relative luminance of some colors.
+
+    module Luminance
+      # The relative luminance of white
+      WHITE = 1.0
+      # The relative luminance of black
+      BLACK = 0.0
+    end
+
     LEVEL_TO_RATIO = {
       Level::AAA => 7,
       Level::AA => 4.5,
-      Level::A => 3,
-      3 => 7,
-      2 => 4.5,
-      1 => 3
+      Level::A => 3
     }.freeze
 
     private_constant :LEVEL_TO_RATIO
@@ -120,7 +127,25 @@ module ColorContrastCalc
     # @return [Float] Contrast ratio
 
     def self.level_to_ratio(level)
+      return level if level.is_a?(Numeric) && level >= 1.0 && level <= 21.0
       LEVEL_TO_RATIO[level]
     end
+
+    ##
+    # Check if the contrast ratio of a given color against black is higher
+    # than against white.
+    #
+    # @param color [String, Array<Integer>] RGB color given as a string or
+    #   an array of integers. Yellow, for example, can be given as "#ffff00"
+    #   or [255, 255, 0].
+    # @return [Boolean] true if the contrast ratio against white is qual to
+    #   or less than the ratio against black
+
+    def self.light_color?(color)
+      l = relative_luminance(color)
+      ratio_with_white = luminance_to_contrast_ratio(Luminance::WHITE, l)
+      ratio_with_black = luminance_to_contrast_ratio(Luminance::BLACK, l)
+      ratio_with_white <= ratio_with_black
+    end
   end
 end

data/lib/color_contrast_calc/color.rb

@@ -185,7 +185,7 @@ module ColorContrastCalc
 
     def find_brightness_threshold(other_color, level = Checker::Level::AA)
       other_color = Color.new(other_color) unless other_color.is_a? Color
-      ThresholdFinder::Brightness.find(self, other_color, level)
+      Color.new(ThresholdFinder::Brightness.find(rgb, other_color.rgb, level))
     end
 
     ##
@@ -202,7 +202,7 @@ module ColorContrastCalc
 
     def find_lightness_threshold(other_color, level = Checker::Level::AA)
       other_color = Color.new(other_color) unless other_color.is_a? Color
-      ThresholdFinder::Lightness.find(self, other_color, level)
+      Color.new(ThresholdFinder::Lightness.find(rgb, other_color.rgb, level))
     end
 
     ##
@@ -338,7 +338,7 @@ module ColorContrastCalc
     #   or less than the ratio against black
 
     def light_color?
-      contrast_ratio_against(WHITE.rgb) <= contrast_ratio_against(BLACK.rgb)
+      Checker.light_color?(rgb)
     end
 
     def generate_new_color(calc, ratio, name = nil)

data/lib/color_contrast_calc/sorter.rb

@@ -75,10 +75,9 @@ module ColorContrastCalc
     ##
     # Sort colors in the order specified by +color_order+.
     #
-    # Sort colors given as a list or tuple of Color instances or hex
-    # color codes.
+    # Sort colors given as an array of Color instances or hex color codes.
     #
-    # You can specify sorting order by giving a +color_order+ tring, such
+    # You can specify sorting order by giving a +color_order+ string, such
     # as "HSL" or "RGB". A component of +color_order+ on the left side
     # has a higher sorting precedence, and an uppercase letter means
     # descending order.
@@ -89,7 +88,7 @@ module ColorContrastCalc
     #   from items to be sorted
     # @param key_mapper_block [Proc] Block that is used instead of key_mapper
     #   when the latter is not given
-    # @return [Array<Color>, Array<String>] Array of of sorted colors
+    # @return [Array<Color>, Array<String>] Array of sorted colors
 
     def self.sort(colors, color_order = 'hSL',
                   key_mapper = nil, &key_mapper_block)

data/lib/color_contrast_calc/threshold_finder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'color_contrast_calc/color'
+require 'color_contrast_calc/converter'
+require 'color_contrast_calc/checker'
 
 module ColorContrastCalc
   ##
@@ -11,12 +12,41 @@ module ColorContrastCalc
     # @private
 
     module Criteria
+      # @private
+
+      def self.threshold_criteria(level, fixed_rgb, other_rgb)
+        if should_scan_darker_side?(fixed_rgb, other_rgb)
+          return ToDarkerSide.new(level, fixed_rgb)
+        end
+
+        ToBrighterSide.new(level, fixed_rgb)
+      end
+
+      # @private
+
+      def self.should_scan_darker_side?(fixed_rgb, other_rgb)
+        fixed_luminance = Checker.relative_luminance(fixed_rgb)
+        other_luminance = Checker.relative_luminance(other_rgb)
+        fixed_luminance > other_luminance ||
+          fixed_luminance == other_luminance && Checker.light_color?(fixed_rgb)
+      end
+
       class SearchDirection
-        attr_reader :level, :target_ratio
+        attr_reader :level, :target_ratio, :fixed_luminance
 
-        def initialize(level)
+        def initialize(level, fixed_rgb)
           @level = level
           @target_ratio = Checker.level_to_ratio(level)
+          @fixed_luminance = Checker.relative_luminance(fixed_rgb)
+        end
+
+        def sufficient_contrast?(rgb)
+          contrast_ratio(rgb) >= @target_ratio
+        end
+
+        def contrast_ratio(rgb)
+          luminance = Checker.relative_luminance(rgb)
+          Checker.luminance_to_contrast_ratio(@fixed_luminance, luminance)
         end
       end
 
@@ -49,35 +79,30 @@ module ColorContrastCalc
       end
     end
 
-    # @private
-
-    def self.threshold_criteria(level, fixed_color, other_color)
-      if should_scan_darker_side?(fixed_color, other_color)
-        return Criteria::ToDarkerSide.new(level)
-      end
-
-      Criteria::ToBrighterSide.new(level)
-    end
-
-    # @private
+    module FinderUtils
+      # @private
 
-    def self.should_scan_darker_side?(fixed_color, other_color)
-      fixed_color.higher_luminance_than?(other_color) ||
-        fixed_color.same_luminance_as?(other_color) && fixed_color.light_color?
-    end
+      def self.binary_search_width(init_width, min)
+        i = 1
+        init_width = init_width.to_f
+        d = init_width / 2**i
 
-    # @private
+        while d > min
+          yield d
+          i += 1
+          d = init_width / 2**i
+        end
+      end
 
-    def self.binary_search_width(init_width, min)
-      i = 1
-      init_width = init_width.to_f
-      d = init_width / 2**i
+      # @private
 
-      while d > min
-        yield d
-        i += 1
-        d = init_width / 2**i
+      def sufficient_contrast?(fixed_rgb, other_rgb, level)
+        target_ratio = Checker.level_to_ratio(level)
+        ratio = Checker.contrast_ratio(fixed_rgb, other_rgb)
+        ratio >= target_ratio
       end
+
+      private :sufficient_contrast?
     end
 
     ##
@@ -85,57 +110,55 @@ module ColorContrastCalc
     # +Color#find_brightness_threshold()+.
 
     module Brightness
+      extend FinderUtils
+
       ##
       # Try to find a color who has a satisfying contrast ratio.
       #
       # The color returned by this method will be created by changing the
-      # brightness of +other_color+. Even when a color that satisfies the
+      # brightness of +other_rgb+. Even when a color that satisfies the
       # specified level is not found, the method returns a new color anyway.
-      # @param fixed_color [Color] The color which remains unchanged
-      # @param other_color [Color] Color before the adjustment of brightness
+      # @param fixed_rgb [Array<Integer>] RGB value  which remains unchanged
+      # @param other_rgb [Array<Integer>] RGB value before the adjustment of
+      #   brightness
       # @param level [String] "A", "AA" or "AAA"
-      # @return [Color] New color whose brightness is adjusted from that of
-      #   +other_color+
+      # @return [Array<Integer>] RGB value of a new color whose brightness is
+      #   adjusted from that of +other_rgb+
 
-      def self.find(fixed_color, other_color, level = Checker::Level::AA)
-        criteria = ThresholdFinder.threshold_criteria(level,
-                                                      fixed_color, other_color)
-        w = calc_upper_ratio_limit(other_color) / 2.0
+      def self.find(fixed_rgb, other_rgb, level = Checker::Level::AA)
+        criteria = Criteria.threshold_criteria(level, fixed_rgb, other_rgb)
+        w = calc_upper_ratio_limit(other_rgb) / 2.0
 
-        upper_color = upper_limit_color(fixed_color, other_color, w * 2, level)
-        return upper_color if upper_color
+        upper_rgb = upper_limit_rgb(criteria, other_rgb, w * 2)
+        return upper_rgb if upper_rgb
 
-        r, sufficient_r = calc_brightness_ratio(fixed_color.relative_luminance,
-                                                other_color.rgb, criteria, w)
+        r, sufficient_r = calc_brightness_ratio(other_rgb, criteria, w)
 
-        generate_satisfying_color(fixed_color, other_color, criteria,
-                                  r, sufficient_r)
+        generate_satisfying_color(other_rgb, criteria, r, sufficient_r)
       end
 
-      def self.upper_limit_color(fixed_color, other_color, max_ratio, level)
-        limit_color = other_color.new_brightness_color(max_ratio)
-
-        if exceed_upper_limit?(fixed_color, other_color, limit_color, level)
-          limit_color
-        end
+      def self.upper_limit_rgb(criteria, other_rgb, max_ratio)
+        limit_rgb = Converter::Brightness.calc_rgb(other_rgb, max_ratio)
+        limit_rgb if exceed_upper_limit?(criteria, other_rgb, limit_rgb)
       end
 
-      private_class_method :upper_limit_color
+      private_class_method :upper_limit_rgb
 
-      def self.exceed_upper_limit?(fixed_color, other_color, limit_color, level)
-        other_color.higher_luminance_than?(fixed_color) &&
-          !limit_color.sufficient_contrast?(fixed_color, level)
+      def self.exceed_upper_limit?(criteria, other_rgb, limit_rgb)
+        other_luminance = Checker.relative_luminance(other_rgb)
+        other_luminance > criteria.fixed_luminance &&
+          !criteria.sufficient_contrast?(limit_rgb)
       end
 
       private_class_method :exceed_upper_limit?
 
-      def self.calc_brightness_ratio(fixed_luminance, other_rgb, criteria, w)
+      def self.calc_brightness_ratio(other_rgb, criteria, w)
         target_ratio = criteria.target_ratio
         r = w
         sufficient_r = nil
 
-        ThresholdFinder.binary_search_width(w, 0.01) do |d|
-          contrast_ratio = calc_contrast_ratio(fixed_luminance, other_rgb, r)
+        FinderUtils.binary_search_width(w, 0.01) do |d|
+          contrast_ratio = calc_contrast_ratio(criteria, other_rgb, r)
 
           sufficient_r = r if contrast_ratio >= target_ratio
           break if contrast_ratio == target_ratio
@@ -148,13 +171,12 @@ module ColorContrastCalc
 
       private_class_method :calc_brightness_ratio
 
-      def self.generate_satisfying_color(fixed_color, other_color, criteria,
-                                         r, sufficient_r)
-        level = criteria.level
-        nearest = other_color.new_brightness_color(criteria.round(r))
+      def self.generate_satisfying_color(other_rgb, criteria, r, sufficient_r)
+        nearest = Converter::Brightness.calc_rgb(other_rgb, criteria.round(r))
 
-        if sufficient_r && !nearest.sufficient_contrast?(fixed_color, level)
-          return other_color.new_brightness_color(criteria.round(sufficient_r))
+        if sufficient_r && !criteria.sufficient_contrast?(nearest)
+          return Converter::Brightness.calc_rgb(other_rgb,
+                                                criteria.round(sufficient_r))
         end
 
         nearest
@@ -162,19 +184,17 @@ module ColorContrastCalc
 
       private_class_method :generate_satisfying_color
 
-      def self.calc_contrast_ratio(fixed_luminance, other_rgb, r)
-        new_rgb = Converter::Brightness.calc_rgb(other_rgb, r)
-        new_luminance = Checker.relative_luminance(new_rgb)
-        Checker.luminance_to_contrast_ratio(fixed_luminance, new_luminance)
+      def self.calc_contrast_ratio(criteria, other_rgb, r)
+        criteria.contrast_ratio(Converter::Brightness.calc_rgb(other_rgb, r))
       end
 
       private_class_method :calc_contrast_ratio
 
       # @private
 
-      def self.calc_upper_ratio_limit(color)
-        return 100 if color.same_color?(Color::BLACK)
-        darkest = color.rgb.reject(&:zero?).min
+      def self.calc_upper_ratio_limit(rgb)
+        return 100 if rgb == Rgb::BLACK
+        darkest = rgb.reject(&:zero?).min
         ((255.0 / darkest) * 100).ceil
       end
     end
@@ -184,61 +204,61 @@ module ColorContrastCalc
     # +Color#find_lightness_threshold()+.
 
     module Lightness
+      extend FinderUtils
+
       ##
       # Try to find a color who has a satisfying contrast ratio.
       #
       # The color returned by this method will be created by changing the
-      # lightness of +other_color+. Even when a color that satisfies the
+      # lightness of +other_rgb+. Even when a color that satisfies the
       # specified level is not found, the method returns a new color anyway.
-      # @param fixed_color [Color] The color which remains unchanged
-      # @param other_color [Color] Color before the adjustment of lightness
+      # @param fixed_rgb [Array<Integer>] RGB value which remains unchanged
+      # @param other_rgb [Array<Integer>] RGB value before the adjustment of
+      #   lightness
       # @param level [String] "A", "AA" or "AAA"
-      # @return [Color] New color whose lightness is adjusted from that of
-      #   +other_color+
+      # @return [Array<Integer>] RGB value of a new color whose lightness is
+      #   adjusted from that of +other_rgb+
 
-      def self.find(fixed_color, other_color, level = Checker::Level::AA)
-        criteria = ThresholdFinder.threshold_criteria(level,
-                                                      fixed_color, other_color)
-        init_l = other_color.hsl[2]
-        max, min = determine_minmax(fixed_color, other_color, init_l)
+      def self.find(fixed_rgb, other_rgb, level = Checker::Level::AA)
+        other_hsl = Utils.rgb_to_hsl(other_rgb)
+        criteria = Criteria.threshold_criteria(level, fixed_rgb, other_rgb)
+        max, min = determine_minmax(fixed_rgb, other_rgb, other_hsl[2])
 
-        boundary_color = lightness_boundary_color(fixed_color, max, min, level)
+        boundary_color = lightness_boundary_color(fixed_rgb, max, min, level)
         return boundary_color if boundary_color
 
-        l, sufficient_l = calc_lightness_ratio(fixed_color, other_color.hsl,
-                                               criteria, max, min)
+        l, sufficient_l = calc_lightness_ratio(other_hsl, criteria, max, min)
 
-        generate_satisfying_color(fixed_color, other_color.hsl, criteria,
-                                  l, sufficient_l)
+        generate_satisfying_color(other_hsl, criteria, l, sufficient_l)
       end
 
-      def self.determine_minmax(fixed_color, other_color, init_l)
-        scan_darker_side = ThresholdFinder.should_scan_darker_side?(fixed_color,
-                                                                    other_color)
+      def self.determine_minmax(fixed_rgb, other_rgb, init_l)
+        scan_darker_side = Criteria.should_scan_darker_side?(fixed_rgb,
+                                                             other_rgb)
         scan_darker_side ? [init_l, 0] : [100, init_l] # [max, min]
       end
 
       private_class_method :determine_minmax
 
-      def self.lightness_boundary_color(color, max, min, level)
-        if min.zero? && !color.sufficient_contrast?(Color::BLACK, level)
-          return Color::BLACK
+      def self.lightness_boundary_color(rgb, max, min, level)
+        if min.zero? && !sufficient_contrast?(Rgb::BLACK, rgb, level)
+          return Rgb::BLACK
         end
 
-        if max == 100 && !color.sufficient_contrast?(Color::WHITE, level)
-          return Color::WHITE
+        if max == 100 && !sufficient_contrast?(Rgb::WHITE, rgb, level)
+          return Rgb::WHITE
         end
       end
 
       private_class_method :lightness_boundary_color
 
-      def self.calc_lightness_ratio(fixed_color, other_hsl, criteria, max, min)
+      def self.calc_lightness_ratio(other_hsl, criteria, max, min)
         h, s, = other_hsl
         l = (max + min) / 2.0
         sufficient_l = nil
 
-        ThresholdFinder.binary_search_width(max - min, 0.01) do |d|
-          contrast_ratio = calc_contrast_ratio(fixed_color, [h, s, l])
+        FinderUtils.binary_search_width(max - min, 0.01) do |d|
+          contrast_ratio = criteria.contrast_ratio(Utils.hsl_to_rgb([h, s, l]))
 
           sufficient_l = l if contrast_ratio >= criteria.target_ratio
           break if contrast_ratio == criteria.target_ratio
@@ -251,20 +271,12 @@ module ColorContrastCalc
 
       private_class_method :calc_lightness_ratio
 
-      def self.calc_contrast_ratio(fixed_color, hsl)
-        fixed_color.contrast_ratio_against(Utils.hsl_to_rgb(hsl))
-      end
-
-      private_class_method :calc_contrast_ratio
-
-      def self.generate_satisfying_color(fixed_color, other_hsl, criteria,
-                                         l, sufficient_l)
+      def self.generate_satisfying_color(other_hsl, criteria, l, sufficient_l)
         h, s, = other_hsl
-        level = criteria.level
-        nearest = Color.new_from_hsl([h, s, l])
+        nearest = Utils.hsl_to_rgb([h, s, l])
 
-        if sufficient_l && !nearest.sufficient_contrast?(fixed_color, level)
-          return Color.new_from_hsl([h, s, sufficient_l])
+        if sufficient_l && !criteria.sufficient_contrast?(nearest)
+          return Utils.hsl_to_rgb([h, s, sufficient_l])
         end
 
         nearest

data/lib/color_contrast_calc/utils.rb

@@ -237,4 +237,13 @@ module ColorContrastCalc
       !/[[:lower:]]/.match?(str)
     end
   end
+
+  ##
+  # RGB values of some colors.
+
+  module Rgb
+    BLACK = [0, 0, 0].freeze
+    GRAY = [128, 128, 128].freeze
+    WHITE = [255, 255, 255].freeze
+  end
 end

data/lib/color_contrast_calc/version.rb

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

data/lib/color_contrast_calc.rb

@@ -41,10 +41,10 @@ module ColorContrastCalc
   ##
   # Sort colors in the order specified by +color_order+.
   #
-  # Sort colors given as a list or tuple of Color instances or hex
-  # color codes. (alias of Sorter.sort())
+  # Sort colors given as an array of Color instances or hex color codes.
+  # (alias of Sorter.sort())
   #
-  # You can specify sorting order by giving a +color_order+ tring, such
+  # You can specify sorting order by giving a +color_order+ string, such
   # as "HSL" or "RGB". A component of +color_order+ on the left side
   # has a higher sorting precedence, and an uppercase letter means
   # descending order.
@@ -55,7 +55,7 @@ module ColorContrastCalc
   #   from items to be sorted
   # @param key_mapper_block [Proc] Block that is used instead of key_mapper
   #   when the latter is not given
-  # @return [Array<Color>, Array<String>] Array of of sorted colors
+  # @return [Array<Color>, Array<String>] Array of sorted colors
 
   def self.sort(colors, color_order = 'hSL',
                 key_mapper = nil, &key_mapper_block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: color_contrast_calc
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - HASHIMOTO, Naoki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-06 00:00:00.000000000 Z
+date: 2018-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler