dynamoid-edge 1.1.0

data/lib/dynamoid/config/options.rb

@@ -0,0 +1,78 @@
+# Shamelessly stolen from Mongoid!
+module Dynamoid #:nodoc
+  module Config
+
+    # Encapsulates logic for setting options.
+    module Options
+
+      # Get the defaults or initialize a new empty hash.
+      #
+      # @example Get the defaults.
+      #   options.defaults
+      #
+      # @return [ Hash ] The default options.
+      #
+      # @since 0.2.0
+      def defaults
+        @defaults ||= {}
+      end
+
+      # Define a configuration option with a default.
+      #
+      # @example Define the option.
+      #   Options.option(:persist_in_safe_mode, :default => false)
+      #
+      # @param [ Symbol ] name The name of the configuration option.
+      # @param [ Hash ] options Extras for the option.
+      #
+      # @option options [ Object ] :default The default value.
+      #
+      # @since 0.2.0
+      def option(name, options = {})
+        defaults[name] = settings[name] = options[:default]
+
+        class_eval <<-RUBY
+          def #{name}
+            settings[#{name.inspect}]
+          end
+
+          def #{name}=(value)
+            settings[#{name.inspect}] = value
+          end
+
+          def #{name}?
+            #{name}
+          end
+          
+          def reset_#{name}
+            settings[#{name.inspect}] = defaults[#{name.inspect}]
+          end
+        RUBY
+      end
+
+      # Reset the configuration options to the defaults.
+      #
+      # @example Reset the configuration options.
+      #   config.reset
+      #
+      # @return [ Hash ] The defaults.
+      #
+      # @since 0.2.0
+      def reset
+        settings.replace(defaults)
+      end
+
+      # Get the settings or initialize a new empty hash.
+      #
+      # @example Get the settings.
+      #   options.settings
+      #
+      # @return [ Hash ] The setting options.
+      #
+      # @since 0.2.0
+      def settings
+        @settings ||= {}
+      end
+    end
+  end
+end

data/lib/dynamoid/config.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require "uri"
+require "dynamoid/config/options"
+
+module Dynamoid
+
+  # Contains all the basic configuration information required for Dynamoid: both sensible defaults and required fields.
+  module Config
+    extend self
+    extend Options
+    include ActiveModel::Observing if defined?(ActiveModel::Observing)
+
+    # All the default options.
+    option :adapter, :default => 'aws_sdk_v2'
+    option :namespace, :default => defined?(Rails) ? "dynamoid_#{Rails.application.class.parent_name}_#{Rails.env}" : "dynamoid"
+    option :logger, :default => defined?(Rails)
+    option :access_key
+    option :secret_key
+    option :read_capacity, :default => 100
+    option :write_capacity, :default => 20
+    option :warn_on_scan, :default => true
+    option :endpoint, :default => nil
+    option :use_ssl, :default => true
+    option :port, :default => '443'
+    option :identity_map, :default => false
+
+    # The default logger for Dynamoid: either the Rails logger or just stdout.
+    #
+    # @since 0.2.0
+    def default_logger
+      defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : ::Logger.new($stdout)
+    end
+
+    # Returns the assigned logger instance.
+    #
+    # @since 0.2.0
+    def logger
+      @logger ||= default_logger
+    end
+
+    # If you want to, set the logger manually to any output you'd like. Or pass false or nil to disable logging entirely.
+    #
+    # @since 0.2.0
+    def logger=(logger)
+      case logger
+      when false, nil then @logger = nil
+      when true then @logger = default_logger
+      else
+        @logger = logger if logger.respond_to?(:info)
+      end
+    end
+
+  end
+end

data/lib/dynamoid/criteria/chain.rb

@@ -0,0 +1,212 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+  module Criteria
+
+    # The criteria chain is equivalent to an ActiveRecord relation (and realistically I should change the name from
+    # chain to relation). It is a chainable object that builds up a query and eventually executes it by a Query or Scan.
+    class Chain
+      attr_accessor :query, :source, :values, :consistent_read
+      include Enumerable
+
+      # Create a new criteria chain.
+      #
+      # @param [Class] source the class upon which the ultimate query will be performed.
+      def initialize(source)
+        @query = {}
+        @source = source
+        @consistent_read = false
+        @scan_index_forward = true
+      end
+
+      # The workhorse method of the criteria chain. Each key in the passed in hash will become another criteria that the
+      # ultimate query must match. A key can either be a symbol or a string, and should be an attribute name or
+      # an attribute name with a range operator.
+      #
+      # @example A simple criteria
+      #   where(:name => 'Josh')
+      #
+      # @example A more complicated criteria
+      #   where(:name => 'Josh', 'created_at.gt' => DateTime.now - 1.day)
+      #
+      # @since 0.2.0
+      def where(args)
+        args.each {|k, v| query[k.to_sym] = v}
+        self
+      end
+
+      def consistent
+        @consistent_read = true
+        self
+      end
+
+      # Returns all the records matching the criteria.
+      #
+      # @since 0.2.0
+      def all
+        records
+      end
+
+      # Destroys all the records matching the criteria.
+      #
+      def destroy_all
+        ids = []
+
+        if key_present?
+          ranges = []
+          Dynamoid.adapter.query(source.table_name, range_query).collect do |hash|
+            ids << hash[source.hash_key.to_sym]
+            ranges << hash[source.range_key.to_sym]
+          end
+
+          Dynamoid.adapter.delete(source.table_name, ids,{:range_key => ranges})
+        else
+          Dynamoid.adapter.scan(source.table_name, query, scan_opts).collect do |hash|
+            ids << hash[source.hash_key.to_sym]
+          end
+
+          Dynamoid.adapter.delete(source.table_name, ids)
+        end
+      end
+
+      def eval_limit(limit)
+        @eval_limit = limit
+        self
+      end
+
+      def batch(batch_size)
+        @batch_size = batch_size
+        self
+      end
+
+      def start(start)
+        @start = start
+        self
+      end
+
+      def scan_index_forward(scan_index_forward)
+        @scan_index_forward = scan_index_forward
+        self
+      end
+
+      # Allows you to use the results of a search as an enumerable over the results found.
+      #
+      # @since 0.2.0
+      def each(&block)
+        records.each(&block)
+      end
+
+      def consistent_opts
+        { :consistent_read => consistent_read }
+      end
+
+      private
+
+      # The actual records referenced by the association.
+      #
+      # @return [Enumerator] an iterator of the found records.
+      #
+      # @since 0.2.0
+      def records
+        results = if key_present?
+          records_via_query
+        else
+          records_via_scan
+        end
+        @batch_size ? results : Array(results)
+      end
+
+      def records_via_query
+        Enumerator.new do |yielder|
+          Dynamoid.adapter.query(source.table_name, range_query).each do |hash|
+            yielder.yield source.from_database(hash)
+          end
+        end
+      end
+
+      # If the query does not match an index, we'll manually scan the associated table to find results.
+      #
+      # @return [Enumerator] an iterator of the found records.
+      #
+      # @since 0.2.0
+      def records_via_scan
+        if Dynamoid::Config.warn_on_scan
+          Dynamoid.logger.warn 'Queries without an index are forced to use scan and are generally much slower than indexed queries!'
+          Dynamoid.logger.warn "You can index this query by adding this to #{source.to_s.downcase}.rb: index [#{source.attributes.sort.collect{|attr| ":#{attr}"}.join(', ')}]"
+        end
+
+        if @consistent_read
+          raise Dynamoid::Errors::InvalidQuery, 'Consistent read is not supported by SCAN operation'
+        end
+
+        Enumerator.new do |yielder|
+          Dynamoid.adapter.scan(source.table_name, query, scan_opts).each do |hash|
+            yielder.yield source.from_database(hash)
+          end
+        end
+      end
+
+      def range_hash(key)
+        val = query[key]
+
+        return { :range_value => query[key] } if query[key].is_a?(Range)
+
+        case key.to_s.split('.').last
+        when 'gt'
+          { :range_greater_than => val.to_f }
+        when 'lt'
+          { :range_less_than  => val.to_f }
+        when 'gte'
+          { :range_gte  => val.to_f }
+        when 'lte'
+          { :range_lte => val.to_f }
+        when 'begins_with'
+          { :range_begins_with => val }
+        end
+      end
+
+      def range_query
+        opts = { :hash_value => query[source.hash_key] }
+        if key = query.keys.find { |k| k.to_s.include?('.') }
+          opts.merge!(range_hash(key))
+        end
+        opts.merge(query_opts).merge(consistent_opts)
+      end
+
+      def query_keys
+        query.keys.collect{|k| k.to_s.split('.').first}
+      end
+
+      # [hash_key] or [hash_key, range_key] is specified in query keys.
+      def key_present?
+        query_keys == [source.hash_key.to_s] || (query_keys.to_set == [source.hash_key.to_s, source.range_key.to_s].to_set)
+      end
+
+      def start_key
+        key = { :hash_key_element => @start.hash_key }
+        if range_key = @start.class.range_key
+          key.merge!({:range_key_element => @start.send(range_key) })
+        end
+        key
+      end
+
+      def query_opts
+        opts = {}
+        opts[:select] = 'ALL_ATTRIBUTES'
+        opts[:limit] = @eval_limit if @eval_limit
+        opts[:next_token] = start_key if @start
+        opts[:scan_index_forward] = @scan_index_forward
+        opts
+      end
+
+      def scan_opts
+        opts = {}
+        opts[:limit] = @eval_limit if @eval_limit
+        opts[:next_token] = start_key if @start
+        opts[:batch_size] = @batch_size if @batch_size
+        opts
+      end
+    end
+
+  end
+
+end

data/lib/dynamoid/criteria.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'dynamoid/criteria/chain'
+
+module Dynamoid
+
+  # Allows classes to be queried by where, all, first, and each and return criteria chains.
+  module Criteria
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      
+      [:where, :all, :first, :each, :eval_limit, :start, :scan_index_forward].each do |meth|
+        # Return a criteria chain in response to a method that will begin or end a chain. For more information, 
+        # see Dynamoid::Criteria::Chain.
+        #
+        # @since 0.2.0
+        define_method(meth) do |*args|
+          chain = Dynamoid::Criteria::Chain.new(self)
+          if args
+            chain.send(meth, *args)
+          else
+            chain.send(meth)
+          end
+        end
+      end
+    end
+  end
+  
+end

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 = {})
+        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save) : new(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 = {})
+        attrs[:type] ? attrs[:type].constantize.new(attrs).tap(&:save!) : new(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,63 @@
+# 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
+      def initialize(document)
+        super("Validation failed: #{document.errors.full_messages.join(", ")}")
+      end
+    end
+
+    class InvalidQuery < Error; end
+  end
+end