ocean-dynamo 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09fc89d897d34e016dd0178202cfcf7efb05b996
-  data.tar.gz: b6b27446ce89451319caa15b5f8aa386e0c7d6f9
+  metadata.gz: ec5cc85dff191d7167a21eb63097edebd85390b4
+  data.tar.gz: 26d74600e6253dfa77c4bbd3a66be11bf03e5130
 SHA512:
-  metadata.gz: 2089ddfeef6c9d4b018d42a4634a4d2a3b9c9bb23fc40bdb669aae91933deb183703acd7a5c2feaafbdb05faa4c63e778d04dfc89f4fcd25ed1a5a66ef53d883
-  data.tar.gz: 04f26407611385c332655415475e7ff012743c208512bb0e4e0772ce72dd3af92f321f65561f2f55759dd0913b0ee621f1fd7dfe5fd4aa93a25e1b8e6e7e19c9
+  metadata.gz: 1b192785b2e8f0befeb1241154a0c1d652d6511a13cb44d12b940beedbb13f05685a5791e2cbecd1abccf883da51a95bb6a8219ade4f7cb915ff4b6e3ee6b338
+  data.tar.gz: 8d00dccf68667873f1a2173198969923307d8285f74ce59ed8ffeacbfa80bafb8b4310aeb1c0fb227d0adc5f79fdffb6cab7e3f89bc7fb0a8538ef297369fe54

data/README.rdoc

@@ -17,19 +17,18 @@ OceanDynamo requires Ruby 2.0 and Ruby on Rails 4.0.0 or later.
 
 As one important use case for OceanDynamo is to facilitate the conversion of SQL based
 ActiveRecord models to DynamoDB based models, it is important that the syntax and semantics
-of OceanDynamo's operations are as close as possible to those of ActiveRecord. This means
-that all callbacks should be available, before, around and after, and that they should be
-called in the same order as in ActiveRecord. OceanDynamo follows this pattern closely and
+of OceanDynamo's operations are as close as possible to those of ActiveRecord, including
+callbacks, exceptions and support methods. Ocean-dynamo follows this pattern closely and
 is of course based on ActiveModel.
 
 The attribute and persistence layer of OceanDynamo is modeled on that of ActiveRecord:
-there's +save+, +save!+, +create+, +update+, +update!+, +update_attribute+ and all the other
+there's +save+, +save!+, +create+, +update+, +update!+, +update_attributes+ and all the other
 methods you're used to. The design goal is always to implement as much as possible of the
-ActiveRecord interface, without sacrificing scalability. This makes the task of switching from
-SQL to no-SQL much easier.
+ActiveRecord interface, without sacrificing scalability. This makes the task of switching 
+from SQL to no-SQL much easier.
 
-Due to its similarity to ActiveRecord, OceanDynamo works with FactoryGirl.
-Furthermore, future versions will keep track of and delete instances after tests.
+Thanks to its structural similarity to ActiveRecord, OceanDynamo works with FactoryGirl.
+To facilitate testing, future versions will keep track of and delete instances after tests.
 
 OceanDynamo will use secondary indices to retrieve related table items, 
 which means it will scale without limits.
@@ -61,37 +60,40 @@ The following example shows the syntax.
     
   end
 
-Each attribute has a name, a type (:string, :integer, :float, :datetime, :boolean, or 
-:serialized) where :string is the default. Each attribute also optionally has a default 
-value, which can be a Proc. The hash key attribute is by default :uuid (this can of
-course be specified) and is a :string. The keys can also be explicitly declared.
+Each attribute has a name, a type (+:string+, +:integer+, +:float+, +:datetime+, +:boolean+, 
+or +:serialized+) where +:string+ is the default. Each attribute also optionally has a default 
+value, which can be a Proc. The hash key attribute is by default +:uuid+ (this can of
+course be specified) and is a +:string+. The keys can also be explicitly declared.
 
-The :string, :integer, :float and :datetime types can also store sets of their type.
-Sets are represented as arrays and may not contain duplicates and may not be empty.
+The +:string+, +:integer+, +:float+ and +:datetime+ types can also store sets of their type.
+Sets are represented as arrays, may not contain duplicates and may not be empty.
 
-All attributes except the :string type can take the value nil. Storing nil for a string
-value will return the empty string, "".
+All attributes except the +:string+ type can take the value +nil+. Storing +nil+ for a string
+value will return the empty string, <tt>""</tt>.
 
 Also, dynamo_schema takes args and many options. Here's the full syntax:
 
  dynamo_schema(
-   table_hash_key = :uuid, 
-   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
- )
+   table_hash_key = :uuid,                 # The name of the hash key attribute
+   table_range_key = nil,                  # The name of the range key attribute (or nil)
+   table_name: compute_table_name,         # The basename of the DynamoDB table
+   table_name_prefix: nil,                 # A basename prefix string or nil
+   table_name_suffix: nil,                 # A basename suffix string or nil
+   read_capacity_units: 10,                # Used only when creating a table
+   write_capacity_units: 5,                # Used only when creating a table
+   connect: :late,                         # true, :late, nil/false
+   create: false,                          # If true, create the table if nonexistent
+   locking: :lock_version,                 # The name of the lock attribute or nil/false
+   timestamps: [:created_at, :updated_at]  # An array of timestamp columns or nil/false
+ ) do
+   # Attribute definitions
+   ...
+   ...
+ end
 
 At the moment, OceanDynamo is fully usable as an ActiveModel and can be used by Rails
 controllers. Furthermore, OceanDynamo implements much of the infrastructure of ActiveRecord;
-for instance, read_attribute, write_attribute, and much of the control logic and
+for instance, +read_attribute+, +write_attribute+, and much of the control logic and
 parameters.
 
 Relations are not yet implemented, but are underway. Relations will use secondary

data/lib/ocean-dynamo/attributes.rb

@@ -1,12 +1,14 @@
 module OceanDynamo
   class Base
-    #include ActiveModel::DeprecatedMassAssignmentSecurity
-    #include ActiveModel::ForbiddenAttributesProtection
 
+    #
+    # The hash of attributes and their values. Keys are strings.
+    #
     attr_reader :attributes
-    attr_reader :destroyed
-    attr_reader :new_record
-    attr_reader :dynamo_item
+
+    attr_reader :destroyed    # :nodoc:
+    attr_reader :new_record   # :nodoc:
+    attr_reader :dynamo_item  # :nodoc:
 
 
     def initialize(attrs={})

data/lib/ocean-dynamo/engine.rb

@@ -1,6 +1,8 @@
 module OceanDynamo
+
   class Engine < ::Rails::Engine
     config.generators.integration_tool :rspec
     config.generators.test_framework :rspec
   end
+  
 end

data/lib/ocean-dynamo/persistence.rb

@@ -183,7 +183,7 @@ module OceanDynamo
 
     protected
 
-    def self._late_connect?
+    def self._late_connect? # :nodoc:
       return false if table_connected
       return false unless table_connect_policy
       establish_db_connection
@@ -191,7 +191,7 @@ module OceanDynamo
     end
 
 
-    def _late_connect?
+    def _late_connect? # :nodoc:
       self.class._late_connect?
     end
 
@@ -215,7 +215,7 @@ module OceanDynamo
     end
 
 
-    def dynamo_delete(lock: nil)
+    def dynamo_delete(lock: nil) # :nodoc:
       _late_connect?
       begin
         options = _handle_locking(lock)
@@ -250,7 +250,7 @@ module OceanDynamo
     end
 
 
-    def set_timestamps(name=nil)
+    def set_timestamps(name=nil) # :nodoc:
       attrs = []
       attrs << timestamp_attributes[0] if timestamp_attributes && new_record?
       attrs << timestamp_attributes[1] if timestamp_attributes
@@ -260,7 +260,7 @@ module OceanDynamo
     end
 
 
-    def _set_timestamp_attributes(attrs)
+    def _set_timestamp_attributes(attrs) # :nodoc:
       return if attrs.blank?
       t = Time.zone.now
       attrs.each { |a| write_attribute a, t }
@@ -268,7 +268,7 @@ module OceanDynamo
     end
 
 
-    def _handle_locking(lock=lock_attribute)
+    def _handle_locking(lock=lock_attribute) # :nodoc:
       _late_connect?
       if lock
         current_v = read_attribute(lock)

data/lib/ocean-dynamo/schema.rb

@@ -28,7 +28,7 @@ module OceanDynamo
       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.lock_attribute = locking if locking
       self.timestamp_attributes = timestamps
       # Init
       self.fields = HashWithIndifferentAccess.new
@@ -68,7 +68,7 @@ module OceanDynamo
 
     protected
 
-    def self.dangerous_attributes
+    def self.dangerous_attributes # :nodoc:
       self.public_methods(false).collect do |sym|
         str = sym.to_s
         if str.end_with?("?", "=")

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Peter Bengtson
@@ -112,21 +112,19 @@ description: "== OceanDynamo\n\nThis is the OceanDynamo ruby gem, implementing a
   scalable Amazon DynamoDB near drop-in \nreplacement for ActiveRecord.\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. This
-  means\nthat all callbacks should be available, before, around and after, and that
-  they should be\ncalled in the same order as in ActiveRecord. 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_attribute+ and all the other\nmethods
-  you're used to. The design goal is always to implement as much as possible of the\nActiveRecord
-  interface, without sacrificing scalability. This makes the task of switching from\nSQL
-  to no-SQL much easier.\n\nOceanDynamo will use secondary indices to retrieve related
-  table items, \nwhich means it will scale without limits. (NB: this is a pre-release
-  which as yet doesn't\nimplement relations, but they are underway.)\n\nDue to its
-  similarity to ActiveRecord, OceanDynamo works with FactoryGirl.\nFurthermore, future
-  versions will keep track of and delete instances after tests.\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'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+ and all the other\nmethods you're used to. The design
+  goal is always to implement as much as possible of the\nActiveRecord interface,
+  without sacrificing scalability. This makes the task of switching from\nSQL to no-SQL
+  much easier.\n\nOceanDynamo will use secondary indices to retrieve related table
+  items, \nwhich means OceanDynamo tables will scale without limits.\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\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: []