dynamini 1.5.2 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1fdfa96c8bf677260145f5d6bb35de6cf667cf90
-  data.tar.gz: 9044d8ce4cf6dfbaab3daa7003e0c5eab9862d43
+  metadata.gz: 6e3b7806d587712702fe4d97bfa6e61c30e31227
+  data.tar.gz: d9420a6dded6bdeb3116abc6498afff11a825c5b
 SHA512:
-  metadata.gz: c73f11b146c731254765292c25a777d77efef22f50298db7e203480d1ac01e6cd58c12a585f777dfdea06fc2526fb21cad65d46198ebada01b8f480709c8f15e
-  data.tar.gz: 6c586d97d5bafa884c5011020cfcd716ce3e8023ab807a51249a44d5cd3d605459f8b1350eac758b0bfdd7671bc50d1bfcfb42eaa7330b8e39fb7bf32e23e968
+  metadata.gz: 4f66f26a56d22e788797901d058183a087909e46545bfb3cc09ee2db0f23d5c351dbd472d5a6a373540925fc07f65ca57826dd57606585059f780f11f39b5529
+  data.tar.gz: a239e9829dda149d4a73e981b9d15eeee8d9281d70d83ed97620053259f099ca5d1cb3d807174833fde6ff910cf161021c9cfd7df6a5d33284a1177709ae0f3a

data/lib/dynamini/base.rb

@@ -1,26 +1,27 @@
 module Dynamini
+  # Core db interface class.
   class Base
     include ActiveModel::Validations
     attr_reader :attributes
 
     BATCH_SIZE = 25
     GETTER_PROCS = {
-        integer: Proc.new   { |v| v.to_i },
-        datetime: Proc.new  { |v| Time.at(v.to_f) },
-        float: Proc.new     { |v| v.to_f },
-        symbol: Proc.new    { |v| v.to_sym },
-        string: Proc.new    { |v| v },
-        boolean: Proc.new   { |v| ['true', '1', '1.0'].include? v },
-        array: Proc.new     { |v| v ? JSON.parse(v) : [] }
+        integer:  proc { |v| v.to_i },
+        datetime: 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| ['true', '1', '1.0'].include? v },
+        array:    proc { |v| v ? (v.is_a?(String) ? JSON.parse(v) : v) : [] }
     }
     SETTER_PROCS = {
-        datetime: Proc.new  { |v| v.to_f },
-        array: Proc.new     { |v| v if v.is_a? Array }
+        datetime: proc { |v| v.to_f },
+        array: proc { |v| v if v.is_a? Array }
     }
 
     class << self
-
       attr_writer :batch_write_queue, :in_memory
+      attr_reader :range_key
 
       def table_name
         @table_name ||= name.demodulize.tableize
@@ -38,7 +39,7 @@ module Dynamini
         @range_key = key
       end
 
-      def handle(column, format_class, options={})
+      def handle(column, format_class, options = {})
         define_handled_getter(column, format_class, options)
         define_handled_setter(column, format_class)
       end
@@ -47,10 +48,6 @@ module Dynamini
         @hash_key || :id
       end
 
-      def range_key
-        @range_key
-      end
-
       def in_memory
         @in_memory || false
       end
@@ -66,57 +63,56 @@ module Dynamini
           @client ||= Aws::DynamoDB::Client.new(
               region: Dynamini.configuration.region,
               access_key_id: Dynamini.configuration.access_key_id,
-              secret_access_key: Dynamini.configuration.secret_access_key)
+              secret_access_key: Dynamini.configuration.secret_access_key
+          )
         end
       end
 
-      def create(attributes, options={})
-        model = self.new(attributes, true)
+      def create(attributes, options = {})
+        model = new(attributes, true)
         model if model.save(options)
       end
 
-      def create!(attributes, options={})
-        model = self.new(attributes, true)
+      def create!(attributes, options = {})
+        model = new(attributes, true)
         model if model.save!(options)
       end
 
       def find(hash_value, range_value = nil)
-        raise "Range key can not be blank" if range_key && range_value.nil?
+        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))
         raise 'Item not found.' unless response.item
-        self.new(response.item.symbolize_keys, false)
+        new(response.item.symbolize_keys, false)
       end
 
       def exists?(key)
-        response = client.get_item(table_name: table_name, key: {hash_key => key.to_s})
-        response.item.present?
+        r = client.get_item(table_name: table_name, key: { hash_key => key.to_s })
+        r.item.present?
       end
 
       def find_or_new(key)
-        response = client.get_item(table_name: table_name, key: {hash_key => key.to_s})
-        if response.item
-          self.new(response.item.symbolize_keys, false)
+        r = client.get_item(table_name: table_name, key: { hash_key => key.to_s })
+        if r.item
+          new(r.item.symbolize_keys, false)
         else
-          self.new(hash_key => key.to_s)
+          new(hash_key => key.to_s)
         end
       end
 
       def batch_find(ids = [])
         return [] if ids.length < 1
         objects = []
-        if ids.length > 100
-          raise StandardError, 'Batch find is limited to 100 items'
-        end
+        fail StandardError, 'Batch is limited to 100 items' if ids.length > 100
         key_structure = ids.map { |i| { hash_key => i.to_s } }
-        response = self.dynamo_batch_get(key_structure)
+        response = dynamo_batch_get(key_structure)
         response.responses[table_name].each do |item|
-          objects << self.new(item.symbolize_keys, false)
+          objects << new(item.symbolize_keys, false)
         end
         objects
       end
 
       def enqueue_for_save(attributes, options = {})
-        model = self.new(attributes, true)
+        model = new(attributes, true)
         model.generate_timestamps! unless options[:skip_timestamps]
         if model.valid?
           batch_write_queue << model
@@ -127,7 +123,7 @@ module Dynamini
       end
 
       def flush_queue!
-        response = self.dynamo_batch_save(batch_write_queue)
+        response = dynamo_batch_save(batch_write_queue)
         self.batch_write_queue = []
         response
       end
@@ -136,7 +132,7 @@ module Dynamini
 
     #### Instance Methods
 
-    def initialize(attributes={}, new_record = true)
+    def initialize(attributes = {}, new_record = true)
       @changed = Set.new
       @new_record = new_record
       @attributes = {}
@@ -146,9 +142,8 @@ module Dynamini
       end
     end
 
-
-    def ==(object)
-      hash_key == object.hash_key if object.is_a?(self.class)
+    def ==(other)
+      hash_key == other.hash_key if other.is_a?(self.class)
     end
 
     def assign_attributes(attributes)
@@ -173,8 +168,7 @@ module Dynamini
     end
 
     def save!(options = {})
-
-      options[:validate]= true if options[:validate].nil?
+      options[:validate] = true if options[:validate].nil?
 
       unless @changed.empty?
         if (options[:validate] && valid?) || !options[:validate]
@@ -207,7 +201,10 @@ module Dynamini
     end
 
     def changes
-      @attributes.select { |attribute| @changed.include?(attribute.to_s) && attribute != self.class.hash_key && attribute != self.class.range_key }
+      @attributes.select { |attribute| @changed.include?(attribute.to_s) &&
+          attribute != self.class.hash_key &&
+          attribute != self.class.range_key
+      }
     end
 
     def changed
@@ -239,34 +236,57 @@ module Dynamini
     end
 
     def generate_timestamps!
-      self.updated_at= Time.now.to_f
-      self.created_at= Time.now.to_f if new_record?
+      self.updated_at = Time.now.to_f
+      self.created_at = Time.now.to_f if new_record?
     end
 
     def save_to_dynamo
-      self.class.client.update_item(table_name: self.class.table_name, key: key, attribute_updates: attribute_updates)
+      self.class.client.update_item(
+          table_name: self.class.table_name,
+          key: key,
+          attribute_updates: attribute_updates
+      )
     end
 
     def touch_to_dynamo
-      self.class.client.update_item(table_name: self.class.table_name, key: key, attribute_updates: {updated_at: {value: Time.now.to_f, action: 'PUT'}})
+      self.class.client.update_item(
+          table_name: self.class.table_name,
+          key: key,
+          attribute_updates:
+              { updated_at:
+                   { value: Time.now.to_f,
+                    action: 'PUT'
+                   }
+              }
+      )
     end
 
     def delete_from_dynamo
       self.class.client.delete_item(table_name: self.class.table_name, key: key)
     end
 
-    def increment_to_dynamo(attribute_increments, opts={})
-      self.class.client.update_item(table_name: self.class.table_name, key: key, attribute_updates: increment_updates(attribute_increments, opts))
+    def increment_to_dynamo(attribute_increments, opts = {})
+      self.class.client.update_item(
+          table_name: self.class.table_name,
+          key: key,
+          attribute_updates: increment_updates(attribute_increments, opts)
+      )
     end
 
-    def self.dynamo_batch_get(key_structure)
-      client.batch_get_item(request_items: {table_name => {keys: key_structure}})
+    def self.dynamo_batch_get(key_struct)
+      client.batch_get_item(
+          request_items: {
+              table_name => { keys: key_struct }
+          }
+      )
     end
 
     def self.dynamo_batch_save(model_array)
       put_requests = []
       model_array.each do |model|
-        put_requests << { put_request: { item: model.attributes.reject{|_k, v| v.blank? }.stringify_keys } }
+        put_requests << { put_request: {
+            item: model.attributes.reject{ |_k, v| v.blank? }.stringify_keys
+        } }
       end
       request_options = { request_items: {
           "#{table_name}" => put_requests }
@@ -293,13 +313,13 @@ module Dynamini
       end
     end
 
-    def increment_updates(attribute_increments, opts={})
+    def increment_updates(attribute_increments, opts = {})
       updates = {}
       attribute_increments.each do |k,v|
-        updates[k] = {value: v, action: 'ADD'}
+        updates[k] = { value: v, action: 'ADD' }
       end
-      updates[:updated_at] = {value: Time.now.to_f, action: 'PUT'} unless opts[:skip_timestamps]
-      updates[:created_at] = {value: Time.now.to_f, action: 'PUT'} unless attributes[:created_at]
+      updates[:updated_at] = { value: Time.now.to_f, action: 'PUT' } unless opts[:skip_timestamps]
+      updates[:created_at] = { value: Time.now.to_f, action: 'PUT' } unless attributes[:created_at]
       updates
     end
 
@@ -307,10 +327,14 @@ module Dynamini
       if value.is_a?(Integer) || value.is_a?(Float)
         current_value = self.send(attribute)
         unless current_value.nil? || current_value.is_a?(Integer) || current_value.is_a?(Float)
-          raise StandardError, "You cannot increment a non-numeric non-nil value: #{attribute} is currently #{current_value}. If your current value is a numeric string, use :handle to autocast it as a number."
+          fail StandardError, "Cannot increment a non-numeric non-nil value:
+                                #{attribute} is currently #{current_value}.
+                                If your current value is a numeric string,
+                                use :handle to autocast it as a number."
         end
       else
-        raise StandardError, "You cannot increment an attribute by a non-numeric value: #{value}"
+        fail StandardError, "You cannot increment an attribute by a
+                              non-numeric value: #{value}"
       end
     end
 
@@ -338,11 +362,11 @@ module Dynamini
       name =~ /^([a-zA-Z][-_\w]*)=.*$/
     end
 
-    def self.define_handled_getter(column, format_class, options={})
+    def self.define_handled_getter(column, format_class, options = {})
       proc = GETTER_PROCS[format_class]
-      raise 'Unsupported data type: ' + format_class.to_s if proc.nil?
+      fail 'Unsupported data type: ' + format_class.to_s if proc.nil?
       define_method(column) do
-        if @attributes.has_key?(column)
+        if @attributes.key?(column)
           proc.call(read_attribute(column))
         else
           options[:default] || nil
@@ -364,14 +388,14 @@ module Dynamini
       end
     end
 
-    def respond_to_missing?(name, include_private=false)
+    def respond_to_missing?(name, include_private = false)
       @attributes.keys.include?(name) || write_method?(name) || super
     end
 
-    def write_attribute(attribute, new_value, record_change=true)
+    def write_attribute(attribute, new_value, record_change = true)
       old_value = @attributes[attribute]
-      @attributes[attribute] = (new_value.nil? ? nil : new_value.to_s)
-      record_change(attribute, new_value.to_s, old_value) if record_change
+      @attributes[attribute] = (new_value.nil? ? nil : new_value)
+      record_change(attribute, new_value, old_value) if record_change
     end
 
     def record_change(attribute, new_value, old_value)

data/lib/dynamini/configuration.rb

@@ -1,5 +1,6 @@
 module Dynamini
+  # Config class to be used with initializers.
   class Configuration
     attr_accessor :region, :access_key_id, :secret_access_key
   end
-end
+end

data/lib/dynamini/test_client.rb

@@ -1,6 +1,7 @@
 module Dynamini
   require 'ostruct'
 
+  # In-memory database client for test purposes.
   class TestClient
 
     attr_reader :hash_key
@@ -12,12 +13,14 @@ module Dynamini
 
     def update_item(args = {})
       table = args[:table_name]
-      updates = flatten_attribute_updates(args).merge({hash_key => args[:key][hash_key]})
+      updates = flatten_attribute_updates(args).merge(
+          hash_key => args[:key][hash_key].to_s
+      )
       @data[table] ||= {}
-      if @data[table][args[:key][hash_key]].present?
-        @data[table][args[:key][hash_key]].merge!(updates)
+      if @data[table][args[:key][hash_key].to_s].present?
+        @data[table][args[:key][hash_key].to_s].merge!(updates)
       else
-        @data[table][args[:key][hash_key]] = updates
+        @data[table][args[:key][hash_key].to_s] = updates
       end
     end
 
@@ -68,14 +71,14 @@ module Dynamini
       attribute_hash = {}
 
       args[:attribute_updates].each do |k, v|
-        if v[:action] == 'ADD' && @data[args[:table_name]][args[:key][hash_key]] #if record has been saved
-          attribute_hash[k] = v[:value] + @data[args[:table_name]][args[:key][hash_key]][k].to_f
+        if v[:action] == 'ADD' && @data[args[:table_name]][args[:key][hash_key]]
+          # if record has been saved
+          attribute_hash[k] = (v[:value] + @data[args[:table_name]][args[:key][hash_key]][k].to_f).to_s
         else
-          attribute_hash[k] = v[:value]
+          attribute_hash[k] = v[:value].to_s
         end
       end
       attribute_hash
     end
-
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamini
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.5.3
 platform: ruby
 authors:
 - Greg Ward
@@ -15,7 +15,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-21 00:00:00.000000000 Z
+date: 2015-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -94,8 +94,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 description: |-
-  Lightweight DynamoDB interface gem designed as a drop-in replacement for ActiveRecord.
-                      Built & maintained by the team at yroo.com.
+  Lightweight DynamoDB interface gem designed as
+                     a drop-in replacement for ActiveRecord.
+                     Built & maintained by the team at yroo.com.
 email: dev@retailcommon.com
 executables: []
 extensions: []