paleta 0.2.0 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b03ada62d667c325f97922bd22b05801aff9cccd
+  data.tar.gz: cb7d2375cfcf0ac8cceb96719d1c9cdb13b5af23
+SHA512:
+  metadata.gz: 2a4cd1d750c2f78091b15b904d0d2e599dea95d91922a32b494ecd559bf5fa0eb504cb53e2ca735688efcab05195f573a5944eacaa37cef455d0430282873dbb
+  data.tar.gz: 1eeac708731584488a6a1611a14f3ba7417f3de5693f5144602cee107c43fe6d3b48b296c8dbd411a04561b46cead354641d77262f2aa8608f7a0a299292ad57

data/Gemfile

@@ -2,6 +2,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rspec', '~>2.8.0'
-gem 'guard-rspec'
-gem 'rmagick'
+gem 'rmagick'

data/lib/paleta/color.rb

@@ -4,9 +4,9 @@ module Paleta
   # Represents a color
   class Color
     include Math
-    
+
     attr_reader :red, :green, :blue, :hue, :saturation, :lightness, :hex
-    
+
     # Initailize a {Color}
     #
     # @overload initialize()
@@ -36,7 +36,6 @@ module Paleta
     #
     # @return [Color] A new instance of {Color}
     def initialize(*args)
-      
       if args.length == 1 && args[0].is_a?(Color)
         args[0].instance_variables.each do |key|
           self.send("#{key[1..key.length]}=".to_sym, args[0].send("#{key[1..key.length]}"))
@@ -59,43 +58,43 @@ module Paleta
         raise(ArgumentError, "Invalid arguments")
       end
     end
-    
+
     def red=(val)
       @red = range_validator(val, 0..255)
       update_hsl
       update_hex
     end
-    
+
     def green=(val)
       @green = range_validator(val, 0..255)
       update_hsl
       update_hex
     end
-    
+
     def blue=(val)
       @blue = range_validator(val, 0..255)
       update_hsl
       update_hex
     end
-    
+
     def lightness=(val)
       @lightness = range_validator(val, 0..100)
       update_rgb
       update_hex
     end
-    
+
     def saturation=(val)
       @saturation = range_validator(val, 0..100)
       update_rgb
       update_hex
     end
-    
+
     def hue=(val)
       @hue = range_validator(val, 0..360)
       update_rgb
       update_hex
     end
-    
+
     def hex=(val)
       raise(ArgumentError, "Invalid Hex String") unless val.length == 6 && /^[[:xdigit:]]+$/ === val
       @hex = val.upcase
@@ -104,23 +103,23 @@ module Paleta
       @blue = val[4..5].hex
       update_hsl
     end
-    
+
     # Determine the equality of the receiver and another {Color}
     # @param [Color] color color to compare
     # @return [Boolean]
     def ==(color)
       color.is_a?(Color) ? (self.hex == color.hex) : false
     end
-    
+
     # Create a copy of the receiver and lighten it by a percentage
     # @param [Number] percentage percentage by which to lighten the {Color}
     # @return [Color] a lightened copy of the receiver
     def lighten(percentage = 5)
-      copy = self.class.new(self)
+      copy = self.dup
       copy.lighten!(percentage)
       copy
     end
-    
+
     # Lighten the receiver by a percentage
     # @param [Number] percentage percentage by which to lighten the {Color}
     # @return [Color] self
@@ -131,16 +130,16 @@ module Paleta
       update_hex
       self
     end
-    
+
     # Create a copy of the receiver and darken it by a percentage
     # @param [Number] percentage percentage by which to darken the {Color}
     # @return [Color] a darkened copy of the receiver
     def darken(percentage = 5)
-      copy = self.class.new(self)
+      copy = self.dup
       copy.darken!(percentage)
       copy
     end
-    
+
     # Darken the receiver by a percentage
     # @param [Number] percentage percentage by which to darken the {Color}
     # @return [Color] self
@@ -151,7 +150,7 @@ module Paleta
       update_hex
       self
     end
-    
+
     # Create a copy of the receiver and invert it
     # @return [Color] an inverted copy of the receiver
     def invert
@@ -159,7 +158,7 @@ module Paleta
       copy.invert!
       copy
     end
-    
+
     # Invert the receiver
     # @return [Color] self
     def invert!
@@ -170,7 +169,7 @@ module Paleta
       update_hex
       self
     end
-    
+
     # Create a copy of the receiver and desaturate it
     # @return [Color] a desaturated copy of the receiver
     def desaturate
@@ -187,7 +186,7 @@ module Paleta
       update_hex
       self
     end
-    
+
     # Create a new {Color} that is the complement of the receiver
     # @return [Color] a desaturated copy of the receiver
     def complement
@@ -195,7 +194,7 @@ module Paleta
       copy.complement!
       copy
     end
-    
+
     # Turn the receiver into it's complement
     # @return [Color] self
     def complement!
@@ -204,14 +203,14 @@ module Paleta
       update_hex
       self
     end
-    
+
     # Calculate the similarity between the receiver and another {Color}
     # @param [Color] color color to calculate the similarity to
     # @return [Number] a value in [0..1] with 0 being identical and 1 being as dissimilar as possible
     def similarity(color)
       distance({ :r => @red, :g => @green, :b => @blue}, { :r => color.red, :g => color.green, :b => color.blue}) / sqrt(3 * (255 ** 2))
     end
-    
+
     # Return an array representation of a {Color} instance,
     # @param [Symbol] model the color model, should be :rgb or :hsl
     # @return [Array] an array of component values
@@ -226,25 +225,25 @@ module Paleta
       end
       array
     end
-    
+
     private
-    
+
     def rgb_init(red = 0, green = 0, blue = 0)
       self.red = red
       self.green = green
       self.blue = blue
     end
-    
+
     def hsl_init(hue = 0, saturation = 0, lightness = 0)
       self.hue = hue
       self.saturation = saturation
       self.lightness = lightness
     end
-    
+
     def hex_init(val = "000000")
       self.hex = val
     end
-    
+
     def update_hsl
       r = @red / 255.0 rescue 0.0
       g = @green / 255.0 rescue 0.0
@@ -253,10 +252,14 @@ module Paleta
       min = [r, g, b].min
       max = [r, g, b].max
       delta = max - min
-      
+
       h = 0
       l = (max + min) / 2.0
-      s = ((l == 0 || l == 1) ? 0 : (delta / (1 - (2 * l - 1).abs)))
+      if ![1, 0].include?(l) && delta / 2.0  == l
+        s = 1.0
+      else
+        s = ((l == 0 || l == 1) ? 0 : (delta / (1 - (2 * l - 1).abs)))
+      end
 
       if delta != 0
         case max
@@ -265,15 +268,14 @@ module Paleta
         when b; h = ((r - g) / delta) + 4
         end
       end
-      
+
       @hue = h * 60
       @hue += 360 if @hue < 0
       @saturation = s * 100
       @lightness = l * 100
     end
-    
+
     def update_rgb
-            
       h = @hue / 60.0 rescue 0.0
       s = @saturation / 100.0 rescue 0.0
       l = @lightness / 100.0 rescue 0.0
@@ -281,7 +283,7 @@ module Paleta
       d1 = (1 - (2 * l - 1).abs) * s
       d2 = d1 * (1 - (h % 2 - 1).abs)
       d3 = l - (d1 / 2.0)
-      
+
       case h.to_i
       when 0; @red, @green, @blue = d1, d2, 0
       when 1; @red, @green, @blue = d2, d1, 0
@@ -291,12 +293,12 @@ module Paleta
       when 5; @red, @green, @blue = d1, 0, d2
       else; @red, @green, @blue = 0, 0, 0
       end
-      
+
       @red = 255 * (@red + d3)
       @green = 255 * (@green + d3)
       @blue = 255 * (@blue + d3)
     end
-    
+
     def update_hex
       r = @red.to_i.to_s(16) rescue "00"
       g = @green.to_i.to_s(16) rescue "00"
@@ -306,7 +308,7 @@ module Paleta
       b = "0#{b}" if b.length < 2
       @hex = "#{r}#{g}#{b}".upcase
     end
-    
+
     def range_validator(val, range)
       range.include?(val) ? val : raise(ArgumentError, "Component range exceeded")
     end

data/lib/paleta/core_ext/math.rb

@@ -8,20 +8,20 @@ module Math
     a.each_with_index { |v, i| sum += (a[i] - b[i]) ** 2 } if a.is_a?(Array)
     sqrt(sum)
   end
-  
+
   def multiple_regression(dx, dy, dz)
     regression = {}
     regression[:slope], regression[:offset] = {}, {}
     size = dx.size
-    
+
     raise "arguments not same length!" unless size == dy.size && size == dz.size
-    
+
     if size == 1
       regression[:slope] = { :x => dx[0], :y => dy[0], :z => dz[0] }
       regression[:offset] = { :x => 0, :y => 0, :z => 0 }
       return regression
     end
-    
+
     sxx = syy = szz = sxy = szx = syz = sx = sy = sz = 0
     dx.zip(dy, dz).each do |x, y, z|
       sxx += x ** 2
@@ -34,15 +34,15 @@ module Math
       sy  += y
       sz  += z
     end
-      
+
     regression[:slope][:x] = ( size * sxy - sx * sz ) / ( size * sxx - sx ** 2 ).to_f
     regression[:slope][:y] = ( size * syz - sz * sy ) / ( size * syy - sz ** 2 ).to_f
     regression[:slope][:z] = ( size * syz - sz * sy ) / ( size * szz - sy ** 2 ).to_f
-    
+
     regression[:offset][:x] = (sz - regression[:slope][:x] * sx) / size
     regression[:offset][:y] = (sy - regression[:slope][:y] * sz) / size
     regression[:offset][:z] = (sx - regression[:slope][:z] * sy) / size
-    
+
     regression
   end
 end

data/lib/paleta/palette.rb

@@ -1,24 +1,23 @@
 require 'paleta/core_ext/math'
 
 module Paleta
-  
   module MagickDependent
     def self.included(klass)
-      require 'RMagick'
+      require 'RMagick' unless defined?(Magick)
       klass.extend(ClassMethods)
     rescue LoadError
       puts "You must install RMagick to use Palette.generate(:from => :image, ...)"
     end
-    
+
     module ClassMethods
       def generate_from_image(path, size = 5)
         include Magick
         begin
           image = Magick::ImageList.new(path)
-          
+
           # quantize image to the nearest power of 2 greater the desired palette size
           quantized_image = image.quantize((Math.sqrt(size).ceil ** 2), Magick::RGBColorspace)
-          colors = quantized_image.color_histogram.sort { |a, b| b[1] <=> a[1] }[0..(size - 1)].map do |color|          
+          colors = quantized_image.color_histogram.sort { |a, b| b[1] <=> a[1] }[0..(size - 1)].map do |color|
             Paleta::Color.new(color[0].red / 256, color[0].green / 256, color[0].blue / 256)
           end
           return Paleta::Palette.new(colors)
@@ -28,15 +27,15 @@ module Paleta
       end
     end
   end
-  
+
   # Represents a palette, a collection of {Color}s
   class Palette
     include Math
     include Enumerable
     include MagickDependent
-    
+
     attr_accessor :colors
-    
+
     # Initialize a {Palette} from a list of {Color}s
     # @param [Array] colors a list of {Color}s to include in the {Palette}
     # @return [Palette] A new instance of {Palette}
@@ -45,7 +44,7 @@ module Paleta
       colors = (args.length == 1 && args[0].is_a?(Array)) ? args[0] : args
       colors.each { |color| self << color }
     end
-    
+
     # Add a {Color} to the {Palette}
     # @overload <<(color)
     #   @param [Color] color a {Color} to add to the receiver
@@ -63,7 +62,7 @@ module Paleta
       end
       self
     end
-    
+
     # Add a {Color} to the {Palette}
     # @overload push(color)
     #   @param [Color] color a {Color} to add to the receiver
@@ -74,56 +73,56 @@ module Paleta
     def push(obj)
       self << obj
     end
-    
+
     # Remove the most recently added {Color} from the receiver
     def pop
       @colors.pop
     end
-    
+
     # Remove a {Color} from the receiver by index
     # @param [Number] index the index at which to remove a {Color}
     def delete_at(index = 0)
       @colors.delete_at(index)
     end
-    
+
     # Access a {Color} in the receiver by index
     # @param [Number] index the index at which to access a {Color}
     def [](index)
       @colors[index]
     end
-    
+
     # The number of {Color}s in the {Palette}
     # @return [Number] the number of {Color}s in the receiver
     def size
       @colors.size
     end
-    
+
     # Iterate through each {Color} in the {Palette}
     def each
       @colors.each { |c| yield c }
     end
-    
+
     # Create a new instance of {Palette} that is a sorted copy of the receiver
     # @return [Palette] a new instance of {Palette}
     def sort(&blk)
       @colors.sort(&blk)
       Paleta::Palette.new(@colors)
     end
-    
+
     # Sort the {Color}s in the receiver
     # return [Palette] self
     def sort!(&blk)
       @colors.sort!(&blk)
       self
     end
-    
+
     # Test if a {Color} exists in the receiver
     # @param [Color] color color to test for inclusion in the {Palette}
     # @return [Boolean]
     def include?(color)
       @colors.include?(color)
     end
-    
+
     # Lighen each {Color} in the receiver by a percentage
     # @param [Number] percentage percentage by which to lighten each {Color} in the receiver
     # @return [Palette] self
@@ -131,7 +130,7 @@ module Paleta
       @colors.each { |color| color.lighten!(percentage) }
       self
     end
-    
+
     # Lighen each {Color} in the receiver by a percentage
     # @param [Number] percentage percentage by which to lighten each {Color} in the receiver
     # @return [Palette] self
@@ -139,40 +138,40 @@ module Paleta
       @colors.each { |color| color.darken!(percentage) }
       self
     end
-    
+
     # Invert each {Color} in the receiver by a percentage
     # @return [Palette] self
     def invert!
       @colors.each { |color| color.invert! }
       self
     end
-    
+
     # Calculate the similarity between the receiver and another {Palette}
     # @param [Palette] palette palette to calculate the similarity to
     # @return [Number] a value in [0..1] with 0 being identical and 1 being as dissimilar as possible
     def similarity(palette)
       r, a, b = [], [], []
       (0..1).each { |i| a[i], b[i] = {}, {} }
-      
+
       # r[i] is a hash of the multiple regression of the Palette in RGB space
       r[0] = fit
       r[1] = palette.fit
-            
+
       [0, 1].each do |i|
         [:x, :y, :z].each do |k|
           a[i][k] = 0 * r[i][:slope][k] + r[i][:offset][k]
           b[i][k] = 255 * r[i][:slope][k] + r[i][:offset][k]
         end
       end
-      
+
       d_max = sqrt(3 * (65025 ** 2))
-     
+
       d1 = distance(a[0], a[1]) / d_max
       d2 = distance(b[0], b[1]) / d_max
-      
+
       d1 + d2
     end
-    
+
     # Generate a {Palette} from a seed {Color}
     # @param [Hash] opts the options with which to generate a new {Palette}
     # @option opts [Symbol] :type the type of palette to generate
@@ -182,25 +181,25 @@ module Paleta
     # @option opts [Number] :size the number of {Color}s to generate for the {Palette}
     # @return [Palette] A new instance of {Palette}
     def self.generate(opts = {})
-      
+
       size = opts[:size] || 5
-      
+
       if !opts[:type].nil? && opts[:type].to_sym == :random
         return self.generate_random_from_color(opts[:color], size)
       end
-      
+
       unless (opts[:from].to_sym == :color && !opts[:color].nil?) || (opts[:from].to_sym == :image && !opts[:image].nil?)
         return raise(ArgumentError, 'You must pass :from and it must be either :color or :image, then you must pass :image => "/path/to/img" or :color => color')
       end
-                  
+
       if opts[:from].to_sym == :image
         path = opts[:image]
         return self.generate_from_image(path, size)
       end
-      
+
       color = opts[:color]
       type = opts[:type] || :shades
-      
+
       case type
       when :analogous; self.generate_analogous_from_color(color, size)
       when :complementary; self.generate_complementary_from_color(color, size)
@@ -212,7 +211,7 @@ module Paleta
       else raise(ArgumentError, "Palette type is not defined. Try :analogous, :monochromatic, :shades, or :random")
       end
     end
-    
+
     # Return an array representation of a {Palette} instance,
     # @param [Symbol] model the color model, should be :rgb, :hsl, or :hex
     # @return [Array] an Array of Arrays where each sub-Array is a representation of a {Color} object in a {Palette} instance
@@ -227,9 +226,9 @@ module Paleta
       end
       array
     end
-    
+
     private
-    
+
     def self.generate_analogous_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       palette = self.new(color)
@@ -248,14 +247,14 @@ module Paleta
       end
       palette.sort! { |a, b| a.hue <=> b.hue }
     end
-    
+
     def self.generate_complementary_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       complement = color.complement
       palette = self.new(color, complement)
       add_monochromatic_in_hues_of_color(palette, color, size)
     end
-    
+
     def self.generate_triad_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       color2 = Paleta::Color.new(:hsl, (color.hue + 120) % 360, color.saturation, color.lightness)
@@ -263,7 +262,7 @@ module Paleta
       palette = self.new(color, color2, color3)
       add_monochromatic_in_hues_of_color(palette, color, size)
     end
-    
+
     def self.generate_tetrad_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       color2 = Paleta::Color.new(:hsl, (color.hue + 90) % 360, color.saturation, color.lightness)
@@ -272,7 +271,7 @@ module Paleta
       palette = self.new(color, color2, color3, color4)
       add_monochromatic_in_hues_of_color(palette, color, size)
     end
-    
+
     def self.generate_monochromatic_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       palette = self.new(color)
@@ -290,7 +289,7 @@ module Paleta
       end
       palette.sort! { |a, b| a.saturation <=> b.saturation }
     end
-    
+
     def self.generate_shades_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       palette = self.new(color)
@@ -298,17 +297,17 @@ module Paleta
       lightness = color.lightness
       d = :down
       until palette.size == size
-        lightness -= step if d == :down
-        lightness += step if d == :up
-        palette << Paleta::Color.new(:hsl, color.hue, color.saturation, lightness)
         if lightness - step < 0
           d = :up
           lightness = color.lightness
         end
+        lightness -= step if d == :down
+        lightness += step if d == :up
+        palette << Paleta::Color.new(:hsl, color.hue, color.saturation, lightness)
       end
       palette.sort! { |a, b| a.lightness <=> b.lightness }
     end
-    
+
     def self.generate_split_complement_from_color(color, size)
       raise(ArgumentError, "Passed argument is not a Color") unless color.is_a?(Color)
       color2 = Paleta::Color.new(:hsl, (color.hue + 150) % 360, color.saturation, color.lightness)
@@ -316,7 +315,7 @@ module Paleta
       palette = self.new(color, color2, color3)
       add_monochromatic_in_hues_of_color(palette, color, size)
     end
-    
+
     def self.generate_random_from_color(color = nil, size)
       palette = color.is_a?(Color) ? self.new(color) : self.new
       r = Random.new(Time.now.sec)
@@ -325,14 +324,14 @@ module Paleta
       end
       palette
     end
-    
+
     def self.add_monochromatic_in_hues_of_color(palette, color, size)
-      raise(ArgumentError, "Second argument is not a Color") unless color.is_a?(Color)       
+      raise(ArgumentError, "Second argument is not a Color") unless color.is_a?(Color)
       hues = palette.map { |c| c.hue }
       step = ugap = dgap = 100 / size
       i = j = 0
       saturation = color.saturation
-      until palette.size == size    
+      until palette.size == size
         if color.saturation + ugap < 100
           saturation = color.saturation + ugap
           ugap += step
@@ -340,13 +339,13 @@ module Paleta
           saturation = color.saturation - dgap
           dgap += step
         end if j == 3 || j == 1
-        new_color = Paleta::Color.new(:hsl, hues[i], saturation, color.lightness)        
+        new_color = Paleta::Color.new(:hsl, hues[i], saturation, color.lightness)
         palette << new_color unless palette.include?(new_color)
         i += 1; j += 1; i %= hues.size; j %= (2 * hues.size)
       end
       palette.sort! { |a, b| a.saturation <=> b.saturation }
     end
-    
+
     def fit
       # create a 3xn matrix where n = @colors.size to represent the set of colors
       reds = @colors.map { |c| c.red }

data/lib/paleta/version.rb

@@ -1,3 +1,3 @@
 module Paleta
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/paleta.gemspec

@@ -14,4 +14,8 @@ Gem::Specification.new do |gem|
   gem.name          = 'paleta'
   gem.require_paths = ['lib']
   gem.version       = Paleta::VERSION
+
+  gem.add_development_dependency "rspec", "~> 2.8"
+  gem.add_development_dependency "guard-rspec", "~> 1.2"
+  gem.add_development_dependency "pry-byebug", "~> 2.0"
 end

data/readme.markdown

@@ -27,63 +27,82 @@ Paleta allows users to create Color objects. Color objects can be defined by HSL
 #### Creating Colors
 
 Colors can be created using RGB or HSL components, or by using a HEX value by passing in a flag of the desired format as the first parameter. If no format flag is used, RGB is assumed.
-	
-	color = Paleta::Color.new(:hsl, 280, 37, 68)
-	color = Paleta::Color.new(:rgb, 94, 161, 235)
-	color = Paleta::Color.new(:hex, "5EA1EB")
-	
-    # creating a Color with no flag defaults to RGB components
-	color = Paleta::Color.new(94, 161, 235)
-	
+
+```ruby
+color = Paleta::Color.new(:hsl, 280, 37, 68)
+color = Paleta::Color.new(:rgb, 94, 161, 235)
+color = Paleta::Color.new(:hex, "5EA1EB")
+
+# creating a Color with no flag defaults to RGB components
+
+color = Paleta::Color.new(94, 161, 235)
+```
+
 Individual component values can be accessed by name
 
-	color.red # => 94
-	color.green # => 161
-	color.blue # => 235
-	color.hue # => 211.48936170212767
-	color.saturation # => 77.90055248618782
-	color.lightness # => 64.50980392156862
-	color.hex # => "5EA1EB"
-	
+```ruby
+color.red # => 94
+color.green # => 161
+color.blue # => 235
+color.hue # => 211.48936170212767
+color.saturation # => 77.90055248618782
+color.lightness # => 64.50980392156862
+color.hex # => "5EA1EB"
+```	
 	
 Get an array representation of a Color
 
-	c = Paleta::Color.new(30, 90, 120)
-	c.to_array(:rgb) # => [30, 90, 120]
-	
+```ruby
+c = Paleta::Color.new(30, 90, 120)
+c.to_array(:rgb) # => [30, 90, 120]
+```
+
 #### Manipulating Colors
 
+
 Colors can be lightened or darkened by a percentage
 
-	color.lighten!(10) 
-	color.darken!(30) 
-	
+```ruby
+color.lighten!(10) 
+color.darken!(30) 
+```
+
 Colors can be desaturated
 
-	color.desaturate!
-	
+```ruby
+color.desaturate!
+```
+
 Colors can be turned into their complement Colors
 
-	color.complement!
+```ruby
+color.complement!
+```
 
 Colors can be inverted
 
-	color.invert!
-	
+```ruby
+color.invert!
+```
+
 **Note** all of the previous methods directly manipulate the object on which they were called. If you would like to create a new Color object that is a copy of the original color (but with the desired manipulation), call the desired method without the trailing bang `!`.
 
 For example, lets create a new Color that is the complement of a Color we have already defined.
 
-	new_color = color.complement
-	
+```ruby
+new_color = color.complement
+```
+
 #### Comparing Colors
 
 Colors can calculate their similarity to other Colors. The `similarity` method returns a value between 0 and 1, with 0 being identical and 1 being as dissimilar as possible.
 
-	color = Paleta::Color.new(:hsl, 280, 37, 68)
-	color2 = Paleta::Color.new(237, 172, 33)
-	color.similarity(color2) # => 0.4100287904421024
-	
+```ruby
+color = Paleta::Color.new(:hsl, 280, 37, 68)
+color2 = Paleta::Color.new(237, 172, 33)
+color.similarity(color2) # => 0.4100287904421024
+```
+
 ### Palette
 
 Palettes are collections of Colors, they share many common Array methods such as `push`, `pop`, `sort`, `include?` and `each`. Palettes also allow collections of Colors to be manipulated as a whole and to be compared to each other.
@@ -92,99 +111,127 @@ Palettes are collections of Colors, they share many common Array methods such as
 
 Palettes can be created by passing a list of Colors to the Palette constructor, or on the fly with `push` and `<<`. 
 
-    color1 = Paleta::Color.new(13, 57, 182)
-    color2 = Paleta::Color.new(94, 161, 235)
-	color3 = Paleta::Color.new(237, 182, 17)
-    palette = Paleta::Palette.new(color1, color2)
-	
-	palette << color3
-	
+```ruby
+color1 = Paleta::Color.new(13, 57, 182)
+color2 = Paleta::Color.new(94, 161, 235)
+color3 = Paleta::Color.new(237, 182, 17)
+palette = Paleta::Palette.new(color1, color2)
+
+palette << color3
+```
+
 #### Retrieving and Removing Colors from Palettes
 
 Colors can be accessed and removed by index.
 	
-	palette[1] # => color2
-	
-	palette.delete_at(2)
-	
+```ruby
+palette[1] # => color2
+
+palette.delete_at(2)
+```
+
 Get an array representation of a Palette
 
-    c1 = Paleta::Color.new(13, 57, 182)
-    c2 = Paleta::Color.new(94, 161, 235)
-    palette = Paleta::Palette.new(c1, c2)
+```ruby
+c1 = Paleta::Color.new(13, 57, 182)
+c2 = Paleta::Color.new(94, 161, 235)
+palette = Paleta::Palette.new(c1, c2)
 	
-	palette.to_array(:rgb) # => [[13, 57, 182], [94, 161, 235]]
+palette.to_array(:rgb) # => [[13, 57, 182], [94, 161, 235]]
+```
 
 #### Manipulating Palettes
 
 Palettes can be lightened, darkened or inverted as a whole.
-	
-	palette.lighten!(15)
-	palette.darken!(20)
-	palette.invert!
-	
+
+```ruby
+palette.lighten!(15)
+palette.darken!(20)
+palette.invert!
+```
+
 #### Comparing Palettes
 
 Palettes can calculate their similarity to other Palettes by using the `similarity` method. Just as with `Color#similarity`, this method returns a value between 0 and 1, with 0 being identical and 1 being as dissimilar as possible. 
 
-    color1 = Paleta::Color.new(13, 57, 182)
-    color2 = Paleta::Color.new(237, 172, 33)
-    palette1 = Paleta::Palette.new(color1, color2)
-    
-    color3 = Paleta::Color.new(13, 57, 182)
-    color4 = Paleta::Color.new(94, 161, 235)
-    palette2 = Paleta::Palette.new(color3, color4)
+```ruby
+color1 = Paleta::Color.new(13, 57, 182)
+color2 = Paleta::Color.new(237, 172, 33)
+palette1 = Paleta::Palette.new(color1, color2)
+
+color3 = Paleta::Color.new(13, 57, 182)
+color4 = Paleta::Color.new(94, 161, 235)
+palette2 = Paleta::Palette.new(color3, color4)
+
+palette1.similarity(palette2) # => 0.0046992695975874915
+```
 
-    palette1.similarity(palette2) # => 0.0046992695975874915
-	
 #### Generating Palettes
 
 Palettes can be generated from a "seed" Color or from an image by using the `generate` method.
 	
 **Generate a Palette of shades from a Color**
 
-	color = Paleta::Color.new(:hex, "ff0000")
-	palette = Paleta::Palette.generate(:type => :shades, :from => :color, :size => 5)
-	
+```ruby
+color = Paleta::Color.new(:hex, "ff0000")
+palette = Paleta::Palette.generate(:type => :shades, :from => :color, :size => 5)
+```
+
 **Generate a Palette of analogous Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "0066cc")
-    palette = Paleta::Palette.generate(:type => :analogous, :from => :color, :size => 5)
-	
+```ruby
+color = Paleta::Color.new(:hex, "0066cc")
+palette = Paleta::Palette.generate(:type => :analogous, :from => :color, :size => 5)
+```
+
 **Generate a Palette of monochromatic Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "336699")
-    palette = Paleta::Palette.generate(:type => :monochromatic, :from => :color, :size => 5)
-	
+```ruby
+color = Paleta::Color.new(:hex, "336699")
+palette = Paleta::Palette.generate(:type => :monochromatic, :from => :color, :size => 5)
+```
+
 **Generate a Palette of complementary Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "0000ff")
-    palette = Paleta::Palette.generate(:type => :complementary, :from => :color, :size => 5)
+```ruby
+color = Paleta::Color.new(:hex, "0000ff")
+palette = Paleta::Palette.generate(:type => :complementary, :from => :color, :size => 5)
+```
 
 **Generate a Palette of split-complement Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "006699")
-    palette = Paleta::Palette.generate(:type => :split_complement, :from => :color, :size => 5)
+```ruby
+color = Paleta::Color.new(:hex, "006699")
+palette = Paleta::Palette.generate(:type => :split_complement, :from => :color, :size => 5)
+```
 
 **Generate a Palette of triad Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "006699")
-    palette = Paleta::Palette.generate(:type => :triad, :from => :color, :size => 5)
+```ruby
+color = Paleta::Color.new(:hex, "006699")
+palette = Paleta::Palette.generate(:type => :triad, :from => :color, :size => 5)
+```
 
 **Generate a Palette of tetrad Colors from a Color**
 
-    color = Paleta::Color.new(:hex, "dd5533")
-    palette = Paleta::Palette.generate(:type => :tetrad, :from => :color, :size => 5)
-	
+```ruby
+color = Paleta::Color.new(:hex, "dd5533")
+palette = Paleta::Palette.generate(:type => :tetrad, :from => :color, :size => 5)
+```
+
 **Generate a random Palette**
 
-	palette = Paleta::Palette.generate(:type => :random, :size => 5)
-	
+```ruby
+palette = Paleta::Palette.generate(:type => :random, :size => 5)
+```
+
 Palettes can also be generated from a seed image
 	
 **Generate a Palette from an image**
 
-	palette = Paleta::Palette.generate(:from => :image, :image => "/path/to/image.jpg", :size => 5)
+```ruby
+palette = Paleta::Palette.generate(:from => :image, :image => "/path/to/image.jpg", :size => 5)
+```
 
 ***
 

metadata

@@ -1,16 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: paleta
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.2.1
 platform: ruby
 authors:
 - Jordan Stephens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-13 00:00:00.000000000Z
-dependencies: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: A gem for working with color palettes
 email:
 - iam@jordanstephens.net
@@ -18,7 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - lib/paleta.rb
@@ -34,27 +75,26 @@ files:
 - spec/spec_helper.rb
 homepage: http://rubygems.org/gems/paleta
 licenses: []
+metadata: {}
 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.10
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A little library for creating, manipulating and comparing colors and color
   palettes
 test_files:
@@ -62,4 +102,3 @@ test_files:
 - spec/models/color_spec.rb
 - spec/models/palette_spec.rb
 - spec/spec_helper.rb
-has_rdoc: