dynamoid 2.2.0 → 3.0.0

data/lib/dynamoid/indexes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Indexes
     extend ActiveSupport::Concern
@@ -27,20 +29,18 @@ module Dynamoid
       #         index; does not work on existing indexes.
       # @option options [Integer] :write_capacity set the write capacity for
       #         the index; does not work on existing indexes.
-      def global_secondary_index(options={})
+      def global_secondary_index(options = {})
         unless options.present?
-          raise Dynamoid::Errors::InvalidIndex.new('empty index definition')
+          raise Dynamoid::Errors::InvalidIndex, 'empty index definition'
         end
 
         unless options[:hash_key].present?
-          raise Dynamoid::Errors::InvalidIndex.new(
-            'A global secondary index requires a :hash_key to be specified'
-          )
+          raise Dynamoid::Errors::InvalidIndex, 'A global secondary index requires a :hash_key to be specified'
         end
 
         index_opts = {
-            read_capacity: Dynamoid::Config.read_capacity,
-            write_capacity: Dynamoid::Config.write_capacity
+          read_capacity: Dynamoid::Config.read_capacity,
+          write_capacity: Dynamoid::Config.write_capacity
         }.merge(options)
 
         index_opts[:dynamoid_class] = self
@@ -48,7 +48,7 @@ module Dynamoid
 
         index = Dynamoid::Indexes::Index.new(index_opts)
         gsi_key = index_key(options[:hash_key], options[:range_key])
-        self.global_secondary_indexes[gsi_key] = index
+        global_secondary_indexes[gsi_key] = index
         self
       end
 
@@ -63,38 +63,39 @@ module Dynamoid
       #         attributes to project for this index. Can be :keys_only, :all
       #         or an array of included fields. If not specified, defaults to
       #         :keys_only.
-      def local_secondary_index(options={})
+      def local_secondary_index(options = {})
         unless options.present?
-          raise Dynamoid::Errors::InvalidIndex.new('empty index definition')
+          raise Dynamoid::Errors::InvalidIndex, 'empty index definition'
         end
 
-        primary_hash_key = self.hash_key
-        primary_range_key = self.range_key
+        primary_hash_key = hash_key
+        primary_range_key = range_key
         index_range_key = options[:range_key]
 
         unless index_range_key.present?
-          raise Dynamoid::Errors::InvalidIndex.new('A local secondary index '\
-            'requires a :range_key to be specified')
+          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index '\
+            'requires a :range_key to be specified'
         end
 
         if primary_range_key.present? && index_range_key == primary_range_key
-          raise Dynamoid::Errors::InvalidIndex.new('A local secondary index'\
-            ' must use a different :range_key than the primary key')
+          raise Dynamoid::Errors::InvalidIndex, 'A local secondary index'\
+            ' must use a different :range_key than the primary key'
         end
 
         index_opts = options.merge(
           dynamoid_class: self,
           type: :local_secondary,
-          hash_key: primary_hash_key)
+          hash_key: primary_hash_key
+        )
 
         index = Dynamoid::Indexes::Index.new(index_opts)
         key = index_key(primary_hash_key, index_range_key)
-        self.local_secondary_indexes[key] = index
+        local_secondary_indexes[key] = index
         self
       end
 
-      def find_index(hash, range=nil)
-        index = self.indexes[index_key(hash, range)]
+      def find_index(hash, range = nil)
+        index = indexes[index_key(hash, range)]
         index
       end
 
@@ -105,8 +106,8 @@ module Dynamoid
       # @param [Symbol] range range key name.
       # @return [Boolean] true iff provided keys correspond to a local
       #         secondary index.
-      def is_local_secondary_index?(hash, range=nil)
-        self.local_secondary_indexes[index_key(hash, range)].present?
+      def is_local_secondary_index?(hash, range = nil)
+        local_secondary_indexes[index_key(hash, range)].present?
       end
 
       # Returns true iff the provided hash[,range] key combo is a global
@@ -116,8 +117,8 @@ module Dynamoid
       # @param [Symbol] range range key name.
       # @return [Boolean] true iff provided keys correspond to a global
       #         secondary index.
-      def is_global_secondary_index?(hash, range=nil)
-        self.global_secondary_indexes[index_key(hash, range)].present?
+      def is_global_secondary_index?(hash, range = nil)
+        global_secondary_indexes[index_key(hash, range)].present?
       end
 
       # Generates a convenient lookup key name for a hash/range index.
@@ -126,11 +127,9 @@ module Dynamoid
       # @param [Symbol] hash hash key name.
       # @param [Symbol] range range key name.
       # @return [String] returns "hash" if hash only, "hash_range" otherwise.
-      def index_key(hash, range=nil)
+      def index_key(hash, range = nil)
         name = hash.to_s
-        if range.present?
-          name += "_#{range.to_s}"
-        end
+        name += "_#{range}" if range.present?
         name
       end
 
@@ -139,8 +138,8 @@ module Dynamoid
       # @param [Symbol] hash hash key name.
       # @param [Symbol] range range key name.
       # @return [String] index name of the form "table_name_index_index_key".
-      def index_name(hash, range=nil)
-        "#{self.table_name}_index_#{self.index_key(hash, range)}"
+      def index_name(hash, range = nil)
+        "#{table_name}_index_#{index_key(hash, range)}"
       end
 
       # Convenience method to return all indexes on the table.
@@ -148,11 +147,11 @@ module Dynamoid
       # @return [Hash<String, Object>] the combined hash of global and local
       #         secondary indexes.
       def indexes
-        self.local_secondary_indexes.merge(self.global_secondary_indexes)
+        local_secondary_indexes.merge(global_secondary_indexes)
       end
 
       def indexed_hash_keys
-        self.global_secondary_indexes.map do |name, index|
+        global_secondary_indexes.map do |_name, index|
           index.hash_key.to_s
         end
       end
@@ -162,12 +161,12 @@ module Dynamoid
     class Index
       include ActiveModel::Validations
 
-      PROJECTION_TYPES = [:keys_only, :all].to_set
+      PROJECTION_TYPES = %i[keys_only all].to_set
       DEFAULT_PROJECTION_TYPE = :keys_only
 
       attr_accessor :name, :dynamoid_class, :type, :hash_key, :range_key,
-          :hash_key_schema, :range_key_schema, :projected_attributes,
-          :read_capacity, :write_capacity
+        :hash_key_schema, :range_key_schema, :projected_attributes,
+        :read_capacity, :write_capacity
 
       validate do
         validate_index_type
@@ -176,9 +175,9 @@ module Dynamoid
         validate_projected_attributes
       end
 
-      def initialize(attrs={})
+      def initialize(attrs = {})
         unless attrs[:dynamoid_class].present?
-          raise Dynamoid::Errors::InvalidIndex.new(':dynamoid_class is required')
+          raise Dynamoid::Errors::InvalidIndex, ':dynamoid_class is required'
         end
 
         @dynamoid_class = attrs[:dynamoid_class]
@@ -187,11 +186,11 @@ module Dynamoid
         @range_key = attrs[:range_key]
         @name = attrs[:name] || @dynamoid_class.index_name(@hash_key, @range_key)
         @projected_attributes =
-            attrs[:projected_attributes] || DEFAULT_PROJECTION_TYPE
+          attrs[:projected_attributes] || DEFAULT_PROJECTION_TYPE
         @read_capacity = attrs[:read_capacity]
         @write_capacity = attrs[:write_capacity]
 
-        raise Dynamoid::Errors::InvalidIndex.new(self) unless self.valid?
+        raise Dynamoid::Errors::InvalidIndex, self unless valid?
       end
 
       # Convenience method to determine the projection type for an index.
@@ -209,16 +208,16 @@ module Dynamoid
       private
 
       def validate_projected_attributes
-        unless (@projected_attributes.is_a?(Array) ||
-                PROJECTION_TYPES.include?(@projected_attributes))
+        unless @projected_attributes.is_a?(Array) ||
+               PROJECTION_TYPES.include?(@projected_attributes)
           errors.add(:projected_attributes, 'Invalid projected attributes specified.')
         end
       end
 
       def validate_index_type
-        unless (@type.present? &&
-          [:local_secondary, :global_secondary].include?(@type))
-            errors.add(:type, 'Invalid index :type specified')
+        unless @type.present? &&
+               %i[local_secondary global_secondary].include?(@type)
+          errors.add(:type, 'Invalid index :type specified')
         end
       end
 
@@ -229,7 +228,7 @@ module Dynamoid
             range_key_type = range_field_attributes[:type]
             if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(range_key_type)
               @range_key_schema = {
-                @range_key => @dynamoid_class.dynamo_type(range_key_type)
+                @range_key => PrimaryKeyTypeMapping.dynamodb_type(range_key_type, range_field_attributes)
               }
             else
               errors.add(:range_key, 'Index :range_key is not a valid key type')
@@ -246,7 +245,7 @@ module Dynamoid
           hash_field_type = hash_field_attributes[:type]
           if Dynamoid::Fields::PERMITTED_KEY_TYPES.include?(hash_field_type)
             @hash_key_schema = {
-              @hash_key => @dynamoid_class.dynamo_type(hash_field_type)
+              @hash_key => PrimaryKeyTypeMapping.dynamodb_type(hash_field_type, hash_field_attributes)
             }
           else
             errors.add(:hash_key, 'Index :hash_key is not a valid key type')

data/lib/dynamoid/middleware/identity_map.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Middleware
     class IdentityMap

data/lib/dynamoid/persistence.rb

@@ -1,25 +1,25 @@
+# frozen_string_literal: true
+
 require 'bigdecimal'
 require 'securerandom'
 require 'yaml'
 
 # encoding: utf-8
 module Dynamoid
-
   # Persistence is responsible for dumping objects to and marshalling objects from the datastore. It tries to reserialize
   # values to be of the same type as when they were passed in, based on the fields in the class.
   module Persistence
     extend ActiveSupport::Concern
 
     attr_accessor :new_record
-    alias :new_record? :new_record
+    alias new_record? new_record
 
     UNIX_EPOCH_DATE = Date.new(1970, 1, 1).freeze
 
     module ClassMethods
-
       def table_name
         table_base_name = options[:name] || base_class.name.split('::').last
-          .downcase.pluralize
+                                                      .downcase.pluralize
 
         @table_name ||= [Dynamoid::Config.namespace.to_s, table_base_name].reject(&:empty?).join('_')
       end
@@ -35,20 +35,19 @@ module Dynamoid
       # @option options [Symbol] :hash_key_type the dynamo type of the hash key (:string or :number)
       # @since 0.4.0
       def create_table(options = {})
-        if self.range_key
-          range_key_hash = { range_key => dynamo_type(attributes[range_key][:type]) }
-        else
-          range_key_hash = nil
-        end
+        range_key_hash = if range_key
+                           { range_key => PrimaryKeyTypeMapping.dynamodb_type(attributes[range_key][:type], attributes[range_key]) }
+                         end
+
         options = {
-          id: self.hash_key,
-          table_name: self.table_name,
-          write_capacity: self.write_capacity,
-          read_capacity: self.read_capacity,
+          id: hash_key,
+          table_name: table_name,
+          write_capacity: write_capacity,
+          read_capacity: read_capacity,
           range_key: range_key_hash,
-          hash_key_type: dynamo_type(attributes[self.hash_key][:type]),
-          local_secondary_indexes: self.local_secondary_indexes.values,
-          global_secondary_indexes: self.global_secondary_indexes.values
+          hash_key_type: PrimaryKeyTypeMapping.dynamodb_type(attributes[hash_key][:type], attributes[hash_key]),
+          local_secondary_indexes: local_secondary_indexes.values,
+          global_secondary_indexes: global_secondary_indexes.values
         }.merge(options)
 
         Dynamoid.adapter.create_table(options[:table_name], options[:id], options)
@@ -56,160 +55,13 @@ module Dynamoid
 
       # Deletes the table for the model
       def delete_table
-        Dynamoid.adapter.delete_table(self.table_name)
+        Dynamoid.adapter.delete_table(table_name)
       end
 
       def from_database(attrs = {})
         clazz = attrs[:type] ? obj = attrs[:type].constantize : self
-        clazz.new(attrs).tap { |r| r.new_record = false }
-      end
-
-      # Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.
-      #
-      # @since 0.2.0
-      def undump(incoming = nil)
-        incoming = (incoming || {}).symbolize_keys
-        Hash.new.tap do |hash|
-          self.attributes.each do |attribute, options|
-            if incoming.has_key?(attribute)
-              hash[attribute] = undump_field(incoming[attribute], options)
-            elsif options.has_key?(:default)
-              hash[attribute] = evaluate_default_value(options[:default])
-            else
-              hash[attribute] = nil
-            end
-          end
-          incoming.each {|attribute, value| hash[attribute] = value unless hash.has_key? attribute }
-        end
-      end
-
-      # Undump a string value for a given type.
-      #
-      # @since 0.2.0
-      def undump_field(value, options)
-        if (field_class = options[:type]).is_a?(Class)
-          raise 'Dynamoid class-type fields do not support default values' if options[:default]
-
-          if field_class.respond_to?(:dynamoid_load)
-            field_class.dynamoid_load(value)
-          end
-        elsif options[:type] == :serialized
-          if value.is_a?(String)
-            options[:serializer] ? options[:serializer].load(value) : YAML.load(value)
-          else
-            value
-          end
-        else
-          unless value.nil?
-            case options[:type]
-              when :string
-                value.to_s
-              when :integer
-                Integer(value)
-              when :number
-                BigDecimal.new(value.to_s)
-              when :array
-                value.to_a
-              when :raw
-                if value.is_a?(Hash)
-                  undump_hash(value)
-                else
-                  value
-                end
-              when :set
-                undump_set(options, value)
-              when :datetime
-                parse_datetime(value, options)
-              when :date
-                if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
-                  value.to_date
-                else
-                  parse_date(value, options)
-                end
-              when :boolean
-                if value == 't' || value == true
-                  true
-                elsif value == 'f' || value == false
-                  false
-                else
-                  raise ArgumentError, 'Boolean column neither true nor false'
-                end
-              else
-                raise ArgumentError, "Unknown type #{options[:type]}"
-            end
-          end
-        end
-      end
-
-      def undump_set(options, value)
-        case options[:of]
-        when :integer
-          value.map { |v| Integer(v) }.to_set
-        when :number
-          value.map { |v| BigDecimal.new(v.to_s) }.to_set
-        else
-          value.is_a?(Set) ? value : Set.new(value)
-        end
-      end
-
-      def dump_field(value, options)
-        if (field_class = options[:type]).is_a?(Class)
-          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} support serialization for Dynamoid."
-          end
-        else
-          case options[:type]
-            when :string
-              !value.nil? ? value.to_s : nil
-            when :integer
-              !value.nil? ? Integer(value) : nil
-            when :number
-              !value.nil? ? value : nil
-            when :set
-              !value.nil? ? Set.new(value) : nil
-            when :array
-              !value.nil? ? value : nil
-            when :datetime
-              !value.nil? ? format_datetime(value, options) : nil
-            when :date
-              !value.nil? ? format_date(value, options) : nil
-            when :serialized
-              options[:serializer] ? options[:serializer].dump(value) : value.to_yaml
-            when :raw
-              !value.nil? ? value : nil
-            when :boolean
-              if !value.nil?
-                if options[:store_as_native_boolean]
-                  !!value # native boolean type
-                else
-                  value.to_s[0] # => "f" or "t"
-                end
-              else
-                nil
-              end
-            else
-              raise ArgumentError, "Unknown type #{options[:type]}"
-          end
-        end
-      end
-
-      def dynamo_type(type)
-        if type.is_a?(Class)
-          type.respond_to?(:dynamoid_field_type) ? type.dynamoid_field_type : :string
-        else
-          case type
-            when :integer, :number, :datetime, :date
-              :number
-            when :string, :serialized
-              :string
-            else
-              raise 'unknown type'
-          end
-        end
+        attrs_undumped = Undumping.undump_attributes(attrs, clazz.attributes)
+        clazz.new(attrs_undumped).tap { |r| r.new_record = false }
       end
 
       # Creates several models at once.
@@ -226,16 +78,27 @@ module Dynamoid
       #   User.import([{ name: 'a' }, { name: 'b' }])
       def import(objects)
         documents = objects.map do |attrs|
-          self.build(attrs).tap do |item|
+          attrs = attrs.symbolize_keys
+
+          if Dynamoid::Config.timestamps
+            time_now = DateTime.now.in_time_zone(Time.zone)
+            attrs[:created_at] ||= time_now
+            attrs[:updated_at] ||= time_now
+          end
+
+          build(attrs).tap do |item|
             item.hash_key = SecureRandom.uuid if item.hash_key.blank?
           end
         end
 
-        unless Dynamoid.config.backoff
-          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump))
-        else
+        if Dynamoid.config.backoff
           backoff = nil
-          Dynamoid.adapter.batch_write_item(self.table_name, documents.map(&:dump)) do |has_unprocessed_items|
+
+          array = documents.map do |d|
+            Dumping.dump_attributes(d.attributes, attributes)
+          end
+
+          Dynamoid.adapter.batch_write_item(table_name, array) do |has_unprocessed_items|
             if has_unprocessed_items
               backoff ||= Dynamoid.config.build_backoff
               backoff.call
@@ -243,106 +106,16 @@ module Dynamoid
               backoff = nil
             end
           end
-        end
-
-        documents.each { |d| d.new_record = false }
-        documents
-      end
-
-      private
-
-      def undump_hash(hash)
-        {}.tap do |h|
-          hash.each { |key, value| h[key.to_sym] = undump_hash_value(value) }
-        end
-      end
-
-      def undump_hash_value(val)
-        case val
-        when BigDecimal
-          if Dynamoid::Config.convert_big_decimal
-            val.to_f
-          else
-            val
-          end
-        when Hash
-          undump_hash(val)
-        when Array
-          val.map { |v| undump_hash_value(v) }
-        else
-          val
-        end
-      end
-
-      def format_datetime(value, options)
-        use_string_format = options[:store_as_string].nil? \
-          ? Dynamoid.config.store_datetime_as_string \
-          : options[:store_as_string]
-
-        if use_string_format
-          value.to_time.iso8601
         else
-          unless value.respond_to?(:to_i) && value.respond_to?(:nsec)
-            value = value.to_time
+          array = documents.map do |d|
+            Dumping.dump_attributes(d.attributes, attributes)
           end
-          BigDecimal("%d.%09d" % [value.to_i, value.nsec])
-        end
-      end
-
-      def format_date(value, options)
-        use_string_format = options[:store_as_string].nil? \
-          ? Dynamoid.config.store_date_as_string \
-          : options[:store_as_string]
-
-        unless use_string_format
-          (value.to_date - UNIX_EPOCH_DATE).to_i
-        else
-          value.to_date.iso8601
-        end
-      end
-
-      def parse_datetime(value, options)
-        return value if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
-
-        use_string_format = options[:store_as_string].nil? \
-          ? Dynamoid.config.store_datetime_as_string \
-          : options[:store_as_string]
-        value = DateTime.iso8601(value).to_time.to_i if use_string_format
-
-        case Dynamoid::Config.application_timezone
-          when :utc
-            ActiveSupport::TimeZone['UTC'].at(value).to_datetime
-          when :local
-            Time.at(value).to_datetime
-          when String
-            ActiveSupport::TimeZone[Dynamoid::Config.application_timezone].at(value).to_datetime
-        end
-      end
-
-      def parse_date(value, options)
-        use_string_format = options[:store_as_string].nil? \
-          ? Dynamoid.config.store_date_as_string \
-          : options[:store_as_string]
 
-        unless use_string_format
-          UNIX_EPOCH_DATE + value.to_i
-        else
-          Date.iso8601(value)
+          Dynamoid.adapter.batch_write_item(table_name, array)
         end
-      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
+        documents.each { |d| d.new_record = false }
+        documents
       end
     end
 
@@ -365,12 +138,12 @@ module Dynamoid
     # Run the callbacks and then persist this object in the datastore.
     #
     # @since 0.2.0
-    def save(options = {})
+    def save(_options = {})
       self.class.create_table
 
       if new_record?
-        conditions = { unless_exists: [self.class.hash_key]}
-        conditions[:unless_exists] << range_key if(range_key)
+        conditions = { unless_exists: [self.class.hash_key] }
+        conditions[:unless_exists] << range_key if range_key
 
         run_callbacks(:create) { persist(conditions) }
       else
@@ -383,19 +156,23 @@ module Dynamoid
     # never cause an update! to fail, but an update! may cause a concurrent save to fail.
     #
     #
-    def update!(conditions = {}, &block)
+    def update!(conditions = {})
       run_callbacks(:update) do
-        options = range_key ? {range_key: dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+        options = range_key ? { range_key: Dumping.dump_field(read_attribute(range_key), self.class.attributes[range_key]) } : {}
 
         begin
-          new_attrs = Dynamoid.adapter.update_item(self.class.table_name, self.hash_key, options.merge(conditions: conditions)) do |t|
-            if(self.class.attributes[:lock_version])
-              t.add(lock_version: 1)
+          new_attrs = Dynamoid.adapter.update_item(self.class.table_name, hash_key, options.merge(conditions: conditions)) do |t|
+            t.add(lock_version: 1) if self.class.attributes[:lock_version]
+
+            if Dynamoid::Config.timestamps
+              time_now = DateTime.now.in_time_zone(Time.zone)
+              time_now_dumped = Dumping.dump_field(time_now, self.class.attributes[:updated_at])
+              t.set(updated_at: time_now_dumped)
             end
 
             yield t
           end
-          load(new_attrs)
+          load(Undumping.undump_attributes(new_attrs, self.class.attributes))
         rescue Dynamoid::Errors::ConditionalCheckFailedException
           raise Dynamoid::Errors::StaleObjectError.new(self, 'update')
         end
@@ -414,81 +191,64 @@ module Dynamoid
     # @since 0.2.0
     def destroy
       ret = run_callbacks(:destroy) do
-        self.delete
+        delete
       end
-      (ret == false) ? false : self
+      ret == false ? false : self
     end
 
     def destroy!
-      destroy || raise(Dynamoid::Errors::RecordNotDestroyed.new(self))
+      destroy || (raise Dynamoid::Errors::RecordNotDestroyed, self)
     end
 
     # Delete this object from the datastore.
     #
     # @since 0.2.0
     def delete
-      options = range_key ? {range_key: dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+      options = range_key ? { range_key: Dumping.dump_field(read_attribute(range_key), self.class.attributes[range_key]) } : {}
 
       # Add an optimistic locking check if the lock_version column exists
-      if(self.class.attributes[:lock_version])
-        conditions = {if: {}}
+      if self.class.attributes[:lock_version]
+        conditions = { if: {} }
         conditions[:if][:lock_version] =
           if changes[:lock_version].nil?
-            self.lock_version
+            lock_version
           else
             changes[:lock_version][0]
           end
         options[:conditions] = conditions
       end
-      Dynamoid.adapter.delete(self.class.table_name, self.hash_key, options)
+      Dynamoid.adapter.delete(self.class.table_name, hash_key, options)
     rescue Dynamoid::Errors::ConditionalCheckFailedException
       raise Dynamoid::Errors::StaleObjectError.new(self, 'delete')
     end
 
-    # Dump this object's attributes into hash form, fit to be persisted into the datastore.
-    #
-    # @since 0.2.0
-    def dump
-      Hash.new.tap do |hash|
-        self.class.attributes.each do |attribute, options|
-          hash[attribute] = dump_field(self.read_attribute(attribute), options)
-        end
-      end
-    end
-
     private
 
-    # Determine how to dump this field. Given a value, it'll determine how to turn it into a value that can be
-    # persisted into the datastore.
-    #
-    # @since 0.2.0
-    def dump_field(value, options)
-      self.class.dump_field(value, options)
-    end
-
     # Persist the object into the datastore. Assign it an id first if it doesn't have one.
     #
     # @since 0.2.0
     def persist(conditions = nil)
       run_callbacks(:save) do
-        self.hash_key = SecureRandom.uuid if self.hash_key.blank?
+        self.hash_key = SecureRandom.uuid if hash_key.blank?
 
         # Add an exists check to prevent overwriting existing records with new ones
-        if(new_record?)
+        if new_record?
           conditions ||= {}
           (conditions[:unless_exists] ||= []) << self.class.hash_key
         end
 
         # Add an optimistic locking check if the lock_version column exists
-        if(self.class.attributes[:lock_version])
+        if self.class.attributes[:lock_version]
           conditions ||= {}
           self.lock_version = (lock_version || 0) + 1
           # Uses the original lock_version value from ActiveModel::Dirty in case user changed lock_version manually
-          (conditions[:if] ||= {})[:lock_version] = changes[:lock_version][0] if(changes[:lock_version][0])
+          (conditions[:if] ||= {})[:lock_version] = changes[:lock_version][0] if changes[:lock_version][0]
         end
 
+        attributes_dumped = Dumping.dump_attributes(attributes, self.class.attributes)
+
         begin
-          Dynamoid.adapter.write(self.class.table_name, self.dump, conditions)
+          Dynamoid.adapter.write(self.class.table_name, attributes_dumped, conditions)
           @new_record = false
           true
         rescue Dynamoid::Errors::ConditionalCheckFailedException => e