Rename KeysDetector to KeyFieldsDetector

Author: andrykonchin

lib/dynamoid/criteria/chain.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require_relative 'keys_detector'
+require_relative 'key_fields_detector'
 require_relative 'nonexistent_fields_detector'
 
 module Dynamoid #:nodoc:
   module Criteria
     # The criteria chain is equivalent to an ActiveRecord relation (and realistically I should change the name from
     # chain to relation). It is a chainable object that builds up a query and eventually executes it by a Query or Scan.
     class Chain
-      attr_reader :query, :source, :consistent_read, :keys_detector
+      attr_reader :query, :source, :consistent_read, :key_fields_detector
 
       include Enumerable
       # Create a new criteria chain.
@@ -27,7 +27,7 @@ def initialize(source)
         end
 
         # we should re-initialize keys detector every time we change query
-        @keys_detector = KeysDetector.new(@query, @source)
+        @key_fields_detector = KeyFieldsDetector.new(@query, @source)
       end
 
       # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the
@@ -57,7 +57,7 @@ def where(args)
         end
 
         # we should re-initialize keys detector every time we change query
-        @keys_detector = KeysDetector.new(@query, @source)
+        @key_fields_detector = KeyFieldsDetector.new(@query, @source)
 
         self
       end
@@ -75,7 +75,7 @@ def all
       end
 
       def count
-        if @keys_detector.key_present?
+        if @key_fields_detector.key_present?
           count_via_query
         else
           count_via_scan
@@ -96,7 +96,7 @@ def delete_all
         ids = []
         ranges = []
 
-        if @keys_detector.key_present?
+        if @key_fields_detector.key_present?
           Dynamoid.adapter.query(source.table_name, range_query).flat_map{ |i| i }.collect do |hash|
             ids << hash[source.hash_key.to_sym]
             ranges << hash[source.range_key.to_sym] if source.range_key
@@ -171,7 +171,7 @@ def records
       #
       # @since 3.1.0
       def pages
-        if @keys_detector.key_present?
+        if @key_fields_detector.key_present?
           pages_via_query
         else
           issue_scan_warning if Dynamoid::Config.warn_on_scan && query.present?
@@ -279,24 +279,24 @@ def range_query
         opts = {}
 
         # Add hash key
-        opts[:hash_key] = @keys_detector.hash_key
-        opts[:hash_value] = type_cast_condition_parameter(@keys_detector.hash_key, query[@keys_detector.hash_key])
+        opts[:hash_key] = @key_fields_detector.hash_key
+        opts[:hash_value] = type_cast_condition_parameter(@key_fields_detector.hash_key, query[@key_fields_detector.hash_key])
 
         # Add range key
-        if @keys_detector.range_key
-          opts[:range_key] = @keys_detector.range_key
-          if query[@keys_detector.range_key].present?
-            value = type_cast_condition_parameter(@keys_detector.range_key, query[@keys_detector.range_key])
+        if @key_fields_detector.range_key
+          opts[:range_key] = @key_fields_detector.range_key
+          if query[@key_fields_detector.range_key].present?
+            value = type_cast_condition_parameter(@key_fields_detector.range_key, query[@key_fields_detector.range_key])
             opts.update(range_eq: value)
           end
 
-          query.keys.select { |k| k.to_s =~ /^#{@keys_detector.range_key}\./ }.each do |key|
+          query.keys.select { |k| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }.each do |key|
             opts.merge!(range_hash(key))
           end
         end
 
-        (query.keys.map(&:to_sym) - [@keys_detector.hash_key.to_sym, @keys_detector.range_key.try(:to_sym)])
-          .reject { |k, _| k.to_s =~ /^#{@keys_detector.range_key}\./ }
+        (query.keys.map(&:to_sym) - [@key_fields_detector.hash_key.to_sym, @key_fields_detector.range_key.try(:to_sym)])
+          .reject { |k, _| k.to_s =~ /^#{@key_fields_detector.range_key}\./ }
           .each do |key|
           if key.to_s.include?('.')
             opts.update(field_hash(key))
@@ -331,8 +331,8 @@ def type_cast_condition_parameter(key, value)
       def start_key
         return @start if @start.is_a?(Hash)
 
-        hash_key = @keys_detector.hash_key || source.hash_key
-        range_key = @keys_detector.range_key || source.range_key
+        hash_key = @key_fields_detector.hash_key || source.hash_key
+        range_key = @key_fields_detector.range_key || source.range_key
 
         key = {}
         key[hash_key] = type_cast_condition_parameter(hash_key, @start.send(hash_key))
@@ -351,7 +351,7 @@ def start_key
 
       def query_opts
         opts = {}
-        opts[:index_name] = @keys_detector.index_name if @keys_detector.index_name
+        opts[:index_name] = @key_fields_detector.index_name if @key_fields_detector.index_name
         opts[:select] = 'ALL_ATTRIBUTES'
         opts[:record_limit] = @record_limit if @record_limit
         opts[:scan_limit] = @scan_limit if @scan_limit

lib/dynamoid/criteria/keys_detector.rb renamed to lib/dynamoid/criteria/key_fields_detector.rb

@@ -2,7 +2,7 @@
 
 module Dynamoid #:nodoc:
   module Criteria
-    class KeysDetector
+    class KeyFieldsDetector
       attr_reader :hash_key, :range_key, :index_name
 
       def initialize(query, source)

spec/dynamoid/criteria/chain_spec.rb

@@ -134,9 +134,9 @@ def request_params
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', age: 10).all).to contain_exactly(customer1)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:age)
-      expect(chain.keys_detector.index_name).to be_nil
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:age)
+      expect(chain.key_fields_detector.index_name).to be_nil
     end
 
     it 'supports lt' do
@@ -211,9 +211,9 @@ def request_params
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'a', age: 10).all).to contain_exactly(customer1)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to be_nil
-      expect(chain.keys_detector.index_name).to be_nil
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to be_nil
+      expect(chain.key_fields_detector.index_name).to be_nil
     end
 
     it 'supports eq for set' do
@@ -359,9 +359,9 @@ def request_params
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_scan).and_call_original
       expect(chain.where(age: 10).all).to contain_exactly(customer1)
-      expect(chain.keys_detector.hash_key).to be_nil
-      expect(chain.keys_detector.range_key).to be_nil
-      expect(chain.keys_detector.index_name).to be_nil
+      expect(chain.key_fields_detector.hash_key).to be_nil
+      expect(chain.key_fields_detector.range_key).to be_nil
+      expect(chain.key_fields_detector.index_name).to be_nil
     end
 
     it 'supports eq for set' do
@@ -535,41 +535,41 @@ def request_params
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', 'range.lt': 3, 'range2.gt': 15).to_a.size).to eq(1)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:range)
-      expect(chain.keys_detector.index_name).to be_nil
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:range)
+      expect(chain.key_fields_detector.index_name).to be_nil
     end
 
     it 'supports query on local secondary index' do
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', 'range2.gt': 15).to_a.size).to eq(2)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:range2)
-      expect(chain.keys_detector.index_name).to eq(:range2index)
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:range2)
+      expect(chain.key_fields_detector.index_name).to eq(:range2index)
 
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', 'range3.lt': 200).to_a.size).to eq(1)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:range3)
-      expect(chain.keys_detector.index_name).to eq(:range3index)
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:range3)
+      expect(chain.key_fields_detector.index_name).to eq(:range3index)
     end
 
     it 'supports query on local secondary index with start' do
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', 'range2.gt': 15).to_a.size).to eq(2)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:range2)
-      expect(chain.keys_detector.index_name).to eq(:range2index)
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:range2)
+      expect(chain.key_fields_detector.index_name).to eq(:range2index)
 
       chain = Dynamoid::Criteria::Chain.new(model)
       expect(chain).to receive(:pages_via_query).and_call_original
       expect(chain.where(name: 'Bob', 'range2.gt': 15).start(@customer2).all).to contain_exactly(@customer3)
-      expect(chain.keys_detector.hash_key).to eq(:name)
-      expect(chain.keys_detector.range_key).to eq(:range2)
-      expect(chain.keys_detector.index_name).to eq(:range2index)
+      expect(chain.key_fields_detector.hash_key).to eq(:name)
+      expect(chain.key_fields_detector.range_key).to eq(:range2)
+      expect(chain.key_fields_detector.index_name).to eq(:range2index)
     end
   end
 
@@ -592,9 +592,9 @@ def request_params
       expect(chain).to receive(:pages_via_scan).and_call_original
       expect(chain.where(city: 'San Francisco').to_a.size).to eq(2)
       # Does not use GSI since not projecting all attributes
-      expect(chain.keys_detector.hash_key).to be_nil
-      expect(chain.keys_detector.range_key).to be_nil
-      expect(chain.keys_detector.index_name).to be_nil
+      expect(chain.key_fields_detector.hash_key).to be_nil
+      expect(chain.key_fields_detector.range_key).to be_nil
+      expect(chain.key_fields_detector.index_name).to be_nil
     end
 
     context 'with full composite key for table' do
@@ -628,57 +628,57 @@ def request_params
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(name: 'Bob').to_a.size).to eq(1)
-        expect(chain.keys_detector.hash_key).to eq(:name)
-        expect(chain.keys_detector.range_key).to be_nil
-        expect(chain.keys_detector.index_name).to be_nil
+        expect(chain.key_fields_detector.hash_key).to eq(:name)
+        expect(chain.key_fields_detector.range_key).to be_nil
+        expect(chain.key_fields_detector.index_name).to be_nil
       end
 
       it 'supports query on global secondary index' do
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(city: 'San Francisco').to_a.size).to eq(3)
-        expect(chain.keys_detector.hash_key).to eq(:city)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:cityage)
+        expect(chain.key_fields_detector.hash_key).to eq(:city)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:cityage)
 
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(city: 'San Francisco', 'age.gt': 12).to_a.size).to eq(2)
-        expect(chain.keys_detector.hash_key).to eq(:city)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:cityage)
+        expect(chain.key_fields_detector.hash_key).to eq(:city)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:cityage)
 
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(email: '[email protected]').to_a.size).to eq(1)
-        expect(chain.keys_detector.hash_key).to eq(:email)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:emailage)
+        expect(chain.key_fields_detector.hash_key).to eq(:email)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:emailage)
 
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(email: '[email protected]', 'age.gt': 12).to_a.size).to eq(1)
-        expect(chain.keys_detector.hash_key).to eq(:email)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:emailage)
+        expect(chain.key_fields_detector.hash_key).to eq(:email)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:emailage)
       end
 
       it 'supports scan when no global secondary index available' do
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_scan).and_call_original
         expect(chain.where(gender: 'male').to_a.size).to eq(4)
-        expect(chain.keys_detector.hash_key).to be_nil
-        expect(chain.keys_detector.range_key).to be_nil
-        expect(chain.keys_detector.index_name).to be_nil
+        expect(chain.key_fields_detector.hash_key).to be_nil
+        expect(chain.key_fields_detector.range_key).to be_nil
+        expect(chain.key_fields_detector.index_name).to be_nil
       end
 
       it 'supports query on global secondary index with start' do
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(city: 'San Francisco').to_a.size).to eq(3)
-        expect(chain.keys_detector.hash_key).to eq(:city)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:cityage)
+        expect(chain.key_fields_detector.hash_key).to eq(:city)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:cityage)
 
         # Now query with start at customer2 and we should only see customer3
         chain = Dynamoid::Criteria::Chain.new(model)
@@ -690,25 +690,25 @@ def request_params
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_scan).and_call_original
         expect(chain.where('city.begins_with': 'San').to_a.size).to eq(3)
-        expect(chain.keys_detector.hash_key).to be_nil
-        expect(chain.keys_detector.range_key).to be_nil
-        expect(chain.keys_detector.index_name).to be_nil
+        expect(chain.key_fields_detector.hash_key).to be_nil
+        expect(chain.key_fields_detector.range_key).to be_nil
+        expect(chain.key_fields_detector.index_name).to be_nil
       end
 
       it 'prefers global secondary index with range key used in conditions to index w/o such range key' do
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(city: 'San Francisco', 'age.lte': 15).to_a.size).to eq(2)
-        expect(chain.keys_detector.hash_key).to eq(:city)
-        expect(chain.keys_detector.range_key).to eq(:age)
-        expect(chain.keys_detector.index_name).to eq(:cityage)
+        expect(chain.key_fields_detector.hash_key).to eq(:city)
+        expect(chain.key_fields_detector.range_key).to eq(:age)
+        expect(chain.key_fields_detector.index_name).to eq(:cityage)
 
         chain = Dynamoid::Criteria::Chain.new(model)
         expect(chain).to receive(:pages_via_query).and_call_original
         expect(chain.where(city: 'San Francisco', gender: 'male').to_a.size).to eq(3)
-        expect(chain.keys_detector.hash_key).to eq(:city)
-        expect(chain.keys_detector.range_key).to eq(:gender)
-        expect(chain.keys_detector.index_name).to eq(:citygender)
+        expect(chain.key_fields_detector.hash_key).to eq(:city)
+        expect(chain.key_fields_detector.range_key).to eq(:gender)
+        expect(chain.key_fields_detector.index_name).to eq(:citygender)
       end
     end