easy_attributes 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Allen Fair
+
+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,156 @@
+= easy_attributes
+
+Easy Attributes is a Ruby DSL to give more control to attributes. Tested with ruby 1.87 & 1.9.2
+
+== Usage
+
+Easy Attributes works in any Ruby class, it does not require Active Record or other ORM. 
+
+First, install this from rubygems.org
+ gem install easy_attributes
+
+Next, you need to configure your app to use it, by either:
+ require 'rubygems'                 # Rails application, no framework
+ require 'easy_attributes'          #
+ 
+ config.gem 'easy_attributes'       # Rails 2.x, in your ./config/environment.rb
+
+ gem 'easy_attributes'              # Rails 3.x, in your ./Gemfile
+ 
+Configuration:
+  EasyAttributes::Config.orm = :active_model   # will generate some validations, etc.
+  EasyAttributes::Config.load(filename)        # Loads a file of column/value/names/descriptions
+  EasyAttributes::define(attribute_name, {:name=>value, ...})
+
+Declaration:
+
+ class Record < ObjectRelationalMapperOfChoice
+   include EasyAttributes
+   
+   attr_values :field, :name=>'value', :name=>'value', ... :validate=>:active_record, :required=>true, :like=>'other' ...
+   attr_sequence  :field, :name, :name, ... ,:start=>1, :step=>1
+   attr_money  :amount, :units=>"dollars", :unit=>'$', :negative=>'%.2f CR'
+   attr_bytes  :bandwidth
+ end
+ 
+== attr_values 
+
+will define:
+  field()              # => value  ### if orm == :attr, attr_accessor will be installed for the attribute
+  field=(value)        # => value
+  field_sym()          # => :name
+  field_sym=(symbol)   # => value
+  field_values()       # => {:name=>value, ...}
+  field_is?(:name)     # true if :name matches current value
+  field_is?(:name, :name, ...)  # true if value matches a given symbol
+  field_is?(:greater_than, :name) # true if the value is greater than the value of :name
+    The first argument can be one of: 
+    :greater_than, :gt, :greater_than_or_equal, :ge, :less_than, :lt, :less_than_or_equal, :le
+  field_is?(:between, :name1, :name2) # true if the value is between the corresponding values
+
+== attr_sequence 
+
+sets up a attr_values with the sequential numbering, by default starting at 1 incrementing by 1
+
+== attr_bytes
+
+Creates helper fields to display and accept byte quantities as KB, MB, GB, TB, etc.  Since a kilobyte (KB) is
+now defined as 1000 bytes, and a kibibyte (KiB) is the 1024 quantity, you wan to configure which you want to use
+
+  EasyAttributes::Config.kb_size = 1000   # Uses KB units as 1KB = 1000 bytes
+  EasyAttributes::Config.kb_size = 1024   # Uses KB units as 1KB = 1024 bytes
+  EasyAttributes::Config.kb_size = :new   # Uses KiB units as 1KiB = 1024 bytes (DEFAULT)
+  EasyAttributes::Config.kb_size = :both  # Combines usage of KB (1000) and KiB (1024) units (Watch out!)
+  
+attr_bytes creates the following methods for a :bandwidth attribute
+
+  bandwidth_bytes = "1 KB"                # => 1024
+  bandwidth_bytes                         # => "1 KB" using whatever unit is best
+  bandwidth_bytes(:MiB)                   # => "12345.67 MB" using the specified unit
+  bandwidth_bytes(:MiB, :precision=>0)    # => "123 MB"
+
+== attr_money
+
+is the inclusion of my easy_money gem 
+
+Mixin the EasyAttributes module into the (model) class you need, and declare the 
+attributes (columns) you wish you have the attr_money helpers
+
+ class Ledger
+   include EasyAttributes
+   attr_accessor :amount, :euro     # Integer value of cents
+   attr_money :amount               # Creates amount_money() and amount_money=() methods
+   attr_money :amount, :units=>"dollars", :unit=>'$', :negative=>'%.2f CR'
+                                    # Creates amount_dollars() and amount_dollars=() methods
+ end
+
+ ledger = Ledger.new
+ ledger.amount = 100                # 100 cents = $1.00
+ ledger.amount_money                #=> "1.00"
+ ledger.amount_money = "-123.45"
+ ledger.amount                      #=> -12345 (cents)
+ ledger.amount_money(:negative=>'%.2f CR', :zero=>'Free') # Uses these formats 
+ ledger.amount_dollars              #=> "$123.45 CR"
+
+ # Track the bets of the Gamesters of Triskelion on their drill thrall competitions.
+ class ProviderWagers < ActiveRecord::Base
+   include EasyAttributes
+   attr_money :quatloos, :units=>'quatloos', :precision=>3, 
+     :zero=>'even', :nil=>'no bet', :negative=>'%.3f Loss', :unit=>'Q',
+     :negative_regex=>/^(-?)(.+\d)\s*Loss/i
+                                    # creates amount_quatloos(), amount_quatloos=()
+ end
+
+ # in your views
+ <%= f.text_field :amount_quatloos %>  # -12000 => "Q12.000 Loss"
+
+Options for attr_money calls:
+* :money_method - Use this as the alternative name to the money-access methods
+* :units - Use this as an alternative suffix name to the money methods ('dollars' gives 'xx_dollars')
+* :precision - The number of digits implied after the decimal, default is 2
+* :separator - The character to use after the integer part, default is '.'
+* :delimiter - The character to use between every 3 digits of the integer part, default none
+* :positive - The sprintf format to use for positive numbers, default is based on precision
+* :negative - The sprintf format to use for negative numbers, default is same as :positive
+* :zero - The sprintf format to use for zero, default is same as :positive
+* :nil - The sprintf format to use for nil values, default none
+* :unit - Prepend this to the front of the money value, say '$', default none
+* :blank - Return this value when the money string is empty or has no digits on assignment
+* :negative_regex - A Regular Expression used to determine if a number is negative (and without a - sign), defaults to having a "CR" after the number
+
+===  Formatters
+You can also call or build your own custom conversions. Ensure that
+you can convert between the integer and money forms if you need to.
+
+The "money" type is a string, suitable for human editing, and will convert back into 
+integer type. If you override the formatting options, test that your money result 
+string will convert properly back to the original integer value.
+
+  include EasyAttributes
+  ...
+  puts EasyAttributes.money_to_integer( money_string, :option=>value, ... )
+  puts EasyAttributes.integer_to_money( cents_integer, :option=>value, ... )
+  puts EasyAttributes.integer_to_float( cents_integer, :option=>value, ... )
+  puts EasyAttributes.float_to_integer( money_float, :option=>value, ... )
+
+  EasyAttributes.integer_to_float( nil, blank:0 ) #=> 0.0  [Ruby 1.9.1 Syntax]
+  EasyAttributes.integer_to_float( 12345, :precision=>3 ) #=> 12.345
+  EasyAttributes.float_to_integer(12.345111, :precision=>3 ) #=> 12345
+
+The options to these methods are the same as the #attr_money declarations
+
+
+== 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 Allen Fair. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "easy_attributes"
+    gem.summary = %Q{Easy Attributes for Ruby}
+    gem.description = %Q{Easy Attributes is a Ruby DSL to give more control to attributes.}
+    gem.email = "allen.fair@gmail.com"
+    gem.homepage = "http://github.com/afair/easy_attributes"
+    gem.authors = ["Allen Fair"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "easy_attributes #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/easy_attributes.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{easy_attributes}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Allen Fair"]
+  s.date = %q{2010-04-28}
+  s.description = %q{Easy Attributes is a Ruby DSL to give more control to attributes.}
+  s.email = %q{allen.fair@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "easy_attributes.gemspec",
+     "lib/easy_attributes.rb",
+     "test/helper.rb",
+     "test/test_easy_attributes.rb"
+  ]
+  s.homepage = %q{http://github.com/afair/easy_attributes}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Easy Attributes for Ruby}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_easy_attributes.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/easy_attributes.rb

@@ -0,0 +1,364 @@
+# Mixes in attr_* definitions into ruby classes for using symbolic names as values, money, and bytes
+module EasyAttributes
+  
+  def self.included(base) #:nodoc:
+    base.extend( ClassMethods )
+    #EasyAttributes::Config
+    #puts "easy_attributes included into #{base}"
+  end
+  
+  # Configuration class for EasyAttributes, set at load time.
+  class Config
+    @@orm = :attr # :attr, :active_model
+    @@attributes = {}
+    @@values = {}
+    @@kb_size=:iec
+    
+    # Values: :old, :jedec, or 1024 uses KB=1024
+    #         :new, :iec            uses KiB=1024, no KB
+    #         1000, :decimal        uses only KB (1000) (other values mix KB and KiB units)
+    def self.kb_size=(b)
+      @@kb_size = b
+    end
+    
+    # Returns the kb_size setting
+    def self.kb_size
+      @@kb_size
+    end
+    
+    # Set the ORM or attribute manager, currently to :attr (attr_accessor) or :active_model
+    def self.orm=(o)
+      @@orm = o
+    end
+    
+    # Returns the ORM setting
+    def self.orm
+      @@orm
+    end
+
+    # Defines a symbol name to a hash of :name=>value
+    def self.define(name, hash)
+      @@attributes[name] = hash
+    end
+    
+    # Returns the symbol table
+    def self.attributes
+      @@attributes
+    end
+    
+    # Loads a tab-delimted filename into the symbol table in format: 
+    # attribute value role symbolic_name short_description long_description (useful for "<option>" data)
+    # If a block is given, it should parse a file line and return an array of 
+    # [attribute, value, role*, name, short*, long_description*], *denotes not required, but placeholder required
+    def self.load(filename)
+      File.open(filename).each do |r|
+        next unless r =~ /^\w/
+        (col, val, priv, symbol, word, desc) = block_given? ? yield(r) : r.split(/\t/)
+        next if desc.nil? || desc.empty? || symbol.empty? || word.empty? || symbol.nil?
+        col = col.to_sym
+        @@values[col] = {:sym=>{}, :val=>{}, :rec=>{}} unless @@values.has_key?(col)
+        @@values[col][:sym][symbol.to_sym] = val.to_i
+        @@values[col][:val][val] = symbol.to_sym
+        @@values[col][:rec][symbol.to_sym] = {:word=>word, :description=>desc, :value=>val.to_i}
+        @@attributes[col.to_s] ||= {}
+        @@attributes[col.to_s][symbol.to_sym] = val.to_i
+      end
+    end
+  end
+  
+  module ClassMethods
+    # Defines an attribute as a sequence of names. :name1=>1, :name2=>2, etc.
+    # attr_sequence :attr, :name, ... :start=>n, :step=>:n
+    def attr_sequence(attribute, *names)
+      opt = EasyAttributes.pop_options(names)
+      values = {}
+      names.inject(opt[:start]||1) { |seq, n| values[n]=seq; seq+=(opt[:step]||1)}
+      attr_values( attribute, values, opt)
+    end
+    
+    # Defines an attribute as a hash like {:key=>value,...} where key names are used interchangably with values
+    def attr_values(attribute, *args)
+      opt = args.size > 1 ? args.pop : {}
+      hash = args.first
+      
+      # Use :like=>colname to copy from another definition (ClassName#attribute) or from the loaded table columns
+      if opt[:like]
+        hash = EasyAttributes::Config.attributes[opt[:like]]
+      end
+      
+      name = "#{self.name}##{attribute}"
+      EasyAttributes.add_definition( name, hash)
+      code = ''
+      if EasyAttributes::Config.orm == :active_model
+        validates_inclusion_of attribute, :in=>hash.values
+      else
+        attr_accessor attribute
+      end
+      code += %Q(
+        def #{attribute}_sym=(v)
+          self.#{attribute} = EasyAttributes.value_for_sym("#{name}", v)
+        end
+        def #{attribute}_sym
+          EasyAttributes.sym_for_value("#{name}", #{attribute})
+        end
+        def self.#{attribute}_values
+          EasyAttributes::Config.attributes["#{name}"]
+        end
+        def #{attribute}_is?(*args)
+          EasyAttributes.value_is?("#{name}", attribute, *args)
+        end
+      )
+      #puts code
+      class_eval code
+    end
+    
+    # attr_bytes allows manipultion and display as kb, mb, gb, tb, pb
+    # Adds method: attribute_bytes=() and attribute_bytes(:unit, :option=>value )
+    def attr_bytes(attribute, *args)
+      name = "#{self.name}##{attribute}"
+      opt = EasyAttributes.pop_options(args)
+      #getter, setter = EasyAttributes.getter_setter(attribute)
+      attr_accessor attribute if EasyAttributes::Config.orm == :attr
+      code = %Q(
+        def #{attribute}_bytes(*args)
+          args.size == 0 ? v : EasyAttributes::format_bytes(self.#{attribute}, *args)
+        end
+        def #{attribute}_bytes=(v)
+          self.#{attribute} = EasyAttributes.parse_bytes(v)
+        end
+      )
+      #puts code
+      class_eval code
+    end
+    
+    # Creates an money instance method for the given method, named "#{attribute}_money" which returns
+    # a formatted money string, and a #{attribute}_money= method used to set an edited money string.
+    # The original method stores the value as integer (cents, or other precision/currency setting). Options:
+    # * :money_method - Use this as the alternative name to the money-access methods
+    # * :units - Use this as an alternative suffix name to the money methods ('dollars' gives 'xx_dollars')
+    # * :precision - The number of digits implied after the decimal, default is 2
+    # * :separator - The character to use after the integer part, default is '.'
+    # * :delimiter - The character to use between every 3 digits of the integer part, default none
+    # * :positive - The sprintf format to use for positive numbers, default is based on precision
+    # * :negative - The sprintf format to use for negative numbers, default is same as :positive
+    # * :zero - The sprintf format to use for zero, default is same as :positive
+    # * :nil - The sprintf format to use for nil values, default none
+    # * :unit - Prepend this to the front of the money value, say '$', default none
+    # * :blank - Return this value when the money string is empty or has no digits on assignment
+    # * :negative_regex - A Regular Expression used to determine if a number is negative (and without a - sign)
+    #
+    def attr_money(attribute, *args)
+      opt = args.last.is_a?(Hash) ? args.pop : {}
+      money_method = opt.delete(:money_method) || "#{attribute}_#{opt.delete(:units)||'money'}"
+
+      class_eval %Q(
+      def #{money_method}(*args)
+        opt = args.last.is_a?(Hash) ? args.pop : {}
+        EasyAttributes.integer_to_money( #{attribute}, #{opt.inspect}.merge(opt))
+      end
+
+      def #{money_method}=(v, *args)
+        opt = args.last.is_a?(Hash) ? args.pop : {}
+        self.#{attribute} = EasyAttributes.money_to_integer( v, #{opt.inspect}.merge(opt))
+      end
+      )
+    end
+    
+  end
+
+  # Returns a [getter_code, setter_code] depending on the orm configuration
+  def self.getter_setter(attribute)
+    if EasyAttributes::Config.orm == :active_model
+      ["self.attributes[:#{attribute}]", "self.write_attribute(:#{attribute}, v)"]
+    else
+      ["@#{attribute}", "@#{attribute} = v"]
+    end
+  end
+
+  def self.pop_options(args, defaults={})
+    args.last.is_a?(Hash) ? defaults.merge(args.pop) : defaults
+  end
+  
+  def self.add_definition(attribute, hash, opt={})
+    EasyAttributes::Config.define attribute, hash
+  end
+  
+  ##############################################################################
+  # attr_values helpers
+  ##############################################################################
+  
+  # Returns the defined value for the given symbol and attribute
+  def self.value_for_sym(attribute, sym)
+    EasyAttributes::Config.attributes[attribute][sym]
+  end
+  
+  # Returns the defined symbol for the given value on the attribute
+  def self.sym_for_value(attribute, value)
+    EasyAttributes::Config.attributes[attribute].each {|k,v| return k if v==value}
+  end
+  
+  def self.value_is?(attribute, value, *args)
+    case args.first
+    when :between then
+      value >= EasyAttributes::Config.attributes[attribute][args[1]] && value <= EasyAttributes::Config.attributes[attribute][args[2]]
+    when :gt, :greater_than then
+      value > EasyAttributes::Config.attributes[attribute][args[1]]
+    when :ge, :greater_than_or_equal_to then
+      value >= EasyAttributes::Config.attributes[attribute][args[1]]
+    when :lt, :less_than then
+      value < EasyAttributes::Config.attributes[attribute][args[1]]
+    when :le, :less_than_or_equal_to then
+      value <= EasyAttributes::Config.attributes[attribute][args[1]]
+    #when :not, :not_in
+    #  ! args.include? EasyAttributes::Config.attributes[attribute].keys
+    else
+      args.include? EasyAttributes.sym_for_value(v)
+    end
+  end
+  
+  ##############################################################################
+  # attr_byte helpers
+  ##############################################################################
+
+  # Official Definitions for kilobyte and kibibyte quantity prefixes
+  KB =1000; MB =KB **2; GB= KB **3; TB =KB **4; PB =KB **5; EB =KB **6; ZB =KB **7; YB =KB **8
+  KiB=1024; MiB=KiB**2; GiB=KiB**3; TiB=KiB**4; PiB=KiB**5; EiB=KiB**6; ZiB=KiB**7; YiB=KiB**8
+  DECIMAL_PREFIXES = {:B=>1, :KB=>KB, :MB=>MB, :GB=>GB, :TB=>TB, :PB=>PB, :EB=>EB, :ZB=>ZB, :TB=>YB}
+  BINARY_PREFIXES = {:B=>1, :KiB=>KiB, :MiB=>MiB, :GiB=>GiB, :TiB=>TiB, :PiB=>PiB, :EiB=>EiB, :ZiB=>ZiB, :TiB=>YiB}
+
+  # Returns a hash of prefix names to decimal quantities for the given setting
+  def self.byte_prefixes(kb_size=0)
+    case kb_size
+    when 1000, :decimal, :si then DECIMAL_PREFIXES
+    when :old, :jedec, 1024 then {:KB=>KiB, :MB=>MiB, :GB=>GiB, :TB=>TiB, :PB=>PiB, :EB=>EiB, :ZB=>ZiB, :TB=>YiB}
+    when :new, :iec then BINARY_PREFIXES
+    else DECIMAL_PREFIXES.merge(BINARY_PREFIXES) # Both? What's the least surprise?
+    end
+  end
+  
+  # Takes a number of bytes and an optional :unit argument and :precision option, returns a formatted string of units
+  def self.format_bytes(v, *args)
+    opt = EasyAttributes.pop_options(args, :precision=>3)
+    prefixes = EasyAttributes.byte_prefixes(opt[:kb_size]||EasyAttributes::Config.kb_size||0)
+    if args.size > 0 && args.first.is_a?(Symbol)
+      (unit, precision) = args
+      v = "%.#{precision||opt[:precision]}f" % (1.0 * v / (prefixes[unit]||1))
+      return "#{v} #{unit}"
+    else
+      precision = args.shift || opt[:precision]
+      prefixes.sort{|a,b| a[1]<=>b[1]}.reverse.each do |pv|
+        next if pv[1] > v
+        v = "%f.10f" % (1.0 * v / pv[1])
+        v = v[0,precision+1] if v =~ /^(\d)+\.(\d+)/ && v.size > (precision+1)
+        v.gsub!(/\.0*$/, '')
+        return "#{v} #{pv[0]}"
+      end
+    end
+    v.to_s
+  end
+  
+  # Takes a string of "number units" or Array of [number, :units] and returns the number of bytes represented.
+  def self.parse_bytes(v, *args)
+    opt = EasyAttributes.pop_options(args, :precision=>3)
+    # Handle v= [100, :KB]
+    if v.is_a?(Array)
+      bytes = v.shift
+      v = "#{bytes} #{v.shift}"
+    else
+      bytes = v.to_f
+    end
+    
+	  if v.downcase =~ /^\s*(?:[\d\.]+)\s*([kmgtpezy]i?b)/i
+	    units = ($1.size==2 ? $1.upcase : $1[0,1].upcase+$1[1,1]+$1[2,1].upcase).to_sym
+      prefixes = EasyAttributes.byte_prefixes(opt[:kb_size]||EasyAttributes::Config.kb_size||0)
+	    bytes *= prefixes[units] if prefixes.has_key?(units)
+	    #puts "v=#{v} b=#{bytes} u=#{units} #{units.class} bp=#{prefixes[units]} kb=#{opt[:kb_size]} P=#{prefixes.inspect}"
+	  end
+	  (bytes*100).to_i/100
+  end
+  
+  ##############################################################################
+  # attr_money helpers
+  ##############################################################################
+  
+  # Returns the money string of the given integer value. Uses relevant options from #easy_money
+  def self.integer_to_money(value, *args)
+    opt = args.last.is_a?(Hash) ? args.pop : {}
+    opt[:positive] ||= "%.#{opt[:precision]||2}f"
+    pattern = 
+      if value.nil?
+        value = 0
+        opt[:nil] || opt[:positive]
+      else
+        case value <=> 0
+        when 1 then opt[:positive]
+        when 0 then opt[:zero] || opt[:positive]
+        else  
+          value = -value if opt[:negative] && opt[:negative] != opt[:positive]
+          opt[:negative] || opt[:positive]
+        end
+      end
+    value = self.format_money( value, pattern, opt)
+    value = opt[:unit]+value if opt[:unit]
+    value.gsub!(/\./,opt[:separator]) if opt[:separator]
+    if opt[:delimiter] && (m = value.match(/^(\D*)(\d+)(.*)/))
+      # Adapted From Rails' ActionView::Helpers::NumberHelper
+      n = m[2].gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{opt[:delimiter]}")
+      value=m[1]+n+m[3]
+    end
+    value
+  end
+
+  def self.integer_to_float(value, *args)
+    opt = args.last.is_a?(Hash) ? args.pop : {}
+    return (opt[:blank]||nil) if value.nil?
+    value = 1.0 * value / (10**(opt[:precision]||2)) 
+  end
+
+  # Returns the integer of the given money string. Uses relevant options from #easy_money
+  def self.money_to_integer(value, *args)
+    opt = args.last.is_a?(Hash) ? args.pop : {}
+    value = value.gsub(opt[:delimiter],'') if opt[:delimiter]
+    value = value.gsub(opt[:separator],'.') if opt[:separator]
+    value = value.gsub(/^[^\d\.\-\,]+/,'')
+    return (opt[:blank]||nil) unless value =~ /\d/
+    m = value.to_s.match(opt[:negative_regex]||/^(-?)(.+\d)\s*cr/i)
+    value = value.match(/^-/) ? m[2] : "-#{m[2]}" if m && m[2]
+
+    # Money string ("123.45") to proper integer withough passing through the float transformation
+    match = value.match(/(-?\d*)\.?(\d*)/)
+    return 0 unless match
+    value = match[1].to_i * (10 ** (opt[:precision]||2))
+    cents = match[2]
+    cents = cents + '0' while cents.length < (opt[:precision]||2)
+    cents = cents.to_s[0,opt[:precision]||2]
+    value += cents.to_i * (value<0 ? -1 : 1)
+    value
+  end
+
+  # Returns the integer (cents) value from a Float
+  def self.float_to_integer(value, *args)
+    opt = args.last.is_a?(Hash) ? args.pop : {}
+    return (opt[:blank]||nil) if value.nil?
+    value = (value.to_f*(10**((opt[:precision]||2)+1))).to_i/10 # helps rounding 4.56 -> 455 ouch!
+  end
+  
+  # Replacing the sprintf function to deal with money as float. "... %[flags]m ..."
+  def self.format_money(value, pattern="%.2m", *args)
+    opt = args.last.is_a?(Hash) ? args.pop : {}
+    sign = value < 0 ? -1 : 1
+    dollars, cents = value.abs.divmod( 10 ** (opt[:precision]||2))
+    dollars *= sign
+    parts = pattern.match(/^(.*)%([-\. \d+0]*)[fm](.*)/)
+    return pattern unless parts
+    intdec = parts[2].match(/(.*)\.(\d*)/)
+    dprec, cprec = intdec ? [intdec[1], intdec[2]] : ['', '']
+    dollars = sprintf("%#{dprec}d", dollars)
+    cents = '0' + cents.to_s while cents.to_s.length < (opt[:precision]||2)
+    cents = cents.to_s[0,cprec.to_i]
+    cents = cents + '0' while cents.length < cprec.to_i
+    value = parts[1] + "#{(dollars.to_i==0 && sign==-1) ? '-' : '' }#{dollars}#{cents>' '? '.':''}#{cents}" + parts[3]
+    value
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'easy_attributes'
+
+class Test::Unit::TestCase
+end
+require 'rubygems'
+require 'test/unit'
+
+
+class Sample
+  include EasyAttributes
+  attr_accessor :price, :balance
+  attr_money :price
+  attr_money :balance
+end

data/test/test_easy_attributes.rb

@@ -0,0 +1,147 @@
+require 'helper'
+EasyAttributes::Config.orm = :attr
+
+class TestEasyAttributes < Test::Unit::TestCase
+  include EasyAttributes
+  attr_sequence :tas, :n1, :n2
+  attr_values :tav, :k1=>1, :k2=>2, :k3=>3
+  attr_values :status, {}, :like=>'TestEasyAttributes#tav'
+  attr_bytes  :bw
+  attr_money  :amount
+  
+  def test_attr_sequence
+    self.tas_sym = :n1
+    assert_equal self.tas, 1
+    assert_equal self.tas_sym, :n1
+  end
+  
+  def test_attr_values
+    self.tav_sym = :k1
+    assert_equal tav, 1
+    self.tav_sym = :k2
+    assert_equal tav, 2
+    assert_equal tav_sym, :k2
+  end
+  
+  def test_like
+    self.status_sym = :k1
+    assert_equal self.status, 1
+  end
+
+  # Removed for now, not shipping my data file!
+  def test_load
+    #EasyAttributes::Config.load "values"
+    #assert_equal EasyAttributes::Config.attributes['status'][:ok], 8
+  end
+  
+  def test_attr_bytes
+    self.bw = 1024
+    assert_equal bw, 1024
+    assert_equal bw_bytes(:KiB, :precision=>0), "1 KiB"
+    self.bw = [1, :kb]
+  end
+  
+  def test_format_bytes
+    EasyAttributes::Config.kb_size = :both
+    assert_equal EasyAttributes.format_bytes( 900 ), "900 B"
+    assert_equal EasyAttributes.format_bytes( 1000 ), "1 KB"
+    assert_equal EasyAttributes.format_bytes( 12345 ), "12 KiB"
+    assert_equal EasyAttributes.format_bytes( 123456789 ), "117 MiB"
+    assert_equal EasyAttributes.format_bytes( 9999999999 ), "9.31 GiB"
+    assert_equal EasyAttributes.format_bytes( 123456789,  :KiB ), "120563.271 KiB"
+    assert_equal EasyAttributes.format_bytes( 123456789,  :KiB, 1 ), "120563.3 KiB"
+    assert_equal EasyAttributes.format_bytes( 123456789,  :KiB, 0 ), "120563 KiB"
+  end
+  
+  def test_parse_bytes
+    EasyAttributes::Config.kb_size=:both
+    assert_equal EasyAttributes.parse_bytes( "1.5 KiB" ), 1536
+    assert_equal EasyAttributes.parse_bytes( "1 gb" ), EasyAttributes::GB
+    assert_equal EasyAttributes.parse_bytes( "1kb", :kb_size=>1000 ), 1000
+    assert_equal EasyAttributes.parse_bytes( "1kb", :kb_size=>1024 ), 1024
+  end
+  
+  def test_include
+    sample = Sample.new
+    flunk "no price_money method" unless sample.respond_to?(:price_money)
+    flunk "no price_money= method" unless sample.respond_to?(:price_money=)
+  end
+
+  def test_method_money
+    s = Sample.new
+    [ 10000, 123456, 0, -1 -9876 ].each do |p|
+      s.price = p
+      m = s.price_money
+      s.price_money = m
+      flunk "Assignment error: p=#{p} m=#{m} price=#{s.price}" unless s.price = p
+    end
+  end
+
+  def test_method_money=
+    s = Sample.new
+    { "0.00"=>0, "12.34"=>1234, "-1.2345"=>-123, "12"=>1200, "4.56CR"=>-456 }.each do |m,p|
+      s.price_money = m
+      flunk "Assignment error: p=#{p} m=#{m} price=#{s.price}" unless s.price = p
+    end
+  end
+
+  def test_integer_to_money
+    assert EasyAttributes.integer_to_money(123) == '1.23'
+    assert EasyAttributes.integer_to_money(-12333) == '-123.33'
+    assert EasyAttributes.integer_to_money(0) == '0.00'
+    assert EasyAttributes.integer_to_money(nil, :nil=>'?') == '?'
+    assert EasyAttributes.integer_to_money(-1, :negative=>'%.2f CR') == '0.01 CR'
+    assert EasyAttributes.integer_to_money(0, :zero=>'free') == 'free'
+    assert EasyAttributes.integer_to_money(100, :unit=>'$') == '$1.00'
+    assert EasyAttributes.integer_to_money(100, :separator=>',') == '1,00'
+    assert EasyAttributes.integer_to_money(12345678900, :separator=>',', :delimiter=>'.') == '123.456.789,00'
+    assert EasyAttributes.integer_to_money(333, :precision=>3) == '0.333'
+    assert EasyAttributes.integer_to_money(111, :precision=>1) == '11.1'
+    assert EasyAttributes.integer_to_money(111, :precision=>0) == '111'
+  end
+
+  def test_money_to_integer
+    assert EasyAttributes.money_to_integer('1.23'        ) == 123
+    assert EasyAttributes.money_to_integer('0.00'        ) == 0
+    assert EasyAttributes.money_to_integer('-1.23'       ) == -123
+    assert EasyAttributes.money_to_integer('1.23 CR'     ) == -123
+    assert EasyAttributes.money_to_integer('$-2.34 CR'   ) == 234
+    assert EasyAttributes.money_to_integer('   1.234'    ) == 123
+    assert EasyAttributes.money_to_integer('$1'          ) == 100
+    assert EasyAttributes.money_to_integer('1'           ) == 100
+    assert EasyAttributes.money_to_integer(''            ) == nil
+    assert EasyAttributes.money_to_integer('1,00', :separator=>',',:delimiter=>'.') == 100
+    assert EasyAttributes.money_to_integer('$123.456.789,00 CR', :separator=>',',:delimiter=>'.') == -12345678900
+    assert EasyAttributes.money_to_integer('4.44', :precision=>4 ) == 44400
+    assert EasyAttributes.money_to_integer('4.44', :precision=>0 ) == 4
+  end
+
+  def test_float_to_integer
+    assert EasyAttributes.float_to_integer(1.00   ) == 100
+    assert EasyAttributes.float_to_integer(1.001  ) == 100
+    assert EasyAttributes.float_to_integer(-1.23  ) == -123
+    assert EasyAttributes.float_to_integer(9.0    ) == 900
+    assert EasyAttributes.float_to_integer(nil    ) == nil
+    assert EasyAttributes.float_to_integer(0.00   ) == 0
+  end
+
+  def test_integer_to_float
+    assert EasyAttributes.integer_to_float(1      ) == 0.01
+    assert EasyAttributes.integer_to_float(0      ) == 0.0
+    assert EasyAttributes.integer_to_float(-100   ) == -1.00
+    assert EasyAttributes.integer_to_float(nil    ) == nil
+    assert EasyAttributes.integer_to_float(9999888, :precision=>3 ) == 9999.888
+  end
+  
+  def test_format_money
+    assert EasyAttributes.format_money(12345) == '123.45'
+    assert EasyAttributes.format_money(12345, "%07.2m") == '0000123.45'
+    assert EasyAttributes.format_money(12345, "%07.3m") == '0000123.450'
+    assert EasyAttributes.format_money(12345, "%m") == '123'
+    assert EasyAttributes.format_money(12345, "free") == 'free'
+    assert EasyAttributes.format_money(-12345) == '-123.45'
+    assert EasyAttributes.format_money(-12345, "%07.1m") == '-000123.4'
+    assert EasyAttributes.format_money(-1) == '-0.01'
+  end
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: easy_attributes
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Allen Fair
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-28 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Easy Attributes is a Ruby DSL to give more control to attributes.
+email: allen.fair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- easy_attributes.gemspec
+- lib/easy_attributes.rb
+- test/helper.rb
+- test/test_easy_attributes.rb
+has_rdoc: true
+homepage: http://github.com/afair/easy_attributes
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Easy Attributes for Ruby
+test_files: 
+- test/helper.rb
+- test/test_easy_attributes.rb