dynamoid 2.2.0 → 3.0.0

data/lib/dynamoid/primary_key_type_mapping.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  class PrimaryKeyTypeMapping
+    def self.dynamodb_type(type, options)
+      if Class === type
+        type = type.respond_to?(:dynamoid_field_type) ? type.dynamoid_field_type : :string
+      end
+
+      case type
+      when :string, :serialized
+        :string
+      when :integer, :number
+        :number
+      when :datetime
+        string_format = if options[:store_as_string].nil?
+                          Dynamoid::Config.store_datetime_as_string
+                        else
+                          options[:store_as_string]
+                        end
+        string_format ? :string : :number
+      when :date
+        string_format = if options[:store_as_string].nil?
+                          Dynamoid::Config.store_date_as_string
+                        else
+                          options[:store_as_string]
+                        end
+        string_format ? :string : :number
+      else
+        raise Errors::UnsupportedKeyType, "#{type} cannot be used as a type of table key attribute"
+      end
+    end
+  end
+end

data/lib/dynamoid/railtie.rb

@@ -1,4 +1,6 @@
-if defined? (Rails)
+# frozen_string_literal: true
+
+if defined? Rails
 
   module Dynamoid
     class Railtie < Rails::Railtie

data/lib/dynamoid/tasks/database.rake

@@ -1,29 +1,31 @@
+# frozen_string_literal: true
+
 require 'dynamoid'
 require 'dynamoid/tasks/database'
 
 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
+  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" }
-      result.sort.each{ |r| puts r }
+      result = tables[:created].map { |c| "#{c} created" } + tables[:existing].map { |e| "#{e} already exists" }
+      result.sort.each { |r| puts r }
     else
-      puts "Dynamoid models are not loaded, or you have no Dynamoid models."
+      puts 'Dynamoid models are not loaded, or you have no Dynamoid models.'
     end
   end
 
   desc 'Tests if the DynamoDB instance can be contacted using your configuration'
-  task :ping => :environment do
+  task ping: :environment do
     success = false
     failure_reason = nil
 
     begin
       Dynamoid::Tasks::Database.ping
       success = true
-    rescue Exception => e
+    rescue StandardError => e
       failure_reason = e.message
     end
 
@@ -33,9 +35,7 @@ namespace :dynamoid do
            else
              ' at remote AWS endpoint'
            end
-    if not success
-      msg << ", reason being '#{failure_reason}'"
-    end
+    msg << ", reason being '#{failure_reason}'" unless success
     puts msg
   end
 end

data/lib/dynamoid/tasks/database.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Dynamoid
   module Tasks
     module Database
-      extend self
+      module_function
 
       # Create any new tables for the models. Existing tables are not
       # modified.
       def create_tables
         results = { created: [], existing: [] }
         # We can't quite rely on Dynamoid.included_models alone, we need to select only viable models
-        Dynamoid.included_models.select{ |m| not m.base_class.try(:name).blank? }.uniq(&:table_name).each do |model|
+        Dynamoid.included_models.reject { |m| m.base_class.try(:name).blank? }.uniq(&:table_name).each do |model|
           if Dynamoid.adapter.list_tables.include? model.table_name
             results[:existing] << model.table_name
           else
@@ -24,7 +26,6 @@ module Dynamoid
         Dynamoid.adapter.list_tables
         true
       end
-
     end
   end
 end

data/lib/dynamoid/type_casting.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module TypeCasting
+    def self.cast_attributes(attributes, attributes_options)
+      {}.tap do |h|
+        attributes.symbolize_keys.each do |attribute, value|
+          h[attribute] = cast_field(value, attributes_options[attribute])
+        end
+      end
+    end
+
+    def self.cast_field(value, options)
+      return value if options.nil?
+      return nil if value.nil?
+
+      type_caster = find_type_caster(options)
+      if type_caster.nil?
+        raise ArgumentError, "Unknown type #{options[:type]}"
+      end
+
+      type_caster.process(value)
+    end
+
+    def self.find_type_caster(options)
+      type_caster_class = case options[:type]
+                          when :string     then StringTypeCaster
+                          when :integer    then IntegerTypeCaster
+                          when :number     then NumberTypeCaster
+                          when :set        then SetTypeCaster
+                          when :array      then ArrayTypeCaster
+                          when :datetime   then DateTimeTypeCaster
+                          when :date       then DateTypeCaster
+                          when :raw        then RawTypeCaster
+                          when :serialized then SerializedTypeCaster
+                          when :boolean    then BooleanTypeCaster
+                          when Class       then CustomTypeCaster
+                          end
+
+      if type_caster_class.present?
+        type_caster_class.new(options)
+      end
+    end
+
+    class Base
+      def initialize(options)
+        @options = options
+      end
+
+      def process(value)
+        value
+      end
+    end
+
+    class StringTypeCaster < Base
+      def process(value)
+        if value == true
+          't'
+        elsif value == false
+          'f'
+        elsif value.is_a? String
+          value.dup
+        else
+          value.to_s
+        end
+      end
+    end
+
+    class IntegerTypeCaster < Base
+      def process(value)
+        if value == true
+          1
+        elsif value == false
+          0
+        elsif value.is_a?(String) && value.blank?
+          nil
+        elsif value.is_a?(Float) && !value.finite?
+          nil
+        elsif !value.respond_to?(:to_i)
+          nil
+        else
+          value.to_i
+        end
+      end
+    end
+
+    class NumberTypeCaster < Base
+      def process(value)
+        if value == true
+          1
+        elsif value == false
+          0
+        elsif value.is_a?(Symbol)
+          value.to_s.to_d
+        elsif value.is_a?(String) && value.blank?
+          nil
+        elsif value.is_a?(Float) && !value.finite?
+          nil
+        elsif !(value.respond_to?(:to_d))
+          nil
+        else
+          value.to_d
+        end
+      end
+    end
+
+    class SetTypeCaster < Base
+      def process(value)
+        if value.is_a?(Set)
+          value.dup
+        elsif value.respond_to?(:to_set)
+          value.to_set
+        else
+          nil
+        end
+      end
+    end
+
+    class ArrayTypeCaster < Base
+      def process(value)
+        if value.is_a?(Array)
+          value.dup
+        elsif value.respond_to?(:to_a)
+          value.to_a
+        else
+          nil
+        end
+      end
+    end
+
+    class DateTimeTypeCaster < Base
+      def process(value)
+        if !value.respond_to?(:to_datetime)
+          nil
+        elsif value.is_a?(String)
+          dt = DateTime.parse(value) rescue nil
+          if dt
+            seconds = string_utc_offset(value) || ApplicationTimeZone.utc_offset
+            offset = seconds_to_offset(seconds)
+            DateTime.new(dt.year, dt.mon, dt.mday, dt.hour, dt.min, dt.sec, offset)
+          end
+        else
+          value.to_datetime
+        end
+      end
+
+      private
+
+      def string_utc_offset(string)
+        Date._parse(string)[:offset]
+      end
+
+      # 3600 -> "+01:00"
+      def seconds_to_offset(seconds)
+        ActiveSupport::TimeZone.seconds_to_utc_offset(seconds)
+      end
+    end
+
+    class DateTypeCaster < Base
+      def process(value)
+        if !value.respond_to?(:to_date)
+          nil
+        else
+          begin
+            value.to_date
+          rescue ArgumentError
+          end
+        end
+      end
+    end
+
+    class RawTypeCaster < Base
+    end
+
+    class SerializedTypeCaster < Base
+    end
+
+    class BooleanTypeCaster < Base
+      def process(value)
+        if value == ''
+          nil
+        elsif [false, 'false', 'FALSE', 0, '0', 'f', 'F', 'off', 'OFF'].include? value
+          false
+        else
+          true
+        end
+      end
+    end
+
+    class CustomTypeCaster < Base
+    end
+  end
+end

data/lib/dynamoid/undumping.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+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])
+        end
+      end
+    end
+
+    def self.undump_field(value, options)
+      undumper = find_undumper(options)
+
+      if undumper.nil?
+        raise ArgumentError, "Unknown type #{options[:type]}"
+      end
+
+      return nil if value.nil?
+      undumper.process(value)
+    end
+
+    def self.find_undumper(options)
+      undumper_class = case options[:type]
+                       when :string     then StringUndumper
+                       when :integer    then IntegerUndumper
+                       when :number     then NumberUndumper
+                       when :set        then SetUndumper
+                       when :array      then ArrayUndumper
+                       when :datetime   then DateTimeUndumper
+                       when :date       then DateUndumper
+                       when :raw        then RawUndumper
+                       when :serialized then SerializedUndumper
+                       when :boolean    then BooleanUndumper
+                       when Class       then CustomTypeUndumper
+                       end
+
+      if undumper_class.present?
+        undumper_class.new(options)
+      end
+    end
+
+    class Base
+      def initialize(options)
+        @options = options
+      end
+
+      def process(value)
+        value
+      end
+    end
+
+    class StringUndumper < Base
+    end
+
+    class IntegerUndumper < Base
+      def process(value)
+        value.to_i
+      end
+    end
+
+    class NumberUndumper < Base
+    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
+        else
+          value.is_a?(Set) ? value : Set.new(value)
+        end
+      end
+    end
+
+    class ArrayUndumper < Base
+    end
+
+    class DateTimeUndumper < Base
+      def process(value)
+        return value if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+
+        use_string_format = if @options[:store_as_string].nil?
+                              Dynamoid.config.store_datetime_as_string
+                            else
+                              @options[:store_as_string]
+                            end
+        value = DateTime.iso8601(value).to_time.to_i if use_string_format
+        ApplicationTimeZone.at(value)
+      end
+    end
+
+    class DateUndumper < Base
+      def process(value)
+        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
+          Date.iso8601(value)
+        else
+          Dynamoid::Persistence::UNIX_EPOCH_DATE + value.to_i
+        end
+      end
+    end
+
+    class RawUndumper < Base
+      def process(value)
+        if value.is_a?(Hash)
+          undump_hash(value)
+        else
+          value
+        end
+      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
+    end
+
+    class SerializedUndumper < Base
+      def process(value)
+        if @options[:serializer]
+          @options[:serializer].load(value)
+        else
+          YAML.load(value)
+        end
+      end
+    end
+
+    class BooleanUndumper < Base
+      STRING_VALUES = ['t', 'f']
+
+      def process(value)
+        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
+        elsif STRING_VALUES.include?(value)
+          value == 't'
+        else
+          raise ArgumentError, 'Boolean column neither true nor false'
+        end
+      end
+    end
+
+    class CustomTypeUndumper < Base
+      def process(value)
+        field_class = @options[:type]
+
+        unless field_class.respond_to?(:dynamoid_load)
+          raise ArgumentError, "#{field_class} does not support serialization for Dynamoid."
+        end
+
+        field_class.dynamoid_load(value)
+      end
+    end
+  end
+end