kodachroma 1.0.0

data/lib/kodachroma/color/modifiers.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+module Kodachroma
+  class Color
+    # Methods that return a new modified {Color}.
+    module Modifiers
+      # Lightens the color by the given `amount`.
+      #
+      # @example
+      #   'red'.paint.lighten     #=> #ff3333
+      #   'red'.paint.lighten(20) #=> #ff6666
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def lighten(amount = 10)
+        hsl = self.hsl
+        hsl.l = clamp01(hsl.l + (amount / 100.0))
+        self.class.new(hsl, @format)
+      end
+
+      # Brightens the color by the given `amount`.
+      #
+      # @example
+      #   'red'.paint.brighten     #=> #ff1a1a
+      #   'red'.paint.brighten(20) #=> #ff3333
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def brighten(amount = 10)
+        # Don't include alpha
+        rgb = @rgb.to_a[0..2]
+        amount = (255 * (-amount / 100.0)).round
+
+        rgb.map! do |n|
+          [0, [255, n - amount].min].max
+        end
+
+        self.class.new(ColorModes::Rgb.new(*rgb), @format)
+      end
+
+      # Darkens the color by the given `amount`.
+      #
+      # @example
+      #   'red'.paint.darken     #=> #cc0000
+      #   'red'.paint.darken(20) #=> #990000
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def darken(amount = 10)
+        hsl = self.hsl
+        hsl.l = clamp01(hsl.l - (amount / 100.0))
+        self.class.new(hsl, @format)
+      end
+
+      # Desaturates the color by the given `amount`.
+      #
+      # @example
+      #   'red'.paint.desaturate     #=> #f20d0d
+      #   'red'.paint.desaturate(20) #=> #e61919
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def desaturate(amount = 10)
+        hsl = self.hsl
+        hsl.s = clamp01(hsl.s - (amount / 100.0))
+        self.class.new(hsl, @format)
+      end
+
+      # Saturates the color by the given `amount`.
+      #
+      # @example
+      #   '#123'.paint.saturate     #=> #0e2236
+      #   '#123'.paint.saturate(20) #=> #0a223a
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def saturate(amount = 10)
+        hsl = self.hsl
+        hsl.s = clamp01(hsl.s + (amount / 100.0))
+        self.class.new(hsl, @format)
+      end
+
+      # Converts the color to grayscale.
+      #
+      # @example
+      #   'green'.paint.grayscale #=> #404040
+      #
+      # @return [Color]
+      def grayscale
+        desaturate(100)
+      end
+
+      alias greyscale grayscale
+
+      # Sets color opacity to the given 'amount'.
+      #
+      # @example
+      #   'red'.paint.opacity(0.5)        #=> #ff0000
+      #   'red'.paint.opacity(0.5).to_rgb #=> 'rgba(255, 0, 0, 0.5)'
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def opacity(amount)
+        rgb = @rgb.to_a[0..2] + [amount]
+        self.class.new(ColorModes::Rgb.new(*rgb), @format)
+      end
+
+      # Spins around the hue color wheel by `amount` in degrees.
+      #
+      # @example
+      #   'red'.paint.spin(30) #=> #ff8000
+      #   'red'.paint.spin(60) #=> yellow
+      #   'red'.paint.spin(90) #=> #80ff00
+      #
+      # @param amount [Fixnum]
+      # @return       [Color]
+      def spin(amount)
+        hsl = self.hsl
+        hue = (hsl.h.round + amount) % 360
+        hsl.h = hue.negative? ? 360 + hue : hue
+        self.class.new(hsl, @format)
+      end
+    end
+  end
+end

data/lib/kodachroma/color/serializers.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+module Kodachroma
+  class Color
+    # Methods for serializing {Color} to different color mode string formats.
+    module Serializers
+      # Convert to hsv string.
+      #
+      # @example
+      #   'red'.paint.to_hsv                  #=> 'hsv(0, 100%, 100%)'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_hsv #=> 'hsva(0, 100%, 100%, 0.5)'
+      #
+      # @return [String]
+      def to_hsv
+        to_hs(:v)
+      end
+
+      # Convert to hsl string.
+      #
+      # @example
+      #   'red'.paint.to_hsl                  #=> 'hsl(0, 100%, 50%)'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_hsl #=> 'hsla(0, 100%, 50%, 0.5)'
+      #
+      # @return [String]
+      def to_hsl
+        to_hs(:l)
+      end
+
+      # Convert to hexadecimal string.
+      #
+      # @example
+      #   'red'.paint.to_hex                  #=> '#ff0000'
+      #   'red'.paint.to_hex(true)            #=> '#f00'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_hex #=> '#ff0000'
+      #
+      # @param allow_3 [true, false] output 3-character hexadecimal
+      #   if possible
+      # @return [String]
+      def to_hex(allow_3 = false)
+        "##{ to_basic_hex(allow_3) }"
+      end
+
+      # Convert to 8-character hexadecimal string. The highest order byte
+      #   (left most hexadecimal pair represents the alpha value).
+      #
+      # @example
+      #   'red'.paint.to_hex                  #=> '#ffff0000'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_hex #=> '#80ff0000'
+      #
+      # @return [String]
+      def to_hex8
+        "##{ to_basic_hex8 }"
+      end
+
+      # Convert to rgb string.
+      #
+      # @example
+      #   'red'.paint.to_rgb                  #=> 'rgb(255, 0, 0)'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_rgb #=> 'rgb(255, 0, 0, 0.5)'
+      #
+      # @return [String]
+      def to_rgb
+        middle = @rgb.to_a[0..2].map(&:round).join(', ')
+
+        with_alpha(:rgb, middle)
+      end
+
+      # Convert to named color if possible. If a color name can't be found, it
+      # returns `'<unknown>'` or the hexadecimal string based on the value of
+      # `hex_for_unknown`.
+      #
+      # @example
+      #   'red'.paint.to_name                  #=> 'red'
+      #   'rgba(255, 0, 0, 0.5)'.paint.to_name #=> '<unknown>'
+      #   '#00f'.paint.to_name                 #=> 'blue'
+      #   '#123'.paint.to_name(true)           #=> '#112233'
+      #
+      # @param hex_for_unknown [true, false] determine how unknown color names
+      #   should be returned
+      # @return [String]
+      def to_name(hex_for_unknown = false)
+        return 'transparent' if alpha.zero?
+
+        if alpha < 1 || (name = Kodachroma.name_from_hex(to_basic_hex(true))).nil?
+          if hex_for_unknown
+            to_hex
+          else
+            '<unknown>'
+          end
+        else
+          name
+        end
+      end
+
+      # Convert to a string based on the color format.
+      #
+      # @example
+      #   'red'.paint.to_s             #=> 'red'
+      #   'rgb(255, 0, 0)'.paint.to_s  #=> 'rgb(255, 0, 0)'
+      #   '#f00'.paint.to_s            #=> '#f00'
+      #   '#80ff0000'.paint.to_s(:rgb) #=> 'rgba(255, 0, 0, 0.5)'
+      #
+      # @param format [Symbol] the color format
+      # @return       [String]
+      def to_s(format = @format)
+        use_alpha = alpha < 1 && alpha >= 0 && /^hex(3|6)?$/ =~ format
+
+        return to_rgb if use_alpha
+
+        case format.to_s
+        when 'rgb'         then to_rgb
+        when 'hex', 'hex6' then to_hex
+        when 'hex3'        then to_hex(true)
+        when 'hex8'        then to_hex8
+        when 'hsl'         then to_hsl
+        when 'hsv'         then to_hsv
+        when 'name'        then to_name(true)
+        else                    to_hex
+        end
+      end
+
+      alias inspect to_s
+
+      # Converts to an instance of {ColorModes::Hsv}
+      # @return [ColorModes::Hsv]
+      def hsv
+        Converters::HsvConverter.convert_rgb(@rgb)
+      end
+
+      # Converts to an instance of {ColorModes::Hsl}
+      # @return [ColorModes::Hsl]
+      def hsl
+        Converters::HslConverter.convert_rgb(@rgb)
+      end
+
+      # Converts to an instance of {ColorModes::Rgb}
+      # @return [ColorModes::Rgb]
+      attr_reader :rgb
+
+      private
+
+      def to_basic_hex(allow_3 = false)
+        r, g, b = [@rgb.r, @rgb.g, @rgb.b].map do |n|
+          to_2char_hex(n)
+        end
+
+        if allow_3 && r[0] == r[1] && g[0] == g[1] && b[0] == b[1]
+          return "#{ r[0] }#{ g[0] }#{ b[0] }"
+        end
+
+        ([r, g, b].flatten * '').to_s
+      end
+
+      def to_basic_hex8
+        [
+          to_2char_hex(alpha * 255),
+          to_2char_hex(@rgb.r),
+          to_2char_hex(@rgb.g),
+          to_2char_hex(@rgb.b)
+        ].join
+      end
+
+      def to_hs(third)
+        name = "hs#{ third }"
+        color = send(name)
+
+        h = color.h.round
+        s = (color.s * 100).round
+        lv = (color.send(third) * 100).round
+
+        middle = "#{ h }, #{ s }%, #{ lv }%"
+
+        with_alpha(name, middle)
+      end
+
+      def with_alpha(mode, middle)
+        if alpha < 1
+          "#{ mode }a(#{ middle }, #{ rounded_alpha })"
+        else
+          "#{ mode }(#{ middle })"
+        end
+      end
+    end
+  end
+end

data/lib/kodachroma/color.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+module Kodachroma
+  # The main class to represent colors.
+  class Color
+    include Attributes
+    include Serializers
+    include Modifiers
+    include Helpers::Bounders
+
+    # @param input  [String, ColorModes::Rgb, ColorModes::Hsl, ColorModes::Hsv]
+    # @param format [Symbol] the color mode format
+    def initialize(input, format = nil)
+      @input = input
+      @rgb, gen_format = generate_rgb_and_format(input)
+      @format = format || gen_format
+    end
+
+    # Returns self. Useful for ducktyping situations with {String#paint}.
+    #
+    # @example
+    #   red = 'red'.paint
+    #
+    #   red.paint            #=> red
+    #   red.paint.equal? red #=> true
+    #
+    # @return [self]
+    def paint
+      self
+    end
+
+    # Returns true if `self` is equal to `other` and they're both instances of
+    # {Color}.
+    #
+    # @example
+    #   red = 'red'.paint
+    #   blue = 'blue'.paint
+    #
+    #   red.eql? red          #=> true
+    #   red.eql? blue         #=> false
+    #   red.eql? '#f00'.paint #=> true
+    #
+    # @param other [Color]
+    # @return      [true, false]
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+
+    # Returns true if both are equal in value.
+    #
+    # @example
+    #   red = 'red'.paint
+    #   blue = 'blue'.paint
+    #
+    #   red == red          #=> true
+    #   red == blue         #=> false
+    #   red == '#f00'.paint #=> true
+    #
+    # @param other [Color]
+    # @return      [true, false]
+    def ==(other)
+      to_hex == other.to_hex
+    end
+
+    # Returns the complementary color.
+    #
+    # @example
+    #   'red'.paint.complement #=> cyan
+    #
+    # @return [Color] the complementary color
+    def complement
+      hsl = self.hsl
+      hsl.h = (hsl.h + 180) % 360
+      self.class.new(hsl, @format)
+    end
+
+    # Returns an instance of {Harmonies} from which to call a palette method.
+    #
+    # @example
+    #   'red'.paint.palette #=> #<Kodachroma::Harmonies:0x007faf6b9f9148 @color=red>
+    #
+    # @return [Harmonies]
+    def palette
+      Harmonies.new(self)
+    end
+
+    # Defines a custom palette and immediately returns it. Uses a DSL inside
+    # `block` that mirrors the methods in {Color::Modifiers}.
+    #
+    # @example
+    #   'red'.paint.custom_palette do
+    #     spin 60
+    #     spin 180
+    #   end
+    #   #=> [red, yellow, cyan]
+    #
+    # @param block [Proc] the palette definition block
+    # @return [Array<Color>] palette array of colors
+    def custom_palette(&block)
+      PaletteBuilder.build(&block).evaluate(self)
+    end
+
+    private
+
+    def to_2char_hex(n)
+      n.round.to_s(16).rjust(2, '0')
+    end
+
+    def generate_rgb_and_format(input)
+      RgbGenerator.generate_rgb_and_format(input)
+    end
+  end
+end

data/lib/kodachroma/color_modes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Kodachroma
+  module ColorModes
+    class << self
+      private
+
+      # Builds a new color mode class.
+      #
+      # @param name  [String]        the class name
+      # @param attrs [Array<Symbol>] the instance attribute names
+      # @!macro [attach] build
+      #   @!parse class $1
+      #     attr_accessor :$2, :$3, :$4, :a
+      #
+      #     # @param $2 [Numeric]
+      #     # @param $3 [Numeric]
+      #     # @param $4 [Numeric]
+      #     # @param a [Numeric]
+      #     def initialize(${2-4}, a = 1)
+      #       @$2, @$3, @$4, @a = $2, $3, $4, a
+      #     end
+      #
+      #     # Returns the values `$2`, `$3`, `$4`, and `a` as an array.
+      #     #
+      #     # @return [Array<Numeric>]
+      #     def to_a
+      #       [@$2, @$3, @$4, @a]
+      #     end
+      #
+      #     alias_method :to_ary, :to_a
+      #     end
+      def build(name, *attrs)
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          class #{ name }
+            attr_accessor #{ (attrs + [:a]).map { |attr| ":#{ attr }" } * ', ' }
+
+            def initialize(#{ attrs * ', ' }, a = 1)
+              #{ attrs.map { |attr| "@#{ attr }" } * ', ' }, @a = #{ attrs * ', ' }, a
+            end
+
+            def to_a
+              [#{ attrs.map { |attr| "@#{ attr }" } * ', ' }, @a]
+            end
+
+            alias_method :to_ary, :to_a
+          end
+        EOS
+      end
+    end
+
+    build 'Rgb', :r, :g, :b
+    build 'Hsl', :h, :s, :l
+    build 'Hsv', :h, :s, :v
+  end
+end