tarantool-crud 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ecc01ae9122ffa4404d90dc8257541b26eed6fbb503a2eefaaa8be7d10b4ccf
+  data.tar.gz: e5ed1f866cee6873e51dcc70490ffaede45c79fdd690f49c2457649afee4fafc
+SHA512:
+  metadata.gz: 9bc5da2356ccb4477cb6b37053cac70743bf952d2799675fef5d442c1202a270d947c1f5e21a8fd478d929dcdfbf0c441050f4a798d06594895d034fa316c154
+  data.tar.gz: d9bd55c7c4f033b0943b9782daa5bd8441544a574c4722f1d5e83eb071bf2b8cba5045ea669e883ce649bd2288bea16ca4fb56dd5bf07ca108bec136157262f4

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+First release.
+
+- `Tarantool::Crud::Client` over `Tarantool::Client` or `Pool`, per-space handles.
+- insert, replace, upsert (tuple or object), get, update, delete, select, each, count, min, max, len, truncate.
+- `*_many` and `*_many!` batch operations.
+- Conditions from Arrays or Hashes with ranges.
+- Read and write defaults filtered by the options each crud function accepts.
+- `storage_info` and `stats`; `stats` accepts `timeout:` and falls back to the `read:` timeout plus `timeout_margin`.
+- Depends on `tarantool-client ~> 0.1.0`.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Starlexxx
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# tarantool-crud
+
+Ruby wrapper over [tarantool/crud](https://github.com/tarantool/crud) for sharded (vshard) Tarantool 2.11+ and 3.x
+clusters, built on [tarantool-client](../tarantool-client).
+
+## Installation
+
+Requirements: Ruby >= 3.2, Tarantool 2.11+ or 3.x, tarantool/crud module installed on routers (tested with 1.8.0).
+
+```ruby
+gem 'tarantool-crud'
+```
+
+```ruby
+require 'tarantool/crud'
+```
+
+crud must be installed and initialised on the routers the client connects to.
+
+## Usage
+
+```ruby
+pool = Tarantool::Client::Pool.new(['tcp://app:secret@router-1:3301', 'tcp://app:secret@router-2:3301'])
+crud = Tarantool::Crud::Client.new(pool, read: { mode: 'read', balance: true }, write: {}, timeout_margin: 0.5)
+users = crud.space(:users)
+
+users.insert([1, nil, 'a@b.c', 20])                  # crud.insert
+users.insert({ id: 1, email: 'a@b.c', age: 20 })     # crud.insert_object
+users.get(1)                                         # => { id: 1, bucket_id: 7, email: "a@b.c", age: 20 } or nil
+users.update(1, [['+', 'age', 1]])
+users.upsert({ id: 1, email: 'a@b.c', age: 20 }, [['+', 'age', 1]])  # => nil
+users.delete(1)
+
+page = users.select({ age: 18.. }, first: 50)        # Result
+users.select({ age: 18.. }, first: 50, after: page.last)  # after: accepts a Hash row or a tuple Array
+users.each({ age: 18.. }, batch_size: 500) { |row| } # Enumerator without a block; batch_size is the page size of underlying selects
+users.count({ age: 18...65 })
+users.min(:age_index)
+users.len
+users.truncate
+
+result = users.insert_many(rows)                     # ManyResult, never raises crud errors
+result.errors                                        # [Tarantool::Crud::CallError, ...] with #operation_data
+users.insert_many!(rows)                             # raises Tarantool::Crud::ManyError
+
+pairs = [
+  [{ id: 1, email: 'a@b.c', age: 20 }, [['+', 'age', 1]]],
+  [{ id: 2, email: 'b@c.d', age: 25 }, [['+', 'age', 1]]],
+]
+users.upsert_many(pairs)                             # each element is [tuple, operations]
+
+crud.storage_info
+crud.stats(:users)
+```
+
+Any object responding to `call(function, arguments, timeout:)` can serve as the transport: `Tarantool::Client` or
+`Tarantool::Client::Pool`.
+
+Write Hash tuples and Hash conditions with braces. Bare `key: value` arguments are crud options.
+
+## Results
+
+`select` returns a `Result`: Enumerable of Hash rows (Symbol keys, taken from crud's metadata), plus `tuples`
+(raw Arrays), `metadata`, `first`, `last`, `size`, `empty?`. `each` yields the same Hash rows page by page, and
+returns an Enumerator without a block. Single-row operations (`get`, `insert`, `update`, ...) return a Hash row or
+`nil`, not a `Result`; `upsert` always returns `nil`.
+
+`insert_many`/`replace_many`/`upsert_many` return a `ManyResult`, which adds `errors` and `success?`. If the whole
+call fails (missing space, empty row list, ...), crud reports it as `InsertManyError`/`ReplaceManyError`/
+`UpsertManyError` inside `errors` with no rows, rather than raising.
+
+## Conditions
+
+An Array of `[operator, field, value]` or a Hash:
+
+| Hash value | Conditions |
+|---|---|
+| `18` | `['==', 'age', 18]` |
+| `18..65` | `['>=', 'age', 18], ['<=', 'age', 65]` |
+| `18...65` | `['>=', 'age', 18], ['<', 'age', 65]` |
+| `18..` / `..65` / `...65` | `['>=', 'age', 18]` / `['<=', 'age', 65]` / `['<', 'age', 65]` |
+
+## Options
+
+Keyword options go to crud unchanged. `timeout:` is also used as the request timeout plus `timeout_margin`.
+
+`read:` defaults apply to `get select each count min max len storage_info stats`. `write:` defaults apply to the
+other operations. crud rejects options a function does not know, so a default is sent only to functions that accept
+it: `prefer_replica`/`balance` skip `min`/`max`, and `truncate` gets only `timeout`/`vshard_router`. Options given
+to a call are never filtered. Use Symbol keys.
+
+`stats` takes only `timeout:` and sends crud no options: the given or default timeout, plus `timeout_margin`, only
+bounds the request.
+
+The `mode:` option here is the crud/vshard router option (`'read'` or `'write'` strings), not the `Pool` routing mode (which uses symbols like `:prefer_ro`).
+
+## Errors
+
+`Tarantool::Crud::Error` has `message` (the crud error message), `str` (crud's `tostring` of the full error, e.g. `"InsertError: ..."`), `class_name`, `file`, `line`, and `operation_data`. Subclasses: `InsertError`,
+`ReplaceError`, `UpsertError`, `GetError`, `UpdateError`, `DeleteError`, `SelectError`, `CountError`, `MinMaxError`,
+`LenError`, `TruncateError`, `CallError`, `InsertManyError`, `ReplaceManyError`, `UpsertManyError`.
+`Tarantool::Crud::ManyError` is a separate `Tarantool::Error` subclass raised by the `*_many!` bang variants; it
+carries `result` (and `errors`), not the crud error fields. Transport and server errors from tarantool-client
+propagate unchanged.
+
+A crud `timeout:` that runs out on the router arrives as the function's `Crud::*Error` with "Timeout exceeded"
+in the message. Only a request that gets no answer within the transport timeout (`timeout:` plus
+`timeout_margin`) raises `Tarantool::TimeoutError`.
+
+## Development
+
+```sh
+podman compose -f tarantool-crud/docker-compose.yml up -d --wait --build
+cd tarantool-crud
+INTEGRATION=1 TARANTOOL_CRUD_URI=tcp://app:secret@localhost:3311 bundle exec rspec
+```
+
+## Public API
+
+`Tarantool::Crud::Client`, `Space`, `Result`, `ManyResult`, and the error classes above.
+
+Everything else, including anything tagged `@api private` in its source comment, is an implementation detail
+and may change in any release.

data/lib/tarantool/crud/call.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # One crud.<function> invocation: merges defaults, sets the transport timeout, unpacks errors.
+    # @api private
+    class Call
+      def initialize(caller, defaults:, timeout_margin:)
+        @caller = caller
+        @defaults = defaults
+        @timeout_margin = timeout_margin
+      end
+
+      def value(function, arguments, options)
+        result, error = perform(function, arguments, options)
+        raise Error.from(error) if error
+
+        result
+      end
+
+      def many(function, arguments, options) = ManyResult.from_crud(*perform(function, arguments, options))
+
+      # For functions that take no options: the timeout, given or default, bounds only the transport.
+      def without_options(function, arguments, timeout)
+        timeout ||= @defaults.options_for(function)[:timeout]
+
+        @caller.call("crud.#{function}", arguments, timeout: transport_timeout(timeout))
+      end
+
+      private
+
+      def perform(function, arguments, options)
+        options = @defaults.options_for(function).merge(options)
+
+        @caller.call("crud.#{function}", [*arguments, options], timeout: transport_timeout(options[:timeout]))
+      end
+
+      def transport_timeout(timeout) = timeout && (timeout + @timeout_margin)
+    end
+  end
+end

data/lib/tarantool/crud/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Entry point: crud functions over any caller responding to call(function, arguments, timeout:).
+    class Client
+      def initialize(caller, read: {}, write: {}, timeout_margin: 0.5)
+        @call = Call.new(caller, defaults: Defaults.new(read:, write:), timeout_margin:)
+      end
+
+      def space(name) = Space.new(name, @call)
+
+      def storage_info(**options) = @call.value('storage_info', [], options)
+
+      # crud.stats takes no options and encodes an empty table as an Array.
+      def stats(space = nil, timeout: nil)
+        stats = @call.without_options('stats', [space&.to_s].compact, timeout).first
+
+        stats.is_a?(Hash) ? stats : {}
+      end
+    end
+  end
+end

data/lib/tarantool/crud/conditions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Converts Array or Hash conditions into crud's [[operator, field, value]] form.
+    # @api private
+    module Conditions
+      OPERATORS = %w[< <= == = >= >].freeze
+
+      class << self
+        def build(conditions)
+          case conditions
+          when nil then nil
+          when Hash then conditions.flat_map { |field, value| from_pair(field.to_s, value) }
+          else conditions.map { |operator, field, value| [check(operator.to_s), stringify(field), value] }
+          end
+        end
+
+        private
+
+        def from_pair(field, value)
+          return [['==', field, value]] unless value.is_a?(Range)
+
+          bounds = []
+          bounds << ['>=', field, value.begin] unless value.begin.nil?
+          bounds << [value.exclude_end? ? '<' : '<=', field, value.end] unless value.end.nil?
+
+          bounds
+        end
+
+        def check(operator)
+          return operator if OPERATORS.include?(operator)
+
+          raise ArgumentError, "unknown condition operator: #{operator}"
+        end
+
+        def stringify(field) = field.is_a?(Symbol) ? field.to_s : field
+      end
+    end
+  end
+end

data/lib/tarantool/crud/defaults.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Client-wide read and write options. crud rejects options a function does not know, so defaults are
+    # narrowed to what each function accepts (crud 1.8.0); options given to a call are sent as is.
+    # @api private
+    class Defaults
+      READ_FUNCTIONS = %w[get select count min max len storage_info stats].freeze
+
+      READ = %i[timeout request_timeout bucket_id prefer_replica balance mode vshard_router].freeze
+      BORDERS = %i[timeout request_timeout fields mode vshard_router fetch_latest_metadata].freeze
+      SERVICE = %i[timeout vshard_router].freeze
+      WRITE = %i[timeout bucket_id fields vshard_router noreturn fetch_latest_metadata].freeze
+      TUPLE = (WRITE + %i[add_space_schema_hash]).freeze
+      OBJECT = (TUPLE + %i[skip_nullability_check_on_flatten]).freeze
+      MANY = %i[timeout fields stop_on_error rollback_on_error vshard_router noreturn fetch_latest_metadata].freeze
+      TUPLE_MANY = (MANY + %i[add_space_schema_hash]).freeze
+      OBJECT_MANY = (MANY + %i[skip_nullability_check_on_flatten]).freeze
+
+      ACCEPTED = {
+        'get' => READ + %i[fields fetch_latest_metadata],
+        'select' => READ + %i[after first batch_size force_map_call fields fullscan fetch_latest_metadata
+                              readview readview_info yield_every],
+        'count' => READ + %i[force_map_call fullscan yield_every],
+        'min' => BORDERS,
+        'max' => BORDERS,
+        'len' => READ - %i[bucket_id],
+        'storage_info' => SERVICE,
+        'stats' => %i[timeout],
+        'truncate' => SERVICE,
+        'insert' => TUPLE,
+        'insert_object' => OBJECT,
+        'replace' => TUPLE,
+        'replace_object' => OBJECT,
+        'upsert' => TUPLE,
+        'upsert_object' => TUPLE,
+        'update' => WRITE,
+        'delete' => WRITE,
+        'insert_many' => TUPLE_MANY,
+        'insert_object_many' => OBJECT_MANY,
+        'replace_many' => TUPLE_MANY,
+        'replace_object_many' => OBJECT_MANY,
+        'upsert_many' => TUPLE_MANY,
+        'upsert_object_many' => MANY
+      }.freeze
+
+      def initialize(read:, write:)
+        @read = read
+        @write = write
+      end
+
+      def options_for(function)
+        (READ_FUNCTIONS.include?(function) ? @read : @write).slice(*ACCEPTED.fetch(function))
+      end
+    end
+  end
+end

data/lib/tarantool/crud/errors.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Error returned by a crud function; the message is crud's err field.
+    class Error < Tarantool::Error
+      attr_reader :class_name, :str, :file, :line, :operation_data
+
+      # @api private
+      def self.from(error)
+        CLASSES.fetch(error['class_name'], Error).new(
+          error['err'],
+          class_name: error['class_name'], str: error['str'], file: error['file'], line: error['line'],
+          operation_data: error['operation_data']
+        )
+      end
+
+      def initialize(message = nil, class_name: nil, str: nil, file: nil, line: nil, operation_data: nil)
+        super(message)
+        @class_name = class_name
+        @str = str
+        @file = file
+        @line = line
+        @operation_data = operation_data
+      end
+    end
+
+    class InsertError < Error; end
+    class ReplaceError < Error; end
+    class UpsertError < Error; end
+    class GetError < Error; end
+    class UpdateError < Error; end
+    class DeleteError < Error; end
+    class SelectError < Error; end
+    class CountError < Error; end
+    class MinMaxError < Error; end
+    class LenError < Error; end
+    class TruncateError < Error; end
+
+    # One row of a *_many call failed; operation_data holds that row.
+    class CallError < Error; end
+
+    # A whole *_many call failed before any row was processed.
+    class InsertManyError < Error; end
+    class ReplaceManyError < Error; end
+    class UpsertManyError < Error; end
+
+    # Raised by *_many! when any row failed; result holds the rows that were written.
+    # An aggregate, not one crud function error, hence not a Crud::Error.
+    class ManyError < Tarantool::Error
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+        super("#{result.errors.size} crud operation(s) failed, first: #{result.errors.first.message}")
+      end
+
+      def errors = result.errors
+    end
+
+    class Error
+      CLASSES = {
+        'InsertError' => InsertError,
+        'ReplaceError' => ReplaceError,
+        'UpsertError' => UpsertError,
+        'GetError' => GetError,
+        'UpdateError' => UpdateError,
+        'DeleteError' => DeleteError,
+        'SelectError' => SelectError,
+        'CountError' => CountError,
+        'BorderError' => MinMaxError,
+        'LenError' => LenError,
+        'TruncateError' => TruncateError,
+        'CallError' => CallError,
+        'InsertManyError' => InsertManyError,
+        'ReplaceManyError' => ReplaceManyError,
+        'UpsertManyError' => UpsertManyError
+      }.freeze
+      private_constant :CLASSES
+    end
+  end
+end

data/lib/tarantool/crud/many_result.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Result of a *_many call: the rows written plus the errors of the rows that failed.
+    class ManyResult < Result
+      attr_reader :errors
+
+      # @api private
+      def self.from_crud(response, errors = nil)
+        super(response, errors: Array(errors).map { |error| Error.from(error) })
+      end
+
+      # @api private
+      def initialize(errors:, **)
+        super(**)
+        @errors = errors
+      end
+
+      def success? = errors.empty?
+    end
+  end
+end

data/lib/tarantool/crud/result.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Rows returned by a crud function, as Hashes keyed by field name.
+    class Result
+      include Enumerable
+
+      attr_reader :metadata, :tuples
+
+      # @api private
+      def self.from_crud(response, **)
+        response ||= {}
+
+        new(metadata: response.fetch('metadata', []).map { |field| field.transform_keys(&:to_sym) },
+            tuples: response.fetch('rows', []), **)
+      end
+
+      # @api private
+      def initialize(metadata:, tuples:)
+        @metadata = metadata
+        @tuples = tuples
+        names = metadata.map { |field| field[:name].to_sym }
+        @rows = tuples.map { |tuple| names.zip(tuple).to_h }
+      end
+
+      def each(&) = @rows.each(&)
+
+      def last = @rows.last
+
+      def size = @rows.size
+
+      def empty? = @rows.empty?
+    end
+  end
+end

data/lib/tarantool/crud/scan.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Iterates a select batch by batch, continuing after the last tuple until a short batch arrives.
+    # @api private
+    class Scan
+      def initialize(space, conditions, batch_size:, options:)
+        raise ArgumentError, 'batch_size must be positive' unless batch_size.positive?
+
+        @space = space
+        @conditions = conditions
+        @batch_size = batch_size
+        @options = options
+      end
+
+      def each(&block)
+        return to_enum(:each) unless block_given?
+
+        options = @options.merge(first: @batch_size)
+
+        loop do
+          batch = @space.select(@conditions, **options)
+          batch.each(&block)
+          break if batch.size < @batch_size
+
+          options = options.merge(after: batch.tuples.last)
+        end
+      end
+    end
+  end
+end

data/lib/tarantool/crud/space.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    # Operations on one sharded space; Hash rows go to the *_object crud variants.
+    class Space
+      attr_reader :name
+
+      def initialize(name, call)
+        @name = name.to_s
+        @call = call
+      end
+
+      def insert(tuple, **) = row(variant('insert', tuple), tuple, **)
+
+      def replace(tuple, **) = row(variant('replace', tuple), tuple, **)
+
+      def upsert(tuple, operations, **) = row(variant('upsert', tuple), tuple, operations, **)
+
+      def get(key, **) = row('get', key, **)
+
+      def update(key, operations, **) = row('update', key, operations, **)
+
+      def delete(key, **) = row('delete', key, **)
+
+      def min(index = nil, **) = row('min', index, **)
+
+      def max(index = nil, **) = row('max', index, **)
+
+      def select(conditions = nil, **options)
+        options[:after] = options[:after].values if options[:after].is_a?(Hash)
+
+        Result.from_crud(value('select', Conditions.build(conditions), **options))
+      end
+
+      def each(conditions = nil, batch_size: 1000, **options, &)
+        Scan.new(self, conditions, batch_size:, options:).each(&)
+      end
+
+      def count(conditions = nil, **) = value('count', Conditions.build(conditions), **)
+
+      def len(**) = value('len', **)
+
+      def truncate(**) = value('truncate', **)
+
+      def insert_many(rows, **) = many(many_variant('insert', rows), rows, **)
+
+      def replace_many(rows, **) = many(many_variant('replace', rows), rows, **)
+
+      def upsert_many(pairs, **) = many(many_variant('upsert', pairs.map(&:first)), pairs, **)
+
+      def insert_many!(rows, **) = successful(insert_many(rows, **))
+
+      def replace_many!(rows, **) = successful(replace_many(rows, **))
+
+      def upsert_many!(pairs, **) = successful(upsert_many(pairs, **))
+
+      private
+
+      def value(function, *arguments, **options) = @call.value(function, [name, *arguments], options)
+
+      def row(...) = Result.from_crud(value(...)).first
+
+      def variant(function, tuple) = tuple.is_a?(Hash) ? "#{function}_object" : function
+
+      def many(function, rows, **options) = @call.many(function, [name, rows], options)
+
+      def many_variant(function, rows)
+        kinds = rows.map { |row| row.is_a?(Hash) }.uniq
+        raise ArgumentError, 'rows must be all Arrays or all Hashes' if kinds.size > 1
+
+        kinds.first ? "#{function}_object_many" : "#{function}_many"
+      end
+
+      def successful(result)
+        raise ManyError, result unless result.success?
+
+        result
+      end
+    end
+  end
+end

data/lib/tarantool/crud/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Crud
+    VERSION = '0.1.0'
+  end
+end

data/lib/tarantool/crud.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'tarantool/client'
+
+require_relative 'crud/version'
+require_relative 'crud/errors'
+require_relative 'crud/conditions'
+require_relative 'crud/result'
+require_relative 'crud/many_result'
+require_relative 'crud/defaults'
+require_relative 'crud/call'
+require_relative 'crud/scan'
+require_relative 'crud/space'
+require_relative 'crud/client'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: tarantool-crud
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Starlexxx
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tarantool-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Per-space CRUD, conditions, pagination and batch operations over the
+  tarantool/crud module for vshard clusters on Tarantool 2.11+ and 3.x, built on tarantool-client.
+email:
+- apavlovskiy088@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/tarantool/crud.rb
+- lib/tarantool/crud/call.rb
+- lib/tarantool/crud/client.rb
+- lib/tarantool/crud/conditions.rb
+- lib/tarantool/crud/defaults.rb
+- lib/tarantool/crud/errors.rb
+- lib/tarantool/crud/many_result.rb
+- lib/tarantool/crud/result.rb
+- lib/tarantool/crud/scan.rb
+- lib/tarantool/crud/space.rb
+- lib/tarantool/crud/version.rb
+homepage: https://github.com/Starlexxx/tarantool-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Starlexxx/tarantool-ruby/tree/master/tarantool-crud
+  changelog_uri: https://github.com/Starlexxx/tarantool-ruby/blob/master/tarantool-crud/CHANGELOG.md
+  bug_tracker_uri: https://github.com/Starlexxx/tarantool-ruby/issues
+  homepage_uri: https://github.com/Starlexxx/tarantool-ruby
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby wrapper over tarantool/crud for sharded Tarantool clusters
+test_files: []