synamoid 1.2.1 → 1.2.2

data/lib/dynamoid/associations/single_association.rb

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

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

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

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

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

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