dynamoid 0.3.2 → 0.4.0

data/lib/dynamoid/indexes.rb

@@ -40,8 +40,9 @@ module Dynamoid #:nodoc:
       # @since 0.2.0
       def create_indexes
         self.indexes.each do |name, index|
-          opts = index.range_key? ? {:range_key => :range} : {}
-          self.create_table(index.table_name, :id, opts) unless self.table_exists?(index.table_name)
+          opts = {:table_name => index.table_name, :id => :id}
+          opts[:range_key] = { :range => :number } if index.range_key?
+          self.create_table(opts)
         end
       end
     end

data/lib/dynamoid/indexes/index.rb

@@ -81,7 +81,7 @@ module Dynamoid #:nodoc:
         self.delete(obj, true)
         values = values(obj)
         return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
-        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], values[:range_value])
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value] })
         ids = ((existing and existing[:ids]) or Set.new)
         Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => ids.merge([obj.id]), :range => values[:range_value]})
       end
@@ -93,7 +93,7 @@ module Dynamoid #:nodoc:
       def delete(obj, changed_attributes = false)
         values = values(obj, changed_attributes)
         return true if values[:hash_value].blank? || (!values[:range_value].nil? && values[:range_value].blank?)
-        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], values[:range_value])
+        existing = Dynamoid::Adapter.read(self.table_name, values[:hash_value], { :range_key => values[:range_value]})
         return true unless existing && existing[:ids] && existing[:ids].include?(obj.id)
         Dynamoid::Adapter.write(self.table_name, {:id => values[:hash_value], :ids => (existing[:ids] - Set[obj.id]), :range => values[:range_value]})
       end

data/lib/dynamoid/persistence.rb

@@ -17,14 +17,31 @@ module Dynamoid
       #
       # @since 0.2.0
       def table_name
-        "#{Dynamoid::Config.namespace}_#{self.to_s.downcase.pluralize}"
+        "#{Dynamoid::Config.namespace}_#{options[:name] ? options[:name] : self.name.downcase.pluralize}"
       end
       
-      # Creates a table for a given table name, hash key, and range key.
+      # Creates a table.
       #
-      # @since 0.2.0
-      def create_table(table_name, id = :id, options = {})
-        Dynamoid::Adapter.tables << table_name if Dynamoid::Adapter.create_table(table_name, id.to_sym, options)
+      # @param [Hash] options options to pass for table creation
+      # @option options [Symbol] :id the id field for the table
+      # @option options [Symbol] :table_name the actual name for the table
+      # @option options [Integer] :read_capacity set the read capacity for the table; does not work on existing tables
+      # @option options [Integer] :write_capacity set the write capacity for the table; does not work on existing tables
+      # @option options [Hash] {range_key => :type} a hash of the name of the range key and a symbol of its type
+      #
+      # @since 0.4.0
+      def create_table(options = {})
+        options = {
+          :id => self.hash_key,
+          :table_name => self.table_name,
+          :write_capacity => self.write_capacity,
+          :read_capacity => self.read_capacity,
+          :range_key => self.range_key ? {range_key => attributes[range_key][:type]} : nil
+        }.merge(options)
+        
+        return true if table_exists?(options[:table_name])
+        
+        Dynamoid::Adapter.tables << options[:table_name] if Dynamoid::Adapter.create_table(options[:table_name], options[:id], options)
       end
 
       # Does a table with this name exist?
@@ -38,12 +55,12 @@ module Dynamoid
       #
       # @since 0.2.0
       def undump(incoming = nil)
-        incoming ||= {}
-        incoming = incoming.symbolize_keys
+        incoming = (incoming || {}).symbolize_keys
         Hash.new.tap do |hash|
           self.attributes.each do |attribute, options|
             hash[attribute] = undump_field(incoming[attribute], options[:type])
           end
+          incoming.each {|attribute, value| hash[attribute] ||= value }
         end
       end
 
@@ -84,11 +101,6 @@ module Dynamoid
 
     end
     
-    # Create the table if it doesn't exist already upon loading the class.
-    included do
-      self.create_table(self.table_name) unless self.table_exists?(self.table_name)
-    end
-    
     # Is this object persisted in the datastore? Required for some ActiveModel integration stuff.
     #
     # @since 0.2.0
@@ -100,6 +112,8 @@ module Dynamoid
     #
     # @since 0.2.0
     def save(options = {})
+      self.class.create_table
+
       @previously_changed = changes
 
       if new_record?
@@ -175,10 +189,11 @@ module Dynamoid
     # @since 0.2.0
     def persist
       run_callbacks(:save) do
-        self.id = SecureRandom.uuid if self.id.nil? || self.id.blank?
+        self.hash_key = SecureRandom.uuid if self.hash_key.nil? || self.hash_key.blank?
         Dynamoid::Adapter.write(self.class.table_name, self.dump)
         save_indexes
-        !(@new_record = false)
+        @new_record = false
+        true
       end
     end
         

data/spec/app/models/address.rb

@@ -3,4 +3,8 @@ class Address
   
   field :city
   field :options, :serialized
+
+  def zip_code=(zip_code)
+    self.city = "Chicago"
+  end
 end

data/spec/app/models/camel_case.rb

@@ -7,5 +7,18 @@ class CamelCase
   has_many :users
   has_one :sponsor
   has_and_belongs_to_many :subscriptions
+  
+  before_create :doing_before_create
+  after_create :doing_after_create
+  
+  private
+  
+  def doing_before_create
+    true
+  end
+  
+  def doing_after_create
+    true
+  end
 
 end

data/spec/app/models/tweet.rb

@@ -0,0 +1,9 @@
+class Tweet
+  include Dynamoid::Document
+
+  table name: :twitters, key: :tweet_id, read_capacity: 200, write_capacity: 200
+
+  range :group, :string
+
+  field :msg
+end

data/spec/dynamoid/adapter/aws_sdk_spec.rb

@@ -8,7 +8,7 @@ describe Dynamoid::Adapter::AwsSdk do
     context 'without a preexisting table' do
       # CreateTable and DeleteTable
       it 'performs CreateTable and DeleteTable' do
-        table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key => :created_at)
+        table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key =>  { :created_at => :number })
     
         Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
     
@@ -20,7 +20,7 @@ describe Dynamoid::Adapter::AwsSdk 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')
-        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => :range) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
+        Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
       end
 
       # GetItem, PutItem and DeleteItem
@@ -41,11 +41,11 @@ describe Dynamoid::Adapter::AwsSdk do
       it 'performs GetItem for an item that does exist with a range key' do
         Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 2.0})
 
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
 
-        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', 2.0)
+        Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0)
         
-        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', 2.0).should be_nil        
+        Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should be_nil        
       end
       
       it 'performs DeleteItem for an item that does not exist' do

data/spec/dynamoid/adapter/local_spec.rb

@@ -4,239 +4,239 @@ require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
 describe Dynamoid::Adapter::Local do
 
   unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
-  
+
     # BatchGetItem
     it 'performs BatchGetItem with singular keys' do
       Dynamoid::Adapter.create_table('table1', :id)
       Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.create_table('table2', :id)
-      Dynamoid::Adapter.put_item('table2', {:id => '1', :name => 'Justin'})    
-    
+      Dynamoid::Adapter.put_item('table2', {:id => '1', :name => 'Justin'})
+
       results = Dynamoid::Adapter.batch_get_item('table1' => '1', 'table2' => '1')
       results.size.should == 2
       results['table1'].should include({:name => 'Josh', :id => '1'})
       results['table2'].should include({:name => 'Justin', :id => '1'})
     end
-  
+
     it 'performs BatchGetItem with multiple keys' do
       Dynamoid::Adapter.create_table('table1', :id)
       Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('table1', {:id => '2', :name => 'Justin'})
-    
+
       results = Dynamoid::Adapter.batch_get_item('table1' => ['1', '2'])
       results.size.should == 1
       results['table1'].should include({:name => 'Josh', :id => '1'})
       results['table1'].should include({:name => 'Justin', :id => '2'})
     end
-    
+
     it 'performs BatchGetItem with range keys' do
-      Dynamoid::Adapter.create_table('table1', :id, :range_key => :range)
+      Dynamoid::Adapter.create_table('table1', :id, :range_key => { :range => :string })
       Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 1.0})
       Dynamoid::Adapter.put_item('table1', {:id => '2', :range => 2.0})
-    
+
       results = Dynamoid::Adapter.batch_get_item('table1' => [['1', 1.0], ['2', 2.0]])
       results.size.should == 1
       results['table1'].should include({:id => '1', :range => 1.0})
       results['table1'].should include({:id => '2', :range => 2.0})
     end
-    
+
     it 'performs BatchGetItem with range keys on one primary key' do
-      Dynamoid::Adapter.create_table('table1', :id, :range_key => :range)
+      Dynamoid::Adapter.create_table('table1', :id, :range_key => { :range => :string })
       Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 1.0})
       Dynamoid::Adapter.put_item('table1', {:id => '1', :range => 2.0})
-    
+
       results = Dynamoid::Adapter.batch_get_item('table1' => [['1', 1.0], ['1', 2.0]])
       results.size.should == 1
       results['table1'].should include({:id => '1', :range => 1.0})
       results['table1'].should include({:id => '1', :range => 2.0})
     end
-  
+
     # CreateTable
     it 'performs CreateTable' do
       Dynamoid::Adapter.create_table('Test Table', :id)
-    
+
       Dynamoid::Adapter.list_tables.should include 'Test Table'
     end
-  
+
     # DeleteItem
     it 'performs DeleteItem' do
       Dynamoid::Adapter.create_table('table1', :id)
       Dynamoid::Adapter.put_item('table1', {:id => '1', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.delete_item('table1', '1')
-    
+
       Dynamoid::Adapter.data['table1'][:data].should be_empty
     end
-  
+
     it 'performs DeleteItem for an item that does not exist' do
       Dynamoid::Adapter.create_table('table1', :id)
-    
+
       Dynamoid::Adapter.delete_item('table1', '1')
-    
+
       Dynamoid::Adapter.data['table1'][:data].should be_empty
     end
-  
+
     # DeleteTable
     it 'performs DeleteTable' do
       Dynamoid::Adapter.create_table('table1', :id)
-    
+
       Dynamoid::Adapter.delete_table('table1')
-    
+
       Dynamoid::Adapter.data['table1'].should be_nil
     end
-  
+
     # DescribeTable
-  
+
     # GetItem
     it "performs GetItem for an item that does not exist" do
       Dynamoid::Adapter.create_table('Test Table', :id)
-    
+
       Dynamoid::Adapter.get_item('Test Table', '1').should be_nil
     end
-  
+
     it "performs GetItem for an item that does exist" do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.get_item('Test Table', '1').should == {:id => '1', :name => 'Josh'}
     end
-    
+
     it "performs GetItem for an item with a range key" do
-      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key =>  { :range => :number })
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 1.0})
-      
+
       Dynamoid::Adapter.get_item('Test Table', '1').should be_nil
-      Dynamoid::Adapter.get_item('Test Table', '1', 1.0).should == {:id => '1', :range => 1.0}
+      Dynamoid::Adapter.get_item('Test Table', '1', :range_key => 1.0).should == {:id => '1', :range => 1.0}
     end
-  
+
     # ListTables
     it 'performs ListTables' do
       Dynamoid::Adapter.create_table('Table1', :id)
       Dynamoid::Adapter.create_table('Table2', :id)
-    
+
       Dynamoid::Adapter.list_tables.should include 'Table1'
       Dynamoid::Adapter.list_tables.should include 'Table2'
     end
-  
+
     # PutItem
     it 'performs PutItem for an item that does not exist' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>nil, :data=>{"1."=>{:id=>"1", :name=>"Josh"}}}
     end
-    
+
     it 'puts an item twice and overwrites an existing item' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin'})
-    
-      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>nil, :data=>{"1."=>{:id=>"1", :name=>"Justin"}}}      
+
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>nil, :data=>{"1."=>{:id=>"1", :name=>"Justin"}}}
     end
-    
+
     it 'puts an item twice and does not overwrite an existing item if the range key is not the same' do
-      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key =>  { :range => :number })
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 1.0})
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 2.0})
-    
+
       Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>:range, :data=>{"1.1.0"=>{:id=>"1", :name=>"Justin", :range => 1.0}, "1.2.0" => {:id=>"1", :name=>"Justin", :range => 2.0}}}
     end
-    
+
     it 'puts an item twice and does overwrite an existing item if the range key is the same' do
-      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+      Dynamoid::Adapter.create_table('Test Table', :id, :range_key => { :range => :number })
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh', :range => 1.0})
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Justin', :range => 1.0})
-    
-      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>:range, :data=>{"1.1.0"=>{:id=>"1", :name=>"Justin", :range => 1.0}}}      
+
+      Dynamoid::Adapter.data['Test Table'].should == {:hash_key=>:id, :range_key=>:range, :data=>{"1.1.0"=>{:id=>"1", :name=>"Justin", :range => 1.0}}}
     end
-    
-  
+
+
     # Query
     it 'performs query on a table and returns items' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
-    
-      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+
+      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == [{ :id=> '1', :name=>"Josh" }]
     end
-  
+
     it 'performs query on a table and returns items if there are multiple items' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Justin'})
-    
-      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
+
+      Dynamoid::Adapter.query('Test Table', :hash_value => '1').should == [{ :id=> '1', :name=>"Josh" }]
     end
-    
+
     context 'range queries' do
       before do
-        Dynamoid::Adapter.create_table('Test Table', :id, :range_key => :range)
+        Dynamoid::Adapter.create_table('Test Table', :id, :range_key => { :range => :number })
         Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 1.0})
-        Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 2.0})        
+        Dynamoid::Adapter.put_item('Test Table', {:id => '1', :range => 2.0})
       end
-      
-      it 'performs query on a table with a range and selects items in a range' do      
+
+      it 'performs query on a table with a range and selects items in a range' do
         Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
       end
-      
-      it 'performs query on a table with a range and selects items greater than' do      
+
+      it 'performs query on a table with a range and selects items greater than' do
         Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => 2.0}]
       end
-      
-      it 'performs query on a table with a range and selects items less than' do      
+
+      it 'performs query on a table with a range and selects items less than' do
         Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => 1.0}]
       end
-      
-      it 'performs query on a table with a range and selects items gte' do      
+
+      it 'performs query on a table with a range and selects items gte' do
         Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
       end
-      
-      it 'performs query on a table with a range and selects items lte' do      
+
+      it 'performs query on a table with a range and selects items lte' do
         Dynamoid::Adapter.query('Test Table', :hash_value => '1', :range_lte => 2.0).should =~ [{:id => '1', :range => 1.0}, {:id => '1', :range => 2.0}]
       end
-      
+
     end
-      
+
     # Scan
     it 'performs scan on a table and returns items' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.scan('Test Table', :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.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Justin'})
-    
+
       Dynamoid::Adapter.scan('Test Table', :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.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.scan('Test Table', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }, { :id=> '2', :name=>"Josh" }]
     end
-    
+
     it 'performs scan on a table and returns all items if no criteria are specified' do
       Dynamoid::Adapter.create_table('Test Table', :id)
       Dynamoid::Adapter.put_item('Test Table', {:id => '1', :name => 'Josh'})
       Dynamoid::Adapter.put_item('Test Table', {:id => '2', :name => 'Josh'})
-    
+
       Dynamoid::Adapter.scan('Test Table', {}).should == [{ :id=> '1', :name=>"Josh" }, { :id=> '2', :name=>"Josh" }]
     end
-  
+
     # UpdateItem
-  
+
     # UpdateTable
-  
+
     protected
-  
+
     def setup_value(table, key, value)
       Dynamoid::Adapter.data[table][key] = value
     end
-    
+
   end
 end