synamoid 1.2.1

data/lib/dynamoid/dirty.rb

@@ -0,0 +1,47 @@
+module Dynamoid
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    module ClassMethods
+      def from_database(*)
+        super.tap { |d| d.changed_attributes.clear }
+      end
+    end
+
+    def save(*)
+      clear_changes { super }
+    end
+
+    def update!(*)
+      ret = super
+      clear_changes #update! completely reloads all fields on the class, so any extant changes are wiped out
+      ret
+    end
+
+    def reload
+      super.tap { clear_changes }
+    end
+
+    def clear_changes
+      previous = changes
+      (block_given? ? yield : true).tap do |result|
+        unless result == false #failed validation; nil is OK.
+          @previously_changed = previous
+          changed_attributes.clear
+        end
+      end
+    end
+
+    def write_attribute(name, value)
+      attribute_will_change!(name) unless self.read_attribute(name) == value
+      super
+    end
+
+    protected
+
+    def attribute_method?(attr)
+      super || self.class.attributes.has_key?(attr.to_sym)
+    end
+  end
+end

data/lib/dynamoid/document.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # This is the base module for all domain objects that need to be persisted to
+  # the database as documents.
+  module Document
+    extend ActiveSupport::Concern
+    include Dynamoid::Components
+
+    included do
+      class_attribute :options, :read_only_attributes, :base_class
+      self.options = {}
+      self.read_only_attributes = []
+      self.base_class = self
+
+      Dynamoid.included_models << self
+    end
+
+    module ClassMethods
+      # Set up table options, including naming it whatever you want, setting the id key, and manually overriding read and
+      # write capacity.
+      #
+      # @param [Hash] options options to pass for this table
+      # @option options [Symbol] :name the name for the table; this still gets namespaced
+      # @option options [Symbol] :id id column 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
+      #
+      # @since 0.4.0
+      def table(options = {})
+        self.options = options
+        super if defined? super
+      end
+
+      def attr_readonly(*read_only_attributes)
+        self.read_only_attributes.concat read_only_attributes.map(&:to_s)
+      end
+
+      # Returns the read_capacity for this table.
+      #
+      # @since 0.4.0
+      def read_capacity
+        options[:read_capacity] || Dynamoid::Config.read_capacity
+      end
+
+      # Returns the write_capacity for this table.
+      #
+      # @since 0.4.0
+      def write_capacity
+        options[:write_capacity] || Dynamoid::Config.write_capacity
+      end
+
+      # Returns the id field for this class.
+      #
+      # @since 0.4.0
+      def hash_key
+        options[:key] || :id
+      end
+
+      # Returns the number of items for this class.
+      #
+      # @since 0.6.1
+      def count
+        Dynamoid.adapter.count(table_name)
+      end
+
+      # Initialize a new object and immediately save it to the database.
+      #
+      # @param [Hash] attrs Attributes with which to create the object.
+      #
+      # @return [Dynamoid::Document] the saved document
+      #
+      # @since 0.2.0
+      def create(attrs = {})
+        build(attrs).tap(&:save)
+      end
+
+      # Initialize a new object and immediately save it to the database. Raise an exception if persistence failed.
+      #
+      # @param [Hash] attrs Attributes with which to create the object.
+      #
+      # @return [Dynamoid::Document] the saved document
+      #
+      # @since 0.2.0
+      def create!(attrs = {})
+        build(attrs).tap(&:save!)
+      end
+
+      # Initialize a new object.
+      #
+      # @param [Hash] attrs Attributes with which to create the object.
+      #
+      # @return [Dynamoid::Document] the new document
+      #
+      # @since 0.2.0
+      def build(attrs = {})
+        attrs[:type] ? attrs[:type].constantize.new(attrs) : new(attrs)
+      end
+
+      # Does this object exist?
+      #
+      # @param [Mixed] id_or_conditions the id of the object or a hash with the options to filter from.
+      #
+      # @return [Boolean] true/false
+      #
+      # @since 0.2.0
+      def exists?(id_or_conditions = {})
+        case id_or_conditions
+          when Hash then ! where(id_or_conditions).all.empty?
+          else !! find(id_or_conditions)
+        end
+      end
+    end
+
+    # Initialize a new object.
+    #
+    # @param [Hash] attrs Attributes with which to create the object.
+    #
+    # @return [Dynamoid::Document] the new document
+    #
+    # @since 0.2.0
+    def initialize(attrs = {})
+      run_callbacks :initialize do
+        @new_record = true
+        @attributes ||= {}
+        @associations ||= {}
+
+        load(attrs)
+      end
+    end
+
+    def load(attrs)
+      self.class.undump(attrs).each do |key, value|
+        send("#{key}=", value) if self.respond_to?("#{key}=")
+      end
+    end
+
+    # An object is equal to another object if their ids are equal.
+    #
+    # @since 0.2.0
+    def ==(other)
+      if self.class.identity_map_on?
+        super
+      else
+        return false if other.nil?
+        other.is_a?(Dynamoid::Document) && self.hash_key == other.hash_key && self.range_value == other.range_value
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      hash_key.hash ^ range_value.hash
+    end
+
+    # Reload an object from the database -- if you suspect the object has changed in the datastore and you need those
+    # changes to be reflected immediately, you would call this method. This is a consistent read.
+    #
+    # @return [Dynamoid::Document] the document this method was called on
+    #
+    # @since 0.2.0
+    def reload
+      range_key_value = range_value ? dumped_range_value : nil
+      self.attributes = self.class.find(hash_key, :range_key => range_key_value, :consistent_read => true).attributes
+      @associations.values.each(&:reset)
+      self
+    end
+
+    # Return an object's hash key, regardless of what it might be called to the object.
+    #
+    # @since 0.4.0
+    def hash_key
+      self.send(self.class.hash_key)
+    end
+
+    # Assign an object's hash key, regardless of what it might be called to the object.
+    #
+    # @since 0.4.0
+    def hash_key=(value)
+      self.send("#{self.class.hash_key}=", value)
+    end
+
+    def range_value
+      if range_key = self.class.range_key
+        self.send(range_key)
+      end
+    end
+
+    def range_value=(value)
+      self.send("#{self.class.range_key}=", value)
+    end
+
+    private
+
+    def dumped_range_value
+      dump_field(range_value, self.class.attributes[self.class.range_key])
+    end
+  end
+end

data/lib/dynamoid/errors.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+module Dynamoid
+
+  # All the errors specific to Dynamoid.  The goal is to mimic ActiveRecord.
+  module Errors
+
+    # Generic Dynamoid error
+    class Error < StandardError; end
+
+    class MissingRangeKey < Error; end
+
+    class MissingIndex < Error; end
+
+    # InvalidIndex is raised when an invalid index is specified, for example if
+    # specified key attribute(s) or projected attributes do not exist.
+    class InvalidIndex < Error
+      def initialize(item)
+        if (item.is_a? String)
+          super(item)
+        else
+          super("Validation failed: #{item.errors.full_messages.join(", ")}")
+        end
+      end
+    end
+
+    # This class is intended to be private to Dynamoid.
+    class ConditionalCheckFailedException < Error
+      attr_reader :inner_exception
+
+      def initialize(inner)
+        super
+        @inner_exception = inner
+      end
+    end
+
+    class RecordNotUnique < ConditionalCheckFailedException
+      attr_reader :original_exception
+
+      def initialize(original_exception, record)
+        super("Attempted to write record #{record} when its key already exists")
+        @original_exception = original_exception
+      end
+    end
+
+    class StaleObjectError < ConditionalCheckFailedException
+      attr_reader :record, :attempted_action
+
+      def initialize(record, attempted_action)
+        super("Attempted to #{attempted_action} a stale object #{record}")
+        @record = record
+        @attempted_action = attempted_action
+      end
+    end
+
+    class DocumentNotValid < Error
+      attr_reader :document
+
+      def initialize(document)
+        super("Validation failed: #{document.errors.full_messages.join(", ")}")
+        @document = document
+      end
+    end
+
+    class InvalidQuery < Error; end
+  end
+end

data/lib/dynamoid/fields.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+  # All fields on a Dynamoid::Document must be explicitly defined -- if you have fields in the database that are not
+  # specified with field, then they will be ignored.
+  module Fields
+    extend ActiveSupport::Concern
+
+    PERMITTED_KEY_TYPES = [
+      :number,
+      :integer,
+      :string,
+      :datetime
+    ]
+
+    # Initialize the attributes we know the class has, in addition to our magic attributes: id, created_at, and updated_at.
+    included do
+      class_attribute :attributes
+      class_attribute :range_key
+
+      self.attributes = {}
+      field :created_at, :datetime
+      field :updated_at, :datetime
+
+      field :id #Default primary key
+    end
+
+    module ClassMethods
+
+      # Specify a field for a document.
+      #
+      # Its type determines how it is coerced when read in and out of the datastore.
+      # You can specify :integer, :number, :set, :array, :datetime, and :serialized,
+      # or specify a class that defines a serialization strategy.
+      #
+      # If you specify a class for field type, Dynamoid will serialize using
+      # `dynamoid_dump` or `dump` methods, and load using `dynamoid_load` or `load` methods.
+      #
+      # Default field type is :string.
+      #
+      # @param [Symbol] name the name of the field
+      # @param [Symbol] type the type of the field (refer to method description for details)
+      # @param [Hash] options any additional options for the field
+      #
+      # @since 0.2.0
+      def field(name, type = :string, options = {})
+        named = name.to_s
+        if type == :float
+          Dynamoid.logger.warn("Field type :float, which you declared for '#{name}', is deprecated in favor of :number.")
+          type = :number
+        end
+        self.attributes = attributes.merge(name => {:type => type}.merge(options))
+
+        define_method(named) { read_attribute(named) }
+        define_method("#{named}?") do
+          value = read_attribute(named)
+          case value
+          when true        then true
+          when false, nil  then false
+          else
+            !value.nil?
+          end
+        end
+        define_method("#{named}=") {|value| write_attribute(named, value) }
+      end
+
+      def range(name, type = :string)
+        field(name, type)
+        self.range_key = name
+      end
+
+      def table(options)
+        #a default 'id' column is created when Dynamoid::Document is included
+        unless(attributes.has_key? hash_key)
+          remove_field :id
+          field(hash_key)
+        end
+      end
+
+      def remove_field(field)
+        field = field.to_sym
+        attributes.delete(field) or raise "No such field"
+        remove_method field
+        remove_method :"#{field}="
+        remove_method :"#{field}?"
+      end
+    end
+
+    # You can access the attributes of an object directly on its attributes method, which is by default an empty hash.
+    attr_accessor :attributes
+    alias :raw_attributes :attributes
+
+    # Write an attribute on the object. Also marks the previous value as dirty.
+    #
+    # @param [Symbol] name the name of the field
+    # @param [Object] value the value to assign to that field
+    #
+    # @since 0.2.0
+    def write_attribute(name, value)
+      if (size = value.to_s.size) > MAX_ITEM_SIZE
+        Dynamoid.logger.warn "DynamoDB can't store items larger than #{MAX_ITEM_SIZE} and the #{name} field has a length of #{size}."
+      end
+
+      if association = @associations[name]
+        association.reset
+      end
+
+      attributes[name.to_sym] = value
+    end
+    alias :[]= :write_attribute
+
+    # Read an attribute from an object.
+    #
+    # @param [Symbol] name the name of the field
+    #
+    # @since 0.2.0
+    def read_attribute(name)
+      attributes[name.to_sym]
+    end
+    alias :[] :read_attribute
+
+    # Updates multiple attibutes at once, saving the object once the updates are complete.
+    #
+    # @param [Hash] attributes a hash of attributes to update
+    #
+    # @since 0.2.0
+    def update_attributes(attributes)
+      attributes.each {|attribute, value| self.write_attribute(attribute, value)} unless attributes.nil? || attributes.empty?
+      save
+    end
+
+    # Update a single attribute, saving the object afterwards.
+    #
+    # @param [Symbol] attribute the attribute to update
+    # @param [Object] value the value to assign it
+    #
+    # @since 0.2.0
+    def update_attribute(attribute, value)
+      write_attribute(attribute, value)
+      save
+    end
+
+    private
+
+    # Automatically called during the created callback to set the created_at time.
+    #
+    # @since 0.2.0
+    def set_created_at
+      self.created_at = DateTime.now if Dynamoid::Config.timestamps
+    end
+
+    # Automatically called during the save callback to set the updated_at time.
+    #
+    # @since 0.2.0
+    def set_updated_at
+      self.updated_at = DateTime.now if Dynamoid::Config.timestamps
+    end
+
+    def set_type
+      self.type ||= self.class.to_s if self.class.attributes[:type]
+    end
+
+  end
+
+end