dynamini 1.10.2 → 1.10.4

data/lib/dynamini/querying.rb

@@ -16,8 +16,8 @@ module Dynamini
     end
 
     def find_or_new(hash_value, range_value = nil)
-      fail 'Key cannot be blank.' if (hash_value.nil? || hash_value == '')
-      fail 'Range key cannot be blank.' if range_key && range_value.nil?
+      validate_query_values(hash_value, range_value)
+
 
       r = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
       if r.item
@@ -39,6 +39,12 @@ module Dynamini
       objects
     end
 
+    protected
+
+    def range_is_numeric?
+      handles[@range_key] && [:integer, :time, :float, :date].include?(handles[@range_key][:format])
+    end
+
     private
 
     def dynamo_query(args)
@@ -72,30 +78,9 @@ module Dynamini
       expression
     end
 
-    #FIXME unused method
-    def build_range_expression(start_value, end_value)
-      operator = (
-      if start_value && end_value
-        'BETWEEN'
-      elsif start_value
-        'GE'
-      elsif end_value
-        'LE'
-      end
-      )
-      attribute_value_list = []
-
-      if handle = handles[range_key.to_sym]
-        attribute_value_list << attribute_callback(SETTER_PROCS, handle, start_value) if start_value
-        attribute_value_list << attribute_callback(SETTER_PROCS, handle, end_value) if end_value
-      else
-        attribute_value_list << start_value if start_value
-        attribute_value_list << end_value if end_value
-      end
-
-      {attribute_value_list: attribute_value_list, comparison_operator: operator}
+    def validate_query_values(hash_value, range_value)
+      fail 'Key cannot be blank.' if (hash_value.nil? || hash_value == '')
+      fail 'Range key cannot be blank.' if range_key && range_value.nil?
     end
-
-
   end
 end

data/lib/dynamini/test_client.rb

@@ -61,7 +61,7 @@ module Dynamini
       OpenStruct.new(item: attributes_hash)
     end
 
-    #FIXME Add range key support
+    # No range key support - use query instead.
     def batch_get_item(args = {})
       responses = {}
 
@@ -76,7 +76,7 @@ module Dynamini
       OpenStruct.new(responses: responses)
     end
 
-    #FIXME Add range key support
+    # TODO add range key support
     def batch_write_item(request_options)
       request_options[:request_items].each do |table_name, put_requests|
         put_requests.each do |request_hash|

data/lib/dynamini/type_handler.rb

@@ -0,0 +1,58 @@
+module Dynamini
+  module TypeHandler
+    module ClassMethods
+      def handle(column, format_class, options = {})
+        self.handles = self.handles.merge(column => { format: format_class, options: options })
+
+        define_handled_getter(column, format_class, options)
+        define_handled_setter(column, format_class)
+      end
+
+      def define_handled_getter(column, format_class, _options = {})
+        proc = GETTER_PROCS[format_class]
+        fail 'Unsupported data type: ' + format_class.to_s if proc.nil?
+
+        define_method(column) do
+          read_attribute(column)
+        end
+      end
+
+      def define_handled_setter(column, format_class)
+        method_name = (column.to_s + '=')
+        proc = SETTER_PROCS[format_class]
+        fail 'Unsupported data type: ' + format_class.to_s if proc.nil?
+        define_method(method_name) do |value|
+          write_attribute(column, value)
+        end
+      end
+    end
+
+    GETTER_PROCS = {
+        integer:  proc { |v| v.to_i },
+        date:     proc { |v| v.is_a?(Date) ? v : Time.at(v).to_date },
+        time:     proc { |v| Time.at(v.to_f) },
+        float:    proc { |v| v.to_f },
+        symbol:   proc { |v| v.to_sym },
+        string:   proc { |v| v },
+        boolean:  proc { |v| v }
+    }
+
+    SETTER_PROCS = {
+        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 },
+        boolean:  proc { |v| v },
+        date:     proc { |v| v.to_time.to_f }
+    }
+
+    def handles
+      self.class.handles
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/spec/dynamini/base_spec.rb

@@ -45,58 +45,9 @@ describe Dynamini::Base do
     end
   end
 
-  describe '.client' do
-    it 'should not reinstantiate the client' do
-      expect(Dynamini::TestClient).to_not receive(:new)
-      Dynamini::Base.client
-    end
-  end
 
   describe 'operations' do
 
-    describe '.handle' do
-
-      class HandledClass < Dynamini::Base;
-      end
-
-      context 'when reading the handled attirubte' do
-        before { HandledClass.handle :price, :integer, default: 9 }
-        it 'should return the proper format' do
-          object = HandledClass.new(price: "1")
-          expect(object.price).to eq(1)
-        end
-        it 'should return the default value if not assigned' do
-          object = HandledClass.new
-          expect(object.price).to eq(9)
-        end
-        it 'should return an array with formated item if handled' do
-          object = HandledClass.new(price: ["1", "2"])
-          expect(object.price).to eq([1, 2])
-        end
-      end
-
-      context 'when writing the handled attribute' do
-        before { HandledClass.handle :price, :float, default: 9 }
-        it 'should convert the value to handled format' do
-          object = HandledClass.new(price: "1")
-          expect(object.attributes[:price]).to eq(1.0)
-        end
-      end
-
-    end
-
-    describe '.new' do
-      let(:dirty_model) { Dynamini::Base.new(model_attributes) }
-
-      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
-
-      it 'should not include the primary key in the changes' do
-        expect(dirty_model.changes[:id]).to be_nil
-      end
-    end
-
     describe '.create' do
       it 'should save the item' do
         other_model_attributes = model_attributes
@@ -119,79 +70,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '.increment!' do
-      context 'when incrementing a nil value' do
-        it 'should save' do
-          expect(model.class.client).to receive(:update_item).with(
-                                            table_name: 'bases',
-                                            key: {id: model_attributes[:id]},
-                                            attribute_updates: hash_including(
-                                                "foo" => {
-                                                    value: 5,
-                                                    action: 'ADD'
-                                                }
-                                            )
-                                        )
-          model.increment!(foo: 5)
-        end
-        it 'should update the value' do
-          model.increment!(foo: 5)
-          expect(Dynamini::Base.find('abcd1234').foo.to_i).to eq 5
-        end
-      end
-      context 'when incrementing a numeric value' do
-        it 'should save' do
-          expect(model).to receive(:read_attribute).and_return(9.99)
-          expect(model.class.client).to receive(:update_item).with(
-                                            table_name: 'bases',
-                                            key: {id: model_attributes[:id]},
-                                            attribute_updates: hash_including(
-                                                "price" => {
-                                                    value: 5,
-                                                    action: 'ADD'
-                                                }
-                                            )
-                                        )
-          model.increment!(price: 5)
-
-        end
-        it 'should sum the values' do
-          expect(model).to receive(:read_attribute).and_return(9.99)
-          model.increment!(price: 5)
-          expect(Dynamini::Base.find('abcd1234').price).to eq 14.99
-        end
-      end
-      context 'when incrementing a non-numeric value' do
-        it 'should raise an error and not save' do
-          expect(model).to receive(:read_attribute).and_return('hello')
-          expect { model.increment!(price: 5) }.to raise_error(StandardError)
-        end
-      end
-      context 'when incrementing with a non-numeric value' do
-        it 'should raise an error and not save' do
-          expect { model.increment!(foo: 'bar') }.to raise_error(StandardError)
-        end
-      end
-      context 'when incrementing multiple values' do
-        it 'should create/sum both values' do
-          allow(model).to receive(:read_attribute).and_return(9.99)
-          model.increment!(price: 5, baz: 6)
-          found_model = Dynamini::Base.find('abcd1234')
-          expect(found_model.price).to eq 14.99
-          expect(found_model.baz).to eq 6
-        end
-      end
-      context 'when incrementing a new record' do
-        it 'should save the record and init the values and timestamps' do
-          Dynamini::Base.new(id: 1, foo: 'bar').increment!(baz: 1)
-          found_model = Dynamini::Base.find(1)
-          expect(found_model.baz).to eq 1
-          expect(found_model.created_at).to_not be_nil
-          expect(found_model.updated_at).to_not be_nil
-        end
-      end
-    end
-
     describe '#==' do
       let(:model_a) { Dynamini::Base.new(model_attributes).tap {
           |model| model.send(:clear_changes)
@@ -503,52 +381,6 @@ describe Dynamini::Base do
     end
   end
 
-  describe 'custom column handling' do
-    class HandleModel < Dynamini::Base
-      handle :price, :float, default: 10
-      handle :start_date, :time
-      handle :int_list, :integer
-      handle :sym_list, :symbol
-    end
-
-    let(:handle_model) { HandleModel.new }
-
-    it 'should create getters and setters' do
-      expect(handle_model).to_not receive(:method_missing)
-      handle_model.price = 1
-      handle_model.price
-    end
-
-    it 'should retrieve price as a float' do
-      handle_model.price = '5.2'
-      expect(handle_model.price).to be_a(Float)
-    end
-
-    it 'should default price to 0 if not set' do
-      expect(handle_model.price).to eq 10
-    end
-
-    it 'should store times as floats' do
-      handle_model.start_date = Time.now
-      expect(handle_model.attributes[:start_date]).to be_a(Float)
-      expect(handle_model.attributes[:start_date] > 1_000_000_000).to be_truthy
-      expect(handle_model.start_date).to be_a(Time)
-    end
-
-    it 'should reject bad data' do
-      expect { handle_model.int_list = {a: 1} }.to raise_error NoMethodError
-    end
-
-    it 'should save casted arrays' do
-      handle_model.int_list = [12, 24, 48]
-      expect(handle_model.int_list).to eq([12, 24, 48])
-    end
-
-    it 'should retrieve casted arrays' do
-      handle_model.sym_list = ['foo', 'bar', 'baz']
-      expect(handle_model.sym_list).to eq([:foo, :bar, :baz])
-    end
-  end
 
   describe 'attributes' do
     describe '#attributes' do
@@ -617,122 +449,6 @@ describe Dynamini::Base do
       end
     end
 
-    describe '#__was' do
-
-      context 'nonexistent attribute' do
-        it 'should raise an error' do
-          expect { Dynamini::Base.new.thing_was }.to raise_error ArgumentError
-        end
-      end
-
-      context 'after saving' do
-        it 'should clear all _was values' do
-          model = Dynamini::Base.new
-          model.new_val = 'new'
-          model.save
-          expect(model.new_val_was).to eq('new')
-        end
-      end
-
-      context 'new record' do
-
-        subject(:model) { Dynamini::Base.new(baz: 'baz') }
-        it { is_expected.to respond_to(:baz_was) }
-
-        context 'handled attribute with default' do
-          it 'should return the default value' do
-            Dynamini::Base.handle(:num, :integer, default: 2)
-            expect(model.num_was).to eq(2)
-          end
-        end
-
-        context 'handled attribute with no default' do
-          it 'should return nil' do
-            Dynamini::Base.handle(:num, :integer)
-            expect(model.num_was).to be_nil
-          end
-        end
-
-        context 'newly assigned attribute' do
-          it 'should return nil' do
-            model.new_attribute = 'hello'
-            expect(model.new_attribute_was).to be_nil
-          end
-        end
-      end
-
-      context 'previously saved record' do
-        subject(:model) { Dynamini::Base.new({baz: 'baz', nil_val: nil}, false) }
-        context 'unchanged attribute' do
-          it 'should return the current value' do
-            expect(model.baz_was).to eq('baz')
-          end
-        end
-
-        context 'newly assigned attribute or attribute changed from explicit nil' do
-          it 'should return nil' do
-            model.nil_val = 'no longer nil'
-            model.new_val = 'new'
-            expect(model.nil_val_was).to be_nil
-            expect(model.new_val_was).to be_nil
-          end
-        end
-
-        context 'attribute changed from value to value' do
-          it 'should return the old value' do
-            model.baz = 'baz2'
-            expect(model.baz_was).to eq('baz')
-          end
-        end
-      end
-    end
-
-    describe '#changes' do
-      it 'should not return the hash key or range key' do
-        Dynamini::Base.set_range_key(:range_key)
-        model.instance_variable_set(:@changes, {id: 'test_hash_key', range_key: "test_range_key"})
-        expect(model.changes).to eq({})
-        Dynamini::Base.set_range_key(nil)
-      end
-
-      context 'no change detected' do
-        it 'should return an empty hash' do
-          expect(model.changes).to eq({})
-        end
-      end
-
-      context 'attribute changed' do
-        before { model.price = 1 }
-        it 'should include the changed attribute' do
-          expect(model.changes['price']).to eq([9.99, 1])
-        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'])
-        end
-      end
-
-      context 'attribute changed twice' do
-        before do
-          model.foo = 'bar'
-          model.foo = 'baz'
-        end
-        it 'should only include one copy of the changed attribute' do
-          expect(model.changes['foo']).to eq(['bar', 'baz'])
-        end
-      end
-    end
-
-    describe '#changed' do
-      it 'should stringify the keys of changes' do
-        allow(model).to receive(:changes).and_return({'price' => [1, 2], 'name' => ['a', 'b']})
-        expect(model.changed).to eq(['price', 'name'])
-      end
-    end
-
     describe '#key' do
       context 'when using hash key only' do
 

data/spec/dynamini/client_interface_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Dynamini::ClientInterface do
+  describe '.client' do
+    it 'should not reinstantiate the client' do
+      expect(Dynamini::TestClient).to_not receive(:new)
+      Dynamini::Base.client
+    end
+  end
+end