paleta 0.0.4 → 0.0.5

data/Gemfile

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

data/lib/paleta/color.rb

@@ -9,15 +9,9 @@ module Paleta
     def initialize(*args)
       
       if args.length == 1 && args[0].is_a?(Color)
-        # TODO: refactor this, find out how to call a method name by the value of a variable
-        # something like args[0].instance_variables.each { |k, v| self.(k) = v }
-        @red = args[0].red
-        @green = args[0].green
-        @blue = args[0].blue
-        @hue = args[0].hue
-        @saturation = args[0].saturation
-        @lightness = args[0].lightness
-        @hex = args[0].hex
+        args[0].instance_variables.each do |key|
+          self.send("#{key[1..key.length]}=".to_sym, args[0].send("#{key[1..key.length]}"))
+        end
       elsif args.length == 2 && args[0] == :hex && args[1].is_a?(String)
         # example: new(:hex, "336699")
         hex_init(args[1])
@@ -98,10 +92,14 @@ module Paleta
       update_hsl
     end
     
+    def ==(color)
+      color.is_a?(Color) ? (self.hex == color.hex) : false
+    end
+    
     def lighten(percent = 5)
       copy = self.class.new(self)
       copy.lighten!(percent)
-      return copy
+      copy
     end
     
     def lighten!(percent = 5)
@@ -109,12 +107,13 @@ module Paleta
       @lightness = 100 if @lightness > 100
       update_rgb
       update_hex
+      self
     end
     
     def darken(percent = 5)
       copy = self.class.new(self)
       copy.darken!(percent)
-      return copy
+      copy
     end
     
     def darken!(percent = 5)
@@ -122,12 +121,13 @@ module Paleta
       @lightness = 0 if @lightness < 0
       update_rgb
       update_hex
+      self
     end
     
     def invert
       copy = self.class.new(self)
       copy.invert!
-      return copy
+      copy
     end
     
     def invert!
@@ -136,30 +136,33 @@ module Paleta
       @blue = 255 - @blue
       update_hsl
       update_hex
+      self
     end
     
     def desaturate
       copy = self.class.new(self)
       copy.desaturate!
-      return copy
+      copy
     end
     
     def desaturate!
       @saturation = 0
       update_rgb
       update_hex
+      self
     end
     
     def complement
       copy = self.class.new(self)
       copy.complement!
-      return copy
+      copy
     end
     
     def complement!
       @hue = (@hue + 180) % 360
       update_rgb
       update_hex
+      self
     end
     
     def similarity(color)

data/lib/paleta/core_ext/math.rb

@@ -9,42 +9,39 @@ module Math
     sqrt(sum)
   end
   
-  class MultipleRegression
-    attr_accessor :slope, :offset
-
-    def initialize dr, dg, db
-      
-      @slope, @offset = {}, {}
-      @size = dr.size
-      raise "arguments not same length!" unless @size == dg.size && @size == db.size
+  def multiple_regression(dx, dy, dz)
+    regression = {}
+    regression[:slope], regression[:offset] = {}, {}
+    size = dx.size
     
-      if @size == 1
-        @slope = { :r => dr[0], :g => dg[0], :b => db[0] }
-        @offset = { :r => 0, :g => 0, :b => 0 }
-        return
-      end
+    raise "arguments not same length!" unless size == dy.size && size == dz.size
     
-      srr = sgg = sbb = srg = sbr = sgb = sr = sb = sg = 0
-      dr.zip(dg,db).each do |r,g,b|
-        srr += r ** 2
-        sgg += g ** 2
-        srg += r * g
-        sbr += b * r
-        sgb += g * b
-        sr  += r
-        sb  += g
-        sg  += b
-      end
-      
-      @slope[:r] = ( @size * srg - sr * sb ) / ( @size * srr - sr ** 2 ).to_f
-      @slope[:g] = ( @size * sgb - sb * sg ) / ( @size * sgg - sb ** 2 ).to_f
-      @slope[:b] = ( @size * sgb - sb * sg ) / ( @size * sbb - sg ** 2 ).to_f
+    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
     
-      @offset[:r] = (sb - @slope[:r] * sr) / @size
-      @offset[:g] = (sg - @slope[:g] * sb) / @size
-      @offset[:b] = (sr - @slope[:b] * sg) / @size
-      
-      return
+    sxx = syy = szz = sxy = szx = syz = sx = sy = sz = 0
+    dx.zip(dy, dz).each do |x, y, z|
+      sxx += x ** 2
+      syy += y ** 2
+      sxy += x * y
+      szx += z * x
+      syz += y * z
+      sx  += x
+      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

@@ -15,13 +15,19 @@ module Paleta
       end
     end
     
-    def <<(color)
-      color.is_a?(Color) ? @colors << color : raise(ArgumentError, "Passed argument is not a Color")
+    def <<(obj)
+      if obj.is_a?(Color)
+        @colors << obj
+      elsif obj.is_a?(Palette)
+        @colors |= obj.colors
+      else
+        raise(ArgumentError, "Passed argument is not a Color")
+      end
       self
     end
     
-    def push(color)
-      self << color
+    def push(obj)
+      self << obj
     end
     
     def pop
@@ -81,13 +87,13 @@ module Paleta
       (0..1).each { |i| a[i], b[i] = {}, {} }
       
       # r[i] is the Math::MultipleRegression of the Palette in RGB space
-      r[0] = self.fit
+      r[0] = fit
       r[1] = palette.fit
-      
+            
       [0, 1].each do |i|
-        [:r, :g, :b].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]
+        [: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
       
@@ -105,22 +111,26 @@ module Paleta
       type = opts[:type] || :shades
       size = opts[:size] || 5
       case type
-      when :analogous; self.generate_analogous_palette_from_color(color, size)
-      when :monochromatic; self.generate_monochromatic_palette_from_color(color, size)
-      when :shades; self.generate_shades_palette_from_color(color, size)
-      when :random; self.generate_random_palette_from_color(color, size)
+      when :analogous; self.generate_analogous_from_color(color, size)
+      when :complementary; self.generate_complementary_from_color(color, size)
+      when :monochromatic; self.generate_monochromatic_from_color(color, size)
+      when :random; self.generate_random_from_color(color, size)
+      when :shades; self.generate_shades_from_color(color, size)
+      when :split_complement; self.generate_split_complement_from_color(color, size)
+      when :tetrad; self.generate_tetrad_from_color(color, size)
+      when :triad; self.generate_triad_from_color(color, size)
       else raise(ArgumentError, "Palette type is not defined. Try :analogous, :monochromatic, :shades, or :random")
       end
     end
     
     private
     
-    def self.generate_analogous_palette_from_color(color, n)
+    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)
       step = 20
-      below = (n / 2)
-      above = (n % 2 == 0) ? (n / 2) - 1: (n / 2)
+      below = (size / 2)
+      above = (size % 2 == 0) ? (size / 2) - 1: (size / 2)
       below.times do |i|
         hue = color.hue - ((i + 1) * step)
         hue += 360 if hue < 0
@@ -134,13 +144,37 @@ module Paleta
       palette.sort! { |a, b| a.hue <=> b.hue }
     end
     
-    def self.generate_monochromatic_palette_from_color(color, n)
+    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)
+      color3 = Paleta::Color.new(:hsl, (color2.hue + 120) % 360, color2.saturation, color2.lightness)
+      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)
+      color3 = Paleta::Color.new(:hsl, (color2.hue + 90) % 360, color2.saturation, color2.lightness)
+      color4 = Paleta::Color.new(:hsl, (color3.hue + 90) % 360, color3.saturation, color3.lightness)
+      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)
-      step = (100 / n)
+      step = (100 / size)
       saturation = color.saturation
       d = :down
-      until palette.size == n
+      until palette.size == size
         saturation -= step if d == :down
         saturation += step if d == :up
         palette << Paleta::Color.new(:hsl, color.hue, saturation, color.lightness)
@@ -152,13 +186,13 @@ module Paleta
       palette.sort! { |a, b| a.saturation <=> b.saturation }
     end
     
-    def self.generate_shades_palette_from_color(color, n)
+    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)
-      step = (100 / n)
+      step = (100 / size)
       lightness = color.lightness
       d = :down
-      until palette.size == n
+      until palette.size == size
         lightness -= step if d == :down
         lightness += step if d == :up
         palette << Paleta::Color.new(:hsl, color.hue, color.saturation, lightness)
@@ -170,21 +204,50 @@ module Paleta
       palette.sort! { |a, b| a.lightness <=> b.lightness }
     end
     
-    def self.generate_random_palette_from_color(color = nil, n)
+    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)
+      color3 = Paleta::Color.new(:hsl, (color2.hue + 60) % 360, color2.saturation, color2.lightness)
+      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)
-      until palette.size == n
+      until palette.size == size
         palette << Paleta::Color.new(r.rand(0..255), r.rand(0..255), r.rand(0..255))
       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)       
+      hues = palette.map { |c| c.hue }
+      step = ugap = dgap = 100 / size
+      i = j = 0
+      saturation = color.saturation
+      until palette.size == size    
+        if color.saturation + ugap < 100
+          saturation = color.saturation + ugap
+          ugap += step
+        else
+          saturation = color.saturation - dgap
+          dgap += step
+        end if j == 3 || j == 1
+        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 }
       greens = @colors.map { |c| c.green }
       blues = @colors.map { |c| c.blue }
-      MultipleRegression.new(reds, greens, blues)
+      multiple_regression(reds, greens, blues)
     end
   end
 end

data/lib/paleta/version.rb

@@ -1,3 +1,3 @@
 module Paleta
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/paleta.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ['iam@jordanstephens.net']
   gem.description   = 'A gem for working with color palettes'
   gem.summary       = 'A little library for creating, manipulating and comparing colors and color palettes'
-  gem.homepage      = 'http://jordanstephens.net'
+  gem.homepage      = 'http://rubygems.org/gems/paleta'
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")

data/readme.markdown

@@ -22,77 +22,97 @@ and run
 
 ### Color
 
-	# create a Color with HSL components
-	color = Paleta::Color.new(:hsl, 280, 37, 68)
+Paleta allows users to create Color objects. Color objects can be defined by HSL, RGB or HEX values and can be manipulated and compared.
+
+#### 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.
 	
-	# create a Color with RGB components
+	color = Paleta::Color.new(:hsl, 280, 37, 68)
 	color = Paleta::Color.new(:rgb, 94, 161, 235)
-	
-	# create a Color with a HEX value
 	color = Paleta::Color.new(:hex, "5EA1EB")
 	
     # creating a Color with no flag defaults to RGB components
 	color = Paleta::Color.new(94, 161, 235)
 	
-	# access component values
+Individual component values can be accessed by name
+
 	color.red # => 94
 	color.green # => 161
 	color.blue # => 235
-	
-	# HSL components are maintained too!
 	color.hue # => 211.48936170212767
 	color.saturation # => 77.90055248618782
 	color.lightness # => 64.50980392156862
-	
-	# a HEX value is also maintained for each Color
 	color.hex # => "5EA1EB"
 	
-	# lighten by a percentage
+#### Manipulating Colors
+
+Colors can be lightened or darkened by a percentage
+
 	color.lighten!(10) 
+	color.darken!(30) 
 	
-	# darken by a percentage
-	color.darken!(10) 
-	
-	# desaturate a Color
+Colors can be desaturated
+
 	color.desaturate!
 	
-	# convert a Color into its complement
+Colors can be turned into their complement Colors
+
 	color.complement!
-	
-	# invert a Color
+
+Colors can be inverted
+
 	color.invert!
 	
-	# calculate similarity between Colors
-	# Color#similarity calculates the similarity between two Colors and returns a
-	# value in 0..1, with 0 being identical and 1 being as dissimilar as possible
+**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
+	
+#### 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.5609077061558945
+	color.similarity(color2) # => 0.4100287904421024
 	
 ### Palette
 
-	# add Colors to a 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.
+
+#### Creating a Palette
+
+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)
 	
-	# add Colors to a Palette
 	palette << color3
 	
-	# retreive a Color from a Palette
+#### Retrieving and Removing Colors from Palettes
+
+Colors can be accessed and removed by index.
+	
 	palette[1] # => color2
 	
-	# remove a Color from a Palette by index
 	palette.delete_at(2)
+
+#### Manipulating Palettes
+
+Palettes can be lightened, darkened or inverted as a whole.
 	
-	# lighten and darken an entire Palette by a percentage
 	palette.lighten!(15)
 	palette.darken!(20)
-
-	# invert each color in a Palette
 	palette.invert!
 	
-	# calculate similarity of two Palettes
+#### 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)
@@ -101,25 +121,53 @@ and run
     color4 = Paleta::Color.new(94, 161, 235)
     palette2 = Paleta::Palette.new(color3, color4)
 
-	# Palette#similarity calculates the similarity between two Palettes and returns a
-	# value in 0..1, with 0 being identical and 1 being as dissimilar as possible	
     palette1.similarity(palette2) # => 0.0046992695975874915
 	
-	# generate random Palette
+#### Generating Palettes
+
+Palettes can be generated from a "seed" Color by using the `generate` method.
+
+**Generate a random Palette**
+
 	palette = Paleta::Palette.generate(:type => :random, :size = 5)
 	
-	# generate a Palette of shades from a Color
+**Generate a Palette of shades from a Color**
+
 	color = Paleta::Color.new(:hex, "ff0000")
 	palette = Paleta::Palette.generate(:type => :shades, :from => color, :size => 5)
 	
-	# generate a Palette of Colors analogous to the seed Color
+**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)
 	
-	# generate a Palette of Colors monochromatic to the seed Color
+**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)
 	
+**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)
+
+**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)
+
+**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)
+
+**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)
+
+***
+
 See the [documentation](http://rubydoc.info/gems/paleta/ "Documentation").
 
  

data/spec/models/color_spec.rb

@@ -57,6 +57,16 @@ describe Paleta::Color do
     expect{ Paleta::Color.new(:hsl, 200, 50, 150) }.to raise_error(ArgumentError)
   end
   
+  it "should determine its equality to another Color" do
+    color1 = Paleta::Color.new(237, 172, 33)
+    color2 = Paleta::Color.new(:hex, "EDAC21")
+    (color1 == color2).should be_true
+    color3 = Paleta::Color.new(:hsl, 200, 50, 100)
+    (color1 == color3).should be_false
+    obj = Object.new
+    (color1 == obj).should be_false
+  end
+  
   it "should calculate its HSL value on itialization" do
     color = Paleta::Color.new(237, 172, 33)
     color.hue.to_i.should == 40
@@ -193,13 +203,13 @@ describe Paleta::Color do
   it "should become its complement" do
     color = Paleta::Color.new(:hsl, 90, 50, 50)
     color.complement!
-    color.hue.should == 270
+    color.hue.to_i.should == 270
   end
   
   it "should return its complement Color" do
     color = Paleta::Color.new(:hsl, 90, 50, 50)
     complement = color.complement
-    complement.hue.should == 270
+    complement.hue.to_i.should == 270
   end
   
   it "should calculate its similarity to another Color" do

data/spec/models/palette_spec.rb

@@ -99,12 +99,12 @@ describe Paleta::Palette do
     c3 = Paleta::Color.new(237, 172, 33)
     palette = Paleta::Palette.new(c1, c2, c3)
     r = palette.fit
-    r.slope[:r].should == 0.4632575855725132
-    r.slope[:g].should == -0.5730072013906133
-    r.slope[:b].should == 0.06837037037037037
-    r.offset[:r].should == 76.87979685435182
-    r.offset[:g].should == 224.49093618077973
-    r.offset[:b].should == 104.41111111111111
+    r[:slope][:x].should == 0.19585157930194594
+    r[:slope][:y].should == 0.5276697919048708
+    r[:slope][:z].should == 0.09102564102564102
+    r[:offset][:x].should == 127.54235224004354
+    r[:offset][:y].should == 50.849531214269376
+    r[:offset][:z].should == 102.83333333333333
   end
   
   it "should calculate its similarity to another Palette" do
@@ -132,17 +132,17 @@ describe Paleta::Palette do
     c9 = Paleta::Color.new(13, 57, 182)
     c10 = Paleta::Color.new(94, 161, 235)
     p6 = Paleta::Palette.new(c9, c10)
-    p5.similarity(p6).round(5).should == 0.0047
+    p5.similarity(p6).round(5).should == 0.00627
   end
   
   it "should generate a new Palette of shades of a single Color" do
     color = Paleta::Color.new(:hex, "ff0000")
     palette = Paleta::Palette.generate(:from => color, :size => 5)
+    palette.size.should == 5
     palette.each do |p|
       p.hue.should == color.hue
       p.saturation.should == color.saturation
     end
-        
     palette[0].lightness.should == 10
     palette[1].lightness.should == 30
     palette[2].lightness.should == 50
@@ -153,6 +153,7 @@ describe Paleta::Palette do
   it "should generate a new Palette of Colors analogous to the seed Color" do
     color = Paleta::Color.new(:hex, "0066cc")
     palette = Paleta::Palette.generate(:type => :analogous, :from => color, :size => 5)
+    palette.size.should == 5
     palette.each do |p|
       p.lightness.should == color.lightness
       p.saturation.should == color.saturation
@@ -167,6 +168,7 @@ describe Paleta::Palette do
   it "should generate a new Palette of Colors monochromatic to the seed Color" do
     color = Paleta::Color.new(:hex, "0066cc")
     palette = Paleta::Palette.generate(:type => :monochromatic, :from => color, :size => 5)
+    palette.size.should == 5
     palette.each do |p|
       p.hue.should == color.hue
       p.lightness.should == color.lightness
@@ -176,11 +178,50 @@ describe Paleta::Palette do
     palette[2].saturation.should == 60
     palette[3].saturation.should == 80
     palette[4].saturation.should == 100
-    
   end
   
   it "should generate a new Palette of random Colors" do
     palette = Paleta::Palette.generate(:type => :random, :size => 5)
     palette.size.should == 5
   end
+  
+  it "should generate a new complementary Palette from the seed Color" do
+    color = Paleta::Color.new(:hex, "0066cc")
+    palette = Paleta::Palette.generate(:type => :complementary, :from => color, :size => 5)
+    palette.size.should == 5
+    palette.each do |c|
+      c.lightness.should == color.lightness
+      [color.hue, color.complement.hue].include?(c.hue).should be_true
+    end
+  end
+
+  it "should generate a new triad Palette from the seed Color" do
+    color = Paleta::Color.new(:hex, "0066cc")
+    palette = Paleta::Palette.generate(:type => :triad, :from => color, :size => 5)
+    palette.size.should == 5
+    palette.each do |c|
+      c.lightness.should == color.lightness
+      [color.hue, (color.hue + 120) % 360, (color.hue + 240) % 360].include?(c.hue).should be_true
+    end
+  end
+
+  it "should generate a new tetrad Palette from the seed Color" do
+    color = Paleta::Color.new(:hex, "0066cc")
+    palette = Paleta::Palette.generate(:type => :tetrad, :from => color, :size => 5)
+    palette.size.should == 5
+    palette.each do |c|
+      c.lightness.should == color.lightness
+      [color.hue, (color.hue + 90) % 360, (color.hue + 180) % 360, (color.hue + 270) % 360].include?(c.hue).should be_true
+    end
+  end
+  
+  it "should generate a new split-complement Palette from the seed Color" do
+    color = Paleta::Color.new(:hex, "0066cc")
+    palette = Paleta::Palette.generate(:type => :split_complement, :from => color, :size => 5)
+    palette.size.should == 5
+    palette.each do |c|
+      c.lightness.should == color.lightness
+      [color.hue, (color.hue + 150) % 360, (color.hue + 210) % 360].include?(c.hue).should be_true
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paleta
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-11 00:00:00.000000000Z
+date: 2012-01-20 00:00:00.000000000Z
 dependencies: []
 description: A gem for working with color palettes
 email:
@@ -31,7 +31,7 @@ files:
 - spec/models/color_spec.rb
 - spec/models/palette_spec.rb
 - spec/spec_helper.rb
-homepage: http://jordanstephens.net
+homepage: http://rubygems.org/gems/paleta
 licenses: []
 post_install_message: 
 rdoc_options: []