dynamini 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af37a6a457e3643934e6d1f3900254c824069313
-  data.tar.gz: a094c3596ee5b2614c4a30798739b1ee97353d32
+  metadata.gz: c71e8851f1dcde97317c1fd5034423cb4698a823
+  data.tar.gz: e62c81d4d011bc3bc99365dd577a6d11e054fdda
 SHA512:
-  metadata.gz: 32cc0f359b3b9272059aeb92faed3ef27b54c7b7120d068517d1a63a420e37ff1fe83afcc9e023f12939421b1b4ada06e10f17e4182cff6c879ed8a9cf3386cd
-  data.tar.gz: 2031fabc0a87a412a04cdb3d1b31fed1a0b68ef6183d74eabc3a1f97d16e2f7d53176e665eb3a4481f9bbb40dd2a294ae3eda263a8f84b4e501d00912016c9a8
+  metadata.gz: 65bb9e2e742706642974c9509100afc9c96fb1f71a1d06fb32413b342b7b61a613e4687c88ee4364ddd5b9663074794c028601eb4b5403720ce3395ca005ce7c
+  data.tar.gz: acd5c9f3c9b30a2c5e512493348f7acc6fde4ffaa25cdd667519999b8f58ee7ca80613b0507da5b2cc03b9de92c622bcac8bc06bb9f3ddf901d3acea3da8c44e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.4.0)
+    dynamini (2.6.0)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
@@ -17,12 +17,12 @@ GEM
       minitest (~> 5.1)
       thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    aws-sdk (2.5.3)
-      aws-sdk-resources (= 2.5.3)
-    aws-sdk-core (2.5.3)
+    aws-sdk (2.6.1)
+      aws-sdk-resources (= 2.6.1)
+    aws-sdk-core (2.6.1)
       jmespath (~> 1.0)
-    aws-sdk-resources (2.5.3)
-      aws-sdk-core (= 2.5.3)
+    aws-sdk-resources (2.6.1)
+      aws-sdk-core (= 2.6.1)
     builder (3.2.2)
     coderay (1.1.0)
     diff-lcs (1.2.5)
@@ -99,3 +99,6 @@ DEPENDENCIES
   guard-shell
   pry (~> 0)
   rspec (~> 3)
+
+BUNDLED WITH
+   1.12.5

data/README.md

@@ -98,10 +98,50 @@ The following datatypes are supported by handle:
 * :date
 * :time
 * :string
+* :array
 
 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.
 
+## Array Support
+You can save arrays to your Dynamini model. Optionally, you can have Dynamini perform type conversion on each element of your array. Here's how it works:
+
+```ruby
+class Vehicle < Dynamini::Base
+    set_hash_key :vin
+    handle :parts, :array, of: :symbol # :of accepts the same types as :handle
+    handle :other_array, :array
+end
+
+car = Vehicle.new(vin: 'H3LL0')
+car.parts
+> []
+
+car.parts = 'wheel'
+car.parts
+> :wheel
+
+car.parts = ['wheel', 'brakes', 'seat']
+car.parts
+> [:wheel, :brakes, :seat]
+
+# This line will raise an error since 5 cannot be converted to a symbol.
+car.parts = ['wheel', 'brakes', 5]
+
+# If you want a multitype array, invoke :handle without the :of option.
+car.other_array = ['wheel', 'brakes', 5]
+car.other_array
+> ['wheel', 'brakes', 5]
+# But then you won't have any type conversion.
+car.save
+Vehicle.find('H3LLO').other_array
+> ['wheel', 'brakes', BigDecimal(5)]
+```
+
+Please note that changing arrays in place using mutator methods like << or map! will not record a change to the object. 
+
+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
 
 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.
@@ -154,44 +194,6 @@ DailyWeather.query(hash_key: "Toronto", scan_index_forward: false)
 > [C, B, A]
 ```
 
-## Array Support
-You can save arrays to your Dynamini model. If you've :handled that attribute, it will attempt to convert its contents to the correct datatype when setting and getting. Here's how it works:
-
-```ruby
-class Vehicle < Dynamini::Base
-    set_hash_key :vin
-    handle :parts, :symbol, default: []
-end
-
-car = Vehicle.new(vin: 'H3LL0')
-car.parts
-> []
-
-car.parts = 'wheel'
-car.parts
-> :wheel
-
-car.parts = ['wheel', 'brakes', 'seat']
-car.parts
-> [:wheel, :brakes, :seat]
-
-# This line will raise an error since 5 cannot be converted to a symbol.
-car.parts = ['wheel', 'brakes', 5]
-
-# That multitype array can be saved to a non-:handled attribute.
-car.stuff = ['wheel', 'brakes', 5]
-car.stuff
-> ['wheel', 'brakes', 5]
-# But then you won't have any type conversion.
-car.save
-Vehicle.find('H3LLO').stuff
-> ['wheel', 'brakes', BigDecimal(5)]
-```
-
-Please note that changing arrays in place using mutator methods like << or map! will not record a change to the object. 
-
-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.
-
 ## 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.
 

data/dynamini.gemspec

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

data/lib/dynamini/adder.rb

@@ -0,0 +1,25 @@
+module Dynamini
+  module Adder
+    def add_to(attribute, value)
+      complain_about(attribute) unless handles[attribute]
+      old_value = read_attribute(attribute)
+      add_value = attribute_callback(Dynamini::TypeHandler::SETTER_PROCS, handles[attribute], value)
+      case handles[attribute][:format]
+        when :set, :array
+          @attributes[attribute] += add_value
+        when :integer, :float, :time, :date
+          @attributes[attribute] += add_value
+        else
+          complain_about(attribute)
+      end
+      record_change(attribute, old_value, add_value, 'ADD')
+      self
+    end
+
+    private
+
+    def complain_about(attribute)
+      raise ArgumentError, "#{attribute.capitalize} is not handled as an addable type. Addable types are set, array, integer, float, time, and date."
+    end
+  end
+end

data/lib/dynamini/base.rb

@@ -4,6 +4,7 @@ require_relative 'client_interface'
 require_relative 'dirty'
 require_relative 'increment'
 require_relative 'type_handler'
+require_relative 'adder'
 
 module Dynamini
   # Core db interface class.
@@ -16,6 +17,8 @@ module Dynamini
     include Dynamini::Dirty
     include Dynamini::Increment
     include Dynamini::TypeHandler
+    include Dynamini::Adder
+
 
     attr_reader :attributes
     class_attribute :handles
@@ -74,7 +77,7 @@ module Dynamini
       @attributes = {}
       clear_changes
       attributes.each do |k, v|
-        write_attribute(k, v, new_record)
+        write_attribute(k, v, change: new_record)
       end
     end
 
@@ -174,7 +177,7 @@ module Dynamini
     def attribute_updates
       changes.reduce({}) do |updates, (key, value)|
         current_value = value[1]
-        updates[key] = { value: current_value, action: 'PUT' }
+        updates[key] = { value: current_value, action: value[2] || 'PUT' }
         updates
       end
     end
@@ -207,13 +210,13 @@ module Dynamini
       @attributes.keys.include?(name) || write_method?(name) || was_method?(name) || super
     end
 
-    def write_attribute(attribute, new_value, change = true)
+    def write_attribute(attribute, new_value, change: true, **options)
       old_value = read_attribute(attribute)
       if (handle = handles[attribute.to_sym]) && !new_value.nil?
         new_value = attribute_callback(SETTER_PROCS, handle, new_value)
       end
       @attributes[attribute] = new_value
-      record_change(attribute, new_value, old_value) if change && new_value != old_value
+      record_change(attribute, old_value, new_value, options[:action]) if change && new_value != old_value
     end
 
     def read_attribute(name)

data/lib/dynamini/dirty.rb

@@ -15,16 +15,17 @@ module Dynamini
     end
 
     def mark(attr)
-      if @changes[attr] == [nil, nil]
+      if @changes[attr][0..1] == [nil, nil]
         val = @attributes[attr]
-        @changes[attr] = [val, val]
+        @changes[attr][0..1] = [val, val]
       end
     end
 
     private
 
-    def record_change(attribute, new_value, old_value)
-      @changes[attribute] = [old_value, new_value]
+    def record_change(attribute, old_value, new_value, action)
+      action ||= 'PUT'
+      @changes[attribute] = [old_value, new_value, action]
     end
 
     def clear_changes

data/lib/dynamini/type_handler.rb

@@ -9,7 +9,8 @@ module Dynamini
         symbol:   proc { |v| v.to_sym },
         string:   proc { |v| v },
         boolean:  proc { |v| v },
-        array:    proc { |v| v }
+        array:    proc { |v| v },
+        set:      proc { |v| v }
     }
 
     SETTER_PROCS = {
@@ -20,12 +21,14 @@ module Dynamini
         string:   proc { |v| v },
         boolean:  proc { |v| v },
         date:     proc { |v| v.to_time.to_f },
-        array:    proc { |v| v }
+        array:    proc { |v| v },
+        set:      proc { |v| v }
     }
 
     module ClassMethods
       def handle(column, format_class, options = {})
-        options[:default] ||= [] if format_class == :array
+        options[:default] ||= format_default(format_class)
+        options[:default] ||= Set.new if format_class == :set
 
         self.handles = self.handles.merge(column => { format: format_class, options: options })
 
@@ -50,6 +53,15 @@ module Dynamini
           write_attribute(column, value)
         end
       end
+
+      def format_default(format_class)
+        case format_class
+          when :array
+            []
+          when :set
+            Set.new
+        end
+      end
     end
 
     private
@@ -61,20 +73,24 @@ module Dynamini
     def attribute_callback(procs, handle, value)
       type = handle[:options][:of] || handle[:format]
       callback = procs[type]
-
-      if handle_as_array?(handle, value)
+      if value.is_a?(Array)
         value.map { |e| callback.call(e) }
+      elsif value.is_a?(Set)
+        Set.new(value.map { |e| callback.call(e) })
+      elsif handled_as?(handle, [:array, :set])
+        raise ArgumentError, "Can't write a non-enumerable value to field handled as #{handle[:format]}"
       else
         callback.call(value)
       end
     end
 
-    def handle_as_array?(handle, value)
-      handle[:format] == :array || value.is_a?(Array)
+    def handled_as?(handle, type)
+      type.include? handle[:format]
     end
 
     def self.included(base)
       base.extend ClassMethods
     end
+
   end
 end

data/spec/dynamini/adder_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Dynamini::Adder do
+
+  class AddHandledModel < Dynamini::Base
+    handle :price, :float
+    handle :things, :set
+    handle :stuff, :array
+    handle :when, :date
+    handle :what_time, :time
+    handle :widget_count, :integer
+  end
+
+  let(:model_attributes) {
+    {
+        name: 'Widget',
+        price: 9.99,
+        id: 'abcd1234',
+        hash_key: '009',
+        things: Set.new([1,2,3]),
+        stuff: [4,5,6]
+    }
+  }
+
+  let(:model) { AddHandledModel.new(model_attributes, false) }
+
+
+  describe '.add_to' do
+    context 'a change exists for the given attribute' do
+      it 'should overwrite the change with a change that adds to the previously set value' do
+        model.price = 2
+        model.add_to(:price, 3)
+        expect(model.price).to eq(5)
+        expect(model.changes['price']).to eq([2, 3, 'ADD'])
+      end
+    end
+
+    context 'no change exists for the given attribute' do
+      it 'should create an add change' do
+        model.add_to(:price, 2)
+        expect(model.price).to eq(11.99)
+        expect(model.changes['price']).to eq([9.99, 2, 'ADD'])
+      end
+    end
+
+    context 'a setter is called after adding' do
+      it 'should overwrite the ADD change with a PUT change' do
+        model.add_to(:price, 2)
+        model.price = 2
+        expect(model.changes['price']).to eq([11.99, 2, 'PUT'])
+      end
+    end
+
+    context 'adding to a set' do
+      context 'the provided value is enumerable' do
+        it 'merges the sets' do
+          model.add_to(:things, Set.new([4]))
+          expect(model.things).to eq(Set.new([1,2,3,4]))
+        end
+      end
+      context 'the provided value is not enumerable' do
+        it 'raises an error' do
+          expect{ model.add_to(:things, 4) }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    context 'adding to an array' do
+      context 'the provided value is enumerable' do
+        it 'merges the arrays' do
+          model.add_to(:stuff, [7])
+          expect(model.stuff).to eq([4,5,6,7])
+        end
+      end
+      context 'the provided value is not enumerable' do
+        it 'raises an error' do
+          expect{ model.add_to(:stuff, 4) }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+end

data/spec/dynamini/dirty_spec.rb

@@ -16,8 +16,6 @@ describe Dynamini::Dirty do
 
 
   describe '.new' do
-
-
     it 'should append all initial attrs to @changed, including hash_key' do
       expect(dirty_model.changed).to eq(model_attributes.keys.map(&:to_s).delete_if { |k, v| k == 'id' })
     end
@@ -37,7 +35,7 @@ describe Dynamini::Dirty do
     context 'when marking an already changed attribute' do
       it 'should do nothing' do
         dirty_model.mark(:price)
-        expect(dirty_model.changes['price']).to eq([nil, model_attributes[:price]])
+        expect(dirty_model.changes['price']).to eq([nil, model_attributes[:price], 'PUT'])
       end
     end
     context 'when using it to mark a changed array' do
@@ -138,14 +136,26 @@ describe Dynamini::Dirty do
     context 'attribute changed' do
       before { model.price = 1 }
       it 'should include the changed attribute' do
-        expect(model.changes['price']).to eq([9.99, 1])
+        expect(model.changes['price']).to eq([9.99, 1, 'PUT'])
+      end
+    end
+
+    context 'attribute changed with ADD action' do
+
+      class AddModel < Dynamini::Base
+        handle :price, :float
+      end
+      it 'should include a change with ADD action specified' do
+        model = AddModel.create!(model_attributes)
+        model.add_to(:price, 1)
+        expect(model.changes['price']).to eq([9.99, 1, 'ADD'])
       end
     end
 
     context 'attribute created' do
       before { model.foo = 'bar' }
       it 'should include the created attribute' do
-        expect(model.changes['foo']).to eq([nil, 'bar'])
+        expect(model.changes['foo']).to eq([nil, 'bar', 'PUT'])
       end
     end
 
@@ -155,7 +165,7 @@ describe Dynamini::Dirty do
         model.foo = 'baz'
       end
       it 'should only include one copy of the changed attribute' do
-        expect(model.changes['foo']).to eq(['bar', 'baz'])
+        expect(model.changes['foo']).to eq(['bar', 'baz', 'PUT'])
       end
     end
   end

data/spec/dynamini/querying_spec.rb

@@ -32,6 +32,7 @@ describe Dynamini::Querying do
       expect(found.price).to eq(9.99)
       expect(found.name).to eq('Widget')
       expect(found.hash_key).to eq('009')
+      expect(found).to_not be_new_record
     end
 
     context 'when the object does not exist' do
@@ -254,4 +255,4 @@ describe Dynamini::Querying do
       end
     end
   end
-end
+end

data/spec/dynamini/test_client_spec.rb

@@ -19,6 +19,13 @@ describe Dynamini::TestClient do
         test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 'def', action: 'PUT'}})
         expect(test_client.data[table_name]['hash_key_value']).to eq(abc: 'def', :hash_key_name => "hash_key_value")
       end
+
+      it 'ADDs integers' do
+        test_client = Dynamini::TestClient.new(:hash_key_name)
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 1, action: 'PUT'}})
+        test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: 1, action: 'ADD'}})
+        expect(test_client.data[table_name]['hash_key_value']).to eq(abc: 2, hash_key_name: 'hash_key_value')
+      end
     end
 
     context 'with Hash key and range key' do
@@ -57,6 +64,7 @@ describe Dynamini::TestClient do
   end
 
   describe '#get_item' do
+
     context 'table with just a hash key' do
       let(:test_client) { Dynamini::TestClient.new(:hash_key_name) }
 

data/spec/dynamini/type_handler_spec.rb

@@ -41,6 +41,10 @@ describe Dynamini::TypeHandler do
     handle :defaulted_ary, :array, default: [1,2,3]
     handle :float_array, :array, of: :float
     handle :sym_array, :array, of: :symbol
+    handle :my_set, :set
+    handle :defaulted_set, :set, default: Set.new([1,2,3])
+    handle :sym_set, :set, of: :symbol
+    handle :float_set, :set, of: :float
   end
 
   let(:handle_model) { HandleModel.new }
@@ -71,25 +75,52 @@ describe Dynamini::TypeHandler do
     expect { handle_model.int_list = {a: 1} }.to raise_error NoMethodError
   end
 
-  it 'should retrieve casted float arrays' do
-    handle_model.float_array = [12, 24, 48]
-    expectations = [12.0, 24.0, 48.0]
-    handle_model.float_array.each_with_index do |e, i|
-      expect(e).to equal(expectations[i])
-    end
+  it 'should reject non-enumerable data for enumerable handles' do
+    expect { handle_model.my_set = 2 }.to raise_error ArgumentError
+    expect { handle_model.ary = 2}.to raise_error ArgumentError
   end
 
-  it 'should retrieve casted symbol arrays' do
-    handle_model.sym_array = ['foo', 'bar', 'baz']
-    expect(handle_model.sym_array).to eq([:foo, :bar, :baz])
-  end
+  context 'when handling as array' do
+    it 'should retrieve casted float arrays' do
+      handle_model.float_array = [12, 24, 48]
+      expectations = [12.0, 24.0, 48.0]
+      handle_model.float_array.each_with_index do |e, i|
+        expect(e).to equal(expectations[i])
+      end
+    end
+
+    it 'should retrieve casted symbol arrays' do
+      handle_model.sym_array = ['foo', 'bar', 'baz']
+      expect(handle_model.sym_array).to eq([:foo, :bar, :baz])
+    end
+
+    it 'should default arrays to []' do
+      expect(handle_model.ary).to eq([])
+    end
 
-  it 'should default arrays to []' do
-    expect(handle_model.ary).to eq([])
+    it 'should allow default values for arrays' do
+      expect(handle_model.defaulted_ary).to eq([1, 2, 3])
+    end
   end
 
-  it 'should allow default values for arrays' do
-    expect(handle_model.defaulted_ary).to eq([1, 2, 3])
+  context 'when handling as set' do
+    it 'should retrieve casted float sets' do
+      handle_model.float_set = Set.new([12, 24, 48])
+      expect(handle_model.float_set).to eq(Set.new([12.0, 24.0, 48.0]))
+    end
+
+    it 'should retrieve casted symbol arrays' do
+      handle_model.sym_set = Set.new(['foo', 'bar', 'baz'])
+      expect(handle_model.sym_set).to eq(Set.new([:foo, :bar, :baz]))
+    end
+
+    it 'should default sets to empty sets' do
+      expect(handle_model.my_set).to eq(Set.new)
+    end
+
+    it 'should allow default values for arrays' do
+      expect(handle_model.defaulted_ary).to eq([1, 2, 3])
+    end
   end
 
   context 'legacy support' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-15 00:00:00.000000000 Z
+date: 2016-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -142,6 +142,7 @@ files:
 - dynamini.gemspec
 - lib/.DS_Store
 - lib/dynamini.rb
+- lib/dynamini/adder.rb
 - lib/dynamini/base.rb
 - lib/dynamini/batch_operations.rb
 - lib/dynamini/client_interface.rb
@@ -153,6 +154,7 @@ files:
 - lib/dynamini/test_client.rb
 - lib/dynamini/testing.rb
 - lib/dynamini/type_handler.rb
+- spec/dynamini/adder_spec.rb
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
 - spec/dynamini/dirty_spec.rb
@@ -187,6 +189,7 @@ signing_key:
 specification_version: 4
 summary: DynamoDB interface
 test_files:
+- spec/dynamini/adder_spec.rb
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
 - spec/dynamini/dirty_spec.rb