easy_rails_money 0.0.3 → 0.0.4

data/.gitignore

@@ -3,20 +3,25 @@
 *.rbc
 .bundle
 .config
-.yardoc
 Gemfile.lock
-InstalledFiles
-_yardoc
 coverage
-doc/
+InstalledFiles
 lib/bundler/man
 pkg
-rdoc
 spec/reports
 test/tmp
 test/version_tmp
 tmp
 
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+rdoc
+
 .rvmrc
+.ruby-version
+.ruby-gemset
+
 NOTES
 .rspec

data/CHANGELOG.md

@@ -14,9 +14,10 @@
 - has a dependency on ActiveRecord and removed the dependency on Rails
 
 ## 0.0.3
-- add missing cases for supporting a single currency
+- add missing test-cases for supporting a single currency
 - refactor tests
 - add simplecov coverage report
 - Add yard docs and update README
 
-
+## 0.0.4
+- add dsl with_currency for defining a single currency on the model

data/README.md

@@ -2,11 +2,6 @@
 [![Dependency Status](https://gemnasium.com/deepak/easy_rails_money.png)](https://gemnasium.com/deepak/easy_rails_money)
 [![Code Climate](https://codeclimate.com/github/deepak/easy_rails_money.png)](https://codeclimate.com/github/deepak/easy_rails_money)
 
-### Under Development
-
-The migration helpers are functionally complete.
-Working on integrating with Rails' ActiveModel
-
 # EasyRailsMoney
 
 > “Young people, nowadays, imagine that money is everything.
@@ -17,13 +12,11 @@ Working on integrating with Rails' ActiveModel
 
 This library provides integration of [money](http://github.com/Rubymoney/money) gem with [Rails](https://github.com/rails/rails).
 
-[money-rails](https://github.com/RubyMoney/money-rails) is much more
-popular and full-featured. Definately try it out. I have actually
-submitted a PR to that project and it is actively maintained.
+It provides migration helpers to define a schema with either a single  
+currency column or a currency column per-money object.  
 
-I have tried to create a simpler version of [money-rails](https://github.com/RubyMoney/money-rails)
-With a better API and database schema, in my opinion
-I created this project to scratch my itch.
+It also provides a ActiveRecord DSL to define that an attribute is a
+Money object and that it has a default currency   
 
 Please open a new issue [in the github project issues tracker](http://github.com/deepak/easy_rails_money/issues). You are also
 more than welcome to contribute to the project :-)  
@@ -33,6 +26,14 @@ more than welcome to contribute to the project :-)
 Have stolen lots of code from [money-rails](https://github.com/RubyMoney/money-rails)  
 But database schema, API and tests are written from scratch  
 
+[money-rails](https://github.com/RubyMoney/money-rails) is much more
+popular and full-featured. Definately try it out. I have actually
+submitted a PR to that project and it is actively maintained.
+
+I have tried to create a simpler version of [money-rails](https://github.com/RubyMoney/money-rails)
+With a better API and database schema, in my opinion.  
+I created this project to scratch my itch.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -69,7 +70,7 @@ Option 1:
 class CreateLoan < ActiveRecord::Migration
   def change
     create_table :loans do |t|
-      t.integer       :principal
+      t.integer       :principal_money
       t.string        :principal_currency
     end
   end
@@ -101,8 +102,8 @@ Floating-Point Arithmetic, by David Goldberg, published in March,
 
 We have encoded the currency in the column name. I like it because
 there is no need to define another column and it is simple. But the
-disadvantage is that it is inflexible and changing the column name in
-MySQL might require downtime for a big table
+disadvantage is that it is inflexible ie. cannot store two currencies
+and changing the column name in MySQL might require downtime for a big table
 
 So let us go with the first option. The disadvantage is that currency
 is stored as a string. Integer might be better for storing in the database
@@ -121,11 +122,11 @@ Now we would represent it as
 class CreateLoan < ActiveRecord::Migration
   def change
     create_table :loans do |t|
-      t.integer       :principal
+      t.integer       :principal_money
       t.string        :principal_currency
-      t.integer       :repaid
+      t.integer       :repaid_money
       t.string        :repaid_currency
-      t.integer       :npa
+      t.integer       :npa_money
       t.string        :npa_currency
     end
   end
@@ -141,9 +142,9 @@ class CreateLoan < ActiveRecord::Migration
   def change
     create_table :loans do |t|
       t.string        :currency
-      t.integer       :principal
-      t.integer       :repaid
-      t.integer       :npa
+      t.integer       :principal_money
+      t.integer       :repaid_money
+      t.integer       :npa_money
     end
   end
 end
@@ -152,6 +153,10 @@ end
 It might be possible that we set a currency once for the whole app and
 never change it. But this seems like a nice tradeoff api-wise
 
+Also the column names are suffixed with ```_money``` and ```_currency```   
+We need this for now, to reflect on the database scheme. I
+Ideally should be able to read the metadata from rails scheme cache.  
+
 ## Usage
 
 ### ActiveRecord
@@ -256,6 +261,88 @@ It is used to reflect on the database schema ie. to find out the
 money and currency columns defined.  
 Right now, none of these choices are customizable.
 
+#### Defining the Model
+
+If every money column has its own currency column, then we cn define  
+the model as:
+
+```ruby
+class Loan < ActiveRecord::Base
+  attr_accessible :name
+  money :principal
+  money :repaid
+  money :npa
+end
+```
+
+The corresponding migration (given above) is:
+
+```ruby
+class CreateLoanWithCurrency < ActiveRecord::Migration
+  def change
+    create_table :loans, force: true do |t|
+      t.string :name
+      t.money  :principal
+      t.money  :repaid
+      t.money  :npa
+    end
+  end
+end
+```
+
+Now if you want a single currency column then:
+
+```ruby
+class Loan < ActiveRecord::Base
+  attr_accessible :name
+
+  with_currency(:inr) do
+    money :principal
+    money :repaid
+    money :npa
+  end
+end
+```
+
+The corresponding migration (given above) is:
+
+```ruby
+class CreateLoanWithCurrency < ActiveRecord::Migration
+  def change
+    create_table :loans, force: true do |t|
+      t.string :name
+      t.money  :principal
+      t.money  :repaid
+      t.money  :npa
+      t.currency
+    end
+  end
+end
+```
+
+For such a record, where the single currency is defined. calling
+currency on a new record will give us the currency. And can define a
+common currency per-record while creating it
+
+eg:  
+```ruby
+class Loan < ActiveRecord::Base
+  attr_accessible :name
+
+  with_currency(:inr) do
+    money :principal
+    money :repaid
+    money :npa
+  end
+end
+
+loan = Loan.new
+loan.currency # equals Money::Currency.new(:inr)
+
+loan_usd = Loan.new(currency: :usd)
+loan_usd.currency # equals Money::Currency.new(:usd)
+```
+
 ## TODO's
 1. Proof-read docs
 2. currency is stored as a string. Integer might be better for storing in the database
@@ -267,3 +354,10 @@ Right now, none of these choices are customizable.
 6. configure the ```_money``` and ```_currency``` prefix and the name
    of the common ```currency``` column
 7. check specs tagged as "fixme"
+8. cryptographically sign gem
+9. test if Memoization in ```MoneyDsl#money`` will make any difference
+   and add a performance test to catch regressions
+10. will it make sense to define the ```money``` dsl on ```ActiveModel``` ?
+11. the column names are suffixed with ```_money``` and ```_currency```  
+    We need this for now, to reflect on the database scheme. 
+    Ideally should be able to read the metadata from rails scheme cache.  

data/lib/easy_rails_money/active_record/money_dsl.rb

@@ -1,17 +1,97 @@
 require 'active_support/concern'
-require 'active_support/core_ext/array/extract_options'
+require "easy_rails_money/money_dsl_helper"
 
 module EasyRailsMoney
   module ActiveRecord
     module MoneyDsl
       extend ActiveSupport::Concern
-
+      
       module ClassMethods
-        def money(field, *args)
-          options = args.extract_options!          
+        attr_accessor :single_currency
+
+        def single_currency?
+          self.columns_hash.has_key? "currency"
+        end
+        
+        def with_currency currency, &block
+          self.single_currency = EasyRailsMoney::MoneyDslHelper.to_currency(currency)
+          instance_eval &block
+        end
+
+        def new(attributes = nil, options = {})
+          instance = super
+          # single currency is defined
+          if single_currency?
+            if attributes && attributes[:currency]
+              instance.currency = EasyRailsMoney::MoneyDslHelper.to_currency attributes[:currency]
+            else
+              instance.currency = instance.class.single_currency
+            end
+          end
+          instance
         end
-      end
+
+        def money column_name
+          money_column = "#{column_name}_money"
+          currency_column = "#{column_name}_currency"
+          single_currency_column = "currency"
+          
+          if single_currency?
+            define_method column_name do |*args|
+              money = send(money_column)
+              currency = send(single_currency_column)
+              
+              if money
+                Money.new(money, currency)
+              else
+                nil
+              end
+            end
+          else
+            # TODO: test if Memoization will make any difference
+            define_method column_name do |*args|
+              money = send(money_column)
+              currency = send(currency_column) || EasyRailsMoney.default_currency
+              
+              if money
+                Money.new(money, currency)
+              else
+                nil
+              end
+            end
+          end
+
+          if single_currency?
+            define_method "#{column_name}=" do |value|
+              raise ::ArgumentError.new("only Integer or nil accepted") unless (value.kind_of?(Integer) || value.is_a?(NilClass))
+
+              send("#{money_column}=", value)
+              # currency is stored in a seperate common column
+              return Money.new(value, self.currency)
+            end # define_method setter
+          else
+            define_method "#{column_name}=" do |value|
+              raise ::ArgumentError.new("only Money or nil accepted") unless (value.kind_of?(Money) || value.is_a?(NilClass))
+
+              if value
+                send("#{money_column}=", value.fractional)
+                # it is stored in the database as a string but the Money
+                # object exposes it as a Symbol. so we store it as a
+                # String for consistency
+                send("#{currency_column}=", value.currency.id.to_s)
+                return value
+              else
+                send("#{money_column}=", nil)
+                send("#{currency_column}=", nil)
+                return nil
+              end
+            end # define_method setter
+          end # if single_currency?
+        end # def money
+      end # module ClassMethods
       
     end
   end
 end
+
+

data/lib/easy_rails_money/configuration.rb

@@ -8,6 +8,11 @@ module EasyRailsMoney
 
     # Configuration parameters
     delegate :default_currency=, :to => :Money
-    delegate :default_currency, :to => :Money
+
+    def default_currency
+      default =  Money.default_currency
+      return default if default.is_a? ::Money::Currency
+      return ::Money::Currency.new(default)
+    end
   end
 end

data/lib/easy_rails_money/money_dsl_helper.rb

@@ -0,0 +1,9 @@
+module EasyRailsMoney
+  module MoneyDslHelper
+    def to_currency currency
+      return currency if currency.is_a? ::Money::Currency
+      ::Money::Currency.new(currency)
+    end
+    module_function :to_currency
+  end
+end

data/lib/easy_rails_money/version.rb

@@ -1,3 +1,3 @@
 module EasyRailsMoney
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end