module ModFactor::Owner

Public Class Methods

included(base) click to toggle source
# File lib/mod_factor/owner.rb, line 4
def self.included base
        base.extend ClassMethods

        base.after_initialize do |obj|
                if base.instance_variable_defined? :@factor_model
                        factor_model = base.instance_variable_get :@factor_model
                        obj.send(factor_model).each do |factor|
                                obj.instance_variable_set "@#{factor.key.to_sym}", factor.amount
                                obj.factor_hash[factor.key.to_sym] = factor.amount
                        end
                        base.factor_define.keys.each do |key|
                                if base.factor_define[key][:default] && obj.send(key).nil?
                                        obj.instance_variable_set "@#{key}", base.factor_define[key][:default]
                                end
                        end

                end
                if base.instance_variable_defined? :@property_model
                        property_model = base.instance_variable_get :@property_model
                        obj.send(property_model).each do |property|
                                define = base.property_define[property.key.to_sym]
                                value = property.value
                                value = case define[:type]
                                                                when :decimal
                                                                        BigDecimal.new value.to_s
                                                                when :integer
                                                                        value.to_i
                                                                when :boolean
                                                                        if value.is_a?(FalseClass) ||
                                                                                value.nil? ||
                                                                                value == 0 ||
                                                                                value =~ /^(f|false|0)$/i ||
                                                                                (value.respond_to? :empty? and value.empty?)
                                                                                false
                                                                        else
                                                                                true
                                                                        end
                                                                else
                                                                        property.value
                                                                end

                                obj.instance_variable_set "@#{property.key.to_sym}", value
                                obj.property_hash[property.key.to_sym] = value
                        end
                        base.property_define.keys.each do |key|
                                if base.property_define[key][:default] && obj.send(key).nil?
                                        obj.instance_variable_set "@#{key}", base.property_define[key][:default]
                                end
                        end

                end
        end

        base.after_save do |obj|
                if base.instance_variable_defined? :@factor_model
                        factor_model = base.instance_variable_get :@factor_model

                        factor_changes.each do |key|
                                factor = obj.send(factor_model).find_or_initialize_by_key key
                                factor.amount = BigDecimal.new(obj.send(key).to_s)
                                factor.save!
                                obj.instance_variable_set "@#{key}", factor.amount
                        end
                        obj.reload
                end

                if base.instance_variable_defined? :@property_model
                        property_model = base.instance_variable_get :@property_model

                        property_changes.each do |key|
                                property = obj.send(property_model).find_or_initialize_by_key key
                                property.value = obj.send(key)
                                property.save!
                                obj.instance_variable_set "@#{key}", property.value
                        end
                        obj.reload
                end

        end
end

Public Instance Methods

calculate(options={}) click to toggle source
# File lib/mod_factor/owner.rb, line 154
def calculate options={}
        self.class.generate_list.each do |key|
                if (condition = self.class.factor_define[key][:condition]).nil? || self.instance_exec(options, &condition)
                        raise "formula should be defined when generate" unless callable = self.class.factor_define[key][:formula]

                        instance_variable_set "@#{key}", self.instance_exec(options, &callable)
                end
        end
end
calculate!(options={}) click to toggle source
# File lib/mod_factor/owner.rb, line 164
def calculate! options={}
        calculate options
        save!
end
changed_for_autosave?() click to toggle source
Calls superclass method
# File lib/mod_factor/owner.rb, line 169
def changed_for_autosave?
        !factor_changes.empty? || !property_changes.empty? || super
end
factor_changes() click to toggle source
# File lib/mod_factor/owner.rb, line 135
def factor_changes
        self.class.factor_define.keys.select do |key|
                factor_hash[key] != __send__(key)
        end
end
factor_hash() click to toggle source
# File lib/mod_factor/owner.rb, line 128
def factor_hash
        @factor_hash ||= self.class.factor_define.keys.inject({}) do 
                |out, item| out[item] = self.class.factor_define[item][:default]
                out
        end
end
property_changes() click to toggle source
# File lib/mod_factor/owner.rb, line 148
def property_changes
        self.class.property_define.keys.select do |key|
                property_hash[key] != __send__(key)
        end
end
property_hash() click to toggle source
# File lib/mod_factor/owner.rb, line 141
def property_hash
        @property_hash ||= self.class.factor_define.keys.inject({}) do 
                |out, item| out[item] = self.class.factor_define[item][:default]
                out
        end
end