ocean-dynamo 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8d0a72119872cc64002656244d0340796eac76b
-  data.tar.gz: febbde29e54a570653a6ada2f55a92c272491335
+  metadata.gz: d36ffc88503b1fb28acf30eb86d8b5e709561e72
+  data.tar.gz: 126589875287f2df88701c60aea134918e0b6c55
 SHA512:
-  metadata.gz: b7f8dd862bfa88185538352545016d18345fe7eb160338a16dd959b0290c7be9ccdd255742886e69ebd2556b53bb4cd7bf9595d4f97cf583e9770bc087b23243
-  data.tar.gz: c1aa7ec59bbe3990e9c2ee981ebea6d4742e95b750128227e05d10f897330f172a131e5400cede0d82ce71ff300423bf49d032991032b0b8422c81e952029b54
+  metadata.gz: 54c12079e7262327235bd3bae2fd40151c817ea7950ecbd1a22a61ac11f288c9bdec67a31f1e256b39aef30699aa56a1de14211ca29b2588f6a789d75a4e0d2a
+  data.tar.gz: 67e51cfa1e840deca03e0119b897b20a2a5de29b3f4b23df8b2669b375493efa728c914172820f1e160ff902cb0e4253bb2fe3b84384e049475fb76348db94b7

data/lib/ocean-dynamo/attributes.rb

@@ -6,9 +6,9 @@ module OceanDynamo
     #
     attr_reader :attributes
 
-    attr_reader :destroyed    # :nodoc:
-    attr_reader :new_record   # :nodoc:
-    attr_reader :dynamo_item  # :nodoc:
+    attr_reader :destroyed      # :nodoc:
+    attr_reader :new_record     # :nodoc:
+    attr_reader :dynamo_item    # :nodoc:
 
 
     def initialize(attrs={})
@@ -132,82 +132,6 @@ module OceanDynamo
     end
 
 
-    def serialized_attributes
-      result = Hash.new
-      fields.each do |attribute, metadata|
-        serialized = serialize_attribute(attribute, read_attribute(attribute), metadata)
-        result[attribute] = serialized unless serialized == nil
-      end
-      result
-    end
-
-
-    def serialize_attribute(attribute, value, metadata=fields[attribute],
-                            target_class: metadata[:target_class],
-                            type: metadata[:type],
-                            no_save: metadata[:no_save]
-                            )
-      return nil if value == nil
-      case type
-      when :reference
-        return nil if no_save
-        raise DynamoError, ":reference must always have a :target_class" unless target_class
-        return value if value.is_a?(String)
-        return value.id if value.is_a?(target_class)
-        raise AssociationTypeMismatch, "can't save a #{value.class} in a #{target_class} :reference"
-      when :string
-        return nil if ["", []].include?(value)
-        value
-      when :integer
-        value == [] ? nil : value
-      when :float
-        value == [] ? nil : value
-      when :boolean
-        value ? "true" : "false"
-      when :datetime
-        value.to_i
-      when :serialized
-        value.to_json
-      else
-        raise UnsupportedType.new(type.to_s)
-      end
-    end
-
-
-    def deserialize_attribute(value, metadata, type: metadata[:type])
-      case type
-      when :reference
-        return value
-      when :string
-        return "" if value == nil
-        value.is_a?(Set) ? value.to_a : value
-      when :integer
-        return nil if value == nil
-        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_i) : value.to_i
-      when :float
-        return nil if value == nil
-        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_f) : value.to_f
-      when :boolean
-        case value
-        when "true"
-          true
-        when "false"
-          false
-        else
-          nil
-        end
-      when :datetime
-        return nil if value == nil
-        Time.zone.at(value.to_i)
-      when :serialized
-        return nil if value == nil
-        JSON.parse(value)
-      else
-        raise UnsupportedType.new(type.to_s)
-      end
-    end
-
-
     private
 
     def _assign_attribute(k, v) # :nodoc:

data/lib/ocean-dynamo/persistence.rb

@@ -180,6 +180,43 @@ module OceanDynamo
     end
 
 
+    #
+    # Sets the dynamo_item and deserialises and assigns all its defined 
+    # attributes. Skips undeclared attributes. 
+    #
+    # The arg may be either an Item or an ItemData. If Item, a request will be
+    # made for the attributes from DynamoDB. If ItemData, no DB access will
+    # be made and the existing data will be used.
+    #
+    # The :consistent keyword may only be used when the arg is an Item.
+    #
+    def _setup_from_dynamo(arg, consistent: false)
+      case arg
+      when AWS::DynamoDB::Item
+        item = arg
+        item_data = nil
+      when AWS::DynamoDB::ItemData
+        item = arg.item
+        item_data = arg
+        raise ArgumentError, ":consistent may not be specified when passing an ItemData" if consistent
+      else
+        raise ArgumentError, "arg must be an AWS::DynamoDB::Item or an AWS::DynamoDB::ItemData"
+      end
+      
+      @dynamo_item = item
+
+      if !item_data
+        raw_attrs = item.attributes.to_hash(consistent_read: consistent)
+      else
+        raw_attrs = item_data.attributes
+      end
+
+      dynamo_deserialize_attributes(raw_attrs)
+      @new_record = false
+      self
+    end
+
+
 
     protected
 
@@ -196,11 +233,6 @@ module OceanDynamo
     end
 
 
-    def perform_validations(options={}) # :nodoc:
-      options[:validate] == false || valid?(options[:context])
-    end
-
-
     def dynamo_persist(lock: nil) # :nodoc:
       _late_connect?
       begin
@@ -209,7 +241,6 @@ module OceanDynamo
       rescue AWS::DynamoDB::Errors::ConditionalCheckFailedException
         raise OceanDynamo::StaleObjectError.new(self)
       end
-
       @new_record = false
       true
     end
@@ -226,28 +257,94 @@ module OceanDynamo
     end
 
 
-    def dynamo_unpersist(item, consistent) # :nodoc:
-      _late_connect?
-      @dynamo_item = item
-      @new_record = false
-      assign_attributes(_dynamo_read_attributes(consistent_read: consistent))
-      self
+    def serialized_attributes
+      result = Hash.new
+      fields.each do |attribute, metadata|
+        serialized = serialize_attribute(attribute, read_attribute(attribute), metadata)
+        result[attribute] = serialized unless serialized == nil
+      end
+      result
     end
 
 
-    def _dynamo_read_attributes(consistent_read: false) # :nodoc:
-      hash = _dynamo_read_raw_attributes(consistent_read)
+    def dynamo_deserialize_attributes(hash) # :nodoc:
       result = Hash.new
       fields.each do |attribute, metadata|
         next if metadata[:no_save]
         result[attribute] = deserialize_attribute(hash[attribute], metadata)
       end
-      result
+      assign_attributes(result)
+    end
+
+
+    def serialize_attribute(attribute, value, metadata=fields[attribute],
+                            target_class: metadata[:target_class],
+                            type: metadata[:type],
+                            no_save: metadata[:no_save]
+                            )
+      return nil if value == nil
+      case type
+      when :reference
+        return nil if no_save
+        raise DynamoError, ":reference must always have a :target_class" unless target_class
+        return value if value.is_a?(String)
+        return value.id if value.is_a?(target_class)
+        raise AssociationTypeMismatch, "can't save a #{value.class} in a #{target_class} :reference"
+      when :string
+        return nil if ["", []].include?(value)
+        value
+      when :integer
+        value == [] ? nil : value
+      when :float
+        value == [] ? nil : value
+      when :boolean
+        value ? "true" : "false"
+      when :datetime
+        value.to_i
+      when :serialized
+        value.to_json
+      else
+        raise UnsupportedType.new(type.to_s)
+      end
     end
 
 
-    def _dynamo_read_raw_attributes(consistent) # :nodoc:
-      dynamo_item.attributes.to_hash(consistent_read: consistent)
+    def deserialize_attribute(value, metadata, type: metadata[:type])
+      case type
+      when :reference
+        return value
+      when :string
+        return "" if value == nil
+        value.is_a?(Set) ? value.to_a : value
+      when :integer
+        return nil if value == nil
+        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_i) : value.to_i
+      when :float
+        return nil if value == nil
+        value.is_a?(Set) || value.is_a?(Array) ? value.collect(&:to_f) : value.to_f
+      when :boolean
+        case value
+        when "true"
+          true
+        when "false"
+          false
+        else
+          nil
+        end
+      when :datetime
+        return nil if value == nil
+        Time.zone.at(value.to_i)
+      when :serialized
+        return nil if value == nil
+        JSON.parse(value)
+      else
+        raise UnsupportedType.new(type.to_s)
+      end
+    end
+
+
+    def perform_validations(options={}) # :nodoc:
+      options[:validate] == false || valid?(options[:context])
     end
 
 

data/lib/ocean-dynamo/queries.rb

@@ -5,7 +5,7 @@ module OceanDynamo
       _late_connect?
       item = dynamo_items[hash, range]
       raise RecordNotFound, "can't find a #{self} with primary key ['#{hash}', #{range.inspect}]" unless item.exists?
-      new.send(:dynamo_unpersist, item, consistent)
+      new._setup_from_dynamo(item, consistent: consistent)
     end
 
 
@@ -21,9 +21,25 @@ module OceanDynamo
     end
 
 
-    def self.count
+    #
+    # The number of records in the table.
+    #
+    def self.count(**options)
       _late_connect?
-      dynamo_table.item_count || -1    # The || -1 is for fake_dynamo specs.
+      dynamo_items.count(options)
+    end
+
+
+    #
+    # Returns all records in the table.
+    #
+    def self.all(**options)
+      _late_connect?
+      result = []
+      dynamo_items.select(options) do |item_data| 
+        result << new._setup_from_dynamo(item_data)
+      end
+      result
     end
 
   end

data/lib/ocean-dynamo/schema.rb

@@ -32,7 +32,11 @@ module OceanDynamo
       self.timestamp_attributes = timestamps
       # Init
       self.fields = HashWithIndifferentAccess.new
-      attribute table_hash_key, :string, default: ""
+      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

data/lib/ocean-dynamo/version.rb

@@ -1,3 +1,3 @@
 module OceanDynamo
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ocean-dynamo
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Peter Bengtson