synamoid 1.2.1

data/lib/dynamoid/associations/single_association.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Associations
+    module SingleAssociation
+      include Association
+
+      delegate :class, :to => :target
+
+      def setter(object)
+        delete
+        source.update_attribute(source_attribute, Set[object.hash_key])
+        self.send(:associate_target, object) if target_association
+        object
+      end
+
+      def delete
+        source.update_attribute(source_attribute, nil)
+        self.send(:disassociate_target, target) if target && target_association
+        target
+      end
+
+      def create!(attributes = {})
+        setter(target_class.create!(attributes))
+      end
+
+      def create(attributes = {})
+        setter(target_class.create(attributes))
+      end
+
+
+      # Is this object equal to the association's target?
+      #
+      # @return [Boolean] true/false
+      #
+      # @since 0.2.0
+      def ==(other)
+        target == other
+      end
+
+      # Delegate methods we don't find directly to the target.
+      #
+      # @since 0.2.0
+      def method_missing(method, *args)
+        if target.respond_to?(method)
+          target.send(method, *args)
+        else
+          super
+        end
+      end
+
+      def nil?
+        target.nil?
+      end
+
+      private
+
+      # Find the target of the has_one association.
+      #
+      # @return [Dynamoid::Document] the found target (or nil if nothing)
+      #
+      # @since 0.2.0
+      def find_target
+        return if source_ids.empty?
+        target_class.find(source_ids.first)
+      end
+    end
+  end
+end

data/lib/dynamoid/components.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Dynamoid
+
+  # All modules that a Document is composed of are defined in this
+  # module, to keep the document class from getting too cluttered.
+  module Components
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Translation
+      extend ActiveModel::Callbacks
+
+      define_model_callbacks :create, :save, :destroy, :initialize, :update
+
+      before_create :set_created_at
+      before_save :set_updated_at
+      after_initialize :set_type
+    end
+
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Conversion
+    include ActiveModel::MassAssignmentSecurity if defined?(ActiveModel::MassAssignmentSecurity)
+    include ActiveModel::Naming
+    include ActiveModel::Observing if defined?(ActiveModel::Observing)
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Dynamoid::Fields
+    include Dynamoid::Indexes
+    include Dynamoid::Persistence
+    include Dynamoid::Finders
+    include Dynamoid::Associations
+    include Dynamoid::Criteria
+    include Dynamoid::Validations
+    include Dynamoid::IdentityMap
+    include Dynamoid::Dirty
+  end
+end

data/lib/dynamoid/config.rb

@@ -0,0 +1,58 @@
+# 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
+    option :timestamps, :default => true
+    option :sync_retry_max_times, :default => 60 # a bit over 2 minutes
+    option :sync_retry_wait_seconds, :default => 2
+    option :convert_big_decimal, :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/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/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/criteria/chain.rb

@@ -0,0 +1,214 @@
+# 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 }
+        when 'lt'
+          { :range_less_than  => val }
+        when 'gte'
+          { :range_gte  => val }
+        when 'lte'
+          { :range_lte => val }
+        when 'between'
+          { :range_between => val }
+        when 'begins_with'
+          { :range_begins_with => val }
+        end
+      end
+
+      def range_query
+        opts = { :hash_value => query[source.hash_key] }
+        query.keys.select { |k| k.to_s.include?('.') }.each do |key|
+          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