ocean-dynamo 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65a6bf63b42ff8ffecd0ea41b312b5657e62d5c9
-  data.tar.gz: 3055b4f29b1006c4fe80de69d97e31802653eb27
+  metadata.gz: d067b77a882722c6a949672647c910338812ccf7
+  data.tar.gz: 48f95744f784e8cef31a65fe496c9d69737521f8
 SHA512:
-  metadata.gz: 1d365ff5096522676044fa6edbb3fd8e4c48de842636d820192e8674ce046de2f3af871d0b50236a837363daa24349819485003f09d32f06ab9d52d5c457745a
-  data.tar.gz: 997a24d91aa6a42f47dc38262200158120781ba74a9bd2355df304291d3796c3076d9dcd0710ce1cde96594abc8ea35cc617025f3034664b898e8d40ad0501a2
+  metadata.gz: 8e46bbfcce5105eef9737075b4042c049472ecb06bb7b938503d920a176083ffbeb0c281a4eba79698d34de7e3bec5c8483a4f8a7ca4f6dd9ee1df880fea24f3
+  data.tar.gz: c519f71fea7afc08ebfe2496c13cec6f3292ada38e51dc15893396005ae70ec29694d0dcfd9702a92a36b99f6c4e614f2b14a7a90b1d639b60ee874bc0f26a3c

data/README.rdoc

@@ -91,11 +91,11 @@ value will return the empty string, <tt>""</tt>.
    ...
  end
 
-=== +belongs_to+
+=== +has_many+ and +belongs_to+
 
 ==== Example
 
-The following example shows how to set up a +belongs_to+ relation:
+The following example shows how to set up a +has_many+ / +belongs_to+ relation:
 
  class Parent < OceanDynamo::Table
    dynamo_schema do
@@ -103,7 +103,7 @@ The following example shows how to set up a +belongs_to+ relation:
      attribute :that
      attribute :the_other
    end
-   #has_many :children       -- coming soon
+   has_many :children
  end
 
 
@@ -124,6 +124,9 @@ Restrictions for +belongs_to+ tables:
 * +belongs_to+ can be specified only once in each class.
 * +belongs_to+ must be placed after the +dynamo_schema+ attribute block.
 
+Restrictions for +has_many+ tables:
+* The +has_many+ table may not have a range key.
+
 These restrictions allow OceanDynamo to implement the +has_many+ / +belongs_to+ 
 relation in a very efficient and massively scalable way. 
 
@@ -157,18 +160,25 @@ controllers. OceanDynamo implements much of the infrastructure of ActiveRecord;
 for instance, +read_attribute+, +write_attribute+, and much of the control logic and
 parameters.
 
-+belongs_to+ is now operational. The other side, +has_many+, is much simpler and should 
-follow very soon (probably today). 
+* has_many now works, in a minimalistic fashion. To implement the rest of the interface,
+  we need association proxies.
+
+* Instances of classes with one or more has_many relations now save all relations after
+  the instance has been saved. To save only dirty association collections, we need
+  association proxies. Collections which are nil are not saved. Collections which are []
+  are saved, which means they clear all children. This difference is crucial, until we
+  get association proxies.
+
+* #reload clears all relations.
 
 === Future milestones
 
-* After the +has_many+ / +belongs_to+ association, the +has_and_belongs_to_many+ assocation
-  will be implemented. 
+* Association proxies, to implement the same kind of interace as ActiveRecord, e.g.: 
+  <code>blog_entry.comments.build(body: "Cool!").save!</code>
 
-* A generator to install the <tt>config/aws.yml</tt> file.
+* The +has_and_belongs_to_many+ assocation. 
 
-* OceanDynamo will use association proxies to achieve the same kind of
-  interface as ActiveRecord, e.g.: <code>blog_entry.comments.build(body: "Cool!").save!</code>
+* A generator to install the <tt>config/aws.yml</tt> file.
 
 
 === Current use

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

@@ -14,6 +14,17 @@ module OceanDynamo
 
     module ClassMethods
 
+      #
+      #
+      #
+      def relations_of_type(rel_type)
+        relations.inject([]) do |acc, rel|
+          kl, type = rel
+          acc << kl if type == rel_type
+          acc
+        end
+      end
+
       #
       #
       #

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

@@ -116,17 +116,26 @@ module OceanDynamo
     #
     # ---------------------------------------------------------
 
+    def initialize(attrs={})
+      super
+    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.
+    # (such as master_id) to the value given. This is a hack, do away with
+    # the double storage when association proxies are introduced.
     #
-    def assign_associations(attrs)  # :nodoc: 
-      if attrs && attrs.include?(:master)
-        @master = attrs[:master]
-        write_attribute('master_id', @master)
+    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
 

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

@@ -14,17 +14,25 @@ module OceanDynamo
 
     module ClassMethods
 
+
       #
-      #
+      # Defines a has_many relation to a belongs_to class.
       #
       def has_many(children)                                         # :children
         children_attr = children.to_s.underscore                     # "children"
         child_class = children_attr.singularize.camelize.constantize # Child
         register_relation(child_class, :has_many)
         # Define accessors for instances
-        self.class_eval "def #{children_attr}; read_children(#{child_class}); end"
-        self.class_eval "def #{children_attr}=(value); write_children(#{child_class}, value); end"
-        # TODO: "?" method
+        self.class_eval "def #{children_attr} 
+                           @#{children_attr} ||= read_children(#{child_class})
+                         end"
+        self.class_eval "def #{children_attr}=(value)
+                           @#{children_attr} = value
+                         end"
+        self.class_eval "def #{children_attr}? 
+                           @#{children_attr} ||= read_children(#{child_class})
+                           @#{children_attr}.present?
+                         end"
       end
 
     end
@@ -36,8 +44,9 @@ module OceanDynamo
     #
     # ---------------------------------------------------------
 
+
     #
-    #
+    # Reads all children of a has_many relation.
     #
     def read_children(child_class)
       if new_record? 
@@ -53,16 +62,59 @@ module OceanDynamo
       end
     end
 
+
+    #
+    # Write all children in the arg, which should be nil or an array.
+    #
+    def write_children(child_class, arg)
+      return nil if arg.blank?
+      raise AssociationTypeMismatch, "not an array or nil" if !arg.is_a?(Array)
+      raise AssociationTypeMismatch, "an array element is not a #{child_class}" unless arg.all? { |m| m.is_a?(child_class) }
+      # We now know that arg is an array containing only members of the child_class
+      arg.each(&:save!)
+      arg
+    end
+
+
+    #
+    # Sets all has_many relations to nil.
     #
+    def reload(*)
+      result = super
+
+      self.class.relations_of_type(:has_many).each do |klass|
+        attr_name = klass.to_s.pluralize.underscore
+        instance_variable_set("@#{attr_name}", nil)
+      end
+
+      result
+    end
+
+
+    protected
+
     #
+    # This version also writes back any relations. TODO: only
+    # dirty relations should be persisted. Introduce a dirty flag.
+    # Easiest done via an association proxy object.
     #
-    def write_children(child_class, value)
-      return nil if value.blank?
-      raise AssociationTypeMismatch, "not an array or nil" if !value.is_a?(Array)
-      raise AssociationTypeMismatch, "an array element is not a #{child_class}" unless value.all? { |m| m.is_a?(child_class) }
-      # We now know that value is an array containing only members of the child_class
-      value.each(&:save!)
-      value
+    def dynamo_persist(*)  # :nodoc:
+      result = super
+
+      self.class.relations_of_type(:has_many).each do |klass|
+        attr_name = klass.to_s.pluralize.underscore
+        # First create or update the children in the new set
+        new_children = instance_variable_get("@#{attr_name}")
+        next unless new_children
+        write_children klass, new_children
+        # 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
+        end
+      end
+
+      result
     end
 
   end

data/lib/ocean-dynamo/attributes.rb

@@ -13,6 +13,31 @@ module OceanDynamo
     # ---------------------------------------------------------
 
     module ClassMethods
+
+      def dynamo_schema(table_hash_key=:id, 
+                        table_range_key=nil,
+                        locking: :lock_version,
+                        timestamps: [:created_at, :updated_at],
+                        **keywords,
+                        &block)
+        self.lock_attribute = locking
+        self.timestamp_attributes = timestamps
+        # Init
+        self.fields = HashWithIndifferentAccess.new
+        attribute(table_hash_key, :string, default: "")
+        if table_range_key
+          attribute(table_range_key, :string, default: "")
+          self.validates(table_range_key, presence: true)
+        end
+        timestamp_attributes.each { |name| attribute name, :datetime } if timestamp_attributes
+        attribute(lock_attribute, :integer, default: 0) if locking
+        block.call
+        # Define attribute accessors
+        fields.each { |name, md| define_attribute_accessors(name) }
+        # Return table name
+        super
+      end
+
     end
 
 
@@ -32,6 +57,19 @@ module OceanDynamo
     attr_reader :dynamo_item    # :nodoc:
 
 
+    def initialize(attrs={})
+      @attributes = Hash.new
+      fields.each do |name, md| 
+        write_attribute(name, evaluate_default(md[:default], md[:type]))
+      end
+      raise UnknownPrimaryKey unless table_hash_key
+      set_belongs_to_association(attrs)
+      # Barf on unknown attributes here?
+      attrs && attrs.delete_if { |k, v| !fields.has_key?(k) }
+      super(attrs)
+    end
+
+
     #
     # Returns the value of the hash key attribute
     #
@@ -49,23 +87,6 @@ module OceanDynamo
     end
 
 
-    def initialize(attrs={})
-      run_callbacks :initialize do
-        @attributes = Hash.new
-        fields.each do |name, md| 
-          write_attribute(name, evaluate_default(md[:default], md[:type]))
-        end
-        @dynamo_item = nil
-        @destroyed = false
-        @new_record = true
-        raise UnknownPrimaryKey unless table_hash_key
-      end
-      assign_associations(attrs)
-      attrs && attrs.delete_if { |k, v| !fields.has_key?(k) }
-      super(attrs)
-    end
-
-
     def [](attribute)
       read_attribute attribute
     end
@@ -77,7 +98,7 @@ module OceanDynamo
 
 
     def id
-     read_attribute(table_hash_key)
+      hash_key
     end
 
 
@@ -85,8 +106,9 @@ module OceanDynamo
       write_attribute(table_hash_key, value)
     end
 
+
     def id?
-      read_attribute(table_hash_key).present?
+      hash_key.present?
     end
 
 
@@ -101,7 +123,7 @@ module OceanDynamo
       if fields.has_key?(attr_name)
         @attributes[attr_name]
       else
-        raise ActiveModel::MissingAttributeError, "can't read unknown attribute `#{attr_ name}"
+        raise ActiveModel::MissingAttributeError, "can't read unknown attribute '#{attr_ name}"
       end
     end
 
@@ -112,7 +134,7 @@ module OceanDynamo
       if fields.has_key?(attr_name)
         @attributes[attr_name] = type_cast_attribute_for_write(attr_name, value)
       else
-        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+        raise ActiveModel::MissingAttributeError, "can't write unknown attribute '#{attr_name}'"
       end
     end
 
@@ -121,14 +143,14 @@ module OceanDynamo
       return nil unless persisted?
       key = respond_to?(:id) && id
       return nil unless key
-      table_range_key ? [key, read_attribute(table_range_key)] : [key]
+      table_range_key ? [key, range_key] : [key]
     end
 
 
     def assign_attributes(values, without_protection: false)
       return if values.blank?
       values = values.stringify_keys
-      assign_associations(values)
+      set_belongs_to_association(values)
       # if values.respond_to?(:permitted?)
       #   unless values.permitted?
       #     raise ActiveModel::ForbiddenAttributesError
@@ -180,7 +202,7 @@ module OceanDynamo
       if respond_to?("#{k}=")
         raise
       else
-        raise UnknownAttributeError, "unknown attribute: `#{k}'"
+        raise UnknownAttributeError, "unknown attribute: '#{k}'"
       end
     end
 

data/lib/ocean-dynamo/basal.rb

@@ -1,32 +1,46 @@
-module Basal
-    
-  def ==(comparison_object)
-    super ||
-      comparison_object.instance_of?(self.class) &&
-      id.present? &&
-      comparison_object.id == id
-  end
-  alias :eql? :==
+module OceanDynamo
+  module Basal
+      
+    #
+    # The equality comparator. 
+    #
+    def ==(comparison_object)
+      super ||
+        comparison_object.instance_of?(self.class) &&
+        hash_key.present? &&
+        comparison_object.hash_key == hash_key &&
+        (range_key == comparison_object.range_key)
+    end
+    alias :eql? :==
 
 
-  # Clone and freeze the attributes hash such that associations are still
-  # accessible, even on destroyed records, but cloned models will not be
-  # frozen.
-  def freeze
-    @attributes = @attributes.clone.freeze
-    self
-  end
+    #
+    # Allows sort on instances
+    #
+    def <=>(other_object)
+      if other_object.is_a?(self.class)
+        self.to_key <=> other_object.to_key
+      end
+    end
 
-  # Returns +true+ if the attributes hash has been frozen.
-  def frozen?
-    @attributes.frozen?
-  end
 
-  # Allows sort on objects
-  def <=>(other_object)
-    if other_object.is_a?(self.class)
-      self.to_key <=> other_object.to_key
+    #
+    # Clone and freeze the attributes hash such that associations are still
+    # accessible, even on destroyed records, but cloned models will not be
+    # frozen.
+    #
+    def freeze
+      @attributes = @attributes.clone.freeze
+      self
     end
-  end
 
+
+    #
+    # Returns +true+ if the attributes hash has been frozen.
+    #
+    def frozen?
+      @attributes.frozen?
+    end
+
+  end
 end

data/lib/ocean-dynamo/persistence.rb

@@ -70,6 +70,18 @@ module OceanDynamo
     #
     # ---------------------------------------------------------
 
+    def initialize(attrs={})
+      @destroyed = false
+      @new_record = true
+      super
+    end
+
+
+    def dynamo_schema(*)
+      super
+    end
+
+
     def destroyed?
       @destroyed
     end

data/lib/ocean-dynamo/schema.rb

@@ -7,48 +7,8 @@ module OceanDynamo
     #
     # ---------------------------------------------------------
 
-    def dynamo_schema(table_hash_key=:id, 
-                      table_range_key=nil,
-                      table_name: compute_table_name,
-                      table_name_prefix: nil,
-                      table_name_suffix: nil,
-                      read_capacity_units: 10,
-                      write_capacity_units: 5,
-                      connect: :late,
-                      create: false,
-                      locking: :lock_version,
-                      timestamps: [:created_at, :updated_at],
-                      &block)
-      # Set class vars
-      self.dynamo_client = nil
-      self.dynamo_table = nil
-      self.dynamo_items = nil
-      self.table_connected = false
-      self.table_connect_policy = connect
-      self.table_create_policy = create
-      self.table_hash_key = table_hash_key
-      self.table_range_key = table_range_key
-      self.table_name = table_name
-      self.table_name_prefix = table_name_prefix
-      self.table_name_suffix = table_name_suffix
-      self.table_read_capacity_units = read_capacity_units
-      self.table_write_capacity_units = write_capacity_units
-      self.lock_attribute = locking
-      self.timestamp_attributes = timestamps
-      # Init
-      self.fields = HashWithIndifferentAccess.new
-      attribute(table_hash_key, :string, default: "")
-      if table_range_key
-        attribute(table_range_key, :string, default: "")
-        self.validates(table_range_key, presence: true)
-      end
-      timestamp_attributes.each { |name| attribute name, :datetime } if timestamp_attributes
-      attribute(lock_attribute, :integer, default: 0) if locking
-      block.call
-      # Define attribute accessors
-      fields.each { |name, md| define_attribute_accessors(name) }
-      # Connect to AWS
-      establish_db_connection if connect == true
+    def dynamo_schema(*)
+      super
       # Finally return the full table name
       table_full_name
     end

data/lib/ocean-dynamo/tables.rb

@@ -1,86 +1,136 @@
 module OceanDynamo
   module Tables
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+
     # ---------------------------------------------------------
     #
     #  Class methods
     #
     # ---------------------------------------------------------
 
-    def establish_db_connection
-      setup_dynamo  
-      if dynamo_table.exists?
-        wait_until_table_is_active
-        self.table_connected = true
-      else
-        raise(TableNotFound, table_full_name) unless table_create_policy
-        create_table
+    module ClassMethods
+
+      def dynamo_schema(table_hash_key=:id, 
+                        table_range_key=nil,
+                        table_name: compute_table_name,
+                        table_name_prefix: nil,
+                        table_name_suffix: nil,
+                        read_capacity_units: 10,
+                        write_capacity_units: 5,
+                        connect: :late,
+                        create: false,
+                        **keywords,
+                        &block)
+        self.dynamo_client = nil
+        self.dynamo_table = nil
+        self.dynamo_items = nil
+        self.table_connected = false
+        self.table_connect_policy = connect
+        self.table_create_policy = create
+        self.table_hash_key = table_hash_key
+        self.table_range_key = table_range_key
+        self.table_name = table_name
+        self.table_name_prefix = table_name_prefix
+        self.table_name_suffix = table_name_suffix
+        self.table_read_capacity_units = read_capacity_units
+        self.table_write_capacity_units = write_capacity_units
+        # Connect if asked to
+        establish_db_connection if connect == true
       end
-      set_dynamo_table_keys
-    end
 
 
-    def setup_dynamo
-      #self.dynamo_client = AWS::DynamoDB::Client.new(:api_version => '2012-08-10') 
-      self.dynamo_client ||= AWS::DynamoDB.new
-      self.dynamo_table = dynamo_client.tables[table_full_name]
-      self.dynamo_items = dynamo_table.items
-    end
+      def establish_db_connection
+        setup_dynamo  
+        if dynamo_table.exists?
+          wait_until_table_is_active
+          self.table_connected = true
+        else
+          raise(TableNotFound, table_full_name) unless table_create_policy
+          create_table
+        end
+        set_dynamo_table_keys
+      end
 
 
-    def wait_until_table_is_active
-      loop do
-        case dynamo_table.status
-        when :active
-          set_dynamo_table_keys
-          return
-        when :updating, :creating
-          sleep 1
-          next
-        when :deleting
-          sleep 1 while dynamo_table.exists?
-          create_table
-          return
-        else
-          raise UnknownTableStatus.new("Unknown DynamoDB table status '#{dynamo_table.status}'")
+      def setup_dynamo
+        #self.dynamo_client = AWS::DynamoDB::Client.new(:api_version => '2012-08-10') 
+        self.dynamo_client ||= AWS::DynamoDB.new
+        self.dynamo_table = dynamo_client.tables[table_full_name]
+        self.dynamo_items = dynamo_table.items
+      end
+
+
+      def wait_until_table_is_active
+        loop do
+          case dynamo_table.status
+          when :active
+            set_dynamo_table_keys
+            return
+          when :updating, :creating
+            sleep 1
+            next
+          when :deleting
+            sleep 1 while dynamo_table.exists?
+            create_table
+            return
+          else
+            raise UnknownTableStatus.new("Unknown DynamoDB table status '#{dynamo_table.status}'")
+          end
         end
       end
-    end
 
 
-    def set_dynamo_table_keys
-      hash_key_type = fields[table_hash_key][:type]
-      hash_key_type = :string if hash_key_type == :reference
-      dynamo_table.hash_key = [table_hash_key, hash_key_type]
+      def set_dynamo_table_keys
+        hash_key_type = fields[table_hash_key][:type]
+        hash_key_type = :string if hash_key_type == :reference
+        dynamo_table.hash_key = [table_hash_key, hash_key_type]
 
-      if table_range_key
-        range_key_type = fields[table_range_key][:type]
-        dynamo_table.range_key = [table_range_key, range_key_type]
+        if table_range_key
+          range_key_type = fields[table_range_key][:type]
+          dynamo_table.range_key = [table_range_key, range_key_type]
+        end
       end
-    end
 
 
-    def create_table
-      hash_key_type = fields[table_hash_key][:type]
-      hash_key_type = :string if hash_key_type == :reference
+      def create_table
+        hash_key_type = fields[table_hash_key][:type]
+        hash_key_type = :string if hash_key_type == :reference
+
+        range_key_type = table_range_key && fields[table_range_key][:type]
+
+        self.dynamo_table = dynamo_client.tables.create(table_full_name, 
+          table_read_capacity_units, table_write_capacity_units,
+          hash_key: { table_hash_key => hash_key_type},
+          range_key: table_range_key && { table_range_key => range_key_type }
+        )
+        sleep 1 until dynamo_table.status == :active
+        setup_dynamo
+        true
+      end
+
 
-      range_key_type = table_range_key && fields[table_range_key][:type]
+      def delete_table
+        return false unless dynamo_table.exists? && dynamo_table.status == :active
+        dynamo_table.delete
+        true
+      end
 
-      self.dynamo_table = dynamo_client.tables.create(table_full_name, 
-        table_read_capacity_units, table_write_capacity_units,
-        hash_key: { table_hash_key => hash_key_type},
-        range_key: table_range_key && { table_range_key => range_key_type }
-      )
-      sleep 1 until dynamo_table.status == :active
-      setup_dynamo
-      true
     end
+  
 
+    # ---------------------------------------------------------
+    #
+    #  Instance methods
+    #
+    # ---------------------------------------------------------
 
-    def delete_table
-      return false unless dynamo_table.exists? && dynamo_table.status == :active
-      dynamo_table.delete
-      true
+    def initialize(*)
+      @dynamo_item = nil
+      super
     end
 
   end

data/lib/ocean-dynamo/version.rb

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

data/lib/ocean-dynamo.rb

@@ -35,7 +35,7 @@ module OceanDynamo
 
     include Basal
 
-    extend Tables
+    include Tables
     extend Schema
 
     include Attributes
@@ -47,5 +47,11 @@ module OceanDynamo
     include HasMany
 
 
+    def initialize(attrs={})
+      run_callbacks :initialize do
+        super
+      end
+    end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk