model_formatter 0.0.3

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+debug.log

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/CHANGELOG

@@ -0,0 +1,5 @@
+*svn*
+	* added option to pass instance of a formatter
+	* added options to instantiation of the formatter
+	* added precision options to currency formatter, which now also stores currencies as an integer
+  * exposed formatters as class methods

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in model_formatter.gemspec
+gemspec
+
+gem 'rails'
+gem 'rake', '0.8.7'
+gem 'sqlite3'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005 Geoffrey Grosenbach
+
+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.md

@@ -0,0 +1,62 @@
+## Overview
+
+The ModelFormatter module allows you to easily handle fields that need to be formatted or stripped
+of formatting as they are set or retrieved from the database. You can designate one or more of your
+columns as "formatted columns" like in this example:
+
+    class Widget < ActiveRecord::Base
+      # Set an integer field as a symbol
+      format_column :some_integer, :as => :integer
+
+      # Specify the type as a class
+      format_column :sales_tax, :as => Formatters::FormatCurrency
+      format_column :sales_tax, :as => Formatters::FormatCurrency.new(:precision => 4)
+
+      # Change the prefix of the generated methods and specify type as a symbol
+      format_column :sales_tax, :prefix => 'fmt_', :as => :currency, :options => {:precision => 4}
+
+      # Use specific procedures to convert the data +from+ and +to+ the target
+      format_column :area, :from => Proc.new {|value, options| number_with_delimiter sprintf('%2d', value)},
+                           :to => Proc.new {|str, options| str.gsub(/,/, '')}
+
+      # Use a block to define the formatter methods
+      format_column :sales_tax do
+        def from(value, options = {})
+          number_to_currency value
+        end
+        def to(str, options = {})
+          str.gsub(/[\$,]/, '')
+        end
+      end
+
+      ...
+    end
+
+The methods of this module are automatically included into `ActiveRecord::Base`
+as class methods, so that you can use them in your models.
+
+
+## Documentation
+
+For more detailed documentation, create the rdocs with the following command:
+
+    rake rdoc
+
+
+## Running Unit Tests
+
+By default, the ModelFormatter plugin uses the mysql +test+ database, running on +localhost+.  To run the tests, enter the following:
+
+    rake
+
+
+## Bugs & Feedback
+
+Please file a bug report at http://github.com/bfolkens/model-formatter/issues
+
+[![Build Status](https://secure.travis-ci.org/bfolkens/model-formatter.png)](http://travis-ci.org/bfolkens/model-formatter)
+
+## Credits
+
+Sebastian Kanthak's file_column plugin - used for ideas and best practices.
+

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the model_formatter plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the model_formatter plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ModelFormatter'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/formatters.rb

@@ -0,0 +1,8 @@
+module Formatters
+	FORMATTERS_BASE_PATH = File.join(File.dirname(__FILE__), 'formatters') unless defined? FORMATTERS_BASE_PATH
+
+	require File.join(FORMATTERS_BASE_PATH, 'format.rb')
+	Dir[File.join(FORMATTERS_BASE_PATH, 'format_*.rb')].each do |formatter|
+		require formatter
+	end
+end

data/lib/formatters/format.rb

@@ -0,0 +1,23 @@
+module Formatters
+	class Format
+		def initialize(options = {})
+		end
+
+		def from(value, options = {})
+			raise FormatNotDefinedException
+		end
+
+		def to(str, options = {})
+			raise FormatNotDefinedException
+		end
+	end
+
+	class FormattingException < Exception
+	end
+
+	class FormatNotDefinedException < Exception
+	end
+
+	class FormatNotFoundException < Exception
+	end
+end

data/lib/formatters/format_boolean.rb

@@ -0,0 +1,16 @@
+module Formatters
+	class FormatBoolean < Format
+		def initialize(options = {})
+		  @on = 'yes'
+		  @off = 'no'
+		end
+
+		def from(value, options = {})
+			value ? @on : @off
+		end
+
+		def to(str, options = {})
+			str == @on
+		end
+	end
+end

data/lib/formatters/format_currency.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'action_view'
+
+module Formatters
+	class FormatCurrency < Format
+		include ActionView::Helpers::NumberHelper
+
+		def initialize(options = {})
+			@precision = options[:precision] || 2
+		end
+
+		def from(value, options = {})
+		  options = {:precision => @precision}.merge(options)
+			number_to_currency(value.to_f / (10 ** @precision), options)
+		end
+
+		def to(str, options = {})
+			return nil if str.nil? or str.empty?
+			val = str.gsub(/[^0-9.\-]/, '').to_f
+			(val * (10 ** @precision)) unless val.nil?
+		end
+	end
+end

data/lib/formatters/format_decimal.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'action_view'
+
+module Formatters
+	class FormatDecimal < Format
+		include ActionView::Helpers::NumberHelper
+
+		def initialize(options = {})
+		end
+
+		def from(value, options = {})
+		  options = {:precision => 3, :delimiter => ','}.merge(options)
+			number_with_precision value, options
+		end
+
+		def to(str, options = {})
+			return nil if str.nil? or str.empty?
+			str.gsub(/,/, '').to_f
+		end
+	end
+end

data/lib/formatters/format_integer.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'action_view'
+
+module Formatters
+	class FormatInteger < Format
+		include ActionView::Helpers::NumberHelper
+
+		def initialize(options = {})
+		end
+
+		def from(value, options = {})
+		  options = {:delimiter => ','}.merge(options)
+			number_with_delimiter value, options
+		end
+
+		def to(str, options = {})
+			return nil if str.nil? or str.empty?
+			str.gsub(/,/, '').to_i
+		end
+	end
+end

data/lib/formatters/format_percent.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'action_view'
+
+module Formatters
+	class FormatPercent < Format
+		include ActionView::Helpers::NumberHelper
+
+		def initialize(options = {})
+		end
+
+		def from(value, options = {})
+			number_to_percentage value, options
+		end
+
+		def to(str, options = {})
+			return nil if str.nil? or str.empty?
+			str.gsub(/[^0-9\.\-]/, '').to_f
+		end
+	end
+end

data/lib/formatters/format_phone.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'action_view'
+
+module Formatters
+	class FormatPhone < Format
+		include ActionView::Helpers::NumberHelper
+
+		def initialize(options = {})
+		end
+
+		def from(value, options = {})
+			number_to_phone value, options
+		end
+
+		def to(str, options = {})
+			return nil if str.nil? or str.empty?
+			str.gsub(/[^0-9]/, '').to_i
+		end
+	end
+end

data/lib/model_formatter.rb

@@ -0,0 +1,222 @@
+class Object
+   # The hidden singleton lurks behind everyone
+   def metaclass; class << self; self; end; end
+   def meta_eval &blk; metaclass.instance_eval &blk; end
+
+   # Adds methods to a metaclass
+   def meta_def name, &blk
+     meta_eval { define_method name, &blk }
+   end
+
+   # Defines an instance method within a class
+   def class_def name, &blk
+     class_eval { define_method name, &blk }
+   end
+end
+
+module ModelFormatter # :nodoc:
+  DEFAULT_FORMAT_PREFIX = 'formatted_'
+  
+	def self.append_features(base) # :nodoc:
+		super
+		base.extend(ClassMethods)
+	end
+
+	def self.init_options(defaults, model, attr) # :nodoc:
+		options = defaults.dup
+		options[:attr] = attr
+		options[:prefix] ||= DEFAULT_FORMAT_PREFIX
+		options[:formatted_attr] ||= "#{options[:prefix]}#{attr}"
+
+		# If :as is set, then it must be either a formatter Class, formatter Object, Symbol, or String
+		options[:formatter] = formatter_for(options[:as], options[:options]) unless options[:as].nil?
+
+		# Define the formatter from a :block if :block is defined
+		options[:formatter] = define_formatter(attr, &options[:block]) unless options[:block].nil?
+
+		# Define :formatter from a block based on :from and :to if they're both set
+		if !options[:from].nil? and !options[:to].nil?
+			options[:formatter] = Module.new
+			options[:formatter].class.send :define_method, :from, options[:from]
+			options[:formatter].class.send :define_method, :to, options[:to]
+		end
+
+		# If :as is still not defined raise an error
+		raise 'No formatting options have been defined.' if options[:formatter].nil?
+
+		options
+	end
+
+	# Define a formatter like the actual physical classes
+	# this could easily be done with text and an eval...
+	# but this should be faster
+	def self.define_formatter(attr, &formatter) # :nodoc:
+		# The convention is to name these custom formatters
+		# differently than the other formatting classes
+		class_name = "CustomFormat#{attr.to_s.camelize}"
+
+		# Create a class in the same module as the others
+		clazz = Class.new(Formatters::Format)
+		silence_warnings do
+			Formatters.const_set class_name, clazz
+		end
+
+		# Define the class body
+		clazz.class_eval &formatter
+		return clazz.new
+	end
+
+	# Return the formatter for a class, formatter object, symbol, or
+	# string defining the name of a formatter class.  If it's a symbol, check
+	# the Formatters module for the class that matches the camelized name
+	# of the symbol with 'Format' prepended.  Options hash is passed to the
+	# instantiation of the formatter object.
+	def self.formatter_for(type_name, options = {}) # :nodoc:
+		# If the type_name is an instance of a formatter, just return with it
+		return type_name if type_name.is_a? Formatters::Format
+
+		# If the type_name is a class just assign it to the formatter_class for instantiation later
+		formatter_class = type_name if type_name.is_a? Class
+
+		# Format a symbol or string into a formatter_class
+		if type_name.is_a? Symbol or type_name.is_a? String
+			type_name = type_name.to_s.camelize
+
+			# Construct the class name from the type_name
+			formatter_name = "Format#{type_name}"
+			formatter_class = nil
+			begin
+				formatter_class = Formatters.const_get(formatter_name)
+			rescue NameError => ne
+				# Ignore this, caught below
+			end
+		end
+
+		# Make sure the name of this is found in the Formatters module and that
+		# it's the correct superclass
+		return formatter_class.new(options) unless formatter_class.nil? or
+																								formatter_class.superclass != Formatters::Format
+
+		raise Formatters::FormatNotFoundException.new("Cannot find formatter 'Formatters::#{formatter_name}'")
+	end
+
+	require File.dirname(__FILE__) + '/formatters.rb'
+ 
+	# == Usage
+	#  class Widget < ActiveRecord::Base
+	#    # Set an integer field as a symbol
+	#    format_column :some_integer, :as => :integer
+	#
+	#    # Specify the type as a class
+	#    format_column :sales_tax, :as => Formatters::FormatCurrency
+	#    format_column :sales_tax, :as => Formatters::FormatCurrency.new(:precision => 4)
+	#
+	#    # Change the prefix of the generated methods and specify type as a symbol
+	#    format_column :sales_tax, :prefix => 'fmt_', :as => :currency, :options => {:precision => 4}
+	#
+	#    # Use specific procedures to convert the data +from+ and +to+ the target
+	#    format_column :area, :from => Proc.new {|value, options| number_with_delimiter sprintf('%2d', value)},
+	#                         :to => Proc.new {|str, options| str.gsub(/,/, '')}
+	#
+	#    # Use a block to define the formatter methods
+	#    format_column :sales_tax do
+	#      def from(value, options = {})
+	#        number_to_currency value
+	#      end
+	#      def to(str, options = {})
+	#        str.gsub(/[\$,]/, '')
+	#      end
+	#    end
+	#
+	#    ...
+	#  end
+	module ClassMethods
+  
+		# You can override the default options with +model_formatter+'s +options+ parameter
+		DEFAULT_OPTIONS = {
+			:prefix => nil,
+			:formatted_attr => nil,
+			:as => nil,
+			:from => nil,
+			:to => nil,
+			:options => {}
+		}.freeze
+
+		# After calling "<tt>format_column :sales_tax</tt>" as in the example above, a number of instance methods
+		# will automatically be generated, all prefixed by "formatted_" unless :prefix or :formatter_attr
+		# have been set:
+		#
+		# * <tt>Widget.sales_tax_formatter(value)</tt>: Format the sales tax and return the formatted version
+		# * <tt>Widget.sales_tax_unformatter(str)</tt>: "Un"format sales tax and return the unformatted version
+		# * <tt>Widget#formatted_sales_tax=(value)</tt>: This will set the <tt>sales_tax</tt> of the widget using the value stripped of its formatting.
+		# * <tt>Widget#formatted_sales_tax</tt>: This will return the <tt>sales_tax</tt> of the widget using the formatter specified in the options to +format+.
+		# * <tt>Widget#sales_tax_formatting_options</tt>: Access the options this formatter was created with.  Useful for declaring field length and later referencing it in display helpers.
+		#
+		# === Options:
+		# * <tt>:formatted_attr</tt>  - The actual name used for the formatted attribute.  By default, the formatted attribute
+		#   name is composed of the <tt>:prefix</tt>, followed by the name of the attribute.
+		# * <tt>:prefix</tt>   - Change the prefix prepended to the formatted columns.  By default, formatted columns
+		#   are prepended with "formatted_".
+		# * <tt>:as</tt>       - Format the column as the specified format.  This can be provided in either a String,
+		#   a Symbol, or as a Class reference to the formatter.  The class should subclass Formatters::Format and define <tt>from(value, options = {})</tt> and <tt>to(str, options = {})</tt>.
+		# * <tt>:from</tt>     - Data coming from the attribute retriever method is sent to this +Proc+, then returned as a
+		#   manipulated attribute.
+		# * <tt>:to</tt>       - Data being sent to the attribute setter method is sent to this +Proc+ first to be manipulated,
+		#   and the returned attribute is then sent to the attribute setter.
+		# * <tt>:options</tt>  - Passed to the formatter blocks, instantiating formatter classes and/or methods as additional formatting options.
+		def format_column(attr, options={}, &fmt_block)
+			options[:block] = fmt_block if block_given?
+			options = DEFAULT_OPTIONS.merge(options) if options
+
+			# Create the actual options
+			my_options = ModelFormatter::init_options(options, 
+																								ActiveSupport::Inflector.underscore(self.name).to_s,
+																								attr.to_s)
+
+
+      # Create the class methods
+  		attr_fmt_options_accessor = "#{my_options[:formatted_attr]}_formatting_options".to_sym
+  		attr_formatter_method = "#{my_options[:formatted_attr]}_formatter".to_sym
+  		attr_unformatter_method = "#{my_options[:formatted_attr]}_unformatter".to_sym
+
+      metaclass.class_eval do
+    		# Create an options accessor
+    		define_method attr_fmt_options_accessor do
+    			my_options
+    		end
+
+    		# Define a formatter accessor
+    		define_method attr_formatter_method do |value|
+    		  return value if value.nil?
+
+    			from_method = my_options[:formatter].method(:from)
+    			from_method.call(value, my_options[:options])
+    	  end
+
+    		# Define an unformatter accessor
+    		define_method attr_unformatter_method do |str|
+    			to_method = my_options[:formatter].method(:to)
+    			to_method.call(str, my_options[:options])
+    	  end
+      end
+
+			# Define the instance method formatter for attr
+			define_method my_options[:formatted_attr] do |*params|
+				value = self.send(attr, *params)
+        self.class.send attr_formatter_method, value
+			end
+
+			# Define the instance method unformatter for attr
+			define_method my_options[:formatted_attr] + '=' do |str|
+			  value = self.class.send(attr_unformatter_method, str)
+				self.send(attr.to_s + '=', value)
+			end
+		end
+
+    def is_formatted?(attr)
+      !public_methods.reject {|method| method !~ /#{attr.to_s}_formatting_options$/}.empty?
+    end
+	end
+end
+
+ActiveRecord::Base.send(:include, ModelFormatter)

data/model_formatter.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "model_formatter"
+  s.version     = '0.0.3'
+  s.authors     = ["Brad Folkens", "Tyler Rick"]
+  s.email       = ["bfolkens@gmail.com", "tyler@tylerrick.com"]
+  s.homepage    = "https://github.com/bfolkens/model-formatter"
+  s.summary     = %q{Allows you to easily handle fields in Rails / ActiveRecord that need to be formatted or stripped of formatting as they are set or retrieved from the database.}
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/connection.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:",
+	:timeout => 500
+)
+
+load File.dirname(__FILE__) + "/fixtures/schema.rb"
+

data/test/fixtures/entry.rb

@@ -0,0 +1,2 @@
+class Entry < ActiveRecord::Base
+end

data/test/fixtures/schema.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Schema.define do
+  create_table :entries, :force => true do |t|
+		t.column :some_integer, :integer
+		t.column :some_boolean, :boolean
+    t.column :sales_tax, :integer
+    t.column :super_precise_tax, :integer
+    t.column :area, :float
+		t.column :complex_field, :string
+		t.column :phone, :integer
+  end
+end

data/test/model_formatter_test.rb

@@ -0,0 +1,136 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'action_view'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'connection'
+require 'model_formatter'
+require 'fixtures/entry'
+
+
+class ModelFormatterTest < Test::Unit::TestCase
+	def setup
+		Entry.format_column :some_integer, :as => :integer
+		Entry.format_column :some_boolean, :prefix => 'fmt_', :as => :boolean
+
+		Entry.format_column :sales_tax, :as => :currency, :options => {:precision => 3}
+		Entry.format_column :super_precise_tax, :as => Formatters::FormatCurrency.new(:precision => 6)
+
+		Entry.format_column :area, :from => Proc.new {|value, options| sprintf('%2d', value) + options[:sample_format]},
+															 :to => Proc.new {|str, options| str.gsub(/[^0-9]/, '').to_i},
+															 :options => {:sample_format => ' sq. ft.'}
+
+		Entry.format_column :complex_field do
+			def from(value, options = {})
+				'bouya ' + value
+			end
+
+			def to(str, options = {})
+				str.gsub(/^bouya /, '')
+			end
+		end
+
+		Entry.format_column :phone, :as => :phone
+	end
+	
+	def test_should_define_format_accessors
+	  assert Entry.respond_to?('formatted_some_integer_formatter')
+	  assert Entry.respond_to?('formatted_some_integer_unformatter')
+  end
+
+	def test_should_define_getters
+		assert Entry.new.respond_to?('formatted_some_integer')
+		assert Entry.new.respond_to?('fmt_some_boolean')
+		assert Entry.new.respond_to?('formatted_sales_tax')
+		assert Entry.new.respond_to?('formatted_super_precise_tax')
+		assert Entry.new.respond_to?('formatted_area')
+		assert Entry.new.respond_to?('formatted_complex_field')
+		assert Entry.new.respond_to?('formatted_phone')
+	end
+
+	def test_should_define_setters
+		assert Entry.new.respond_to?('formatted_some_integer=')
+		assert Entry.new.respond_to?('fmt_some_boolean=')
+		assert Entry.new.respond_to?('formatted_sales_tax=')
+		assert Entry.new.respond_to?('formatted_super_precise_tax=')
+		assert Entry.new.respond_to?('formatted_area=')
+		assert Entry.new.respond_to?('formatted_complex_field=')
+		assert Entry.new.respond_to?('formatted_phone=')
+	end
+	
+	def test_should_know_formatters
+	  assert !Entry.is_formatted?(:id)
+
+		assert Entry.is_formatted?(:some_integer)
+		assert Entry.is_formatted?(:some_boolean)
+		assert Entry.is_formatted?(:sales_tax)
+
+		assert Entry.is_formatted?('super_precise_tax')
+		assert Entry.is_formatted?('area')
+		assert Entry.is_formatted?('complex_field')
+		assert Entry.is_formatted?('phone')
+  end
+
+	def test_should_respond_to_basic_definition
+		e = Entry.new
+		
+		assert_equal '3,123', Entry.formatted_some_integer_formatter(3123)
+		e.some_integer = 3123
+		assert_equal '3,123', e.formatted_some_integer
+
+		assert_equal 3123, Entry.formatted_some_integer_unformatter('3,123')
+		e.formatted_some_integer = '3,123'
+		assert_equal 3123, e.some_integer
+	end
+
+	def test_should_respond_to_proc_definition
+		e = Entry.new
+		
+		assert_equal '3123 sq. ft.', Entry.formatted_area_formatter(3123)
+		e.area = 3123
+		assert_equal '3123 sq. ft.', e.formatted_area
+
+		assert_equal 3123, Entry.formatted_area_unformatter('3123 sq. ft.')
+		e.formatted_area = '3123 sq. ft.'
+		assert_equal 3123, e.area
+	end
+
+	def test_should_respond_to_block_definition
+		e = Entry.new
+		
+		assert_equal 'bouya test me', Entry.formatted_complex_field_formatter('test me')
+		e.complex_field = 'test me'
+		assert_equal 'bouya test me', e.formatted_complex_field
+
+		assert_equal 'here and bouya there', Entry.formatted_complex_field_unformatter('bouya here and bouya there')
+		e.formatted_complex_field = 'bouya here and bouya there'
+		assert_equal 'here and bouya there', e.complex_field
+	end
+
+	def test_should_pass_options_upon_instantiation
+		e = Entry.new
+		
+		# Check format accessors
+		assert_equal '$12,412.292', Entry.formatted_sales_tax_formatter(12412292)
+		assert_equal 12412292, Entry.formatted_sales_tax_unformatter('$12,412.292')
+		
+		# Check symbol use		
+		e.sales_tax = 12412292
+		assert_equal '$12,412.292', e.formatted_sales_tax
+
+		e.formatted_sales_tax = '$12,412.292'
+		assert_equal 12412292, e.sales_tax
+
+    # Check instance use
+		e.super_precise_tax = 12412292888
+		assert_equal '$12,412.292888', e.formatted_super_precise_tax		
+
+		e.formatted_super_precise_tax = '$12,412.292888'
+		assert_equal 12412292888, e.super_precise_tax
+	end
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: model_formatter
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Brad Folkens
+- Tyler Rick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-10 00:00:00.000000000 Z
+dependencies: []
+description: Allows you to easily handle fields in Rails / ActiveRecord that need
+  to be formatted or stripped of formatting as they are set or retrieved from the
+  database.
+email:
+- bfolkens@gmail.com
+- tyler@tylerrick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/formatters.rb
+- lib/formatters/format.rb
+- lib/formatters/format_boolean.rb
+- lib/formatters/format_currency.rb
+- lib/formatters/format_decimal.rb
+- lib/formatters/format_integer.rb
+- lib/formatters/format_percent.rb
+- lib/formatters/format_phone.rb
+- lib/model_formatter.rb
+- model_formatter.gemspec
+- test/connection.rb
+- test/fixtures/entry.rb
+- test/fixtures/schema.rb
+- test/model_formatter_test.rb
+homepage: https://github.com/bfolkens/model-formatter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 126899651837855101
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 126899651837855101
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: Allows you to easily handle fields in Rails / ActiveRecord that need to be
+  formatted or stripped of formatting as they are set or retrieved from the database.
+test_files: []