tarantool 0.1

data/lib/tarantool/requests.rb

@@ -0,0 +1,19 @@
+module Tarantool
+  require 'tarantool/request'
+  module Requests
+    REQUEST_TYPES = {
+      insert: 13,
+      select: 17,
+      update: 19,
+      delete: 21,
+      call: 22,
+      ping:  65280
+    }
+    BOX_RETURN_TUPLE = 1
+    BOX_ADD = 2
+
+    %w{insert select update delete call ping}.each do |v|
+      require "tarantool/requests/#{v}"
+    end
+  end
+end

data/lib/tarantool/requests/call.rb

@@ -0,0 +1,20 @@
+module Tarantool
+  module Requests
+    class Call < Request
+      request_type :call
+
+      attr_reader :flags, :proc_name, :tuple
+      def parse_args
+        @flags = params[:return_tuple] ? 1 : 0
+        @proc_name = params[:proc_name]
+        @tuple = params[:args] || []
+      end
+
+      def make_body
+        [flags].pack('L') +
+        self.class.pack_field(proc_name) +
+        self.class.pack_tuple(*tuple)
+      end
+    end
+  end
+end

data/lib/tarantool/requests/delete.rb

@@ -0,0 +1,18 @@
+module Tarantool
+  module Requests
+    class Delete < Request
+      request_type :delete
+
+      attr_reader :flags, :key
+      def parse_args
+        @flags = params[:return_tuple] ? 1 : 0
+        @key = params[:key] || args.first
+      end
+
+      def make_body
+        [space_no, flags].pack('LL') +
+        self.class.pack_tuple(key)
+      end
+    end
+  end
+end

data/lib/tarantool/requests/insert.rb

@@ -0,0 +1,19 @@
+module Tarantool
+  module Requests
+    class Insert < Request
+      request_type :insert
+
+      attr_reader :flags, :values
+      def parse_args
+        @flags = BOX_ADD 
+        @flags |= BOX_RETURN_TUPLE if params[:return_tuple]
+        @values = params[:values] || args
+      end
+
+      def make_body
+        [space_no, flags].pack('LL') +
+        self.class.pack_tuple(*values)
+      end
+    end
+  end
+end

data/lib/tarantool/requests/ping.rb

@@ -0,0 +1,16 @@
+module Tarantool
+  module Requests
+    class Ping < Request
+      request_type :ping
+
+      def make_body
+        @start_time = Time.now
+        ''
+      end
+
+      def make_response(data)
+        succeed(Time.now - @start_time)
+      end
+    end
+  end
+end

data/lib/tarantool/requests/select.rb

@@ -0,0 +1,22 @@
+module Tarantool
+  module Requests
+    class Select < Request
+      request_type :select
+
+      attr_reader :index_no, :offset, :limit, :count, :tuples
+      def parse_args
+        @index_no = params[:index_no] || 0
+        @offset = params[:offset] || 0
+        @limit = params[:limit] || -1
+        @tuples = params[:values] || args
+        raise(ArgumentError.new('values are required')) if tuples.empty?
+        params[:return_tuple] = true
+      end
+
+      def make_body
+        [space_no, index_no, offset, limit, tuples.size].pack('LLLLL') +
+        tuples.map { |tuple| self.class.pack_tuple(*tuple) }.join
+      end
+    end
+  end
+end

data/lib/tarantool/requests/update.rb

@@ -0,0 +1,35 @@
+module Tarantool
+  module Requests
+    class Update < Request
+      request_type :update
+
+      OP_CODES = { set: 0, add: 1, and: 2, or: 3, xor: 4, splice: 5 }
+
+      def self.pack_ops(ops)
+        ops.map do |op|
+          raise ArgumentError.new('Operation should be array of size 3') unless op.size == 3
+
+          field_no, op_symbol, op_arg = op
+          op_code = OP_CODES[op_symbol] || raise(ArgumentError.new("Unsupported operation symbol '#{op_symbol}'"))
+
+          [field_no, op_code].pack('LC') + self.pack_field(op_arg)
+        end.join
+      end
+
+      attr_reader :flags, :key, :ops
+      def parse_args
+          @flags = params[:return_tuple] ? 1 : 0
+          @key = params[:key] || args.first
+          @ops = params[:ops]
+          raise ArgumentError.new('Key is required') unless key
+      end
+
+      def make_body
+        [space_no, flags].pack('LL') +
+        self.class.pack_tuple(key) +
+        [ops.size].pack('L') +
+        self.class.pack_ops(ops)
+      end
+    end
+  end
+end

data/lib/tarantool/response.rb

@@ -0,0 +1,58 @@
+module Tarantool
+  class Field
+    attr_reader :data
+    def initialize(data)
+      @data = data
+    end
+
+    def to_i
+      if data.bytesize == 4
+        data.unpack('L')[0]
+      elsif data.bytesize == 8
+        data.unpack('Q')[0]
+      else
+        raise ValueError.new("Unable to cast field to int: length must be 4 or 8 bytes, field length is #{data.size}")
+      end
+    end
+
+    def to_s
+      data.dup.force_encoding('utf-8')
+    end
+  end
+  class Response
+    attr_reader :tuples_affected, :offset, :tuples
+    def initialize(data, params = {})
+      @offset = 0
+      @tuples_affected, = data[0, 4].unpack('L')
+      @offset += 4
+      if params[:return_tuple]
+        @tuples = (1..tuples_affected).map do
+          unpack_tuple(data)
+        end
+      else
+        tuples_affected
+      end
+    end
+
+    # Only select request can return many tuples
+    def tuple
+      tuples.first
+    end
+
+    def unpack_tuple(data)
+      byte_size, cardinality = data[offset, 8].unpack("LL")
+      @offset += 8
+      tuple_data = data[offset, byte_size]
+      @offset += byte_size
+      (1..cardinality).map do
+        Field.new unpack_field(tuple_data)
+      end
+    end
+
+    def unpack_field(data)
+      byte_size,  = data.unpack('w')
+      data.slice!(0, [byte_size].pack('w').bytesize) # ololo
+      data.slice!(0, byte_size)
+    end
+  end
+end

data/lib/tarantool/serializers.rb

@@ -0,0 +1,9 @@
+module Tarantool
+  module Serializers
+    MAP = {}
+    %w{string integer}.each do |v|
+      require "tarantool/serializers/#{v}"
+    end
+
+  end
+end

data/lib/tarantool/serializers/bson.rb

@@ -0,0 +1,15 @@
+require 'bson'
+module Tarantool
+  module Serializers
+    class BSON
+      Serializers::MAP[:bson] = self
+      def self.encode(value)
+        ::BSON.serialize(value).to_s
+      end
+
+      def self.decode(field)
+        ::BSON.deserialize(field.to_s)
+      end
+    end
+  end
+end

data/lib/tarantool/serializers/integer.rb

@@ -0,0 +1,14 @@
+module Tarantool
+  module Serializers
+    class Integer
+      Serializers::MAP[:integer] = self
+      def self.encode(value)
+        value.to_i
+      end
+
+      def self.decode(field)
+        field.to_i
+      end
+    end
+  end
+end

data/lib/tarantool/serializers/string.rb

@@ -0,0 +1,14 @@
+module Tarantool
+  module Serializers
+    class String
+      Serializers::MAP[:string] = self
+      def self.encode(value)
+        value.to_s
+      end
+
+      def self.decode(field)
+        field.to_s
+      end
+    end
+  end
+end

data/lib/tarantool/space.rb

@@ -0,0 +1,39 @@
+module Tarantool
+  class Space
+    attr_accessor :space_no
+    attr_reader :connection
+    def initialize(connection, space_no = nil)
+      @connection = connection
+      @space_no = space_no
+    end
+
+    def select(*args)
+      request Requests::Select, args
+    end
+
+    def call(*args)
+      request Requests::Call, args
+    end
+
+    def insert(*args)
+      request Requests::Insert, args
+    end
+
+
+    def delete(*args)
+      request Requests::Delete, args
+    end
+
+    def update(*args)
+      request Requests::Update, args
+    end
+
+    def ping(*args)
+      request Requests::Ping, args
+    end
+
+    def request(cls, args)      
+      cls.new(self, *args).perform
+    end
+  end
+end

data/lib/tarantool/synchrony.rb

@@ -0,0 +1,13 @@
+require 'tarantool'
+require 'em-synchrony'
+
+module Tarantool
+  class Space
+    alias :deffered_request :request
+    def request(*args)
+      EM::Synchrony.sync(deffered_request(*args)).tap do |v|
+        raise v if v.is_a?(Exception)        
+      end
+    end
+  end
+end

data/spec/helpers/let.rb

@@ -0,0 +1,11 @@
+module Helpers
+  module Let
+    def let(name, &blk)      
+      define_method name do
+        @let_assigments ||= {}
+        @let_assigments[name] ||= send(:"original_#{name}")
+      end
+      define_method "original_#{name}", &blk
+    end
+  end
+end

data/spec/helpers/truncate.rb

@@ -0,0 +1,12 @@
+module Helpers
+  module Truncate
+    def teardown       
+      while (res = Tarantool.call(proc_name: 'box.select_range', args: [Tarantool.singleton_space.space_no.to_s, '0', '100'], return_tuple: true)) && res.tuples.size > 0
+        res.tuples.each do |k, *_|
+          Tarantool.delete key: k
+        end
+      end
+      super
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'bundler'
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+Bundler.setup
+
+require 'minitest/spec'
+
+require 'helpers/let'
+require 'helpers/truncate'
+require 'rr'
+
+require 'tarantool/synchrony'
+
+config = { host: '10.211.55.3', port: 33013, space_no: 0 }
+
+Tarantool.configure config
+
+class MiniTest::Unit::TestCase
+  extend Helpers::Let
+  include RR::Adapters::MiniTest
+end
+
+at_exit {
+  EM.synchrony do
+    exit_code = MiniTest::Unit.new.run(ARGV)
+    EM.stop
+    exit_code
+  end
+}

data/spec/tarantool.cfg

@@ -0,0 +1,32 @@
+slab_alloc_arena = 0.1
+pid_file = "box.pid"
+
+logger="cat - >> tarantool.log"
+
+primary_port = 33013
+secondary_port = 33014
+admin_port = 33015
+
+rows_per_wal = 50
+
+space[0].enabled = 1
+
+space[0].index[0].type = "HASH"
+space[0].index[0].unique = 1
+space[0].index[0].key_field[0].fieldno = 0
+space[0].index[0].key_field[0].type = "STR"
+
+space[0].index[1].type = "TREE"
+space[0].index[1].unique = 1
+space[0].index[1].key_field[0].fieldno = 1
+space[0].index[1].key_field[0].type = "STR"
+space[0].index[1].key_field[1].fieldno = 2
+space[0].index[1].key_field[1].type = "STR"
+
+
+space[1].enabled = 1
+
+space[1].index[0].type = "HASH"
+space[1].index[0].unique = 1
+space[1].index[0].key_field[0].fieldno = 0
+space[1].index[0].key_field[0].type = "NUM"

data/spec/tarantool/record_spec.rb

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'tarantool/record'
+require 'yajl'
+require 'tarantool/serializers/bson'
+describe Tarantool::Record do
+  include Helpers::Truncate
+  before do
+    Tarantool.singleton_space.space_no = 0
+  end
+  let(:user_class) do
+    Class.new(Tarantool::Record) do
+      def self.name # For naming
+        "User"
+      end
+
+      field :login, :string
+      field :name, :string
+      field :email, :string      
+      field :apples_count, :integer, default: 0
+      index :name, :email
+    end
+  end
+
+  let(:user) { user_class.new }
+  it "should set and get attributes" do
+    user.name = 'Andrew'
+    user.name.must_equal 'Andrew'
+  end
+
+  describe "inheritance" do
+    let(:author_class) do
+      Class.new(user_class) do
+        field :best_book, Integer
+      end
+    end
+    let(:artist_class) do
+      Class.new(user_class) do
+        field :imdb_id, Integer
+      end
+    end
+
+    describe "Artist from User" do
+      it "should has only itself field" do
+        artist_class.fields.keys.must_equal [:login, :name, :email, :apples_count, :imdb_id]
+      end
+    end
+
+    it "should has same space no as parent" do
+      user_class.space_no = 1
+      artist_class.space_no.must_equal 1
+    end
+
+    it "should has different space no to parent if setted" do
+      artist_class.space_no = 1
+      user_class.space_no.must_equal 0
+      artist_class.space_no.must_equal 1
+    end
+  end
+
+  describe "detect_index_no" do
+    let(:select) { user_class.select }
+    it "should return 0 for :login" do
+      select.detect_index_no([:login]).must_equal 0
+    end
+    it "should return 1 for :name" do
+      select.detect_index_no([:name]).must_equal 1
+    end
+    it "should return 1 for :name, :email" do
+      select.detect_index_no([:name, :email]).must_equal 1
+    end
+    it "should return nil for :email" do
+      select.detect_index_no([:email]).must_be_nil
+    end
+    it "should return nil for :login, :name" do
+      select.detect_index_no([:login, :name]).must_be_nil
+    end
+  end
+
+  describe "save" do
+    it "should save and select record" do
+      u = user_class.new login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'
+      u.save
+      u = user_class.find 'prepor'
+      u.id.must_equal 'prepor'
+      u.email.must_equal 'ceo@prepor.ru'
+      u.name.must_equal 'Andrew'
+      u.apples_count.must_equal 0
+    end
+
+    it "should update dirty attributes" do
+      u = user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'
+      u.name = 'Petr'
+      u.save
+      u = user_class.find 'prepor'
+      u.email.must_equal 'ceo@prepor.ru'
+      u.name.must_equal 'Petr'
+    end
+
+    describe "with nils" do
+      before do
+        user_class.field :info, :bson
+      end
+      it "should work properly with nils values" do
+        u = user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru', apples_count: nil
+        u.info.must_be_nil
+        u.apples_count.must_be_nil
+        u = u.reload
+        u.info.must_be_nil
+        u.apples_count.must_be_nil
+        u.info = {'bio' => 'hi!'}
+        u.apples_count = 1
+        u.save
+        u = u.reload
+        u.info.must_equal({ 'bio' => 'hi!' })
+        u.apples_count.must_equal 1
+      end
+    end
+  end
+
+  describe "reload" do
+    it "should reload current record" do
+      u = user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'      
+      u.name = 'Petr'
+      u.reload.name.must_equal 'Andrew'
+    end
+  end
+
+  describe "increment" do
+    let(:user) { user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru' }
+    it "should increment apples count by 1" do
+      user.increment :apples_count
+      user.reload.apples_count.must_equal 1
+    end
+
+    it "should increment apples count by 3" do
+      user.increment :apples_count, 3
+      user.reload.apples_count.must_equal 3
+    end
+  end
+
+  describe "destroy" do
+    it "should destroy record" do
+      u = user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'
+      u.destroy
+      u.reload.must_be_nil
+    end
+  end
+
+  describe "validations" do
+    describe "with validator on login size" do
+      before do
+        user_class.validates_length_of(:login, minimum: 3)
+      end
+      it "should invalidate all records with login less then 3 chars" do
+        u = user_class.new login: 'pr', name: 'Andrew', email: 'ceo@prepor.ru'
+        u.save.must_equal false
+        u.valid?.must_equal false
+        u.errors.size.must_equal 1
+        u.login = 'prepor'
+        u.save.must_equal true
+        u.valid?.must_equal true
+        u.errors.size.must_equal 0
+      end
+    end
+  end
+
+  describe "callbacks" do
+    it "should run before / after create callbackss in right places" do
+      user_class.before_create :action_before_create
+      user_class.after_create :action_after_create
+
+      u = user_class.new login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'
+      mock(u).action_before_create { u.new_record?.must_equal true }
+      mock(u).action_after_create { u.new_record?.must_equal false }
+      u.save
+    end
+  end
+
+  describe "serialization" do
+    it "should support AM serialization API" do
+      h = { login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru' }
+      u = user_class.create h
+      u.as_json.must_equal({ 'user' => h.merge(apples_count: 0) })
+    end
+
+    describe "fields serilizers" do
+      before do
+        user_class.field :info, :bson
+      end
+
+      it "should serialise and deserialize info field" do
+        info = { 'bio' => "hi!", 'age' => 23, 'hobbies' => ['mufa', 'tuka'] }
+        u = user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru', info: info
+        u.info['hobbies'].must_equal ['mufa', 'tuka']
+        u = u.reload
+        u.info['hobbies'].must_equal ['mufa', 'tuka']
+      end
+    end
+  end
+
+  describe "select" do
+    describe "by name Andrew" do
+      let(:select) { user_class.where(name: 'Andrew') }
+      before do
+        user_class.create login: 'prepor', name: 'Andrew', email: 'ceo@prepor.ru'
+        user_class.create login: 'petro', name: 'Petr', email: 'petro@gmail.com'
+        user_class.create login: 'ruden', name: 'Andrew', email: 'rudenkoco@gmail.com'
+      end
+      it "should select all records with name == 'Andrew'" do
+        select.all.map(&:login).must_equal ['prepor', 'ruden']
+      end
+
+      it "should select first record with name == 'Andrew'" do
+        select.first.login.must_equal 'prepor'
+      end
+
+      it "should select 1 record by name and email" do
+        user_class.where(name: 'Andrew', email: 'rudenkoco@gmail.com').map(&:login).must_equal ['ruden']
+      end
+
+      it "should select 2 record by name and email" do
+        user_class.where(name: ['Andrew', 'Andrew'], email: ['ceo@prepor.ru', 'rudenkoco@gmail.com']).map(&:login).must_equal ['prepor', 'ruden']
+      end
+
+      it "should select 3 record by names" do
+        user_class.where(name: ['Andrew', 'Petr']).map(&:login).must_equal ['prepor', 'ruden', 'petro']
+      end
+
+      describe "with limit 1" do
+        let(:select) { super().limit(1) }
+        it "should select first record with name == 'Andrew'" do
+          select.map(&:login).must_equal ['prepor']
+        end
+
+        describe "with offset 1" do
+          let(:select) { super().offset(1) }
+          it "should select last record with name == 'Andrew'" do
+            select.map(&:login).must_equal ['ruden']
+          end
+        end
+      end
+
+    end
+  end
+
+end