dynamosaurus 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61f38932ba6096baa0ae0952bb548637b2829640
-  data.tar.gz: dc8455607eaad41f4c7ad2f1a8657c0f8b9770c0
+  metadata.gz: cf094775fd40a2513f250d77db7be0d6797f7134
+  data.tar.gz: 58be5bbc575faf23d73e70a60f0c778ca81859f4
 SHA512:
-  metadata.gz: 981993c41a99915f41d1b610d19cba3af6ccb944b8f255bea5ce3965ad190a38d96aa8f4b5ba5b730f6225fa8c8dd4b6a76703d24b40f87d866bb266f5a367af
-  data.tar.gz: 839c4eaa14d3adc3bf7d406cf8791284e5c66950313c2b25d794b8b8f0ea0275233f76e2c75a3e88def82a4f206558d17fc77b7c47a58a027ac94ecf07950c12
+  metadata.gz: e04ff2346be1beacadcd04505b7ab1d8d98d5a46b1a06e1c2d748715a7da15f90943dbaa5547b00bef6ef4587acb6b8ed2eb56ae46a091bc40d735fdf6c1e702
+  data.tar.gz: a99e63225e2772ca1320f1fccca2a1a882e13e6bcaa1834f8b5b4421607f7e27d749e7f5ec44f71d32771d6367bb943e0d5d1460fb6dd9c58ecc179aa6eb59a8

data/lib/dynamosaurus/dynamo_class.rb

@@ -55,102 +55,156 @@ module Dynamosaurus
         @table ||= options
       end
 
-      def key k, type, range_key=nil, range_key_type=nil
+      def key k, type, range_key_name=nil, range_key_type=nil
         @key = [k, Dynamosaurus::DynamoBase::TYPES[type]]
-        @key << range_key << Dynamosaurus::DynamoBase::TYPES[range_key_type] if range_key
+        @key << range_key_name << Dynamosaurus::DynamoBase::TYPES[range_key_type] if range_key_name
       end
 
       def get_key
        @key
       end
 
-      def schema
-        @schema = {}
-        @schema[:table_name] = table_name
-        @schema[:key_schema] = []
-        @schema[:attribute_definitions] = []
-
-        @schema[:provisioned_throughput] = {
-          :read_capacity_units => 10,
-          :write_capacity_units => 10
-        }
-
-        @schema[:key_schema]  << {
-          :key_type => "HASH",
-          :attribute_name => get_key[0].to_s
-        }
-        @schema[:attribute_definitions] << {:attribute_name => get_key[0].to_s, :attribute_type => get_key[1].to_s.upcase}
+      def has_renge
+        @key.size == 4
+      end
 
-        if get_key.size == 4
-          @schema[:key_schema]  << {
-            :key_type => "RANGE",
-            :attribute_name => get_key[2].to_s
-          }
-          @schema[:attribute_definitions] << {:attribute_name => get_key[2].to_s, :attribute_type => get_key[3].to_s.upcase}
-        end
+      def hash_key
+        @key[0]
+      end
 
-        unless get_global_indexes.empty?
-          @schema[:global_secondary_indexes] = []
-          get_global_indexes.each do |g_index|
-            index_schema = {
-              :index_name => g_index[0],
-              :key_schema => [],
-              :projection => {
-                :projection_type => "KEYS_ONLY",
-              },
-              :provisioned_throughput => {
-                :read_capacity_units => 10,
-                :write_capacity_units => 10
-              },
-            }
-            index_schema[:key_schema] << {
-              :key_type => "HASH",
-              :attribute_name => g_index[1][0]
-            }
-            @schema[:attribute_definitions] << {:attribute_name => g_index[1][0].to_s, :attribute_type => g_index[1][1].to_s.upcase}
-            if g_index[1].size == 4
-              index_schema[:key_schema] << {
-                :key_type => "RANGE",
-                :attribute_name => g_index[1][2]
-              }
-              @schema[:attribute_definitions] << {:attribute_name => g_index[1][2].to_s, :attribute_type => g_index[1][3].to_s.upcase}
-            end
+      def range_key
+        @key[2]
+      end
 
-            @schema[:global_secondary_indexes] << index_schema
-          end
+      def key_schema
+        key = [{
+          :key_type => "HASH",
+          :attribute_name => hash_key.to_s
+        }]
+        key << {
+          :key_type => "RANGE",
+          :attribute_name => range_key.to_s
+        } if has_renge
+        key
+      end
+
+      # schema
+      def push_attribute_definitions name, type
+        if @attribute_definitions.nil?
+          @attribute_definitions = []
+          @attribute_names = []
         end
-        unless get_secondary_indexes.empty?
-          @schema[:local_secondary_indexes] = []
-          get_secondary_indexes.each do |s_index_key, s_index_value|
-            index_schema = {
-              :index_name => s_index_key,
-              :key_schema => [],
-              :projection => {
-                :projection_type => "KEYS_ONLY",
-              },
-            }
-            index_schema[:key_schema] =[
+        if @attribute_names.index(name).nil?
+          @attribute_definitions << {:attribute_name => name, :attribute_type => type}
+          @attribute_names << name
+        end
+      end
+      def set_init_attribute_definitions
+        push_attribute_definitions(hash_key.to_s,  get_key[1].to_s.upcase)
+        push_attribute_definitions(range_key.to_s, get_key[3].to_s.upcase) if has_renge
+      end
+      def attribute_definitions
+        @attribute_definitions
+      end
+
+      def local_secondary_schemas
+        schema = []
+        get_secondary_indexes.each do |index_key, index_value|
+          schema << {
+            index_name: index_key,
+            key_schema: [],
+            projection: {
+              projection_type: "KEYS_ONLY",
+            },
+            key_schema: [
               {
-                :key_type => "HASH",
-                :attribute_name => s_index_value[0]
+                key_type: "HASH",
+                attribute_name: index_value[0]
               },
               {
-                :key_type => "RANGE",
-                :attribute_name => s_index_value[2]
+                key_type: "RANGE",
+                attribute_name: index_value[2]
               }
             ]
-            @schema[:attribute_definitions] << {:attribute_name => s_index_value[2].to_s, :attribute_type => s_index_value[3].to_s.upcase}
-            @schema[:local_secondary_indexes] << index_schema
-          end
+          }
+        end
+        schema
+      end
+
+      def global_index_schemas
+        schema = []
+        get_global_indexes.each do |index|
+          schema << {
+            :index_name => index[0],
+            :key_schema => global_index_key_schema(index),
+            :projection => {
+              :projection_type => "KEYS_ONLY",
+            },
+            :provisioned_throughput => {
+              :read_capacity_units => 10,
+              :write_capacity_units => 10
+            }
+          }
+        end
+        schema
+      end
+
+      def global_index_key_schema index
+        key_schema = [{
+          :key_type => "HASH",
+          :attribute_name => index[1][0]
+        }]
+        key_schema << {
+              :key_type => "RANGE",
+              :attribute_name => index[1][2]
+            } if index[1].size == 4
+        key_schema
+      end
+
+      def local_secondary_attribute_definitions
+        get_secondary_indexes.each do |index_key, index_value|
+          push_attribute_definitions(index_value[2].to_s, index_value[3].to_s.upcase)
         end
+      end
+
+      def global_indexes_attribute_definitions
+        get_global_indexes.each do |index|
+          push_attribute_definitions(index[1][0].to_s, index[1][1].to_s.upcase)
+          push_attribute_definitions(index[1][2].to_s, index[1][3].to_s.upcase) if index[1].size == 4
+        end
+      end
+
+      def schema
+        set_init_attribute_definitions
+
+        @schema = {
+          table_name: table_name,
+          key_schema: key_schema,
+          provisioned_throughput: {
+            read_capacity_units: 10,
+            write_capacity_units: 10
+          }
+        }
+
+        unless get_global_indexes.empty?
+          @schema[:global_secondary_indexes] = global_index_schemas
+          global_indexes_attribute_definitions
+        end
+        unless get_secondary_indexes.empty?
+          @schema[:local_secondary_indexes] = local_secondary_schemas
+          local_secondary_attribute_definitions
+        end
+        @schema[:attribute_definitions] = attribute_definitions
 
         @schema
       end
+      # end of schema
 
-      def global_index index_name, key, key_type, range_key=nil, range_key_type=nil
+      # indexes
+      def global_index index_name, key, key_type, range_key_name=nil, range_key_type=nil
         @global_index = {} if @global_index.nil?
         @global_index[index_name] = [key, Dynamosaurus::DynamoBase::TYPES[key_type]]
-        @global_index[index_name] << range_key <<  Dynamosaurus::DynamoBase::TYPES[range_key_type] if range_key
+        @global_index[index_name] << range_key_name <<  Dynamosaurus::DynamoBase::TYPES[range_key_type] if range_key_name
       end
 
       def get_global_indexes
@@ -161,9 +215,9 @@ module Dynamosaurus
         @global_index[name]
       end
 
-      def secondary_index index_name, range_key=nil, range_key_type=nil
+      def secondary_index index_name, range_key_name=nil, range_key_type=nil
         @secondary_index = {} if @secondary_index.nil?
-        @secondary_index[index_name.to_sym] = [@key[0], @key[1], range_key, Dynamosaurus::DynamoBase::TYPES[range_key_type]] if range_key
+        @secondary_index[index_name.to_sym] = [@key[0], @key[1], range_key_name, Dynamosaurus::DynamoBase::TYPES[range_key_type]] if range_key_name
       end
 
       def get_secondary_indexes
@@ -193,28 +247,19 @@ module Dynamosaurus
         }
         nil
       end
+      # end of indexes
 
       def table_prefix name
         @table_prefix = name
       end
 
-      def key_list
-        keys = get_key + get_secondary_indexes.values.flatten
-        list = {}
-        until keys.empty?
-          convi = keys.shift(2)
-          list[convi[0]] = convi[1]
-        end
-        list
-      end
-
       def res2hash hash
         new_hash = {}
         return new_hash if hash.nil?
         hash
       end
 
-
+      # query
       def query_without_index value, option
         keys = {}
 
@@ -231,12 +276,12 @@ module Dynamosaurus
       def get_item_key value
         if value.is_a? Array
           {
-            get_key[0] => value[0].to_s,
-            get_key[2] => value[1].to_s,
+            hash_key => value[0].to_s,
+            range_key => value[1].to_s,
           }
         else
           {
-            get_key[0] => value.to_s,
+            hash_key => value.to_s,
           }
         end
       end
@@ -308,6 +353,7 @@ module Dynamosaurus
           end
         end
       end
+      # end of query
 
       # public method
       def get value, option={}
@@ -334,27 +380,59 @@ module Dynamosaurus
         end
       end
 
-      def batch_get_item keys
-        return nil if keys.nil? or keys.empty?
-        Dynamosaurus.logger << "batch_get_item #{table_name} #{keys}"
-        if get_key.size == 2
-          my_keys = keys.map{|_key| {get_key[0].to_s => _key.to_s } }
+      def get_orderd_key_from_hash hash
+        get_orderd_key( (hash[hash_key.to_sym] || hash[hash_key.to_s]),
+                       (hash[range_key.to_sym] || hash[range_key.to_s]))
+      end
+
+      def get_orderd_key_from_array array
+        get_orderd_key(array[0], array[1])
+      end
+
+      def get_orderd_key value1, value2
+        {
+          hash_key.to_s => value1,
+            range_key.to_s => value2
+        }
+      end
+
+      def conv_key_array keys
+        unless has_renge
+          keys.map{|_key| {hash_key.to_s => _key.to_s } }
         else
-          my_keys = []
-          keys[get_key[0]].each do |key1|
-            keys[get_key[2]].each do |key2|
-              my_keys << {
-                get_key[0].to_s => key1,
-                get_key[2].to_s => key2,
-              }
+          if keys.is_a?(Array)
+            if keys[0].is_a?(Array)
+              keys.map{|key| get_orderd_key_from_array(key)}
+            elsif keys[0].is_a?(Hash)
+              keys.map{|key| get_orderd_key_from_hash(key)}
+            else
+              [get_orderd_key_from_array(keys)]
+            end
+          else
+            _keys = []
+            ((p_key = keys[hash_key]).is_a?(Array) ? p_key : [p_key]).each do |key1|
+              if (r_key = keys[range_key]).is_a?(Array)
+                r_key.each do |key2|
+                  _keys << get_orderd_key(key1, key2)
+                end
+              else
+                _keys << get_orderd_key(key1, r_key)
+              end
             end
+            _keys
           end
         end
+      end
+
+      def batch_get_item keys
+        return nil if keys.nil? or keys.empty?
+        Dynamosaurus.logger << "batch_get_item #{table_name} #{keys}"
+        _keys = conv_key_array(keys)
 
         res = dynamo_db.batch_get_item(
           :request_items => {
             table_name => {
-              :keys => my_keys
+              :keys => _keys
             }
           })
 
@@ -392,7 +470,16 @@ module Dynamosaurus
       end
 
       def put hash, num_hash={}, return_values=nil
+        new_hash = put_data(hash, num_hash)
 
+        res = dynamo_db.put_item(
+          :table_name => table_name,
+          :item => new_hash,
+          :return_values => return_values || "NONE"
+        )
+      end
+
+      def put_data hash, num_hash={}
         new_hash = {}
         hash.each{|key, value|
           new_hash[key] = value unless value.nil?
@@ -400,22 +487,55 @@ module Dynamosaurus
         num_hash.merge({:updated_at => Time.now.to_i}).each{|key, value|
           new_hash[key] = value.to_i unless value.nil?
         } if num_hash
+        new_hash
+      end
 
-        res = dynamo_db.put_item(
-          :table_name => table_name,
-          :item => new_hash,
-          :return_values => return_values || "NONE"
+      def batch_write_item put_items = [], delete_items = []
+        return nil if (put_items.nil? or put_items.empty?) and (delete_items.nil? or delete_items.empty?)
+        Dynamosaurus.logger << "batch_write_item #{table_name}"
+
+        requests = []
+        if put_items and put_items.size > 0
+          put_items.each do |item|
+            if item["hash"] or item["num_hash"]
+              new_item = put_data(item["hash"], item["num_hash"])
+            else
+              new_item = item.merge({:updated_at => Time.now.to_i})
+            end
+            requests << {
+              put_request: {
+                item: new_item
+              }
+            }
+          end
+        end
+
+        if delete_items and delete_items.size > 0
+          conv_key_array(delete_items).map{|key|
+            requests << {
+              delete_request: {
+                key: key
+              }
+            }
+          }
+        end
+
+        res = dynamo_db.batch_write_item(
+          request_items: {
+            table_name => requests
+          },
+          return_consumed_capacity: "TOTAL"
         )
+        res
       end
 
       def save hash, num_hash={}, return_values=nil
         put(hash, num_hash, return_values)
-        my_keys = get_key
 
-        if my_keys.size == 4
-          get([hash[my_keys[0]], hash[my_keys[2]]])
+        if has_renge
+          get([hash[hash_key], hash[range_key]])
         else
-          get(hash[my_keys[0]])
+          get(hash[hash_key])
         end
       end
 
@@ -430,11 +550,10 @@ module Dynamosaurus
           }
         end
 
-        class_key = get_key
         keys = {
-          class_key[0].to_sym => key.is_a?(Array) ? key[0] : key
+          hash_key.to_sym => key.is_a?(Array) ? key[0] : key
         }
-        keys[class_key[2].to_sym] = key[1]  if class_key.size > 2
+        keys[range_key.to_sym] = key[1]  if has_renge
 
         query ={
           :table_name => table_name,

data/lib/dynamosaurus/version.rb

@@ -1,3 +1,3 @@
 module Dynamosaurus
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/spec/dynamo_class_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Dynamosaurus::DynamoBase do
+  before(:all) do
+    ENV['DYNAMODB_SUFFIX'] = "_local"
+
+    Aws.config = {
+      :endpoint => "http://localhost:8000",
+      :region => 'local_test',
+    }
+    Dynamosaurus::DynamoBase.create_tables
+  end
+
+  after(:all) do
+    connect = Dynamosaurus::DynamoBase.dynamo_db
+    Dynamosaurus::DynamoBase.tables.each do |table_name|
+      connect.delete_table(:table_name => table_name)
+    end
+  end
+
+  it 'simple ordered kvs test' do
+    expect(Dynamosaurus::DynamoBase.all_models).to match_array [Like, DynamoModelWithoutTableField, DynamoModelWithTableField, Comment, SimpleOrderedKVS, SimpleKVS]
+    expect(Dynamosaurus::DynamoBase.tables).to match_array  ["comment_local", "dynamomodelwithouttablefield_local", "like_local", "simplekvs_local", "simpleorderedkvs_local", "table_name"]
+
+    expect(SimpleOrderedKVS.table_name).to match "simpleorderedkvs_local"
+    expect(SimpleOrderedKVS.get_key).to match_array [:simple_key, :s, :simple_id, :s]
+
+    expect(SimpleOrderedKVS.schema).to match_array [
+      [ :attribute_definitions, [
+        {:attribute_name=>"simple_key", :attribute_type=>"S"},
+        {:attribute_name=>"simple_id", :attribute_type=>"S"},
+        {:attribute_name=>"updated_at", :attribute_type=>"N"}
+      ]],
+      [ :key_schema, [
+        {:key_type=>"HASH", :attribute_name=>"simple_key"}, {:key_type=>"RANGE", :attribute_name=>"simple_id"}
+      ]],
+      [ :local_secondary_indexes, [
+        { :index_name=>:updated_at_index,
+          :key_schema=>[ {:key_type=>"HASH", :attribute_name=>:simple_key}, {:key_type=>"RANGE", :attribute_name=>:updated_at}],
+          :projection=>{:projection_type=>"KEYS_ONLY"}}
+      ]],
+      [:provisioned_throughput, {:read_capacity_units=>10, :write_capacity_units=>10}], [:table_name, "simpleorderedkvs_local"]
+    ]
+    expect(SimpleOrderedKVS.get_global_indexes).to match({})
+    expect(SimpleOrderedKVS.get_secondary_indexes).to match({:updated_at_index=>[:simple_key, :s, :updated_at, :n]})
+    expect(SimpleOrderedKVS.get_indexes).to match({:updated_at_index=>[:simple_key, :s, :updated_at, :n]})
+
+
+    expect(SimpleKVS.schema).to match_array [
+      [:attribute_definitions, [
+        {:attribute_name=>"simple_key", :attribute_type=>"S"}]
+      ],
+      [:key_schema, [
+        {:key_type=>"HASH", :attribute_name=>"simple_key"}
+      ]],
+      [:provisioned_throughput, {:read_capacity_units=>10, :write_capacity_units=>10}], [:table_name, "simplekvs_local"]
+    ]
+
+    expect(Comment.schema).to match_array  [[:attribute_definitions, [{:attribute_name=>"content_id", :attribute_type=>"S"}, {:attribute_name=>"message_id", :attribute_type=>"S"}, {:attribute_name=>"user_id", :attribute_type=>"S"}]], [:global_secondary_indexes, [{:index_name=>:user_index, :key_schema=>[{:key_type=>"HASH", :attribute_name=>:user_id}], :projection=>{:projection_type=>"KEYS_ONLY"}, :provisioned_throughput=>{:read_capacity_units=>10, :write_capacity_units=>10}}]], [:key_schema, [{:key_type=>"HASH", :attribute_name=>"content_id"}, {:key_type=>"RANGE", :attribute_name=>"message_id"}]], [:provisioned_throughput, {:read_capacity_units=>10, :write_capacity_units=>10}], [:table_name, "comment_local"]]
+
+  end
+end

data/spec/dynamosaurus_spec.rb

@@ -55,12 +55,22 @@ describe Dynamosaurus do
 
 
     batch_items = SimpleOrderedKVS.batch_get_item({:simple_key => ["key"], :simple_id => ["1", "2", "3"]})
-    expect(orderd_items.size).to eq 3
+    expect(batch_items.size).to eq 3
 
     kvs = SimpleOrderedKVS.first
     kvs2 = SimpleOrderedKVS.get({:simple_key => kvs.simple_key, :updated_at => kvs.updated_at})
     expect(kvs.simple_id).to eq kvs2[0].simple_id
 
+    put_items = [{simple_key: "key", simple_id: "a"}, {simple_key: "key", simple_id: "b"}]
+    delete_keys = {simple_key: ["key"], simple_id: ["1", "2"]}
+    batch_put_items = SimpleOrderedKVS.batch_write_item(put_items, delete_keys)
+
+    batch_items = SimpleOrderedKVS.batch_get_item({:simple_key => ["key"], :simple_id => ["a", "b", "c"]})
+    expect(batch_items.size).to eq 2
+
+    batch_items = SimpleOrderedKVS.batch_get_item({:simple_key => ["key"], :simple_id => ["1", "2", "3"]})
+    expect(batch_items.size).to eq 1
+
   end
 
   it 'simple kvs test' do
@@ -102,6 +112,7 @@ describe Dynamosaurus do
     kvs.num = 100
     kvs.save
 
+
     kvs = SimpleKVS.first
     expect(kvs.num).to eq 100
 
@@ -124,6 +135,45 @@ describe Dynamosaurus do
     kvs = SimpleKVS.get("key3")
     expect(kvs).to be_nil
 
+    res = SimpleKVS.save({:simple_key => "key4"}, {:num => 3})
+    expect(res.simple_key).to eq "key4"
+    expect(res.num).to eq 3
+  end
+
+  it 'internel method test' do
+    conv_keys = SimpleOrderedKVS.conv_key_array({:simple_key => ["key1", "key2"], :simple_id => ["1", "2", "3"]})
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}, {"simple_key"=>"key1", "simple_id"=>"2"}, {"simple_key"=>"key1", "simple_id"=>"3"},
+      {"simple_key"=>"key2", "simple_id"=>"1"}, {"simple_key"=>"key2", "simple_id"=>"2"}, {"simple_key"=>"key2", "simple_id"=>"3"}
+    ]
+
+    conv_keys = SimpleOrderedKVS.conv_key_array({:simple_key => "key", :simple_id => ["1", "2", "3"]})
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key", "simple_id"=>"1"}, {"simple_key"=>"key", "simple_id"=>"2"}, {"simple_key"=>"key", "simple_id"=>"3"}
+    ]
+
+    conv_keys = SimpleOrderedKVS.conv_key_array({:simple_key => ["key1","key2"], :simple_id => "1"})
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}, {"simple_key"=>"key2", "simple_id"=>"1"}
+    ]
+
+    conv_keys = SimpleOrderedKVS.conv_key_array({:simple_key => "key1", :simple_id => "1"})
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}
+    ]
+
+    conv_keys = SimpleOrderedKVS.conv_key_array([{:simple_key => "key1", :simple_id => "1"}, {:simple_key => "key1", :simple_id => "2"}])
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}, {"simple_key"=>"key1", "simple_id"=>"2"}
+    ]
+    conv_keys = SimpleOrderedKVS.conv_key_array(["key1", "1"])
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}
+    ]
+    conv_keys = SimpleOrderedKVS.conv_key_array([["key1", "1"], ["key1", "2"]])
+    expect(conv_keys).to eq [
+      {"simple_key"=>"key1", "simple_id"=>"1"}, {"simple_key"=>"key1", "simple_id"=>"2"}
+    ]
   end
 
   shared_examples_for 'Basic CRUD' do
@@ -161,11 +211,6 @@ describe Dynamosaurus do
 
   describe 'table options' do
     context 'when table-name is given' do
-      class DynamoModelWithTableField < Dynamosaurus::DynamoBase
-        table name: 'table_name'
-        key :content_id, :string, :message_id, :string
-      end
-
       it_should_behave_like 'Basic CRUD' do
         let!(:model_name) { 'DynamoModelWithTableField' }
       end
@@ -174,10 +219,6 @@ describe Dynamosaurus do
     end
 
     context 'when table-name is not given' do
-      class DynamoModelWithoutTableField < Dynamosaurus::DynamoBase
-        key :content_id, :string, :message_id, :string
-      end
-
       it_should_behave_like 'Basic CRUD' do
         let!(:model_name) { 'DynamoModelWithoutTableField' }
       end

data/spec/testmodel.rb

@@ -13,3 +13,17 @@ class Comment < Dynamosaurus::DynamoBase
   key :content_id, :string, :message_id, :string
   global_index :user_index, :user_id, :string
 end
+
+class DynamoModelWithTableField < Dynamosaurus::DynamoBase
+  table name: 'table_name'
+  key :content_id, :string, :message_id, :string
+end
+
+class DynamoModelWithoutTableField < Dynamosaurus::DynamoBase
+  key :content_id, :string, :message_id, :string
+end
+
+class Like < Dynamosaurus::DynamoBase
+  key :object_id, :string, :user_id, :string
+  global_index :user_index, :user_id, :string
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamosaurus
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Isamu Arimoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,6 +87,7 @@ files:
 - lib/dynamosaurus/dynamo_class.rb
 - lib/dynamosaurus/logger.rb
 - lib/dynamosaurus/version.rb
+- spec/dynamo_class_spec.rb
 - spec/dynamosaurus_spec.rb
 - spec/spec_helper.rb
 - spec/testmodel.rb
@@ -115,6 +116,7 @@ signing_key:
 specification_version: 4
 summary: Dynamodb simple ORM
 test_files:
+- spec/dynamo_class_spec.rb
 - spec/dynamosaurus_spec.rb
 - spec/spec_helper.rb
 - spec/testmodel.rb