Dynamoid 0.0.1

data/lib/dynamoid/attributes.rb

@@ -0,0 +1,27 @@
+# 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
+    
+    module ClassMethods
+      def attributes
+        [self.fields + [:id]].flatten.uniq
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/components.rb

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

data/lib/dynamoid/config/options.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+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 2.3.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 2.0.0.rc.1
+      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
+        RUBY
+      end
+
+      # Reset the configuration options to the defaults.
+      #
+      # @example Reset the configuration options.
+      #   config.reset
+      #
+      # @return [ Hash ] The defaults.
+      #
+      # @since 2.3.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 2.3.0
+      def settings
+        @settings ||= {}
+      end
+    end
+  end
+end

data/lib/dynamoid/document.rb

@@ -0,0 +1,35 @@
+# 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
+
+    attr_accessor :new_record
+    
+    def initialize(attrs = {})
+      @new_record = true
+      @attributes ||= {}
+      self.class.attributes.each {|att| write_attribute(att, attrs[att])}
+    end
+    
+    def ==(other)
+      other.respond_to?(:id) && other.id == self.id
+    end
+    
+    module ClassMethods
+      def create(attrs = {})
+        obj = self.new(attrs)
+        obj.save && obj.new_record = false
+        obj
+      end
+      
+      def build(attrs = {})
+        self.new(attrs)
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/errors.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module Dynamoid
+  module Errors
+
+    class InvalidField < Exception; end
+    
+  end
+end

data/lib/dynamoid/fields.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  module Fields
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :fields
+      
+      self.fields = []
+      field :id
+    end
+    
+    module ClassMethods
+      def field(name, options = {})
+        named = name.to_s
+        self.fields << name
+        define_method(named) do
+          read_attribute(named)
+        end
+        define_method("#{named}=") do |value|
+          write_attribute(named, value)
+        end
+        define_method("#{named}?") do
+          !read_attribute(named).nil?
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/dynamoid/finders.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # This module defines the finder methods that hang off the document at the
+  # class level.
+  module Finders
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def find(*id)
+        id = Array(id.flatten.uniq)
+        if id.count == 1
+          self.find_by_id(id.first)
+        else
+          items = Dynamoid::Adapter.batch_get_item(self.table_name => id)
+          items[self.table_name].collect{|i| o = self.build(i); o.new_record = false; o}
+        end
+      end
+      
+      def find_by_id(id)
+        obj = self.new(Dynamoid::Adapter.get_item(self.table_name, id))
+        obj.new_record = false
+        obj    
+      end
+      
+      def method_missing(method, *args)
+        if method =~ /find/
+          finder = method.to_s.split('_by_').first
+          attributes = method.to_s.split('_by_').last.split('_and_')
+          
+          results = if index = self.indexes.find {|i| i == attributes.sort.collect(&:to_sym)}
+            ids = Dynamoid::Adapter.get_item(self.index_table_name(index), self.key_for_index(index, args))
+            if ids.nil? || ids.empty?
+              []
+            else
+              self.find(ids[:ids].to_a)
+            end
+          else
+            if Dynamoid::Config.warn_on_scan
+              puts 'Queries without an index are forced to use scan and are generally much slower than indexed queries!'
+              puts "You can index this query by adding this to #{self.to_s.downcase}.rb: index [#{attributes.sort.collect{|attr| ":#{attr}"}.join(', ')}]"
+            end
+            scan_hash = {}
+            attributes.each_with_index {|attr, index| scan_hash[attr.to_sym] = args[index]}
+            Dynamoid::Adapter.scan(self.table_name, scan_hash).collect {|hash| self.new(hash)}
+          end
+          
+          if finder =~ /all/
+            return Array(results)
+          else
+            return results.first
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/indexes.rb

@@ -0,0 +1,59 @@
+require 'digest/sha2'
+
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # Builds all indexes present on the model.
+  module Indexes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :indexes
+      
+      self.indexes = []
+    end
+    
+    module ClassMethods
+      def index(name, options = {})
+        name = Array(name).collect(&:to_s).sort.collect(&:to_sym)
+        raise Dynamoid::Errors::InvalidField, 'A key specified for an index is not a field' unless name.all?{|n| self.fields.include?(n)}
+        self.indexes << name
+        create_indexes
+      end
+      
+      def create_indexes
+        self.indexes.each do |index|
+          self.create_table(index_table_name(index), index_key_name(index)) unless self.table_exists?(index_table_name(index))
+        end
+      end
+      
+      def index_table_name(index)
+        "#{Dynamoid::Config.namespace}_index_#{index_key_name(index)}"
+      end
+      
+      def index_key_name(index)
+        "#{self.to_s.downcase}_#{index.collect(&:to_s).collect(&:pluralize).join('_and_')}"
+      end
+      
+      def key_for_index(index, values = [])
+        values = values.collect(&:to_s).sort
+        Digest::SHA2.new.tap do |sha|
+          index.each_with_index {|i, index| sha << values[index] if values[index]}
+        end.to_s
+      end
+    end
+    
+    def key_for_index(index)
+      self.class.key_for_index(index, index.collect{|i| self.send(i)})
+    end
+    
+    def save_indexes
+      self.class.indexes.each do |index|
+        existing = Dynamoid::Adapter.get_item(self.class.index_table_name(index), self.key_for_index(index))
+        ids = existing ? existing[:ids] : Set.new
+        Dynamoid::Adapter.put_item(self.class.index_table_name(index), {self.class.index_key_name(index).to_sym => self.key_for_index(index), :ids => ids.merge([self.id])})
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/persistence.rb

@@ -0,0 +1,35 @@
+require 'securerandom'
+
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # This module saves things!
+  module Persistence
+    extend ActiveSupport::Concern
+    
+    included do
+      self.create_table(self.table_name) unless self.table_exists?(self.table_name)
+    end
+    
+    def save
+      self.id = SecureRandom.uuid if self.id.nil? || self.id.blank?
+      Dynamoid::Adapter.put_item(self.class.table_name, self.attributes)
+      save_indexes
+    end
+    
+    module ClassMethods
+      def table_name
+        "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
+      end
+      
+      def create_table(table_name, id = :id)
+        Dynamoid::Adapter.create_table(table_name, id.to_sym)
+      end
+      
+      def table_exists?(table_name)
+        Dynamoid::Adapter.list_tables.include?(table_name)
+      end
+    end
+  end
+  
+end

data/lib/dynamoid/relations.rb

@@ -0,0 +1,21 @@
+require 'digest/sha2'
+
+# encoding: utf-8
+module Dynamoid #:nodoc:
+
+  # Associate a document with another object: belongs_to, has_many, and has_and_belongs_to_many
+  module Relations
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :indexes
+      
+      self.indexes = []
+    end
+    
+    module ClassMethods
+
+    end
+  end
+  
+end

data/spec/app/models/address.rb

@@ -0,0 +1,5 @@
+class Address
+  include Dynamoid::Document
+  
+  field :city
+end

data/spec/app/models/user.rb

@@ -0,0 +1,11 @@
+class User
+  include Dynamoid::Document
+  
+  field :name
+  field :email
+  field :password
+  
+  index :name
+  index :email
+  index [:name, :email]
+end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -0,0 +1,123 @@
+require 'dynamoid/adapter/aws_sdk'
+require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
+
+describe Dynamoid::Adapter::AwsSdk do
+  
+  if ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
+    
+    context 'without a preexisting table' do
+      # CreateTable and DeleteTable
+      it 'performs CreateTable and DeleteTable' do
+        table = Dynamoid::Adapter.create_table('CreateTable', :id)
+
+        Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
+
+        Dynamoid::Adapter.delete_table('CreateTable')
+      end
+    end
+    
+    context 'with a preexisting table' do
+      before(:all) do
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
+      end
+
+      # GetItem, PutItem and DeleteItem
+      it "performs GetItem for an item that does not exist" do
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
+      end
+
+      it "performs GetItem for an item that does exist" do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:name => 'Josh', :id => '1'}
+
+        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
+        
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
+      end
+      
+      it 'performs DeleteItem for an item that does not exist' do
+        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
+
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
+      end
+
+      it 'performs PutItem for an item that does not exist' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:id => '1', :name => 'Josh'}
+      end
+      
+      # BatchGetItem
+      it "performs BatchGetItem with singular keys" do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
+        results.size.should == 2
+        results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
+        results['dynamoid_tests_TestTable2'].should include({:name => 'Justin', :id => '1'})
+      end
+      
+      it "performs BatchGetItem with multiple keys" do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
+        
+        results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
+        results.size.should == 1
+        results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
+        results['dynamoid_tests_TestTable1'].should include({:name => 'Justin', :id => '2'})
+      end
+      
+      # ListTables
+      it 'performs ListTables' do
+        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable1'
+        Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable2'
+      end
+      
+      # Query
+      it 'performs query on a table and returns items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', '1').should == { :id=> '1', :name=>"Josh" }
+      end
+
+      it 'performs query on a table and returns items if there are multiple items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
+
+        Dynamoid::Adapter.query('dynamoid_tests_TestTable1', '1').should == { :id=> '1', :name=>"Josh" }
+      end
+
+      # Scan
+      it 'performs scan on a table and returns items' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      end
+
+      it 'performs scan on a table and returns items if there are multiple items but only one match' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
+      end
+
+      it 'performs scan on a table and returns multiple items if there are multiple matches' do
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
+        Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
+
+        Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"}] 
+      end
+      
+    end
+    
+    # DescribeTable
+    
+    # UpdateItem
+    
+    # UpdateTable
+  
+  end
+end