dynamini 2.6.4 → 2.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aeef2ffc6acac0bce16107fb9ec281db9509bcb2
-  data.tar.gz: c0757f84ebc577b1ea555c61ded01733acb2ee9a
+  metadata.gz: a58fb603731e3efd1d91be0295a9f9c6bb9ab563
+  data.tar.gz: 914d82aa5c7e4c923e1f5d14552043bfab6f966b
 SHA512:
-  metadata.gz: b9fbb688330e9ad1f1c0330f6f45e0e04eff3e2a9524d99d7e3602b2e232fb548e4b5056d14862099206c6cd77a628f26bcc71008f87a8d406d45f66a8652c4f
-  data.tar.gz: a610af70e44ce47b7cec2c80ee927300a9537ee85f52091342888280fce09b1c829b6f8ae3f3116fe3a1903964375bc56702991d8fb13b981063e1c22e6dce90
+  metadata.gz: 35cef4e720792c20f78a3e9db934fc7fc020de29d06c377641fc4a4484b0874822394c391f0bc1dfb7a39a2310054efe68d665171c7900d523bd21fe92276cf1
+  data.tar.gz: c39c01e1d41bbceade9bf3eac3561766389e0763b308dd841e750e7e0440802809d1bcee273abc6d6b618e854aa8aa7f5377aab69b943ac4c6377d0783575591

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamini (2.6.4)
+    dynamini (2.6.5)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
@@ -56,7 +56,7 @@ GEM
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
     method_source (0.8.2)
-    minitest (5.9.0)
+    minitest (5.9.1)
     nenv (0.2.0)
     notiffany (0.0.8)
       nenv (~> 0.1)

data/dynamini.gemspec

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

data/lib/dynamini/adder.rb

@@ -6,7 +6,7 @@ module Dynamini
     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)
+      add_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handles[attribute], value)
       if ADDABLE_TYPES.include? handles[attribute][:format]
         @attributes[attribute] ? @attributes[attribute] += add_value : @attributes[attribute] = add_value
       else

data/lib/dynamini/base.rb

@@ -14,10 +14,10 @@ module Dynamini
     extend ActiveModel::Callbacks
     extend Dynamini::BatchOperations
     extend Dynamini::Querying
+    extend Dynamini::TypeHandler
     include Dynamini::ClientInterface
     include Dynamini::Dirty
     include Dynamini::Increment
-    include Dynamini::TypeHandler
     include Dynamini::Adder
 
     attr_reader :attributes
@@ -30,6 +30,8 @@ module Dynamini
 
     define_model_callbacks :save
 
+    alias :read_attribute_for_serialization :send
+
     class << self
 
       attr_reader :range_key, :secondary_index
@@ -42,12 +44,14 @@ module Dynamini
         @table_name = name
       end
 
-      def set_hash_key(key)
+      def set_hash_key(key, format = nil)
         @hash_key = key
+        handle(key, format) if format
       end
 
-      def set_range_key(key)
+      def set_range_key(key, format = nil)
         @range_key = key
+        handle(key, format) if format
       end
 
       def set_secondary_index(index_name, args)
@@ -168,8 +172,9 @@ module Dynamini
     end
 
     def self.create_key_hash(hash_value, range_value = nil)
-      key_hash = {self.hash_key => hash_value}
-      key_hash[self.range_key] = range_value if self.range_key
+
+      key_hash = {self.hash_key => handled_key(self.hash_key, hash_value)}
+      key_hash[self.range_key] = handled_key(self.range_key, range_value) if self.range_key
       key_hash
     end
 
@@ -211,8 +216,8 @@ module Dynamini
 
     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)
+      if (handle = self.class.handles[attribute.to_sym]) && !new_value.nil?
+        new_value = self.class.attribute_callback(TypeHandler::SETTER_PROCS, handle, new_value)
       end
       @attributes[attribute] = new_value
       record_change(attribute, old_value, new_value, options[:action]) if change && new_value != old_value
@@ -220,9 +225,9 @@ module Dynamini
 
     def read_attribute(name)
       value = @attributes[name]
-      if (handle = handles[name.to_sym])
+      if (handle = self.class.handles[name.to_sym])
         value = handle[:options][:default] if value.nil?
-        value = attribute_callback(GETTER_PROCS, handle, value) unless value.nil?
+        value = self.class.attribute_callback(TypeHandler::GETTER_PROCS, handle, value) unless value.nil?
       end
       value
     end

data/lib/dynamini/querying.rb

@@ -3,6 +3,7 @@ module Dynamini
     OPTIONAL_QUERY_PARAMS = [:limit, :scan_index_forward]
 
     def find(hash_value, range_value = nil)
+      fail ArgumentError, 'Hash key cannot be nil or empty.' if (hash_value.nil? || hash_value.blank?)
       fail 'Range key cannot be blank.' if range_key && range_value.nil?
       response = client.get_item(table_name: table_name, key: create_key_hash(hash_value, range_value))
 

data/lib/dynamini/test_client.rb

@@ -55,8 +55,6 @@ module Dynamini
       table[hash_key_value] ? table[hash_key_value].merge!(updates) : table[hash_key_value] = updates
     end
 
-
-
     def get_item(args = {})
       table = get_table(args[:table_name])
 

data/lib/dynamini/type_handler.rb

@@ -7,7 +7,7 @@ module Dynamini
         time:     proc { |v| Time.at(v.to_f) },
         float:    proc { |v| v.to_f },
         symbol:   proc { |v| v.to_sym },
-        string:   proc { |v| v },
+        string:   proc { |v| v.to_s },
         boolean:  proc { |v| v },
         array:    proc { |v| v.to_a },
         set:      proc { |v| Set.new(v) }
@@ -18,66 +18,66 @@ module Dynamini
         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 },
+        string:   proc { |v| v.to_s },
         boolean:  proc { |v| v },
         date:     proc { |v| v.to_time.to_f },
         array:    proc { |v| v.to_a },
         set:      proc { |v| Set.new(v) }
     }
 
-    module ClassMethods
-      def handle(column, format_class, options = {})
-        validate_handle(format_class, options)
+    def handle(column, format_class, options = {})
+      validate_handle(format_class, options)
 
-        options[:default] ||= format_default(format_class)
-        options[:default] ||= Set.new if format_class == :set
+      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 })
+      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
+      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?
+    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
+      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
+    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
 
-      def format_default(format_class)
-        case format_class
-          when :array
-            []
-          when :set
-            Set.new
-        end
+    def format_default(format_class)
+      case format_class
+        when :array
+          []
+        when :set
+          Set.new
       end
+    end
 
-      def validate_handle(format, options)
-        if format == :set
-          if options[:of] && [:set, :array].include?(options[:of])
-            raise ArgumentError, 'Invalid handle: cannot store non-primitive datatypes within a set.'
-          end
+    def validate_handle(format, options)
+      if format == :set
+        if options[:of] && [:set, :array].include?(options[:of])
+          raise ArgumentError, 'Invalid handle: cannot store non-primitive datatypes within a set.'
         end
       end
     end
 
-    private
-
-    def handles
-      self.class.handles
+    def handled_key(column, value)
+      if handle = handles[column]
+        attribute_callback(GETTER_PROCS, handle, value)
+      else
+        value
+      end
     end
 
     def attribute_callback(procs, handle, value)
@@ -92,14 +92,6 @@ module Dynamini
       end
     end
 
-    def handled_as?(handle, type)
-      type.include? handle[:format]
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
     def should_convert_elements?(handle, value)
       handle[:options][:of] && (value.is_a?(Array) || value.is_a?(Set))
     end
@@ -111,5 +103,9 @@ module Dynamini
     def convert_elements(enumerable, callback)
       enumerable.map { |e| callback.call(e) }
     end
+
+    def handled_as?(handle, type)
+      type.include? handle[:format]
+    end
   end
 end

data/spec/dynamini/querying_spec.rb

@@ -45,7 +45,14 @@ describe Dynamini::Querying do
           TestClassWithRange.find('1', '2')
         end.to raise_error Dynamini::RecordNotFound, "Couldn't find TestClassWithRange with 'foo'=1 and 'bar'=2"
       end
+    end
 
+    context 'when finding a nil or empty id' do
+      it 'raises an error' do
+        expect{ Dynamini::Base.find('') }.to raise_error ArgumentError
+        expect{ Dynamini::Base.find([]) }.to raise_error ArgumentError
+        expect{ Dynamini::Base.find() }.to raise_error ArgumentError
+      end
     end
 
     context 'when retrieving a subclass' do
@@ -57,6 +64,62 @@ describe Dynamini::Querying do
         expect(Foo.find('1')).to be_a Foo
       end
     end
+
+    context 'when hash key is not handled' do
+      context 'when finding a record by integer when hash key was string' do
+        it 'should raise an error' do
+          Dynamini::Base.create!(id: '123', foo: 'bar')
+          expect{ Dynamini::Base.find(123) }.to raise_error(Dynamini::RecordNotFound)
+        end
+      end
+
+      context 'when finding a record by string when hash key was integer' do
+        it 'should not find the item' do
+          Dynamini::Base.create!(id: 123, foo: 'bar')
+          expect{ Dynamini::Base.find('123') }.to raise_error(Dynamini::RecordNotFound)
+        end
+      end
+    end
+
+    context 'when hash key is handled as string' do
+      class StringHandledHash < Dynamini::Base
+        set_hash_key :id, :string
+      end
+
+      context 'when finding a record by integer when hash key was string' do
+        it 'should find the item' do
+          StringHandledHash.create!(id: '123', foo: 'bar')
+          expect(StringHandledHash.find(123).foo).to eq('bar')
+        end
+      end
+
+      context 'when finding a record by string when hash key was integer' do
+        it 'should find the item' do
+          StringHandledHash.create!(id: 123, foo: 'bar')
+          expect(StringHandledHash.find('123').foo).to eq('bar')
+        end
+      end
+    end
+
+    context 'when hash key is handled as integer' do
+      class IntegerHandledHash < Dynamini::Base
+        set_hash_key :id, :integer
+      end
+
+      context 'when finding a record by integer when hash key was string' do
+        it 'should the item' do
+          IntegerHandledHash.create!(id: '123', foo: 'bar')
+          expect(IntegerHandledHash.find(123).foo).to eq('bar')
+        end
+      end
+
+      context 'when finding a record by string when hash key was integer' do
+        it 'should find the item' do
+          IntegerHandledHash.create!(id: 123, foo: 'bar')
+          expect(IntegerHandledHash.find('123').foo).to eq('bar')
+        end
+      end
+    end
   end
 
   describe '.find_or_nil' do

data/spec/dynamini/test_client_spec.rb

@@ -81,7 +81,7 @@ describe Dynamini::TestClient do
         expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}).item[:test_attr]).to eq('test')
       end
 
-      it 'should returns nil if the item does not exist' do
+      it 'should return nil if the item does not exist' do
         expect(test_client.get_item(table_name: table_name, key: {test_client.hash_key_attr => "abc"}).item).to eq(nil)
       end
 
@@ -116,6 +116,23 @@ describe Dynamini::TestClient do
         expect(test_client.get_item(table_name: table_name, key: {test_client.range_key_attr => 'def'}).item).to eq(nil)
       end
     end
+
+    context 'hash key is not handled' do
+      let(:test_client) { Dynamini::TestClient.new(:hash_key_name) }
+      context 'getting a record by integer when hash key is string' do
+        it 'should not find the item' do
+          test_client.update_item(table_name: table_name, key: {test_client.hash_key_attr => '123'}, attribute_updates: {test_attr: {value: 'test', action: 'PUT'}})
+          expect(test_client.get_item(table_name: table_name, key: {test_client.range_key_attr => 123}).item).to eq(nil)
+        end
+      end
+
+      context 'getting a record by string when hash key is integer' do
+        it 'should not find the item' do
+          test_client.update_item(table_name: table_name, key: {test_client.hash_key_attr => 123}, attribute_updates: {test_attr: {value: 'test', action: 'PUT'}})
+          expect(test_client.get_item(table_name: table_name, key: {test_client.range_key_attr => '123'}).item).to eq(nil)
+        end
+      end
+    end
   end
 
   describe '#query' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 2.6.4
+  version: 2.6.5
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-28 00:00:00.000000000 Z
+date: 2016-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -185,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: DynamoDB interface