kodachroma 1.0.0

data/lib/kodachroma/rgb_generator/base.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    # Base rgb generator class.
+    # @abstract
+    class Base
+      include Helpers::Bounders
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_hex_string_values.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromHexStringValues < Base
+      # @param format [Symbol] color format
+      # @param r      [String] red value
+      # @param g      [String] green value
+      # @param b      [String] blue value
+      # @param a      [String] alpha value
+      def initialize(format, r, g, b, a = 'ff')
+        @format = format || :hex
+        @r = r
+        @g = g
+        @b = b
+        @a = a
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        r, g, b = [@r, @g, @b].map { |n| n.to_i(16) }
+        a = @a.to_i(16) / 255.0
+        [ColorModes::Rgb.new(r, g, b, a), @format]
+      end
+
+      class << self
+        # Generates a {ColorModes::Rgb} from 3-character hexadecimal.
+        # @return [ColorModes::Rgb]
+        #
+        # @param format [Symbol] color format
+        # @param r      [String] red value
+        # @param g      [String] green value
+        # @param b      [String] blue value
+        def from_hex3(format, r, g, b)
+          new(format || :hex3, r * 2, g * 2, b * 2)
+        end
+
+        # Generates a {ColorModes::Rgb} from 6-character hexadecimal.
+        # @return [ColorModes::Rgb]
+        #
+        # @param format [Symbol] color format
+        # @param r      [String] red value
+        # @param g      [String] green value
+        # @param b      [String] blue value
+        def from_hex6(format, r, g, b)
+          new(format, r, g, b)
+        end
+
+        # Generates a {ColorModes::Rgb} from 8-character hexadecimal.
+        # @return [ColorModes::Rgb]
+        #
+        # @param format [Symbol] color format
+        # @param r      [String] red value
+        # @param g      [String] green value
+        # @param b      [String] blue value
+        # @param a      [String] alpha value
+        def from_hex8(format, a, r, g, b)
+          new(format || :hex8, r, g, b, a)
+        end
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_hsl.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromHsl < Base
+      # @param format [Symbol] color format
+      # @param hsl    [ColorModes::Hsl]
+      def initialize(format, hsl)
+        @format = format
+        @hsl = hsl
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        FromHslValues.new(@format, *@hsl.to_a).generate
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_hsl_values.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromHslValues < Base
+      # @param format [Symbol]          color format
+      # @param h      [String, Numeric] hue value
+      # @param s      [String, Numeric] saturation value
+      # @param l      [String, Numeric] lightness value
+      # @param a      [String, Numeric] alpha value
+      def initialize(format, h, s, l, a = 1)
+        s = to_percentage(s)
+        l = to_percentage(l)
+
+        @format = format || :hsl
+        @hsl = ColorModes::Hsl.new(h, s, l, a)
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        [Converters::RgbConverter.convert_hsl(@hsl), @format]
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_hsv.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromHsv < Base
+      # @param format [Symbol] color format
+      # @param hsv    [ColorModes::Hsv]
+      def initialize(format, hsv)
+        @format = format
+        @hsv = hsv
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        FromHsvValues.new(@format, *@hsv.to_a).generate
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_hsv_values.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromHsvValues < Base
+      # @param format [Symbol]          color format
+      # @param h      [String, Numeric] hue value
+      # @param s      [String, Numeric] saturation value
+      # @param v      [String, Numeric] value value
+      # @param a      [String, Numeric] alpha value
+      def initialize(format, h, s, v, a = 1)
+        s = to_percentage(s)
+        v = to_percentage(v)
+
+        @format = format || :hsv
+        @hsv = ColorModes::Hsv.new(h, s, v, a)
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        [Converters::RgbConverter.convert_hsv(@hsv), @format]
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_rgb.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromRgb < Base
+      # @param format [Symbol] color format
+      # @param rgb    [ColorModes::Rgb]
+      def initialize(format, rgb)
+        @format = format
+        @rgb = rgb
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        FromRgbValues.new(@format, @rgb.r, @rgb.g, @rgb.b, @rgb.a).generate
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_rgb_values.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromRgbValues < Base
+      # @param format [Symbol]          color format
+      # @param r      [String, Numeric] red value
+      # @param g      [String, Numeric] green value
+      # @param b      [String, Numeric] blue value
+      # @param a      [String, Numeric] alpha value
+      def initialize(format, r, g, b, a = 1)
+        @format = format || :rgb
+        @r = r
+        @g = g
+        @b = b
+        @a = a
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        r, g, b = [@r, @g, @b].map { |n| bound01(n, 255) * 255 }
+        a = bound_alpha(@a)
+        [ColorModes::Rgb.new(r, g, b, a), @format]
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator/from_string.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module Kodachroma
+  module RgbGenerator
+    class FromString < Base
+      # Returns the regex matchers and rgb generation classes for various
+      # string color formats.
+      #
+      # @api private
+      # @return [Hash<Symbol, Hash>]
+      def self.matchers
+        @matchers ||= begin
+          # TinyColor.js matchers
+          css_int = '[-\\+]?\\d+%?'
+          css_num = '[-\\+]?\\d*\\.\\d+%?'
+          css_unit = "(?:#{ css_num })|(?:#{ css_int })"
+          permissive_prefix = '[\\s|\\(]+('
+          permissive_delim = ')[,|\\s]+('
+          permissive_suffix = ')\\s*\\)?'
+          permissive_match3 = "#{ permissive_prefix }#{ [css_unit] * 3 * permissive_delim }#{ permissive_suffix }"
+          permissive_match4 = "#{ permissive_prefix }#{ [css_unit] * 4 * permissive_delim }#{ permissive_suffix }"
+          hex_match = '[0-9a-fA-F]'
+
+          {
+            rgb: { regex: /rgb#{ permissive_match3 }/, class_name: :FromRgbValues },
+            rgba: { regex: /rgba#{ permissive_match4 }/, class_name: :FromRgbValues },
+            hsl: { regex: /hsl#{ permissive_match3 }/, class_name: :FromHslValues },
+            hsla: { regex: /hsla#{ permissive_match4 }/, class_name: :FromHslValues },
+            hsv: { regex: /hsv#{ permissive_match3 }/, class_name: :FromHsvValues },
+            hsva: { regex: /hsva#{ permissive_match4 }/, class_name: :FromHsvValues },
+            hex3: { regex: /^#?#{ "(#{ hex_match }{1})" * 3 }$/, class_name: :FromHexStringValues, builder: :from_hex3 },
+            hex6: { regex: /^#?#{ "(#{ hex_match }{2})" * 3 }$/, class_name: :FromHexStringValues, builder: :from_hex6 },
+            hex8: { regex: /^#?#{ "(#{ hex_match }{2})" * 4 }$/, class_name: :FromHexStringValues, builder: :from_hex8 }
+          }.freeze
+        end
+      end
+
+      # @param format [Symbol] unused
+      # @param input  [String] input to parse
+      def initialize(_format, input)
+        @input = normalize_input(input)
+      end
+
+      # Generates a {ColorModes::Rgb}.
+      # @return [ColorModes::Rgb]
+      def generate
+        get_generator.generate
+      end
+
+      private
+
+      def get_generator
+        if color = Kodachroma.hex_from_name(@input)
+          format = :name
+        elsif @input == 'transparent'
+          return FromRgbValues.new(:name, 0, 0, 0, 0)
+        else
+          format = nil
+          color = @input
+        end
+
+        match = nil
+
+        _, hash = matchers.find do |_, h|
+          !(match = h[:regex].match(color)).nil?
+        end
+
+        if match.nil?
+          raise Errors::UnrecognizedColor, "Unrecognized color `#{ color }'"
+        end
+
+        build_generator(match[1..-1], hash[:class_name], hash[:builder], format)
+      end
+
+      def build_generator(args, class_name, builder, format)
+        builder ||= :new
+        klass = RgbGenerator.const_get(class_name)
+        klass.__send__(builder, *([format] + args))
+      end
+
+      def normalize_input(input)
+        input.strip.downcase
+      end
+
+      def matchers
+        self.class.matchers
+      end
+    end
+  end
+end

data/lib/kodachroma/rgb_generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Kodachroma
+  # Main module to generate an instance of {ColorModes::Rgb} from several
+  # possible inputs.
+  module RgbGenerator
+    class << self
+      # Generates an instance of {ColorModes::Rgb} as well as color format
+      #   symbol.
+      #
+      # @param input [String, ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+      # @return      [[ColorModes::Rgb, Symbol]]
+      def generate_rgb_and_format(input)
+        get_generator(input).generate.tap do |(rgb)|
+          rgb.r = round(rgb.r)
+          rgb.g = round(rgb.g)
+          rgb.b = round(rgb.b)
+        end
+      end
+
+      private
+
+      def get_generator(input)
+        klass = case input
+                when String          then FromString
+                when ColorModes::Hsl then FromHsl
+                when ColorModes::Hsv then FromHsv
+                when ColorModes::Rgb then FromRgb
+                end
+
+        klass.new(nil, input)
+      end
+
+      def round(n)
+        n < 1 ? n.round : n
+      end
+    end
+  end
+end

data/lib/kodachroma/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Kodachroma
+  VERSION = '1.0.0'
+end

data/lib/kodachroma.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+# General
+require 'kodachroma/version'
+require 'kodachroma/errors'
+require 'yaml'
+
+# Modules
+require 'kodachroma/helpers/bounders'
+
+# Color
+require 'kodachroma/color/attributes'
+require 'kodachroma/color/serializers'
+require 'kodachroma/color/modifiers'
+require 'kodachroma/color'
+require 'kodachroma/color_modes'
+
+# Palettes
+require 'kodachroma/harmonies'
+require 'kodachroma/palette_builder'
+
+# RGB Generators
+require 'kodachroma/rgb_generator'
+require 'kodachroma/rgb_generator/base'
+require 'kodachroma/rgb_generator/from_string'
+require 'kodachroma/rgb_generator/from_rgb_values'
+require 'kodachroma/rgb_generator/from_rgb'
+require 'kodachroma/rgb_generator/from_hsl_values'
+require 'kodachroma/rgb_generator/from_hsl'
+require 'kodachroma/rgb_generator/from_hsv_values'
+require 'kodachroma/rgb_generator/from_hsv'
+require 'kodachroma/rgb_generator/from_hex_string_values'
+
+# Converters
+require 'kodachroma/converters/base'
+require 'kodachroma/converters/rgb_converter'
+require 'kodachroma/converters/hsl_converter'
+require 'kodachroma/converters/hsv_converter'
+
+# The main module.
+module Kodachroma
+  class << self
+    # Returns a new instance of color. Supports hexadecimal, rgb, rgba, hsl,
+    # hsla, hsv, hsva, and named color formats.
+    #
+    # @api public
+    #
+    # @example
+    #   Kodachroma.paint('red')
+    #   Kodachroma.paint('#f00')
+    #   Kodachroma.paint('#ff0000')
+    #   Kodachroma.paint('rgb(255, 0, 0)')
+    #   Kodachroma.paint('hsl(0, 100%, 50%)')
+    #   Kodachroma.paint('hsv(0, 100%, 100%)')
+    #
+    # @param input [String] the color
+    # @return      [Color]  an instance of {Color}
+    def paint(input)
+      Color.new(input)
+    end
+
+    # Returns the hexadecimal string representation of a named color and nil
+    # if no match is found. Favors 3-character hexadecimal if possible.
+    #
+    # @example
+    #   Kodachroma.hex_from_name('red')       #=> 'f00'
+    #   Kodachroma.hex_from_name('aliceblue') #=> 'f0f8ff'
+    #   Kodachroma.hex_from_name('foo')       #=> nil
+    #
+    # @param name [String]      the color name
+    # @return     [String, nil] the color as a string hexadecimal or nil
+    def hex_from_name(name)
+      named_colors_map[name]
+    end
+
+    # Returns the color name of a hexadecimal color if available and nil if no
+    # match is found. Requires 3-character hexadecimal input for applicable
+    # colors.
+    #
+    # @example
+    #   Kodachroma.name_from_hex('f00')    #=> 'red'
+    #   Kodachroma.name_from_hex('f0f8ff') #=> 'aliceblue'
+    #   Kodachroma.name_from_hex('123123') #=> nil
+    #
+    # @param hex [String]      the hexadecimal color
+    # @return    [String, nil] the color name or nil
+    def name_from_hex(hex)
+      hex_named_colors_map[hex]
+    end
+
+    # Defines a custom palette for use by {Color#palette}. Uses a DSL inside
+    # `block` that mirrors the methods in {Color::Modifiers}.
+    #
+    # @example
+    #   'red'.paint.palette.respond_to? :my_palette #=> false
+    #
+    #   Kodachroma.define_palette :my_palette do
+    #     spin 60
+    #     spin 120
+    #     spin 240
+    #   end
+    #
+    #   'red'.paint.palette.respond_to? :my_palette #=> true
+    #
+    # @param name  [Symbol, String]              the name of the custom palette
+    # @param block [Proc]                        the palette definition block
+    # @raise       [Errors::PaletteDefinedError] if the palette is already defined
+    # @return      [Symbol, String]              the name of the custom palette
+    def define_palette(name, &block)
+      if Harmonies.method_defined? name
+        raise Errors::PaletteDefinedError, "Palette `#{ name }' already exists"
+      end
+
+      palette_evaluator = PaletteBuilder.build(&block)
+
+      Harmonies.send(:define_method, name) do
+        palette_evaluator.evaluate(@color)
+      end
+    end
+
+    private
+
+    def hex_named_colors_map
+      @hex_named_colors_map ||= named_colors_map.invert
+    end
+
+    def named_colors_map
+      @named_colors ||= YAML.load_file(File.expand_path('support/named_colors.yml', __dir__))
+    end
+  end
+end