ocean-dynamo 0.5.3 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2db27622c231e1acb60ff447a2c09e03b5296f8b
-  data.tar.gz: d52b739be71641641dcc3692beec600b140de494
+  metadata.gz: 062bcb5f319f4a5af8ce04446494b1ddbccfdee4
+  data.tar.gz: ef17a6d96f6b9185bbf87a9d46a08676b29e3b78
 SHA512:
-  metadata.gz: 1ee704329bb3acc6ab272e262450af7100a276d2dc71807ede59defbd39a7407c282b327b2be252096df55d2b2638b6d6e5c14cfe5fdc70067dfe97f461abc82
-  data.tar.gz: 0f12b591db93660a40edc51e47d56e35d406265e1bf1ada58dc62588b742de29ca7b2ab890e18755637af828685f2fd9bbb4d768fb606207a1bea10f573c9bbc
+  metadata.gz: 51c788173b2dfc7adae92e40859d0ef30d0884e70355b5b936a07cc8360aee1bf2eab30993b280534aee6c691427246930ba5ddbbb171018ec5f02b6c36d53d7
+  data.tar.gz: 0c2028820ab01793de0a8d3b0712396e2aaa3944d9f9d2c350d6c1400acb48a34d815c61c29c11cc55d91a12133967ee45213d3be33663b51ed4f1f5c8c72c29

data/lib/ocean-dynamo.rb

@@ -17,6 +17,7 @@ require "ocean-dynamo/associations/associations"
 require "ocean-dynamo/associations/association"
 require "ocean-dynamo/associations/collection_association"
 require "ocean-dynamo/associations/relation"
+require "ocean-dynamo/associations/collection_proxy"
 require "ocean-dynamo/associations/belongs_to"
 require "ocean-dynamo/associations/has_many"
 

data/lib/ocean-dynamo/active_record_stuff/collection_association.rb

@@ -304,7 +304,7 @@ module ActiveRecord  #:nodoc: all
         end
       end
 
-      # Returns true if the collections is not empty.
+      # Returns true if the collection is not empty.
       # Equivalent to +!collection.empty?+.
       def any?
         if block_given?

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

@@ -25,7 +25,7 @@ module ActiveRecord #:nodoc: all
     # The <tt>@target</tt> object is not \loaded until needed.
     #
     class CollectionProxy < Relation #:nodoc: all
-      #delegate(*(ActiveRecord::Calculations.public_instance_methods - [:count]), to: :scope)
+      delegate(*(ActiveRecord::Calculations.public_instance_methods - [:count]), to: :scope)
 
       def initialize(klass, association)
         @association = association

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

@@ -101,8 +101,8 @@ module OceanDynamo
 
       #
       # Returns the class of the target. belongs_to polymorphic used to override this 
-      # to look at the polymorphic_type field on the owner. However, belongs_to is no
-      # longer implemented in AR using an Assocation, so we keep this only for structural
+      # to look at the polymorphic_type field on the owner. However, as belongs_to is no
+      # longer implemented in AR using an Assocation, we keep this only for structural
       # compatibility.
       #
       def klass

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

@@ -115,7 +115,7 @@ module OceanDynamo
 
 
       #
-      # Returns true if the class has a belongs_to association.
+      # Returns +true+ if the class has a +belongs_to+ association.
       #
       def has_belongs_to?
         fields[table_hash_key]['association'] == :belongs_to
@@ -124,7 +124,7 @@ module OceanDynamo
 
 
       #
-      # Returns the class of the belongs_to association, or false if none.
+      # 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']
@@ -135,17 +135,7 @@ module OceanDynamo
       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.
+      # Make sure the class doesn't already have a +belongs_to+ relation.
       #
       def assert_only_one_belongs_to!  # :nodoc:
         if has_belongs_to?
@@ -166,7 +156,7 @@ module OceanDynamo
 
 
       #
-      # Make sure the hash key isn't called :id.
+      # Make sure the hash key isn't named <tt>:id</tt>.
       #
       def assert_hash_key_is_not_id!  # :nodoc:
         raise HashKeyMayNotBeNamedId, 

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

@@ -5,10 +5,11 @@ module OceanDynamo
     # ease the implementation of association proxies that represent
     # collections. See the class hierarchy in AssociationProxy.
     #
-    #   CollectionAssociation:
-    #     HasAndBelongsToManyAssociation => has_and_belongs_to_many
-    #     HasManyAssociation => has_many
-    #       HasManyThroughAssociation + ThroughAssociation => has_many :through
+    #  Association
+    #    CollectionAssociation:
+    #      HasAndBelongsToManyAssociation => has_and_belongs_to_many
+    #      HasManyAssociation => has_many
+    #        HasManyThroughAssociation + ThroughAssociation => has_many :through
     #
     # CollectionAssociation class provides common methods to the collections
     # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with

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

@@ -0,0 +1,211 @@
+module OceanDynamo
+  module Associations
+    #
+    # Collection proxies in OceanDynamo are middlemen between the object that
+    # holds the association, known as the <tt>@owner</tt>, and the actual associated
+    # object, known as the <tt>@target</tt>. The kind of association any proxy is
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # OceanDynamo::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < OceanDynamo::Table
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # the collection proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class delegates unknown methods to <tt>@target</tt> NOT via
+    # <tt>method_missing</tt> (as the ActiveRecord documentation falsely states),
+    # but through explicit proxy methods for each separate operation.
+    #
+    # The <tt>@target</tt> object is not \loaded until needed. As it turns out,
+    # the key to this lazy loading scheme is <tt>to_ary</tt>.
+    #
+    #
+    # Inheritance chain:
+    #
+    #   Relation             (@klass, @loaded)
+    #     CollectionProxy    (@association)
+    #
+
+
+
+    class CollectionProxy < Relation
+
+
+      def initialize(klass, association)
+        @association = association
+        super klass
+      end
+
+
+      def proxy_association
+        @association
+      end
+
+
+      def target
+        @association.target
+      end
+
+
+      def load_target
+        @association.load_target
+      end
+
+
+      def loaded?
+        @association.loaded?
+      end
+
+
+      def select(select = nil, &block)
+        @association.select(select, &block)
+      end
+
+
+      def find(*args, &block)
+        @association.find(*args, &block)
+      end
+
+
+      def first(*args)
+        @association.first(*args)
+      end
+
+
+      def last(*args)
+        @association.last(*args)
+      end
+
+
+      def build(attributes = {}, &block)
+        @association.build(attributes, &block)
+      end
+      alias_method :new, :build
+
+
+      def create(attributes = {}, &block)
+        @association.create(attributes, &block)
+      end
+
+
+      def create!(attributes = {}, &block)
+        @association.create!(attributes, &block)
+      end
+
+
+      def concat(*records)
+        @association.concat(*records)
+      end
+
+
+      def replace(other_array)
+        @association.replace(other_array)
+      end
+
+
+      def delete_all
+        @association.delete_all
+      end
+
+
+      def clear
+        delete_all
+        self
+      end
+
+
+      def destroy_all
+        @association.destroy_all
+      end
+
+
+      def delete(*records)
+        @association.delete(*records)
+      end
+
+
+      def destroy(*records)
+        @association.destroy(*records)
+      end
+
+
+      def distinct
+        @association.distinct
+      end
+      alias uniq distinct
+
+
+      def count(column_name = nil, options = {})
+        @association.count(column_name, options)
+      end
+
+
+      def size
+        @association.size
+      end
+
+
+      def length
+        @association.length
+      end
+
+
+      def empty?
+        @association.empty?
+      end
+
+
+      def any?(&block)
+        @association.any?(&block)
+      end
+
+
+      def many?(&block)
+        @association.many?(&block)
+      end
+
+
+      def include?(record)
+        @association.include?(record)
+      end
+
+
+      def ==(other)
+        load_target == other
+      end
+
+
+      def to_ary
+        load_target.dup
+      end
+      alias_method :to_a, :to_ary
+
+
+      def <<(*records)
+        proxy_association.concat(records) && self
+      end
+      alias_method :push, :<<
+      alias_method :append, :<<
+
+
+      def prepend(*args)
+        raise NoMethodError, "prepend on association is not defined. Please use << or append"
+      end
+
+
+      def reload
+        proxy_association.reload
+        self
+      end
+
+
+    end
+  end
+end

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

@@ -1,18 +1,29 @@
 module OceanDynamo
 
+
+  #
+  # Relation is a stripped-down version of the corresponding ActiveRecord 
+  # class. OceanDynamo doesn't implement scopes or counter caches, which
+  # simplifies the code considerably. 
+  #
+  # Inheritance chain:
+  #
+  #   Relation             (@klass, @loaded)
+  #     CollectionProxy    (@association)
+  #
+  #
+
   class Relation
 
   	attr_reader :klass
-  	attr_reader :values
   	attr_reader :loaded
 
   	alias :model :klass
     alias :loaded? :loaded
 
 
-  	def initialize(klass, **values)
+  	def initialize(klass)
   	  @klass = klass
-  	  @values = values
   	  @loaded = false
   	end
 

data/lib/ocean-dynamo/queries.rb

@@ -27,11 +27,6 @@ module OceanDynamo
     alias find_by_id find_by_key
 
 
-    # def find_by_id(*args)
-    #   find_by_key(*args)
-    # end
-
-
     #
     # The number of records in the table.
     #

data/lib/ocean-dynamo/tables.rb

@@ -57,7 +57,6 @@ module OceanDynamo
 
 
       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

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.5.3"
+  VERSION = "0.5.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Peter Bengtson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-07 00:00:00.000000000 Z
+date: 2013-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -148,11 +148,10 @@ description: "== OceanDynamo\n\nOceanDynamo is a massively scalable Amazon Dynam
   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"
+  OceanDynamo works with FactoryGirl.\n\nOceanDynamo uses primary indices to retrieve
+  related table items, \nmeaning it scales 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: []
@@ -171,6 +170,7 @@ files:
 - lib/ocean-dynamo/associations/associations.rb
 - lib/ocean-dynamo/associations/belongs_to.rb
 - lib/ocean-dynamo/associations/collection_association.rb
+- lib/ocean-dynamo/associations/collection_proxy.rb
 - lib/ocean-dynamo/associations/has_many.rb
 - lib/ocean-dynamo/associations/relation.rb
 - lib/ocean-dynamo/attributes.rb
@@ -197,9 +197,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='