appoxy-simple_record 1.0.23 → 1.0.26

data/lib/simple_record.rb

@@ -44,17 +44,137 @@ module SimpleRecord
     #                                                  :per_thread (one connection per thread)
     #                                                  :pool (uses a connection pool with a maximum number of connections - NOT IMPLEMENTED YET)
     #      :logger       => Logger Object        # Logger instance: logs to STDOUT if omitted
-    #      :nil_representation => 'mynil'}       # interpret Ruby nil as this string value; i.e. use this string in SDB to represent Ruby nils (default is the string 'nil')
     def self.establish_connection(aws_access_key=nil, aws_secret_key=nil, params={})
         RightAws::ActiveSdb.establish_connection(aws_access_key, aws_secret_key, params)
     end
 
     def self.close_connection()
-                RightAws::ActiveSdb.close_connection
+        RightAws::ActiveSdb.close_connection
+    end
+
+    module Callbacks
+        #this bit of code creates a "run_blank" function for everything value in the @@callbacks array.
+        #this function can then be inserted in the appropriate place in the save, new, destroy, etc overrides
+        #basically, this is how we recreate the callback functions
+        @@callbacks=["before_validation", "before_validation_on_create", "before_validation_on_update",
+                     "after_validation", "after_validation_on_create", "after_validation_on_update",
+                     "before_save", "before_create", "before_update",
+                     "after_create", "after_update", "after_save",
+                     "after_destroy"]
+
+        def self.included(base)
+            #puts 'Callbacks included in ' + base.inspect
+
+        end
     end
 
     class Base < RightAws::ActiveSdb::Base
 
+        include SimpleRecord::Callbacks
+
+
+        # todo: move into Callbacks module
+        #this bit of code creates a "run_blank" function for everything value in the @@callbacks array.
+        #this function can then be inserted in the appropriate place in the save, new, destroy, etc overrides
+        #basically, this is how we recreate the callback functions
+        @@callbacks.each do |callback|
+            instance_eval <<-endofeval
+
+                #puts 'doing callback=' + callback + ' for ' + self.inspect
+                #we first have to make an initialized array for each of the callbacks, to prevent problems if they are not called
+
+                def #{callback}(*args)
+                    #puts 'callback called in ' + self.inspect + ' with ' + args.inspect
+
+                    #make_dirty(arg_s, value)
+                    #self[arg.to_s]=value
+                    #puts 'value in callback #{callback}=' + value.to_s
+                    args.each do |arg|
+                        cnames = callbacks['#{callback}']
+                        #puts '\tcnames1=' + cnames.inspect + ' for class ' + self.inspect
+                        cnames = [] if cnames.nil?
+                        cnames << arg.to_s if cnames.index(arg.to_s).nil?
+                        #puts '\tcnames2=' + cnames.inspect
+                        callbacks['#{callback}'] = cnames
+                    end
+                end
+
+            endofeval
+        end
+        #puts 'base methods=' + self.methods.inspect
+
+
+
+        def self.inherited(base)
+            puts 'SimpleRecord::Base is inherited by ' + base.inspect
+            setup_callbacks(base)
+
+            base.has_dates :created, :updated
+            base.before_create :set_created, :set_updated
+            base.before_update :set_updated
+
+        end
+
+        def self.setup_callbacks(base)
+            instance_eval <<-endofeval
+
+                def callbacks
+                    @callbacks ||= {}
+                    @callbacks
+                end
+
+               def self.defined_attributes
+                    #puts 'class defined_attributes'
+                    @attributes ||= {}
+                    @attributes
+                end
+
+            endofeval
+
+            @@callbacks.each do |callback|
+                class_eval <<-endofeval
+
+             def run_#{callback}
+                #puts 'CLASS CALLBACKS for ' + self.inspect + ' = ' + self.class.callbacks.inspect
+                return true if self.class.callbacks.nil?
+                cnames = self.class.callbacks['#{callback}']
+                cnames = [] if cnames.nil?
+                #cnames += super.class.callbacks['#{callback}'] unless super.class.callbacks.nil?
+                # puts 'cnames XXX = ' + cnames.inspect
+                return true if cnames.nil?
+                cnames.each { |name|
+                    #puts 'run_  #{name}'
+                  unless eval(name)
+                    return false
+                  end
+              }
+                #super.run_#{callback}
+              return true
+            end
+
+                endofeval
+            end
+        end
+
+
+
+        # Holds information about an attribute
+        class Attribute
+            attr_accessor :type, :options
+
+            def initialize(type)
+                @type = type
+            end
+
+        end
+
+
+        def defined_attributes_local
+            #puts 'local defined_attributes'
+            self.class.defined_attributes
+        end
+
+
         attr_accessor :errors
         @@domain_prefix = ''
         @domain_name_for_class = nil
@@ -103,57 +223,67 @@ module SimpleRecord
             domain_name_for_class
         end
 
-        #this bit of code creates a "run_blank" function for everything value in the @@callbacks array.
-        #this function can then be inserted in the appropriate place in the save, new, destroy, etc overrides
-        #basically, this is how we recreate the callback functions
-        @@callbacks=["before_save", "before_create", "after_create", "before_update", "after_update", "after_save", "after_destroy"]
-        @@callbacks.each do |callback|
-            #we first have to make an initialized array for each of the callbacks, to prevent problems if they are not called
-            eval %{
-        @@#{callback}_names=[]
 
-        def self.#{callback}(*args)
-        args.each do |arg|
-          @@#{callback}_names << arg.to_s if @@#{callback}_names.index(arg.to_s).nil?
-        end
-#      asdf    @@#{callback}_names=args.map{|arg| arg.to_s}
-      end
 
-        def run_#{callback}
-          @@#{callback}_names.each { |name|
-          unless eval(name)
-            return false
-          end
-          }
-          return true
+        # Since SimpleDB supports multiple attributes per value, the values are an array.
+        # This method will return the value unwrapped if it's the only, otherwise it will return the array.
+        def get_attribute(arg)
+            arg = arg.to_s
+            if self[arg].class==Array
+                if self[arg].length==1
+                    ret = self[arg][0]
+                else
+                    ret = self[arg]
+                end
+            else
+                ret = self[arg]
+            end
+            ret
         end
-    }
+
+        def make_dirty(arg, value)
+            # todo: only set dirty if it changed
+            #puts 'making dirty ' + @dirty.inspect
+            @dirty[arg] = get_attribute(arg) # Store old value (not sure if we need it?)
+            #puts 'end making dirty ' + @dirty.inspect
         end
 
-         @@attributes = []
         def self.has_attributes(*args)
             args.each do |arg|
-                @@attributes << arg if @@attributes.index(arg).nil?
+                defined_attributes[arg] = SimpleRecord::Base::Attribute.new(:string) if defined_attributes[arg].nil?
                 # define reader method
+                arg_s = arg.to_s # to get rid of all the to_s calls
                 send :define_method, arg do
                     ret = nil
-                    if self[arg.to_s].class==Array
-                        if self[arg.to_s].length==1
-                            ret = self[arg.to_s][0]
-                        else
-                            ret = self[arg.to_s]
-                        end
-                    else
-                        ret = self[arg.to_s]
-                    end
+                    ret = get_attribute(arg)
                     return nil if ret.nil?
                     return un_offset_if_int(arg, ret)
                 end
 
                 # define writer method
-                method_name = (arg.to_s+"=")
+                method_name = (arg_s+"=")
                 send(:define_method, method_name) do |value|
-                    self[arg.to_s]=value#      end
+                    make_dirty(arg_s, value)
+                    self[arg.to_s]=value
+                end
+
+                # Now for dirty methods: http://api.rubyonrails.org/classes/ActiveRecord/Dirty.html
+                # define changed? method
+                send(:define_method, arg_s + "_changed?") do
+                    !@dirty[arg_s].nil?
+                end
+
+                # define change method
+                send(:define_method, arg_s + "_change") do
+                    old_val = @dirty[arg_s]
+                    return nil if old_val.nil?
+                    [old_val, get_attribute(arg_s)]
+                end
+
+                # define was method
+                send(:define_method, arg_s + "_was") do
+                    old_val = @dirty[arg_s]
+                    old_val
                 end
             end
         end
@@ -171,30 +301,22 @@ module SimpleRecord
             are_booleans(*args)
         end
 
-        @@ints = []
         def self.are_ints(*args)
             #    puts 'calling are_ints: ' + args.inspect
             args.each do |arg|
-                # todo: maybe @@ints and @@dates should be maps for quicker lookups
-                @@ints << arg if @@ints.index(arg).nil?
+                defined_attributes[arg].type = :int
             end
-#    @@ints = args
-            #    puts 'ints=' + @@ints.inspect
         end
 
-        @@dates = []
         def self.are_dates(*args)
             args.each do |arg|
-                @@dates << arg if @@dates.index(arg).nil?
+                defined_attributes[arg].type = :date
             end
-#    @@dates = args
-            #    puts 'dates=' + @@dates.inspect
         end
 
-        @@booleans = []
         def self.are_booleans(*args)
             args.each do |arg|
-                @@booleans << arg if @@booleans.index(arg).nil?
+                defined_attributes[arg].type = :boolean
             end
         end
 
@@ -207,14 +329,17 @@ module SimpleRecord
             end
         end
 
-        @@belongs_to_map = {}
         # One belongs_to association per call. Call multiple times if there are more than one.
         #
         # This method will also create an {association)_id method that will return the ID of the foreign object
         # without actually materializing it.
         def self.belongs_to(association_id, options = {})
-            @@belongs_to_map[association_id] = options
+            attribute = SimpleRecord::Base::Attribute.new(:belongs_to)
+            defined_attributes[association_id] = attribute
+            attribute.options = options
+            #@@belongs_to_map[association_id] = options
             arg = association_id
+            arg_s = arg.to_s
             arg_id = arg.to_s + '_id'
 
             # todo: should also handle foreign_key http://74.125.95.132/search?q=cache:KqLkxuXiBBQJ:wiki.rubyonrails.org/rails/show/belongs_to+rails+belongs_to&hl=en&ct=clnk&cd=1&gl=us
@@ -224,7 +349,8 @@ module SimpleRecord
 
             # Define reader method
             send(:define_method, arg) do
-                options2 = @@belongs_to_map[arg]
+                attribute = defined_attributes[arg]
+                options2 = attribute.options # @@belongs_to_map[arg]
                 class_name = options2[:class_name] || arg.to_s[0...1].capitalize + arg.to_s[1...arg.to_s.length]
 
                 # Camelize classnames with underscores (ie my_model.rb --> MyModel)
@@ -243,7 +369,7 @@ module SimpleRecord
 #          puts 'belongs_to incache=' + ret.inspect
                     end
                     if ret.nil?
-                        to_eval = "#{class_name}.find(@attributes['#{arg_id}'][0], :auto_load=>true)"
+                        to_eval = "#{class_name}.find(@attributes['#{arg_id}'][0])"
 #      puts 'to eval=' + to_eval
                         begin
                             ret = eval(to_eval) # (defined? #{arg}_id)
@@ -261,26 +387,28 @@ module SimpleRecord
                 return ret
             end
 
-            # Define reader ID method
-            send(:define_method, arg_id) do
-                if !@attributes[arg_id].nil? && @attributes[arg_id].size > 0 && @attributes[arg_id][0] != nil && @attributes[arg_id][0] != ''
-                    return @attributes[arg_id][0]
-                end
-                return nil
-            end
-
 
             # Define writer method
             send(:define_method, arg.to_s + "=") do |value|
                 arg_id = arg.to_s + '_id'
                 if value.nil?
+                    make_dirty(arg_id, nil)
                     self[arg_id]=nil unless self[arg_id].nil? # if it went from something to nil, then we have to remember and remove attribute on save
                 else
+                    make_dirty(arg_id, value.id)
                     self[arg_id]=value.id
                 end
             end
 
 
+            # Define ID reader method for reading the associated objects id without getting the entire object
+            send(:define_method, arg_id) do
+                if !@attributes[arg_id].nil? && @attributes[arg_id].size > 0 && @attributes[arg_id][0] != nil && @attributes[arg_id][0] != ''
+                    return @attributes[arg_id][0]
+                end
+                return nil
+            end
+
             # Define writer method for setting the _id directly without the associated object
             send(:define_method, arg_id + "=") do |value|
                 if value.nil?
@@ -318,27 +446,8 @@ module SimpleRecord
 
         end
 
-        has_attributes :created, :updated
-        before_create :set_created, :set_updated
-        before_update :set_updated
-        are_dates :created, :updated
-
-        def set_created
-#    puts 'SETTING CREATED'
-            #    @created = DateTime.now
-            self[:created] = DateTime.now
-#    @tester = 'some test value'
-            #    self[:tester] = 'some test value'
-        end
-
-        def set_updated
-#    puts 'SETTING UPDATED'
-            #    @updated = DateTime.now
-            self[:updated] = DateTime.now
-#    @tester = 'some test value updated'
-        end
-
         def initialize(*params)
+
             if params[0]
                 #we have to handle the virtuals. Right now, this assumes that all parameters are passed from inside an array
                 #this is the usually the case when the parameters are passed passed via POST and obtained from the params array
@@ -353,6 +462,34 @@ module SimpleRecord
                 super()
             end
             @errors=SimpleRecord_errors.new
+            @dirty = {}
+
+
+        end
+
+        def clear_errors
+            @errors=SimpleRecord_errors.new
+        end
+
+        def []=(attribute, values)
+            @dirty[attribute] = get_attribute(attribute)
+            super
+        end
+
+
+        def set_created
+#    puts 'SETTING CREATED'
+            #    @created = DateTime.now
+            self[:created] = DateTime.now
+#    @tester = 'some test value'
+            #    self[:tester] = 'some test value'
+        end
+
+        def set_updated
+#    puts 'SETTING UPDATED'
+            #    @updated = DateTime.now
+            self[:updated] = DateTime.now
+#    @tester = 'some test value updated'
         end
 
 
@@ -399,19 +536,27 @@ module SimpleRecord
 
         @create_domain_called = false
 
-        def save(*params)
+        # Options:
+        #   - :except => Array of attributes to NOT save
+        #   - :dirty => true - Will only store attributes that were modified
+        #
+        def save(options={})
             #    puts 'SAVING: ' + self.inspect
+            clear_errors
             is_create = self[:id].nil?
-            ok = pre_save(*params)
+            ok = pre_save(options)
             if ok
                 begin
                     #        puts 'is frozen? ' + self.frozen?.to_s + ' - ' + self.inspect
-                    to_delete = get_atts_to_delete
-                    if super(*params)
+                    if options[:dirty] # Only used in simple_record right now
+                        options[:dirty_atts] = @dirty
+                    end
+                    to_delete = get_atts_to_delete # todo: this should use the @dirty hash now
+                    if super(options)
 #          puts 'SAVED super'
                         self.class.cache_results(self)
                         delete_niled(to_delete)
-                        if run_after_save && is_create ? run_after_create : run_after_update
+                        if is_create ? run_after_create : run_after_update && run_after_save
                             return true
                         else
                             #I thought about calling destroy here, but rails doesn't behave that way, so neither will I
@@ -425,7 +570,7 @@ module SimpleRecord
                     if (domain_ok($!))
                         if !@create_domain_called
                             @create_domain_called = true
-                            save(*params)
+                            save(options)
                         else
                             raise $!
                         end
@@ -440,45 +585,46 @@ module SimpleRecord
         end
 
         def pad_and_offset_ints_to_sdb()
-            if !@@ints.nil?
-                for i in @@ints
+
+            defined_attributes_local.each_pair do |name, att_meta|
 #          puts 'int encoding: ' + i.to_s
-                    if !self[i.to_s].nil?
+                if att_meta.type == :int && !self[name.to_s].nil?
 #            puts 'before: ' + self[i.to_s].inspect
-                        #            puts @attributes.inspect
-                        #            puts @attributes[i.to_s].inspect
-                        arr = @attributes[i.to_s]
-                        arr.collect!{ |x| self.class.pad_and_offset(x) }
-                        @attributes[i.to_s] = arr
+                    #            puts @attributes.inspect
+                    #            puts @attributes[i.to_s].inspect
+                    arr = @attributes[name.to_s]
+                    arr.collect!{ |x| self.class.pad_and_offset(x) }
+                    @attributes[name.to_s] = arr
 #            puts 'after: ' + @attributes[i.to_s].inspect
-                    else
-                        #            puts 'was nil'
-                    end
                 end
             end
         end
 
         def convert_dates_to_sdb()
-            if !@@dates.nil?
-                for i in @@dates
+
+            defined_attributes_local.each_pair do |name, att_meta|
 #          puts 'int encoding: ' + i.to_s
-                    if !self[i.to_s].nil?
+                if att_meta.type == :date && !self[name.to_s].nil?
 #            puts 'before: ' + self[i.to_s].inspect
-                        #            puts @attributes.inspect
-                        #            puts @attributes[i.to_s].inspect
-                        arr = @attributes[i.to_s]
-                        #puts 'padding date=' + i.to_s
-                        arr.collect!{ |x| self.class.pad_and_offset(x) }
-                        @attributes[i.to_s] = arr
+                    #            puts @attributes.inspect
+                    #            puts @attributes[i.to_s].inspect
+                    arr = @attributes[name.to_s]
+                    #puts 'padding date=' + i.to_s
+                    arr.collect!{ |x| self.class.pad_and_offset(x) }
+                    @attributes[name.to_s] = arr
 #            puts 'after: ' + @attributes[i.to_s].inspect
-                    else
-                        #            puts 'was nil'
-                    end
+                else
+                    #            puts 'was nil'
                 end
             end
         end
 
-        def pre_save(*params)
+        def pre_save(options)
+
+            is_create = self[:id].nil?
+            ok = run_before_validation && is_create ? run_before_validation_on_create : run_before_validation_on_update
+            return false unless ok
+
             if respond_to?('validate')
                 validate
 #      puts 'AFTER VALIDATIONS, ERRORS=' + errors.inspect
@@ -488,7 +634,9 @@ module SimpleRecord
                 end
             end
 
-            is_create = self[:id].nil?
+            ok = run_after_validation && is_create ? run_after_validation_on_create : run_after_validation_on_update
+            return false unless ok
+
             ok = respond_to?('before_save') ? before_save : true
             if ok
                 if is_create && respond_to?('before_create')
@@ -518,6 +666,7 @@ module SimpleRecord
         end
 
         def get_atts_to_delete
+            # todo: this should use the @dirty hash now
             to_delete = []
             @attributes.each do |key, value|
                 #      puts 'value=' + value.inspect
@@ -530,12 +679,12 @@ module SimpleRecord
 
         # Run pre_save on each object, then runs batch_put_attributes
         # Returns
-        def self.batch_save(objects)
+        def self.batch_save(objects, options={})
             results = []
             to_save = []
             if objects && objects.size > 0
                 objects.each do |o|
-                    ok = o.pre_save
+                    ok = o.pre_save(options)
                     raise "Pre save failed on object [" + o.inspect + "]" if !ok
                     results << ok
                     next if !ok
@@ -563,51 +712,14 @@ module SimpleRecord
         end
 
         def un_offset_if_int(arg, x)
-            if !@@ints.nil?
-                for i in @@ints
-#        puts 'unpadding: ' + i.to_s
-                    # unpad and unoffset
-                    if i == arg
-#          puts 'unoffsetting ' + x.to_s
-                        x = un_offset_int(x)
-                    end
-                end
-            end
-            if !@@dates.nil?
-                for d in @@dates
-#        puts 'converting created: ' + self['created'].inspect
-                    if d == arg
-                        x = to_date(x)
-                    end
-#          if !self[d].nil?
-#            self[d].collect!{ |d2|
-#              if d2.is_a?(String)
-#                DateTime.parse(d2)
-#              else
-#                d2
-#              end
-#            }
-#          end
-#        puts 'after=' + self['created'].inspect
-                end
-            end
-            if !@@booleans.nil?
-                for b in @@booleans
-#        puts 'converting created: ' + self['created'].inspect
-                    if b == arg
-                        x = to_bool(x)
-                    end
-#          if !self[d].nil?
-#            self[d].collect!{ |d2|
-#              if d2.is_a?(String)
-#                DateTime.parse(d2)
-#              else
-#                d2
-#              end
-#            }
-#          end
-#        puts 'after=' + self['created'].inspect
-                end
+            att_meta =  defined_attributes_local[arg]
+#          puts 'int encoding: ' + i.to_s
+            if att_meta.type == :int
+                x = un_offset_int(x)
+            elsif att_meta.type == :date
+                x = to_date(x)
+            elsif att_meta.type == :boolean
+                x = to_bool(x)
             end
             x
         end
@@ -659,12 +771,9 @@ module SimpleRecord
         end
 
         def unpad_self
-            if !@@ints.nil?
-                for i in @@ints
-#        puts 'unpadding: ' + i.to_s
-                    # unpad and unoffset
-
-                    unpad(i, @attributes)
+            defined_attributes_local.each_pair do |name, att_meta|
+                if att_meta.type == :int
+                    unpad(name, @attributes)
                 end
             end
         end
@@ -746,9 +855,9 @@ This is done on getters now
 
             # Pad and Offset number attributes
             options = params[1]
-#    puts 'options=' + options.inspect
+            #puts 'options=' + options.inspect
             convert_condition_params(options)
-            #   puts 'after collect=' + options.inspect
+            #puts 'after collect=' + options.inspect
 
             results = all ? [] : nil
             begin
@@ -842,6 +951,26 @@ This is done on getters now
             return @@domain_prefix + self.class.name.tableize
         end
 
+        def changed
+            return @dirty.keys
+        end
+
+        def changed?
+            return @dirty.size > 0
+        end
+
+        def changes
+            ret = {}
+            #puts 'in CHANGES=' + @dirty.inspect
+            @dirty.each_pair {|key, value| ret[key] = [value, get_attribute(key)]}
+            return ret
+        end
+
+        def mark_as_old
+            super
+            @dirty = {}
+        end
+
     end
 
     class SimpleRecord_errors
@@ -950,3 +1079,4 @@ This is done on getters now
 
     end
 end
+

data/test/my_child_model.rb

@@ -1,6 +1,34 @@
 require File.expand_path(File.dirname(__FILE__) + "/../lib/simple_record")
+require 'my_model'
 
 class MyChildModel < SimpleRecord::Base
     belongs_to :my_model
-    has_attributes :name
-end
+    has_attributes :name, :child_attr
+
+end
+
+
+=begin
+
+
+puts 'word'
+
+mm = MyModel.new
+puts 'word2'
+
+mcm = MyChildModel.new
+
+puts 'mcm instance methods=' + MyChildModel.instance_methods(true).inspect
+#puts 'mcm=' + mcm.instance_methods(false)
+puts 'mcm class vars = ' + mcm.class.class_variables.inspect
+puts mcm.class == MyChildModel
+puts 'saved? ' + mm.save.to_s
+puts mm.errors.inspect
+
+puts "mm attributes=" + MyModel.defined_attributes.inspect
+puts "mcm attributes=" + MyChildModel.defined_attributes.inspect
+
+mcm2 = MyChildModel.new
+puts "mcm2 attributes=" + MyChildModel.defined_attributes.inspect
+
+=end

data/test/my_model.rb

@@ -2,10 +2,27 @@ require File.expand_path(File.dirname(__FILE__) + "/../lib/simple_record")
 
 class MyModel < SimpleRecord::Base
 
-    has_attributes :name
+    has_attributes :name, :nickname
     has_ints :age
     has_booleans :cool
-    has_dates :created, :updated, :birthday
+    has_dates :birthday
 
 
+    #callbacks
+    before_create :set_nickname
+
+    def set_nickname
+        self.nickname = name if self.nickname.blank?
+    end
+
+    def validate
+        errors.add("name", "can't be empty.") if name.blank?
+    end
+
+
+
+    def atts
+        @@attributes
+    end
+
 end

data/test/test_simple_record.rb

@@ -24,15 +24,27 @@ class TestSimpleRecord < Test::Unit::TestCase
         mm.age = 32
         mm.cool = true
         mm.save
+
+        assert !mm.created.nil?
+        assert !mm.updated.nil?
+        assert !mm.id.nil?
+        assert mm.age == 32
+        assert mm.cool = true
+        assert mm.name = "Travis"
+
         id = mm.id
         puts 'id=' + id.to_s
         # Get the object back
         mm2 = MyModel.find(id)
-        puts 'got=' + mm2.name + ' and he/she is ' + mm2.age.to_s + ' years old and he/she is cool? ' + mm2.cool.to_s
-        puts mm2.cool.class.name
+        #puts 'got=' + mm2.name + ' and he/she is ' + mm2.age.to_s + ' years old and he/she is cool? ' + mm2.cool.to_s
+        #puts mm2.cool.class.name
         assert mm2.id == mm.id
         assert mm2.age == mm.age
         assert mm2.cool == mm.cool
+        assert mm2.age == 32
+        assert mm2.cool = true
+        assert mm2.name = "Travis"
+        assert mm2.created.is_a? DateTime
     end
 
     def test_bad_query
@@ -83,39 +95,85 @@ class TestSimpleRecord < Test::Unit::TestCase
     end
 
     def test_callbacks
-        # these DO NOT work right now, all objects get all callbacks
-        #	I tried like this, seem to be getting somewhere.
-        #
-        #  class << self;
-        #  @@callbacks.each do |callback|
-        #    #we first have to make an initialized array for each of the callbacks, to prevent problems if they are not called
-        #    puts 'setting callback ' + callback.to_s + ' on ' + self.inspect
-        #    eval %{
-        #
-        #        # add the methods to the class
-        #        def #{callback}(*args)
-        #        args.each do |arg|
-        #          cb_names = self.instance_variable_get(:@#{callback}_names)
-        #          cb_names = [] if cb_names.nil?
-        #          cb_names << arg.to_s if cb_names.index(arg.to_s).nil?
-        #          self.instance_variable_set(:@#{callback}_names, cb_names)
-        #        end
-        ##      asdf    @@#{callback}_names=args.map{|arg| arg.to_s}
-        #      end
+
+
+        mm = MyModel.new
+        assert !mm.save
+        assert mm.errors.count == 1 # name is required
+
+        # test queued callback before_create
+        mm.name = "Travis"
+        assert mm.save
+        # now nickname should be set on before_create
+        assert mm.nickname == mm.name
+
+        mm2 = MyModel.find(mm.id)
+        assert mm2.nickname = mm.nickname
+        assert mm2.name = mm.name
+
+
+
+    end
+
+    def test_dirty
+        mm = MyModel.new
+        mm.name = "Travis"
+        mm.age = 32
+        mm.cool = true
+        mm.save
+        id = mm.id
+        puts 'id=' + id.to_s
+        # Get the object back
+        mm2 = MyModel.find(id)
+        puts 'got=' + mm2.name + ' and he/she is ' + mm2.age.to_s + ' years old and he/she is cool? ' + mm2.cool.to_s
+        assert mm2.id == mm.id
+        assert mm2.age == mm.age
+        assert mm2.cool == mm.cool
+
+        mm2.name = "Travis 2"
+        mm2.save(:dirty=>true)
+
+        # todo: how do we assert this?
+
+    end
+
+    # http://api.rubyonrails.org/classes/ActiveRecord/Dirty.html#M002136
+    def test_changed
+        mm = MyModel.new
+        mm.name = "Travis"
+        mm.age = 32
+        mm.cool = true
+        mm.save
+
+        puts 'changed?=' + mm.changed?.to_s
+        assert !mm.changed?
+        assert mm.changed.size == 0
+        assert mm.changes.size == 0
+        assert !mm.name_changed?
+
+        mm.name = "Jim"
+        assert mm.changed?
+        assert mm.changed.size == 1
+        assert mm.changed[0] == "name"
+
+        assert mm.changes.size == 1
+        puts 'CHANGES=' + mm.changes.inspect
+        assert mm.changes["name"][0] == "Travis"
+        assert mm.changes["name"][1] == "Jim"
+
+        assert mm.name_changed?
+        assert mm.name_was == "Travis"
+        assert mm.name_change[0] == "Travis"
+        assert mm.name_change[1] == "Jim"
+
+    end
+
+    def test_attributes_correct
+
+        #MyModel.defined_attributes.each do |a|
         #
-        #        # now we run the methods in the callback array for this class
-        #send :define_method, "run_#{callback}" do
-        ##        def run_#{callback}
-        #          cb_names = self.instance_variable_get(:@#{callback}_names)
-        #          cb_names.each { |name|
-        #          unless eval(name)
-        #            return false
-        #          end
-        #          }
-        #          return true
-        #        end
-        #    }
-        #  end
-        #  end
+        #end
+        #MyChildModel.defined_attributes.inspect
+
     end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: appoxy-simple_record
 version: !ruby/object:Gem::Version 
-  version: 1.0.23
+  version: 1.0.26
 platform: ruby
 authors: 
 - Travis Reeder
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-15 00:00:00 -07:00
+date: 2009-07-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - README.markdown
 has_rdoc: true
 homepage: http://github.com/appoxy/simple_record/
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -47,7 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Drop in replacement for ActiveRecord to Amazon SimpleDB instead.