dynamini 2.11.1 → 2.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 57e821a0bc5b22015ec93c1a14b4618abfaf93dd
-  data.tar.gz: da7cec18f2a3a5a822b63fe6cfd14210196fffb8
+SHA256:
+  metadata.gz: 295d5d3e9ac24824561c2d3ea60328036a2a1ef08cb442c75dc07f07110f05dc
+  data.tar.gz: dc6a149f087e727efed3d20952468639a3ea0b82f3e3acc9d954d9a0a8307153
 SHA512:
-  metadata.gz: 9833c5aba2fe9ba980f4c294954f1647d46744d34e3720ca0aa2acfbbb251f4297dd652e2baeaeec2cc8f3fe0295c2095f23235d0edf7bf54d43284251ba2a81
-  data.tar.gz: b12415f6d442d49da0729cf566cf95a71f038dd70093acfe7f5822a2a5749ad173e40dfbaa99ed91cdb7aec82c6da46a447a77fbdfb601d8dc79f49ad18ed566
+  metadata.gz: 70172147217e1531d2be9a15973babb8cbd77361eff4025e39d816e0591e3c4e25278a6b73431b89a4bd5acdc7415f28ed40a9c423b1f0b36ba980151baca358
+  data.tar.gz: 3e8383facfa971c03a77e22ad8399cf5f5d024a88cc65bd67be213eaf0a967a315f5a4a34908c46afd44e1d4835de5d5a130e8d0950ec12282c6e67da206af8b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.11.1)
+    dynamini (2.12.1)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
@@ -16,13 +16,13 @@ GEM
       minitest (~> 5.1)
       thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    aws-sdk (2.10.131)
-      aws-sdk-resources (= 2.10.131)
-    aws-sdk-core (2.10.131)
+    aws-sdk (2.11.4)
+      aws-sdk-resources (= 2.11.4)
+    aws-sdk-core (2.11.4)
       aws-sigv4 (~> 1.0)
       jmespath (~> 1.0)
-    aws-sdk-resources (2.10.131)
-      aws-sdk-core (= 2.10.131)
+    aws-sdk-resources (2.11.4)
+      aws-sdk-core (= 2.11.4)
     aws-sigv4 (1.0.2)
     builder (3.2.3)
     coderay (1.1.0)
@@ -103,4 +103,4 @@ DEPENDENCIES
   rspec (~> 3)
 
 BUNDLED WITH
-   1.16.0.pre.2
+   1.16.1

data/dynamini.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'dynamini'
-  s.version = '2.11.1'
+  s.version = '2.12.1'
   s.summary = 'DynamoDB interface'
   s.description = 'Lightweight DynamoDB interface gem designed as
                    a drop-in replacement for ActiveRecord.

data/lib/dynamini/querying.rb

@@ -43,6 +43,10 @@ module Dynamini
     def query(args = {})
       fail ArgumentError, 'You must provide a :hash_key.' unless args[:hash_key]
 
+      if (args[:start] || args[:end]) && !current_index_range_key(args)
+        fail ArgumentError, 'You cannot query using start/end without using an index with a range key.'
+      end
+
       response = dynamo_query(args)
       objects = []
       response.items.each do |item|
@@ -69,20 +73,23 @@ module Dynamini
     end
 
     def build_expression_attribute_values(args)
-      range_key = current_index_range_key(args)
+      expression_values = {':h' => args[:hash_key]}
 
-      if (handle = handles[range_key.to_sym])
-        start_val = args[:start] ? attribute_callback(TypeHandler::SETTER_PROCS, handle, args[:start], false) : nil
-        end_val = args[:end] ? attribute_callback(TypeHandler::SETTER_PROCS, handle, args[:end], false) : nil
-      else
-        start_val = args[:start]
-        end_val = args[:end]
+      if current_index_range_key(args)
+        range_key = current_index_range_key(args)
+
+        if (handle = handles[range_key.to_sym])
+          start_val = args[:start] ? attribute_callback(TypeHandler::SETTER_PROCS, handle, args[:start], false) : nil
+          end_val = args[:end] ? attribute_callback(TypeHandler::SETTER_PROCS, handle, args[:end], false) : nil
+        else
+          start_val = args[:start]
+          end_val = args[:end]
+        end
+
+        expression_values[':s'] = start_val if start_val
+        expression_values[':e'] = end_val if end_val
       end
 
-      expression_values = {}
-      expression_values[':h'] = args[:hash_key]
-      expression_values[':s'] = start_val if start_val
-      expression_values[':e'] = end_val if end_val
       expression_values
     end
 

data/spec/dynamini/querying_spec.rb

@@ -154,140 +154,141 @@ describe Dynamini::Querying do
   end
 
   describe '.query' do
-    before do
-      4.times do |i|
-        TestClassWithRange.create(foo: 'foo', bar: i + 1, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 10 - i)
-      end
-      TestClassWithRange.create(foo: 'foo2', bar: 5, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 6)
-
-    end
-    context 'start value provided' do
-      it 'should return records with a range key greater than or equal to the start value' do
-        records = TestClassWithRange.query(hash_key: 'foo', start: 2)
-        expect(records.length).to eq 3
-        expect(records.first.bar).to eq 2
-        expect(records.last.bar).to eq 4
+    context 'class with range key' do
+      before do
+        4.times do |i|
+          TestClassWithRange.create(foo: 'foo', bar: i + 1, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 10 - i)
+        end
+        TestClassWithRange.create(foo: 'foo2', bar: 5, secondary_hash_key: 'secondary_hash_key', secondary_range_key: 6)
+      end
+      context 'start value provided' do
+        it 'should return records with a range key greater than or equal to the start value' do
+          records = TestClassWithRange.query(hash_key: 'foo', start: 2)
+          expect(records.length).to eq 3
+          expect(records.first.bar).to eq 2
+          expect(records.last.bar).to eq 4
+        end
       end
-    end
-    context 'end value provided' do
-      it 'should return records with a range key less than or equal to the start value' do
-        records = TestClassWithRange.query(hash_key: 'foo', end: 2)
-        expect(records.length).to eq 2
-        expect(records.first.bar).to eq 1
-        expect(records.last.bar).to eq 2
+      context 'end value provided' do
+        it 'should return records with a range key less than or equal to the start value' do
+          records = TestClassWithRange.query(hash_key: 'foo', end: 2)
+          expect(records.length).to eq 2
+          expect(records.first.bar).to eq 1
+          expect(records.last.bar).to eq 2
+        end
       end
-    end
-    context 'start and end values provided' do
-      it 'should return records between the two values inclusive' do
-        records = TestClassWithRange.query(hash_key: 'foo', start: 1, end: 3)
-        expect(records.length).to eq 3
-        expect(records.first.bar).to eq 1
-        expect(records.last.bar).to eq 3
+      context 'start and end values provided' do
+        it 'should return records between the two values inclusive' do
+          records = TestClassWithRange.query(hash_key: 'foo', start: 1, end: 3)
+          expect(records.length).to eq 3
+          expect(records.first.bar).to eq 1
+          expect(records.last.bar).to eq 3
+        end
       end
-    end
-    context 'neither value provided' do
-      it 'should return all records belonging to that hash key' do
-        records = TestClassWithRange.query(hash_key: 'foo')
-        expect(records.length).to eq 4
-        expect(records.first.bar).to eq 1
-        expect(records.last.bar).to eq 4
+      context 'neither value provided' do
+        it 'should return all records belonging to that hash key' do
+          records = TestClassWithRange.query(hash_key: 'foo')
+          expect(records.length).to eq 4
+          expect(records.first.bar).to eq 1
+          expect(records.last.bar).to eq 4
+        end
       end
-    end
 
-    context 'hash key does not exist' do
-      it 'should return an empty array' do
-        expect(TestClassWithRange.query(hash_key: 'non-existent-key')).to eq([])
+      context 'hash key does not exist' do
+        it 'should return an empty array' do
+          expect(TestClassWithRange.query(hash_key: 'non-existent-key')).to eq([])
+        end
       end
-    end
 
-    context 'when :limit is provided' do
-      it 'should return only the first two records' do
-        records = TestClassWithRange.query(hash_key: 'foo', limit: 2)
-        expect(records.length).to eq 2
-        expect(records.first.bar).to eq 1
-        expect(records.last.bar).to eq 2
+      context 'when :limit is provided' do
+        it 'should return only the first two records' do
+          records = TestClassWithRange.query(hash_key: 'foo', limit: 2)
+          expect(records.length).to eq 2
+          expect(records.first.bar).to eq 1
+          expect(records.last.bar).to eq 2
+        end
       end
-    end
 
-    context 'when :scan_index_forward is provided' do
-      it 'should return records in order when given true' do
-        records = TestClassWithRange.query(hash_key: 'foo', scan_index_forward: true)
-        expect(records.length).to eq 4
-        expect(records.first.bar).to eq 1
-        expect(records.last.bar).to eq 4
-      end
+      context 'when :scan_index_forward is provided' do
+        it 'should return records in order when given true' do
+          records = TestClassWithRange.query(hash_key: 'foo', scan_index_forward: true)
+          expect(records.length).to eq 4
+          expect(records.first.bar).to eq 1
+          expect(records.last.bar).to eq 4
+        end
 
-      it 'should return records in reverse order when given false' do
-        records = TestClassWithRange.query(hash_key: 'foo', scan_index_forward: false)
-        expect(records.length).to eq 4
-        expect(records.first.bar).to eq 4
-        expect(records.last.bar).to eq 1
+        it 'should return records in reverse order when given false' do
+          records = TestClassWithRange.query(hash_key: 'foo', scan_index_forward: false)
+          expect(records.length).to eq 4
+          expect(records.first.bar).to eq 4
+          expect(records.last.bar).to eq 1
+        end
       end
-    end
 
-    context 'using secondary index' do
-      it 'should be able to query using the secondary index' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index)
-        expect(records.length).to eq(5)
-        expect(records.first.secondary_range_key).to eq(6)
-        expect(records.last.secondary_range_key).to eq(10)
-      end
+      context 'using secondary index' do
+        it 'should be able to query using the secondary index' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index)
+          expect(records.length).to eq(5)
+          expect(records.first.secondary_range_key).to eq(6)
+          expect(records.last.secondary_range_key).to eq(10)
+        end
 
-      it 'should be able to sort backwards' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, scan_index_forward: false)
-        expect(records.length).to eq(5)
-        expect(records.first.secondary_range_key).to eq(10)
-        expect(records.last.secondary_range_key).to eq(6)
-      end
+        it 'should be able to sort backwards' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, scan_index_forward: false)
+          expect(records.length).to eq(5)
+          expect(records.first.secondary_range_key).to eq(10)
+          expect(records.last.secondary_range_key).to eq(6)
+        end
 
-      it 'should be able to limit number of results' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, limit: 3)
-        expect(records.length).to eq(3)
-        expect(records.first.secondary_range_key).to eq(6)
-        expect(records.last.secondary_range_key).to eq(8)
-      end
+        it 'should be able to limit number of results' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, limit: 3)
+          expect(records.length).to eq(3)
+          expect(records.first.secondary_range_key).to eq(6)
+          expect(records.last.secondary_range_key).to eq(8)
+        end
 
-      it 'should be able to give a minimum value for the range key' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 8)
-        expect(records.length).to eq(3)
-        expect(records.first.secondary_range_key).to eq(8)
-        expect(records.last.secondary_range_key).to eq(10)
-      end
+        it 'should be able to give a minimum value for the range key' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 8)
+          expect(records.length).to eq(3)
+          expect(records.first.secondary_range_key).to eq(8)
+          expect(records.last.secondary_range_key).to eq(10)
+        end
 
-      it 'should be able to give a maximum for the range key' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, end: 8)
-        expect(records.length).to eq(3)
-        expect(records.first.secondary_range_key).to eq(6)
-        expect(records.last.secondary_range_key).to eq(8)
-      end
+        it 'should be able to give a maximum for the range key' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, end: 8)
+          expect(records.length).to eq(3)
+          expect(records.first.secondary_range_key).to eq(6)
+          expect(records.last.secondary_range_key).to eq(8)
+        end
 
-      it 'should be able to give a maximum for the range key' do
-        records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 7, end: 9)
-        expect(records.length).to eq(3)
-        expect(records.first.secondary_range_key).to eq(7)
-        expect(records.last.secondary_range_key).to eq(9)
-      end
+        it 'should be able to give a maximum for the range key' do
+          records = TestClassWithRange.query(hash_key: 'secondary_hash_key', index_name: :secondary_index, start: 7, end: 9)
+          expect(records.length).to eq(3)
+          expect(records.first.secondary_range_key).to eq(7)
+          expect(records.last.secondary_range_key).to eq(9)
+        end
 
-      it 'should return no results if none are found with the secondary index' do
-        expect(TestClassWithRange.query(hash_key: 'non-existent-key', index_name: :secondary_index)).to eq([])
+        it 'should return no results if none are found with the secondary index' do
+          expect(TestClassWithRange.query(hash_key: 'non-existent-key', index_name: :secondary_index)).to eq([])
+        end
       end
-    end
 
-    context 'with a type handled range key' do
-      it 'converts the start and end parameter to the raw type' do
-        start_param = Time.new(2000, 1, 1)
-        end_param =  Time.new(2001, 1, 1)
-
-        expect(TestClassWithRange.client).to receive(:query).with(hash_including(
-            expression_attribute_values: {':h' => '12345', ':s' => start_param.to_f, ':e' => end_param.to_f}
-        )).and_return(OpenStruct.new(items: []))
-
-        TestClassWithRange.query(
-            hash_key: '12345',
-            index_name: :tertiary_index,
-            start: start_param,
-            end: end_param
-        )
+      context 'with a type handled range key' do
+        it 'converts the start and end parameter to the raw type' do
+          start_param = Time.new(2000, 1, 1)
+          end_param =  Time.new(2001, 1, 1)
+
+          expect(TestClassWithRange.client).to receive(:query).with(hash_including(
+                                                                        expression_attribute_values: {':h' => '12345', ':s' => start_param.to_f, ':e' => end_param.to_f}
+                                                                    )).and_return(OpenStruct.new(items: []))
+
+          TestClassWithRange.query(
+              hash_key: '12345',
+              index_name: :tertiary_index,
+              start: start_param,
+              end: end_param
+          )
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.11.1
+  version: 2.12.1
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-14 00:00:00.000000000 Z
+date: 2018-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -184,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: DynamoDB interface