dynamini 2.9.2 → 2.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4da5852711d8ecb8a226a9ae7c987f2ea0324927
-  data.tar.gz: eec0aaae89719060294b9ae055f8effabf79dd9b
+  metadata.gz: 1dfc513f038cc378fa09c49d4371fb55de060207
+  data.tar.gz: 278157bffc21bbae3fbaa3a7e2a1652571afc4e3
 SHA512:
-  metadata.gz: f6eaf764f422c931ae8e5d669f2b26349cfaffedfcabb6c13654f06ac40b758ea371b0328149d1f3c0914de67972fa7971d7a01d89bef94b6ab825b3bd1527c3
-  data.tar.gz: d97dab7690b1c371052bff3c1c1a7b8d39107281b2ed71c90e6eb05b3dc18998d9f51c8ad81307ebb249de1d4924f56245ef8f4e85100d42d4fd71b870f5081c
+  metadata.gz: bb4bc3eeaf5c7f7b1321fd0aa29da4bcc5d5c8b968f3e2ab5619cc60fe8dde8ac53ca2135b3c73de70dcbaf4797183cec0a82ceabac6678c097c1a2d6522ff2b
+  data.tar.gz: 51d96dc40837859551f3fffd6a1dcbdf5d5137613a4e610bb5f980c744c67d78d55c001f986e9be9518e70b4e29fc3af983cecdc65dfcb376ecebe7e17f624b0

data/.travis.yml

@@ -2,10 +2,10 @@ language: ruby
 script: bundle exec rspec
 rvm:
 - 2.0.0
-- 2.2.1
+- 2.3.4
 notifications:
   email:
     recipients:
       - dev@retailcommon.com
     on_success: change
-    on_failure: always
+    on_failure: always

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.9.2)
+    dynamini (2.9.3)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 

data/README.md

@@ -5,8 +5,21 @@ Dynamini is a lightweight DynamoDB interface designed as a drop-in replacement f
 [![Code Climate](https://codeclimate.com/github/47colborne/dynamini/badges/gpa.svg)](https://codeclimate.com/github/47colborne/dynamini)
 [![Gem Version](https://badge.fury.io/rb/dynamini.svg)](https://badge.fury.io/rb/dynamini)
 
+##### Table of Contents  
+- [The Basics](#the-basics)  
+- [Configuration](#configuration)
+- [Datatype Handling](#datatype-handling)
+- [Enumerable Attributes](#enumerable-attributes)
+- [Querying](#querying)
+- [Scanning](#scanning)
+- [Secondary Indices](#secondary-indices)
+- [Batch Saving](#batch-saving)
+- [Testing](#testing)
+- [Things to Remember](#things-to-remember)
+- [Contributing](#contributing)
+      
 ## The Basics
-This gem provides an opinionated interface, set up to let you use Amazon's DynamoDB at its most efficient. That means traditional relational DB functions like WHERE, GROUP BY, and HAVING aren't provided, since these trigger table scans that defeat the performance gains realized by switching to Dynamo in the first place. Use this gem when you have an relational table with too much concurrent activity, resulting in constant table locking. After you've moved your data to Dynamo, and installed and configured Dynamini, the following ActiveRecord functions will be preserved:
+This gem is designed to provide an ActiveRecord-like interface for Amazon's DynamoDB, making it easy for you to make the switch from a traditional relational DB. Once you've set up your table in the DynamoDB console, and installed and configured Dynamini, the behavior of the following ActiveRecord methods will be preserved:
 
 Class methods:
 * create(attributes)
@@ -38,7 +51,8 @@ Instance methods:
 * created_at
 
 We've included ActiveModel::Validations, so any validators will still work and be triggered by the save/create methods.
-There are also some new functions specific to DynamoDB's API:
+
+There are also some new methods specific to DynamoDB's API that don't have a counterpart in ActiveRecord:
 
 * find_or_nil(hash_key, range_key) - since ActiveRecord's find_by isn't applicable to noSQL, use this method if you want a .find that doesn't raise exceptions when the item doesn't exist
 * batch_find([keys]) - to retrieve multiple objects at once.
@@ -48,7 +62,7 @@ There are also some new functions specific to DynamoDB's API:
 * delete_attribute!(attrubute) - same as above but with an included save!
 
 ## Configuration
-In application.rb, or in initializers/dynamini.rb, include your AWS settings like so:
+In application.rb, or in initializers/dynamini.rb, include your AWS settings like this:
 
 ```ruby
 Dynamini.configure do |config|
@@ -107,7 +121,7 @@ The following datatypes are supported by handle:
 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.
 
-## Enumerable Support
+## 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:
 
 ```ruby
@@ -146,9 +160,11 @@ Please note that changing enumerables in place using mutator methods like << or
 
 If you want to make changes like this, either clone it then use the assignment operator (e.g. model.array = model.array.dup << 'foo') or call model.mark(:attribute) after mutation and before saving to force Dynamini to write the change.
 
-## Querying With Range Keys
+## Querying
+
+Dynamini includes a query function that's much more narrow than ActiveRecord's where function, since DynamoDB is not automatically optimized for highly flexible read operations. It's designed to retrieve a selection of records that belong to a given hash key but have various range key values. 
 
-Dynamini includes a query function that's much more narrow than ActiveRecord's where function. It's designed to retrieve a selection of records that belong to a given hash key but have various range key values. To use .query, your table needs to be configured with a range key, and you need to :handle that range field as a fundamentally numeric type - integer, float, date, or time. If your range key field isn't numeric, you won't be able to .query, but you'll still be able to .find your records normally.
+To use .query, your table needs to be configured with a range key, and you need to :handle that range field as a fundamentally numeric type - integer, float, date, or time. If your range key field isn't numeric, you won't be able to .query, but you'll still be able to .find your records normally.
 
 Query takes the following arguments:
 * :hash_key (required)
@@ -199,7 +215,7 @@ DailyWeather.query(hash_key: "Toronto", scan_index_forward: false)
 > [C, B, A]
 ```
   
-## Table Scans
+## Scanning
 Table scanning is a very expensive operation, and should not be undertaken without a good understanding of the read/write costs. As such, Dynamini doesn't implement the traditional ActiveRecord collection methods like .all or .where. Instead, you can .scan, which has an interface much closer to DynamoDB's native SDK method.
 
 The following options are supported:
@@ -215,7 +231,6 @@ Note that start_key can be either a hash { "AttributeName" => "Value" } or a val
 
 For more information about using segment and total_segments for parallelization, see: http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html
 
-
 ```ruby
 products_page_one = Product.scan(limit: 100, start_key: 'abcd')
 
@@ -229,7 +244,7 @@ page_two = Product.scan(start_key: products_page_one.last_evaluated_key)
 ```
 
 ## Secondary Indices
-To define a secondary index (so that you can .scan it or .query it), you can list them at the top of your Dynamini subclass. The index names have to match the names you've set up through the DynamoDB console. If your secondary index uses a range key, specify it here as well.
+To define a secondary index (so that you can .scan or .query it), you can set them at the top of your Dynamini subclass. The index names have to match the names you've set up through the DynamoDB console. If your secondary index uses a range key, specify it here as well.
 
 ```ruby
 class Comment < Dynamini::Base
@@ -240,28 +255,6 @@ class Comment < Dynamini::Base
 end
 ```
 For more information on how and why to use secondary indices, see http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html
-## 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:
-```ruby
-require 'dynamini/testing'
-```
-This module replaces all API calls Dynamini makes to AWS DynamoDB with calls to Dynamini::TestClient.
-
-The test client will not reset its database unless you tell it to, like so:
-```ruby
-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:
-```ruby
-require 'dynamini/testing'
-
-config.after(:each) {
-  Vehicle.client.reset # Large test suites will be very slow and unpredictable otherwise!
-}
-```
 
 ## Batch Saving
 Dynamini implements DynamoDB's batch write operation, mapped to the .import method you might be used to from ActiveRecord. http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
@@ -294,6 +287,29 @@ 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:
+```ruby
+require 'dynamini/testing'
+```
+This module replaces all API calls Dynamini makes to AWS DynamoDB with calls to Dynamini::TestClient.
+
+The test client will not reset its database unless you tell it to, like so:
+```ruby
+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:
+```ruby
+require 'dynamini/testing'
+
+config.after(:each) {
+  Vehicle.client.reset # Large test suites will be very slow and unpredictable otherwise!
+}
+```
+
 ## 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.

data/dynamini.gemspec

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

data/lib/dynamini/attributes.rb

@@ -94,7 +94,7 @@ module Dynamini
 
     def write_attribute(attribute, new_value, change: true, **options)
       old_value = read_attribute(attribute)
-      if (handle = self.class.handles[attribute.to_sym]) && !new_value.nil?
+      if (handle = self.class.handles[attribute.to_sym])
         new_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handle, new_value, change)
       end
       @attributes[attribute] = new_value

data/lib/dynamini/type_handler.rb

@@ -4,33 +4,35 @@ module Dynamini
   module TypeHandler
 
     GETTER_PROCS = {
-      integer:  proc { |v| v.to_i },
+      integer:  proc { |v| v&.to_i },
       date:     proc do |v|
         if v.is_a?(Date)
           v
-        else
+        elsif v
           Time.methods.include?(:zone) ? Time.zone.at(v).to_date : Time.at(v).to_date
         end
       end,
       time:     proc do |v|
-        Time.methods.include?(:zone) ? Time.zone.at(v.to_f) : Time.at(v.to_f)
+        if v
+          Time.methods.include?(:zone) ? Time.zone.at(v.to_f) : Time.at(v.to_f)
+        end
       end,
-      float:    proc { |v| v.to_f },
-      symbol:   proc { |v| v.to_sym },
-      string:   proc { |v| v.to_s },
+      float:    proc { |v| v&.to_f },
+      symbol:   proc { |v| v&.to_sym },
+      string:   proc { |v| v&.to_s },
       boolean:  proc { |v| v },
       array:    proc { |v| v.is_a?(Enumerable) ? v.to_a : [v] },
       set:      proc { |v| v.is_a?(Enumerable) ? Set.new(v) : Set.new([v]) }
     }.freeze
 
     SETTER_PROCS = {
-      integer:  proc { |v| v.to_i },
+      integer:  proc { |v| v&.to_i },
       time:     proc { |v| (v.is_a?(Date) ? v.to_time : v).to_f },
-      float:    proc { |v| v.to_f },
-      symbol:   proc { |v| v.to_s },
-      string:   proc { |v| v.to_s },
+      float:    proc { |v| v&.to_f },
+      symbol:   proc { |v| v&.to_s },
+      string:   proc { |v| v&.to_s },
       boolean:  proc { |v| v },
-      date:     proc { |v| v.to_time.to_f },
+      date:     proc { |v| v&.to_time.to_f },
       array:    proc { |v| v.is_a?(Enumerable) ? v.to_a : [v] },
       set:      proc { |v| v.is_a?(Enumerable) ? Set.new(v) : Set.new([v]) }
     }.freeze
@@ -91,6 +93,7 @@ module Dynamini
     end
 
     def attribute_callback(procs, handle, value, validate)
+      value = handle[:options][:default] if value.nil?
       callback = procs[handle[:format]]
       if should_convert_elements?(handle, value)
         result = convert_elements(value, procs[handle[:options][:of]])

data/spec/dynamini/attributes_spec.rb

@@ -129,6 +129,16 @@ describe Dynamini::Attributes do
         expect(model.foo).to eq([])
       end
     end
+
+    context 'when setting a handled attribute to its current value' do
+      it 'should not detect a change' do
+        Dynamini::Base.handle(:my_set, :set, of: :string)
+        Dynamini::Base.create!(id: '123', my_set: nil)
+        model = Dynamini::Base.find('123')
+        model.my_set = nil
+        expect(model.changes).to be_empty
+      end
+    end
   end
 
   describe '#delete_attribute' do

metadata

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