style_train 0.1.0

data/LISENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kane Baccigalupi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.        

data/README.rdoc

@@ -0,0 +1,17 @@
+= StyleTrain
+
+StyleTrain is a css color helper that aims to make it really easy to mix and use colors in CSS. 
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Kane Baccigalupi. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec   
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "style_train"
+    gem.summary = %Q{style_train builds CSS with Ruby}
+    gem.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.}
+    gem.email = "baccigalupi@gmail.com"
+    gem.homepage = "http://github.com/baccigalupi/style_train"
+    gem.authors = ["Kane Baccigalupi"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end      
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/style_train/color.rb

@@ -0,0 +1,103 @@
+# This is a delegatory class that passes most everything to the particular ColorType descendant
+module StyleTrain
+  class Color
+    attr_accessor :delegate, :background_set
+   
+    # Constructor 
+    def initialize( color, opts={} ) 
+      opts = Gnash.new(opts).merge(:color => color) 
+      background_opts = opts.delete(:background) 
+      self.background = background_opts if background_opts
+      if color.is_a?(Color)
+        self.delegate = color.delegate.dup
+        self.alpha = opts[:alpha] if opts[:alpha]
+        self.background = color.background if color.background_set
+      else  
+        color_types.each do |klass|
+          if instance = klass.make(opts)
+            self.delegate = instance
+            break
+          end
+        end 
+      end     
+    end 
+  
+    def self.color_types
+      @color_type ||= ColorType.color_types
+    end 
+  
+    def color_types
+      self.class.color_types
+    end
+  
+    # delegated methods
+    [:alpha, :r, :g, :b].each do |meth|
+      class_eval "
+        def #{meth}
+          self.delegate.#{meth}
+        end
+      "
+    end
+  
+    def alpha=( value )
+      self.delegate.alpha = value
+    end  
+  
+    def to(key)
+      self.delegate.to(key)
+    end 
+  
+    def =~( color )
+      if color.is_a?(Color)
+        self.delegate =~ color.delegate
+      elsif color.is_a?( ColorType )
+        self.delegate =~ color
+      end    
+    end 
+  
+    def ==( color )
+      color.is_a?( Color ) && self =~ color && self.background == color.background
+    end    
+    
+    # rendering
+    def background
+      @background ||= Color.new(:white).to(:hex)
+    end 
+  
+    def background=( opts )
+      color = opts.is_a?(Hash) && (opts[:color] || opts['color'])
+    
+      @background = if color
+        opts.delete(:alpha)
+        Color.new(color, opts)
+      elsif opts.is_a? Color
+        color = opts.dup # so that the original color's alpha isn't affected
+        color.alpha = 1.0
+        color
+      else  
+        Color.new(opts)
+      end
+      raise ArgumentError, "Background with color: #{color} and options: #{opts} not found" unless @background 
+      raise ArgumentError, "Background color #{@background.inspect} has no delegate color" unless @background.delegate
+    
+      self.background_set = true
+      @background  
+    end     
+  
+    def render(render_style=nil) 
+      if render_style && render_style.to_sym == :ie
+        self.background.to(:hex).layer(self.delegate).render
+      else  
+        self.delegate.render
+      end   
+    end
+  
+    def inspect 
+      "<Color @delegate=#{self.delegate.to_s} @background=#{self.background}>"
+    end  
+  
+    def to_s(render_style=nil)
+      render(render_style)
+    end      
+  end
+end 

data/lib/style_train/color_types/color_type.rb

@@ -0,0 +1,218 @@
+module StyleTrain
+  class ColorType 
+    # ERROR CLASSES
+    class PercentageError < ArgumentError
+      def message 
+        @message ||= 'Percentages must be between 0 and 100'
+      end
+    end 
+  
+    class ByteNumberError < ArgumentError
+      def message 
+        @message ||= 'Byte numbers must be between 0 and 255'
+      end
+    end
+  
+    class AlphaError < ArgumentError
+      def message 
+        @message ||= 'Alpha must be between 0.0 and 1.0'
+      end
+    end
+  
+    # ATTRIBUTES  
+    attr_accessor :r, :g, :b 
+    attr_reader :alpha 
+  
+    # INITIALIZATION
+    def initialize( opts )
+      if self.class.is_color?(opts)
+        build_from_color(opts)
+      else
+        opts = Gnash.new(opts)
+        color = opts[:color]
+        self.alpha = opts[:alpha] 
+        type_initialize( color, opts )
+      end  
+    end
+  
+    def type_initialize( color, opts ) 
+      raise NotYetImplemented, "type_initialize must be implemented for #{self}"
+    end  
+  
+    def alpha=( value ) 
+      value = (value || 1.0).to_f   
+      raise AlphaError if value > 1.0 || value < 0.0
+      @alpha = value 
+    end 
+  
+    def build_from_color( color ) 
+      self.r = color.r
+      self.g = color.g
+      self.b = color.b
+      self.alpha = color.alpha
+      build
+    end 
+  
+    def build 
+      raise NotImplementedError, "#build must be implemented for #{self.class}"
+    end   
+  
+    def self.is_color?( color )
+      color.is_a? ColorType 
+    end 
+  
+    # INSTANCE METHODS 
+    # conversion
+    def to( color_type )
+      klass = self.class.color_type_class(color_type)
+      raise ArgumentError, 'color type not supported' unless klass
+      self.class == klass ? self : klass.new( self )
+    end
+  
+    # comparison
+    def =~( color )
+      if color.is_a?( ColorType ) 
+        self.r == color.r && self.g == color.g && self.b == color.b 
+      elsif color.is_a?( Color )
+        self =~ color.delegate
+      end    
+    end
+  
+    def ==( color )
+      (self =~ color) && self.alpha == color.alpha
+    end 
+  
+    def ===( color )
+      (self == color) && self.class == color.class
+    end 
+  
+    # blending
+    def mix( color )
+      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.build
+      mixed
+    end
+  
+    def layer( color )
+      layered = self.dup 
+      ratio = 1 - color.alpha
+      layered.r = self.class.blend( self.r, color.r, ratio )
+      layered.g = self.class.blend( self.g, color.g, ratio )
+      layered.b = self.class.blend( self.b, color.b, ratio )
+      layered.alpha = self.class.blend_alphas( self.alpha, color.alpha ) 
+      layered.build
+      layered
+    end
+  
+    def self.blend(first, second, ratio) 
+      blended = (first*ratio + second*(1-ratio)).round
+    end    
+  
+    def self.average(first, second, round=true)
+      averaged = ((first + second)/2.0)
+      round ? averaged.round : averaged
+    end 
+  
+    def self.blend_alphas(first, second)
+      base, blender = first > second ? [first, second] : [second, first]
+      difference = 1.0 - base
+      base + difference * blender
+    end         
+  
+    # rendering
+    def render(opts=nil) 
+      alpha? ? render_as_rgba : render_as_given
+    end
+  
+    def to_s(opts=nil)
+      render(opts)
+    end   
+  
+    def render_as_given 
+      raise NotImplementedError, "#render_as_given must be implemented for #{self.class}"
+    end     
+  
+    def render_as_rgba
+      "rgba( #{self.r}, #{self.g}, #{self.b}, #{self.alpha} )"
+    end
+  
+    def alpha?
+      self.alpha != 1.0
+    end    
+  
+    # CLASS METHODS 
+  
+    def self.make(opts)
+      begin
+        new(opts)
+      rescue
+        nil
+      end    
+    end  
+      
+    # These can't contain real classes because it will create a dependency loop.
+    def self.color_opts
+      @color_opts ||= Gnash.new(
+        :rgb => 'StyleTrain::RGBcolor',
+        :keyword => 'StyleTrain::KeywordColor', 
+        :hex => 'StyleTrain::HexColor' 
+        # :hsl => 'HSLcolor' # when this class exists
+      ) 
+    end 
+   
+    # So they are replaced on usage with the actual constants, as needed
+    def self.color_type_class( color_type )
+      klass = color_opts[ color_type ]
+      if klass.class == String
+        color_opts[color_type] = klass.constantize
+      else
+        klass
+      end   
+    end
+  
+    def self.color_types  
+      unless @types_built
+        color_opts.each do |key, klass|
+          self.color_type_class( key )
+        end  
+        @types_built = true
+      end   
+      color_opts.values
+    end      
+  
+    def self.percentage( str )
+      if str.class == String && str.match(/^([\d.]*)%$/) 
+        number = $1.to_f
+        raise PercentageError if number > 100.0 || number < 0.0
+        number
+      else  
+        false
+      end  
+    end
+  
+    def self.byte( str ) 
+      str.to_i if valid_byte?( str, true )    
+    end
+  
+    def self.valid_byte?( number, raise_exe=false )
+      num = number.to_i
+      v = num <= 255 && num >= 0 
+      raise ByteNumberError if v != true && raise_exe
+      v
+    end  
+  
+    def self.percent_to_byte( number ) 
+      raise PercentageError  if number > 100.0 || number < 0.0 
+      ( number * 2.55 ).round
+    end
+  
+    def self.byte_to_percentage( number )
+      raise ByteNumberError if number > 255.0 || number < 0.0 
+      ( number/2.55 ).round
+    end                
+  end
+end 

data/lib/style_train/color_types/hex_color.rb

@@ -0,0 +1,44 @@
+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

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