synamoid 1.2.1 → 1.2.2

data/lib/dynamoid/dirty.rb

@@ -1,47 +0,0 @@
-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

@@ -1,201 +0,0 @@
-# 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

@@ -1,66 +0,0 @@
-# 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

@@ -1,164 +0,0 @@
-# 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