tarantool 0.2.5 → 0.3.0.7

data/Gemfile

@@ -1,14 +1,16 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 
-gem "activemodel"
+group :development do
+  gem "debugger"
+end
 
-gem "rr"
-gem "yajl-ruby"
-gem "bson"
-gem "bson_ext"
-
-gem "ruby-debug19"
-
-gem "em-synchrony"
-
-gemspec
+group :test do
+  gem "rr"
+  gem "activesupport"
+  gem "activemodel"
+  gem "yajl-ruby"
+  gem "bson"
+  gem "bson_ext"
+end
+# Specify your gem's dependencies in em-tarantool.gemspec
+gemspec

data/LICENSE

@@ -1,6 +1,6 @@
-/* 
- * Copyright (C) 2011 Mail.RU
-  *
+/*
+ * Copyright (C) 2011-2012 Mail.RU
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -21,4 +21,4 @@
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
- */
+ */

data/README.md

@@ -22,7 +22,13 @@ DB = Tarantool.new host: 'locahost', port: 33013
 space = DB.space 0
 ```
 
-The driver internals can work in two modes: block via TCPSocket and non block via EventMachine and fibers. By default it uses block mode. 
+The driver internals can work in three modes:
+- blocking via TCPSocket
+- callback style via EventMachine
+- EM::Synchrony like via EventMachine and fibers, so that control flow is visually
+  blocked, but eventloop is not (see EM::Synchrony)
+
+By default it uses block mode.
 
 
 ```ruby
@@ -49,7 +55,7 @@ EM.synchrony do
 end
 ```
 
-The driver itself provides ActiveModel API: Callbacks, Validations, Serialization, Dirty. 
+The driver itself provides ActiveModel API: Callbacks, Validations, Serialization, Dirty.
 Type casting is automatic, based on the index type chosen to process the query.
 For example:
 
@@ -59,7 +65,7 @@ require 'tarantool/serializers/bson'
 class User < Tarantool::Record
   field :login, :string
   field :name, :string
-  field :email, :string      
+  field :email, :string
   field :apples_count, :integer, default: 0
   field :info, :bson
   index :name, :email
@@ -76,16 +82,16 @@ User.create login: 'prepor', email: 'ceo@prepor.ru', name: 'Andrew'
 User.create login: 'ruden', name: 'Andrew', email: 'rudenkoco@gmail.com'
 
 # find by primary key login
-User.find 'prepor' 
+User.find 'prepor'
 # first 2 users with name Andrew
-User.where(name: 'Andrew').limit(2).all 
+User.where(name: 'Andrew').limit(2).all
 # second user with name Andrew
-User.where(name: 'Andrew').offset(1).limit(1).all 
+User.where(name: 'Andrew').offset(1).limit(1).all
 # user with name Andrew and email ceo@prepor.ru
 User.where(name: 'Andrew', email: 'ceo@prepor.ru').first
 # raise exception, becouse we can't select query started from not first part of index
 begin
-    User.where(email: 'ceo@prepor.ru') 
+    User.where(email: 'ceo@prepor.ru')
 rescue Tarantool::ArgumentError => e
 end
 # increment field apples_count by one. Its atomic operation via native Tarantool interface
@@ -105,7 +111,7 @@ user.destroy
 ```
 
 When definining a record, field order is important: this is the order of fields
-in the tuple stored by Tarantool. By default, the primary key is field 0. 
+in the tuple stored by Tarantool. By default, the primary key is field 0.
 
 `index` method just mapping to your Tarantool schema, client doesn't modify schema for you.
 
@@ -117,4 +123,4 @@ in the tuple stored by Tarantool. By default, the primary key is field 0.
 * admin-socket protocol
 * safe to add fields to exist model
 * Hash, Array and lambdas as default values
-* timers to response, reconnect strategies
+* timers to response, reconnect strategies

data/Rakefile

@@ -1,131 +1,7 @@
-require 'rubygems'
-require 'rake'
-require 'date'
-
-#############################################################################
-#
-# Helper functions
-#
-#############################################################################
-
-def name
-  @name ||= Dir['*.gemspec'].first.split('.').first
-end
-
-def version
-  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
-  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
-end
-
-def date
-  Date.today.to_s
-end
-
-def rubyforge_project
-  name
-end
-
-def gemspec_file
-  "#{name}.gemspec"
-end
-
-def gem_file
-  "#{name}-#{version}.gem"
-end
-
-def replace_header(head, header_name)
-  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
-end
-
-#############################################################################
-#
-# Standard tasks
-#
-#############################################################################
-
-
-task :default => :spec
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
 require 'rake/testtask'
-Rake::TestTask.new(:spec) do |t|
-  t.libs << 'spec'
-  t.pattern = 'spec/**/*_spec.rb'
-  t.verbose = false
-end
-
-desc "Generate RCov test coverage and open in your browser"
-task :coverage do
-  require 'rcov'
-  sh "rm -fr coverage"
-  sh "rcov test/test_*.rb"
-  sh "open coverage/index.html"
-end
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -r ./lib/#{name}.rb"
-end
-
-
-#############################################################################
-#
-# Packaging tasks
-#
-#############################################################################
-
-desc "Create tag v#{version} and build and push #{gem_file} to Rubygems"
-task :release => :build do
-  unless `git branch` =~ /^\* master$/
-    puts "You must be on the master branch to release!"
-    exit!
-  end
-  sh "git commit --allow-empty -m 'Release #{version}'"
-  sh "git tag v#{version}"
-  sh "git push origin master"
-  sh "git push origin v#{version}"
-  sh "gem push pkg/#{name}-#{version}.gem"
-end
-
-desc "Build #{gem_file} into the pkg directory"
-task :build => :gemspec do
-  sh "mkdir -p pkg"
-  sh "gem build #{gemspec_file}"
-  sh "mv #{gem_file} pkg"
-end
-
-desc "Generate #{gemspec_file}"
-task :gemspec => :validate do
-  # read spec file and split out manifest section
-  spec = File.read(gemspec_file)
-  head, manifest, tail = spec.split("  # = MANIFEST =\n")
-
-  # replace name version and date
-  replace_header(head, :name)
-  replace_header(head, :version)
-  replace_header(head, :date)
-  #comment this out if your rubyforge_project has a different name
-  replace_header(head, :rubyforge_project)
-
-  # determine file list from git ls-files
-  files = `git ls-files`.
-    split("\n").
-    sort.
-    reject { |file| file =~ /^\./ }.
-    reject { |file| file =~ /^(rdoc|pkg)/ }.
-    map { |file| "    #{file}" }.
-    join("\n")
-
-  # piece file back together and write
-  manifest = "  s.files = %w[\n#{files}\n  ]\n"
-  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
-  File.open(gemspec_file, 'w') { |io| io.write(spec) }
-  puts "Updated #{gemspec_file}"
+Rake::TestTask.new do |i|
+  i.options = '-v'
+  i.verbose = true
 end
-
-desc "Validate #{gemspec_file}"
-task :validate do
-  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
-  unless Dir['VERSION*'].empty?
-    puts "A `VERSION` file at root level violates Gem best practices."
-    exit!
-  end
-end

data/lib/tarantool/base_record.rb

@@ -0,0 +1,288 @@
+require 'tarantool'
+require 'tarantool/record/select'
+require 'active_support/core_ext/class/attribute'
+
+module Tarantool
+  class RecordError < StandardError; end
+  class UpdateNewRecord < RecordError; end
+
+  class BaseRecord
+    class_attribute :fields, instance_reader: false, instance_writer: false
+    self.fields = {}.freeze
+
+    class_attribute :default_values, instance_reader: false, instance_writer: false
+    self.default_values = {}.freeze
+
+    class_attribute :indexes, instance_reader: false, instance_writer: false
+    self.indexes = [].freeze
+
+    class_attribute :space_no, instance_reader: false, instance_writer: false
+    class_attribute :tarantool, instance_reader: false, instance_writer: false
+
+    class << self
+      alias set_space_no space_no=
+      alias set_tarantool tarantool=
+    end
+
+    module ClassMethods
+      def field(name, type, params = {})
+        type = Serializers.check_type(type)
+
+        raise ArgumentError, "_tail should be last declaration"  if fields.include?(:_tail)
+        self.fields = fields.merge(name => type)
+        index name  if indexes.empty?
+
+        if params[:default]
+          self.default_values = default_values.merge name => params[:default]
+        end
+
+        define_field_accessor(name, type)
+      end
+
+      def _tail(*types)
+        types = types.map{|type| Serializers.check_type(type)}
+
+        raise ArgumentError, "double _tail declaration"  if fields.include?(:_tail)
+        self.fields = fields.merge(:_tail => types)
+
+        define_field_accessor(:_tail, types)
+      end
+
+      def index(*fields)
+        options = Hash === fields.last ? fields.pop : {}
+        if options[:primary]
+          self.indexes = indexes.dup.tap{|ind| ind[0] = fields}
+        else
+          self.indexes += [fields]
+        end
+      end
+
+      def primary_index
+        indexes[0]
+      end
+
+      def space
+        @space ||= begin
+            tarantool.space_hash(space_no, fields.dup, keys: indexes)
+          end
+      end
+
+      # space that will return records as results for calls
+      # it is useful, if you wish to use callback interface
+      def auto_space
+        @auto_space ||= begin
+            space.with_translator(method(:from_fetched))
+          end
+      end
+
+      def by_pk(pk)
+        if Hash === (res = space.by_pk(pk))
+          from_fetched(res)
+        end
+      end
+
+      def by_pks(pks)
+        space.all_by_pks(pks).map{|hash| from_fetched(hash)}
+      end
+
+      def find(*args)
+        if args.size == 1
+          by_pk(args[0])
+        else
+          by_pks(args)
+        end
+      end
+
+      def first(cond)
+        if Hash === cond
+          if Hash === (res = space.first(cond))
+            from_fetched(res)
+          end
+        else
+          by_pk(cond)
+        end
+      end
+
+      def all(cond, opts={})
+        res = space.all(cond, opts)
+        res.map!{|hash| from_fetched(hash)}
+        res
+      end
+
+      def select(cond=nil, opts={})
+        cond.nil? ? Select.new(self) : all(cond, opts)
+      end
+
+      def create(attributes = {})
+        r = new(attributes)
+        r.save
+        r
+      end
+
+      # Call stored procedure without returning tuples. By default, it prepends
+      # +space_no+ to arguments. To avoid prepending, set +space_no: nil+ in options.
+      #
+      #   MyRecord.call('box.select_range', offset, limit)
+      #   MyRecord.call('myfunction', arg1, arg2, space_no: nil)
+      #
+      def invoke(proc_name, *args)
+        opts = Hash === args.last ? args.pop : {}
+        space.invoke(proc_name, args, opts)
+      end
+
+      # Call stored procedure. By default, it prepends +space_no+ to arguments.
+      # To avoid prepending, set +space_no: nil+ in options.
+      #
+      #   MyRecord.call('box.select_range', offset, limit)
+      #   MyRecord.call('myfunction', arg1, arg2, space_no: nil)
+      #
+      # You could recieve arbitarry arrays or hashes instead of instances of
+      # record, if you pass +:returns+ argument. See documentation for +SpaceHash+
+      # for this.
+      def call(proc_name, *args)
+        opts = Hash === args.last ? args.pop : {}
+        res = space.call(proc_name, args, opts)
+        if Array === res && !opts[:returns]
+          res.map{|hash| from_fetched(hash) }
+        else
+          res
+        end
+      end
+
+      def from_fetched(hash)
+        hash && allocate.__fetched(hash)
+      end
+
+      def insert(hash, ret_tuple = false)
+        hash = default_values.merge(hash)
+        if ret_tuple
+          from_fetched space.insert(hash, return_tuple: true)
+        else
+          space.insert(hash)
+        end
+      end
+
+      def replace(hash, ret_tuple = false)
+        hash = default_values.merge(hash)
+        if ret_tuple
+          from_fetched space.replace(hash, return_tuple: true)
+        else
+          space.replace(hash)
+        end
+      end
+
+      def update(pk, ops, ret_tuple=false)
+        if ret_tuple
+          from_fetched space.update(pk, ops, return_tuple: true)
+        else
+          space.update(pk, ops)
+        end
+      end
+
+      def delete(pk, ret_tuple=false)
+        if ret_tuple
+          from_fetched space.delete(pk, return_tuple: true)
+        else
+          space.delete(pk)
+        end
+      end
+
+      %w{where limit offset}.each do |meth|
+        class_eval <<-"EOF", __FILE__, __LINE__
+          def #{meth}(arg)
+            select.#{meth}(arg)
+          end
+        EOF
+      end
+    end
+    extend ClassMethods
+
+    module InstanceMethods
+      attr_accessor :__new_record
+      attr_reader :attributes
+      alias new_record __new_record
+      alias new_record? new_record
+
+      def new_record!
+        @__new_record = true
+        self
+      end
+
+      def old_record!
+        @__new_record = false
+        self
+      end
+
+      def set_attributes(attributes)
+        attributes.each do |k, v|
+          send("#{k}=", v)
+        end      
+      end
+
+      def _tail
+        @attributes[:_tail]
+      end
+
+      def _tail=(v)
+        @attributes[:_tail] = v
+      end
+
+      def update_attributes(attributes)
+        set_attributes(attributes)
+        save
+      end
+
+      def id
+        (primary = self.class.primary_index).size == 1 ?
+          @attributes[primary[0]] :
+          @attributes.values_at(*primary)
+      end
+
+      def space
+        self.class.space
+      end
+
+      def auto_space
+        self.class.space
+      end
+
+      def reload
+        if hash = space.by_pk(id)
+          @__new_record = false
+          @attributes = hash
+          self
+        else
+          _raise_doesnt_exists("reload")
+        end
+      end
+
+      def ==(other)
+        equal?(other) || (other.class == self.class && id == other.id)
+      end
+
+      # update record in db first, reload it then
+      #
+      #   record.update({:state => 'sleep', :sleep_count => [:+, 1]})
+      #   record.update([[:state, 'sleep'], [:sleep_count, :+, 1]])
+      def update(ops)
+        raise UpdateNewRecord, "Could not call update on new record"  if @__new_record
+        unless new_attrs = space.update(id, ops, return_tuple: true)
+          _raise_doesnt_exists
+        end
+        @attributes = new_attrs
+
+        self
+      end
+
+      def increment(field, by = 1)
+        update([[field.to_sym, :+, by]])
+      end
+
+      def _raise_doesnt_exists(action = "update")
+        raise TupleDoesntExists.new(0x3102, "Record which you wish to #{action}, doesn't exists")
+      end
+    end
+    include InstanceMethods
+
+  end
+end

data/lib/tarantool/block_db.rb

@@ -0,0 +1,135 @@
+module Tarantool
+  class BlockDB < DB
+    def establish_connection
+      @connection = IProto.get_connection(@host, @port, :block)
+    end
+
+    def close_connection
+      @connection.close
+    end
+
+    def _send_request(request_type, body, cb)
+      cb.call @connection.send_request(request_type, body)
+    end
+
+    module CommonSpaceBlockingMethods
+      def _block_cb
+        @_block_cb ||= method(:_raise_or_return)
+      end
+
+      def all_by_pks(pks, opts={})
+        all_by_pks_cb(pks, _block_cb, opts)
+      end
+
+      def by_pk(pk)
+        by_pk_cb(pk, _block_cb)
+      end
+
+      def insert(tuple, opts={})
+        insert_cb(tuple, _block_cb, opts)
+      end
+
+      def replace(tuple, opts={})
+        replace_cb(tuple, _block_cb, opts)
+      end
+
+      def update(pk, operations, opts={})
+        update_cb(pk, operations, _block_cb, opts)
+      end
+
+      def delete(pk, opts={})
+        delete_cb(pk, _block_cb, opts)
+      end
+
+      def invoke(func_name, values = [], opts = {})
+        invoke_cb(func_name, values, _block_cb, opts)
+      end
+
+      def call(func_name, values = [], opts = {})
+        call_cb(func_name, values, _block_cb, opts)
+      end
+
+      def ping
+        ping_cb(_block_cb)
+      end
+    end
+
+    class SpaceArray < ::Tarantool::SpaceArray
+      include CommonSpaceBlockingMethods
+
+      def all_by_key(index_no, key, opts={})
+        all_by_key_cb(index_no, key, _block_cb, opts)
+      end
+
+      def first_by_key(index_no, key)
+        first_by_key_cb(index_no, key, _block_cb)
+      end
+
+      def all_by_keys(index_no, keys, opts={})
+        all_by_keys_cb(index_no, keys, _block_cb, opts)
+      end
+
+      def select(index_no, keys, offset=0, limit=-1)
+        select_cb(index_no, keys, offset, limit, _block_cb)
+      end
+    end
+
+    class SpaceHash < ::Tarantool::SpaceHash
+      include CommonSpaceBlockingMethods
+
+      def all(keys, opts = {})
+        all_cb(keys, _block_cb, opts)
+      end
+
+      def first(key)
+        first_cb(key, _block_cb)
+      end
+
+      def select(keys, offset=0, limit=-1)
+        select_cb(keys, offset, limit, _block_cb)
+      end
+    end
+
+    class Query < ::Tarantool::Query
+      def select(space_no, index_no, keys, offset, limit, opts={})
+        select_cb(space_no, index_no, keys, offset, limit, _block_cb, opts)
+      end
+
+      def all(space_no, index_no, keys, opts={})
+        all_cb(space_no, index_no, keys, _block_cb, opts)
+      end
+
+      def first(space_no, index_no, key, opts={})
+        first_cb(space_no, index_no, key, _block_cb, opts)
+      end
+
+      def insert(space_no, tuple, opts={})
+        insert_cb(space_no, tuple, _block_cb, opts)
+      end
+
+      def replace(space_no, tuple, opts={})
+        replace_cb(space_no, tuple, _block_cb, opts)
+      end
+
+      def update(space_no, pk, operation, opts={})
+        update_cb(space_no, pk, operation, _block_cb, opts)
+      end
+
+      def delete(space_no, pk, opts={})
+        delete_cb(space_no, pk, _block_cb, opts)
+      end
+
+      def invoke(func_name, values, opts={})
+        invoke_cb(func_name, values, _block_cb, opts)
+      end
+
+      def call(func_name, values, opts={})
+        call_cb(func_name, values, _block_cb, opts)
+      end
+
+      def ping
+        ping_cb(_block_cb)
+      end
+    end
+  end
+end