dynamini 2.7.0 → 2.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e1c5e5210674b1e75d93ca770697f796b9ca42e
-  data.tar.gz: 4de485ac6fa5fad8375104f6e3049abf3a542d09
+  metadata.gz: 15802466753d1d5ac670e2d1649cecb5f4cf8334
+  data.tar.gz: b2c044abc94835728ab8b356be4f771ef3246f2c
 SHA512:
-  metadata.gz: 141816813ba6319ebbede710503514cc1a88a55a2f915bc65e7b5d450e21b1ebd96e9df0b4fa6a1d0bf1e27e4f682d8f2eff3c13c87e824d8228dff608bfe1a2
-  data.tar.gz: 49a6b6842b43c606b6e766709d11de5ca8ef0da0eee8039446a3d00a0b8f165ff6ac1aff5a0d88869b62d9a0dd886c00413f6be51802ebf2a844960db5644712
+  metadata.gz: a6224689aaedb675bbdb9ab84fddd710184666e6357c525affc799d4d5befc5c04a640d68785df8352e3282ea5c3a9d69bf187885656df60382a65aa89700abe
+  data.tar.gz: 09bccbb64058d707bb4cc72f7af7ee50ef1ea6daaa3ef172c869d29ec304d7eeaa6179ca269cf243341bd369d40a56b56396ee57edd3de473b3609da791a46c6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.6.8)
+    dynamini (2.7.3)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
@@ -101,4 +101,4 @@ DEPENDENCIES
   rspec (~> 3)
 
 BUNDLED WITH
-   1.12.5
+   1.13.6

data/README.md

@@ -40,10 +40,12 @@ Instance methods:
 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:
 
-* 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 
+* 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.
 * increment!({attribute1: amount, attribute2: amount}) - to update your record using DynamoDB's Atomic Counter functionality. (For more information, see http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.AtomicCounters )
 * add_to(attribute, value) - If you use this to modify your attribute, when saving, Dynamini will update that attribute with ADD instead of PUT. Your attribute must be handled as an addable type - :integer, :float, :array, :set, :date, or :time. (For more information on ADD actions, see http://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html )
+* delete_attribute(attribute) - Use this to delete an attribute from a record completely, rather than just blanking it or nullifying it.
+* 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:
@@ -65,7 +67,7 @@ class Vehicle < Dynamini::Base
     set_table_name 'cars-dev' # 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
-    
+
     # ...All the rest of your class methods, instance methods, and validators
 end
 ```
@@ -111,17 +113,17 @@ You can save arrays and sets to your Dynamini model. Optionally, you can have Dy
 ```ruby
 class Vehicle < Dynamini::Base
     set_hash_key :vin
-    handle :parts, :array, of: :symbol # :of accepts all types except :set and :array 
+    handle :parts, :array, of: :symbol # :of accepts all types except :set and :array
     handle :other_array, :array
 end
 
-car = Vehicle.new(vin: 'H3LL0')
+car = Vehicle.create(vin: 'H3LL0')
 car.parts
 > []
 
 car.parts = ['wheel']
 car.parts
-> :wheel
+> [:wheel]
 
 car.parts = ['wheel', 'brakes', 'seat']
 car.parts

data/dynamini.gemspec

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

data/lib/dynamini/attributes.rb

@@ -0,0 +1,110 @@
+module Dynamini
+  module Attributes
+
+    ADDABLE_TYPES = [:set, :array, :integer, :float, :time, :date]
+    DELETED_TOKEN = '__deleted__'
+
+    attr_reader :attributes
+
+    def assign_attributes(attributes)
+      attributes.each do |key, value|
+        write_attribute(key, value)
+      end
+      nil
+    end
+
+    def update_attribute(key, value, options = {})
+      write_attribute(key, value)
+      save!(options)
+    end
+
+    def update_attributes(attributes, options = {})
+      assign_attributes(attributes)
+      save!(options)
+    end
+
+    def add_to(attribute, value)
+      complain_about(attribute) unless self.class.handles[attribute]
+      old_value = read_attribute(attribute)
+      add_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS,  self.class.handles[attribute], value, true)
+      if ADDABLE_TYPES.include? self.class.handles[attribute][:format]
+        @attributes[attribute] ? @attributes[attribute] += add_value : @attributes[attribute] = add_value
+      else
+        complain_about(attribute)
+      end
+      record_change(attribute, old_value, add_value, 'ADD')
+      self
+    end
+
+    def delete_attribute(attribute)
+      old_value = read_attribute(attribute)
+      record_change(attribute, old_value, DELETED_TOKEN, 'DELETE')
+      @attributes.delete(attribute)
+    end
+
+    def delete_attribute!(attribute)
+      delete_attribute(attribute)
+      save!
+    end
+
+    private
+
+    def attribute_updates
+      changes.reduce({}) do |updates, (key, value)|
+        current_value = value[1]
+        updates[key] = { value: current_value, action: value[2] || 'PUT' }
+        updates
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if write_method?(name)
+        write_attribute(attribute_name(name), args.first)
+      elsif was_method?(name)
+        __was(name)
+      elsif read_method?(name)
+        read_attribute(name)
+      else
+        super
+      end
+    end
+
+    def attribute_name(name)
+      name[0..-2].to_sym
+    end
+
+    def read_method?(name)
+      name =~ /^([a-zA-Z][-_\w]*)[^=?]*$/
+    end
+
+    def write_method?(name)
+      name =~ /^([a-zA-Z][-_\w]*)=.*$/
+    end
+
+    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
+
+    def respond_to_missing?(name, include_private = false)
+      @attributes.keys.include?(name) || write_method?(name) || was_method?(name) || super
+    end
+
+    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?
+        new_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handle, new_value, change)
+      end
+      @attributes[attribute] = new_value
+      record_change(attribute, old_value, new_value, options[:action]) if change && new_value != old_value
+    end
+
+    def read_attribute(name)
+      value = @attributes[name]
+      if (handle = self.class.handles[name.to_sym])
+        value = handle[:options][:default] if value.nil?
+        value = self.class.attribute_callback(TypeHandler::GETTER_PROCS, handle, value, false) unless value.nil?
+      end
+      value
+    end
+  end
+end

data/lib/dynamini/base.rb

@@ -4,7 +4,7 @@ require_relative 'client_interface'
 require_relative 'dirty'
 require_relative 'increment'
 require_relative 'type_handler'
-require_relative 'adder'
+require_relative 'attributes'
 require_relative 'errors'
 
 module Dynamini
@@ -18,9 +18,8 @@ module Dynamini
     include Dynamini::ClientInterface
     include Dynamini::Dirty
     include Dynamini::Increment
-    include Dynamini::Adder
+    include Dynamini::Attributes
 
-    attr_reader :attributes
     class_attribute :handles
 
     self.handles = {
@@ -93,23 +92,6 @@ module Dynamini
       hash_key == other.hash_key if other.is_a?(self.class)
     end
 
-    def assign_attributes(attributes)
-      attributes.each do |key, value|
-        write_attribute(key, value)
-      end
-      nil
-    end
-
-    def update_attribute(key, value, options = {})
-      write_attribute(key, value)
-      save!(options)
-    end
-
-    def update_attributes(attributes, options = {})
-      assign_attributes(attributes)
-      save!(options)
-    end
-
     def save(options = {})
       run_callbacks :save do
         @changes.empty? || (valid? && trigger_save(options))
@@ -176,59 +158,5 @@ module Dynamini
       key_hash[self.range_key] = handled_key(self.range_key, range_value) if self.range_key
       key_hash
     end
-
-    def attribute_updates
-      changes.reduce({}) do |updates, (key, value)|
-        current_value = value[1]
-        updates[key] = { value: current_value, action: value[2] || 'PUT' }
-        updates
-      end
-    end
-
-    def method_missing(name, *args, &block)
-      if write_method?(name)
-        write_attribute(attribute_name(name), args.first)
-      elsif was_method?(name)
-        __was(name)
-      elsif read_method?(name)
-        read_attribute(name)
-      else
-        super
-      end
-    end
-
-    def attribute_name(name)
-      name[0..-2].to_sym
-    end
-
-    def read_method?(name)
-      name =~ /^([a-zA-Z][-_\w]*)[^=?]*$/
-    end
-
-    def write_method?(name)
-      name =~ /^([a-zA-Z][-_\w]*)=.*$/
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      @attributes.keys.include?(name) || write_method?(name) || was_method?(name) || super
-    end
-
-    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?
-        new_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handle, new_value, change)
-      end
-      @attributes[attribute] = new_value
-      record_change(attribute, old_value, new_value, options[:action]) if change && new_value != old_value
-    end
-
-    def read_attribute(name)
-      value = @attributes[name]
-      if (handle = self.class.handles[name.to_sym])
-        value = handle[:options][:default] if value.nil?
-        value = self.class.attribute_callback(TypeHandler::GETTER_PROCS, handle, value, false) unless value.nil?
-      end
-      value
-    end
   end
 end

data/lib/dynamini/test_client.rb

@@ -229,11 +229,14 @@ module Dynamini
     def handle_updates(args, hash_key_value, range_key_value, attribute_hash)
       table = get_table(args[:table_name])
       args[:attribute_updates].each do |k, v|
-        if v[:action] == 'ADD' && table[hash_key_value]
-          # if record has been saved
+        if v[:action] == 'ADD' && table[hash_key_value] # if record has been saved, otherwise use a simple setter for add
           data = table[hash_key_value]
           data = (data[range_key_value] ||= {}) if range_key_value
           attribute_hash[k] = data[k] ? data[k] + v[:value] : v[:value]
+        elsif v[:action] == 'DELETE'
+          data = table[hash_key_value]
+          data = (data[range_key_value] ||= {}) if range_key_value
+          data.delete(k)
         else
           attribute_hash[k] = v[:value]
         end

data/spec/dynamini/attributes_spec.rb

@@ -0,0 +1,230 @@
+require 'spec_helper'
+
+describe Dynamini::Attributes do
+
+  class HandledModel < Dynamini::Base
+    handle :price, :float
+    handle :things, :set
+    handle :stuff, :array
+    handle :when, :date
+    handle :what_time, :time
+    handle :widget_count, :integer
+    handle :new_set, :set
+    handle :new_array, :array
+  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) { HandledModel.new(model_attributes) }
+
+  describe '#attributes' do
+    it 'should return all attributes of the object' do
+      expect(model.attributes).to include model_attributes
+    end
+  end
+
+  describe '#assign_attributes' do
+    it 'should return nil' do
+      expect(model.assign_attributes(price: '5')).to be_nil
+    end
+
+    it 'should update the attributes of the model' do
+      model.assign_attributes(price: '5')
+      expect(model.attributes[:price]).to eq(5.0)
+    end
+
+    it 'should append changed attributes to @changed' do
+      model.save
+      model.assign_attributes(name: 'Widget', price: '5')
+      expect(model.changed).to eq ['price']
+    end
+  end
+
+  describe '#update_attribute' do
+
+    it 'should update the attribute and save the object' do
+      expect(model).to receive(:save!)
+      model.update_attribute(:name, 'Widget 2.0')
+      expect(model.name).to eq('Widget 2.0')
+    end
+  end
+
+  describe '#update_attributes' do
+    it 'should update multiple attributes and save the object' do
+      expect(model).to receive(:save!)
+      model.update_attributes(name: 'Widget 2.0', price: '12.00')
+      expect(model.attributes).to include(name: 'Widget 2.0', price: 12.00)
+    end
+  end
+
+  describe 'reader method' do
+    it 'responds to handled columns but not unhandled columns' do
+      expect(model).to respond_to(:price)
+      expect(model).not_to respond_to(:foo)
+    end
+
+    context 'existing attribute' do
+      it 'should return the attribute' do
+        expect(model.price).to eq(9.99)
+      end
+    end
+
+    context 'new attribute' do
+      before { model.description = 'test model' }
+      it 'should return the attribute' do
+        expect(model.description).to eq('test model')
+      end
+    end
+
+    context 'nonexistent attribute' do
+      it 'should return nil' do
+        expect(model.foo).to be_nil
+      end
+    end
+
+    context 'attribute set to nil' do
+      before { model.price = nil }
+      it 'should return nil' do
+        expect(model.price).to be_nil
+      end
+    end
+  end
+
+  describe 'writer method' do
+    it 'responds to handled columns but not unhandled columns' do
+      expect(model).to respond_to(:price=)
+    end
+
+    context 'existing attribute' do
+      before { model.price = '1' }
+      it 'should overwrite the attribute' do
+        expect(model.price).to eq(1.0)
+      end
+    end
+    context 'new attribute' do
+      before { model.foo = 'bar' }
+      it 'should write to the attribute' do
+        expect(model.foo).to eq('bar')
+      end
+    end
+
+    context 'arrays' do
+      it 'should write to the attribute and switch type freely' do
+        model.foo = ['bar', 'baz']
+        expect(model.foo).to eq(['bar', 'baz'])
+        model.foo = ['quux']
+        expect(model.foo).to eq(['quux'])
+        model.foo = 'zort'
+        expect(model.foo).to eq('zort')
+        model.foo = []
+        expect(model.foo).to eq([])
+      end
+    end
+  end
+
+  describe '#delete_attribute' do
+    context 'the attribute exists' do
+      it 'should enqueue a DELETE change for that attribute' do
+        model.delete_attribute(:stuff)
+        expect(model.changes['stuff']).to eq([model_attributes[:stuff], Dynamini::Attributes::DELETED_TOKEN, 'DELETE'])
+      end
+
+      it 'should remove the attribute from the in-memory attributes' do
+        model.delete_attribute('stuff')
+        expect(model.attributes.keys).to_not include('stuff')
+      end
+    end
+
+    context 'the attribute does not exist' do
+      it 'does nothing' do
+        model.delete_attribute('non-existent')
+      end
+    end
+  end
+
+  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
+      context 'adding to an uninitialized set' do
+        it 'creates the set' do
+          model.add_to(:new_set, Set.new([4]))
+          expect(model.new_set).to eq(Set.new([4]))
+        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
+      context 'adding to an empty array' do
+        it 'creates the array' do
+          model.add_to(:new_array, [4])
+          expect(model.new_array).to eq([4])
+        end
+      end
+    end
+
+    context 'without reading a previously saved item' do
+      it 'still adds' do
+        model.save
+        model_clone = HandledModel.new(id: model_attributes[:id])
+        model_clone.add_to(:price, 2)
+        model_clone.save
+        expect(HandledModel.find(model_attributes[:id]).price).to eq(11.99)
+      end
+    end
+  end
+end

data/spec/dynamini/base_spec.rb

@@ -115,39 +115,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '#assign_attributes' do
-      it 'should return nil' do
-        expect(model.assign_attributes(price: '5')).to be_nil
-      end
-
-      it 'should update the attributes of the model' do
-        model.assign_attributes(price: '5')
-        expect(model.attributes[:price]).to eq('5')
-      end
-
-      it 'should append changed attributes to @changed' do
-        model.assign_attributes(name: 'Widget', price: '5')
-        expect(model.changed).to eq ['price']
-      end
-    end
-
-    describe '#update_attribute' do
-
-      it 'should update the attribute and save the object' do
-        expect(model).to receive(:save!)
-        model.update_attribute(:name, 'Widget 2.0')
-        expect(model.name).to eq('Widget 2.0')
-      end
-    end
-
-    describe '#update_attributes' do
-      it 'should update multiple attributes and save the object' do
-        expect(model).to receive(:save!)
-        model.update_attributes(name: 'Widget 2.0', price: '12.00')
-        expect(model.attributes).to include(name: 'Widget 2.0', price: '12.00')
-      end
-    end
-
     describe '#save' do
       it 'should run before and after save callbacks' do
         expect_any_instance_of(TestClassWithCallbacks).to receive(:before_callback)
@@ -412,127 +379,60 @@ describe Dynamini::Base do
   end
 
 
-  describe 'attributes' do
-    describe '#attributes' do
-      it 'should return all attributes of the object' do
-        expect(model.attributes).to include model_attributes
-      end
+  describe '#new_record?' do
+    it 'should return true for a new record' do
+      expect(Dynamini::Base.new).to be_truthy
     end
-
-    describe '#new_record?' do
-      it 'should return true for a new record' do
-        expect(Dynamini::Base.new).to be_truthy
-      end
-      it 'should return false for a retrieved record' do
-        expect(Dynamini::Base.find('abcd1234').new_record?).to be_falsey
-      end
-      it 'should return false after a new record is saved' do
-        expect(model.new_record?).to be_falsey
-      end
+    it 'should return false for a retrieved record' do
+      expect(Dynamini::Base.find('abcd1234').new_record?).to be_falsey
     end
+    it 'should return false after a new record is saved' do
+      expect(model.new_record?).to be_falsey
+    end
+  end
 
-    describe 'reader method' do
-      it { is_expected.to respond_to(:price) }
-      it { is_expected.not_to respond_to(:foo) }
 
-      context 'existing attribute' do
-        it 'should return the attribute' do
-          expect(model.price).to eq(9.99)
-        end
-      end
 
-      context 'new attribute' do
-        before { model.description = 'test model' }
-        it 'should return the attribute' do
-          expect(model.description).to eq('test model')
-        end
-      end
+  describe '#key' do
+    context 'when using hash key only' do
 
-      context 'nonexistent attribute' do
-        it 'should return nil' do
-          expect(subject.foo).to be_nil
+      before do
+        class TestClass < Dynamini::Base
+          set_hash_key :foo
         end
       end
 
-      context 'attribute set to nil' do
-        before { model.price = nil }
-        it 'should return nil' do
-          expect(model.price).to be_nil
-        end
+      it 'should return an hash containing only the hash_key name and value' do
+        expect(TestClass.new(foo: 2).send(:key)).to eq(foo: 2)
       end
     end
-
-    describe 'writer method' do
-      it { is_expected.to respond_to(:baz=) }
-
-      context 'existing attribute' do
-        before { model.price = '1' }
-        it 'should overwrite the attribute' do
-          expect(model.price).to eq('1')
-        end
-      end
-      context 'new attribute' do
-        before { model.foo = 'bar' }
-        it 'should write to the attribute' do
-          expect(model.foo).to eq('bar')
-        end
-      end
-
-      context 'arrays' do
-        it 'should write to the attribute and switch type freely' do
-          model.foo = ['bar', 'baz']
-          expect(model.foo).to eq(['bar', 'baz'])
-          model.foo = ['quux']
-          expect(model.foo).to eq(['quux'])
-          model.foo = 'zort'
-          expect(model.foo).to eq('zort')
-          model.foo = []
-          expect(model.foo).to eq([])
-        end
+    context 'when using both hash_key and range_key' do
+      it 'should return an hash containing only the hash_key name and value' do
+        key_hash = TestClassWithRange.new(foo: 2, bar: 2015).send(:key)
+        expect(key_hash).to eq(foo: 2, bar: 2015)
       end
     end
+  end
 
-    describe '#key' do
-      context 'when using hash key only' do
-
-        before do
-          class TestClass < Dynamini::Base
-            set_hash_key :foo
-          end
-        end
-
-        it 'should return an hash containing only the hash_key name and value' do
-          expect(TestClass.new(foo: 2).send(:key)).to eq(foo: 2)
-        end
-      end
-      context 'when using both hash_key and range_key' do
-        it 'should return an hash containing only the hash_key name and value' do
-          key_hash = TestClassWithRange.new(foo: 2, bar: 2015).send(:key)
-          expect(key_hash).to eq(foo: 2, bar: 2015)
-        end
+  describe '#set_secondary_index' do
+    it 'should return an hash containing only the hash_key and range_key name and value when setting a global secondary index' do
+      class TestClass < Dynamini::Base
+        set_hash_key :foo
+        set_range_key :bar
+        set_secondary_index :git_baz, hash_key: :git, range_key: :baz
       end
-    end
 
-    describe '#set_secondary_index' do
-      it 'should return an hash containing only the hash_key and range_key name and value when setting a global secondary index' do
-        class TestClass < Dynamini::Base
-          set_hash_key :foo
-          set_range_key :bar
-          set_secondary_index :git_baz, hash_key: :git, range_key: :baz
-        end
+      expect(TestClass.secondary_index['git_baz']).to eq(hash_key_name: :git, range_key_name: :baz)
+    end
 
-        expect(TestClass.secondary_index['git_baz']).to eq(hash_key_name: :git, range_key_name: :baz)
+    it 'should return an hash containing only the hash_key and range_key name and value when setting a local secondary index' do
+      class TestClass < Dynamini::Base
+        set_hash_key :foo
+        set_range_key :bar
+        set_secondary_index :foo_baz, range_key: :baz
       end
 
-      it 'should return an hash containing only the hash_key and range_key name and value when setting a local secondary index' do
-        class TestClass < Dynamini::Base
-          set_hash_key :foo
-          set_range_key :bar
-          set_secondary_index :foo_baz, range_key: :baz
-        end
-
-        expect(TestClass.secondary_index['foo_baz']).to eq(hash_key_name: :foo, range_key_name: :baz)
-      end
+      expect(TestClass.secondary_index['foo_baz']).to eq(hash_key_name: :foo, range_key_name: :baz)
     end
   end
 end

data/spec/dynamini/test_client_spec.rb

@@ -33,6 +33,13 @@ describe Dynamini::TestClient do
         test_client.update_item(table_name: table_name, key: {hash_key_name: 'hash_key_value'}, attribute_updates: {abc: {value: Set.new([2]), action: 'ADD'}})
         expect(test_client.data[table_name]['hash_key_value']).to eq(abc: Set.new([1, 2]), hash_key_name: 'hash_key_value')
       end
+
+      it 'DELETEs attributes' 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: {action: 'DELETE'}})
+        expect(test_client.data[table_name]['hash_key_value']).to eq(hash_key_name: 'hash_key_value')
+      end
     end
 
     context 'with Hash key and range key' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.7.3
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-24 00:00:00.000000000 Z
+date: 2016-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -142,7 +142,7 @@ files:
 - dynamini.gemspec
 - lib/.DS_Store
 - lib/dynamini.rb
-- lib/dynamini/adder.rb
+- lib/dynamini/attributes.rb
 - lib/dynamini/base.rb
 - lib/dynamini/batch_operations.rb
 - lib/dynamini/client_interface.rb
@@ -155,7 +155,7 @@ files:
 - lib/dynamini/test_client.rb
 - lib/dynamini/testing.rb
 - lib/dynamini/type_handler.rb
-- spec/dynamini/adder_spec.rb
+- spec/dynamini/attributes_spec.rb
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
 - spec/dynamini/dirty_spec.rb
@@ -190,7 +190,7 @@ signing_key:
 specification_version: 4
 summary: DynamoDB interface
 test_files:
-- spec/dynamini/adder_spec.rb
+- spec/dynamini/attributes_spec.rb
 - spec/dynamini/base_spec.rb
 - spec/dynamini/batch_operations_spec.rb
 - spec/dynamini/dirty_spec.rb

data/lib/dynamini/adder.rb

@@ -1,25 +0,0 @@
-module Dynamini
-  module Adder
-
-    ADDABLE_TYPES = [:set, :array, :integer, :float, :time, :date]
-
-    def add_to(attribute, value)
-      complain_about(attribute) unless handles[attribute]
-      old_value = read_attribute(attribute)
-      add_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handles[attribute], value, true)
-      if ADDABLE_TYPES.include? handles[attribute][:format]
-        @attributes[attribute] ? @attributes[attribute] += add_value : @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/spec/dynamini/adder_spec.rb

@@ -1,106 +0,0 @@
-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
-    handle :new_set, :set
-    handle :new_array, :array
-  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) }
-
-
-  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
-      context 'adding to an uninitialized set' do
-        it 'creates the set' do
-          model.add_to(:new_set, Set.new([4]))
-          expect(model.new_set).to eq(Set.new([4]))
-        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
-      context 'adding to an empty array' do
-        it 'creates the array' do
-          model.add_to(:new_array, [4])
-          expect(model.new_array).to eq([4])
-        end
-      end
-    end
-
-    context 'without reading a previously saved item' do
-      it 'still adds' do
-        model.save
-        model2 = AddHandledModel.new(id: model_attributes[:id])
-        model2.add_to(:price, 2)
-        model2.save
-        expect(AddHandledModel.find(model_attributes[:id]).price).to eq(11.99)
-      end
-    end
-  end
-end