style_train 0.1.0

data/lib/style_train/support/gnash.rb

@@ -0,0 +1,143 @@
+# Taken from RAILS, see RAIL'S LICENSE for usage
+
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+unless defined?(HashWithIndifferentAccess)
+  class Hash
+    def with_indifferent_access
+      hash = HashWithIndifferentAccess.new(self)
+      hash.default = self.default
+      hash
+    end
+  end  
+  
+  class HashWithIndifferentAccess < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    # 
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    # 
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    # 
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    # 
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super other_hash.with_indifferent_access
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def symbolize_keys!; self end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          value.with_indifferent_access
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+        else
+          value
+        end
+      end
+  end
+end
+
+Gnash = HashWithIndifferentAccess unless defined?( Gnash ) # because Gnash is easier to write, thanks Merb!
+        

data/lib/style_train/support/numbers.rb

@@ -0,0 +1,23 @@
+class Fixnum
+  def px
+    "#{self}px"
+  end
+  
+  def em
+    "#{self}em"
+  end
+  
+  def percent
+    "#{self}%"
+  end
+  
+  def pt
+    "#{self}pt"
+  end
+end
+
+class Float
+  def em
+    "#{self}em"
+  end
+end

data/lib/style_train/support/string.rb

@@ -0,0 +1,24 @@
+# From ActiveSupport
+
+unless String.instance_methods.include?( 'constantize' )
+  class String
+    # Constantize tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    #
+    # @example
+    #   "Module".constantize #=> Module
+    #   "Class".constantize #=> Class
+    def constantize
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+        raise NameError, "#{self.inspect} is not a valid constant name!"
+      end
+
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+    def dasherize
+      self.gsub('_', '-') || self
+    end 
+  end  
+end  

data/lib/style_train.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift( File.dirname(__FILE__) )
+
+# ruby libs
+require 'singleton'
+
+# Support stuff
+require 'style_train/support/gnash'
+require 'style_train/support/string'
+require 'style_train/support/numbers'
+
+# The color load!
+require 'style_train/color_types/color_type'
+require 'style_train/color_types/rgb_color'
+require 'style_train/color_types/hsl_color'
+require 'style_train/color_types/keyword_color'
+require 'style_train/color_types/hex_color'
+require "style_train/color"
+# require 'lib/palette'
+
+require "style_train/sheet"
+# require 'set'
+# require 'style'   

data/spec/color/color_spec.rb

@@ -0,0 +1,224 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+Color = StyleTrain::Color unless defined?(Color)
+HexColor = StyleTrain::HexColor unless defined?( HexColor )
+KeywordColor = StyleTrain::KeywordColor unless defined?( KeywordColor )
+RGBcolor = StyleTrain::RGBcolor unless defined?( RGBcolor )
+
+describe Color do
+  def build_color_type( color_class, args ) 
+    color_class.new(:color => args)
+  end
+  
+  describe 'alpha' do
+    it 'should be delegated' do
+      color = Color.new(:black, :alpha => 0.5)
+      color.alpha.should == 0.5
+    end 
+  
+    it 'setter should be delegated' do 
+      color = Color.new(:black)
+      color.alpha = 0.5
+      color.delegate.alpha.should == 0.5
+    end  
+  end  
+   
+  describe 'initialization' do
+    describe 'with an existing color' do
+      it 'should build a delegate of the existing type' do 
+        Color.new(Color.new(:white)).delegate.should == build_color_type(KeywordColor, :white)
+        Color.new(Color.new('#FFF')).delegate.should == build_color_type(HexColor, '#FFF')
+        Color.new(Color.new([255,255,255])).delegate.should == build_color_type(RGBcolor, [255,255,255])
+      end
+      
+      it 'should set the background if the argument color has a background' do
+        Color.new(Color.new(:white), :background => :gray).background.should == Color.new(:gray)
+        Color.new(Color.new(:white)).background_set.should_not be_true
+      end
+      
+      it 'after the new color is created changes to the delegate should not change the original' do
+        original = Color.new(:white)
+        new_color = Color.new(original, :background => :black, :alpha => 0.5)
+        original.alpha.should == 1.0
+      end 
+      
+      it 'should set the alpha' do
+        color = Color.new(Color.new(:white), :alpha => 0.5)
+        color.alpha.should == 0.5
+      end        
+    end 
+     
+    describe 'assigns a delegate' do
+      describe 'with a keyword argument' do
+        it 'should build an html keyword color' do
+          Color.new("gray").delegate.should == build_color_type(KeywordColor, 'gray')
+        end 
+
+        it 'should build a svg keyword color' do 
+          Color.new(:linen).delegate.should == build_color_type(KeywordColor, :linen)
+        end
+      end   
+ 
+      describe 'with a hex string argument' do
+        it '(3-digit no #) should build a hex color' do 
+          Color.new('333').delegate.should == build_color_type(HexColor, '333')
+        end
+      
+        it '(3-digit with #) should build a hex color' do 
+          Color.new('#333').delegate.should == build_color_type(HexColor, '#333')
+        end
+      
+        it '(6-digit no #) should build a hex color' do  
+          Color.new('333333').delegate.should == build_color_type(HexColor, '333333')
+        end
+      
+        it '(6-digit with #) should build a hex color' do
+          Color.new('#333333').delegate.should == build_color_type(HexColor, '#333333')
+        end
+      end
+ 
+      describe 'with an rgb array argument' do
+        it '(with a byte array) should build a rgb color' do
+          Color.new([127,127,127]).delegate.should == build_color_type(RGBcolor, [127,127,127])
+        end
+      
+        it '(with a percentage array) should build a rgb color' do
+          Color.new(['50%','50%','50%']).delegate.should == build_color_type(RGBcolor, [127,127,127])
+        end
+      end
+    
+      describe 'hsl colors' 
+    end
+    
+    describe 'options' do
+      it 'should pass on the alpha argument' do
+        color = Color.new(:black, :alpha => 0.5)
+        color.alpha.should == 0.5
+      end
+    end    
+  end 
+  
+  describe 'comparison' do
+    before do
+      @color = Color.new(:black)
+      @color_type = KeywordColor.new(:color => :black)
+      @color_type_too = RGBcolor.new(:color => [0,0,0])
+      @color_too = Color.new(:black)
+    end
+    
+    describe '=~' do
+      describe 'with another Color object' do
+        it 'should not be true if the delegates don\'t match' do
+          (@color =~ Color.new(:white)).should_not be_true  
+        end
+        
+        it 'should be indifferent to background' do
+          (@color =~ Color.new(:black, :background => :yellow)).should be_true
+        end
+        
+        it 'should be true if background and delegate match' do
+          (@color =~ @color_too).should be_true
+        end
+      end
+      
+      describe 'with a ColorType object' do
+        it 'should be true if the delegate matches the ColorType' do
+          (@color =~ @color_type).should be_true 
+          (@color =~ @color_type_too).should be_true
+        end
+      end
+    end  
+    
+    describe '==' do
+      describe 'with another Color object' do
+        it 'should not be true if the delegates don\'t match' do
+          (@color == Color.new(:white)).should_not be_true  
+        end
+        
+        it 'should be indifferent to background' do
+          (@color == Color.new(:black, :background => :yellow)).should_not be_true
+        end
+        
+        it 'should be true if background and delegate match' do
+          (@color == @color_too).should be_true 
+        end
+      end
+      
+      describe 'with a ColorType object' do
+        it 'should be false' do
+          (@color == @color_type).should be_false
+        end
+      end
+    end  
+  end    
+
+  describe 'background' do
+    before do
+      @color = Color.new(:black, :alpha => 0.5)
+    end
+    
+    it 'should have a white opaque background by default' do
+      @color.background.should =~ Color.new(:white)
+    end 
+    
+    it 'should be settable' do
+      @color.background = :black
+      @color.background.should =~ Color.new(:black)
+    end
+    
+    it 'should ignore alpha' do
+      @color.background = {:color => :black, :alpha => 0.5 }
+      @color.background.delegate.should == Color.new(:black, :alpha => 1.0).delegate
+    end 
+    
+    it 'should be initalized into the instance' do
+      color = Color.new(:black, :background => :yellow)
+      color.background.should =~ Color.new(:yellow)
+    end
+    
+    it 'should set a flag when it is set not by default' do
+      color = Color.new(:black) 
+      color.background
+      color.background_set.should_not == true
+      
+      color = Color.new(:black, :background => :yellow)
+      color.background_set.should == true
+    end
+  end
+  
+  describe 'rendering' do
+    it 'should render via the delegates default method by default' do
+      Color.new(:white).render.should == build_color_type(KeywordColor, :white).render_as_given
+      Color.new(['100%', '100%', '100%']).render.should == build_color_type(RGBcolor, ['100%', '100%', '100%']).render_as_given
+      Color.new([255,255,255]).render.should == build_color_type(RGBcolor, [255,255,255]).render_as_given
+      Color.new('#FFF').render.should == build_color_type(HexColor, '#FFF').render_as_given
+    end 
+    
+    it 'should render rgba if it has transparency' do  
+      Color.new(:white, :alpha => 0.5).render.should =~ /rgba/
+      Color.new(['100%', '100%', '100%'], :alpha => 0.5).render.should =~ /rgba/ 
+      Color.new([255,255,255], :alpha => 0.5).render.should =~ /rgba/ 
+      Color.new('#FFF', :alpha => 0.5).render.should =~ /rgba/ 
+    end
+    
+    describe 'ie' do
+      it 'should render as a hex color' do 
+        Color.new(:white).render(:ie).should == build_color_type(HexColor, '#ffffff').render_as_given
+        Color.new(['100%', '100%', '100%']).render(:ie).should == build_color_type(HexColor, '#ffffff').render_as_given
+        Color.new([255,255,255]).render(:ie).should == build_color_type(HexColor, '#ffffff').render_as_given
+        Color.new('#FFF').render(:ie).should == build_color_type(HexColor, '#ffffff').render_as_given 
+      end 
+      
+      it 'should render delegate layered on the background if there is transparency and as a hex color' do
+        Color.new(:black, :alpha => 0.5).render(:ie).should == build_color_type( HexColor, '#808080' ).render
+        Color.new(['0%', '0%', '0%'], :alpha => 0.5).render(:ie).should == build_color_type( HexColor, '#808080' ).render
+        Color.new([255,255,255], :alpha => 0.5, :background => :black).render(:ie).should == build_color_type( HexColor, '#808080' ).render
+        Color.new('#FFF', :alpha => 0.5, :background => :black).render(:ie).should == build_color_type( HexColor, '#808080' ).render    
+      end
+    end
+    
+    it 'should alias #to_s to render' do
+      Color.new(:black, :alpha => 0.5).to_s.should == Color.new(:black, :alpha => 0.5).render
+    end
+  end
+end

data/spec/color/color_type_spec.rb

@@ -0,0 +1,370 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+ColorType = StyleTrain::ColorType unless defined?( ColorType ) 
+HexColor = StyleTrain::HexColor unless defined?( HexColor )
+KeywordColor = StyleTrain::KeywordColor unless defined?( KeywordColor )
+RGBcolor = StyleTrain::RGBcolor unless defined?( RGBcolor )
+
+describe ColorType do 
+  describe 'class methods' do
+    describe 'percentages' do
+      it 'should return false if string does not contain a percentage' do 
+        ColorType.percentage( '255' ).should == false
+      end  
+    
+      it 'should return the number' do
+        ColorType.percentage( '33%' ).should == 33
+      end
+    
+      it 'should return decimal values of percentages' do
+        ColorType.percentage( '33.5%' ).should == 33.5
+      end 
+    
+      it 'should raise an argument error if the percentage is out of range' do 
+        lambda { ColorType.percentage( '133%' ) }.should raise_error( ArgumentError )
+      end  
+    end
+  
+    describe 'byte numbers' do
+      it 'should return the number' do
+        ColorType.byte( '33' ).should == 33
+        ColorType.byte( '0' ).should == 0
+      end
+    
+      it 'should raise an argument error if the number is out of range' do 
+        lambda { ColorType.byte( '256' ) }.should raise_error( ArgumentError )
+      end  
+    end
+  
+    describe 'conversion' do
+      it 'should convert from byte numbers to percentages' do 
+        ColorType.byte_to_percentage( 255 ).should == 100
+        ColorType.byte_to_percentage( 127 ).should == 50
+        ColorType.byte_to_percentage( 64 ).should == 25
+        ColorType.byte_to_percentage( 0 ).should == 0
+        lambda{ ColorType.byte_to_percentage(256) }.should raise_error( ColorType::ByteNumberError )
+        lambda{ ColorType.byte_to_percentage(-5) }.should raise_error( ColorType::ByteNumberError )
+        lambda{ ColorType.byte_to_percentage(122.6) }.should_not raise_error
+      end
+  
+      it 'should convert from percentage to byte' do 
+        ColorType.percent_to_byte( 100 ).should == 255
+        ColorType.percent_to_byte( 50 ).should == 127
+        ColorType.percent_to_byte( 25 ).should == 64
+        ColorType.percent_to_byte( 0 ).should == 0
+        lambda{ ColorType.percent_to_byte(101) }.should raise_error( ColorType::PercentageError )
+        lambda{ ColorType.percent_to_byte(-5) }.should raise_error( ColorType::PercentageError )
+        lambda{ ColorType.percent_to_byte(22.6) }.should_not raise_error 
+      end 
+      
+      it 'custom argument errors should raise custom messages' do
+        begin
+          ColorType.percent_to_byte(101)
+        rescue Exception => e
+          e.message.match(/must be between 0 and/)
+        end
+    
+        begin
+          ColorType.byte_to_percentage(256)
+        rescue Exception => e
+          e.message.match(/must be between 0 and/)
+        end    
+      end         
+    end
+  
+    describe '#is_color?' do
+      it 'should recognize any of the color types' do
+        ColorType.is_color?(KeywordColor.new(:color => :linen)).should be_true
+        ColorType.is_color?(RGBcolor.new(:color => [0,0,0])).should be_true
+      end
+      
+      it 'should be false if not a color type' do
+        ColorType.is_color?( nil ).should be_false
+        ColorType.is_color?( {} ).should be_false
+        ColorType.is_color?( [] ).should be_false
+      end
+    end
+  
+    describe '#make' do
+      it 'returns nil if not the right type' do
+        HexColor.make(:color => :lightyellow).should be_nil
+      end
+      
+      it 'returns an instance on the color type if arguments are correct' do
+        KeywordColor.make(:color => :lightyellow).is_a?(KeywordColor).should be_true
+      end
+    end
+  end
+  
+  describe 'instance methods' do
+    describe 'conversion' do
+      describe 'from rgb' do
+        before do
+          @color = RGBcolor.new(:color => [0,0,0])
+        end 
+        
+        it 'to keyword works' do
+          new_color = @color.to(:keyword)
+          new_color.class.should == KeywordColor 
+          new_color.keyword.should == :black
+        end  
+        
+        it 'to hex works' do
+          new_color = @color.to(:hex)
+          new_color.class.should == HexColor 
+          new_color.hex_6.should == 0x000000
+        end
+      end
+      
+      describe 'from hex' do
+        before do
+          @color = HexColor.new(:color => '#000')
+        end
+        
+        it 'to keyword works' do
+          new_color = @color.to(:keyword) 
+          new_color.class.should == KeywordColor 
+          new_color.keyword.should == :black
+        end
+        
+        it 'to rgb works' do 
+          new_color = @color.to(:rgb)
+          new_color.class.should == RGBcolor 
+          new_color.red.should == 0
+          new_color.green.should == 0
+          new_color.blue.should == 0
+        end
+      end  
+      
+      describe 'from keyword' do
+        before do
+          @color = KeywordColor.new(:color => :black)
+        end
+        
+        it 'to rgb works' do 
+          new_color = @color.to(:rgb)
+          new_color.class.should == RGBcolor 
+          new_color.red.should == 0
+          new_color.green.should == 0
+          new_color.blue.should == 0
+        end 
+        
+        it 'to hex works' do
+          new_color = @color.to(:hex)
+          new_color.class.should == HexColor 
+          new_color.hex_6.should == 0x000000
+        end  
+      end
+    end
+  
+    describe 'alpha' do 
+      before do 
+        @color = KeywordColor.new(:color => :black)
+      end
+      
+      it 'should be 1.0 by default' do
+        @color.alpha.should == 1.0
+      end
+      
+      it 'should be 1.0 if alpha is entered as 1' do
+        @color.alpha = 1
+        @color.alpha.should == 1.0
+      end
+      
+      it 'should be be 0.0 if set to 0' do
+        @color.alpha = 0
+        @color.alpha.should == 0.0
+      end
+      
+      it 'should be a decimal value between zero and one if set that way' do
+        @color.alpha = 0.5
+        @color.alpha.should == 0.5
+      end
+      
+      it 'should be set via the initializer' do
+        color = KeywordColor.new(:color => :black, :alpha => 0.5) 
+        color.alpha.should == 0.5
+      end 
+      
+      it 'should raise an error if out of range' do
+        lambda{ @color.alpha = 1.5 }.should raise_error
+      end 
+      
+      describe '#alpha?' do
+        it '#should be false if alpha value is 1.0' do
+          @color.alpha?.should == false
+        end  
+      
+        it 'should be true if alpha is greater than 0 and less than 1' do
+          @color.alpha = 0.5
+          @color.alpha?.should be_true
+        end 
+      end  
+    end                  
+    
+    describe 'comparisons' do
+      before do
+        @hex = HexColor.new(:color => '#000')
+        @keyword = KeywordColor.new(:color => :black)
+      end
+       
+      describe '=~' do
+        it 'should be true if the r, g, b values are the same' do
+          (@hex =~ @keyword).should == true
+        end
+        
+        it 'should be true even if the alpha values are different' do
+          @hex.alpha = 0.5
+          (@hex =~ @keyword).should == true
+        end
+        
+        it 'should compare with the delagate of a color' do
+          (@hex =~ StyleTrain::Color.new('#000')).should == true
+          (@hex =~ StyleTrain::Color.new('#fff')).should == false
+        end 
+      end
+      
+      describe '==' do
+        it 'should be true if the colors are =~ and also have the same alpha' do
+          (@hex == @keyword).should == true
+        end
+        
+        it 'should be false if the alphas are different' do 
+          @hex.alpha = 0.5
+          (@hex == @keyword).should == false
+        end
+        
+        it 'should be false if the r, g, b values are different' do
+          color = KeywordColor.new(:color => :maroon)
+          (color == @keyword).should == false
+        end
+      end
+      
+      describe '===' do
+        before do
+          @key2 = KeywordColor.new(:color => :black)
+        end
+          
+        it 'should be true if the colors are == and also have the same class' do
+          (@key2 === @keyword).should == true
+        end 
+        
+        it 'should be false if the classes are different' do
+          (@keyword === @hex).should == false
+        end
+        
+        it 'should be false if the alphas are different' do 
+          @key2.alpha = 0.5
+          (@key2 == @keyword).should == false
+        end
+        
+        it 'should be false if the r, g, b values are different' do
+          color = KeywordColor.new(:color => :maroon)
+          (color == @keyword).should == false
+        end 
+      end    
+    end
+    
+    describe 'mixing' do
+      before do
+        @rgb = RGBcolor.new(:color => [20,40,60], :alpha => 0.5)
+        @hex = HexColor.new(:color => '#666') 
+      end
+      
+      describe 'averaging' do
+        it 'should average the r, g, and b values' do
+          color = @rgb.mix(@hex)
+          color.r.should == ((102+20)/2.0).round
+          color.g.should == ((102+40)/2.0).round
+          color.b.should == ((102+60)/2.0).round
+        end 
+        
+        it 'should average the alpha' do
+          color = @rgb.mix(@hex)
+          color.alpha.should == 0.75
+        end
+        
+        it 'should return the original color type' do 
+          color = @rgb.mix(@hex)
+          color.class.should == RGBcolor
+          
+          color = @hex.mix(@rgb)
+          color.class.should == HexColor
+        end
+      end 
+      
+      describe 'layering' do
+        before do
+          @white = HexColor.new(:color => '#FFF')
+          @shadow = HexColor.new(:color => '#000', :alpha => 0.5)
+        end 
+        
+        it 'should blend on the class method' do
+          ColorType.blend(255, 0, 0.5).should == 128
+          ColorType.blend(128, 0, 0.5).should == 64
+          ColorType.blend(255, 0, 0.25).should == 64
+        end
+        
+        describe 'r, g, b' do
+          describe 'opaque top layer' do
+            it 'should have the r, g, b values of the top layer' do
+              color = @rgb.layer(@hex)
+              color.r.should == 102 
+              color.g.should == 102
+              color.b.should == 102 
+            end
+          end  
+        
+          describe 'opaque bottom layer' do
+            before do
+              @color = @white.layer(@shadow) 
+            end 
+          
+            it 'should mix the r, g, and b in proportion to the top layer\'s alpha' do
+              @color.r.should == 128
+              @color.g.should == 128
+              @color.b.should == 128 
+            
+              red = RGBcolor.new(:color => [153,0,0], :alpha => 0.25)
+              color = @white.layer(red)
+              color.r.should == (153*0.25 + 255*0.75).round
+              color.g.should == (0*0.25 + 255*0.75).round
+              color.b.should == (0*0.25 + 255*0.75).round
+            end
+          end
+        end
+        
+        describe 'alpha blending' do
+          it 'should be 1.0 if bottom layer is opaque' do 
+            color = @white.layer(@shadow)
+            color.alpha.should == 1.0
+          end
+          
+          it 'should be 1.0 if the top layer is opaque' do
+            color = @shadow.layer(@white)
+            color.alpha.should == 1.0
+          end   
+          
+          it 'should have an alpha greater than or equal to the composites' do
+            color = @rgb.layer(@shadow)
+            (color.alpha >= @rgb.alpha).should be_true
+            (color.alpha >= @shadow.alpha).should be_true
+          end
+          
+          it 'should calculate the blending of two alphas properly' do
+            color = @rgb.layer(@shadow)
+            color.alpha.should == 0.75 # 0.5 for the base color, plus 0.5 of the remaining transparency
+          end  
+        end 
+      end  
+      
+      describe 'stepping'
+      
+    end
+
+    describe 'rendering' do
+      # todo: do color specs first, to work out where the blending of background should happen
+    end
+  end
+
+end