dynamini 1.10.2 → 1.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8248aff788be3cda0502be12ccc3768cdf4fc3d4
-  data.tar.gz: 860898330266f91bce5a52d1a4193edce7f64e07
+  metadata.gz: 77216b9785381180fbe3c6fb26fa9068b1875205
+  data.tar.gz: 377ad37843a21e5fd5cd8cb286df9d8897845bcd
 SHA512:
-  metadata.gz: 9dc5d37aefc854902b172a271a2b80b5ab22310f507ad2f5c234a60bb81d00b5a2f0a69bdd2ef8fe6c426830fe06d9f985f67d51db62b83a98d4eb8d6a956bee
-  data.tar.gz: 9efb1fd623f05c5eba81660ea04e46873d222634b5aca361b69205e75eccb1ad2c1fef2d53cf44555514eb5eae68aa559aec1ddebdc2a03dd53a49219a6c86ad
+  metadata.gz: 5357921d66fed581b203a729210a8e9a94c30110133f561c03ff1ed44382069926797e8b77ffbd3319b6471f04e7771ee301fdc0bbec24710ad7353fa1fb05c8
+  data.tar.gz: acf65739006b37541d869bd48bacf44bf6c911a1d800a7e79be4f74a09bd6e46634dd0b75f65b0e05babd7c5781519626796950dadfe65473a6df1ebe0dd4af6

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    dynamini (1.10.2)
+    dynamini (1.10.4)
       activemodel (>= 3, < 5.0)
       aws-sdk (~> 2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.5)
-      activesupport (= 4.2.5)
+    activemodel (4.2.4)
+      activesupport (= 4.2.4)
       builder (~> 3.1)
-    activesupport (4.2.5)
+    activesupport (4.2.4)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -56,7 +56,7 @@ GEM
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
     method_source (0.8.2)
-    minitest (5.8.3)
+    minitest (5.8.2)
     nenv (0.2.0)
     notiffany (0.0.8)
       nenv (~> 0.1)

data/dynamini.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = 'dynamini'
-  s.version = '1.10.2'
-  s.date = '2015-01-07'
+  s.version = '1.10.4'
+  s.date = '2015-01-11'
   s.summary = 'DynamoDB interface'
   s.description = 'Lightweight DynamoDB interface gem designed as
                    a drop-in replacement for ActiveRecord.

data/lib/dynamini/base.rb

@@ -1,5 +1,9 @@
 require_relative 'batch_operations'
 require_relative 'querying'
+require_relative 'client_interface'
+require_relative 'dirty'
+require_relative 'increment'
+require_relative 'type_handler'
 
 module Dynamini
   # Core db interface class.
@@ -7,38 +11,22 @@ module Dynamini
     include ActiveModel::Validations
     extend Dynamini::BatchOperations
     extend Dynamini::Querying
+    include Dynamini::ClientInterface
+    include Dynamini::Dirty
+    include Dynamini::Increment
+    include Dynamini::TypeHandler
 
-    attr_reader :attributes
 
+    attr_reader :attributes
     class_attribute :handles
 
     self.handles = {
-          created_at: { format: :time, options: {} },
-          updated_at: { format: :time, options: {} }
-        }
-
-    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 }
+        created_at: { format: :time, options: {} },
+        updated_at: { format: :time, options: {} }
     }
 
     class << self
-      attr_writer :in_memory
+
       attr_reader :range_key
 
       def table_name
@@ -57,33 +45,10 @@ module Dynamini
         @range_key = key
       end
 
-      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 hash_key
         @hash_key || :id
       end
 
-      def in_memory
-        @in_memory || false
-      end
-
-      def client
-        if in_memory
-          @client ||= Dynamini::TestClient.new(hash_key, range_key)
-        else
-          @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
-          )
-        end
-      end
-
       def create(attributes, options = {})
         model = new(attributes, true)
         model if model.save(options)
@@ -110,15 +75,6 @@ module Dynamini
       [self.class.hash_key, self.class.range_key]
     end
 
-    def changes
-      @changes.delete_if { |attr, value| keys.include?(attr) }
-              .stringify_keys
-    end
-
-    def changed
-      changes.keys.map(&:to_s)
-    end
-
     def ==(other)
       hash_key == other.hash_key if other.is_a?(self.class)
     end
@@ -165,23 +121,11 @@ module Dynamini
       end
     end
 
-    def increment!(attributes, opts = {})
-      attributes.each do |attr, value|
-        validate_incrementable_attribute(attr, value)
-      end
-      increment_to_dynamo(attributes, opts)
-    end
-
     def delete
       delete_from_dynamo
       self
     end
 
-
-    def new_record?
-      @new_record
-    end
-
     private
 
     def trigger_save(options = {})
@@ -203,39 +147,6 @@ module Dynamini
       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
-      )
-    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'
-                   }
-              }
-      )
-    end
-
-    def delete_from_dynamo
-      self.class.client.delete_item(table_name: self.class.table_name, key: key)
-    end
-
-    def increment_to_dynamo(attributes, opts = {})
-      self.class.client.update_item(
-          table_name: self.class.table_name,
-          key: key,
-          attribute_updates: increment_updates(attributes, opts)
-      )
-    end
-
     def key
       key_hash = { self.class.hash_key => @attributes[self.class.hash_key] }
       key_hash[self.class.range_key] = @attributes[self.class.range_key] if self.class.range_key
@@ -256,33 +167,6 @@ module Dynamini
       end
     end
 
-    def increment_updates(attributes, opts = {})
-      updates = {}
-      attributes.each do |attr,value|
-        updates[attr] = { value: value, 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.stringify_keys
-    end
-
-    def validate_incrementable_attribute(attribute, value)
-      if value.is_a?(Integer) || value.is_a?(Float)
-        current_value = read_attribute(attribute)
-        unless current_value.nil? || current_value.is_a?(Integer) || current_value.is_a?(Float) || current_value.is_a?(BigDecimal)
-          fail StandardError, "Cannot increment a non-numeric non-nil value:
-                                #{attribute} is currently #{current_value}, a #{current_value.class}."
-        end
-      else
-        fail StandardError, "You cannot increment an attribute by a
-                              non-numeric value: #{value}"
-      end
-    end
-
-    def clear_changes
-      @changes = Hash.new { |hash, key| hash[key] = Array.new(2) }
-    end
-
     def method_missing(name, *args, &block)
       if write_method?(name)
         write_attribute(attribute_name(name), args.first)
@@ -307,29 +191,6 @@ module Dynamini
       name =~ /^([a-zA-Z][-_\w]*)=.*$/
     end
 
-    def was_method?(name)
-      method_name = name.to_s
-      read_method?(method_name) && method_name.end_with?('_was')
-    end
-
-    def self.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 self.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 respond_to_missing?(name, include_private = false)
       @attributes.keys.include?(name) || write_method?(name) || was_method?(name) || super
     end
@@ -343,10 +204,6 @@ module Dynamini
       record_change(attribute, new_value, old_value) if change && new_value != old_value
     end
 
-    def record_change(attribute, new_value, old_value)
-      @changes[attribute] = [old_value, new_value]
-    end
-
     def read_attribute(name)
       value = @attributes[name]
       if (handle = handles[name.to_sym])
@@ -360,20 +217,5 @@ module Dynamini
       callback = procs[handle[:format]]
       value.is_a?(Array) ? value.map { |e| callback.call(e) } : callback.call(value)
     end
-
-    def __was(name)
-      attr_name = name[0..-5].to_sym
-      raise ArgumentError unless (@attributes[attr_name] || handles[attr_name])
-      @changes[attr_name].compact.present? ? @changes[attr_name][0] : read_attribute(attr_name)
-    end
-
-    def handles
-      self.class.handles
-    end
-
-    def self.range_is_numeric?
-      handles[@range_key] && [:integer, :time, :float, :date].include?(handles[@range_key][:format])
-    end
-
   end
 end

data/lib/dynamini/client_interface.rb

@@ -0,0 +1,61 @@
+module Dynamini
+  module ClientInterface
+    module ClassMethods
+
+      attr_writer :in_memory
+
+      def client
+        if in_memory
+          @client ||= Dynamini::TestClient.new(hash_key, range_key)
+        else
+          @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
+          )
+        end
+      end
+
+      def in_memory
+        @in_memory || false
+      end
+    end
+
+    def save_to_dynamo
+      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'
+                    }
+              }
+      )
+    end
+
+    def delete_from_dynamo
+      self.class.client.delete_item(table_name: self.class.table_name, key: key)
+    end
+
+    def increment_to_dynamo(attributes, opts = {})
+      self.class.client.update_item(
+          table_name: self.class.table_name,
+          key: key,
+          attribute_updates: increment_updates(attributes, opts)
+      )
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/dynamini/dirty.rb

@@ -0,0 +1,38 @@
+module Dynamini
+  module Dirty
+
+    def changes
+      @changes.delete_if { |attr, _value| keys.include?(attr) }
+          .stringify_keys
+    end
+
+    def changed
+      changes.keys.map(&:to_s)
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    private
+
+    def record_change(attribute, new_value, old_value)
+      @changes[attribute] = [old_value, new_value]
+    end
+
+    def clear_changes
+      @changes = Hash.new { |hash, key| hash[key] = Array.new(2) }
+    end
+
+    def was_method?(name)
+      method_name = name.to_s
+      read_method?(method_name) && method_name.end_with?('_was')
+    end
+
+    def __was(name)
+      attr_name = name[0..-5].to_sym
+      raise ArgumentError unless (@attributes[attr_name] || handles[attr_name])
+      @changes[attr_name].compact.present? ? @changes[attr_name][0] : read_attribute(attr_name)
+    end
+  end
+end

data/lib/dynamini/increment.rb

@@ -0,0 +1,44 @@
+module Dynamini
+  module Increment
+
+    def increment!(attributes, opts = {})
+      attributes.each do |attr, value|
+        validate_incrementable_attribute(attr, value)
+      end
+      increment_to_dynamo(attributes, opts)
+    end
+
+    private
+
+    def increment_updates(attributes, opts = {})
+      updates = {}
+      attributes.each do |attr,value|
+        updates[attr] = { value: value, 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.stringify_keys
+    end
+
+    def validate_incrementable_attribute(attribute, value)
+      validate_new_increment_value(value)
+      validate_current_increment_value(attribute  )
+    end
+
+    def validate_new_increment_value(value)
+      unless value.is_a?(Integer) || value.is_a?(Float)
+        fail StandardError, "You cannot increment an attribute by a
+          non-numeric value: #{value}"
+      end
+    end
+
+    def validate_current_increment_value(attribute)
+      current_value = read_attribute(attribute)
+      unless current_value.nil? || current_value.is_a?(Integer) || current_value.is_a?(Float) || current_value.is_a?(BigDecimal)
+        fail StandardError, "Cannot increment a non-numeric non-nil value:
+                              #{attribute} is currently #{current_value}, a #{current_value.class}."
+      end
+    end
+
+  end
+end