dynamoid 2.2.0 → 3.0.0

data/lib/dynamoid/dirty.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Dirty
     extend ActiveSupport::Concern
@@ -34,14 +36,14 @@ module Dynamoid
     end
 
     def write_attribute(name, value)
-      attribute_will_change!(name) unless self.read_attribute(name) == value
+      attribute_will_change!(name) unless read_attribute(name) == value
       super
     end
 
     protected
 
     def attribute_method?(attr)
-      super || self.class.attributes.has_key?(attr.to_sym)
+      super || self.class.attributes.key?(attr.to_sym)
     end
 
     if ActiveModel::VERSION::STRING >= '5.2.0'
@@ -53,8 +55,7 @@ module Dynamoid
         @mutations_from_database ||= ActiveModel::NullMutationTracker.instance
       end
 
-      def forget_attribute_assignments
-      end
+      def forget_attribute_assignments; end
     end
 
     if ActiveModel::VERSION::STRING < '4.2.0'

data/lib/dynamoid/document.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
-module Dynamoid #:nodoc:
+# frozen_string_literal: true
 
+module Dynamoid #:nodoc:
   # This is the base module for all domain objects that need to be persisted to
   # the database as documents.
   module Document
@@ -114,35 +114,66 @@ module Dynamoid #:nodoc:
       # @since 0.2.0
       def exists?(id_or_conditions = {})
         case id_or_conditions
-          when Hash then where(id_or_conditions).first.present?
-          else !! find_by_id(id_or_conditions)
-        end
-      end
-
-      def update(hash_key, range_key_value=nil, attrs)
-        if range_key.present?
-          range_key_value = dump_field(range_key_value, attributes[self.range_key])
+        when Hash then where(id_or_conditions).first.present?
         else
-          range_key_value = nil
+          begin
+            find(id_or_conditions)
+            true
+          rescue Dynamoid::Errors::RecordNotFound
+            false
+          end
         end
+      end
 
+      # Update document with provided values.
+      # Instantiates document and saves changes. Runs validations and callbacks.
+      #
+      # @param [Scalar value] partition key
+      # @param [Scalar value] sort key, optional
+      # @param [Hash] attributes
+      #
+      # @return [Dynamoid::Doument] updated document
+      #
+      # @example Update document
+      #   Post.update(101, read: true)
+      def update(hash_key, range_key_value = nil, attrs)
         model = find(hash_key, range_key: range_key_value, consistent_read: true)
         model.update_attributes(attrs)
         model
       end
 
-      def update_fields(hash_key_value, range_key_value=nil, attrs={}, conditions={})
+      # Update document.
+      # Uses efficient low-level `UpdateItem` API call.
+      # Changes attibutes and loads new document version with one API call.
+      # Doesn't run validations and callbacks. Can make conditional update.
+      # If a document doesn't exist or specified conditions failed - returns `nil`
+      #
+      # @param [Scalar value] partition key
+      # @param [Scalar value] sort key (optional)
+      # @param [Hash] attributes
+      # @param [Hash] conditions
+      #
+      # @return [Dynamoid::Document/nil] updated document
+      #
+      # @example Update document
+      #   Post.update_fields(101, read: true)
+      #
+      # @example Update document with condition
+      #   Post.update_fields(101, { read: true }, if: { version: 1 })
+      def update_fields(hash_key_value, range_key_value = nil, attrs = {}, conditions = {})
         optional_params = [range_key_value, attrs, conditions].compact
         if optional_params.first.is_a?(Hash)
           range_key_value = nil
-          attrs, conditions = optional_params[0 .. 1]
+          attrs, conditions = optional_params[0..1]
         else
           range_key_value = optional_params.first
-          attrs, conditions = optional_params[1 .. 2]
+          attrs, conditions = optional_params[1..2]
         end
 
         options = if range_key
-                    { range_key: dump_field(range_key_value, attributes[range_key]) }
+                    value_casted = TypeCasting.cast_field(range_key_value, attributes[range_key])
+                    value_dumped = Dumping.dump_field(value_casted, attributes[range_key])
+                    { range_key: value_dumped }
                   else
                     {}
                   end
@@ -150,42 +181,81 @@ module Dynamoid #:nodoc:
         (conditions[:if_exists] ||= {})[hash_key] = hash_key_value
         options[:conditions] = conditions
 
+        attrs = attrs.symbolize_keys
+        if Dynamoid::Config.timestamps
+          attrs[:updated_at] ||= DateTime.now.in_time_zone(Time.zone)
+        end
+
         begin
           new_attrs = Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
-            attrs.symbolize_keys.each do |k, v|
-              t.set k => dump_field(v, attributes[k])
+            attrs.each do |k, v|
+              value_casted = TypeCasting.cast_field(v, attributes[k])
+              value_dumped = Dumping.dump_field(value_casted, attributes[k])
+              t.set(k => value_dumped)
             end
           end
-          new(new_attrs)
+          attrs_undumped = Undumping.undump_attributes(new_attrs, attributes)
+          new(attrs_undumped)
         rescue Dynamoid::Errors::ConditionalCheckFailedException
         end
       end
 
-      def upsert(hash_key_value, range_key_value=nil, attrs={}, conditions={})
+
+      # Update existing document or create new one.
+      # Similar to `.update_fields`. The only diffirence is creating new document.
+      #
+      # Uses efficient low-level `UpdateItem` API call.
+      # Changes attibutes and loads new document version with one API call.
+      # Doesn't run validations and callbacks. Can make conditional update.
+      # If specified conditions failed - returns `nil`
+      #
+      # @param [Scalar value] partition key
+      # @param [Scalar value] sort key (optional)
+      # @param [Hash] attributes
+      # @param [Hash] conditions
+      #
+      # @return [Dynamoid::Document/nil] updated document
+      #
+      # @example Update document
+      #   Post.update(101, read: true)
+      #
+      # @example Update document
+      #   Post.upsert(101, read: true)
+      def upsert(hash_key_value, range_key_value = nil, attrs = {}, conditions = {})
         optional_params = [range_key_value, attrs, conditions].compact
         if optional_params.first.is_a?(Hash)
           range_key_value = nil
-          attrs, conditions = optional_params[0 .. 1]
+          attrs, conditions = optional_params[0..1]
         else
           range_key_value = optional_params.first
-          attrs, conditions = optional_params[1 .. 2]
+          attrs, conditions = optional_params[1..2]
         end
 
         options = if range_key
-                    { range_key: dump_field(range_key_value, attributes[range_key]) }
+                    value_casted = TypeCasting.cast_field(range_key_value, attributes[range_key])
+                    value_dumped = Dumping.dump_field(value_casted, attributes[range_key])
+                    { range_key: value_dumped }
                   else
                     {}
                   end
 
         options[:conditions] = conditions
 
+        attrs = attrs.symbolize_keys
+        if Dynamoid::Config.timestamps
+          attrs[:updated_at] ||= DateTime.now.in_time_zone(Time.zone)
+        end
+
         begin
           new_attrs = Dynamoid.adapter.update_item(table_name, hash_key_value, options) do |t|
-            attrs.symbolize_keys.each do |k, v|
-              t.set k => dump_field(v, attributes[k])
+            attrs.each do |k, v|
+              value_casted = TypeCasting.cast_field(v, attributes[k])
+              value_dumped = Dumping.dump_field(value_casted, attributes[k])
+              t.set(k => value_dumped)
             end
           end
-          new(new_attrs)
+          attrs_undumped = Undumping.undump_attributes(new_attrs, attributes)
+          new(attrs_undumped)
         rescue Dynamoid::Errors::ConditionalCheckFailedException
         end
       end
@@ -212,13 +282,30 @@ module Dynamoid #:nodoc:
         @attributes ||= {}
         @associations ||= {}
 
-        load(attrs)
+        self.class.attributes.each do |_, options|
+          if options[:type].is_a?(Class) && options[:default]
+            raise 'Dynamoid class-type fields do not support default values'
+          end
+        end
+
+        attrs_with_defaults = {}
+        self.class.attributes.each do |attribute, options|
+          attrs_with_defaults[attribute] = if attrs.key?(attribute)
+                                             attrs[attribute]
+                                           elsif options.key?(:default)
+                                             evaluate_default_value(options[:default])
+                                           end
+        end
+
+        attrs_virtual = attrs.slice(*(attrs.keys - self.class.attributes.keys))
+
+        load(attrs_with_defaults.merge(attrs_virtual))
       end
     end
 
     def load(attrs)
-      self.class.undump(attrs).each do |key, value|
-        send("#{key}=", value) if self.respond_to?("#{key}=")
+      attrs.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
       end
     end
 
@@ -230,7 +317,7 @@ module Dynamoid #:nodoc:
         super
       else
         return false if other.nil?
-        other.is_a?(Dynamoid::Document) && self.hash_key == other.hash_key && self.range_value == other.range_value
+        other.is_a?(Dynamoid::Document) && hash_key == other.hash_key && range_value == other.range_value
       end
     end
 
@@ -249,8 +336,13 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def reload
-      range_key_value = range_value ? dumped_range_value : nil
-      self.attributes = self.class.find(hash_key, range_key: range_key_value, consistent_read: true).attributes
+      options = { consistent_read: true }
+
+      if self.class.range_key
+        options[:range_key] = range_value
+      end
+
+      self.attributes = self.class.find(hash_key, options).attributes
       @associations.values.each(&:reset)
       self
     end
@@ -259,30 +351,44 @@ module Dynamoid #:nodoc:
     #
     # @since 0.4.0
     def hash_key
-      self.send(self.class.hash_key)
+      send(self.class.hash_key)
     end
 
     # Assign an object's hash key, regardless of what it might be called to the object.
     #
     # @since 0.4.0
     def hash_key=(value)
-      self.send("#{self.class.hash_key}=", value)
+      send("#{self.class.hash_key}=", value)
     end
 
     def range_value
       if range_key = self.class.range_key
-        self.send(range_key)
+        send(range_key)
       end
     end
 
     def range_value=(value)
-      self.send("#{self.class.range_key}=", value)
+      send("#{self.class.range_key}=", value)
     end
 
     private
 
     def dumped_range_value
-      dump_field(range_value, self.class.attributes[self.class.range_key])
+      Dumping.dump_field(range_value, self.class.attributes[self.class.range_key])
+    end
+
+    # Evaluates the default value given, this is used by undump
+    # when determining the value of the default given for a field options.
+    #
+    # @param [Object] :value the attribute's default value
+    def evaluate_default_value(val)
+      if val.respond_to?(:call)
+        val.call
+      elsif val.duplicable?
+        val.dup
+      else
+        val
+      end
     end
   end
 end

data/lib/dynamoid/dumping.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Dumping
+    def self.dump_attributes(attributes, attributes_options)
+      {}.tap do |h|
+        attributes.each do |attribute, value|
+          h[attribute] = dump_field(value, attributes_options[attribute])
+        end
+      end
+    end
+
+    def self.dump_field(value, options)
+      dumper = field_dumper(options)
+
+      if dumper.nil?
+        raise ArgumentError, "Unknown type #{options[:type]}"
+      end
+
+      dumper.process(value)
+    end
+
+    def self.field_dumper(options)
+      dumper_class = case options[:type]
+                     when :string     then StringDumper
+                     when :integer    then IntegerDumper
+                     when :number     then NumberDumper
+                     when :set        then SetDumper
+                     when :array      then ArrayDumper
+                     when :datetime   then DateTimeDumper
+                     when :date       then DateDumper
+                     when :serialized then SerializedDumper
+                     when :raw        then RawDumper
+                     when :boolean    then BooleanDumper
+                     when Class       then CustomTypeDumper
+                     end
+
+      if dumper_class.present?
+        dumper_class.new(options)
+      end
+    end
+
+    class Base
+      def initialize(options)
+        @options = options
+      end
+
+      def process(value)
+        value
+      end
+    end
+
+    # string -> string
+    class StringDumper < Base
+    end
+
+    # integer -> number
+    class IntegerDumper < Base
+    end
+
+    # number -> number
+    class NumberDumper < Base
+    end
+
+    # set -> set
+    class SetDumper < Base
+    end
+
+    # array -> array
+    class ArrayDumper < Base
+    end
+
+    # datetime -> integer/string
+    class DateTimeDumper < Base
+      def process(value)
+        !value.nil? ? format_datetime(value, @options) : nil
+      end
+
+      private
+
+      def format_datetime(value, options)
+        use_string_format = if options[:store_as_string].nil?
+                              Dynamoid.config.store_datetime_as_string
+                            else
+                              options[:store_as_string]
+                            end
+
+        if use_string_format
+          value_in_time_zone = Dynamoid::DynamodbTimeZone.in_time_zone(value)
+          value_in_time_zone.iso8601
+        else
+          unless value.respond_to?(:to_i) && value.respond_to?(:nsec)
+            value = value.to_time
+          end
+          BigDecimal(format('%d.%09d', value.to_i, value.nsec))
+        end
+      end
+    end
+
+    # date -> integer/string
+    class DateDumper < Base
+      def process(value)
+        !value.nil? ? format_date(value, @options) : nil
+      end
+
+      private
+
+      def format_date(value, options)
+        use_string_format = if options[:store_as_string].nil?
+                              Dynamoid.config.store_date_as_string
+                            else
+                              options[:store_as_string]
+                            end
+
+        if use_string_format
+          value.to_date.iso8601
+        else
+          (value.to_date - Dynamoid::Persistence::UNIX_EPOCH_DATE).to_i
+        end
+      end
+    end
+
+    # any standard Ruby object -> self
+    class RawDumper < Base
+    end
+
+    # object -> string
+    class SerializedDumper < Base
+      def process(value)
+        @options[:serializer] ? @options[:serializer].dump(value) : value.to_yaml
+      end
+    end
+
+    # True/False -> True/False/string
+    class BooleanDumper < Base
+      def process(value)
+        unless value.nil?
+          store_as_boolean = if @options[:store_as_native_boolean].nil?
+                               Dynamoid.config.store_boolean_as_native
+                             else
+                               @options[:store_as_native_boolean]
+                             end
+          if store_as_boolean
+            !!value
+          else
+            value.to_s[0] # => "f" or "t"
+          end
+        end
+      end
+    end
+
+    # any object -> string
+    class CustomTypeDumper < Base
+      def process(value)
+        field_class = @options[:type]
+
+        if value.respond_to?(:dynamoid_dump)
+          value.dynamoid_dump
+        elsif field_class.respond_to?(:dynamoid_dump)
+          field_class.dynamoid_dump(value)
+        else
+          raise ArgumentError, "Neither #{field_class} nor #{value} supports serialization for Dynamoid."
+        end
+      end
+    end
+  end
+end