dynamoid 0.0.2

data/lib/dynamoid/adapter/local.rb

@@ -0,0 +1,77 @@
+module Dynamoid
+  module Adapter
+    module Local
+      extend self
+      # Gimpy hash that should be somewhat equivalent to what Amazon's actual DynamoDB, for offline development.
+    
+      def data
+        @data ||= {}
+      end
+    
+      def reset_data
+        self.data.each {|k, v| v[:data] = {}}
+      end
+    
+      # BatchGetItem
+      def batch_get_item(options)
+        Hash.new { |h, k| h[k] = Array.new }.tap do |hash|
+          options.each do |table_name, keys|
+            table = data[table_name]
+            Array(keys).each do |key|
+              hash[table_name] << table[:data][key]
+            end
+          end
+        end
+      end
+    
+      # CreateTable
+      def create_table(table_name, key)
+        data[table_name] = {:id => key, :data => {}}
+      end
+    
+      # DeleteItem
+      def delete_item(table_name, key)
+        data[table_name][:data].delete(key)
+      end
+    
+      # DeleteTable
+      def delete_table(table_name)
+        data.delete(table_name)
+      end
+    
+      # DescribeTable
+    
+      # GetItem
+      def get_item(table_name, key)
+        data[table_name][:data][key]
+      end
+    
+      # ListTables
+      def list_tables
+        data.keys
+      end
+    
+      # PutItem
+      def put_item(table_name, object)
+        table = data[table_name]
+        table[:data][object[table[:id]]] = object
+      end
+    
+      # Query
+      def query(table_name, id)
+        get_item(table_name, id)
+      end
+    
+      # Scan
+      def scan(table_name, scan_hash)
+        return [] if data[table_name].nil?
+        data[table_name][:data].values.select{|d| scan_hash.all?{|k, v| !d[k].nil? && d[k] == v}}
+      end
+    
+      # UpdateItem
+    
+      # UpdateTable
+    
+    end
+  end
+end

data/lib/dynamoid/associations.rb

@@ -0,0 +1,54 @@
+require 'dynamoid/associations/association'
+require 'dynamoid/associations/has_many'
+require 'dynamoid/associations/belongs_to'
+require 'dynamoid/associations/has_one'
+require 'dynamoid/associations/has_and_belongs_to_many'
+
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # Connects models together through the magic of associations.
+  module Associations
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :associations
+      
+      self.associations = {}
+    end
+
+    module ClassMethods
+      def has_many(name, options = {})
+        association(:has_many, name, options)
+      end
+      
+      def has_one(name, options = {})
+        association(:has_one, name, options)
+      end
+      
+      def belongs_to(name, options = {})
+        association(:belongs_to, name, options)
+      end
+      
+      def has_and_belongs_to_many(name, options = {})
+        association(:has_and_belongs_to_many, name, options)
+      end
+      
+      private
+      
+      def association(type, name, options = {})
+        field "#{name}_ids".to_sym
+        self.associations[name] = options.merge(:type => type)
+        define_method(name) do
+          @associations ||= {}
+          @associations[name] ||= Dynamoid::Associations.const_get(type.to_s.camelcase).new(self, name, options)
+        end
+        define_method("#{name}=".to_sym) do |objects|
+          self.send(name) << objects
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/dynamoid/associations/association.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The base association module.
+  module Associations
+    module Association
+      attr_accessor :name, :options, :source
+
+      def initialize(source, name, options)
+        @name = name
+        @options = options
+        @source = source
+      end
+      
+      def empty?
+        records.empty?
+      end
+      alias :nil? :empty?
+      
+      def size
+        records.count
+      end
+      alias :count :size
+      
+      def include?(object)
+        records.include?(object)
+      end
+      
+      def delete(object)
+        source.update_attribute(source_attribute, source_ids - Array(object).collect(&:id))
+        Array(object).collect{|o| self.send(:disassociate_target, o)} if target_association
+        object
+      end
+      
+      def <<(object)
+        source.update_attribute(source_attribute, source_ids.merge(Array(object).collect(&:id)))
+        Array(object).collect{|o| self.send(:associate_target, o)} if target_association
+        object
+      end
+      
+      def create(attributes = {})
+        object = target_class.create(attributes)
+        self << object
+      end
+      
+      private
+      
+      def records
+        results = target_class.find(source_ids.to_a)
+        results.nil? ? [] : Array(results)
+      end
+      
+      def target_class
+        name.to_s.singularize.capitalize.constantize
+      end
+      
+      def target_attribute
+        "#{target_association}_ids".to_sym if target_association
+      end
+      
+      def target_ids
+        target.send(target_attribute) || Set.new
+      end
+      
+      def source_class
+        source.class
+      end
+      
+      def source_attribute
+        "#{name}_ids".to_sym
+      end
+      
+      def source_ids
+        source.send(source_attribute) || Set.new
+      end
+
+    end
+  end
+  
+end

data/lib/dynamoid/associations/belongs_to.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The BelongsTo association.
+  module Associations
+    class BelongsTo
+      include Dynamoid::Associations::Association
+      
+      def ==(other)
+        target == other
+      end
+      
+      private
+      
+      def target
+        records.first
+      end
+      
+      def target_association
+        has_many_key_name = source.class.to_s.pluralize.downcase.to_sym
+        has_one_key_name = source.class.to_s.downcase.to_sym
+        if !target_class.associations[has_many_key_name].nil?
+          return has_many_key_name if target_class.associations[has_many_key_name][:type] == :has_many
+        elsif !target_class.associations[has_one_key_name].nil?
+          return has_one_key_name if target_class.associations[has_one_key_name][:type] == :has_one
+        end
+      end
+      
+      def associate_target(object)
+        object.update_attribute(target_attribute, target_ids.merge(Array(source.id)))
+      end
+      
+      def disassociate_target(object)
+        source.update_attribute(source_attribute, target_ids - Array(source.id))
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/associations/has_and_belongs_to_many.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The habtm association.
+  module Associations
+    class HasAndBelongsToMany
+      include Dynamoid::Associations::Association
+      
+      def ==(other)
+        records == Array(other)
+      end
+      
+      private
+      
+      def target_association
+        key_name = source.class.to_s.pluralize.downcase.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :has_and_belongs_to_many
+        key_name
+      end
+            
+      def associate_target(object)
+        ids = object.send(target_attribute) || Set.new
+        object.update_attribute(target_attribute, ids.merge(Array(source.id)))
+      end
+      
+      def disassociate_target(object)
+        ids = object.send(target_attribute) || Set.new
+        source.update_attribute(source_attribute, ids - Array(source.id))
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/associations/has_many.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The HasMany association.
+  module Associations
+    class HasMany
+      include Dynamoid::Associations::Association
+      
+      def ==(other)
+        records == Array(other)
+      end
+
+      private
+
+      def target_association
+        key_name = source.class.to_s.singularize.downcase.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+        key_name
+      end
+            
+      def associate_target(object)
+        object.update_attribute(target_attribute, Set[source.id])
+      end
+      
+      def disassociate_target(object)
+        object.update_attribute(target_attribute, nil)
+      end
+      
+    end
+  end
+  
+end

data/lib/dynamoid/associations/has_one.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # The HasOne association.
+  module Associations
+    class HasOne
+      include Dynamoid::Associations::Association
+      
+      def ==(other)
+        target == other
+      end
+      
+      private
+      
+      def target
+        records.first
+      end
+      
+      def target_association
+        key_name = source.class.to_s.pluralize.downcase.to_sym
+        guess = target_class.associations[key_name]
+        return nil if guess.nil? || guess[:type] != :belongs_to
+        key_name
+      end
+      
+      def associate_target(object)
+        object.update_attribute(target_attribute, source.id)
+      end
+      
+      def disassociate_target(object)
+        source.update_attribute(source_attribute, nil)
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/attributes.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Attributes
+    extend ActiveSupport::Concern
+    
+    attr_accessor :attributes
+    alias :raw_attributes :attributes
+      
+    def write_attribute(name, value)
+      attributes[name.to_sym] = value
+    end
+    alias :[]= :write_attribute
+    
+    def read_attribute(name)
+      attributes[name.to_sym]
+    end
+    alias :[] :read_attribute
+    
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+    
+    def update_attribute(attribute, value)
+      self.attributes[attribute] = value
+      save
+    end
+    
+    module ClassMethods
+      def attributes
+        [self.fields + [:id]].flatten.uniq
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/components.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Dynamoid #:nodoc
+  module Components #:nodoc
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend ActiveModel::Translation
+    end
+
+    include ActiveModel::Conversion
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Naming
+    include ActiveModel::Observing
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Dynamoid::Attributes
+    include Dynamoid::Fields
+    include Dynamoid::Indexes
+    include Dynamoid::Persistence
+    include Dynamoid::Finders
+    include Dynamoid::Associations
+  end
+end

data/lib/dynamoid/config.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require "uri"
+require "dynamoid/config/options"
+
+module Dynamoid #:nodoc
+  
+  module Config
+    extend self
+    extend Options
+    include ActiveModel::Observing
+
+    option :adapter, :default => 'local'
+    option :namespace, :default => 'dynamoid'
+    option :access_key
+    option :secret_key
+    option :warn_on_scan, :default => true
+
+  end
+end