color_fun 1.0.0

data/README.md

@@ -0,0 +1,66 @@
+# Color Fun
+
+This gem provides a few useful methods associated with colors for use in 
+web-based applications. This was all written for a little app we're working on.
+
+## Example Usage
+
+```ruby
+# Initializing colors
+red   = ColorFun::RBG.new(255,0,0)         # =>  #<ColorFun::RGB:0x007f9 @red=255, @green=0, @blue=0>
+red   = ColorFun::RBG.from_hex('ff0000')   # =>  #<ColorFun::RGB:0x007f9 @red=255, @green=0, @blue=0>
+
+# Access colors
+red.red                                 # => 255
+red.green                               # => 0
+red.blue                                # => 0
+
+# Return perceived brightness of the colors
+red.perceived_brightness                # => 139.43627576782163
+red.dark?                               # => true
+red.light?                              # => false
+
+# Return a lighter/darker version of the color. Accepts (optionally) a percentage.
+red.lighter                             # => #<ColorFun::RGB:0x007fa @red=255, @green=127, @blue=127>
+red.lighter(75)                         # => #<ColorFun::RGB:0x007fa @red=255, @green=191, @blue=191>
+red.darker                              # => #<ColorFun::RGB:0x007fa @red=127, @green=0, @blue=0>
+red.darker(25)                          # => #<ColorFun::RGB:0x007fa @red=191, @green=0, @blue=0>
+
+# Return a hex value for the color
+red.hex                                 # => 'ff0000'
+
+# Return an HSL object for the color
+red.hsl                                 # => #<ColorFun::HSL:0x007fa @hue=0.0, @saturation=100.0, @lightness=100.0>
+red.hsl.hue                             # => 0.0
+red.hsl.saturation                      # => 100.0
+red.hsl.lightness                       # => 100.0
+red.hsl.name                            # => 'Red'
+
+# Quick access to key colors
+red     = ColorFun::RGB.red
+green   = ColorFun::RGB.green
+blue    = ColorFun::RGB.blue
+```
+
+## Gradients
+
+Another cool little feature in here is the ability to work with gradients. This will automatically
+create a linear gradient between colours you provide.
+
+### Example usage with gradientds
+
+```ruby
+gradient              = ColorFun::Gradient.new('e10025', '00a5e2', '7ae100')
+
+# Optionally, set the resolution for the gradient (default is 100)
+gradient.resolution   = 100
+
+# Get the colour of the gradient at a specific point
+gradient.at(50)      # => #<ColorFun::RGB:0x007fb @red=0, @green=165, @blue=226>
+gradient.at(25)      # => #<ColorFun::RGB:0x007fb @red=112, @green=82, @blue=131>
+gradient.at(100)     # => #<ColorFun::RGB:0x007fb @red=122, @green=225, @blue=0>
+gradient.at(0)       # => #<ColorFun::RGB:0x007fb @red=225, @green=0, @blue=37>
+
+# Return all the points for each part of the gradient
+gradient.points      # => Array of all points as if you called the at method on each
+```

data/color_fun.gemspec

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'color_fun'
+
+Gem::Specification.new do |s|
+  s.name = 'color_fun'
+  s.version = ColorFun::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A little gem for playing with colors in Ruby"
+  s.description = s.summary
+  s.files = Dir["**/*"]
+  s.bindir = "bin"
+  s.require_path = 'lib'
+  s.has_rdoc = false
+  s.author = "Adam Cooke"
+  s.email = "adam@atechmedia.com"
+  s.homepage = "http://atechmedia.com"
+end

data/lib/color_fun.rb

@@ -0,0 +1,6 @@
+require 'color_fun/rgb'
+require 'color_fun/hsl'
+require 'color_fun/gradient'
+module ColorFun
+  VERSION = '1.0.0'
+end

data/lib/color_fun/gradient.rb

@@ -0,0 +1,51 @@
+module ColorFun
+  class Gradient
+    
+    attr_accessor :resolution
+    
+    def initialize(*colors)
+      @colors = colors
+      @resolution = 100
+    end
+    
+    def colors
+      @colors.map do |color|
+        color.scan(/../).map { |c| c.to_i(16) }
+      end
+    end
+    
+    def differences
+      colors[0..-2].each_with_index.map do |color, i|
+        color.dup.each_with_index.map { |c, j| colors[i + 1][j] - c }
+      end
+    end
+    
+    def color_window_size
+      @resolution / differences.size
+    end
+    
+    def points
+      @resolution.times.map { |i| self.at(i) }
+    end
+    
+    def at(point)
+      window = point / color_window_size
+
+      if point == @resolution
+        difference = differences.last
+        position = color_window_size
+        window = differences.size - 1
+      else
+        difference = differences[window]
+        position = point % color_window_size
+      end
+
+      new_colors = difference.each_with_index.map do |dc, i|
+        (colors[window][i] + (dc * (position.to_f / color_window_size.to_f))).to_i
+      end
+      
+      ColorFun::RGB.new(*new_colors)
+    end
+    
+  end
+end

data/lib/color_fun/hsl.rb

@@ -0,0 +1,67 @@
+module ColorFun
+  class HSL
+    
+    attr_accessor :hue, :saturation, :lightness
+    
+    def initialize(h, s, l)
+      @hue, @saturation, @lightness = h, s, l
+    end
+    
+    # Return a name for this colour
+    def name
+      Array.new.tap do |s|
+        if @saturation == 0 && @lightness == 0
+          s << "Black"
+        elsif @saturation == 0 && @lightness == 100
+          s << "White"
+        elsif @saturation <= 15 && @saturation > 0
+          s << "Light"
+        elsif @lightness < 40 && @saturation > 0
+          s << "Dark"
+        end
+        
+        if @saturation > 0
+          s << case @hue
+          when 0..8, 347..360 then 'Red'
+          when 9..42          then 'Orange'
+          when 43..61         then 'Yellow'
+          when 62..158        then 'Green'
+          when 159..264       then 'Blue'
+          when 265..285       then 'Purple'
+          when 286..346       then 'Pink'
+          end
+        else
+          s << "Grey"
+        end
+      end.join(' ')
+    end
+    
+    # Create a new HSL object based on the RGB values
+    def self.from_rbg(r,g,b)
+      colors    = [r / 255.0, g / 255.0, b / 255.0]
+      max       = colors.max
+      min       = colors.min
+      d         = max - min
+      v         = max * 100
+
+      s = max != 0.0 ? d / max *100 : 0.0
+
+      if s == 0.0
+        h = 0.0
+      else
+        case max
+        when colors[0]
+          h = (colors[1] - colors[2]) / d
+        when colors[1]
+          h = 2 + (colors[2] - colors[0]) / d
+        when colors[2]
+          h = 4 + (colors[0] - colors[1]) / d
+        end
+        h *= 60.0
+        h += 360.0 if (h < 0)
+      end
+      self.new(h, s, v)
+    end
+    
+  end
+end

data/lib/color_fun/rgb.rb

@@ -0,0 +1,62 @@
+module ColorFun
+  class RGB
+    
+    # Accessors for accessing the individual colors
+    attr_accessor :red, :green, :blue
+
+    # Initialize by passinga red, green and blue hex code
+    def initialize(red, green, blue)
+      @red, @green, @blue = red.to_i, green.to_i, blue.to_i
+    end
+
+    # Return the brightness value for a given colour (HSP)
+    def perceived_brightness
+      @brightness ||= Math.sqrt((0.299 * @red * @red) + (0.587 * @green * @green) + (0.114 * @blue * @blue))
+    end
+
+    # Return whether or not the color is visibly dark to the human eye?
+    def dark?
+      perceived_brightness < 160
+    end
+
+    # Return whether or not the color is visibly light to the human eye?
+    def light?
+      perceived_brightness > 161
+    end
+
+    # Return a new color object for a lighter version of this color
+    def lighter(percent = 50)
+      percent = (percent / 100.0)
+      RGB.new((255 - @red) * percent + @red, (255 - @green) * percent + @green, (255 - @blue) * percent + @blue)
+    end
+    
+    # Return a new color object for a darker version of this color
+    def darker(percent = 50)
+      percent = ((100 - percent) / 100.0)
+      RGB.new(@red * percent, @green * percent, @blue * percent)
+    end
+    
+    # Return a hex string for this color
+    def hex
+      [@red, @green, @blue].map do |c|
+        c.to_s(16).rjust(2, '0')
+      end.join
+    end
+    
+    # Return a HSL version of this color
+    def hsl
+      @hsl ||= HSL.from_rbg(@red, @green, @blue)
+    end
+    
+    # Initialize a new color object for a given hex code
+    def self.from_hex(hex)
+      self.new(*hex.scan(/../).map { |i| i.to_i(16) })
+    end
+
+    # Methods to create raw red, green and blue colors
+    def self.red; self.new(255,0,0); end
+    def self.green; self.new(0,255,0); end
+    def self.blue; self.new(0,0,255); end
+
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: color_fun
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-03 00:00:00.000000000 Z
+dependencies: []
+description: A little gem for playing with colors in Ruby
+email: adam@atechmedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- color_fun.gemspec
+- lib/color_fun/gradient.rb
+- lib/color_fun/hsl.rb
+- lib/color_fun/rgb.rb
+- lib/color_fun.rb
+- README.md
+homepage: http://atechmedia.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A little gem for playing with colors in Ruby
+test_files: []