color_palette 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 235899892340cee9ffb5e918be86839bfe208d04
+  data.tar.gz: ed25701723e172dceec1747e3c704963f69b423a
+SHA512:
+  metadata.gz: a3e348480f756482b569bcf3e4eca879ce7212cea5c8bb47476f16250a90e88742d27a31cb2794fee020393a7fd22d8d9cf159ea9d9ecdfed7f49fcdefb09c8d
+  data.tar.gz: 551fb57fe65b466934223ff6d72fe7c11a8c9a5bdccda3a5b8d6d9f9e2d1d8a4c4adde58f7d88e14c3741542da3a75b37861756d3615caca96ba4e0a422e0d3f

data/lib/color_palette.rb

@@ -0,0 +1,28 @@
+
+module ColorPalette
+
+  def self.unidirectional(end_color, palette_size, start_color="#ffffff", return_color_strings=true)
+    start_color = ColorPalette::Color::RGB.from_string(start_color)
+    end_color = ColorPalette::Color::RGB.from_string(end_color)
+
+    delta_r = (end_color.r - start_color.r) / (palette_size - 1)
+    delta_g = (end_color.g - start_color.g) / (palette_size - 1)
+    delta_b = (end_color.b - start_color.b) / (palette_size - 1)
+
+    palette = []
+    palette_size.times do |i|
+      color = ColorPalette::Color::RGB.from_increment_in_other_color(start_color, i*delta_r, i*delta_g, i*delta_b)
+      palette << color 
+    end
+
+    if return_color_strings
+      palette.map(&:to_s)
+    else
+      palette
+    end
+  end
+
+end
+
+require 'color_palette/version'
+require 'color_palette/color/rgb'

data/lib/color_palette/color/rgb.rb

@@ -0,0 +1,296 @@
+# Inspired by the work of 2005 Austin Ziegler (http://rubyforge.org/ruby-pdf/)
+
+# An RGB colour object.
+module ColorPalette::Color
+  class RGB
+
+    attr_accessor :r, :g, :b
+
+    # Creates an RGB colour object from percentages 0..100.
+    def self.from_percentages(r=0, g=0, b=0)
+      from_fractions(r/100.0, g/100.0, b/100.0)
+    end
+    
+    # Creates an RGB colour object from integer values 0..255.
+    def self.from_integers(r=0, g=0, b=0)
+      from_fractions(r/255.0, g/255.0, b/255.0)
+    end
+
+    # Creates an RGB colour object from fractional values 0..1.
+    def self.from_fractions(r=0.0, g=0.0, b=0.0)
+      color = ColorPalette::Color::RGB.new
+      color.r = r
+      color.g = g
+      color.b = b
+      color
+    end
+
+    # Creates an RGB color object from a hex string (e.g.,
+    #
+    #   Color::RGB.from_string("bef")
+    #   Color::RGB.from_string("#bef")
+    #   Color::RGB.from_string("#dabbec")
+    #   Color::RGB.from_string("dabbec")
+    def self.from_string(color_string)
+      # remove hashtag if necessary
+      color_string = color_string.gsub(%r{[#;]}, '')
+      
+      case color_string.size 
+      when 3
+        colors = color_string.scan(/[0-9A-Fa-f]/).map { |color_value| (color_value * 2).to_i(16) }
+      when 6
+        colors = color_string.scan(/[0-9A-Fa-f]{2}/).map { |color_value| color_value.to_i(16) }
+      else
+        raise ArgumentError
+      end
+
+      from_integers(*colors)
+    end
+
+    def self.from_increment_in_other_color(other_color, r_increment, g_increment, b_increment)
+      color = from_fractions(other_color.r, other_color.g, other_color.b)
+      color.r = color.r + r_increment
+      color.g = color.g + g_increment
+      color.b = color.b + b_increment
+      color
+    end
+
+    # Compares the other colour to this one. This will report that two
+    # RGB colours are equivalent if all component values are within 1e-4
+    # (0.0001) of each other.
+    def ==(other_color)
+      # The other color will be converted to RGB before comparison. If there is no #to_rgb
+      # conversion, this will raise an exception.
+      other_color = other_color.to_rgb
+
+      if other_color.is_a?(ColorPalette::Color::RGB)
+        return ((@r - other_color.r).abs <= 1e-4) && 
+          ((@g - other_color.g).abs <= 1e-4) && 
+          ((@b - other_color.b).abs <= 1e-4)
+      end
+
+      return false
+    end
+
+    # Creates a black RGB colour object. Please use class methods from_* to create other colors.
+    def initialize
+      self.r = 0.0
+      self.g = 0.0
+      self.b = 0.0
+    end
+
+    def to_s
+      r_integer = (r * 255).round
+      r_integer = 255 if r_integer > 255
+
+      g_integer = (g * 255).round
+      g_integer = 255 if g_integer > 255
+
+      b_integer = (b * 255).round
+      b_integer = 255 if b_integer > 255
+
+      "#%02x%02x%02x" % [ r_integer, g_integer, b_integer ]
+    end
+
+    def to_rgb
+      self
+    end
+
+    # overload setters to garantee storing in floats and in range 0..1
+    def r=(red)
+      red = 1.0 if red > 1
+      red = 0.0 if red < 0
+      @r = red.to_f
+    end
+
+    def g=(green)
+      green = 1.0 if green > 1
+      green = 0.0 if green < 0
+      @g = green.to_f
+    end
+
+    def b=(blue)
+      blue = 1.0 if blue > 1
+      blue = 0.0 if blue < 0
+      @b = blue.to_f
+    end
+
+    # # Converts the RGB colour to CMYK. Most colour experts strongly suggest
+    # # that this is not a good idea (some even suggesting that it's a very
+    # # bad idea). CMYK represents additive percentages of inks on white
+    # # paper, whereas RGB represents mixed colour intensities on a black
+    # # screen.
+    # #
+    # # However, the colour conversion can be done. The basic method is
+    # # multi-step:
+    # #
+    # # 1. Convert the R, G, and B components to C, M, and Y components.
+    # #     c = 1.0 – r
+    # #     m = 1.0 – g
+    # #     y = 1.0 – b
+    # # 2. Compute the minimum amount of black (K) required to smooth the
+    # #    colour in inks.
+    # #     k = min(c, m, y)
+    # # 3. Perform undercolour removal on the C, M, and Y components of the
+    # #    colours because less of each colour is needed for each bit of
+    # #    black. Also, regenerate the black (K) based on the undercolour
+    # #    removal so that the colour is more accurately represented in ink.
+    # #     c = min(1.0, max(0.0, c – UCR(k)))
+    # #     m = min(1.0, max(0.0, m – UCR(k)))
+    # #     y = min(1.0, max(0.0, y – UCR(k)))
+    # #     k = min(1.0, max(0.0, BG(k)))
+    # #
+    # # The undercolour removal function and the black generation functions
+    # # return a value based on the brightness of the RGB colour.
+    # def to_cmyk
+    #   c = 1.0 - @r.to_f
+    #   m = 1.0 - @g.to_f
+    #   y = 1.0 - @b.to_f
+
+    #   k = [c, m, y].min
+    #   k = k - (k * brightness)
+
+    #   c = [1.0, [0.0, c - k].max].min
+    #   m = [1.0, [0.0, m - k].max].min
+    #   y = [1.0, [0.0, y - k].max].min
+    #   k = [1.0, [0.0, k].max].min
+
+    #   Color::CMYK.from_fraction(c, m, y, k)
+    # end
+
+    # # Returns the YIQ (NTSC) colour encoding of the RGB value.
+    # def to_yiq
+    #   y = (@r * 0.299) + (@g *  0.587) + (@b *  0.114)
+    #   i = (@r * 0.596) + (@g * -0.275) + (@b * -0.321)
+    #   q = (@r * 0.212) + (@g * -0.523) + (@b *  0.311)
+    #   Color::YIQ.from_fraction(y, i, q)
+    # end
+
+    # # Returns the HSL colour encoding of the RGB value.
+    # def to_hsl
+    #   min   = [ @r, @g, @b ].min
+    #   max   = [ @r, @g, @b ].max
+    #   delta = (max - min).to_f
+
+    #   lum   = (max + min) / 2.0
+
+    #   if delta <= 1e-5  # close to 0.0, so it's a grey
+    #     hue = 0
+    #     sat = 0
+    #   else
+    #     if (lum - 0.5) <= 1e-5
+    #       sat = delta / (max + min).to_f
+    #     else
+    #       sat = delta / (2 - max - min).to_f
+    #     end
+
+    #     if @r == max
+    #       hue = (@g - @b) / delta.to_f
+    #     elsif @g == max
+    #       hue = (2.0 + @b - @r) / delta.to_f
+    #     elsif (@b - max) <= 1e-5
+    #       hue = (4.0 + @r - @g) / delta.to_f
+    #     end
+    #     hue /= 6.0
+
+    #     hue += 1 if hue < 0
+    #     hue -= 1 if hue > 1
+    #   end
+    #   Color::HSL.from_fraction(hue, sat, lum)
+    # end
+
+    # # Mix the RGB hue with White so that the RGB hue is the specified
+    # # percentage of the resulting colour. Strictly speaking, this isn't a
+    # # darken_by operation.
+    # def lighten_by(percent)
+    #   mix_with(White, percent)
+    # end
+
+    # # Mix the RGB hue with Black so that the RGB hue is the specified
+    # # percentage of the resulting colour. Strictly speaking, this isn't a
+    # # darken_by operation.
+    # def darken_by(percent)
+    #   mix_with(Black, percent)
+    # end
+
+    # # Mix the mask colour (which must be an RGB object) with the current
+    # # colour at the stated opacity percentage (0..100).
+    # def mix_with(mask, opacity)
+    #   opacity /= 100.0
+    #   rgb = self.dup
+
+    #   rgb.r = (@r * opacity) + (mask.r * (1 - opacity))
+    #   rgb.g = (@g * opacity) + (mask.g * (1 - opacity))
+    #   rgb.b = (@b * opacity) + (mask.b * (1 - opacity))
+
+    #   rgb
+    # end
+
+    # # Returns the brightness value for a colour, a number between 0..1.
+    # # Based on the Y value of YIQ encoding, representing luminosity, or
+    # # perceived brightness.
+    # #
+    # # This may be modified in a future version of color-tools to use the
+    # # luminosity value of HSL.
+    # def brightness
+    #   to_yiq.y
+    # end
+
+    # def to_grayscale
+    #   Color::GrayScale.from_fraction(to_hsl.l)
+    # end
+
+    # alias to_greyscale to_grayscale
+
+    # # Returns a new colour with the brightness adjusted by the specified
+    # # percentage. Negative percentages will darken the colour; positive
+    # # percentages will brighten the colour.
+    # #
+    # #   Color::RGB::DarkBlue.adjust_brightness(10)
+    # #   Color::RGB::DarkBlue.adjust_brightness(-10)
+    # def adjust_brightness(percent)
+    #   percent /= 100.0
+    #   percent += 1.0
+    #   percent  = [ percent, 2.0 ].min
+    #   percent  = [ 0.0, percent ].max
+
+    #   hsl      = to_hsl
+    #   hsl.l   *= percent
+    #   hsl.to_rgb
+    # end
+
+    # # Returns a new colour with the saturation adjusted by the specified
+    # # percentage. Negative percentages will reduce the saturation; positive
+    # # percentages will increase the saturation.
+    # #
+    # #   Color::RGB::DarkBlue.adjust_saturation(10)
+    # #   Color::RGB::DarkBlue.adjust_saturation(-10)
+    # def adjust_saturation(percent)
+    #   percent  /= 100.0
+    #   percent  += 1.0
+    #   percent  = [ percent, 2.0 ].min
+    #   percent  = [ 0.0, percent ].max
+
+    #   hsl      = to_hsl
+    #   hsl.s   *= percent
+    #   hsl.to_rgb
+    # end
+
+    # # Returns a new colour with the hue adjusted by the specified
+    # # percentage. Negative percentages will reduce the hue; positive
+    # # percentages will increase the hue.
+    # #
+    # #   Color::RGB::DarkBlue.adjust_hue(10)
+    # #   Color::RGB::DarkBlue.adjust_hue(-10)
+    # def adjust_hue(percent)
+    #   percent  /= 100.0
+    #   percent  += 1.0
+    #   percent  = [ percent, 2.0 ].min
+    #   percent  = [ 0.0, percent ].max
+
+    #   hsl      = to_hsl
+    #   hsl.h   *= percent
+    #   hsl.to_rgb
+    # end
+  end
+end

data/lib/color_palette/version.rb

@@ -0,0 +1,3 @@
+module ColorPalette
+  VERSION = '0.0.1'
+end

data/spec/color_palette_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ColorPalette do
+  describe '.unidirectional' do
+    it 'should return an array of colors starting with white and ending with the specified color' do
+      colors = ColorPalette.unidirectional('#ff0000', 5)
+      expect(colors.size).to be == 5
+      expect(colors.first).to be == '#ffffff'
+      expect(colors.last).to be == '#ff0000'
+    end
+
+    it 'should accept a color as start color' do
+      colors = ColorPalette.unidirectional('#ff0000', 5, '#000000')
+      expect(colors.size).to be == 5
+      expect(colors.first).to be == '#000000'
+      expect(colors.last).to be == '#ff0000'
+    end
+
+    it 'should accept many formats of color strings' do
+      expect { ColorPalette.unidirectional('#ff0000', 5, '#000000') }.to_not raise_error
+      expect { ColorPalette.unidirectional('#f00', 5, '#00F') }.to_not raise_error
+      expect { ColorPalette.unidirectional('ff0000', 5, '000000') }.to_not raise_error
+      expect { ColorPalette.unidirectional('f00', 5, '00F') }.to_not raise_error
+    end
+  end 
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: color_palette
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Henrique Gubert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: This gem aims to be as simple as possible helping you to create palettes
+  dynamically. No more hard-coding a lot of colors in your ruby code!
+email:
+- guberthenrique@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/color_palette.rb
+- lib/color_palette/color/rgb.rb
+- lib/color_palette/version.rb
+- spec/color_palette_spec.rb
+homepage: https://github.com/hsgubert/color_palette
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Simple gem to build palettes (sequence of colors) of various types based
+  on one or more reference colors.
+test_files:
+- spec/color_palette_spec.rb