ocean-dynamo 0.4.1 → 0.4.2

data/lib/ocean-dynamo/associations/belongs_to.rb

@@ -47,23 +47,40 @@ module OceanDynamo
 
         # Define accessors for instances
         self.class_eval "def #{target_attr}
-                           read_and_maybe_load_pointer('#{target_attr_id}')
+                           @#{target_attr} ||= load_target_from_id('#{target_attr_id}')
                          end"
 
-        self.class_eval "def #{target_attr}=(value) 
-                           write_attribute('#{target_attr_id}', value) 
-                           @#{target_attr} = value
+        self.class_eval "def #{target_attr_id}
+                           read_attribute('#{target_attr_id}')
                          end"
 
-        self.class_eval "def #{target_attr_id}
-                           get_pointer_id(@#{target_attr})
+        self.class_eval "def #{target_attr}=(value) 
+                           if !value
+                             target_id = nil
+                             target = nil
+                           elsif !value.kind_of?(#{target_class})
+                             raise AssociationTypeMismatch, \"can't save a #\{value.class\} in a #{target_class} foreign key\"
+                           else
+                             target_id = value.hash_key
+                             target = value
+                           end
+                           write_attribute('#{target_attr_id}', target_id) 
+                           @#{target_attr} = target
+                           value
                          end"
 
         self.class_eval "def #{target_attr_id}=(value)
-                           write_attribute('#{target_attr_id}', value) 
-                           @#{target_attr} = value
+                           if !value
+                             target_id = nil
+                           elsif value.is_a?(String)
+                             target_id = value
+                           else
+                             raise AssociationTypeMismatch, 'Foreign key #{target_attr_id} must be nil or a string'
+                           end
+                           write_attribute('#{target_attr_id}', target_id) 
+                           @#{target_attr} = nil
+                           value
                          end"
-        # TODO: "?" methods
       end
 
 
@@ -121,40 +138,23 @@ module OceanDynamo
     end
 
 
-    protected
-
     #
     # This is run by #initialize and by #assign_attributes to set the
-    # association variables (@master, for instance) and its associated attribute
-    # (such as master_id) to the value given. This is a hack, do away with
-    # the double storage when association proxies are introduced.
+    # association instance variables (@master, for instance) and their associated 
+    # attributes (such as master_id) from a given value.
     #
     def set_belongs_to_association(attrs)  # :nodoc:
       parent_class = self.class.belongs_to_class
       return unless parent_class
       parent_class = parent_class.to_s.underscore.to_sym
-      if attrs && attrs.include?(parent_class)
-        instance_variable_set("@#{parent_class}", attrs[parent_class])
-        write_attribute("#{parent_class}_id", attrs[parent_class])
-      end
-    end
-
-
-    def read_and_maybe_load_pointer(name)  # :nodoc:
-      ptr = read_attribute(name)
-      return nil if ptr.blank?
-      if persisted? && ptr.is_a?(String)
-        parent = fields[name][:target_class].find(ptr, consistent: true)  # TODO: true?
-        write_attribute(name, parent)  # Keep the instance we've just read
-      else
-        ptr
-      end
+      send("#{parent_class}=", attrs[parent_class]) if attrs && attrs.include?(parent_class)
     end
 
 
-    def get_pointer_id(ptr)  # :nodoc:
-      return nil if ptr.blank?
-      ptr.is_a?(String) ? ptr : ptr.id
+    def load_target_from_id(name)  # :nodoc:
+      v = read_attribute(name)
+      return nil unless v
+      fields[name][:target_class].find(v, consistent: true)
     end
 
   end

data/lib/ocean-dynamo/associations/has_many.rb

@@ -22,8 +22,10 @@ module OceanDynamo
         children_attr = children.to_s.underscore                     # "children"
         child_class = children_attr.singularize.camelize.constantize # Child
         register_relation(child_class, :has_many)
+        attr_accessor children_attr
         # Define accessors for instances
-        self.class_eval "def #{children_attr} 
+        self.class_eval "def #{children_attr}(force_reload=false) 
+                           @#{children_attr} = false if force_reload
                            @#{children_attr} ||= read_children(#{child_class})
                          end"
         self.class_eval "def #{children_attr}=(value)
@@ -110,7 +112,7 @@ module OceanDynamo
         # Destroy all children not in the new set (this is not yet scalable)
         read_children(klass).each do |c|
           next if new_children.include?(c)
-          c.delete
+          c.destroy
         end
       end
 

data/lib/ocean-dynamo/exceptions.rb

@@ -48,7 +48,15 @@ module OceanDynamo
 
   class UnknownAttributeError < NoMethodError; end
 
-  class AttributeAssignmentError < DynamoError; end
+  class AttributeAssignmentError < DynamoError
+    attr_reader :exception, :attribute
+    def initialize(message, exception, attribute)
+      super(message)
+      @exception = exception
+      @attribute = attribute
+    end
+  end
+
 
   class MultiparameterAssignmentErrors < DynamoError; end
 

data/lib/ocean-dynamo/persistence.rb

@@ -327,6 +327,7 @@ module OceanDynamo
       when :reference
         raise DynamoError, ":reference must always have a :target_class" unless target_class
         return value if value.is_a?(String)
+        # The next two lines should be superfluous now
         return value.id if value.kind_of?(target_class)
         raise AssociationTypeMismatch, "can't save a #{value.class} in a #{target_class} :reference"
       when :string

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-25 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -138,21 +138,21 @@ dependencies:
         version: 0.1.3
 description: "== OceanDynamo\n\nOceanDynamo is a massively scalable Amazon DynamoDB
   near drop-in replacement for \nActiveRecord.\n\nAs one important use case for OceanDynamo
-  is to facilitate the conversion of SQL based\nActiveRecord models to DynamoDB based
-  models, it is important that the syntax and semantics\nof OceanDynamo's operations
-  are as close as possible to those of ActiveRecord, including\ncallbacks, exceptions
-  and support methods. Ocean-dynamo follows this pattern closely and\nis of course
-  based on ActiveModel.\n\nThe attribute and persistence layer of OceanDynamo is modeled
-  on that of ActiveRecord:\nthere's +save+, +save!+, +create+, +update+, +update!+,
-  +update_attributes+, +find_each+,\n+destroy_all+, +delete_all+ and all the other
-  methods you're used to. The design goal \nis always to implement as much of the
-  ActiveRecord interface as possible, without \ncompromising scalability. This makes
-  the task of switching from SQL to no-SQL much easier.\n\nThanks to its structural
-  similarity to ActiveRecord, OceanDynamo works with FactoryGirl.\nTo facilitate testing,
-  future versions will keep track of and delete instances after tests.\n\nOceanDynamo
-  uses primary indices to retrieve related table items, \nwhich means it will scale
-  without limits.\n\nSee also Ocean, a Rails framework for creating highly scalable
-  SOAs in the cloud, in which\nocean-dynamo is used as a central component: http://wiki.oceanframework.net"
+  is to facilitate the conversion of SQL\ndatabases to no-SQL DynamoDB databases,
+  it is important that the syntax and semantics\nof OceanDynamo are as close as possible
+  to those of ActiveRecord. This includes\ncallbacks, exceptions and method chaining
+  semantics. OceanDynamo follows this pattern \nclosely and is of course based on
+  ActiveModel.\n\nThe attribute and persistence layer of OceanDynamo is modeled on
+  that of ActiveRecord:\nthere's +save+, +save!+, +create+, +update+, +update!+, +update_attributes+,
+  +find_each+,\n+destroy_all+, +delete_all+ and all the other methods you're used
+  to. The design goal \nis always to implement as much of the ActiveRecord interface
+  as possible, without \ncompromising scalability. This makes the task of switching
+  from SQL to no-SQL much easier.\n\nThanks to its structural similarity to ActiveRecord,
+  OceanDynamo works with FactoryGirl.\nTo facilitate testing, future versions will
+  keep track of and delete instances after tests.\n\nOceanDynamo uses primary indices
+  to retrieve related table items, \nwhich means it will scale without limits.\n\nSee
+  also Ocean, a Rails framework for creating highly scalable SOAs in the cloud, in
+  which\nocean-dynamo is used as a central component: http://wiki.oceanframework.net"
 email:
 - peter@peterbengtson.com
 executables: []
@@ -160,9 +160,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/routes.rb
+- lib/ocean-dynamo/active_record_stuff/collection_proxy.rb
+- lib/ocean-dynamo/active_record_stuff/reflection.rb
+- lib/ocean-dynamo/active_record_stuff/relation.rb
 - lib/ocean-dynamo/associations/associations.rb
 - lib/ocean-dynamo/associations/belongs_to.rb
-- lib/ocean-dynamo/associations/collection_proxy.rb
 - lib/ocean-dynamo/associations/has_many.rb
 - lib/ocean-dynamo/attributes.rb
 - lib/ocean-dynamo/basal.rb