dynamoid-moda 0.7.1

data/lib/dynamoid/identity_map.rb

@@ -0,0 +1,96 @@
+module Dynamoid
+  module IdentityMap
+    extend ActiveSupport::Concern
+
+    def self.clear
+      models.each { |m| m.identity_map.clear }
+    end
+
+    def self.models
+      Dynamoid::Config.included_models
+    end
+
+    module ClassMethods
+      def identity_map
+        @identity_map ||= {}
+      end
+
+      def from_database(attrs = {})
+        return super if identity_map_off?
+
+        key = identity_map_key(attrs)
+        document = identity_map[key]
+
+        if document.nil?
+          document = super
+          identity_map[key] = document
+        else
+          document.load(attrs)
+        end
+
+        document
+      end
+
+      def find_by_id(id, options = {})
+        return super if identity_map_off?
+
+        key = id.to_s
+
+        if range_key = options[:range_key]
+          key += "::#{range_key}"
+        end
+
+        if identity_map[key]
+          identity_map[key]
+        else
+          super
+        end
+      end
+
+      def identity_map_key(attrs)
+        key = attrs[hash_key].to_s
+        if range_key
+          key += "::#{attrs[range_key]}"
+        end
+        key
+      end
+
+      def identity_map_on?
+        Dynamoid::Config.identity_map
+      end
+
+      def identity_map_off?
+        !identity_map_on?
+      end
+    end
+
+    def identity_map
+      self.class.identity_map
+    end
+
+    def save(*args)
+      return super if self.class.identity_map_off?
+
+      if result = super
+        identity_map[identity_map_key] = self
+      end
+      result
+    end
+
+    def delete
+      return super if self.class.identity_map_off?
+
+      identity_map.delete(identity_map_key)
+      super
+    end
+
+
+    def identity_map_key
+      key = hash_key.to_s
+      if self.class.range_key
+        key += "::#{range_value}"
+      end
+      key
+    end
+  end
+end

data/lib/dynamoid/indexes.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'dynamoid/indexes/index'
+
+module Dynamoid #:nodoc:
+
+  # Indexes are quick ways of performing queries by anything other than id in DynamoDB. They are denormalized tables; 
+  # that is, data is duplicated in the initial table (where the object is saved) and the index table (where 
+  # we perform indexing). 
+  module Indexes
+    extend ActiveSupport::Concern
+
+    # Make some helpful attributes to persist indexes.
+    included do
+      class_attribute :indexes
+      
+      self.indexes = {}
+    end
+    
+    module ClassMethods
+      
+      # The call to create an index. Generates a new index with the specified options -- for more information, see Dynamoid::Indexes::Index.
+      # This function also attempts to immediately create the indexing table if it does not exist already.
+      #
+      # @since 0.2.0
+      def index(name, options = {})
+        index = Dynamoid::Indexes::Index.new(self, name, options)
+        self.indexes[index.name] = index
+        create_indexes        
+      end
+      
+      # Helper function to find indexes.
+      #
+      # @since 0.2.0
+      def find_index(index)
+        self.indexes[Array(index).collect(&:to_s).sort.collect(&:to_sym)]
+      end
+      
+      # Helper function to create indexes (if they don't exist already).
+      #
+      # @since 0.2.0
+      def create_indexes
+        self.indexes.each do |name, index|
+          opts = {:table_name => index.table_name, :id => :id}
+          opts[:range_key] = { :range => :number } if index.range_key?
+          self.create_table(opts)
+        end
+      end
+    end
+    
+    # Callback for an object to save itself to each of a class' indexes.
+    #
+    # @since 0.2.0
+    def save_indexes
+      self.class.indexes.each do |name, index|
+        index.save(self)
+      end
+    end
+
+    # Callback for an object to delete itself from each of a class' indexes.
+    #
+    # @since 0.2.0    
+    def delete_indexes
+      self.class.indexes.each do |name, index|
+        index.delete(self)
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/indexes/index.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+  module Indexes
+
+    # The class contains all the information an index contains, including its keys and which attributes it covers.
+    class Index
+      attr_accessor :source, :name, :hash_keys, :range_keys
+      alias_method :range_key?, :range_keys
+      
+      # Create a new index. Pass either :range => true or :range => :column_name to create a ranged index on that column.
+      #
+      # @param [Class] source the source class for the index
+      # @param [Symbol] name the name of the index
+      #
+      # @since 0.2.0      
+      def initialize(source, name, options = {})
+        @source = source
+        
+        if options.delete(:range)
+          @range_keys = sort(name)
+        elsif options[:range_key]
+          @range_keys = sort(options[:range_key])
+        end
+        @hash_keys = sort(name)
+        @name = sort([hash_keys, range_keys])
+        
+        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless keys.all?{|n| source.attributes.include?(n)}
+      end
+      
+      # Sort objects into alphabetical strings, used for composing index names correctly (since we always assume they're alphabetical).
+      #
+      # @example find all users by first and last name
+      #   sort([:gamma, :alpha, :beta, :omega]) # => [:alpha, :beta, :gamma, :omega]
+      #
+      # @since 0.2.0         
+      def sort(objs)
+        Array(objs).flatten.compact.uniq.collect(&:to_s).sort.collect(&:to_sym)
+      end
+
+      # Return the array of keys this index uses for its table.
+      #
+      # @since 0.2.0      
+      def keys
+        [Array(hash_keys) + Array(range_keys)].flatten.uniq
+      end
+      
+      # Return the table name for this index.
+      #
+      # @since 0.2.0
+      def table_name
+        "#{Dynamoid::Config.namespace}_index_" + source.table_name.sub("#{Dynamoid::Config.namespace}_", '').singularize + "_#{name.collect(&:to_s).collect(&:pluralize).join('_and_')}"
+      end
+
+      # Given either an object or a list of attributes, generate a hash key and a range key for the index. Optionally pass in 
+      # true to changed_attributes for a list of all the object's dirty attributes in convenient index form (for deleting stale 
+      # information from the indexes).
+      #
+      # @param [Object] attrs either an object that responds to :attributes, or a hash of attributes
+      #
+      # @return [Hash] a hash with the keys :hash_value and :range_value
+      #
+      # @since 0.2.0
+      def values(attrs, changed_attributes = false)
+        if changed_attributes
+          hash = {}
+          attrs.changes.each {|k, v| hash[k.to_sym] = (v.first || v.last)}
+          attrs = hash
+        end
+        attrs = attrs.send(:attributes) if attrs.respond_to?(:attributes)
+        {}.tap do |hash|
+          hash[:hash_value] = hash_keys.collect{|key| attrs[key]}.join('.')
+          hash[:range_value] = range_keys.inject(0.0) {|sum, key| sum + attrs[key].to_f} if self.range_key?
+        end
+      end
+      
+      # Save an object to this index, merging it with existing ids if there's already something present at this index location.
+      # First, though, delete this object from its old indexes (so the object isn't listed in an erroneous index).
+      #
+      # @since 0.2.0
+      def save(obj)
+        self.delete(obj, true)
+        values = values(obj)
+        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value] })
+        ids = ((existing and existing[:ids]) or Set.new)
+        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => ids.merge([obj.id]), :range => values[:range_value]})
+      end
+
+      # Delete an object from this index, preserving existing ids if there are any, and failing gracefully if for some reason the 
+      # index doesn't already have this object in it.
+      #
+      # @since 0.2.0      
+      def delete(obj, changed_attributes = false)
+        values = values(obj, changed_attributes)
+        return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value]})
+        return true unless existing && existing[:ids] && existing[:ids].include?(obj.id)
+        Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => (existing[:ids] - Set[obj.id]), :range => values[:range_value]})
+      end
+      
+    end
+  end
+end

data/lib/dynamoid/middleware/identity_map.rb

@@ -0,0 +1,16 @@
+module Dynamoid
+  module Middleware
+    class IdentityMap
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Dynamoid::IdentityMap.clear
+        @app.call(env)
+      ensure
+        Dynamoid::IdentityMap.clear
+      end
+    end
+  end
+end

data/lib/dynamoid/persistence.rb

@@ -0,0 +1,292 @@
+require 'securerandom'
+
+# encoding: utf-8
+module Dynamoid
+
+  # Persistence is responsible for dumping objects to and marshalling objects from the datastore. It tries to reserialize
+  # values to be of the same type as when they were passed in, based on the fields in the class.
+  module Persistence
+    extend ActiveSupport::Concern
+
+    attr_accessor :new_record
+    alias :new_record? :new_record
+
+    module ClassMethods
+
+      def table_name
+        @table_name ||= "#{Dynamoid::Config.namespace}_#{options[:name] || base_class.name.split('::').last.downcase.pluralize}"
+      end
+
+      # Creates a table.
+      #
+      # @param [Hash] options options to pass for table creation
+      # @option options [Symbol] :id the id field for the table
+      # @option options [Symbol] :table_name the actual name for the table
+      # @option options [Integer] :read_capacity set the read capacity for the table; does not work on existing tables
+      # @option options [Integer] :write_capacity set the write capacity for the table; does not work on existing tables
+      # @option options [Hash] {range_key => :type} a hash of the name of the range key and a symbol of its type
+      #
+      # @since 0.4.0
+      def create_table(options = {})
+        if self.range_key
+          range_key_hash = { range_key => dynamo_type(attributes[range_key][:type]) }
+        else
+          range_key_hash = nil
+        end
+        options = {
+          :id => self.hash_key,
+          :table_name => self.table_name,
+          :write_capacity => self.write_capacity,
+          :read_capacity => self.read_capacity,
+          :range_key => range_key_hash
+        }.merge(options)
+
+        return true if table_exists?(options[:table_name])
+
+        Dynamoid::Adapter.tables << options[:table_name] if Dynamoid::Adapter.create_table(options[:table_name], options[:id], options)
+      end
+
+      # Does a table with this name exist?
+      #
+      # @since 0.2.0
+      def table_exists?(table_name)
+        Dynamoid::Adapter.tables ? Dynamoid::Adapter.tables.include?(table_name) : false
+      end
+
+      def from_database(attrs = {})
+        clazz = attrs[:type] ? obj = attrs[:type].constantize : self
+        clazz.new(attrs).tap { |r| r.new_record = false }
+      end
+
+      # Undump an object into a hash, converting each type from a string representation of itself into the type specified by the field.
+      #
+      # @since 0.2.0
+      def undump(incoming = nil)
+        incoming = (incoming || {}).symbolize_keys
+        Hash.new.tap do |hash|
+          self.attributes.each do |attribute, options|
+            hash[attribute] = undump_field(incoming[attribute], options)
+          end
+          incoming.each {|attribute, value| hash[attribute] = value unless hash.has_key? attribute }
+        end
+      end
+
+      # Undump a value for a given type. Given a string, it'll determine (based on the type provided) whether to turn it into a
+      # string, integer, float, set, array, datetime, or serialized return value.
+      #
+      # @since 0.2.0
+      def undump_field(value, options)
+        if value.nil? && (default_value = options[:default])
+          value = default_value.respond_to?(:call) ? default_value.call : default_value
+        else
+          return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        end
+
+        case options[:type]
+        when :string
+          value.to_s
+        when :integer
+          value.to_i
+        when :float
+          value.to_f
+        when :set, :array
+          if value.is_a?(Set) || value.is_a?(Array)
+            value
+          else
+            Set[value]
+          end
+        when :datetime
+          if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+            value
+          else
+            Time.at(value).to_datetime
+          end
+        when :serialized
+          if value.is_a?(String)
+            options[:serializer] ? options[:serializer].load(value) : YAML.load(value)
+          else
+            value
+          end
+        when :boolean
+          # persisted as 't', but because undump is called during initialize it can come in as true
+          if value == 't' || value == true
+            true
+          elsif value == 'f' || value == false
+            false
+          else
+            raise ArgumentError, "Boolean column neither true nor false"
+          end
+        else
+          raise ArgumentError, "Unknown type #{options[:type]}"
+        end
+      end
+
+      def dynamo_type(type)
+        case type
+        when :integer, :float, :datetime
+          :number
+        when :string, :serialized
+          :string
+        else
+          raise 'unknown type'
+        end
+      end
+
+    end
+
+    # Set updated_at and any passed in field to current DateTime. Useful for things like last_login_at, etc.
+    #
+    def touch(name = nil)
+      now = DateTime.now
+      self.updated_at = now
+      attributes[name] = now if name
+      save
+    end
+
+    # Is this object persisted in the datastore? Required for some ActiveModel integration stuff.
+    #
+    # @since 0.2.0
+    def persisted?
+      !new_record?
+    end
+
+    # Run the callbacks and then persist this object in the datastore.
+    #
+    # @since 0.2.0
+    def save(options = {})
+      self.class.create_table
+      
+      if new_record?
+        conditions = { :unless_exists => [self.class.hash_key]}
+        conditions[:unless_exists] << range_key if(range_key)
+
+        run_callbacks(:create) { persist(conditions) }
+      else
+        persist
+      end
+
+      self
+    end
+
+    #
+    # update!() will increment the lock_version if the table has the column, but will not check it. Thus, a concurrent save will 
+    # never cause an update! to fail, but an update! may cause a concurrent save to fail. 
+    #
+    #
+    def update!(conditions = {}, &block)
+      run_callbacks(:update) do
+        options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+        new_attrs = Dynamoid::Adapter.update_item(self.class.table_name, self.hash_key, options.merge(:conditions => conditions)) do |t|
+          if(self.class.attributes[:lock_version])
+            raise "Optimistic locking cannot be used with Partitioning" if(Dynamoid::Config.partitioning)
+            t.add(lock_version: 1)
+          end
+
+          yield t
+        end
+        load(new_attrs)
+      end
+    end
+
+    def update(conditions = {}, &block)
+      update!(conditions, &block)
+      true
+    rescue Dynamoid::Errors::ConditionalCheckFailedException
+      false
+    end
+
+    # Delete this object, but only after running callbacks for it.
+    #
+    # @since 0.2.0
+    def destroy
+      run_callbacks(:destroy) do
+        self.delete
+      end
+      self
+    end
+
+    # Delete this object from the datastore and all indexes.
+    #
+    # @since 0.2.0
+    def delete
+      delete_indexes
+      options = range_key ? {:range_key => dump_field(self.read_attribute(range_key), self.class.attributes[range_key])} : {}
+      Dynamoid::Adapter.delete(self.class.table_name, self.hash_key, options)
+    end
+
+    # Dump this object's attributes into hash form, fit to be persisted into the datastore.
+    #
+    # @since 0.2.0
+    def dump
+      Hash.new.tap do |hash|
+        self.class.attributes.each do |attribute, options|
+          hash[attribute] = dump_field(self.read_attribute(attribute), options)
+        end
+      end
+    end
+
+    private
+
+    # Determine how to dump this field. Given a value, it'll determine how to turn it into a value that can be
+    # persisted into the datastore.
+    #
+    # @since 0.2.0
+    def dump_field(value, options)
+      return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+      case options[:type]
+      when :string
+        value.to_s
+      when :integer
+        value.to_i
+      when :float
+        value.to_f
+      when :set, :array
+        if value.is_a?(Set) || value.is_a?(Array)
+          value
+        else
+          Set[value]
+        end
+      when :datetime
+        value.to_time.to_f
+      when :serialized
+        options[:serializer] ? options[:serializer].dump(value) : value.to_yaml
+      when :boolean
+        value.to_s[0]
+      else
+        raise ArgumentError, "Unknown type #{options[:type]}"
+      end
+    end
+    
+    # Persist the object into the datastore. Assign it an id first if it doesn't have one; then afterwards,
+    # save its indexes.
+    #
+    # @since 0.2.0
+    def persist(conditions = nil)
+      run_callbacks(:save) do
+        self.hash_key = SecureRandom.uuid if self.hash_key.nil? || self.hash_key.blank?
+        
+        # Add an exists check to prevent overwriting existing records with new ones
+        if(new_record?)
+          conditions ||= {}
+          (conditions[:unless_exists] ||= []) << self.class.hash_key
+        end
+
+        # Add an optimistic locking check if the lock_version column exists
+        if(self.class.attributes[:lock_version])
+          conditions ||= {}
+          raise "Optimistic locking cannot be used with Partitioning" if(Dynamoid::Config.partitioning)
+          self.lock_version = (lock_version || 0) + 1 
+          #Uses the original lock_version value from ActiveModel::Dirty in case user changed lock_version manually
+          (conditions[:if] ||= {})[:lock_version] = changes[:lock_version][0] if(changes[:lock_version][0])
+        end
+
+        Dynamoid::Adapter.write(self.class.table_name, self.dump, conditions)
+        save_indexes
+        @new_record = false
+        true
+      end
+    end
+  end
+
+end