abachrome 0.1.0 → 0.1.1

data/lib/abachrome/color_mixins/to_oklch.rb

@@ -1,8 +1,33 @@
-# frozen_string_literal: true
+# Abachrome::ColorMixins::ToOklch - OKLCH color space conversion functionality
+#
+# This mixin provides methods for converting colors to the OKLCH color space, which is a
+# cylindrical representation of the OKLAB color space using lightness, chroma, and hue
+# coordinates. OKLCH offers intuitive color manipulation through its polar coordinate
+# system where hue is represented as an angle and chroma represents colorfulness.
+#
+# Key features:
+# - Convert colors to OKLCH with automatic converter lookup
+# - Both non-destructive (to_oklch) and destructive (to_oklch!) conversion methods
+# - Direct access to OKLCH components (lightness, chroma, hue)
+# - Utility methods for OKLCH array and value extraction
+# - Optimized to return the same object when no conversion is needed
+# - High-precision decimal arithmetic for accurate color science calculations
+#
+# The OKLCH color space uses three components: L (lightness), C (chroma/colorfulness),
+# and h (hue angle in degrees), providing an intuitive interface for color adjustments
+# that better matches human perception compared to traditional RGB-based color spaces.
 
 module Abachrome
   module ColorMixins
     module ToOklch
+      # Converts the current color to the OKLCH color space.
+      # 
+      # This method transforms the color into the perceptually uniform OKLCH color space.
+      # If the color is already in OKLCH, it returns itself unchanged. If the color is in
+      # OKLAB, it directly converts from OKLAB to OKLCH. For all other color spaces, it
+      # first converts to OKLAB as an intermediate step, then converts to OKLCH.
+      # 
+      # @return [Abachrome::Color] A new Color object in the OKLCH color space
       def to_oklch
         return self if color_space.name == :oklch
 
@@ -15,6 +40,12 @@ module Abachrome
         end
       end
 
+      # Converts the color to OKLCH color space in-place.
+      # This method transforms the current color to OKLCH color space, modifying
+      # the original object instead of creating a new one. If the color is already
+      # in OKLCH space, no conversion is performed.
+      # 
+      # @return [Abachrome::Color] self, allowing for method chaining
       def to_oklch!
         unless color_space.name == :oklch
           oklch_color = to_oklch
@@ -24,25 +55,52 @@ module Abachrome
         self
       end
 
+      # Returns the lightness component of the color in the OKLCH color space.
+      # This method provides direct access to the first coordinate of the OKLCH
+      # representation of the color, which represents perceptual lightness.
+      # 
+      # @return [AbcDecimal] the lightness value in the OKLCH color space,
+      # typically in the range of 0.0 to 1.0, where 0.0 is black and 1.0 is white
       def lightness
         to_oklch.coordinates[0]
       end
 
+      # Returns the chroma value of the color by converting it to the OKLCH color space.
+      # Chroma represents color intensity or saturation in the OKLCH color space.
+      # 
+      # @return [AbcDecimal] The chroma value (second coordinate) from the OKLCH color space
       def chroma
         to_oklch.coordinates[1]
       end
 
+      # Returns the hue value of the color in the OKLCH color space.
+      # 
+      # @return [AbcDecimal] The hue component of the color in degrees (0-360)
+      # from the OKLCH color space representation.
       def hue
         to_oklch.coordinates[2]
       end
 
+      # Returns the OKLCH coordinates of the color.
+      # 
+      # @return [Array<AbcDecimal>] Array of OKLCH coordinates [lightness, chroma, hue] where:
+      # - lightness: perceptual lightness component (0-1)
+      # - chroma: colorfulness/saturation component
+      # - hue: hue angle in degrees (0-360)
       def oklch_values
         to_oklch.coordinates
       end
 
+      # Returns the OKLCH coordinates of the color as an array.
+      # 
+      # Converts the current color to OKLCH color space and returns its coordinates
+      # as an array. The OKLCH color space represents colors using Lightness,
+      # Chroma, and Hue components in a perceptually uniform way.
+      # 
+      # @return [Array<Numeric>] An array containing the OKLCH coordinates [lightness, chroma, hue]
       def oklch_array
         to_oklch.coordinates
       end
     end
   end
-end
+end

data/lib/abachrome/color_mixins/to_srgb.rb

@@ -1,21 +1,52 @@
-# frozen_string_literal: true
+# Abachrome::ColorMixins::ToSrgb - sRGB color space conversion functionality
+#
+# This mixin provides methods for converting colors to the sRGB color space, which is the
+# standard RGB color space used in most displays and web applications. sRGB uses gamma
+# correction to better match human visual perception compared to linear RGB, making it
+# ideal for display purposes and color output in digital media.
+#
+# Key features:
+# - Convert colors to sRGB with automatic converter lookup
+# - Both non-destructive (to_srgb/to_rgb) and destructive (to_srgb!/to_rgb!) conversion methods
+# - Direct access to sRGB components (red, green, blue)
+# - Utility methods for RGB array and hex string output
+# - Optimized to return the same object when no conversion is needed
+# - High-precision decimal arithmetic for accurate color science calculations
+#
+# The sRGB color space is the default RGB color space for web content and most consumer
+# displays, providing a standardized way to represent colors that will appear consistently
+# across different devices and applications.
 
 require_relative "../converter"
 
 module Abachrome
   module ColorMixins
     module ToSrgb
+      # Converts the current color to the sRGB color space.
+      # 
+      # If the color is already in the sRGB color space, returns the color instance
+      # unchanged. Otherwise, performs a color space conversion from the current
+      # color space to sRGB.
+      # 
+      # @return [Abachrome::Color] A new Color instance in the sRGB color space,
+      # or self if already in sRGB
       def to_srgb
         return self if color_space.name == :srgb
 
         Converter.convert(self, :srgb)
       end
 
+      # Alias for #to_srgb method.
+      # 
+      # @return [Abachrome::Color] The color converted to sRGB color space
       def to_rgb
         # assume they mean srgb
         to_srgb
       end
 
+      # Converts the color to the sRGB color space, mutating the current object.
+      # If the color is already in sRGB space, this method does nothing.
+      # @return [Abachrome::Color] self for method chaining
       def to_srgb!
         unless color_space.name == :srgb
           srgb_color = to_srgb
@@ -25,39 +56,83 @@ module Abachrome
         self
       end
 
+      # Converts the current color to sRGB color space in place.
+      # This is an alias for {#to_srgb!} as RGB commonly refers to sRGB
+      # in web and design contexts.
+      # 
+      # @return [self] Returns self after converting to sRGB
       def to_rgb!
         # assume they mean srgb
         to_srgb!
       end
 
+      # Returns the red component of the color in the sRGB color space.
+      # 
+      # @return [AbcDecimal] The red component value in the sRGB color space,
+      # normalized between 0 and 1.
       def red
         to_srgb.coordinates[0]
       end
 
+      # Returns the green component of the color in sRGB space.
+      # 
+      # This method converts the current color to sRGB color space if needed,
+      # then extracts the green component (second coordinate).
+      # 
+      # @return [AbcDecimal] The green component value in the sRGB color space, typically in the range 0-1
       def green
         to_srgb.coordinates[1]
       end
 
+      # Returns the blue component of the color in sRGB color space.
+      # 
+      # This method converts the current color to sRGB if needed and
+      # extracts the third coordinate value (blue).
+      # 
+      # @return [AbcDecimal] The blue component value in sRGB space, typically in range 0-1
       def blue
         to_srgb.coordinates[2]
       end
 
+      # Returns the RGB color values in the sRGB color space.
+      # 
+      # @return [Array<AbcDecimal>] An array of three AbcDecimal values representing
+      # the red, green, and blue color components in the sRGB color space.
       def srgb_values
         to_srgb.coordinates
       end
 
+      # Returns the RGB values of the color as coordinates in the sRGB color space.
+      # 
+      # @return [Array<Abachrome::AbcDecimal>] The RGB coordinates (red, green, blue) in sRGB color space
       def rgb_values
         to_srgb.coordinates
       end
 
+      # Returns an array of RGB values (0-255) for this color.
+      # 
+      # This method converts the color to sRGB, then scales the component values
+      # from the 0-1 range to the 0-255 range commonly used in RGB color codes.
+      # Values are rounded to the nearest integer and clamped between 0 and 255.
+      # 
+      # @return [Array<Integer>] An array of three integers representing the [R, G, B]
+      # values in the 0-255 range
       def rgb_array
         to_srgb.coordinates.map { |c| (c * 255).round.clamp(0, 255) }
       end
 
+      # Returns a hexadecimal representation of this color in sRGB color space.
+      # Converts the color to sRGB, then formats it as a hexadecimal string.
+      # 
+      # @return [String] A string in the format "#RRGGBB" where RR, GG, and BB are
+      # the hexadecimal representations of the red, green, and blue components,
+      # each ranging from 00 to FF.
+      # @example
+      # color.rgb_hex #=> "#3a7bc8"
       def rgb_hex
         r, g, b = rgb_array
         format("#%02x%02x%02x", r, g, b)
       end
     end
   end
-end
+end

data/lib/abachrome/color_models/hsv.rb

@@ -1,4 +1,21 @@
-# frozen_string_literal: true
+# Abachrome::ColorModels::HSV - HSV color space model definition
+#
+# This module defines the HSV (Hue, Saturation, Value) color model within the Abachrome
+# color manipulation library. HSV provides an intuitive way to represent colors using
+# cylindrical coordinates where hue represents the color type, saturation represents
+# the intensity or purity of the color, and value represents the brightness.
+#
+# Key features:
+# - Registers the HSV color space with coordinate names [hue, saturation, value]
+# - Validates HSV coordinates to ensure all components are within the [0, 1] range
+# - Uses normalized 0-1 values internally for consistency with other color models
+# - Provides a more intuitive interface for color adjustments compared to RGB
+# - Supports conversion to and from other color spaces through the converter system
+#
+# The HSV model is particularly useful for color picking interfaces and applications
+# where users need to adjust color properties in a way that matches human perception
+# of color relationships. All coordinate values are stored as AbcDecimal objects to
+# maintain precision during color science calculations.
 
 module Abachrome
   module ColorModels
@@ -11,6 +28,12 @@ module Abachrome
 
       register :hsv, "HSV", %w[hue saturation value]
 
+      # Validates whether the coordinates are valid for the HSV color model.
+      # Each component (hue, saturation, value) must be in the range [0, 1].
+      # 
+      # @param coordinates [Array<Numeric>] An array of three values representing
+      # hue (h), saturation (s), and value (v) in the range [0, 1]
+      # @return [Boolean] true if all coordinates are within valid ranges, false otherwise
       def valid_coordinates?(coordinates)
         h, s, v = coordinates
         h >= 0 && h <= 1.0 &&
@@ -19,4 +42,4 @@ module Abachrome
       end
     end
   end
-end
+end

data/lib/abachrome/color_models/oklab.rb

@@ -1,4 +1,21 @@
-# frozen_string_literal: true
+# Abachrome::ColorModels::Oklab - OKLAB color space model definition
+#
+# This module defines the OKLAB color model within the Abachrome color manipulation library.
+# OKLAB is a perceptually uniform color space designed for better color manipulation and
+# comparison, providing more intuitive lightness adjustments and color blending compared
+# to traditional RGB color spaces.
+#
+# Key features:
+# - Registers the OKLAB color space with coordinate names [lightness, a, b]
+# - Uses L (lightness) ranging from 0 (black) to 1 (white)
+# - Uses a and b components representing green-red and blue-yellow axes respectively
+# - Provides perceptually uniform color space for accurate color science calculations
+# - Serves as an intermediate color space for conversions to OKLCH and other models
+# - Maintains high precision through AbcDecimal arithmetic for color transformations
+#
+# The OKLAB model is particularly useful for color adjustments that need to appear natural
+# to human perception, such as lightness modifications, color blending, and gamut mapping
+# operations where perceptual uniformity is important.
 
 module Abachrome
   module ColorModels
@@ -13,4 +30,4 @@ ColorSpace.register(
   %w[l a b],
   nil,
   ["ok-lab"]
-)
+)

data/lib/abachrome/color_models/oklch.rb

@@ -1,8 +1,33 @@
-# frozen_string_literal: true
+# Abachrome::ColorModels::Oklch - OKLCH color space model definition
+#
+# This module defines the OKLCH color model within the Abachrome color manipulation library.
+# OKLCH is a cylindrical representation of the OKLAB color space using lightness, chroma, and hue
+# coordinates. OKLCH offers intuitive color manipulation through its polar coordinate
+# system where hue is represented as an angle and chroma represents colorfulness.
+#
+# Key features:
+# - Registers the OKLCH color space with coordinate names [lightness, chroma, hue]
+# - Provides conversion utilities between OKLCH and OKLAB color spaces
+# - Uses L (lightness) ranging from 0 (black) to 1 (white)
+# - Uses C (chroma) representing colorfulness intensity starting from 0
+# - Uses h (hue) as an angle in degrees from 0 to 360
+# - Includes normalization methods for proper coordinate ranges
+# - Maintains high precision through AbcDecimal arithmetic for color transformations
+#
+# The OKLCH model is particularly useful for color adjustments that need to appear natural
+# to human perception, such as hue shifts, saturation modifications, and lightness changes
+# where the cylindrical coordinate system provides more intuitive control compared to
+# rectangular color spaces.
 
 module Abachrome
   module ColorModels
     class Oklch
+      # Normalizes OKLCH color values to their standard ranges.
+      # 
+      # @param l [Numeric] The lightness component, will be clamped to range 0-1
+      # @param c [Numeric] The chroma component, will be clamped to range 0-1
+      # @param h [Numeric] The hue component in degrees, will be normalized to range 0-360
+      # @return [Array<AbcDecimal>] Array containing the normalized [lightness, chroma, hue] values
       def self.normalize(l, c, h)
         l = AbcDecimal(l)
         c = AbcDecimal(c)
@@ -19,6 +44,12 @@ module Abachrome
         [l, c, h]
       end
 
+      # Converts OKLCH color coordinates to OKLab color coordinates.
+      # 
+      # @param l [Numeric] The lightness value in the OKLCH color space
+      # @param c [Numeric] The chroma value in the OKLCH color space
+      # @param h [Numeric] The hue value in degrees in the OKLCH color space
+      # @return [Array<Numeric>] An array containing the OKLab coordinates [l, a, b]
       def self.to_oklab(l, c, h)
         # Convert OKLCH to OKLab
         h_rad = h * Math::PI / 180
@@ -27,6 +58,15 @@ module Abachrome
         [l, a, b]
       end
 
+      # Converts OKLab color coordinates to OKLCH color coordinates.
+      # 
+      # @param l [Numeric] The lightness component from OKLab.
+      # @param a [Numeric] The green-red component from OKLab.
+      # @param b [Numeric] The blue-yellow component from OKLab.
+      # @return [Array<Numeric>] An array containing the OKLCH values [l, c, h] where:
+      # - l is the lightness component (unchanged from OKLab)
+      # - c is the chroma component (calculated from a and b)
+      # - h is the hue angle in degrees (0-360)
       def self.from_oklab(l, a, b)
         # Convert OKLab to OKLCH
         c = Math.sqrt((a * a) + (b * b))
@@ -44,4 +84,4 @@ ColorSpace.register(
   %w[lightness chroma hue],
   nil,
   ["ok-lch"]
-)
+)

data/lib/abachrome/color_models/rgb.rb

@@ -1,9 +1,35 @@
-# frozen_string_literal: true
+# Abachrome::ColorModels::RGB - RGB color space model utilities
+#
+# This module provides utility methods for the RGB color model within the Abachrome
+# color manipulation library. RGB represents colors using red, green, and blue
+# components, which is the most common color model for digital displays and web
+# applications.
+#
+# Key features:
+# - Normalizes RGB component values to the [0, 1] range from various input formats
+# - Handles percentage values (with % suffix) by dividing by 100
+# - Handles 0-255 range values by dividing by 255
+# - Handles 0-1 range values directly without conversion
+# - Supports string and numeric input types for flexible color specification
+# - Maintains high precision through AbcDecimal arithmetic for color calculations
+#
+# The RGB model serves as a foundation for sRGB and linear RGB color spaces,
+# providing the basic coordinate normalization needed for accurate color
+# representation and conversion between different RGB-based color spaces.
 
 module Abachrome
   module ColorModels
     class RGB
       class << self
+        # Normalizes RGB color component values to the [0,1] range.
+        # 
+        # @param r [String, Numeric] Red component. If string with % suffix, interpreted as percentage;
+        # if string without suffix or numeric > 1, interpreted as 0-255 range value;
+        # if numeric ≤ 1, used directly.
+        # @param g [String, Numeric] Green component. Same interpretation as red component.
+        # @param b [String, Numeric] Blue component. Same interpretation as red component.
+        # @return [Array<AbcDecimal>] Array of three normalized components as AbcDecimal objects,
+        # each in the range [0,1].
         def normalize(r, g, b)
           [r, g, b].map do |value|
             case value
@@ -25,4 +51,4 @@ module Abachrome
       end
     end
   end
-end
+end

data/lib/abachrome/color_space.rb

@@ -1,20 +1,57 @@
-# frozen_string_literal: true
+# Abachrome::ColorSpace - Core color space definition and registry system
+#
+# This module provides the foundation for managing color spaces within the Abachrome library.
+# It implements a registry system for storing and retrieving color space definitions, along
+# with the ColorSpace class that encapsulates color space properties including coordinate
+# names, white points, and color models.
+#
+# Key features:
+# - Global registry for color space registration and lookup with alias support
+# - Color space definition with configurable coordinates, white points, and color models
+# - Built-in registration of standard color spaces (sRGB, linear RGB, HSL, LAB, OKLAB, OKLCH)
+# - Equality comparison and hash support for color space objects
+# - Flexible initialization through block-based configuration
+# - Support for color space aliases (e.g., :rgb as alias for :srgb)
+#
+# The ColorSpace class serves as the foundation for the Color class and converter system,
+# providing the metadata needed for proper color representation and transformation between
+# different color spaces. All registered color spaces are accessible through the registry
+# class methods and can be extended with custom color space definitions.
 
 module Abachrome
   class ColorSpace
     class << self
+      # A registry of all registered color spaces.
+      # 
+      # @return [Hash] A memoized hash where keys are color space identifiers and values are the corresponding color space objects
       def registry
         @registry ||= {}
       end
 
+      # Registers a new color space with the specified name.
+      # 
+      # @param name [String, Symbol] The identifier for the color space
+      # @param block [Proc] A block that configures the color space properties
+      # @return [Abachrome::ColorSpace] The newly created color space instance added to the registry
       def register(name, &block)
         registry[name.to_sym] = new(name, &block)
       end
 
+      # Aliases a color space name to an existing registered color space.
+      # 
+      # This method creates an alias for an existing color space in the registry,
+      # allowing the same color space to be accessed through multiple names.
+      # 
+      # @param name [Symbol, String] The existing color space name already registered
+      # @param aliased_name [Symbol, String] The new alias name to register
+      # @return [void]
       def alias(name, aliased_name)
         registry[aliased_name.to_sym] = registry[name.to_sym]
       end
 
+      # @param name [String, Symbol] The name of the color space to find
+      # @return [Abachrome::ColorSpace] The color space with the given name
+      # @raise [ArgumentError] If no color space with the given name exists in the registry
       def find(name)
         registry[name.to_sym] or raise ArgumentError, "Unknown color space: #{name}"
       end
@@ -22,37 +59,74 @@ module Abachrome
 
     attr_reader :name, :coordinates, :white_point, :color_model
 
+    # Initialize a new ColorSpace instance.
+    # 
+    # @param name [String, Symbol] The name of the color space, which will be converted to a symbol
+    # @return [Abachrome::ColorSpace] A new instance of ColorSpace
+    # @yield [self] Yields self to the block for configuration if a block is given
     def initialize(name)
       @name = name.to_sym
       yield self if block_given?
     end
 
+    # Sets the color coordinates for the current color space.
+    # 
+    # @param [Array] coords The coordinate values that define a color in this color space.
+    # Multiple arguments or a single flat array can be provided.
+    # @return [Array] The flattened array of coordinates.
     def coordinates=(*coords)
       @coordinates = coords.flatten
     end
 
+    # Sets the white point reference used by the color space.
+    # 
+    # The white point is a reference that defines what is considered "white" in a color space.
+    # Common values include :D50, :D65, etc.
+    # 
+    # @param point [Symbol, String] The white point reference to use (will be converted to Symbol)
+    # @return [Symbol] The newly set white point
     def white_point=(point)
       @white_point = point.to_sym
     end
 
+    # Sets the color model for the color space.
+    # 
+    # @param model [String, Symbol] The new color model to set for this color space
+    # @return [Symbol] The color model as a symbolized value
     def color_model=(model)
       @color_model = model.to_sym
     end
 
+    # Compares this ColorSpace instance with another to check for equality.
+    # 
+    # Two ColorSpace objects are considered equal if they have the same name.
+    # 
+    # @param other [Object] The object to compare against
+    # @return [Boolean] true if other is a ColorSpace with the same name, false otherwise
     def ==(other)
       return false unless other.is_a?(ColorSpace)
 
       name == other.name
     end
 
+    # Checks if two color spaces are equal.
+    # 
+    # @param other [Abachrome::ColorSpace] The color space to compare with
+    # @return [Boolean] true if the color spaces are equal, false otherwise
     def eql?(other)
       self == other
     end
 
+    # Returns a hash value for the color space based on its name.
+    # 
+    # @return [Integer] A hash value computed from the color space name that can be
+    # used for equality comparison and as a hash key.
     def hash
       name.hash
     end
 
+    # Returns the identifier for the color space, which is currently the same as its name.
+    # @return [String, Symbol] the identifier of the color space
     def id
       name
     end
@@ -94,4 +168,4 @@ module Abachrome
     s.white_point = :D65
     s.color_model = :oklch
   end
-end
+end

data/lib/abachrome/converter.rb

@@ -1,16 +1,53 @@
-# frozen_string_literal: true
+# Abachrome::Converter - Color space conversion registry and orchestration system
+#
+# This module provides the central registry and conversion orchestration for transforming colors
+# between different color spaces within the Abachrome library. It manages a registry of converter
+# classes that handle transformations between specific color space pairs (e.g., sRGB to OKLAB,
+# OKLCH to linear RGB) and provides the main conversion interface used throughout the library.
+#
+# Key features:
+# - Global registry for color space converter registration with automatic discovery
+# - Converter lookup and routing between source and target color spaces
+# - Automatic registration of all converter classes found in the Converters namespace
+# - Conversion orchestration that finds appropriate converters based on color model compatibility
+# - Support for multi-step conversions through intermediate color spaces when needed
+# - Integration with the ColorSpace system for proper color space identification
+#
+# The Converter system serves as the backbone for all color transformations in Abachrome,
+# enabling seamless conversion between any registered color spaces while maintaining the
+# precision and accuracy required for color science calculations. Converter classes follow
+# a naming convention (FromSpaceToSpace) for automatic registration and discovery.
 
 module Abachrome
   class Converter
     class << self
+      # Returns the registry hash used to store color space converters.
+      # 
+      # This method lazily initializes and returns the hash used internally to store
+      # converter mappings between different color spaces. This registry is a central
+      # repository that maps color space pairs to their appropriate conversion functions.
+      # 
+      # @return [Hash] The converter registry hash, mapping color space pairs to converter functions
       def registry
         @registry ||= {}
       end
 
+      # Register a converter class for transforming colors between two specific color spaces.
+      # 
+      # @param from_space [Symbol, String] The source color space identifier
+      # @param to_space [Symbol, String] The destination color space identifier
+      # @param converter_class [Class] The converter class that implements the transformation
+      # @return [Class] The registered converter class
       def register(from_space, to_space, converter_class)
         registry[[from_space.to_s, to_space.to_s]] = converter_class
       end
 
+      # Converts a color from its current color space to the specified target color space.
+      # 
+      # @param color [Abachrome::Color] The color to convert
+      # @param to_space_name [String, Symbol] The name of the target color space
+      # @return [Abachrome::Color] The color converted to the target color space
+      # @raise [RuntimeError] If no converter is found between the source and target color models
       def convert(color, to_space_name)
         to_space = ColorSpace.find(to_space_name)
         return color if color.color_space == to_space
@@ -23,7 +60,19 @@ module Abachrome
         converter.convert(color)
       end
 
-      # Automatically register all converters in the Converters namespace
+      # @api private
+      # @since 0.1.0
+      # @example
+      # converter = Abachrome::Converter.new
+      # converter.register_all_converters
+      # 
+      # Automatically registers all converter classes found in the Converters namespace.
+      # The method iterates through constants in the Converters module, identifies classes
+      # with naming pattern "FromSpaceToSpace" (e.g., LrgbToOklab), extracts the source
+      # and destination color spaces from the class name, and registers the converter
+      # class for the corresponding color space conversion.
+      # 
+      # @return [void]
       def register_all_converters
         Converters.constants.each do |const_name|
           const = Converters.const_get(const_name)
@@ -42,6 +91,11 @@ module Abachrome
 
       private
 
+      # Retrieves a converter function between two color spaces from the registry.
+      # 
+      # @param from_space_name [String, Symbol] The source color space name
+      # @param to_space_name [String, Symbol] The target color space name
+      # @return [Proc, nil] The conversion function if registered, or nil if no converter exists for the specified color spaces
       def find_converter(from_space_name, to_space_name)
         registry[[from_space_name.to_s, to_space_name.to_s]]
       end
@@ -56,4 +110,4 @@ module Abachrome
 
   # Auto-register all converters
   Converter.register_all_converters
-end
+end