dymos 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 408c57bc4b5bc1b6a83e14f53cb1e69071e885b0
-  data.tar.gz: eaf61ec14a52d888980e478d45aa91180bdd0536
+  metadata.gz: 7c0c0a46aa4fd1522baccf359d95557969ef7b84
+  data.tar.gz: ce4dddfca46a0a4531633111ff41221821307972
 SHA512:
-  metadata.gz: bd4d7dbab18afeba617102abe889732658458aac36b119b5c5f5d7c5b5a0288d44040f27ca437dbfdf079610e3e719280dcdee59f16c3a490cdc374c704382a9
-  data.tar.gz: b4f0eafab6f9c8346c2d986a189f7038b5cc8f67534289eebb1aa1a1ea45cef7d47b8178529ce8b54ae491195fdc794d17d62ecd3c81240547a4ae31fe883bf0
+  metadata.gz: 51158e3ba9bbe24135f76217f825fa11282bfce214f993ed2a92a1b01de54ed0d554137add7b387658dfd287e2dba741dde117a3528fb59012756d17adef4807
+  data.tar.gz: 4c654ea7370834f50eff5f83e7562ec77ba68d595a8fa0d26b6cd30898d5c674974f5ff863a45351a58e9d47504dfefef98f8f84709c0dbd7d687fe9aaa33e59

data/.gitignore

@@ -13,4 +13,5 @@
 *.a
 mkmf.log
 .idea/
-/vendor/bundle
+/vendor/bundle
+.ruby-version

data/.rspec

@@ -1,3 +1,2 @@
 --color
---warnings
 --require spec_helper

data/.travis.yml

@@ -1,8 +1,9 @@
 language: ruby
 cache: bundler
-before_script: 'bundle exec fake_dynamo -d .fake_dynamo.db -P .fake_dynamo.pid -D'
-script: 'bundle exec rake'
-after_script: 'kill `cat .fake_dynamo.pid`'
+before_install:
+  - wget http://dynamodb-local.s3-website-us-west-2.amazonaws.com/dynamodb_local_latest
+  - tar xfz dynamodb_local_latest
+  - java -Djava.library.path=./DynamoDBLocal_lib -jar DynamoDBLocal.jar -inMemory -port 4567 &
 rvm:
   - 2.1.0
   - 2.1.1

data/Rakefile

@@ -1,13 +1,7 @@
-# -*- encoding: utf-8 -*-
-require "bundler/gem_tasks" 
-require 'rubygems'
-require 'rake'
-$:.unshift  File.join(File.dirname(__FILE__), "lib")
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
 
-require 'rspec/core'
+# RSpec
 require 'rspec/core/rake_task'
-
-task :default => :spec
-
-desc "Run all specs in spec directory"
 RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/dymos.rb

@@ -1,8 +1,14 @@
+require "dymos/query/attribute"
+require "dymos/query/expect"
+require "dymos/query/builder"
+require "dymos/query/put_item"
+require "dymos/query/update_item"
+require "dymos/query/get_item"
+require "dymos/query/query"
+require "dymos/attribute"
+require "dymos/command"
 require "dymos/model"
 require "dymos/version"
 
 module Dymos
-  def self.model
-    Dymos::Model
-  end
 end

data/lib/dymos/attribute.rb

@@ -1,5 +1,4 @@
 module Dymos
   module Attribute
-
   end
 end

data/lib/dymos/command.rb

@@ -0,0 +1,32 @@
+module Dymos
+  module Command
+
+    # @return [PutItem]
+    def put
+      Dymos::Query::PutItem.new(:put_item, table_name, class_name)
+    end
+
+    # @return [UpdateItem]
+    def update
+      Dymos::Query::UpdateItem.new(:update_item, table_name, class_name)
+    end
+
+    # @return [GetItem]
+    def get
+      Dymos::Query::GetItem.new(:get_item, table_name, class_name)
+    end
+
+    # @return [Query]
+    def query
+      Dymos::Query::Query.new(:query, table_name, class_name)
+    end
+
+    def scan
+
+    end
+
+    def describe
+
+    end
+  end
+end

data/lib/dymos/model.rb

@@ -4,6 +4,7 @@ require 'active_model'
 module Dymos
   class Model
     include ActiveModel::Model
+    extend Dymos::Command
 
     def initialize(params={})
       @attributes = {}
@@ -18,6 +19,7 @@ module Dymos
     end
 
     def self.table(name)
+      define_singleton_method('table_name') { name }
       define_method('table_name') { name }
     end
 
@@ -89,10 +91,15 @@ module Dymos
     end
 
     def dynamo
-
       @client ||= Aws::DynamoDB::Client.new
     end
 
+    # @return [String]
+    def self.class_name
+      self.name
+    end
+
+    # @return [String]
     def class_name
       self.class.name
     end

data/lib/dymos/query/attribute.rb

@@ -0,0 +1,14 @@
+module Dymos
+  module Query
+    class Attribute
+      def initialize(value)
+        value =value.to_i if /^[0-9]+$/ =~ value
+        @value = value
+      end
+
+      def data
+        @value
+      end
+    end
+  end
+end

data/lib/dymos/query/builder.rb

@@ -0,0 +1,43 @@
+module Dymos
+  module Query
+    class Builder
+      attr_accessor :table_name, :command, :query
+
+      def initialize(command, table_name=nil, class_name=nil)
+        @class_name = class_name
+        @command = command
+        @table_name = table_name if table_name.present?
+        self
+      end
+
+      def query
+
+      end
+
+      def execute(client)
+        begin
+          res = client.send command, query
+        rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
+          return false
+        end
+        if @class_name.present?
+          if res.data.respond_to? :items
+            res.data[:items].map do |datum|
+              obj = Object.const_get(@class_name).new
+              obj.attributes = datum
+              obj
+            end
+          elsif res.data.respond_to? :attributes
+            return nil if res.attributes.nil?
+            obj = Object.const_get(@class_name).new
+            obj.attributes = res.attributes
+            obj
+          end
+        else
+          res.data
+        end
+
+      end
+    end
+  end
+end

data/lib/dymos/query/expect.rb

@@ -0,0 +1,65 @@
+module Dymos
+  module Query
+    class Expect < Attribute
+      def initialize
+      end
+
+      def condition(operator, value)
+        if value.present?
+          value1, value2 = value.split(" ")
+          value1 =value1.to_i if /^[0-9]+$/.match(value1)
+          value2 =value2.to_i if /^[0-9]+$/.match(value2)
+          @value = value1
+        end
+
+        case operator.to_sym
+          when :==, :eq
+            @operator = 'EQ'
+          when :!=, :nq
+            @operator = 'NE'
+          when :<=, :le
+            @operator = 'LE'
+          when :<, :lt
+            @operator = 'LT'
+          when :>=, :ge
+            @operator = 'GE'
+          when :>, :gt
+            @operator = 'GT'
+          when :between
+            @operator = 'BETWEEN'
+            @value =[value1, value2]
+          when :is_null
+            @operator = 'NULL'
+          when :is_not_null
+            @operator = 'NOT_NULL'
+          when :contains
+            @operator = 'CONTAINS'
+          when :not_contains
+            @operator = 'NOT_CONTAINS'
+          when :begins_with
+            @operator = 'BEGINS_WITH'
+          else
+            raise ArgumentError, '%s is not defined ' % operator
+        end
+        self
+      end
+
+      def data(is_force_array=false)
+        value = super()
+        if is_force_array or value.is_a? Array
+          data = {
+              attribute_value_list: (is_force_array and !(value.is_a? Array)) ? [value] : value,
+              comparison_operator: @operator
+          }
+        else
+          data = {}
+          data[:value]= value if value.present?
+          data[:comparison_operator]= @operator
+        end
+
+        data[:exists] = true if @exists.present?
+        data
+      end
+    end
+  end
+end

data/lib/dymos/query/get_item.rb

@@ -0,0 +1,19 @@
+module Dymos
+  module Query
+    class GetItem < ::Dymos::Query::Builder
+
+      def key(params)
+        @key = params
+        self
+      end
+
+      def query
+        {
+            table_name: @table_name.to_s,
+            key: @key,
+            consistent_read: true,
+        }
+      end
+    end
+  end
+end

data/lib/dymos/query/put_item.rb

@@ -0,0 +1,48 @@
+module Dymos
+  module Query
+    class PutItem < ::Dymos::Query::Builder
+
+      def item(params)
+        @item = params
+        self
+      end
+
+      def expected(params)
+        @expected = Hash[params.map do |name, expression|
+          operator, values = expression.split(' ', 2)
+          if values.nil?
+            value1 = operator
+            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data]
+          else
+            value1, value2 = values.split(' ')
+            if value2.present?
+              [name, ::Dymos::Query::Expect.new.condition(operator, values).data]
+            else
+              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data]
+            end
+          end
+
+        end]
+        self
+      end
+
+      def query
+        data = {
+            table_name: @table_name.to_s,
+            item: @item,
+            return_values: @return_values || 'ALL_OLD',
+            # return_consumed_capacity: @return_consumed_capacity || 'TOTAL',
+            # return_item_collection_metrics: @return_item_collection_metrics || 'SIZE',
+        }
+
+        if @expected.present?
+          data[:expected] = @expected
+          if @expected.size > 1
+            data[:conditional_operator] = @conditional_operator || 'AND'
+          end
+        end
+        data
+      end
+    end
+  end
+end

data/lib/dymos/query/query.rb

@@ -0,0 +1,38 @@
+module Dymos
+  module Query
+    class Query < ::Dymos::Query::Builder
+
+      def key_conditions(params)
+        @key = Hash[params.map do |name, expression|
+          operator, values = expression.split(' ', 2)
+          if values.nil?
+            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data(true)]
+          else
+            value1, value2 = values.split(' ')
+            if value2.present?
+              [name, ::Dymos::Query::Expect.new.condition(operator, values).data(true)]
+            else
+              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data(true)]
+            end
+          end
+
+        end]
+        self
+      end
+
+      def index_name(name)
+        @index_name =name
+        self
+      end
+
+      def query
+        {
+            table_name: @table_name.to_s,
+            index_name: @index_name.to_s,
+            key_conditions: @key,
+            consistent_read: false
+        }
+      end
+    end
+  end
+end

data/lib/dymos/query/update_item.rb

@@ -0,0 +1,72 @@
+module Dymos
+  module Query
+    class UpdateItem < ::Dymos::Query::Builder
+
+      # @param [String] name
+      # @return [self]
+      def key(name)
+        @key = name
+        self
+      end
+
+      # @param [Hash] param
+      # @param [String] action
+      # @return [self]
+      def attribute_updates(param, action="put")
+        @attribute_updates||={}
+        param.each { |key, value|
+          @attribute_updates[key] = {
+              value: value,
+              action: action.upcase
+          }
+        }
+        self
+      end
+
+      # @param [Hash] params
+      # @return [self]
+      def expected(params)
+        @expected = Hash[params.map do |name, expression|
+          operator, values = expression.split(' ', 2)
+          if values.nil?
+            [name, ::Dymos::Query::Expect.new.condition(operator, nil).data]
+          else
+            value1, value2 = values.split(' ')
+            if value2.present?
+              [name, ::Dymos::Query::Expect.new.condition(operator, values).data]
+            else
+              [name, ::Dymos::Query::Expect.new.condition(operator, value1).data]
+            end
+          end
+
+        end]
+        self
+      end
+
+      # @param [String] value
+      # @return [self]
+      def return_values(value)
+        @return_values = value.upcase
+        self
+      end
+
+      # @return [Hash]
+      def query
+        data = {
+            table_name: @table_name.to_s,
+            key: @key,
+            attribute_updates: @attribute_updates,
+            return_values: @return_values || 'ALL_NEW',
+        }
+
+        if @expected.present?
+          data[:expected] = @expected
+          if @expected.size > 1
+            data[:conditional_operator] = @conditional_operator || 'AND'
+          end
+        end
+        data
+      end
+    end
+  end
+end

data/lib/dymos/version.rb

@@ -1,3 +1,3 @@
 module Dymos
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/lib/dymos/model_spec.rb

@@ -66,12 +66,6 @@ describe Dymos::Model do
 
 #  let(:model) { Dummy.new }
 
-  describe Dymos do
-    it "dymos.model" do
-      expect(Dymos::model.name).to eq('Dymos::Model')
-    end
-  end
-
   describe :new do
 
     describe :field do

data/spec/lib/dymos/query/attribute_spec.rb

@@ -0,0 +1,15 @@
+describe Dymos::Query::Attribute do
+  describe :new do
+    describe "DynamoDBClientで取り扱う値の形式に変換" do
+      it "文字列" do
+        attribute = Dymos::Query::Attribute.new('10')
+        expect(attribute.data).to eq(10)
+      end
+      it "数値に変換可能な文字列はintになる" do
+        attribute = Dymos::Query::Attribute.new('10')
+        expect(attribute.data).to eq(10)
+      end
+    end
+  end
+end
+

data/spec/lib/dymos/query/builder_spec.rb

@@ -0,0 +1,65 @@
+describe Dymos::Query::Builder do
+  before :all do
+    Aws.config[:region] = 'us-west-1'
+    Aws.config[:endpoint] = 'http://localhost:4567'
+    Aws.config[:access_key_id] = 'XXX'
+    Aws.config[:secret_access_key] = 'XXX'
+  end
+
+  describe :list_tables do
+    let(:query) { Dymos::Query::Builder.new(:list_tables) }
+
+    it "command" do
+      expect(query.command).to eq(:list_tables)
+    end
+
+    it "execute" do
+      client = Aws::DynamoDB::Client.new
+      expect(query.execute(client).methods.include? :table_names).to eq(true)
+    end
+  end
+
+  describe :put_item do
+    before :all do
+      client = Aws::DynamoDB::Client.new
+      # client.delete_table(table_name: 'test_put_item') if client.list_tables[:table_names].include?('test_put_item')
+      # client.create_table(
+      #     table_name: 'test_put_item',
+      #     attribute_definitions: [
+      #         {attribute_name: 'id', attribute_type: 'S'}
+      #     ],
+      #     key_schema: [
+      #         {attribute_name: 'id', key_type: 'HASH'}
+      #     ],
+      #     provisioned_throughput: {
+      #         read_capacity_units: 1,
+      #         write_capacity_units: 1,
+      #     })
+      # client.put_item(table_name: 'test_put_item', item: {id: 'hoge', name: '太郎'})
+      # client.put_item(table_name: 'test_put_item', item: {id: 'fuga', name: '次郎'})
+      # client.put_item(table_name: 'test_put_item', item: {id: 'piyo', name: '三郎'})
+    end
+    let(:client) { Aws::DynamoDB::Client.new }
+    let(:query) { Dymos::Query::Builder.new(:put_item, "test_put_item") }
+
+    it 'put' do
+      # User.put.item(id:"hoge",name:"太郎").expected(id:'hoge')
+      # query.query = {
+      #     table_name: query.table_name,
+      #     item: {
+      #         id: "hoge",
+      #         name: "太郎2",
+      #     },
+      #     expected: {
+      #         id: Dymos::Query::Expect.new(:s).condition(:==, 'hoge').data,
+      #         name: Dymos::Query::Expect.new(:s).condition(:==, '太郎2').data,
+      #     },
+      #     return_values: "ALL_OLD",
+      # }
+      # result = query.execute client
+      # expect(result).to eq('hoge')
+    end
+
+  end
+end
+

data/spec/lib/dymos/query/expect_spec.rb

@@ -0,0 +1,5 @@
+describe Dymos::Query::Expect do
+  describe :new do
+  end
+end
+

data/spec/lib/dymos/query/get_item_spec.rb

@@ -0,0 +1,55 @@
+describe Dymos::Query::GetItem do
+  before :all do
+    Aws.config[:region] = 'us-west-1'
+    Aws.config[:endpoint] = 'http://localhost:4567'
+    Aws.config[:access_key_id] = 'XXX'
+    Aws.config[:secret_access_key] = 'XXX'
+
+    client = Aws::DynamoDB::Client.new
+    client.delete_table(table_name: 'test_get_item') if client.list_tables[:table_names].include?('test_get_item')
+    client.create_table(
+        table_name: 'test_get_item',
+        attribute_definitions: [
+            {attribute_name: 'id', attribute_type: 'S'},
+            {attribute_name: 'category_id', attribute_type: 'N'},
+        ],
+        key_schema: [
+            {attribute_name: 'id', key_type: 'HASH'},
+            {attribute_name: 'category_id', key_type: 'RANGE'}
+        ],
+        provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+        })
+    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 0, name: '太郎'})
+    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 1})
+
+    class TestItem < Dymos::Model
+      table :test_get_item
+      field :id, :string
+    end
+  end
+
+  let(:client) { Aws::DynamoDB::Client.new }
+  describe :put_item do
+    describe "クエリ生成" do
+      it "追加のみ" do
+        query = TestItem.get.key(id: 'hoge', category_id: 1)
+        expect(query.query).to eq({
+                                      table_name: "test_get_item",
+                                      key: {id: "hoge", category_id: 1},
+                                      consistent_read: true,
+                                  })
+        # p client.scan(table_name: "test_get_item")
+        # res = query.execute client
+        # p res
+
+
+        # expect(res).to eq({})
+        # p client.scan(table_name:"test_get_item")
+      end
+
+    end
+  end
+end
+

data/spec/lib/dymos/query/put_item_spec.rb

@@ -0,0 +1,316 @@
+describe Dymos::Query::PutItem do
+  before :all do
+    Aws.config[:region] = 'us-west-1'
+    Aws.config[:endpoint] = 'http://localhost:4567'
+    Aws.config[:access_key_id] = 'XXX'
+    Aws.config[:secret_access_key] = 'XXX'
+
+    client = Aws::DynamoDB::Client.new
+    client.delete_table(table_name: 'test_put_item') if client.list_tables[:table_names].include?('test_put_item')
+    client.create_table(
+        table_name: 'test_put_item',
+        attribute_definitions: [
+            {attribute_name: 'id', attribute_type: 'S'},
+        ],
+        key_schema: [
+            {attribute_name: 'id', key_type: 'HASH'}
+        ],
+        provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+        })
+    client.put_item(table_name: 'test_put_item', item: {id: 'hoge', name: '太郎'})
+    client.put_item(table_name: 'test_put_item', item: {id: 'fuga', category_id: 1})
+
+    class TestItem < Dymos::Model
+      table :test_put_item
+      field :id, :string
+    end
+  end
+
+  let(:client) { Aws::DynamoDB::Client.new }
+  describe :put_item do
+    describe "クエリ生成" do
+      it "追加のみ" do
+        query = TestItem.put.item(id: "foo", name: "John")
+        expect(query.query).to eq({
+                                      table_name: "test_put_item",
+                                      item: {id: "foo", name: "John"},
+                                      return_values: "ALL_OLD",
+                                  })
+      end
+
+    end
+    it "条件なしput_item実行 追加時はattributesがnilになる" do
+      query = TestItem.put.item(id: "foo", name: "John")
+      result = query.execute client
+      expect(result).to eq(nil)
+    end
+
+    # it "条件ありput_item" do
+    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(name: "== 太郎")
+    #   expect(query.query).to eq({
+    #                                 table_name: "test_put_item",
+    #                                 item: {id: "hoge", name: "次郎"},
+    #                                 :expected => {:name => {:value => "太郎", :comparison_operator => "EQ"}},
+    #                                 return_values: "ALL_OLD",
+    #                             })
+    #
+    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(category_id: "== 1")
+    #   expect(query.query).to eq({
+    #                                 table_name: "test_put_item",
+    #                                 item: {id: "hoge", name: "次郎"},
+    #                                 :expected => {:category_id => {:value => 1, :comparison_operator => "EQ"}},
+    #                                 return_values: "ALL_OLD",
+    #                             })
+    #
+    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(category_id: "between 0 2")
+    #   expect(query.query).to eq({
+    #                                 table_name: "test_put_item",
+    #                                 item: {id: "hoge", name: "次郎"},
+    #                                 :expected => {:category_id => {:attribute_value_list => [0, 2], :comparison_operator => "BETWEEN"}},
+    #                                 return_values: "ALL_OLD",
+    #                             })
+    # end
+
+    # it "条件ありput_item実行 成功すると古いデータを返す" do
+    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(name: "== 太郎")
+    #   result = query.execute client
+    #   expect(result.attributes).to eq({id: "hoge", name: "太郎"})
+    # end
+
+    describe "条件指定" do
+      it "undefined operator" do
+        expect{TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "= 1")}.to raise_error(ArgumentError)
+      end
+
+      describe :== do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 1") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 1, :comparison_operator => "EQ"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 2")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :!= do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "!= 0") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 0, :comparison_operator => "NE"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 2")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :> do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 0") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 0, :comparison_operator => "GT"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 2")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :>= do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: ">= 1") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 1, :comparison_operator => "GE"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 2")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :< do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 2") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 2, :comparison_operator => "LT"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 0")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :<= do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "<= 1") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:value => 1, :comparison_operator => "LE"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "<= 0")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :between do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 1 2") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:category_id => {:attribute_value_list => [1, 2], :comparison_operator => "BETWEEN"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 2 3")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :contain do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "contains uga") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:id => {:value => "uga", :comparison_operator => "CONTAINS"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "contains ppp")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :not_contain do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "not_contains ppp") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:id => {:value => "ppp", :comparison_operator => "NOT_CONTAINS"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "not_contains uga")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :begins_with do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "begins_with fug") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:id => {:value => "fug", :comparison_operator => "BEGINS_WITH"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "begins_with uga")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :is_null do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(bar: "is_null") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:bar => {:comparison_operator => "NULL"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "is_null")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+
+      describe :is_not_null do
+        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "is_not_null") }
+        it :query do
+          expect(query.query).to eq(table_name: "test_put_item",
+                                    item: {id: "fuga", category_id: 1},
+                                    expected: {:id => {:comparison_operator => "NOT_NULL"}},
+                                    return_values: "ALL_OLD")
+        end
+        it :execute do
+          result = query.execute client
+          expect(result.attributes).to eq({id: "fuga", category_id: 1})
+        end
+        it :error do
+          query = TestItem.put.item(id: "fuga", category_id: 1).expected(bar: "is_not_null")
+          expect(query.execute(client)).to eq(false)
+        end
+      end
+    end
+    #
+    # it :< do
+    #   query = TestPutItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 2")
+    #   result = query.execute client
+    #   expect(result.attributes).to eq({id: "fuga", category_id: 1})
+    # end
+    # it :between do
+    #   query = TestPutItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 1 2")
+    #   result = query.execute client
+    #   expect(result.attributes).to eq({id: "fuga", category_id: 1})
+    # end
+  end
+end
+

data/spec/lib/dymos/query/query_spec.rb

@@ -0,0 +1,90 @@
+describe Dymos::Query::Query do
+  before :all do
+    Aws.config[:region] = 'us-west-1'
+    Aws.config[:endpoint] = 'http://localhost:4567'
+    Aws.config[:access_key_id] = 'XXX'
+    Aws.config[:secret_access_key] = 'XXX'
+
+    client = Aws::DynamoDB::Client.new
+    client.delete_table(table_name: 'test_query_item') if client.list_tables[:table_names].include?('test_query_item')
+    client.create_table(
+        table_name: 'test_query_item',
+        attribute_definitions: [
+            {attribute_name: 'id', attribute_type: 'S'},
+            {attribute_name: 'category_id', attribute_type: 'N'},
+            {attribute_name: 'other_id', attribute_type: 'N'},
+        ],
+        key_schema: [
+            {attribute_name: 'id', key_type: 'HASH'},
+            {attribute_name: 'category_id', key_type: 'RANGE'}
+        ],
+        global_secondary_indexes: [
+            {
+                index_name: "index_other_id",
+                key_schema: [
+                    {attribute_name: "id", key_type: "HASH"},
+                    {attribute_name: "other_id", key_type: "RANGE"},
+                ],
+                projection: {
+                    projection_type: "ALL",
+                },
+                provisioned_throughput: {
+                    read_capacity_units: 1,
+                    write_capacity_units: 1,
+                },
+            },
+        ],
+        provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+        })
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 0, other_id: 1})
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 1, other_id: 2})
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 2, other_id: 3})
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 3, other_id: 4})
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 4, other_id: 5})
+    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 5, other_id: 6})
+
+    class TestItem < Dymos::Model
+      table :test_query_item
+      field :id, :string
+    end
+  end
+
+  let(:client) { Aws::DynamoDB::Client.new }
+  describe :put_item do
+    describe "クエリ生成" do
+      describe "グローバルセカンダリインデックスを利用した検索" do
+        let(:query) {
+          TestItem.query.index_name(:index_other_id).key_conditions(
+              id: "== hoge",
+              other_id: "between 1 3"
+          )
+        }
+        it :query do
+          expect(query.query).to eq(
+                                     table_name: 'test_query_item',
+                                     index_name: 'index_other_id',
+                                     key_conditions: {
+                                         id: {
+                                             attribute_value_list: ["hoge"],
+                                             comparison_operator: "EQ"
+                                         },
+                                         other_id: {
+                                             attribute_value_list: [1, 3],
+                                             comparison_operator: "BETWEEN"
+                                         }},
+                                     consistent_read: false,
+                                 )
+        end
+        it :execute do
+          res = query.execute client
+          expect(res.size).to eq(3)
+        end
+
+
+      end
+    end
+  end
+end
+

data/spec/lib/dymos/query/update_item_spec.rb

@@ -0,0 +1,119 @@
+describe Dymos::Query::UpdateItem do
+  before :all do
+    Aws.config[:region] = 'us-west-1'
+    Aws.config[:endpoint] = 'http://localhost:4567'
+    Aws.config[:access_key_id] = 'XXX'
+    Aws.config[:secret_access_key] = 'XXX'
+
+    client = Aws::DynamoDB::Client.new
+    client.delete_table(table_name: 'test_update_item') if client.list_tables[:table_names].include?('test_update_item')
+    client.create_table(
+        table_name: 'test_update_item',
+        attribute_definitions: [
+            {attribute_name: 'id', attribute_type: 'S'},
+        ],
+        key_schema: [
+            {attribute_name: 'id', key_type: 'HASH'}
+        ],
+        provisioned_throughput: {
+            read_capacity_units: 1,
+            write_capacity_units: 1,
+        })
+    client.put_item(table_name: 'test_update_item', item: {id: 'hoge', name: '太郎'})
+    client.put_item(table_name: 'test_update_item', item: {id: 'fuga', count: 0})
+    client.put_item(table_name: 'test_update_item', item: {id: 'poyo', name: '可奈'})
+    client.put_item(table_name: 'test_update_item', item: {id: 'piyo', name: '杏奈', count: 10})
+
+    class TestItem < Dymos::Model
+      table :test_update_item
+      field :id, :string
+      field :name, :string
+      field :count, :string
+    end
+  end
+
+  let(:client) { Aws::DynamoDB::Client.new }
+  describe :put_item do
+    describe "クエリ生成" do
+      describe "新しいアイテムを追加" do
+        let(:query) { TestItem.update.key(id: "foo").attribute_updates({name: "Sam"}, 'PUT') }
+        it :query do
+          expect(query.query).to eq({
+                                        table_name: "test_update_item",
+                                        key: {id: "foo"},
+                                        attribute_updates: {name: {value: "Sam", action: "PUT"}},
+                                        return_values: "ALL_NEW",
+                                    })
+        end
+        it "成功すると新しいアイテムを返す" do
+          res = query.execute client
+          expect(res.id).to eq("foo")
+        end
+      end
+
+      describe "既存のアイテムを更新" do
+        describe "return_values :ALL_OLD" do
+          it "更新した場合は更新前のアイテムを返す" do
+            query = TestItem.update.key(id: "hoge").attribute_updates({name: "次郎"}, 'PUT').return_values(:ALL_OLD)
+            res = query.execute client
+            expect(res.name).to eq("太郎")
+          end
+          it "追加した場合はnilを返す" do
+            query = TestItem.update.key(id: "bar").attribute_updates({name: "Sam"}, 'PUT').return_values(:ALL_OLD)
+            res = query.execute client
+            expect(res).to eq(nil)
+          end
+        end
+        it "アイテムに加算する" do
+          query = TestItem.update.key(id: "fuga").attribute_updates({count: 1}, 'add')
+          res = query.execute client
+          expect(res.count).to eq(1)
+        end
+
+        describe "条件付き更新" do
+          describe :== do
+            let(:query) { TestItem.update.key(id: "poyo").attribute_updates({name: "志保"}, 'PUT').expected(name: "== 可奈") }
+
+            it :query do
+              expect(query.query).to eq({
+                                            table_name: "test_update_item",
+                                            key: {id: "poyo"},
+                                            attribute_updates: {name: {value: "志保", action: "PUT"}},
+                                            expected: ({name: {value: "可奈", comparison_operator: "EQ"}}),
+                                            return_values: "ALL_NEW",
+                                        })
+            end
+            it "成功すると新しいアイテムを返す" do
+              res = query.execute client
+              expect(res.name).to eq("志保")
+            end
+          end
+          describe "複数条件" do
+            let(:query) { TestItem.update.key(id: "piyo").attribute_updates({name: "百合子"}, 'PUT')
+            .expected(count: "between 9 12", name: "== 杏奈", hoge:"is_null")}
+
+            it :query do
+              expect(query.query).to eq({
+                                            table_name: "test_update_item",
+                                            key: {id: "piyo"},
+                                            attribute_updates: {name: {value: "百合子", action: "PUT"}},
+                                            expected: ({
+                                                name: {value: "杏奈", comparison_operator: "EQ"},
+                                                count: {attribute_value_list: [9, 12], comparison_operator: "BETWEEN"},
+                                                hoge: {comparison_operator: "NULL"},
+                                            }),
+                                            return_values: "ALL_NEW",
+                                            conditional_operator: "AND"
+                                        })
+            end
+            it "成功すると新しいアイテムを返す" do
+              res = query.execute client
+              expect(res.name).to eq("百合子")
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -1,81 +1,7 @@
 require 'coveralls'
 Coveralls.wear!
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause this
-# file to always be loaded, without a need to explicitly require it in any files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, make a
-# separate helper file that requires this one and then use it only in the specs
-# that actually need it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-Dir[File.join(File.dirname(__FILE__), "..", "lib", "**/*.rb")].each{|f| require f }
 
+require 'rubygems'
+require 'bundler/setup'
 
-RSpec.configure do |config|
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # Enable only the newer, non-monkey-patching expect syntax.
-    # For more details, see:
-    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-    expectations.syntax = :expect
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Enable only the newer, non-monkey-patching expect syntax.
-    # For more details, see:
-    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-    mocks.syntax = :expect
-
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended.
-    mocks.verify_partial_doubles = true
-  end
-end
+require 'dymos'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dymos
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - hoshina85
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-21 00:00:00.000000000 Z
+date: 2014-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,9 +125,24 @@ files:
 - dymos.gemspec
 - lib/dymos.rb
 - lib/dymos/attribute.rb
+- lib/dymos/command.rb
 - lib/dymos/model.rb
+- lib/dymos/query/attribute.rb
+- lib/dymos/query/builder.rb
+- lib/dymos/query/expect.rb
+- lib/dymos/query/get_item.rb
+- lib/dymos/query/put_item.rb
+- lib/dymos/query/query.rb
+- lib/dymos/query/update_item.rb
 - lib/dymos/version.rb
 - spec/lib/dymos/model_spec.rb
+- spec/lib/dymos/query/attribute_spec.rb
+- spec/lib/dymos/query/builder_spec.rb
+- spec/lib/dymos/query/expect_spec.rb
+- spec/lib/dymos/query/get_item_spec.rb
+- spec/lib/dymos/query/put_item_spec.rb
+- spec/lib/dymos/query/query_spec.rb
+- spec/lib/dymos/query/update_item_spec.rb
 - spec/spec_helper.rb
 homepage: ''
 licenses:
@@ -155,4 +170,11 @@ specification_version: 4
 summary: aws-sdk-core-ruby dynamodb client wrapper
 test_files:
 - spec/lib/dymos/model_spec.rb
+- spec/lib/dymos/query/attribute_spec.rb
+- spec/lib/dymos/query/builder_spec.rb
+- spec/lib/dymos/query/expect_spec.rb
+- spec/lib/dymos/query/get_item_spec.rb
+- spec/lib/dymos/query/put_item_spec.rb
+- spec/lib/dymos/query/query_spec.rb
+- spec/lib/dymos/query/update_item_spec.rb
 - spec/spec_helper.rb