dynamoid 3.1.0 → 3.2.0

data/lib/dynamoid/criteria/ignored_conditions_detector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Criteria
+    class IgnoredConditionsDetector
+      def initialize(conditions)
+        @conditions = conditions
+        @ignored_keys = ignored_keys
+      end
+
+      def found?
+        @ignored_keys.present?
+      end
+
+      def warning_message
+        return unless found?
+
+        'Where conditions may contain only one condition for an attribute. ' \
+          "Following conditions are ignored: #{ignored_conditions}"
+      end
+
+      private
+
+      def ignored_keys
+        @conditions.keys
+          .group_by(&method(:key_to_field))
+          .select { |field, ary| ary.size > 1 }
+          .flat_map { |field, ary| ary[0 .. -2] }
+      end
+
+      def key_to_field(key)
+        key.to_s.split('.')[0]
+      end
+
+      def ignored_conditions
+        @conditions.slice(*@ignored_keys)
+      end
+    end
+  end
+end
+

data/lib/dynamoid/criteria/key_fields_detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dynamoid #:nodoc:
+  module Criteria
+    class KeyFieldsDetector
+      attr_reader :hash_key, :range_key, :index_name
+
+      def initialize(query, source)
+        @query = query
+        @source = source
+
+        detect_keys
+      end
+
+      def key_present?
+        @hash_key.present?
+      end
+
+      private
+
+      def detect_keys
+        query_keys = @query.keys.collect { |k| k.to_s.split('.').first }
+
+        # See if querying based on table hash key
+        if @query.keys.map(&:to_s).include?(@source.hash_key.to_s)
+          @hash_key = @source.hash_key
+
+          # Use table's default range key
+          if query_keys.include?(@source.range_key.to_s)
+            @range_key = @source.range_key
+            return
+          end
+
+          # See if can use any local secondary index range key
+          # Chooses the first LSI found that can be utilized for the query
+          @source.local_secondary_indexes.each do |_, lsi|
+            next unless query_keys.include?(lsi.range_key.to_s)
+
+            @range_key = lsi.range_key
+            @index_name = lsi.name
+          end
+
+          return
+        end
+
+        # See if can use any global secondary index
+        # Chooses the first GSI found that can be utilized for the query
+        # But only do so if projects ALL attributes otherwise we won't
+        # get back full data
+        @source.global_secondary_indexes.each do |_, gsi|
+          next unless @query.keys.map(&:to_s).include?(gsi.hash_key.to_s) && gsi.projected_attributes == :all
+          next if @range_key.present? && !query_keys.include?(gsi.range_key.to_s)
+
+          @hash_key = gsi.hash_key
+          @range_key = gsi.range_key
+          @index_name = gsi.name
+        end
+      end
+    end
+  end
+end

data/lib/dynamoid/criteria/nonexistent_fields_detector.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Criteria
+    class NonexistentFieldsDetector
+      def initialize(conditions, source)
+        @conditions = conditions
+        @source = source
+        @nonexistent_fields = nonexistent_fields
+      end
+
+      def found?
+        @nonexistent_fields.present?
+      end
+
+      def warning_message
+        return unless found?
+
+        fields_list = @nonexistent_fields.map { |s| "`#{s}`" }.join(', ')
+        count = @nonexistent_fields.size
+
+        "where conditions contain nonexistent" \
+          " field #{ 'name'.pluralize(count) } #{ fields_list }"
+      end
+
+      private
+
+      def nonexistent_fields
+        fields_from_conditions - fields_existent
+      end
+
+      def fields_from_conditions
+        @conditions.keys.map { |s| s.to_s.split('.')[0].to_sym }
+      end
+
+      def fields_existent
+        @source.attributes.keys.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/dynamoid/criteria/overwritten_conditions_detector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dynamoid
+  module Criteria
+    class OverwrittenConditionsDetector
+      def initialize(conditions, conditions_new)
+        @conditions = conditions
+        @new_conditions = conditions_new
+        @overwritten_keys = overwritten_keys
+      end
+
+      def found?
+        @overwritten_keys.present?
+      end
+
+      def warning_message
+        return unless found?
+
+        'Where conditions may contain only one condition for an attribute. ' \
+          "Following conditions are ignored: #{ignored_conditions}"
+      end
+
+      private
+
+      def overwritten_keys
+        new_fields = @new_conditions.keys.map(&method(:key_to_field))
+        @conditions.keys.select { |key| key_to_field(key).in?(new_fields) }
+      end
+
+      def key_to_field(key)
+        key.to_s.split('.')[0]
+      end
+
+      def ignored_conditions
+        @conditions.slice(*@overwritten_keys.map(&:to_sym))
+      end
+    end
+  end
+end
+

data/lib/dynamoid/document.rb

@@ -33,6 +33,7 @@ module Dynamoid #:nodoc:
       end
 
       def attr_readonly(*read_only_attributes)
+        ActiveSupport::Deprecation.warn('[Dynamoid] .attr_readonly is deprecated! Call .find instead of')
         self.read_only_attributes.concat read_only_attributes.map(&:to_s)
       end
 
@@ -112,14 +113,28 @@ module Dynamoid #:nodoc:
 
       # Does this object exist?
       #
+      # Supports primary key in format that `find` call understands.
+      # Multiple keys and single compound primary key should be passed only as Array explicitily.
+      #
+      # Supports conditions in format that `where` call understands.
+      #
       # @param [Mixed] id_or_conditions the id of the object or a hash with the options to filter from.
       #
       # @return [Boolean] true/false
       #
+      # @example With id
+      #
+      #   Post.exist?(713)
+      #   Post.exist?([713, 210])
+      #
+      # @example With attributes conditions
+      #
+      #   Post.exist?(version: 1, 'created_at.gt': Time.now - 1.day)
+      #
       # @since 0.2.0
       def exists?(id_or_conditions = {})
         case id_or_conditions
-        when Hash then where(id_or_conditions).first.present?
+        when Hash then where(id_or_conditions).count >= 1
         else
           begin
             find(id_or_conditions)
@@ -205,7 +220,6 @@ module Dynamoid #:nodoc:
         end
       end
 
-
       # Update existing document or create new one.
       # Similar to `.update_fields`. The only diffirence is creating new document.
       #
@@ -267,7 +281,7 @@ module Dynamoid #:nodoc:
         end
       end
 
-      def inc(hash_key_value, range_key_value=nil, counters)
+      def inc(hash_key_value, range_key_value = nil, counters)
         options = if range_key
                     value_casted = TypeCasting.cast_field(range_key_value, attributes[range_key])
                     value_dumped = Dumping.dump_field(value_casted, attributes[range_key])
@@ -303,22 +317,12 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def initialize(attrs = {})
-      # we need this hack for Rails 4.0 only
-      # because `run_callbacks` calls `attributes` getter while it is still nil
-      @attributes = {}
-
       run_callbacks :initialize do
         @new_record = true
         @attributes ||= {}
         @associations ||= {}
         @attributes_before_type_cast ||= {}
 
-        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)
@@ -348,6 +352,7 @@ module Dynamoid #:nodoc:
         super
       else
         return false if other.nil?
+
         other.is_a?(Dynamoid::Document) && hash_key == other.hash_key && range_value == other.range_value
       end
     end

data/lib/dynamoid/dumping.rb

@@ -29,6 +29,7 @@ module Dynamoid
                      when :number     then NumberDumper
                      when :set        then SetDumper
                      when :array      then ArrayDumper
+                     when :map        then MapDumper
                      when :datetime   then DateTimeDumper
                      when :date       then DateDumper
                      when :serialized then SerializedDumper
@@ -42,6 +43,35 @@ module Dynamoid
       end
     end
 
+    module DeepSanitizeHelper
+      extend self
+
+      def deep_sanitize(value)
+        case value
+        when Hash
+          sanitize_hash(value).transform_values { |v| deep_sanitize(v) }
+        when Array
+          sanitize_array(value).map { |v| deep_sanitize(v) }
+        else
+          value
+        end
+      end
+
+      private
+
+      def sanitize_hash(hash)
+        hash.transform_values { |v| invalid_value?(v) ? nil : v }
+      end
+
+      def sanitize_array(array)
+        array.map { |v| invalid_value?(v) ? nil : v }
+      end
+
+      def invalid_value?(value)
+        (value.is_a?(Set) || value.is_a?(String)) && value.empty?
+      end
+    end
+
     class Base
       def initialize(options)
         @options = options
@@ -66,7 +96,7 @@ module Dynamoid
 
     # set -> set
     class SetDumper < Base
-      ALLOWED_TYPES = [:string, :integer, :number, :date, :datetime, :serialized]
+      ALLOWED_TYPES = %i[string integer number date datetime serialized].freeze
 
       def process(set)
         if @options.key?(:of)
@@ -98,27 +128,27 @@ module Dynamoid
       end
 
       def element_type
-        unless @options[:of].is_a?(Hash)
-          @options[:of]
-        else
+        if @options[:of].is_a?(Hash)
           @options[:of].keys.first
+        else
+          @options[:of]
         end
       end
 
       def element_options
-        unless @options[:of].is_a?(Hash)
-          { type: element_type }
-        else
+        if @options[:of].is_a?(Hash)
           @options[:of][element_type].dup.tap do |options|
             options[:type] = element_type
           end
+        else
+          { type: element_type }
         end
       end
     end
 
     # array -> array
     class ArrayDumper < Base
-      ALLOWED_TYPES = [:string, :integer, :number, :date, :datetime, :serialized]
+      ALLOWED_TYPES = %i[string integer number date datetime serialized].freeze
 
       def process(array)
         if @options.key?(:of)
@@ -150,24 +180,31 @@ module Dynamoid
       end
 
       def element_type
-        unless @options[:of].is_a?(Hash)
-          @options[:of]
-        else
+        if @options[:of].is_a?(Hash)
           @options[:of].keys.first
+        else
+          @options[:of]
         end
       end
 
       def element_options
-        unless @options[:of].is_a?(Hash)
-          { type: element_type }
-        else
+        if @options[:of].is_a?(Hash)
           @options[:of][element_type].dup.tap do |options|
             options[:type] = element_type
           end
+        else
+          { type: element_type }
         end
       end
     end
 
+    # hash -> map
+    class MapDumper < Base
+      def process(value)
+        DeepSanitizeHelper.deep_sanitize(value)
+      end
+    end
+
     # datetime -> integer/string
     class DateTimeDumper < Base
       def process(value)
@@ -221,32 +258,7 @@ module Dynamoid
     # any standard Ruby object -> self
     class RawDumper < Base
       def process(value)
-        deep_sanitize(value)
-      end
-
-      private
-
-      def deep_sanitize(el)
-        case el
-        when Hash
-          sanitize_hash(el).transform_values { |v| deep_sanitize(v) }
-        when Array
-          sanitize_array(el).map { |v| deep_sanitize(v) }
-        else
-          el
-        end
-      end
-
-      def sanitize_hash(h)
-        h.transform_values { |v| invalid_value?(v) ? nil : v }
-      end
-
-      def sanitize_array(a)
-        a.map { |v| invalid_value?(v) ? nil : v }
-      end
-
-      def invalid_value?(v)
-        (v.is_a?(Set) || v.is_a?(String)) && v.empty?
+        DeepSanitizeHelper.deep_sanitize(value)
       end
     end
 

data/lib/dynamoid/fields.rb

@@ -89,7 +89,7 @@ module Dynamoid #:nodoc:
           remove_method field
           remove_method :"#{field}="
           remove_method :"#{field}?"
-          remove_method:"#{field}_before_type_cast"
+          remove_method :"#{field}_before_type_cast"
         end
       end
 
@@ -148,6 +148,7 @@ module Dynamoid #:nodoc:
     # @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
 
@@ -174,8 +175,8 @@ module Dynamoid #:nodoc:
       # 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)
+      if self.class.attributes[type] && send(type).nil?
+        send("#{type}=", self.class.name)
       end
     end
   end