dynamoid-moda 0.7.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.id])
+        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,57 @@
+# 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'
+    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 :partitioning, :default => false
+    option :partition_size, :default => 200
+    option :endpoint, :default => 'dynamodb.us-east-1.amazonaws.com'
+    option :use_ssl, :default => true
+    option :port, :default => '443'
+    option :included_models, :default => []
+    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/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, :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,326 @@
+# 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 either on an index
+    # or by a full table scan.
+    class Chain
+      attr_accessor :query, :source, :index, :values, :limit, :start, :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(opts = {})
+        batch opts[:batch_size] if opts.has_key? :batch_size
+        records
+      end
+      
+      # Destroys all the records matching the criteria.
+      #
+      def destroy_all
+        ids = []
+        
+        if range?
+          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})
+        elsif index
+          #TODO: test this throughly and find a way to delete all index table records for one source record
+          if index.range_key?
+            results = Dynamoid::Adapter.query(index.table_name, index_query.merge(consistent_opts))
+          else
+            results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
+          end
+          
+          results.collect do |hash| 
+            ids << hash[source.hash_key.to_sym]
+            index_ranges << hash[source.range_key.to_sym]
+          end
+        
+          unless ids.nil? || ids.empty?
+            ids = ids.to_a
+  
+            if @start
+              ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
+              index_ranges = index_ranges.drop_while { |range| range != @start.hash_key }.drop(1) unless index_ranges.nil?
+            end
+  
+            if @limit           
+              ids = ids.take(@limit) 
+              index_ranges = index_ranges.take(@limit)
+            end
+            
+            Dynamoid::Adapter.delete(source.table_name, ids)
+            
+            if index.range_key?
+              Dynamoid::Adapter.delete(index.table_name, ids,{:range_key => index_ranges})
+            else
+              Dynamoid::Adapter.delete(index.table_name, ids)
+            end
+            
+          end
+        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
+
+      # Returns the first record matching the criteria.
+      #
+      # @since 0.2.0
+      def first
+        limit(1).first
+      end
+
+      def limit(limit)
+        @limit = limit
+        records
+      end
+
+      def batch(batch_size)
+        raise 'Cannot batch calls when using partitioning' if Dynamoid::Config.partitioning?
+        @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 range?
+          records_with_range
+        elsif index
+          records_with_index
+        else
+          records_without_index
+        end
+        @batch_size ? results : Array(results)
+      end
+
+      # If the query matches an index on the associated class, then this method will retrieve results from the index table.
+      #
+      # @return [Enumerator] an iterator of the found records.
+      #
+      # @since 0.2.0
+      def records_with_index
+        ids = ids_from_index
+        if ids.nil? || ids.empty?
+          [].to_enum
+        else
+          ids = ids.to_a
+
+          if @start
+            ids = ids.drop_while { |id| id != @start.hash_key }.drop(1)
+          end
+
+          ids = ids.take(@limit) if @limit
+          source.find(ids, consistent_opts)
+        end
+      end
+
+      # Returns the Set of IDs from the index table.
+      #
+      # @return [Set] a Set containing the IDs from the index.
+      def ids_from_index
+        if index.range_key?
+          Dynamoid::Adapter.query(index.table_name, index_query.merge(consistent_opts)).inject(Set.new) do |all, record|
+            all + Set.new(record[:ids])
+          end
+        else
+          results = Dynamoid::Adapter.read(index.table_name, index_query[:hash_value], consistent_opts)
+          results ? results[:ids] : []
+        end
+      end
+
+      def records_with_range
+        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_without_index
+        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
+
+      # Format the provided query so that it can be used to query results from DynamoDB.
+      #
+      # @return [Hash] a hash with keys of :hash_value and :range_value
+      #
+      # @since 0.2.0
+      def index_query
+        values = index.values(query)
+        {}.tap do |hash|
+          hash[:hash_value] = values[:hash_value]
+          if index.range_key?
+            key = query.keys.find{|k| k.to_s.include?('.')}
+            if key
+              hash.merge!(range_hash(key))
+            else
+              raise Dynamoid::Errors::MissingRangeKey, 'This index requires a range key'
+            end
+          end
+        end
+      end
+
+      def range_hash(key)
+        val = query[key]
+
+        return { :range_value => query[key] } if query[key].is_a?(Range)
+
+        case key.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
+
+      # Return an index that fulfills all the attributes the criteria is querying, or nil if none is found.
+      #
+      # @since 0.2.0
+      def index
+        index = source.find_index(query_keys)
+        return nil if index.blank?
+        index
+      end
+
+      def query_keys
+        query.keys.collect{|k| k.to_s.split('.').first}
+      end
+
+      # Use range query only when [hash_key] or [hash_key, range_key] is specified in query keys.
+      def range?
+        return false unless query_keys.include?(source.hash_key.to_s) or query_keys.include?(source.range_key.to_s)
+        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
+ 	      hash_key_type = @start.class.attributes[@start.class.hash_key][:type] == :string ? 'S' : 'N'
+        key = { :hash_key_element => { hash_key_type => @start.hash_key.to_s } }
+        if range_key = @start.class.range_key
+          range_key_type = @start.class.attributes[range_key][:type] == :string ? 'S' : 'N'
+          key.merge!({:range_key_element => { range_key_type => @start.send(range_key).to_s } })
+        end
+        key
+      end
+
+      def query_opts
+        opts = {}
+        opts[:select] = :all
+        opts[:limit] = @limit if @limit
+        opts[:next_token] = start_key if @start
+        opts[:scan_index_forward] = @scan_index_forward
+        opts
+      end
+      
+      def scan_opts
+        opts = {}
+        opts[:limit] = @limit if @limit
+        opts[:next_token] = start_key if @start
+        opts[:batch_size] = @batch_size if @batch_size
+        opts
+      end
+    end
+
+  end
+
+end