dynamoid 3.0.0 → 3.1.0

data/lib/dynamoid/fields.rb

@@ -64,6 +64,7 @@ module Dynamoid #:nodoc:
             end
           end
           define_method("#{named}=") { |value| write_attribute(named, value) }
+          define_method("#{named}_before_type_cast") { read_attribute_before_type_cast(named) }
         end
       end
 
@@ -88,6 +89,7 @@ module Dynamoid #:nodoc:
           remove_method field
           remove_method :"#{field}="
           remove_method :"#{field}?"
+          remove_method:"#{field}_before_type_cast"
         end
       end
 
@@ -119,6 +121,8 @@ module Dynamoid #:nodoc:
         association.reset
       end
 
+      @attributes_before_type_cast[name] = value
+
       value_casted = TypeCasting.cast_field(value, self.class.attributes[name])
       attributes[name] = value_casted
     end
@@ -134,25 +138,17 @@ module Dynamoid #:nodoc:
     end
     alias [] read_attribute
 
-    # Updates multiple attibutes at once, saving the object once the updates are complete.
-    #
-    # @param [Hash] attributes a hash of attributes to update
-    #
-    # @since 0.2.0
-    def update_attributes(attributes)
-      attributes.each { |attribute, value| write_attribute(attribute, value) } unless attributes.nil? || attributes.empty?
-      save
+    # Returns a hash of attributes before typecasting
+    def attributes_before_type_cast
+      @attributes_before_type_cast
     end
 
-    # Update a single attribute, saving the object afterwards.
+    # Returns the value of the attribute identified by name before typecasting
     #
-    # @param [Symbol] attribute the attribute to update
-    # @param [Object] value the value to assign it
-    #
-    # @since 0.2.0
-    def update_attribute(attribute, value)
-      write_attribute(attribute, value)
-      save
+    # @param [Symbol] attribute name
+    def read_attribute_before_type_cast(name)
+      return nil unless name.respond_to?(:to_sym)
+      @attributes_before_type_cast[name.to_sym]
     end
 
     private
@@ -173,8 +169,14 @@ module Dynamoid #:nodoc:
       end
     end
 
-    def set_type
-      self.type ||= self.class.name if self.class.attributes[:type]
+    def set_inheritance_field
+      # actually it does only following logic:
+      # self.type ||= self.class.name if self.class.attributes[:type]
+
+      type = self.class.inheritance_field
+      if self.class.attributes[type] && self.send(type).nil?
+        self.send("#{type}=", self.class.name)
+      end
     end
   end
 end

data/lib/dynamoid/finders.rb

@@ -37,12 +37,17 @@ module Dynamoid
       # @example Find several documents by partition key and sort key
       #   Document.find([[101, 'archived'], [102, 'new'], [103, 'deleted']])
       #
+      # @example Perform strong consistent reads
+      #   Document.find(101, consistent_read: true)
+      #   Document.find(101, 102, 103, consistent_read: true)
+      #   Document.find(101, range_key: 'archived', consistent_read: true)
+      #
       # @since 0.2.0
       def find(*ids, **options)
         if ids.size == 1 && !ids[0].is_a?(Array)
           _find_by_id(ids[0], options.merge(raise_error: true))
         else
-          _find_all(ids.flatten(1), raise_error: true)
+          _find_all(ids.flatten(1), options.merge(raise_error: true))
         end
       end
 
@@ -95,10 +100,12 @@ module Dynamoid
           end
         end
 
+        read_options = options.slice(:consistent_read)
+
         items = if Dynamoid.config.backoff
                   items = []
                   backoff = nil
-                  Dynamoid.adapter.read(table_name, ids, options) do |hash, has_unprocessed_items|
+                  Dynamoid.adapter.read(table_name, ids, read_options) do |hash, has_unprocessed_items|
                     items += hash[table_name]
 
                     if has_unprocessed_items
@@ -110,14 +117,15 @@ module Dynamoid
                   end
                   items
                 else
-                  items = Dynamoid.adapter.read(table_name, ids, options)
+                  items = Dynamoid.adapter.read(table_name, ids, read_options)
                   items ? items[table_name] : []
                 end
 
         if items.size == ids.size || !options[:raise_error]
           items ? items.map { |i| from_database(i) } : []
         else
-          message = "Couldn't find all #{name.pluralize} with '#{hash_key}': (#{ids.join(', ')}) "
+          ids_list = range_key ? ids.map { |pk, sk| "(#{pk},#{sk})" } : ids.map(&:to_s)
+          message = "Couldn't find all #{name.pluralize} with primary keys [#{ids_list.join(', ')}] "
           message += "(found #{items.size} results, but was looking for #{ids.size})"
           raise Errors::RecordNotFound, message
         end
@@ -132,10 +140,11 @@ module Dynamoid
           options[:range_key] = key_dumped
         end
 
-        if item = Dynamoid.adapter.read(table_name, id, options)
+        if item = Dynamoid.adapter.read(table_name, id, options.slice(:range_key, :consistent_read))
           from_database(item)
         elsif options[:raise_error]
-          message = "Couldn't find #{name} with '#{hash_key}'=#{id}"
+          primary_key = range_key ? "(#{id},#{options[:range_key]})" : id
+          message = "Couldn't find #{name} with primary key #{primary_key}"
           raise Errors::RecordNotFound, message
         end
       end

data/lib/dynamoid/persistence.rb

@@ -59,7 +59,7 @@ module Dynamoid
       end
 
       def from_database(attrs = {})
-        clazz = attrs[:type] ? obj = attrs[:type].constantize : self
+        clazz = choose_right_class(attrs)
         attrs_undumped = Undumping.undump_attributes(attrs, clazz.attributes)
         clazz.new(attrs_undumped).tap { |r| r.new_record = false }
       end
@@ -151,6 +151,36 @@ module Dynamoid
       end
     end
 
+    # Updates multiple attibutes at once, saving the object once the updates are complete.
+    #
+    # @param [Hash] attributes a hash of attributes to update
+    #
+    # @since 0.2.0
+    def update_attributes(attributes)
+      attributes.each { |attribute, value| write_attribute(attribute, value) } unless attributes.nil? || attributes.empty?
+      save
+    end
+
+    # Updates multiple attibutes at once, saving the object once the updates are complete.
+    # Raises a Dynamoid::Errors::DocumentNotValid exception if there is vaidation and it fails.
+    #
+    # @param [Hash] attributes a hash of attributes to update
+    def update_attributes!(attributes)
+      attributes.each { |attribute, value| write_attribute(attribute, value) } unless attributes.nil? || attributes.empty?
+      save!
+    end
+
+    # Update a single attribute, saving the object afterwards.
+    #
+    # @param [Symbol] attribute the attribute to update
+    # @param [Object] value the value to assign it
+    #
+    # @since 0.2.0
+    def update_attribute(attribute, value)
+      write_attribute(attribute, value)
+      save
+    end
+
     #
     # update!() will increment the lock_version if the table has the column, but will not check it. Thus, a concurrent save will
     # never cause an update! to fail, but an update! may cause a concurrent save to fail.
@@ -186,6 +216,36 @@ module Dynamoid
       false
     end
 
+    # Initializes attribute to zero if nil and adds the value passed as by (default is 1).
+    # Only makes sense for number-based attributes. Returns self.
+    def increment(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    # Wrapper around increment that saves the record.
+    # Returns true if the record could be saved.
+    def increment!(attribute, by = 1)
+      increment(attribute, by)
+      save
+    end
+
+    # Initializes attribute to zero if nil and subtracts the value passed as by (default is 1).
+    # Only makes sense for number-based attributes. Returns self.
+    def decrement(attribute, by = 1)
+      self[attribute] ||= 0
+      self[attribute] -= by
+      self
+    end
+
+    # Wrapper around decrement that saves the record.
+    # Returns true if the record could be saved.
+    def decrement!(attribute, by = 1)
+      decrement(attribute, by)
+      save
+    end
+
     # Delete this object, but only after running callbacks for it.
     #
     # @since 0.2.0

data/lib/dynamoid/tasks/database.rake

@@ -7,7 +7,7 @@ namespace :dynamoid do
   desc 'Creates DynamoDB tables, one for each of your Dynamoid models - does not modify pre-existing tables'
   task create_tables: :environment do
     # Load models so Dynamoid will be able to discover tables expected.
-    Dir[File.join(Dynamoid::Config.models_dir, '*.rb')].sort.each { |file| require file }
+    Dir[File.join(Dynamoid::Config.models_dir, '**/*.rb')].sort.each { |file| require file }
     if Dynamoid.included_models.any?
       tables = Dynamoid::Tasks::Database.create_tables
       result = tables[:created].map { |c| "#{c} created" } + tables[:existing].map { |e| "#{e} already exists" }

data/lib/dynamoid/tasks/database.rb

@@ -14,7 +14,7 @@ module Dynamoid
           if Dynamoid.adapter.list_tables.include? model.table_name
             results[:existing] << model.table_name
           else
-            model.create_table
+            model.create_table(sync: true)
             results[:created] << model.table_name
           end
         end

data/lib/dynamoid/type_casting.rb

@@ -106,6 +106,18 @@ module Dynamoid
 
     class SetTypeCaster < Base
       def process(value)
+        set = type_cast_to_set(value)
+
+        if set.present? && @options[:of].present?
+          process_typed_set(set)
+        else
+          set
+        end
+      end
+
+      private
+
+      def type_cast_to_set(value)
         if value.is_a?(Set)
           value.dup
         elsif value.respond_to?(:to_set)
@@ -114,10 +126,50 @@ module Dynamoid
           nil
         end
       end
+
+      def process_typed_set(set)
+        type_caster = TypeCasting.find_type_caster(element_options)
+
+        if type_caster.nil?
+          raise ArgumentError, "Set element type #{element_type} isn't supported"
+        end
+
+        set.map { |el| type_caster.process(el) }.to_set
+      end
+
+      def element_type
+        unless @options[:of].is_a?(Hash)
+          @options[:of]
+        else
+          @options[:of].keys.first
+        end
+      end
+
+      def element_options
+        unless @options[:of].is_a?(Hash)
+          { type: element_type }
+        else
+          @options[:of][element_type].dup.tap do |options|
+            options[:type] = element_type
+          end
+        end
+      end
     end
 
     class ArrayTypeCaster < Base
       def process(value)
+        array = type_cast_to_array(value)
+
+        if array.present? && @options[:of].present?
+          process_typed_array(array)
+        else
+          array
+        end
+      end
+
+      private
+
+      def type_cast_to_array(value)
         if value.is_a?(Array)
           value.dup
         elsif value.respond_to?(:to_a)
@@ -126,6 +178,34 @@ module Dynamoid
           nil
         end
       end
+
+      def process_typed_array(array)
+        type_caster = TypeCasting.find_type_caster(element_options)
+
+        if type_caster.nil?
+          raise ArgumentError, "Set element type #{element_type} isn't supported"
+        end
+
+        array.map { |el| type_caster.process(el) }
+      end
+
+      def element_type
+        unless @options[:of].is_a?(Hash)
+          @options[:of]
+        else
+          @options[:of].keys.first
+        end
+      end
+
+      def element_options
+        unless @options[:of].is_a?(Hash)
+          { type: element_type }
+        else
+          @options[:of][element_type].dup.tap do |options|
+            options[:type] = element_type
+          end
+        end
+      end
     end
 
     class DateTimeTypeCaster < Base

data/lib/dynamoid/undumping.rb

@@ -4,20 +4,24 @@ module Dynamoid
   module Undumping
     def self.undump_attributes(attributes, attributes_options)
       {}.tap do |h|
-        attributes.symbolize_keys.each do |attribute, value|
-          h[attribute] = undump_field(value, attributes_options[attribute])
+        # ignore existing attributes not declared in document class
+        attributes.symbolize_keys
+          .select { |attribute| attributes_options.key?(attribute) }
+          .each do |attribute, value|
+            h[attribute] = undump_field(value, attributes_options[attribute])
         end
       end
     end
 
     def self.undump_field(value, options)
+      return nil if value.nil?
+
       undumper = find_undumper(options)
 
       if undumper.nil?
         raise ArgumentError, "Unknown type #{options[:type]}"
       end
 
-      return nil if value.nil?
       undumper.process(value)
     end
 
@@ -64,19 +68,93 @@ module Dynamoid
     end
 
     class SetUndumper < Base
-      def process(value)
-        case @options[:of]
-        when :integer
-          value.map { |v| Integer(v) }.to_set
-        when :number
-          value.map { |v| BigDecimal(v.to_s) }.to_set
+      ALLOWED_TYPES = [:string, :integer, :number, :date, :datetime, :serialized]
+
+      def process(set)
+        if @options.key?(:of)
+          process_typed_collection(set)
+        else
+          set.is_a?(Set) ? set : Set.new(set)
+        end
+      end
+
+      private
+
+      def process_typed_collection(set)
+        if allowed_type?
+          undumper = Undumping.find_undumper(element_options)
+          set.map { |el| undumper.process(el) }.to_set
         else
-          value.is_a?(Set) ? value : Set.new(value)
+          raise ArgumentError, "Set element type #{element_type} isn't supported"
+        end
+      end
+
+      def allowed_type?
+        ALLOWED_TYPES.include?(element_type) || element_type.is_a?(Class)
+      end
+
+      def element_type
+        unless @options[:of].is_a?(Hash)
+          @options[:of]
+        else
+          @options[:of].keys.first
+        end
+      end
+
+      def element_options
+        unless @options[:of].is_a?(Hash)
+          { type: element_type }
+        else
+          @options[:of][element_type].dup.tap do |options|
+            options[:type] = element_type
+          end
         end
       end
     end
 
     class ArrayUndumper < Base
+      ALLOWED_TYPES = [:string, :integer, :number, :date, :datetime, :serialized]
+
+      def process(array)
+        if @options.key?(:of)
+          process_typed_collection(array)
+        else
+          array.is_a?(Array) ? array : Array(array)
+        end
+      end
+
+      private
+
+      def process_typed_collection(array)
+        if allowed_type?
+          undumper = Undumping.find_undumper(element_options)
+          array.map { |el| undumper.process(el) }
+        else
+          raise ArgumentError, "Array element type #{element_type} isn't supported"
+        end
+      end
+
+      def allowed_type?
+        ALLOWED_TYPES.include?(element_type) || element_type.is_a?(Class)
+      end
+
+      def element_type
+        unless @options[:of].is_a?(Hash)
+          @options[:of]
+        else
+          @options[:of].keys.first
+        end
+      end
+
+      def element_options
+        unless @options[:of].is_a?(Hash)
+          { type: element_type }
+        else
+          @options[:of][element_type].dup.tap do |options|
+            options[:type] = element_type
+          end
+        end
+      end
     end
 
     class DateTimeUndumper < Base