simple_record 1.1.41 → 1.1.42

data/lib/simple_record.rb

@@ -29,10 +29,12 @@ require 'sdb/active_sdb'
 require 'base64'
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/encryptor")
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/callbacks")
+require File.expand_path(File.dirname(__FILE__) + "/simple_record/attributes")
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/errors")
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/password")
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/results_array")
 require File.expand_path(File.dirname(__FILE__) + "/simple_record/stats")
+require File.expand_path(File.dirname(__FILE__) + "/simple_record/translations")
 
 
 module SimpleRecord
@@ -73,8 +75,12 @@ module SimpleRecord
 
     class Base < Aws::ActiveSdb::Base
 
+        include SimpleRecord::Translations
+#        include SimpleRecord::Attributes
+        extend SimpleRecord::Attributes
         include SimpleRecord::Callbacks
 
+
         def initialize(attrs={})
             # todo: Need to deal with objects passed in. iterate through belongs_to perhaps and if in attrs, set the objects id rather than the object itself
 
@@ -89,12 +95,7 @@ module SimpleRecord
         def initialize_base(attrs={})
 
             #we have to handle the virtuals.
-            @@virtuals.each do |virtual|
-                #we first copy the information for the virtual to an instance variable of the same name
-                eval("@#{virtual}=attrs['#{virtual}']")
-                #and then remove the parameter before it is passed to initialize, so that it is NOT sent to SimpleDB
-                eval("attrs.delete('#{virtual}')")
-            end
+            Attributes.handle_virtuals(attrs)
 
             @errors=SimpleRecord_errors.new
             @dirty = {}
@@ -112,40 +113,9 @@ module SimpleRecord
         end
 
 
-        # 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)
+            Callbacks.setup_callbacks(base)
 
 #            base.has_strings :id
             base.has_dates :created, :updated
@@ -154,59 +124,6 @@ module SimpleRecord
 
         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 for #{callback} = ' + cnames.inspect
-                return true if cnames.nil?
-                cnames.each { |name|
-                    #puts 'run_  #{name}'
-                  if eval(name) == false # nil should be an ok return, only looking for false
-                    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, options=nil)
-                @type = type
-                @options = options
-            end
-
-        end
-
 
         def defined_attributes_local
             #puts 'local defined_attributes'
@@ -252,14 +169,6 @@ module SimpleRecord
             super
         end
 
-=begin
- def self.get_domain_name
-            # puts 'returning domain_name=' + @domain_name_for_class.to_s
-            #return @domain_name_for_class
-            return self.domain
-        end
-
-=end
 
         def domain
             super # super.domain
@@ -276,8 +185,8 @@ module SimpleRecord
 
         def get_attribute_sdb(arg)
 #            arg = arg.to_s
-            puts "get_attribute_sdb(#{arg}) - #{arg.class.name}"
-            puts 'self[]=' + self.inspect
+#            puts "get_attribute_sdb(#{arg}) - #{arg.class.name}"
+#            puts 'self[]=' + self.inspect
             ret = strip_array(self[arg])
             return ret
         end
@@ -317,217 +226,18 @@ module SimpleRecord
 
         def make_dirty(arg, value)
             arg = arg.to_s
-            puts "Marking #{arg} dirty with #{value}"
+#            puts "Marking #{arg} dirty with #{value}"
             if @dirty.include?(arg)
                 old = @dirty[arg]
-                puts "Was already dirty #{old}"
+#                puts "Was already dirty #{old}"
                 @dirty.delete(arg) if value == old
             else
                 old = get_attribute(arg)
-                puts "dirtifying #{old} to #{value}"
+#                puts "dirtifying #{old} to #{value}"
                 @dirty[arg] = old if value != old
             end
         end
 
-        def self.has_attributes(*args)
-            args.each do |arg|
-                arg_options = nil
-                if arg.is_a?(Hash)
-                    # then attribute may have extra options
-                    arg_options = arg
-                    arg = arg_options[:name]
-                end
-                attr = SimpleRecord::Base::Attribute.new(:string, arg_options)
-                defined_attributes[arg] = attr 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 = get_attribute(arg)
-                    return ret
-                end
-
-                # define writer method
-                send(:define_method, arg_s+"=") do |value|
-                    set(arg, 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.has_key?(arg_s)
-                end
-
-                # define change method
-                send(:define_method, arg_s + "_change") do
-                    old_val = @dirty[arg_s]
-                    [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
-
-        def self.has_strings(*args)
-            has_attributes(*args)
-        end
-
-        def self.has_ints(*args)
-            has_attributes(*args)
-            are_ints(*args)
-        end
-
-        def self.has_dates(*args)
-            has_attributes(*args)
-            are_dates(*args)
-        end
-
-        def self.has_booleans(*args)
-            has_attributes(*args)
-            are_booleans(*args)
-        end
-
-        def self.are_ints(*args)
-            #    puts 'calling are_ints: ' + args.inspect
-            args.each do |arg|
-                defined_attributes[arg].type = :int
-            end
-        end
-
-        def self.are_dates(*args)
-            args.each do |arg|
-                defined_attributes[arg].type = :date
-            end
-        end
-
-        def self.are_booleans(*args)
-            args.each do |arg|
-                defined_attributes[arg].type = :boolean
-            end
-        end
-
-        @@virtuals=[]
-
-        def self.has_virtuals(*args)
-            @@virtuals = args
-            args.each do |arg|
-                #we just create the accessor functions here, the actual instance variable is created during initialize
-                attr_accessor(arg)
-            end
-        end
-
-        # 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 = {})
-            attribute = SimpleRecord::Base::Attribute.new(:belongs_to, options)
-            defined_attributes[association_id] = attribute
-            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
-            #    puts "arg_id=#{arg}_id"
-            #        puts "is defined? " + eval("(defined? #{arg}_id)").to_s
-            #        puts 'atts=' + @attributes.inspect
-
-            # Define reader method
-            send(:define_method, arg) do
-                attribute = defined_attributes_local[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)
-                class_name = class_name.camelize
-
-                #      puts "attr=" + @attributes[arg_id].inspect
-                #      puts 'val=' + @attributes[arg_id][0].inspect unless @attributes[arg_id].nil?
-                ret = nil
-                arg_id = arg.to_s + '_id'
-                if !@attributes[arg_id].nil? && @attributes[arg_id].size > 0 && @attributes[arg_id][0] != nil && @attributes[arg_id][0] != ''
-                    if !@@cache_store.nil?
-                        arg_id_val = @attributes[arg_id][0]
-                        cache_key = self.class.cache_key(class_name, arg_id_val)
-#          puts 'cache_key=' + cache_key
-                        ret = @@cache_store.read(cache_key)
-#          puts 'belongs_to incache=' + ret.inspect
-                    end
-                    if ret.nil?
-                        to_eval = "#{class_name}.find(@attributes['#{arg_id}'][0])"
-#      puts 'to eval=' + to_eval
-                        begin
-                            ret = eval(to_eval) # (defined? #{arg}_id)
-                        rescue Aws::ActiveSdb::ActiveSdbError
-                            if $!.message.include? "Couldn't find"
-                                ret = nil
-                            else
-                                raise $!
-                            end
-                        end
-
-                    end
-                end
-#      puts 'ret=' + ret.inspect
-                return ret
-            end
-
-
-            # Define writer method
-            send(:define_method, arg.to_s + "=") do |value|
-                set_belongs_to(arg, value)
-            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?
-                    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
-                    self[arg_id] = value
-                end
-            end
-
-            send(:define_method, "create_"+arg.to_s) do |*params|
-                newsubrecord=eval(arg.to_s.classify).new(*params)
-                newsubrecord.save
-                arg_id = arg.to_s + '_id'
-                self[arg_id]=newsubrecord.id
-            end
-        end
-
-        def self.has_many(*args)
-            args.each do |arg|
-                #okay, this creates an instance method with the pluralized name of the symbol passed to belongs_to
-                send(:define_method, arg) do
-                    #when called, the method creates a new, very temporary instance of the Activerecordtosdb_subrecord class
-                    #It is passed the three initializers it needs:
-                    #note the first parameter is just a string by time new gets it, like "user"
-                    #the second and third parameters are still a variable when new gets it, like user_id
-                    return eval(%{Activerecordtosdb_subrecord_array.new('#{arg}', self.class.name ,id)})
-                end
-            end
-            #Disclaimer: this whole funciton just seems crazy to me, and a bit inefficient. But it was the clearest way I could think to do it code wise.
-            #It's bad programming form (imo) to have a class method require something that isn't passed to it through it's variables.
-            #I couldn't pass the id when calling find, since the original find doesn't work that way, so I was left with this.
-        end
-
-        def self.has_one(*args)
-
-        end
-
         def clear_errors
             @errors=SimpleRecord_errors.new
         end
@@ -558,38 +268,8 @@ module SimpleRecord
         end
 
 
-        @@offset = 9223372036854775808
-        @@padding = 20
-        @@date_format = "%Y-%m-%dT%H:%M:%S"; # Time to second precision
-
-        def self.pad_and_offset(x) # Change name to something more appropriate like ruby_to_sdb
-            # todo: add Float, etc
-            #    puts 'padding=' + x.class.name + " -- " + x.inspect
-            if x.kind_of? Integer
-                x += @@offset
-                x_str = x.to_s
-                # pad
-                x_str = '0' + x_str while x_str.size < 20
-                return x_str
-            elsif x.respond_to?(:iso8601)
-                #  puts x.class.name + ' responds to iso8601'
-                #
-                # There is an issue here where Time.iso8601 on an incomparable value to DateTime.iso8601.
-                # Amazon suggests: 2008-02-10T16:52:01.000-05:00
-                #                  "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
-                #
-                if x.is_a? DateTime
-                    x_str = x.getutc.strftime(@@date_format)
-                elsif x.is_a? Time
-                    x_str = x.getutc.strftime(@@date_format)
-                elsif x.is_a? Date
-                    x_str = x.strftime(@@date_format)
-
-                end
-                return x_str
-            else
-                return x
-            end
+        def cache_store
+            @@cache_store
         end
 
         def domain_ok(ex)
@@ -646,7 +326,7 @@ module SimpleRecord
         #   - :dirty => true - Will only store attributes that were modified. To make it save regardless and have it update the :updated value, include this and set it to false.
         #
         def save(options={})
-            puts 'SAVING: ' + self.inspect
+#            puts 'SAVING: ' + self.inspect
             clear_errors
             # todo: decide whether this should go before pre_save or after pre_save? pre_save dirties "updated" and perhaps other items due to callbacks
             if options[:dirty]
@@ -664,7 +344,7 @@ module SimpleRecord
                     end
                     to_delete = get_atts_to_delete # todo: this should use the @dirty hash now
 #                    puts 'done to_delete ' + to_delete.inspect
-                    puts 'options=' + options.inspect
+#                    puts 'options=' + options.inspect
                     SimpleRecord.stats.puts += 1
                     if super(options)
 #          puts 'SAVED super'
@@ -706,35 +386,6 @@ module SimpleRecord
             end
         end
 
-        def pad_and_offset_ints_to_sdb()
-
-#            defined_attributes_local.each_pair do |name, att_meta|
-#                if att_meta.type == :int && !self[name.to_s].nil?
-#                    arr = @attributes[name.to_s]
-#                    arr.collect!{ |x| self.class.pad_and_offset(x) }
-#                    @attributes[name.to_s] = arr
-#                end
-#            end
-        end
-
-        def convert_dates_to_sdb()
-
-#            defined_attributes_local.each_pair do |name, att_meta|
-#          puts 'int encoding: ' + i.to_s
-
-#            end
-        end
-
-        def self.pass_hash(value)
-            hashed = Password::create_hash(value)
-            encoded_value = Base64.encode64(hashed)
-            encoded_value
-        end
-
-        def self.pass_hash_check(value, value_to_compare)
-            unencoded_value = Base64.decode64(value)
-            return Password::check(value_to_compare, unencoded_value)
-        end
 
         def self.get_encryption_key()
             key = SimpleRecord.options[:encryption_key]
@@ -745,25 +396,6 @@ module SimpleRecord
             return key
         end
 
-        def self.encrypt(value, key=nil)
-            key = key || get_encryption_key()
-            raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
-            encrypted_value = SimpleRecord::Encryptor.encrypt(:value => value, :key => key)
-            encoded_value = Base64.encode64(encrypted_value)
-            encoded_value
-        end
-
-
-        def self.decrypt(value, key=nil)
-            puts "decrypt orig value #{value} "
-            unencoded_value = Base64.decode64(value)
-            raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
-            key = key || get_encryption_key()
-            puts "decrypting #{unencoded_value} "
-            decrypted_value = SimpleRecord::Encryptor.decrypt(:value => unencoded_value, :key => key)
-            puts "decrypted #{unencoded_value} to #{decrypted_value}"
-            decrypted_value
-        end
 
         def pre_save(options)
 
@@ -918,127 +550,6 @@ module SimpleRecord
             end
         end
 
-        # Convert value from SimpleDB String version to real ruby value.
-        def sdb_to_ruby(name, value)
-            puts 'sdb_to_ruby arg=' + name.inspect + ' - ' + name.class.name + ' - value=' + value.to_s
-            return nil if value.nil?
-            att_meta = defined_attributes_local[name.to_sym]
-
-            if att_meta.options
-                if att_meta.options[:encrypted]
-                    value = self.class.decrypt(value, att_meta.options[:encrypted])
-                end
-                if att_meta.options[:hashed]
-                    return PasswordHashed.new(value)
-                end
-            end
-
-            if att_meta.type == :int
-                value = Base.un_offset_int(value)
-            elsif att_meta.type == :date
-                value = to_date(value)
-            elsif att_meta.type == :boolean
-                value = to_bool(value)
-            end
-            value
-        end
-
-
-        def ruby_to_sdb(name, value)
-
-            return nil if value.nil?
-
-            name = name.to_s
-
-            puts "Converting #{name} to sdb value=#{value}"
-            puts "atts_local=" + defined_attributes_local.inspect
-
-            att_meta = defined_attributes_local[name.to_sym]
-
-            if att_meta.type == :int
-                ret = self.class.pad_and_offset(value)
-            elsif att_meta.type == :date
-                ret = self.class.pad_and_offset(value)
-            else
-                ret = value.to_s
-            end
-
-
-            if att_meta.options
-                if att_meta.options[:encrypted]
-                    puts "ENCRYPTING #{name} value #{value}"
-                    ret = self.class.encrypt(ret, att_meta.options[:encrypted])
-                    puts 'encrypted value=' + ret.to_s
-                end
-                if att_meta.options[:hashed]
-                    ret = self.class.pass_hash(ret)
-                end
-            end
-
-            return ret.to_s
-
-        end
-
-        def wrap_if_required(arg, value, sdb_val)
-            return nil if value.nil?
-
-            arg_s = arg.to_s
-            att_meta = defined_attributes_local[arg.to_sym]
-            if att_meta.options
-                if att_meta.options[:hashed]
-                    puts 'wrapping ' + arg_s
-                    return PasswordHashed.new(sdb_val)
-                end
-            end
-            value
-        end
-
-        def to_date(x)
-            if x.is_a?(String)
-                DateTime.parse(x)
-            else
-                x
-            end
-        end
-
-        def to_bool(x)
-            if x.is_a?(String)
-                x == "true" || x == "1"
-            else
-                x
-            end
-        end
-
-        def self.un_offset_int(x)
-            if x.is_a?(String)
-                x2 = x.to_i
-#            puts 'to_i=' + x2.to_s
-                x2 -= @@offset
-#            puts 'after subtracting offset='+ x2.to_s
-                x2
-            else
-                x
-            end
-        end
-
-        def unpad(i, attributes)
-            if !attributes[i].nil?
-#          puts 'before=' + self[i].inspect
-                attributes[i].collect!{ |x|
-                    un_offset_int(x)
-
-                }
-            end
-        end
-
-        def unpad_self
-            defined_attributes_local.each_pair do |name, att_meta|
-                if att_meta.type == :int
-                    unpad(name, @attributes)
-                end
-            end
-        end
-
         def reload
             super()
         end
@@ -1108,7 +619,7 @@ module SimpleRecord
                     end
                 end
             rescue Aws::AwsError, Aws::ActiveSdb::ActiveSdbError
-                puts "RESCUED: " + $!.message
+#                puts "RESCUED: " + $!.message
                 if ($!.message().index("NoSuchDomain") != nil)
                     # this is ok
                 elsif ($!.message() =~ @@regex_no_id)
@@ -1130,14 +641,14 @@ module SimpleRecord
             if !conditions.nil? && conditions.size > 1
                 # all after first are values
                 conditions.collect! { |x|
-                    self.pad_and_offset(x)
+                    Translations.pad_and_offset(x)
                 }
             end
 
         end
 
         def self.cache_results(results)
-            if !@@cache_store.nil? && !results.nil?
+            if !cache_store.nil? && !results.nil?
                 if results.is_a?(Array)
                     # todo: cache each result
                 else
@@ -1145,7 +656,7 @@ module SimpleRecord
                     id = results.id
                     cache_key = self.cache_key(class_name, id)
                     #puts 'caching result at ' + cache_key + ': ' + results.inspect
-                    @@cache_store.write(cache_key, results, :expires_in =>30)
+                    cache_store.write(cache_key, results, :expires_in =>30)
                 end
             end
         end
@@ -1316,28 +827,6 @@ module SimpleRecord
 
     end
 
-    class PasswordHashed
-
-        def initialize(value)
-            @value = value
-        end
-
-        def hashed_value
-            @value
-        end
-
-        # This allows you to compare an unhashed string to the hashed one.
-        def ==(val)
-            if val.is_a?(PasswordHashed)
-                return val.hashed_value == self.hashed_value
-            end
-            return SimpleRecord::Base.pass_hash_check(@value, val)
-        end
-
-        def to_s
-            @value
-        end
-    end
 
 end
 

data/lib/simple_record/attributes.rb

@@ -0,0 +1,246 @@
+module SimpleRecord
+    module Attributes
+# For all things related to defining attributes.
+
+
+        def self.included(base)
+            #puts 'Callbacks included in ' + base.inspect
+=begin
+            instance_eval <<-endofeval
+
+         def self.defined_attributes
+                #puts 'class defined_attributes'
+                @attributes ||= {}
+                @attributes
+            endendofeval
+            endofeval
+=end
+
+        end
+
+        def defined_attributes
+            @attributes ||= {}
+            @attributes
+        end
+
+        def has_attributes(*args)
+            args.each do |arg|
+                arg_options = nil
+                if arg.is_a?(Hash)
+                    # then attribute may have extra options
+                    arg_options = arg
+                    arg = arg_options[:name]
+                end
+                attr = Attribute.new(:string, arg_options)
+                defined_attributes[arg] = attr 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 = get_attribute(arg)
+                    return ret
+                end
+
+                # define writer method
+                send(:define_method, arg_s+"=") do |value|
+                    set(arg, 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.has_key?(arg_s)
+                end
+
+                # define change method
+                send(:define_method, arg_s + "_change") do
+                    old_val = @dirty[arg_s]
+                    [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
+
+        def has_strings(*args)
+            has_attributes(*args)
+        end
+
+        def has_ints(*args)
+            has_attributes(*args)
+            are_ints(*args)
+        end
+
+        def has_dates(*args)
+            has_attributes(*args)
+            are_dates(*args)
+        end
+
+        def has_booleans(*args)
+            has_attributes(*args)
+            are_booleans(*args)
+        end
+
+        def are_ints(*args)
+            #    puts 'calling are_ints: ' + args.inspect
+            args.each do |arg|
+                defined_attributes[arg].type = :int
+            end
+        end
+
+        def are_dates(*args)
+            args.each do |arg|
+                defined_attributes[arg].type = :date
+            end
+        end
+
+        def are_booleans(*args)
+            args.each do |arg|
+                defined_attributes[arg].type = :boolean
+            end
+        end
+
+        @@virtuals=[]
+
+        def has_virtuals(*args)
+            @@virtuals = args
+            args.each do |arg|
+                #we just create the accessor functions here, the actual instance variable is created during initialize
+                attr_accessor(arg)
+            end
+        end
+
+        # 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 belongs_to(association_id, options = {})
+            attribute = Attribute.new(:belongs_to, options)
+            defined_attributes[association_id] = attribute
+            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
+            #    puts "arg_id=#{arg}_id"
+            #        puts "is defined? " + eval("(defined? #{arg}_id)").to_s
+            #        puts 'atts=' + @attributes.inspect
+
+            # Define reader method
+            send(:define_method, arg) do
+                attribute = defined_attributes_local[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)
+                class_name = class_name.camelize
+
+                #      puts "attr=" + @attributes[arg_id].inspect
+                #      puts 'val=' + @attributes[arg_id][0].inspect unless @attributes[arg_id].nil?
+                ret = nil
+                arg_id = arg.to_s + '_id'
+                if !@attributes[arg_id].nil? && @attributes[arg_id].size > 0 && @attributes[arg_id][0] != nil && @attributes[arg_id][0] != ''
+                    if !cache_store.nil?
+                        arg_id_val = @attributes[arg_id][0]
+                        cache_key = self.class.cache_key(class_name, arg_id_val)
+#          puts 'cache_key=' + cache_key
+                        ret = cache_store.read(cache_key)
+#          puts 'belongs_to incache=' + ret.inspect
+                    end
+                    if ret.nil?
+                        to_eval = "#{class_name}.find(@attributes['#{arg_id}'][0])"
+#      puts 'to eval=' + to_eval
+                        begin
+                            ret = eval(to_eval) # (defined? #{arg}_id)
+                        rescue Aws::ActiveSdb::ActiveSdbError
+                            if $!.message.include? "Couldn't find"
+                                ret = nil
+                            else
+                                raise $!
+                            end
+                        end
+
+                    end
+                end
+#      puts 'ret=' + ret.inspect
+                return ret
+            end
+
+
+            # Define writer method
+            send(:define_method, arg.to_s + "=") do |value|
+                set_belongs_to(arg, value)
+            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?
+                    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
+                    self[arg_id] = value
+                end
+            end
+
+            send(:define_method, "create_"+arg.to_s) do |*params|
+                newsubrecord=eval(arg.to_s.classify).new(*params)
+                newsubrecord.save
+                arg_id = arg.to_s + '_id'
+                self[arg_id]=newsubrecord.id
+            end
+        end
+
+        def has_many(*args)
+            args.each do |arg|
+                #okay, this creates an instance method with the pluralized name of the symbol passed to belongs_to
+                send(:define_method, arg) do
+                    #when called, the method creates a new, very temporary instance of the Activerecordtosdb_subrecord class
+                    #It is passed the three initializers it needs:
+                    #note the first parameter is just a string by time new gets it, like "user"
+                    #the second and third parameters are still a variable when new gets it, like user_id
+                    return eval(%{Activerecordtosdb_subrecord_array.new('#{arg}', self.class.name ,id)})
+                end
+            end
+            #Disclaimer: this whole funciton just seems crazy to me, and a bit inefficient. But it was the clearest way I could think to do it code wise.
+            #It's bad programming form (imo) to have a class method require something that isn't passed to it through it's variables.
+            #I couldn't pass the id when calling find, since the original find doesn't work that way, so I was left with this.
+        end
+
+        def has_one(*args)
+
+        end
+
+        def self.handle_virtuals(attrs)
+            @@virtuals.each do |virtual|
+                #we first copy the information for the virtual to an instance variable of the same name
+                eval("@#{virtual}=attrs['#{virtual}']")
+                #and then remove the parameter before it is passed to initialize, so that it is NOT sent to SimpleDB
+                eval("attrs.delete('#{virtual}')")
+            end
+        end
+
+        # Holds information about an attribute
+        class Attribute
+            attr_accessor :type, :options
+
+            def initialize(type, options=nil)
+                @type = type
+                @options = options
+            end
+
+        end
+
+    end
+end

data/lib/simple_record/callbacks.rb

@@ -1,4 +1,3 @@
-
 module SimpleRecord::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
@@ -12,6 +11,66 @@ module SimpleRecord::Callbacks
     def self.included(base)
         #puts 'Callbacks included in ' + base.inspect
 
+#        puts "setup callbacks #{base.inspect}"
+        base.instance_eval <<-endofeval
+
+            def callbacks
+                @callbacks ||= {}
+                @callbacks
+            end
+
+
+        endofeval
+
+        @@callbacks.each do |callback|
+            base.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 for #{callback} = ' + cnames.inspect
+            return true if cnames.nil?
+            cnames.each { |name|
+                #puts 'run_  #{name}'
+              if eval(name) == false # nil should be an ok return, only looking for false
+                return false
+              end
+          }
+            #super.run_#{callback}
+          return true
+        end
+
+            endofeval
+
+            #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
+            base.instance_eval <<-endofeval
+
+#            puts 'defining 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
     end
 
     def before_destroy()
@@ -19,4 +78,10 @@ module SimpleRecord::Callbacks
 
     def after_destroy()
     end
+
+
+    def self.setup_callbacks(base)
+
+    end
+
 end

data/lib/simple_record/translations.rb

@@ -0,0 +1,240 @@
+# This module defines all the methods that perform data translations for storage and retrieval.
+module SimpleRecord
+    module Translations
+
+        @@offset = 9223372036854775808
+        @@padding = 20
+        @@date_format = "%Y-%m-%dT%H:%M:%S"; # Time to second precision
+
+        def ruby_to_sdb(name, value)
+
+            return nil if value.nil?
+
+            name = name.to_s
+
+            puts "Converting #{name} to sdb value=#{value}"
+            puts "atts_local=" + defined_attributes_local.inspect
+
+            att_meta = defined_attributes_local[name.to_sym]
+
+            if att_meta.type == :int
+                ret = Translations.pad_and_offset(value)
+            elsif att_meta.type == :date
+                ret = Translations.pad_and_offset(value)
+            else
+                ret = value.to_s
+            end
+
+
+            if att_meta.options
+                if att_meta.options[:encrypted]
+                    puts "ENCRYPTING #{name} value #{value}"
+                    ret = Translations.encrypt(ret, att_meta.options[:encrypted])
+                    puts 'encrypted value=' + ret.to_s
+                end
+                if att_meta.options[:hashed]
+                    ret = Translations.pass_hash(ret)
+                end
+            end
+
+            return ret.to_s
+
+        end
+
+
+        # Convert value from SimpleDB String version to real ruby value.
+        def sdb_to_ruby(name, value)
+            puts 'sdb_to_ruby arg=' + name.inspect + ' - ' + name.class.name + ' - value=' + value.to_s
+            return nil if value.nil?
+            att_meta = defined_attributes_local[name.to_sym]
+
+            if att_meta.options
+                if att_meta.options[:encrypted]
+                    value = Translations.decrypt(value, att_meta.options[:encrypted])
+                end
+                if att_meta.options[:hashed]
+                    return PasswordHashed.new(value)
+                end
+            end
+
+            if att_meta.type == :int
+                value = Translations.un_offset_int(value)
+            elsif att_meta.type == :date
+                value = to_date(value)
+            elsif att_meta.type == :boolean
+                value = to_bool(value)
+            end
+            value
+        end
+
+
+        def self.pad_and_offset(x) # Change name to something more appropriate like ruby_to_sdb
+            # todo: add Float, etc
+            #    puts 'padding=' + x.class.name + " -- " + x.inspect
+            if x.kind_of? Integer
+                x += @@offset
+                x_str = x.to_s
+                # pad
+                x_str = '0' + x_str while x_str.size < 20
+                return x_str
+            elsif x.respond_to?(:iso8601)
+                #  puts x.class.name + ' responds to iso8601'
+                #
+                # There is an issue here where Time.iso8601 on an incomparable value to DateTime.iso8601.
+                # Amazon suggests: 2008-02-10T16:52:01.000-05:00
+                #                  "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
+                #
+                if x.is_a? DateTime
+                    x_str = x.getutc.strftime(@@date_format)
+                elsif x.is_a? Time
+                    x_str = x.getutc.strftime(@@date_format)
+                elsif x.is_a? Date
+                    x_str = x.strftime(@@date_format)
+
+                end
+                return x_str
+            else
+                return x
+            end
+        end
+
+
+        def wrap_if_required(arg, value, sdb_val)
+            return nil if value.nil?
+
+            arg_s = arg.to_s
+            att_meta = defined_attributes_local[arg.to_sym]
+            if att_meta && att_meta.options
+                if att_meta.options[:hashed]
+                    puts 'wrapping ' + arg_s
+                    return PasswordHashed.new(sdb_val)
+                end
+            end
+            value
+        end
+
+        def to_date(x)
+            if x.is_a?(String)
+                DateTime.parse(x)
+            else
+                x
+            end
+        end
+
+        def to_bool(x)
+            if x.is_a?(String)
+                x == "true" || x == "1"
+            else
+                x
+            end
+        end
+
+        def self.un_offset_int(x)
+            if x.is_a?(String)
+                x2 = x.to_i
+#            puts 'to_i=' + x2.to_s
+                x2 -= @@offset
+#            puts 'after subtracting offset='+ x2.to_s
+                x2
+            else
+                x
+            end
+        end
+
+        def unpad(i, attributes)
+            if !attributes[i].nil?
+#          puts 'before=' + self[i].inspect
+                attributes[i].collect!{ |x|
+                    un_offset_int(x)
+
+                }
+            end
+        end
+
+        def unpad_self
+            defined_attributes_local.each_pair do |name, att_meta|
+                if att_meta.type == :int
+                    unpad(name, @attributes)
+                end
+            end
+        end
+
+
+        def self.encrypt(value, key=nil)
+            key = key || get_encryption_key()
+            raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
+            encrypted_value = SimpleRecord::Encryptor.encrypt(:value => value, :key => key)
+            encoded_value = Base64.encode64(encrypted_value)
+            encoded_value
+        end
+
+
+        def self.decrypt(value, key=nil)
+            puts "decrypt orig value #{value} "
+            unencoded_value = Base64.decode64(value)
+            raise SimpleRecordError, "Encryption key must be defined on the attribute." if key.nil?
+            key = key || get_encryption_key()
+            puts "decrypting #{unencoded_value} "
+            decrypted_value = SimpleRecord::Encryptor.decrypt(:value => unencoded_value, :key => key)
+            puts "decrypted #{unencoded_value} to #{decrypted_value}"
+            decrypted_value
+        end
+
+
+        def pad_and_offset_ints_to_sdb()
+
+#            defined_attributes_local.each_pair do |name, att_meta|
+#                if att_meta.type == :int && !self[name.to_s].nil?
+#                    arr = @attributes[name.to_s]
+#                    arr.collect!{ |x| self.class.pad_and_offset(x) }
+#                    @attributes[name.to_s] = arr
+#                end
+#            end
+        end
+
+        def convert_dates_to_sdb()
+
+#            defined_attributes_local.each_pair do |name, att_meta|
+#          puts 'int encoding: ' + i.to_s
+
+#            end
+        end
+
+        def self.pass_hash(value)
+            hashed = Password::create_hash(value)
+            encoded_value = Base64.encode64(hashed)
+            encoded_value
+        end
+
+        def self.pass_hash_check(value, value_to_compare)
+            unencoded_value = Base64.decode64(value)
+            return Password::check(value_to_compare, unencoded_value)
+        end
+
+    end
+
+
+    class PasswordHashed
+
+        def initialize(value)
+            @value = value
+        end
+
+        def hashed_value
+            @value
+        end
+
+        # This allows you to compare an unhashed string to the hashed one.
+        def ==(val)
+            if val.is_a?(PasswordHashed)
+                return val.hashed_value == self.hashed_value
+            end
+            return Translations.pass_hash_check(@value, val)
+        end
+
+        def to_s
+            @value
+        end
+    end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simple_record
 version: !ruby/object:Gem::Version 
-  version: 1.1.41
+  version: 1.1.42
 platform: ruby
 authors: 
 - Travis Reeder
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-30 00:00:00 -08:00
+date: 2010-01-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,12 +34,14 @@ extra_rdoc_files:
 - README.markdown
 files: 
 - lib/simple_record.rb
+- lib/simple_record/attributes.rb
 - lib/simple_record/callbacks.rb
 - lib/simple_record/encryptor.rb
 - lib/simple_record/errors.rb
 - lib/simple_record/password.rb
 - lib/simple_record/results_array.rb
 - lib/simple_record/stats.rb
+- lib/simple_record/translations.rb
 - README.markdown
 has_rdoc: true
 homepage: http://github.com/appoxy/simple_record/