style_train 0.3.2 → 0.4.0

data/lib/style_train/color_types/hex_color.rb

@@ -1,44 +0,0 @@
-module StyleTrain
-  class HexColor < ColorType 
-    class HexError < ArgumentError 
-      def message 
-        @message ||= 'Hexidecimal colors should be 3 or 6 hexidecimal digits and can be preceded by a # sign'
-      end 
-    end  
-  
-    attr_accessor :hex, :hex_6
-  
-    def type_initialize( color, opts ) 
-      hex = color.to_s 
-      raise HexError unless hex.match(/^#?([a-f0-9]{3})$/i) || hex.match(/^#?([a-f0-9]{6})$/i)
-      self.hex = "#{$1}"
-      self.hex_6 =  self.class.expand( self.hex ) 
-      self.r = (self.hex_6 / 0x10000) & 0xff
-      self.g = (self.hex_6 / 0x100) & 0xff
-      self.b = (self.hex_6) & 0xff
-    end
-  
-    def build 
-      self.hex =  "%.2x" % self.r + "%.2x" % self.g + "%.2x" % self.b
-      self.hex_6 = ('0x' + self.hex).to_i(16)
-    end  
-      
-    def self.expand( hex ) 
-      expanded = if (hex.size == 3)
-        str = ''
-        (0..2).each do |index|
-          char = hex[index..index]
-          str << char*2
-        end
-        str
-      else
-        hex
-      end
-      "0x#{expanded}".to_i(16)       
-    end
-  
-    def render_as_given
-      "##{self.hex}"
-    end 
-  end 
-end 

data/lib/style_train/color_types/hsl_color.rb

@@ -1,5 +0,0 @@
-# todo: when needed
-module StyleTrain
-  class HSLcolor < ColorType 
-  end
-end     

data/lib/style_train/color_types/keyword_color.rb

@@ -1,192 +0,0 @@
-module StyleTrain
-  class KeywordColor < ColorType 
-    class KeywordError < ArgumentError 
-      def message 
-        @message ||= 'Keyword not found'
-      end 
-    end  
-  
-    KEYWORD_MAP = {
-      :aliceblue	=>	[240, 248, 255],
-   	 	:antiquewhite	=>	[250, 235, 215],
-   	 	:aqua	=>	[0, 255, 255],
-   	 	:aquamarine	=>	[127, 255, 212],
-   	 	:azure	=>	[240, 255, 255],
-   	 	:beige	=>	[245, 245, 220],
-   	 	:bisque	=>	[255, 228, 196],
-   	 	:black	=>	[0, 0, 0],
-   	 	:blanchedalmond	=>	[255, 235, 205],
-   	 	:blue	=>	[0, 0, 255],
-   	 	:blueviolet	=>	[138, 43, 226],
-   	 	:brown	=>	[165, 42, 42],
-   	 	:burlywood	=>	[222, 184, 135],
-   	 	:cadetblue	=>	[95, 158, 160],
-   	 	:chartreuse	=>	[127, 255, 0],
-   	 	:chocolate	=>	[210, 105, 30],
-   	 	:coral	=>	[255, 127, 80],
-   	 	:cornflowerblue	=>	[100, 149, 237],
-   	 	:cornsilk	=>	[255, 248, 220],
-   	 	:crimson	=>	[220, 20, 60],
-   	 	:cyan	=>	[0, 255, 255],
-   	 	:darkblue	=>	[0, 0, 139],
-   	 	:darkcyan	=>	[0, 139, 139],
-   	 	:darkgoldenrod	=>	[184, 134, 11],
-   	 	:darkgray	=>	[169, 169, 169],
-   	 	:darkgreen	=>	[0, 100, 0],
-   	 	:darkgrey	=>	[169, 169, 169],
-   	 	:darkkhaki	=>	[189, 183, 107],
-   	 	:darkmagenta	=>	[139, 0, 139],
-   	 	:darkolivegreen	=>	[85, 107, 47],
-   	 	:darkorange	=>	[255, 140, 0],
-   	 	:darkorchid	=>	[153, 50, 204],
-   	 	:darkred	=>	[139, 0, 0],
-   	 	:darksalmon	=>	[233, 150, 122],
-   	 	:darkseagreen	=>	[143, 188, 143],
-   	 	:darkslateblue	=>	[72, 61, 139],
-   	 	:darkslategray	=>	[47, 79, 79],
-   	 	:darkslategrey	=>	[47, 79, 79],
-   	 	:darkturquoise	=>	[0, 206, 209],
-   	 	:darkviolet	=>	[148, 0, 211],
-   	 	:deeppink	=>	[255, 20, 147],
-   	 	:deepskyblue	=>	[0, 191, 255],
-   	 	:dimgray	=>	[105, 105, 105],
-   	 	:dimgrey	=>	[105, 105, 105],
-   	 	:dodgerblue	=>	[30, 144, 255],
-   	 	:firebrick	=>	[178, 34, 34],
-   	 	:floralwhite	=>	[255, 250, 240],
-   	 	:forestgreen	=>	[34, 139, 34],
-   	 	:fuchsia	=>	[255, 0, 255],
-   	 	:gainsboro	=>	[220, 220, 220],
-   	 	:ghostwhite	=>	[248, 248, 255],
-   	 	:gold	=>	[255, 215, 0],
-   	 	:goldenrod	=>	[218, 165, 32],
-   	 	:gray	=>	[128, 128, 128],
-   	 	:green	=>	[0, 128, 0],
-   	 	:greenyellow	=>	[173, 255, 47],
-   	 	:grey	=>	[128, 128, 128],
-   	 	:honeydew	=>	[240, 255, 240],
-   	 	:hotpink	=>	[255, 105, 180],
-   	 	:indianred	=>	[205, 92, 92],
-   	 	:indigo	=>	[75, 0, 130],
-   	 	:ivory	=>	[255, 255, 240],
-   	 	:khaki	=>	[240, 230, 140],
-   	 	:lavender	=>	[230, 230, 250],
-   	 	:lavenderblush	=>	[255, 240, 245],
-   	 	:lawngreen	=>	[124, 252, 0],
-   	 	:lemonchiffon	=>	[255, 250, 205],
-   	 	:lightblue	=>	[173, 216, 230],
-   	 	:lightcoral	=>	[240, 128, 128],
-   	 	:lightcyan	=>	[224, 255, 255],
-   	 	:lightgoldenrodyellow	=>	[250, 250, 210],
-   	 	:lightgray	=>	[211, 211, 211],
-   	 	:lightgreen	=>	[144, 238, 144],
-   	 	:lightgrey	=>	[211, 211, 211],
-   	 	:lightpink	=>	[255, 182, 193],
-   	 	:lightsalmon	=>	[255, 160, 122],
-   	 	:lightseagreen	=>	[32, 178, 170],
-   	 	:lightskyblue	=>	[135, 206, 250],
-   	 	:lightslategray	=>	[119, 136, 153],
-   	 	:lightslategrey	=>	[119, 136, 153],
-   	 	:lightsteelblue	=>	[176, 196, 222],
-   	 	:lightyellow	=>	[255, 255, 224],
-   	 	:lime	=>	[0, 255, 0],
-   	 	:limegreen	=>	[50, 205, 50],
-   	 	:linen	=>	[250, 240, 230],
-   	 	:magenta	=>	[255, 0, 255],
-   	 	:maroon	=>	[128, 0, 0],
-   	 	:mediumaquamarine	=>	[102, 205, 170],
-   	 	:mediumblue	=>	[0, 0, 205],
-   	 	:mediumorchid	=>	[186, 85, 211],
-   	 	:mediumpurple	=>	[147, 112, 219],
-   	 	:mediumseagreen	=>	[60, 179, 113],
-   	 	:mediumslateblue	=>	[123, 104, 238],
-   	 	:mediumspringgreen	=>	[0, 250, 154],
-   	 	:mediumturquoise	=>	[72, 209, 204],
-   	 	:mediumvioletred	=>	[199, 21, 133],
-   	 	:midnightblue	=>	[25, 25, 112],
-   	 	:mintcream	=>	[245, 255, 250],
-   	 	:mistyrose	=>	[255, 228, 225],
-   	 	:moccasin	=>	[255, 228, 181],
-   	 	:navajowhite	=>	[255, 222, 173],
-   	 	:navy	=>	[0, 0, 128],
-   	 	:oldlace	=>	[253, 245, 230],
-   	 	:olive	=>	[128, 128, 0],
-   	 	:olivedrab	=>	[107, 142, 35],
-   	 	:orange	=>	[255, 165, 0],
-   	 	:orangered	=>	[255, 69, 0],
-   	 	:orchid	=>	[218, 112, 214],
-   	 	:palegoldenrod	=>	[238, 232, 170],
-   	 	:palegreen	=>	[152, 251, 152],
-   	 	:paleturquoise	=>	[175, 238, 238],
-   	 	:palevioletred	=>	[219, 112, 147],
-   	 	:papayawhip	=>	[255, 239, 213],
-   	 	:peachpuff	=>	[255, 218, 185],
-   	 	:peru	=>	[205, 133, 63],
-   	 	:pink	=>	[255, 192, 203],
-   	 	:plum	=>	[221, 160, 221],
-   	 	:powderblue	=>	[176, 224, 230],
-   	 	:purple	=>	[128, 0, 128],
-   	 	:red	=>	[255, 0, 0],
-   	 	:rosybrown	=>	[188, 143, 143],
-   	 	:royalblue	=>	[65, 105, 225],
-   	 	:saddlebrown	=>	[139, 69, 19],
-   	 	:salmon	=>	[250, 128, 114],
-   	 	:sandybrown	=>	[244, 164, 96],
-   	 	:seagreen	=>	[46, 139, 87],
-   	 	:seashell	=>	[255, 245, 238],
-   	 	:sienna	=>	[160, 82, 45],
-   	 	:silver	=>	[192, 192, 192],
-   	 	:skyblue	=>	[135, 206, 235],
-   	 	:slateblue	=>	[106, 90, 205],
-   	 	:slategray	=>	[112, 128, 144],
-   	 	:slategrey	=>	[112, 128, 144],
-   	 	:snow	=>	[255, 250, 250],
-   	 	:springgreen	=>	[0, 255, 127],
-   	 	:steelblue	=>	[70, 130, 180],
-   	 	:tan	=>	[210, 180, 140],
-   	 	:teal	=>	[0, 128, 128],
-   	 	:thistle	=>	[216, 191, 216],
-   	 	:tomato	=>	[255, 99, 71],
-   	 	:turquoise	=>	[64, 224, 208],
-   	 	:violet	=>	[238, 130, 238],
-   	 	:wheat	=>	[245, 222, 179],
-   	 	:white	=>	[255, 255, 255],
-   	 	:whitesmoke	=>	[245, 245, 245],
-   	 	:yellow	=>	[255, 255, 0],
-   	 	:yellowgreen	=>	[154, 205, 50],
-      :transparent => [0,0,0]
-    }
-
-    attr_reader :keyword
-  
-    def keyword=( color )
-      color = color.to_sym
-      raise KeywordError, "'#{color}' not found" unless KEYWORD_MAP.keys.include?( color )
-      @keyword = color.to_sym 
-      mapped = KEYWORD_MAP[color]
-      self.r = mapped[0]
-      self.g = mapped[1]
-      self.b = mapped[2] 
-    end  
-  
-    def type_initialize( color, opts )
-      self.keyword = color 
-    end
-  
-    def build 
-      # TODO: map to closest color instead of throwing an error
-      found = false
-      KEYWORD_MAP.each do |keyword, rgb| 
-        if self.r == rgb[0] && self.g == rgb[1] && self.b == rgb[2]
-          found = true
-          self.keyword = keyword
-        end  
-      end 
-      raise KeywordError, "Keyword match not found for color matching rgb( #{self.r}, #{self.g}, #{self.b} )" unless found 
-    end
-  
-    def render_as_given 
-      self.keyword.to_s
-    end  
-  end 
-end 

data/lib/style_train/color_types/rgb_color.rb

@@ -1,57 +0,0 @@
-module StyleTrain 
-  class RGBcolor < ColorType
-    attr_reader :red, :green, :blue # these are the entered values, not the calculated values 
-
-    METHOD_MAP ={
-      'r' => 'red',
-      'g' => 'green',
-      'b' => 'blue'
-    } 
-  
-    ['red', 'green', 'blue'].each do |clr|
-      class_eval " 
-        def #{clr}=( value )
-          @#{clr} = value
-          self.#{clr[0..0]} = value  
-        end 
-      "
-    end  
-  
-    ['r', 'g', 'b'].each do |clr| 
-      class_eval "
-        def #{clr}=( value )
-          @#{clr} = normalize_internal_rgb( value )  
-        end  
-      "
-    end
-  
-    def type_initialize( color, opts )
-      if color.is_a? Array  
-        self.red =    color[0]
-        self.green =  color[1]
-        self.blue =   color[2] 
-      else
-        raise ArgumentError, 'RGB color must be initialized with a :color opts argument that is an array' unless color && color.class == Array
-      end  
-    end
-  
-    def build
-      self.red =    self.r
-      self.green =  self.g
-      self.blue =   self.b
-    end    
-  
-    def normalize_internal_rgb( value )
-      if percentage = self.class.percentage( value )
-        percentage = value.to_i
-        self.class.percent_to_byte( percentage )
-      else
-        value.to_i if self.class.valid_byte?( value, true )
-      end
-    end     
-  
-    def render_as_given
-      "rgb( #{self.red}, #{self.green}, #{self.blue} )"
-    end  
-  end
-end  

data/spec/color/color_spec.rb

@@ -1,252 +0,0 @@
-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
-  
-  describe 'stepping' do
-    before :all do
-      @black = Color.new('#000')
-      @yellow = Color.new(:lightyellow, :alpha => 0.5)
-      @steps = @black.step(@yellow)
-    end
-    
-    it 'returs an array' do
-      @steps.is_a?(Array).should be_true
-    end
-    
-    it 'has 10 steps by default' do
-      @steps.size.should == 10
-    end
-    
-    it 'has takes optional number of steps' do
-      @black.step(@yellow, 5).size.should == 5
-    end
-    
-    it 'first color should be the starting point' do
-      @steps.first.should == @black.delegate
-    end
-    
-    it 'last color should be the last point' do
-      @steps.last.should == @yellow.delegate
-    end
-  end
-end