dynamini 2.9.5 → 2.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f7c910987e834399c78a7c26cf2524d00eb6729
-  data.tar.gz: 74298b30b3f7994a64ee6d54b0d6d15709eaabd0
+  metadata.gz: 394d8fc8fe9d1d1f6a0380d91009868d82eae552
+  data.tar.gz: 3b831be32226ae1ccdbc2da1b7b11b2f9a5b3e56
 SHA512:
-  metadata.gz: 2aa48e095d7f04867863d9e33571f90e57e8bde41daa5c6c36ddfd6b9428c814187fbb39111b7eca4cfaa0f8c5cc591aaecdd425d6100e4a043a5ee601bda1a6
-  data.tar.gz: 76fcae444b9633607b5abb142afd5bf2fd2182edc42390a5be61b6fb1adb8d8bc10519c01da1c8b84148563bc10fd8da74bab70786981f8c19571398a51e42f8
+  metadata.gz: 4d1db9cfb9c089962b23c11204cc6ef9608a4eb46585d051f7d5a40856c40e49a5e9093546a3028d5a72f601930ee903f863d1bf56a2548df1430c59cf637c74
+  data.tar.gz: f9e7a129e6f89b8588520392ccd5509deddf62e4aaaca493f9dca695732775d51a8e113c043f9b3bab8b8fb5aafc5ef5bbef82bc0e23c850cd4e5026002e9750

data/Gemfile.lock

@@ -1,29 +1,30 @@
 PATH
   remote: .
   specs:
-    dynamini (2.9.5)
+    dynamini (2.9.6)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.5.1)
-      activesupport (= 4.2.5.1)
+    activemodel (4.2.9)
+      activesupport (= 4.2.9)
       builder (~> 3.1)
-    activesupport (4.2.5.1)
+    activesupport (4.2.9)
       i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
       thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    aws-sdk (2.2.22)
-      aws-sdk-resources (= 2.2.22)
-    aws-sdk-core (2.2.22)
+    aws-sdk (2.10.45)
+      aws-sdk-resources (= 2.10.45)
+    aws-sdk-core (2.10.45)
+      aws-sigv4 (~> 1.0)
       jmespath (~> 1.0)
-    aws-sdk-resources (2.2.22)
-      aws-sdk-core (= 2.2.22)
-    builder (3.2.2)
+    aws-sdk-resources (2.10.45)
+      aws-sdk-core (= 2.10.45)
+    aws-sigv4 (1.0.2)
+    builder (3.2.3)
     coderay (1.1.0)
     diff-lcs (1.2.5)
     ffi (1.9.10)
@@ -48,15 +49,14 @@ GEM
     guard-shell (0.7.1)
       guard (>= 2.0.0)
       guard-compat (~> 1.0)
-    i18n (0.7.0)
-    jmespath (1.1.3)
-    json (1.8.3)
+    i18n (0.8.6)
+    jmespath (1.3.1)
     listen (3.0.3)
       rb-fsevent (>= 0.9.3)
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
     method_source (0.8.2)
-    minitest (5.8.4)
+    minitest (5.10.3)
     nenv (0.2.0)
     notiffany (0.0.8)
       nenv (~> 0.1)
@@ -85,8 +85,8 @@ GEM
     shellany (0.0.1)
     slop (3.6.0)
     thor (0.19.1)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
       thread_safe (~> 0.1)
 
 PLATFORMS
@@ -99,3 +99,6 @@ DEPENDENCIES
   guard-shell
   pry (~> 0)
   rspec (~> 3)
+
+BUNDLED WITH
+   1.16.0.pre.2

data/README.md

@@ -78,7 +78,7 @@ Here's what a sample model looks like. This one includes a range key - sometimes
 
 ```ruby
 class Vehicle < Dynamini::Base
-    set_table_name 'cars-dev' # must match the table name configured in AWS
+    set_table_name 'cars'     # must match the table name configured in AWS
     set_hash_key :model       # defaults to :id if not set
     set_range_key :vin        # must be set if your AWS table is configured with a range key
 
@@ -86,8 +86,16 @@ class Vehicle < Dynamini::Base
 end
 ```
 
+If you don't use set_table_name, Dynamini will try to find a table with the pluralized, downcased class name. For instance, a Dynamini class called PageView would look for a table called 'page_views'. If you use separate DynamoDB tables for development and production, wrap set_table_name in a conditional to determine the appropriate table when your class initializes. In this example, the production table is 'vehicles' and the development table is 'vehicles-dev':
+
+```ruby
+class Vehicle < Dynamini::Base
+    set_table_name 'vehicles-dev' unless Rails.env.production?
+end
+```
+
 ## Datatype Handling
-There are a few quirks about how the Dynamo Ruby SDK stores data. It stores numeric values as BigDecimal objects, symbols as strings, and doesn't accept ruby Date or Time objects. To save you from having to convert your data to the correct type before saving and after retrieval, you can use the :handle helper for automatic type conversion. You can also use this to specify default values for your fields. Here's how it works:
+There are a few quirks about how the Dynamo Ruby SDK stores data. It stores numeric values as BigDecimal objects, symbols as strings, and doesn't accept ruby Date or Time objects. To save you from having to convert your data to the correct type before saving and after retrieval, you can use :handle to manage automatic type conversion. This is also where you can specify default values for your attributes. Here's how it works:
 
 ```ruby
 class Vehicle < Dynamini::Base
@@ -98,6 +106,7 @@ end
 car = Vehicle.new(vin: '43H1R')
 car.top_speed
 > 80
+
 car.top_speed = 90
 car.save
 Vehicle.find('43H1R').top_speed
@@ -105,9 +114,7 @@ Vehicle.find('43H1R').top_speed
 # This would return BigDecimal(90) without the handle helper.
 ```
 
-Defaults are optional - without a default, a handled field without a value assigned to it will return nil like any other field.
-
-The following datatypes are supported by handle:
+Dynamini lets you :handle the following types:
 * :integer
 * :float
 * :symbol
@@ -118,8 +125,14 @@ The following datatypes are supported by handle:
 * :array
 * :set
 
-Booleans and strings don't actually need to be translated, but you can set up defaults for those fields this way.
-The magic fields updated_at and created_at are handled as :time by default.
+Default values aren't actually written to the database when saving your instance. Instead, they define what will be returned when reading an unset or nullified attribute. If you don't provide your own default, the "default default" value depends on the specified type:
+
+* array: []
+* set: Set.new
+* all other types: nil
+* attribute not handled: nil
+
+The auto-generated fields updated_at and created_at are intrinsically handled as :time.
 
 ## Enumerable Attributes
 You can save arrays and sets to your Dynamini model. Optionally, you can have Dynamini perform type conversion on each element of your enumerable. Here's how it works:
@@ -288,35 +301,32 @@ Product.find('qwerty').updated_at
 ````
 
 ## Testing
-We've included an optional in-memory test client, so you don't necessarily have to connect to a real Dynamo instance when running tests. You could also use this in your development environment if you don't have a real Dynamo instance yet, but the data saved to it won't persist through a server restart.
-
-To activate this feature, just require the testing module:
+Dynamini includes an in-memory test client, so you don't have to connect to a real Dynamo instance when running tests. To activate this feature, just require the testing module:
 ```ruby
 require 'dynamini/testing'
 ```
-This module replaces all API calls Dynamini makes to AWS DynamoDB with calls to Dynamini::TestClient.
+Requiring the module replaces all API calls Dynamini makes to AWS with calls to Dynamini::TestClient.
 
-The test client will not reset its database unless you tell it to, like so:
+You probably don't want your data to persist between tests, so you'll have to reset the test client to wipe its data:
 ```ruby
+# in this case Vehicle is our Dynamini subclass
 Vehicle.client.reset
 ```
 
-So, for instance, to get Rspec working with your test suite the way your ActiveRecord model behaved, add these lines to your spec_helper.rb:
+Here's an implementation of the above in a typical spec_helper.rb:
 ```ruby
 require 'dynamini/testing'
 
 config.after(:each) {
-  Vehicle.client.reset # Large test suites will be very slow and unpredictable otherwise!
+  Vehicle.client.reset
 }
 ```
 
 ## Things to remember
-* Since DynamoDB is schemaless, your model will respond to any method that looks like a reader, meaning model.foo will return nil.
-* You can also write any arbitrary attribute to your model.
-* Other models in your app cannot have a has_one or has_many relationship with your Dynamini model, since these would require a table scan. Your other models can still use belongs_to.
-* If you change the primary key value on an instance of your model, then resave it, you'll have two copies in your database.
-* If you use non-numeric strings for your primary key, remember to change your foreign key columns on related ActiveRecord tables to be string type.
-* You might want to conditionally set the table name for your model based on the Rails.env, enabling separate tables for development and production.
+* Since DynamoDB is schemaless, Dynamini is designed to allow your instance to respond to any method call that looks like an attribute name, even if you've never referenced it before. For instance, model.i_bet_this_will_raise_an_error will return nil.
+* Similarly, you can write any arbitrarily-named attribute to your instance without defining its name or properties beforehand.
+* If you change the primary key value on an instance of your model, then resave it, you'll have two records in your database.
+* If you have a model with a foreign key attribute that points to your Dynamini model, you can use Rails' :belongs_to association helper normally. (If you use non-numeric strings for your Dynamini hash key, remember to change your foreign key columns on related ActiveRecord tables to be string type.)
 
 ## Contributing
 

data/dynamini.gemspec

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

data/lib/dynamini/attributes.rb

@@ -53,7 +53,8 @@ module Dynamini
 
     def attribute_updates
       changes.reduce({}) do |updates, (key, value)|
-        current_value = value[1]
+        # TODO: remove this ternary once aws-sdk accepts empty set pull request
+        current_value = value[1].is_a?(Set) && value[1].empty? ? nil : value[1]
         updates[key] = { action: value[2] || 'PUT' }
         updates[key][:value] = current_value unless current_value == DELETED_TOKEN
         updates

data/lib/dynamini/base.rb

@@ -53,7 +53,7 @@ module Dynamini
         handle(key, format) if format
       end
 
-      def set_secondary_index(index_name, args)
+      def set_secondary_index(index_name, args = {})
         @secondary_index ||= {}
         @secondary_index[index_name.to_s] = {hash_key_name: args[:hash_key] || hash_key, range_key_name: args[:range_key]}
       end

data/lib/dynamini/batch_operations.rb

@@ -69,7 +69,8 @@ module Dynamini
     def dynamo_scan(options)
       if options[:start_key] && !options[:start_key].is_a?(Hash)
         if options[:index_name]
-          start_key = { options[:index_name].to_s => options[:start_key] }
+          attr = secondary_index[options[:index_name]][:hash_key_name].to_s
+          start_key = { attr => options[:start_key] }
         else
           start_key = { hash_key.to_s => options[:start_key] }
         end
@@ -92,7 +93,7 @@ module Dynamini
         raise ArgumentError, 'Must specify segment if specifying total_segments'
       elsif options[:segment] && !options[:total_segments]
         raise ArgumentError, 'Must specify total_segments if specifying segment'
-      elsif options[:index_name] && !self.secondary_index[options[:index_name]]
+      elsif options[:index_name] && (!self.secondary_index || !self.secondary_index[options[:index_name]])
         raise ArgumentError, "Secondary index of #{options[:index_name]} does not exist"
       end
     end

data/lib/dynamini/test_client.rb

@@ -86,7 +86,6 @@ module Dynamini
 
     def scan(args = {})
       records = get_table(args[:table_name]).values
-
       sort_scanned_records!(records, args[:secondary_index_name]) if args[:secondary_index_name]
       start_index = index_of_start_key(args, records)
       items = limit_scanned_records(args[:limit], records, start_index)

data/spec/dynamini/base_spec.rb

@@ -185,6 +185,40 @@ describe Dynamini::Base do
             model.save
           end
         end
+        context 'when an empty set is submitted' do
+          it 'should nullify the set' do
+            expect(model.class.client).to receive(:update_item).with(
+                table_name: 'bases',
+                key: {id: model_attributes[:id]},
+                attribute_updates: hash_including(
+                    "foo" => {
+                        value: nil,
+                        action: 'PUT'
+                    }
+                )
+            )
+            model.foo = Set.new
+            model.bar = 4
+            model.save
+          end
+        end
+        context 'when a populated set is submitted' do
+          it 'should submit the set' do
+            expect(model.class.client).to receive(:update_item).with(
+                table_name: 'bases',
+                key: {id: model_attributes[:id]},
+                attribute_updates: hash_including(
+                    "foo" => {
+                        value: Set.new([1]),
+                        action: 'PUT'
+                    }
+                )
+            )
+            model.foo = Set.new([1])
+            model.bar = 4
+            model.save
+          end
+        end
       end
 
       context 'when failing validation' do

data/spec/dynamini/batch_operations_spec.rb

@@ -127,103 +127,84 @@ describe Dynamini::BatchOperations do
     end
   end
 
-  class SecBase < Dynamini::Base
-    set_hash_key :id
-    set_secondary_index :sec, hash_key: :sec
-    set_secondary_index :rev, hash_key: :sec
-  end
-
   describe '.scan' do
+    let(:response) { OpenStruct.new(items: [], last_evaluated_key: {'foo' => 'bar'}) }
 
     before do
-      SecBase.create(id: '123', sec: 'D')
-      SecBase.create(id: '124', sec: 'C')
-      SecBase.create(id: '125', sec: 'B')
-      SecBase.create(id: '126', sec: 'A')
+      subject.set_secondary_index :foo_index, hash_key: :foo_attr
     end
 
-    context 'scanning the primary key' do
-      context 'with an exclusive_start_key' do
-        context 'with a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(start_key: '124', limit: 1)
-            expect(response.items.map { |i| i.id }).to eq(['124'])
-            expect(response.last_evaluated_key).to eq('id' => '124')
-          end
-        end
-        context 'without a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(start_key: '124')
-            expect(response.items.map { |i| i.id }).to eq(%w(124 125 126))
-            expect(response.last_evaluated_key).to be_nil
-          end
-        end
-
-        context 'the start key is in aws sdk style' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(start_key: {'id' => '124'}, limit: 2)
-            expect(response.items.map { |i| i.id }).to eq(['124', '125'])
-            expect(response.last_evaluated_key).to eq('id' => '125')
-          end
-        end
+    context 'no start key is provided' do
+      it 'passes the request to the client in the correct shape and returns the correct shape' do
+        expect(subject.client).to receive(:scan).with(
+          consistent_read:      false,
+          secondary_index_name: 'foo_index',
+          limit:                100,
+          segment:              1,
+          total_segments:       2,
+          table_name:           'bases'
+        ).and_return(response)
+
+        expect(
+            subject.scan(
+              consistent_read: false,
+              index_name: 'foo_index',
+              limit: 100,
+              segment: 1,
+              total_segments: 2
+            )
+        ).to eq(response)
       end
-      context 'without an exclusive_start_key' do
-        context 'with a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(limit: 2)
-            expect(response.items.map { |i| i.id }).to eq(%w(123 124))
-            expect(response.last_evaluated_key).to eq('id' => '124')
-          end
-        end
-        context 'without a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan
-            expect(response.items.map { |i| i.id }).to eq(%w(123 124 125 126))
-            expect(response.last_evaluated_key).to be_nil
-          end
-        end
+    end
+    context 'a literal start key is provided' do
+      it 'passes the request to the client in the correct shape and returns the correct shape' do
+        expect(subject.client).to receive(:scan).with(
+          consistent_read:      false,
+          secondary_index_name: 'foo_index',
+          exclusive_start_key:  { 'foo_attr' => 'abc' },
+          limit:                100,
+          segment:              1,
+          total_segments:       2,
+          table_name:           'bases'
+        ).and_return(response)
+
+        expect(subject.scan(
+          consistent_read: false,
+          index_name: 'foo_index',
+          start_key: 'abc',
+          limit: 100,
+          segment: 1,
+          total_segments: 2
+        )).to eq(response)
       end
     end
-    context 'scanning a secondary index' do
-      context 'with an exclusive_start_key' do
-        context 'with a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(index_name: 'sec', start_key: 'B', limit: 2)
-            expect(response.items.map { |i| i.sec }).to eq(%w(B C))
-            expect(response.last_evaluated_key).to eq('sec' => 'C')
-          end
-        end
-        context 'without a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(index_name: 'sec', start_key: 'B')
-            expect(response.items.map { |i| i.sec }).to eq(%w(B C D))
-            expect(response.last_evaluated_key).to be_nil
-          end
-        end
+    context 'a complex start key is provided' do
+      it 'passes the request to the client in the correct shape and returns the correct shape' do
+        expect(subject.client).to receive(:scan).with(
+            consistent_read:      false,
+            secondary_index_name: 'foo_index',
+            exclusive_start_key:  { 'foo_attr' => 'abc' },
+            limit:                100,
+            segment:              1,
+            total_segments:       2,
+            table_name:           'bases'
+        ).and_return(response)
+
+        expect(subject.scan(
+            consistent_read: false,
+            index_name: 'foo_index',
+            start_key: { 'foo_attr' => 'abc' },
+            limit: 100,
+            segment: 1,
+            total_segments: 2
+        )).to eq(response)
       end
-      context 'without an exclusive_start_key' do
-        context 'with a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(index_name: 'sec', limit: 3)
-            expect(response.items.map { |i| i.sec }).to eq(%w(A B C))
-            expect(response.last_evaluated_key).to eq('sec' => 'C')
-          end
-        end
-        context 'without a limit' do
-          it 'retrieves the correct items' do
-            response = SecBase.scan(index_name: 'sec')
-            expect(response.items.map { |i| i.sec }).to eq(%w(A B C D))
-            expect(response.last_evaluated_key).to be_nil
-          end
+      context 'with a model with no secondary indices but with a start key' do
+        it 'behaves' do
+          expect{ Dynamini::Base.scan(start_key: '123') }.to_not raise_error
         end
       end
     end
-
-    context 'with a model with no secondary indices but with a start key' do
-      it 'behaves' do
-        expect{ Dynamini::Base.scan(start_key: '123') }.to_not raise_error
-      end
-    end
   end
 end
 

data/spec/dynamini/test_client_spec.rb

@@ -470,4 +470,87 @@ describe Dynamini::TestClient do
       expect(result.responses[table_name].first[:id]).to eq('foo')
     end
   end
+
+  class SecBase < Dynamini::Base
+    set_hash_key :id
+    set_secondary_index :sec_index, hash_key: :sec
+  end
+
+  describe '.scan' do
+    before do
+      SecBase.create(id: '123', sec: 'D')
+      SecBase.create(id: '124', sec: 'C')
+      SecBase.create(id: '125', sec: 'B')
+      SecBase.create(id: '126', sec: 'A')
+    end
+
+    context 'scanning the primary key' do
+      context 'with an exclusive_start_key' do
+        context 'with a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(exclusive_start_key: {'id' => '124'}, limit: 1, table_name: 'sec_bases')
+            expect(response.items.map { |i| i[:id] }).to eq(['124'])
+            expect(response.last_evaluated_key).to eq('id' => '124')
+          end
+        end
+        context 'without a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(exclusive_start_key: {'id' => '124'}, table_name: 'sec_bases')
+            expect(response.items.map { |i| i[:id] }).to eq(%w(124 125 126))
+            expect(response.last_evaluated_key).to be_nil
+          end
+        end
+      end
+      context 'without an exclusive_start_key' do
+        context 'with a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(limit: 2, table_name: 'sec_bases')
+            expect(response.items.map { |i| i[:id] }).to eq(%w(123 124))
+            expect(response.last_evaluated_key).to eq('id' => '124')
+          end
+        end
+        context 'without a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(table_name: 'sec_bases')
+            expect(response.items.map { |i| i[:id] }).to eq(%w(123 124 125 126))
+            expect(response.last_evaluated_key).to be_nil
+          end
+        end
+      end
+    end
+    context 'scanning a secondary index' do
+      context 'with an exclusive_start_key' do
+        context 'with a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(secondary_index_name: 'sec_index', exclusive_start_key: {'sec' => 'B'}, limit: 2, table_name: 'sec_bases')
+            expect(response.items.map { |i| i['sec'] }).to eq(%w(B C))
+            expect(response.last_evaluated_key).to eq('sec' => 'C')
+          end
+        end
+        context 'without a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(secondary_index_name: 'sec_index', exclusive_start_key: {'sec' => 'B'}, table_name: 'sec_bases')
+            expect(response.items.map { |i| i['sec'] }).to eq(%w(B C D))
+            expect(response.last_evaluated_key).to be_nil
+          end
+        end
+      end
+      context 'without an exclusive_start_key' do
+        context 'with a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(secondary_index_name: 'sec_index', limit: 3, table_name: 'sec_bases')
+            expect(response.items.map { |i| i['sec'] }).to eq(%w(A B C))
+            expect(response.last_evaluated_key).to eq('sec' => 'C')
+          end
+        end
+        context 'without a limit' do
+          it 'retrieves the correct items' do
+            response = SecBase.client.scan(secondary_index_name: 'sec_index', table_name: 'sec_bases')
+            expect(response.items.map { |i| i['sec'] }).to eq(%w(A B C D))
+            expect(response.last_evaluated_key).to be_nil
+          end
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.9.5
+  version: 2.9.6
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-14 00:00:00.000000000 Z
+date: 2017-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel