ocean-dynamo 0.3.13 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff62cac1b81cd01f68f4d8be25004ae94c0afa14
-  data.tar.gz: f5fa8a4e8d8c7b86421a2ad977fd279136a08402
+  metadata.gz: 65a6bf63b42ff8ffecd0ea41b312b5657e62d5c9
+  data.tar.gz: 3055b4f29b1006c4fe80de69d97e31802653eb27
 SHA512:
-  metadata.gz: d2296afae10ea96ca8eecdb5822878da60fbd2c20b293a868694f6167bfc95ddb9519153a8b1fb08bacc7ec2506a25c307aefc4cf01398e4486d17e01f568c9e
-  data.tar.gz: 02ec483b0b395f07e5213bc572cf57e30ad30cd420d0b9bf39fafbcb04198f391bb8b73603f22c1e6b98dc728d18e7491e1d84c72e0ecd0232ccabfe62fbb798
+  metadata.gz: 1d365ff5096522676044fa6edbb3fd8e4c48de842636d820192e8674ce046de2f3af871d0b50236a837363daa24349819485003f09d32f06ab9d52d5c457745a
+  data.tar.gz: 997a24d91aa6a42f47dc38262200158120781ba74a9bd2355df304291d3796c3076d9dcd0710ce1cde96594abc8ea35cc617025f3034664b898e8d40ad0501a2

data/README.rdoc

@@ -34,7 +34,7 @@ which means it will scale without limits.
 
 The following example shows the basic syntax for declaring a DynamoDB-based schema. 
 
-  class AsyncJob < OceanDynamo::Base
+  class AsyncJob < OceanDynamo::Table
 
     dynamo_schema(:uuid) do
       attribute :credentials,          :string
@@ -97,7 +97,7 @@ value will return the empty string, <tt>""</tt>.
 
 The following example shows how to set up a +belongs_to+ relation:
 
- class Parent < OceanDynamo::Base
+ class Parent < OceanDynamo::Table
    dynamo_schema do
      attribute :this
      attribute :that
@@ -107,7 +107,7 @@ The following example shows how to set up a +belongs_to+ relation:
  end
 
 
- class Child < OceanDynamo::Base
+ class Child < OceanDynamo::Table
    dynamo_schema(:uuid) do
      attribute :foo
      attribute :bar

data/lib/ocean-dynamo.rb

@@ -4,19 +4,48 @@ require "aws-sdk"
 require "active_model"
 require "active_support"
 
-require "ocean-dynamo/base"
 require "ocean-dynamo/exceptions"
 require "ocean-dynamo/class_variables"
+
+require "ocean-dynamo/basal"
 require "ocean-dynamo/tables"
 require "ocean-dynamo/schema"
 require "ocean-dynamo/attributes"
-require "ocean-dynamo/callbacks"
 require "ocean-dynamo/persistence"
 require "ocean-dynamo/queries"
-
+require "ocean-dynamo/associations/associations"
 require "ocean-dynamo/associations/belongs_to"
+require "ocean-dynamo/associations/has_many"
 
 
 module OceanDynamo
+  class Table
+
+    include ActiveModel::Model
+    include ActiveModel::Validations::Callbacks
+
+    define_model_callbacks :initialize, only: :after
+    define_model_callbacks :save
+    define_model_callbacks :create
+    define_model_callbacks :update
+    define_model_callbacks :destroy
+    define_model_callbacks :commit, only: :after
+    define_model_callbacks :touch
+
+
+    include Basal
+
+    extend Tables
+    extend Schema
+
+    include Attributes
+    include Persistence
+    extend Queries
+
+    include Associations
+    include BelongsTo
+    include HasMany
+
 
+  end
 end

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

@@ -0,0 +1,58 @@
+module OceanDynamo
+  module Associations
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+    module ClassMethods
+
+      #
+      #
+      #
+      def relates_to(klass)
+        relations[klass]
+      end
+
+      #
+      #
+      #
+      def register_relation(klass, value)
+        relations[klass] = value
+      end
+
+      #
+      #
+      #
+      def clear_relations
+        self.relations = Hash.new
+      end
+
+
+      def dynamo_schema(*)
+        clear_relations
+        super
+      end
+
+    end
+
+
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
+
+    # def initialize(*)
+    #   self.class.clear_relations
+    # end
+
+  end
+end

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

@@ -1,95 +1,123 @@
 module OceanDynamo
-  class Base
+  module BelongsTo
 
-    def self.belongs_to(target)                        # :master, "master", Master
-      target_attr = target.to_s.underscore             # "master"
-      target_attr_id = "#{target_attr}_id"             # "master_id"
-      target_class = target_attr.camelize.constantize  # Master
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
 
-      assert_only_one_belongs_to!
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
 
-      self.table_range_key = table_hash_key            # The RANGE KEY is variable
-      self.table_hash_key = target_attr_id.to_sym      # The HASH KEY is the parent UUID
+    module ClassMethods
+      
+      #
+      # 
+      #
+      def belongs_to(target)                             # :master, "master", Master
+        target_attr = target.to_s.underscore             # "master"
+        target_attr_id = "#{target_attr}_id"             # "master_id"
+        target_class = target_attr.camelize.constantize  # Master
 
-      attribute table_hash_key, :string                # Define :master_id
-      define_attribute_accessors(table_hash_key)       # Define master_id, master_id=, master_id?
+        assert_only_one_belongs_to!
 
-      # Make sure there always is a parent
-      validates(table_hash_key, presence: true)        # Can't save without a parent_id
+        self.table_range_key = table_hash_key            # The RANGE KEY is variable
+        self.table_hash_key = target_attr_id.to_sym      # The HASH KEY is the parent UUID
 
-      # Define the range attribute (our unique UUID)
-      attribute(table_range_key, :string, default: "") # Define :uuid
-      define_attribute_accessors(table_range_key)      # define uuid, uuid=, uuid?
+        attribute table_hash_key, :string                # Define :master_id
+        define_attribute_accessors(table_hash_key)       # Define master_id, master_id=, master_id?
 
+        # Make sure there always is a parent
+        validates(table_hash_key, presence: true)        # Can't save without a parent_id
 
+        # Define the range attribute (our unique UUID)
+        attribute(table_range_key, :string, default: "") # Define :uuid
+        define_attribute_accessors(table_range_key)      # define uuid, uuid=, uuid?
 
-      # Define the parent id attribute 
-      attribute target_attr_id, :reference, default: nil, target_class: target_class,
-                                association: :belongs_to
 
-      self.class_eval "def #{target_attr}
-                         read_and_maybe_load_pointer('#{target_attr_id}')
-                       end"
 
-      self.class_eval "def #{target_attr}=(value) 
-                         write_attribute('#{target_attr_id}', value) 
-                         @#{target_attr} = value
-                       end"
+        # Define the parent id attribute 
+        attribute target_attr_id, :reference, default: nil, target_class: target_class,
+                                  association: :belongs_to
+        register_relation(target_class, :belongs_to)
 
-      self.class_eval "def #{target_attr_id}
-                         get_pointer_id(@#{target_attr})
-                       end"
 
-      self.class_eval "def #{target_attr_id}=(value)
-                         write_attribute('#{target_attr_id}', value) 
-                         @#{target_attr} = value
-                       end"
-      # TODO: "?" methods
-    end
+        # Define accessors for instances
+        self.class_eval "def #{target_attr}
+                           read_and_maybe_load_pointer('#{target_attr_id}')
+                         end"
 
+        self.class_eval "def #{target_attr}=(value) 
+                           write_attribute('#{target_attr_id}', value) 
+                           @#{target_attr} = value
+                         end"
 
-    #
-    # Returns true if the class has a belongs_to association.
-    #
-    def self.has_belongs_to?
-      fields[table_hash_key]['association'] == :belongs_to
-    end
+        self.class_eval "def #{target_attr_id}
+                           get_pointer_id(@#{target_attr})
+                         end"
 
+        self.class_eval "def #{target_attr_id}=(value)
+                           write_attribute('#{target_attr_id}', value) 
+                           @#{target_attr} = value
+                         end"
+        # TODO: "?" methods
+      end
 
 
-    #
-    # Returns the class of the belongs_to association, or false if none.
-    #
-    def self.belongs_to_class
-      has_belongs_to? && fields[table_hash_key]['target_class']
-    end
+      #
+      # Returns true if the class has a belongs_to association.
+      #
+      def has_belongs_to?
+        fields[table_hash_key]['association'] == :belongs_to
+      end
 
 
 
-    protected
+      #
+      # Returns the class of the belongs_to association, or false if none.
+      #
+      def belongs_to_class
+        has_belongs_to? && fields[table_hash_key]['target_class']
+      end
 
-    #
-    # belongs_to can be specified only once in each model, since we use the range key to
-    # store its UUID and the hash key to store the UUID of the parent, as in
-    # ["parent_uuid", "child_uuid"]. This allows the parent to find all its children 
-    # extremely efficiently by using only the primary index. It also allows the child
-    # to find its parent using only its own hash key. Presto: scalability without any
-    # secondary indices in the has_many/belongs_to association.
-    #
-    # Caveat: the parent must have a simple primary key, not a composite one. It *is*
-    # possible to use a composite key, but then the children must use scans to find
-    # their parents. We could conditionalise this, of course, so that the lookup
-    # strategy is transparent to the user.
-    #
-    def self.assert_only_one_belongs_to!  # :nodoc:
-      if has_belongs_to?
-        raise OceanDynamo::AssociationMustBeUnique, 
-              "#{self} already belongs_to #{belongs_to_class}" 
+
+
+      protected
+
+      #
+      # belongs_to can be specified only once in each model, since we use the range key to
+      # store its UUID and the hash key to store the UUID of the parent, as in
+      # ["parent_uuid", "child_uuid"]. This allows the parent to find all its children 
+      # extremely efficiently by using only the primary index. It also allows the child
+      # to find its parent using only its own hash key. Presto: scalability without any
+      # secondary indices in the has_many/belongs_to association.
+      #
+      # Caveat: the parent must have a simple primary key, not a composite one. It *is*
+      # possible to use a composite key, but then the children must use scans to find
+      # their parents. We could conditionalise this, of course, so that the lookup
+      # strategy is transparent to the user.
+      #
+      def assert_only_one_belongs_to!  # :nodoc:
+        if has_belongs_to?
+          raise OceanDynamo::AssociationMustBeUnique, 
+                "#{self} already belongs_to #{belongs_to_class}" 
+        end
+        false
       end
-      false
     end
 
 
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
+
+    protected
+
     #
     # This is run by #initialize and by #assign_attributes to set the
     # association variables (@master, for instance) and its associated attribute

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

@@ -15,7 +15,7 @@ module OceanDynamo
     #
     # For example, given
     #
-    #   class Blog < OceanDynamo::Base
+    #   class Blog < OceanDynamo::Table
     #     has_many :posts
     #   end
     #
@@ -66,7 +66,7 @@ module OceanDynamo
       #
       # *First:* Specify a subset of fields to be selected from the result set.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -121,10 +121,10 @@ module OceanDynamo
       end
 
       # Finds an object in the collection responding to the +id+. Uses the same
-      # rules as <tt>OceanDynamo::Base.find</tt>. Returns <tt>OceanDynamo::RecordNotFound</tt>
+      # rules as <tt>OceanDynamo::Table.find</tt>. Returns <tt>OceanDynamo::RecordNotFound</tt>
       # error if the object can not be found.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -154,7 +154,7 @@ module OceanDynamo
       # If the collection is empty, the first form returns +nil+, and the second
       # form returns an empty array.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -184,7 +184,7 @@ module OceanDynamo
       # If the collection is empty, the first form returns +nil+, and the second
       # form returns an empty array.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -215,7 +215,7 @@ module OceanDynamo
       # You can pass an array of attributes hashes, this will return an array
       # with the new objects.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -243,7 +243,7 @@ module OceanDynamo
       # attributes, linked to this object and that has already been saved (if it
       # passes the validations).
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -271,7 +271,7 @@ module OceanDynamo
 
       # Like +create+, except that if the record is invalid, raises an exception.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -290,7 +290,7 @@ module OceanDynamo
       # inserts each record, +push+ and +concat+ behave identically. Returns +self+
       # so method calls may be chained.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     pets :has_many
       #   end
       #
@@ -316,7 +316,7 @@ module OceanDynamo
       # Replaces this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -348,7 +348,7 @@ module OceanDynamo
       # sets the foreign keys to <tt>NULL</tt>. For, +has_many+ <tt>:through</tt>,
       # the default strategy is +delete_all+.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets # dependent: :nullify option by default
       #   end
       #
@@ -381,7 +381,7 @@ module OceanDynamo
       # are removed by calling their +destroy+ method. See +destroy+ for more
       # information.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets, dependent: :destroy
       #   end
       #
@@ -406,7 +406,7 @@ module OceanDynamo
       # If it is set to <tt>:delete_all</tt>, all the objects are deleted
       # *without* calling their +destroy+ method.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets, dependent: :delete_all
       #   end
       #
@@ -435,7 +435,7 @@ module OceanDynamo
       # This will _always_ remove the records ignoring the +:dependent+
       # option.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -467,7 +467,7 @@ module OceanDynamo
       # keys to <tt>NULL</tt>. For, +has_many+ <tt>:through</tt>, the default
       # strategy is +delete_all+.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets # dependent: :nullify option by default
       #   end
       #
@@ -495,7 +495,7 @@ module OceanDynamo
       # If it is set to <tt>:destroy</tt> all the +records+ are removed by calling
       # their +destroy+ method. See +destroy+ for more information.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets, dependent: :destroy
       #   end
       #
@@ -523,7 +523,7 @@ module OceanDynamo
       # If it is set to <tt>:delete_all</tt>, all the +records+ are deleted
       # *without* calling their +destroy+ method.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets, dependent: :delete_all
       #   end
       #
@@ -551,7 +551,7 @@ module OceanDynamo
       # You can pass +Fixnum+ or +String+ values, it finds the records
       # responding to the +id+ and executes delete on them.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -579,7 +579,7 @@ module OceanDynamo
       # This method will _always_ remove record from the database ignoring
       # the +:dependent+ option. Returns an array with the removed records.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -649,7 +649,7 @@ module OceanDynamo
 
       # Specifies whether the records should be unique or not.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -668,7 +668,7 @@ module OceanDynamo
 
       # Count all records using SQL.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -690,7 +690,7 @@ module OceanDynamo
       # equivalent. If not and you are going to need the records anyway
       # +length+ will take one less query. Otherwise +size+ is more efficient.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -716,7 +716,7 @@ module OceanDynamo
       # equivalent. If not and you are going to need the records anyway this
       # method will take one less query. Otherwise +size+ is more efficient.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -742,7 +742,7 @@ module OceanDynamo
       # not already been loaded and you are going to fetch the records anyway it
       # is better to check <tt>collection.length.zero?</tt>.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -759,7 +759,7 @@ module OceanDynamo
 
       # Returns +true+ if the collection is not empty.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -793,7 +793,7 @@ module OceanDynamo
       # Returns true if the collection has more than one record.
       # Equivalent to <tt>collection.size > 1</tt>.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -830,7 +830,7 @@ module OceanDynamo
 
       # Returns +true+ if the given object is present in the collection.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -869,7 +869,7 @@ module OceanDynamo
       # to the corresponding element in the other array, otherwise returns
       # +false+.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -895,7 +895,7 @@ module OceanDynamo
       # Returns a new array of objects from the collection. If the collection
       # hasn't been loaded, it fetches the records from the database.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -934,7 +934,7 @@ module OceanDynamo
       # to the association's primary key. Returns +self+, so several appends may be
       # chained together.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #
@@ -971,7 +971,7 @@ module OceanDynamo
       # Reloads the collection from the database. Returns +self+.
       # Equivalent to <tt>collection(true)</tt>.
       #
-      #   class Person < OceanDynamo::Base
+      #   class Person < OceanDynamo::Table
       #     has_many :pets
       #   end
       #

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

@@ -0,0 +1,69 @@
+module OceanDynamo
+  module HasMany
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+    module ClassMethods
+
+      #
+      #
+      #
+      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
+      end
+
+    end
+
+
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
+
+    #
+    #
+    #
+    def read_children(child_class)
+      if new_record? 
+        nil
+      else
+        result = Array.new
+        _late_connect?
+        child_items = child_class.dynamo_items
+        child_items.query(hash_value: id, range_gte: "0") do |item_data|
+          result << child_class.new._setup_from_dynamo(item_data)
+        end
+        result
+      end
+    end
+
+    #
+    #
+    #
+    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
+    end
+
+  end
+end

data/lib/ocean-dynamo/attributes.rb

@@ -1,5 +1,26 @@
 module OceanDynamo
-  class Base
+  module Attributes
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+    module ClassMethods
+    end
+
+
+    # ---------------------------------------------------------
+    #
+    #  Instance variables and methods
+    #
+    # ---------------------------------------------------------
 
     #
     # The hash of attributes and their values. Keys are strings.

data/lib/ocean-dynamo/basal.rb

@@ -0,0 +1,32 @@
+module Basal
+    
+  def ==(comparison_object)
+    super ||
+      comparison_object.instance_of?(self.class) &&
+      id.present? &&
+      comparison_object.id == id
+  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
+
+  # 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
+    end
+  end
+
+end

data/lib/ocean-dynamo/class_variables.rb

@@ -1,5 +1,5 @@
 module OceanDynamo
-  class Base
+  class Table
 
     class_attribute :dynamo_client, instance_writer: false
     self.dynamo_client = nil
@@ -49,5 +49,8 @@ module OceanDynamo
     class_attribute :timestamp_attributes, instance_writer: false
     self.timestamp_attributes = [:created_at, :updated_at]
 
+    class_attribute :relations, instance_writer: false
+    self.relations = nil
+
   end
 end

data/lib/ocean-dynamo/exceptions.rb

@@ -23,7 +23,7 @@ module OceanDynamo
     def initialize(record) # :nodoc:
       @record = record
       errors = @record.errors.full_messages.join(", ")
-      super(:"#{@record.class}.errors.messages.record_invalid")
+      super(@record.errors.messages)
     end
   end
 
@@ -38,7 +38,7 @@ module OceanDynamo
     def initialize(record) # :nodoc:
       @record = record
       errors = @record.errors.full_messages.join(", ")
-      super(:"#{@record.class}.errors.messages.record_invalid")
+      super(@record.errors.messages)
     end
   end
  
@@ -60,4 +60,7 @@ module OceanDynamo
     class RangeKeyMustNotBeSpecified < BelongsToError; end
     class HashKeyMayNotBeNamedId < BelongsToError; end
 
+  class HasManyError < DynamoError; end
+  
+
 end

data/lib/ocean-dynamo/persistence.rb

@@ -1,5 +1,10 @@
 module OceanDynamo
-  class Base
+  module Persistence
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
 
     # ---------------------------------------------------------
     #
@@ -7,44 +12,55 @@ module OceanDynamo
     #
     # ---------------------------------------------------------
 
+    module ClassMethods
 
-    def self.create(attributes = nil, &block)
-      object = new(attributes)
-      yield(object) if block_given?
-      object.save
-      object
-    end
+      def create(attributes = nil, &block)
+        object = new(attributes)
+        yield(object) if block_given?
+        object.save
+        object
+      end
 
 
-    def self.create!(attributes = nil, &block)
-      object = new(attributes)
-      yield(object) if block_given?
-      object.save!
-      object
-    end
+      def create!(attributes = nil, &block)
+        object = new(attributes)
+        yield(object) if block_given?
+        object.save!
+        object
+      end
 
 
-    def self.delete(hash, range=nil)
-      item = dynamo_items[hash, range]
-      return false unless item.exists?
-      item.delete
-      true
-    end
+      def delete(hash, range=nil)
+        item = dynamo_items[hash, range]
+        return false unless item.exists?
+        item.delete
+        true
+      end
 
 
-    def self.delete_all
-      dynamo_items.each() do |item|
-        item.delete
+      def delete_all
+        dynamo_items.each() do |item|
+          item.delete
+        end
+        nil
+      end
+
+
+      def destroy_all
+        dynamo_items.select() do |item_data|
+          new._setup_from_dynamo(item_data).destroy
+        end
+        nil
       end
-      nil
-    end
 
 
-    def self.destroy_all
-      dynamo_items.select() do |item_data|
-        new._setup_from_dynamo(item_data).destroy
+      def _late_connect? # :nodoc:
+        return false if table_connected
+        return false unless table_connect_policy
+        establish_db_connection
+        true
       end
-      nil
+
     end
 
 
@@ -176,7 +192,6 @@ module OceanDynamo
 
 
     def reload(**keywords)
-      raise "HELLISHNESS" if id == range_key
       new_instance = self.class.find(hash_key, range_key, **keywords)
       assign_attributes(new_instance.attributes)
       self
@@ -241,14 +256,6 @@ module OceanDynamo
 
     protected
 
-    def self._late_connect? # :nodoc:
-      return false if table_connected
-      return false unless table_connect_policy
-      establish_db_connection
-      true
-    end
-
-
     def _late_connect? # :nodoc:
       self.class._late_connect?
     end

data/lib/ocean-dynamo/queries.rb

@@ -1,10 +1,16 @@
 module OceanDynamo
-  class Base
+  module Queries
 
-    def self.find(hash, range=nil, consistent: false)
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+    def find(hash, range=nil, consistent: false)
       return hash.collect {|elem| find elem, range, consistent: consistent } if hash.is_a?(Array)
       _late_connect?
-      hash = hash.id if hash.kind_of?(Base)    # TODO: We have (innocuous) leakage, fix!
+      hash = hash.id if hash.kind_of?(Table)    # TODO: We have (innocuous) leakage, fix!
       item = dynamo_items[hash, range]
       unless item.exists?
         raise RecordNotFound, "can't find a #{self} with primary key ['#{hash}', #{range.inspect}]" 
@@ -13,14 +19,14 @@ module OceanDynamo
     end
 
 
-    def self.find_by_key(*args)
+    def find_by_key(*args)
       find(*args)
     rescue RecordNotFound
       nil
     end
 
 
-    def self.find_by_id(*args)
+    def find_by_id(*args)
       find_by_key(*args)
     end
 
@@ -28,7 +34,7 @@ module OceanDynamo
     #
     # The number of records in the table.
     #
-    def self.count(**options)
+    def count(**options)
       _late_connect?
       dynamo_items.count(options)
     end
@@ -37,7 +43,7 @@ module OceanDynamo
     #
     # Returns all records in the table.
     #
-    def self.all(**options)
+    def all(**options)
       _late_connect?
       result = []
       dynamo_items.select(options) do |item_data| 
@@ -54,7 +60,7 @@ module OceanDynamo
     # In that case, batch processing methods allow you to work with the records in batches, 
     # thereby greatly reducing memory consumption.
     #
-    def self.find_each(limit: nil, batch_size: 1000)
+    def find_each(limit: nil, batch_size: 1000)
       dynamo_items.select(limit: limit, batch_size: 1000) do |item_data|
         yield new._setup_from_dynamo(item_data)
       end
@@ -71,7 +77,7 @@ module OceanDynamo
     # #
     # # It’s not possible to set the order.
     # #
-    # def self.find_in_batches(start: nil, batch_size: 1000)
+    # def find_in_batches(start: nil, batch_size: 1000)
     #   []
     # end
   end

data/lib/ocean-dynamo/schema.rb

@@ -1,19 +1,24 @@
 module OceanDynamo
-  class Base
+  module Schema
 
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
 
-    def self.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)
+    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
@@ -49,7 +54,7 @@ module OceanDynamo
     end
 
 
-    def self.define_attribute_accessors(name)
+    def define_attribute_accessors(name)
       name = name.to_s
       self.class_eval "def #{name}; read_attribute('#{name}'); end"
       self.class_eval "def #{name}=(value); write_attribute('#{name}', value); end"
@@ -57,17 +62,17 @@ module OceanDynamo
     end
 
 
-    def self.compute_table_name
+    def compute_table_name
       name.pluralize.underscore
     end
 
 
-    def self.table_full_name
+    def table_full_name
       "#{table_name_prefix}#{table_name}#{table_name_suffix}"
     end
 
 
-    def self.attribute(name, type=:string, default: nil, **extra)
+    def attribute(name, type=:string, default: nil, **extra)
       raise DangerousAttributeError, "#{name} is defined by OceanDynamo" if self.dangerous_attributes.include?(name.to_s)
       attr_accessor name
       fields[name.to_s] = {type: type, default: default}.merge(extra)
@@ -76,7 +81,7 @@ module OceanDynamo
 
     protected
 
-    def self.dangerous_attributes # :nodoc:
+    def dangerous_attributes # :nodoc:
       self.public_methods(false).collect do |sym|
         str = sym.to_s
         if str.end_with?("?", "=")

data/lib/ocean-dynamo/tables.rb

@@ -1,7 +1,13 @@
 module OceanDynamo
-  class Base
+  module Tables
 
-    def self.establish_db_connection
+    # ---------------------------------------------------------
+    #
+    #  Class methods
+    #
+    # ---------------------------------------------------------
+
+    def establish_db_connection
       setup_dynamo  
       if dynamo_table.exists?
         wait_until_table_is_active
@@ -14,7 +20,7 @@ module OceanDynamo
     end
 
 
-    def self.setup_dynamo
+    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]
@@ -22,7 +28,7 @@ module OceanDynamo
     end
 
 
-    def self.wait_until_table_is_active
+    def wait_until_table_is_active
       loop do
         case dynamo_table.status
         when :active
@@ -42,25 +48,23 @@ module OceanDynamo
     end
 
 
-    def self.set_dynamo_table_keys
+    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]
-        #range_key_type = :string if range_key_type == :reference
         dynamo_table.range_key = [table_range_key, range_key_type]
       end
     end
 
 
-    def self.create_table
+    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]
-      #range_key_type = :string if range_key_type == :reference
 
       self.dynamo_table = dynamo_client.tables.create(table_full_name, 
         table_read_capacity_units, table_write_capacity_units,
@@ -73,7 +77,7 @@ module OceanDynamo
     end
 
 
-    def self.delete_table
+    def delete_table
       return false unless dynamo_table.exists? && dynamo_table.status == :active
       dynamo_table.delete
       true

data/lib/ocean-dynamo/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.3.13
+  version: 0.4.0
 platform: ruby
 authors:
 - Peter Bengtson
@@ -160,11 +160,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/routes.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/base.rb
-- lib/ocean-dynamo/callbacks.rb
+- lib/ocean-dynamo/basal.rb
 - lib/ocean-dynamo/class_variables.rb
 - lib/ocean-dynamo/engine.rb
 - lib/ocean-dynamo/exceptions.rb

data/lib/ocean-dynamo/base.rb

@@ -1,38 +0,0 @@
-module OceanDynamo
-  class Base
-
-    include ActiveModel::Model
-    include ActiveModel::Validations::Callbacks
-
-    
-    def ==(comparison_object)
-      super ||
-        comparison_object.instance_of?(self.class) &&
-        id.present? &&
-        comparison_object.id == id
-    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
-
-    # 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
-      end
-    end
-
-  end
-end

data/lib/ocean-dynamo/callbacks.rb

@@ -1,15 +0,0 @@
-module OceanDynamo
-  class Base
-
-    include ActiveModel::Validations::Callbacks
-
-    define_model_callbacks :initialize, only: :after
-    define_model_callbacks :save
-    define_model_callbacks :create
-    define_model_callbacks :update
-    define_model_callbacks :destroy
-    define_model_callbacks :commit, only: :after
-    define_model_callbacks :touch
-
-  end
-end