style_train 0.2.1 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.3

data/lib/style_train/color.rb

@@ -82,7 +82,19 @@ module StyleTrain
     
       self.background_set = true
       @background  
-    end     
+    end
+    
+    def step(end_color, steps=10)
+      start_color = self.delegate
+      end_color = end_color.delegate
+      array = [start_color]
+      (2..(steps-1)).each do |number|
+        ratio = 1 - (steps-number)/steps.to_f
+        array << start_color.mix(end_color, ratio)
+      end
+      array << end_color
+      array
+    end    
   
     def render(render_style=nil) 
       if render_style && render_style.to_sym == :ie

data/lib/style_train/color_types/color_type.rb

@@ -87,12 +87,13 @@ module StyleTrain
     end 
   
     # blending
-    def mix( color )
+    def mix( color, mix_ratio=0.5 )
+      mix_ratio = 1-mix_ratio
       mixed = self.dup
-      mixed.r = self.class.average(self.r, color.r)
-      mixed.g = self.class.average(self.g, color.g)
-      mixed.b = self.class.average(self.b, color.b)
-      mixed.alpha = self.class.average(self.alpha, color.alpha, false)
+      mixed.r = ratio(self.r, color.r, mix_ratio)
+      mixed.g = ratio(self.g, color.g, mix_ratio)
+      mixed.b = ratio(self.b, color.b, mix_ratio)
+      mixed.alpha = ratio(self.alpha, color.alpha, mix_ratio, false)
       mixed.build
       mixed
     end
@@ -109,13 +110,27 @@ module StyleTrain
     end
   
     def self.blend(first, second, ratio) 
-      blended = (first*ratio + second*(1-ratio)).round
+      ratio(first, second, ratio)
     end    
   
     def self.average(first, second, round=true)
-      averaged = ((first + second)/2.0)
-      round ? averaged.round : averaged
+      ratio(first, second, round)
+    end
+    
+    def self.ratio(first, second, first_ratio=0.5, round=true)
+      second_ratio = 1-first_ratio
+      value = first*first_ratio + second*second_ratio
+      round ? value.round : value 
+    end
+    
+    def ratio *args
+      self.class.ratio *args
+    end 
+  
+    def average *args
+      self.class.average *args
     end 
+    
   
     def self.blend_alphas(first, second)
       base, blender = first > second ? [first, second] : [second, first]

data/lib/style_train/sheet.rb

@@ -61,7 +61,9 @@ module StyleTrain
     
     def property( label, value )
       value = value.join(' ') if value.is_a?(Array)
-      self.output << "\n#{indent}#{label}: #{value};"
+      str = "\n#{indent}#{label}: #{value};"
+      self.output << str
+      str
     end
     
     def background( opts )
@@ -222,6 +224,107 @@ module StyleTrain
       RUBY
     end
     
+    def corners(opts)
+      str = ""
+      if opts.is_a?(Hash)
+        if opts[:left]
+          str << corner_top_left( opts[:left] )
+          str << corner_bottom_left( opts[:left] )
+        end
+        
+        if opts[:right]
+          str << corner_top_right( opts[:right] )
+          str << corner_bottom_right( opts[:right] )
+        end
+        
+        if opts[:top]
+          str << corner_top_right( opts[:top] )
+          str << corner_top_left( opts[:top] )
+        end
+        
+        if opts[:bottom]
+          str << corner_bottom_right( opts[:bottom] )
+          str << corner_bottom_left( opts[:bottom] )
+        end
+        
+        str << corner_top_left( opts[:top_left] )         if opts[:top_left]
+        str << corner_top_right( opts[:top_right] )       if opts[:top_right]
+        str << corner_bottom_left( opts[:bottom_left] )   if opts[:bottom_left]
+        str << corner_bottom_right( opts[:bottom_right] ) if opts[:bottom_right]
+      else
+        str << property('border-radius', opts )
+        str << property('-moz-border-radius', opts)
+        str << property('-webkit-border-radius', opts)
+      end
+      str
+    end
+    
+    def corner_top_left size
+      str = ""
+      str << property('border-top-left-radius', size)
+      str << property('-moz-border-radius-topleft', size)
+      str << property('-webkit-border-top-left-radius', size)
+      str
+    end
+    
+    def corner_bottom_left size
+      str = ""
+      str << property('border-bottom-left-radius', size)
+      str << property('-moz-border-radius-bottomleft', size)
+      str << property('-webkit-border-bottom-left-radius', size)
+      str
+    end
+    
+    def corner_top_right size
+      str = ""
+      str << property('border-top-right-radius', size)
+      str << property('-moz-border-radius-topright', size)
+      str << property('-webkit-border-top-right-radius', size)
+      str
+    end
+    
+    def corner_bottom_right size
+      str = ""
+      str << property('border-bottom-right-radius', size)
+      str << property('-moz-border-radius-bottomright', size)
+      str << property('-webkit-border-bottom-right-radius', size)
+      str
+    end
+    
+    def shadow(opts={})
+      opts[:horizontal_offset] ||= default_shadow_offset
+      opts[:vertical_offset] ||= default_shadow_offset
+      opts[:blur] ||= default_shadow_offset
+      opts[:color] ||= default_shadow_color
+      str = ""
+      str << property('box-shadow', shadow_options(opts))
+      str << property('-webkit-box-shadow', shadow_options(opts))
+      str << property('-moz-box-shadow', shadow_options(opts))
+      str
+    end
+    
+    def default_shadow_offset
+      0.25.em # this can be overwritten on a class by class basis
+    end
+    
+    def default_shadow_color
+      :black # this too
+    end
+    
+    def shadow_options(opts)
+      "#{opts[:inner] ? 'inset ' : ''}#{opts[:horizontal_offset]} #{opts[:vertical_offset]} #{opts[:blur]} #{opts[:color]}"
+    end
+    
+    def gradient(opts={})
+      raise ArgumentError, "gradient styles require a :start and :end color" unless opts[:start] && opts[:end]
+      opts[:from] ||= 'top'
+      direction = opts[:from] == 'top' ? "left top, left bottom" : "left top, right top" 
+      str = ""
+      str << property('background', opts[:end])
+      str << property('background', "-webkit-gradient(linear, #{direction}, from(#{opts[:start]}), to(#{opts[:end]}))")
+      str << property('background', "-moz-linear-gradient(#{opts[:from]},  #{opts[:start]},  #{opts[:end]})")
+      str
+    end
     
     def content
       # override me in subclasses

data/lib/style_train/theme.rb

@@ -1,6 +1,6 @@
 module StyleTrain
   class Theme
-    attr_accessor :value_hash, :name 
+    attr_accessor :value_hash, :name, :palette 
     
     def self.required_keys *args
       if args.empty?
@@ -14,6 +14,14 @@ module StyleTrain
       @themes ||= Gnash.new
     end
     
+    def self.defaults hash=nil
+      if hash
+        @defaults = Gnash.new(hash)
+      else
+        @defaults || Gnash.new
+      end
+    end
+    
     def self.[](key)
       themes[key]
     end
@@ -22,15 +30,23 @@ module StyleTrain
       themes.keys.map{|k| k.to_sym}
     end
     
-    def initialize(name, value_hash)
+    def initialize(name, value_hash, palette = {})
       raise ArgumentError, "Unique name is required as first argument" if !name || self.class.themes[name]
-      missing_keys = self.class.required_keys - value_hash.keys
+      self.palette = palette
+      self.value_hash = Gnash.new(self.class.defaults.merge(substitute(value_hash)))
+      missing_keys = self.class.required_keys - self.value_hash.keys.map{|k| k.to_sym}
       raise ArgumentError, "Required keys not provided: #{missing_keys.map{|k| k.inspect}.join(", ")}" if !missing_keys.empty?
-      self.value_hash = Gnash.new(value_hash)
       self.name = name
       self.class.themes[name] = self
     end
     
+    def substitute hash
+      hash.each do |key, value|
+        hash[key] = palette[value] if palette[value]
+      end
+      hash
+    end
+    
     def [](key)
       value_hash[key]
     end

data/spec/color/color_spec.rb

@@ -221,4 +221,32 @@ describe Color 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

data/spec/color/color_type_spec.rb

@@ -271,7 +271,7 @@ describe ColorType do
         @hex = HexColor.new(:color => '#666') 
       end
       
-      describe 'averaging' do
+      describe 'averaging (getting a midway point)' do
         it 'should average the r, g, and b values' do
           color = @rgb.mix(@hex)
           color.r.should == ((102+20)/2.0).round
@@ -358,8 +358,27 @@ describe ColorType do
         end 
       end  
       
-      describe 'stepping'
-      
+      describe 'blending a ratio of one color to the other' do
+        it 'should mix in the correct percentage r, g, and b values' do
+          color = @rgb.mix(@hex, 0.25) # only 25% of the @hex
+          color.r.should == (102*0.25 + 20*0.75).round
+          color.g.should == (102*0.25 + 40*0.75).round
+          color.b.should == (102*0.25 + 60*0.75).round
+        end 
+        
+        it 'should average the alpha' do
+          color = @rgb.mix(@hex, 0.25)
+          color.alpha.should == 0.5*0.75 + 1*0.25
+        end
+        
+        it 'should return the original color type' do 
+          color = @rgb.mix(@hex, 0.25)
+          color.class.should == RGBcolor
+          
+          color = @hex.mix(@rgb, 0.25)
+          color.class.should == HexColor
+        end
+      end
     end
 
     describe 'rendering' do

data/spec/sheet_spec.rb

@@ -514,6 +514,180 @@ describe Sheet do
       end
     end
   end
+  
+  describe 'css 3 goodies' do
+    before :all do
+      @sheet = Sheet.new
+    end
+    
+    describe '#corners' do
+      it 'makes all corners the specified roundness' do
+        str = @sheet.corners(32.px)
+        str.should include "border-radius: 32px"
+        str.should include "-moz-border-radius: 32px"
+        str.should include "-webkit-border-radius: 32px"
+      end
+      
+      it '#corner_top_left make the correct three declarations' do
+        str = @sheet.corner_top_left(1.em)
+        str.should include( 
+          "border-top-left-radius: 1em", 
+          "-moz-border-radius-topleft: 1em", 
+          "-webkit-border-top-left-radius: 1em"
+        )  
+      end
+      
+      it '#corners makes a top left corner' do
+        @sheet.corners(:top_left => 2.em).should == @sheet.corner_top_left(2.em)
+      end
+      
+      it '#corner_top_right make the correct three declarations' do
+        str = @sheet.corner_top_right(1.5.em)
+        str.should include( 
+          "border-top-right-radius: 1.5em", 
+          "-moz-border-radius-topright: 1.5em", 
+          "-webkit-border-top-right-radius: 1.5em"
+        )  
+      end
+      
+      it '#corners makes a top left corner' do
+        @sheet.corners(:top_right => 1.em).should == @sheet.corner_top_right(1.em)
+      end
+      
+      
+      it '#corner_bottom_right make the correct three declarations' do
+        str = @sheet.corner_bottom_right(1.5.em)
+        str.should include( 
+          "border-bottom-right-radius: 1.5em", 
+          "-moz-border-radius-bottomright: 1.5em", 
+          "-webkit-border-bottom-right-radius: 1.5em"
+        )  
+      end
+      
+      it '#corners makes a top right corner' do
+        @sheet.corners(:bottom_right => 1.em).should == @sheet.corner_bottom_right(1.em)
+      end
+      
+      it '#corner_bottom_left make the correct three declarations' do
+        str = @sheet.corner_bottom_left(1.5.em)
+        str.should include( 
+          "border-bottom-left-radius: 1.5em", 
+          "-moz-border-radius-bottomleft: 1.5em", 
+          "-webkit-border-bottom-left-radius: 1.5em"
+        )  
+      end
+      
+      it '#corners makes a top left corner' do
+        @sheet.corners(:bottom_left => 1.em).should == @sheet.corner_bottom_left(1.em)
+      end
+      
+      it 'makes both top corners at once' do
+        str = @sheet.corners(:top => 20.px)
+        str.should include "border-top-left-radius: 20px"
+        str.should include "-moz-border-radius-topleft: 20px"
+        str.should include "-webkit-border-top-left-radius: 20px"
+        str.should include "border-top-right-radius: 20px"
+        str.should include "-moz-border-radius-topright: 20px"
+        str.should include "-webkit-border-top-right-radius: 20px"
+      end
+      
+      it 'makes both bottom corners at once' do
+        str = @sheet.corners(:bottom => 30.px)
+        str.should include "border-bottom-left-radius: 30px"
+        str.should include "-moz-border-radius-bottomleft: 30px"
+        str.should include "-webkit-border-bottom-left-radius: 30px"
+        str.should include "border-bottom-right-radius: 30px"
+        str.should include "-moz-border-radius-bottomright: 30px"
+        str.should include "-webkit-border-bottom-right-radius: 30px"
+      end
+      
+      it 'makes both left corners at once' do
+        str = @sheet.corners(:left => 10.px)
+        str.should include "border-bottom-left-radius: 10px"
+        str.should include "-moz-border-radius-bottomleft: 10px"
+        str.should include "-webkit-border-bottom-left-radius: 10px"
+        str.should include "border-top-left-radius: 10px"
+        str.should include "-moz-border-radius-topleft: 10px"
+        str.should include "-webkit-border-top-left-radius: 10px"
+        
+      end
+      
+      it 'makes both right corners at once' do
+        str = @sheet.corners(:left => 15.px)
+        str.should include "border-bottom-left-radius: 15px"
+        str.should include "-moz-border-radius-bottomleft: 15px"
+        str.should include "-webkit-border-bottom-left-radius: 15px"
+        str.should include "border-top-left-radius: 15px"
+        str.should include "-moz-border-radius-topleft: 15px"
+        str.should include "-webkit-border-top-left-radius: 15px"
+      end
+    end
+    
+    describe '#shadow' do
+      it 'build declarations for all three browser types' do
+        str = @sheet.shadow
+        str.should match(/^box-shadow/)
+        str.should include '-webkit-box-shadow'
+        str.should include '-moz-box-shadow'
+      end
+      
+      it 'has good defaults' do
+        @sheet.shadow.should include "0.25em 0.25em 0.25em black"
+      end
+      
+      it 'uses the color when provided' do
+        str = @sheet.shadow(:color => '#666')
+        str.should include '#666'
+        str.should_not include 'black'
+      end
+      
+      it 'uses the horizontal offset when provided' do
+        @sheet.shadow(:horizontal_offset => 20.px).should include "20px 0.25em 0.25em black"
+      end
+      
+      it 'uses the vertical offset when provided' do
+        @sheet.shadow(:vertical_offset => 10.px).should include "0.25em 10px 0.25em black"
+      end
+      
+      it 'uses the blur when provided' do
+        @sheet.shadow(:blur => 15.px).should include "0.25em 0.25em 15px black"
+      end
+      
+      it 'will make an inner shadow' do
+        @sheet.shadow(:inner => true).should include "inset 0.25em 0.25em 0.25em black"
+      end
+    end
+    
+    describe 'gradient' do
+      it 'requires a start and end color' do
+        lambda{ @sheet.gradient }.should raise_error(ArgumentError, "gradient styles require a :start and :end color")
+      end
+      
+      it 'builds the necessary declarations' do
+        @sheet.gradient(:start => :white, :end => :black).should include(
+          "background: black",
+          "background: -webkit-gradient",
+          "background: -moz-linear-gradient"
+        )
+      end
+      
+      describe 'direction' do
+        it 'defaults from top to bottom' do
+          @sheet.gradient(:start => :white, :end => :black).should include( 
+            "linear, left top, left bottom", 
+            "linear-gradient(top"
+          )
+        end
+        
+        it 'makes from left to right' do
+          @sheet.gradient(:start => :white, :end => :black, :from => :left).should include(
+            "linear, left top, right top",
+            "linear-gradient(left" 
+          )
+        end
+      end
+    end
+  end
 
   class StyleSheet < StyleTrain::Sheet
     def content

data/spec/theme_spec.rb

@@ -4,16 +4,42 @@ Theme = StyleTrain::Theme unless defined?( Theme )
 
 describe Theme do
   class MyTheme < Theme
-    required_keys :foo, :bar
+    required_keys :foo, :bar, :zardoz
+    defaults :zardoz => 'sexy'
   end
   
-  describe 'Theme.required_keys' do
-    it 'stores the values' do
-      MyTheme.instance_eval('@required_keys').should == [:foo, :bar]
+  describe 'requiring keys' do
+    describe '#require_keys' do
+      it 'stores the values' do
+        MyTheme.instance_eval('@required_keys').should == [:foo, :bar, :zardoz]
+      end
+    
+      it 'retreives the keys when no argument is supplied' do
+        MyTheme.required_keys.should == [:foo, :bar, :zardoz]
+      end
     end
     
-    it 'retreives the keys when no argument is supplied' do
-      MyTheme.required_keys.should == [:foo, :bar]
+    describe '#defaults' do
+      before :all do
+        @theme = MyTheme.new(:orange_red, :foo => 'orange', :bar => 'white')
+      end
+      
+      it 'store the values' do
+        MyTheme.instance_eval('@defaults').should == Gnash.new(:zardoz => 'sexy')
+      end
+      
+      it 'retrieves the hash when called without an argument' do
+        MyTheme.defaults.should == Gnash.new(:zardoz => 'sexy')
+      end
+      
+      it 'adds defaults to the value hash' do
+        @theme[:zardoz].should == 'sexy'
+      end
+      
+      it 'does not override values with the same key' do
+        theme = MyTheme.new(:red_orange, :foo => 'red', :bar => 'white', :zardoz => 'not all that')
+        theme[:zardoz].should == 'not all that'
+      end
     end
   end
   
@@ -48,7 +74,21 @@ describe Theme do
     
     it 'sets the value hash to value_hash accessor' do
       theme = MyTheme.new(:maroon, :foo => 'maroon', :bar => 'white')
-      theme.value_hash.should == Gnash.new({:foo => 'maroon', :bar => 'white'})
+      theme.value_hash.should == Gnash.new({:foo => 'maroon', :bar => 'white', :zardoz => 'sexy'})
+    end
+    
+    describe 'with palette' do
+      before :all do
+        @theme = MyTheme.new(:substitutor, {:foo => :blue, :bar => :white}, {:blue => 'true blue', :white => 'off sometimes'})
+      end
+      
+      it "will save the pallete when it finds that argument" do
+        @theme.palette.should == {:blue => 'true blue', :white => 'off sometimes'}
+      end
+      
+      it 'will substitue symbols for pallete values with the same key' do
+        @theme.value_hash.should == Gnash.new({:foo => 'true blue', :bar => 'off sometimes', :zardoz => 'sexy'})
+      end
     end
   end
   

data/style_train.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{style_train}
-  s.version = "0.2.1"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kane Baccigalupi"]
-  s.date = %q{2011-02-19}
+  s.date = %q{2011-02-23}
   s.description = %q{style_train builds CSS using pure Ruby, not a DSL interpreted via Ruby. This allows inheritance, modules, instance level calculations and all the goodness Ruby can offer.}
   s.email = %q{baccigalupi@gmail.com}
   s.extra_rdoc_files = [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: style_train
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - Kane Baccigalupi
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-19 00:00:00 -08:00
+date: 2011-02-23 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency