tantiny 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e082705a8a556a2bf8ebfd08445ea2917e308a1fdd80e2e2dcf75edaa71bc135
-  data.tar.gz: 2098370ed2edcf0aa533abf3327ba4513f76fdf1119ba6f007de68d162510897
+  metadata.gz: 6d0f8d182809f2ef16cea118c6afa3537ce75088eb660491bbf62f88cabf8f9a
+  data.tar.gz: 1194fe1dcd4167e165a27612aab27dae0c3564f2f3dc629cadd23319780c7e4f
 SHA512:
-  metadata.gz: 76171526e6677a13874d8cb2b915496eb844ac120404f220440552d00217b059f3ac55f329318ec020249ec4106a2977ee7251a9c526c0fa237077be8401c937
-  data.tar.gz: 4425ba8f9a882b9e6b2b9eb7c4d0d8aa4a87342249fd0588fd2d82a6f0c8f709fcc2ee5e22e63b66b84256c398decb2a7a207414636cf6d588c64a63c85a496f
+  metadata.gz: 220af19fd88b94bfad830f709607fcf394423c23a7c6ad2b25efe459298e26bcddba3bd8516f8a7719bfd532e4b9b4964136be0521c7d7414409063842eadfb1
+  data.tar.gz: 2bca8e05530015a86b97eb7f0f9cc5dd755de5691c104c6247742baf2d11d5c0ee2843fd634acd3ac25823c5d1ddddc0eeda5a6dcdca41e0bbf89143b1104e21

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.3.0](https://github.com/baygeldin/tantiny/compare/v0.2.2...v0.3.0) (2022-03-17)
+
+
+### ⚠ BREAKING CHANGES
+
+* `commit` method is no longer public
+
+### Features
+
+* Support multithreaded and multiprocess environments ([053b4a0](https://github.com/baygeldin/tantiny/commit/053b4a0a026ae8fd689d95a8d4f3b1a7b6d6779f))
+
+
+### Bug Fixes
+
+* Create the folder at index path when it doesn't exist ([c9446b7](https://github.com/baygeldin/tantiny/commit/c9446b7e949aad40de9ce179707a88915682055c))
+
 ### [0.2.2](https://github.com/baygeldin/tantiny/compare/v0.2.1...v0.2.2) (2022-03-07)
 
 

data/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tantiny"
-version = "0.2.2" # {x-release-please-version}
+version = "0.3.0" # {x-release-please-version}
 edition = "2021"
 authors = ["Alexander Baygeldin"]
 repository = "https://github.com/baygeldin/tantiny"

data/README.md

@@ -1,10 +1,15 @@
+[![Build workflow](https://github.com/baygeldin/tantiny/actions/workflows/build.yml/badge.svg)](https://github.com/baygeldin/tantiny/actions/workflows/build.yml)
+[![Tantiny](https://img.shields.io/gem/v/tantiny?color=31c553)](https://rubygems.org/gems/tantiny)
+[![Maintainability](https://api.codeclimate.com/v1/badges/1b466b52d2ba71ab9d80/maintainability)](https://codeclimate.com/github/baygeldin/tantiny/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/1b466b52d2ba71ab9d80/test_coverage)](https://codeclimate.com/github/baygeldin/tantiny/test_coverage)
+
 # Tantiny
 
 Need a fast full-text search for your Ruby script, but Solr and Elasticsearch are an overkill? 😏
 
-You're in the right place. **Tantiny** is a minimalistic full-text search library for Ruby based on [Tantivy](https://github.com/quickwit-oss/tantivy) (an awesome alternative to Apache Lucene written in Rust). The greatest advantage of using it is that you don't need *anything* to make it work (no separate server or process), it's purely embeddable. So, if your task at hand requires a full-text search, but a full-blown distributed search engine would be an overkill, Tantiny would be perfect for you.
+You're in the right place. **Tantiny** is a minimalistic full-text search library for Ruby based on [Tanti**v**y](https://github.com/quickwit-oss/tantivy) (an awesome alternative to Apache Lucene written in Rust). It's great for cases when your task at hand requires a full-text search, but configuring a full-blown distributed search engine would take more time than the task itself. And even if you already use such an engine in your project (which is highly likely, actually), it still might be easier to just use Tantiny instead because unlike Solr and Elasticsearch it doesn't need *anything* to work (no separate server or process or whatever), it's purely embeddable. So, when you find yourself in a situation when using your search engine of choice would be tricky/inconvinient or would require additional setup you can always revert back to a quick and dirty solution that is nontheless flexible and fast.
 
-The main philosophy is to provide low-level access Tantivy's inverted index, but with a nice Ruby-esque API, sensible defaults, and additional functionality sprinkled on top (so, Tantiny not exactly bindings to Tantivy, but it tries to be close).
+Tantiny is not exactly Ruby bindings to Tantivy, but it tries to be close. The main philosophy is to provide low-level access to Tantivy's inverted index, but with a nice Ruby-esque API, sensible defaults, and additional functionality sprinkled on top.
 
 Take a look at the most basic example:
 
@@ -15,7 +20,6 @@ index << { id: 1, description: "Hello World!" }
 index << { id: 2, description: "What's up?" }
 index << { id: 3, description: "Goodbye World!" }
 
-index.commit
 index.reload
 
 index.search("world") # 1, 3
@@ -26,7 +30,7 @@ index.search("world") # 1, 3
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tantiny'
+gem "tantiny"
 ```
 
 And then execute:
@@ -39,6 +43,10 @@ Or install it yourself as:
 
 You don't **have to** have Rust installed on your system since Tantiny will try to download the pre-compiled binaries hosted on GitHub releases during the installation. However, if no pre-compiled binaries were found for your system (which is a combination of platform, architecture, and Ruby version) you will need to [install Rust](https://www.rust-lang.org/tools/install) first.
 
+⚠️ **IMPORTANT** ⚠️
+
+Please, make sure to specify the minor version when declaring dependency on `tantiny`. The API is a subject to change, and until it reaches `1.0.0` a bump in the minor version will most likely signify a breaking change. 
+
 ## Defining the index
 
 You have to specify a path to where the index would be stored and a block that defines the schema:
@@ -82,6 +90,8 @@ rio_bravo = OpenStruct.new(
   release_date: Date.parse("March 18, 1959")
 )
 
+index << rio_bravo
+
 hanabi = {
   imdb_id: "tt0119250",
   type: "/crime/Japan",
@@ -92,6 +102,8 @@ hanabi = {
   release_date: Date.parse("December 1, 1998")
 }
 
+index << hanabi
+
 brother = {
   imdb_id: "tt0118767",
   type: "/crime/Russia",
@@ -102,8 +114,6 @@ brother = {
   release_date: Date.parse("December 12, 1997")
 }
 
-index << rio_bravo
-index << hanabi
 index << brother
 ```
 
@@ -120,12 +130,32 @@ You can also delete it if you want:
 index.delete(rio_bravo.imdb_id)
 ```
 
-After that you need to commit the index for the changes to take place:
+### Transactions
+
+If you need to perform multiple writing operations (i.e. more than one) you should always use `transaction`:
 
 ```ruby
-index.commit
+index.transaction do
+  index << rio_bravo
+  index << hanabi
+  index << brother
+end
 ```
 
+Transactions group changes and [commit](https://docs.rs/tantivy/latest/tantivy/struct.IndexWriter.html#method.commit) them to the index in one go. This is *dramatically* more efficient than performing these changes one by one. In fact, all writing operations (i.e. `<<` and `delete`) are wrapped in a transaction implicitly when you call them outside of a transaction, so calling `<<` 10 times outside of a transaction is the same thing as performing 10 separate transactions. 
+
+### Concurrency and thread-safety
+
+Tantiny is thread-safe meaning that you can safely share a single instance of the index between threads. You can also spawn separate processes that could write to and read from the same index. However, while reading from the index should be parallel, writing to it is **not**. Whenever you call `transaction` or any other operation that modify the index (i.e. `<<` and `delete`) it will lock the index for the duration of the operation or wait for another process or thread to release the lock. The only exception to this is when there is another process with an index with an exclusive writer running somewhere in which case the methods that modify the index will fail immediately.
+
+Thus, it's best to have a single writer process and many reader processes if you want to avoid blocking calls. The proper way to do this is to set `exclusive_writer` to `true` when initializing the index:
+
+```ruby
+index = Tantiny::Index.new("/path/to/index", exclusive_writer: true) {}
+```
+
+This way the [index writer](https://docs.rs/tantivy/latest/tantivy/struct.IndexWriter.html) will only be acquired once which means the memory for it and indexing threads will only be allocated once as well. Otherwise a new index writer is acquired every time you perform a writing operation.
+
 ## Searching
 
 Make sure that your index is up-to-date by reloading it first:
@@ -190,7 +220,7 @@ All queries can search on multuple fields (except for `facet_query` because it d
 So, the following query:
 
 ```ruby
-index.term_query(%i[title, description], "hello")
+index.term_query(%i[title description], "hello")
 ```
 
 Is equivalent to:
@@ -296,7 +326,7 @@ You may have noticed that `search` method returns only documents ids. This is by
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake build` to build native extensions, and then `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 We use [conventional commits](https://www.conventionalcommits.org) to automatically generate the CHANGELOG, bump the semantic version, and to publish and release the gem. All you need to do is stick to the convention and [CI will take care of everything else](https://github.com/baygeldin/tantiny/blob/main/.github/workflows/release.yml) for you.
 

data/bin/console

@@ -7,9 +7,13 @@ require "pry"
 require "tantiny"
 
 path = File.join(__dir__, "../tmp")
-en_stem = Tantiny::Tokenizer.new(:stemmer, language: :en)
 
-index = Tantiny::Index.new path, tokenizer: en_stem do
+options = {
+  tokenizer: Tantiny::Tokenizer.new(:stemmer, language: :en),
+  exclusive_writer: true,
+}
+
+index = Tantiny::Index.new(path, **options) do
   id :imdb_id
   facet :category
   string :title
@@ -49,11 +53,12 @@ brother = {
   release_date: Date.parse("December 12, 1997")
 }
 
-index << rio_bravo
-index << hanabi
-index << brother
+index.transaction do
+  index << rio_bravo
+  index << hanabi
+  index << brother
+end
 
-index.commit 
 index.reload
 
 binding.pry

data/ext/Rakefile

@@ -1,5 +1,5 @@
 require "thermite/tasks"
 
-project_dir = File.dirname(File.dirname(__FILE__))
+project_dir = File.dirname(__FILE__, 2)
 Thermite::Tasks.new(cargo_project_path: project_dir, ruby_project_path: project_dir)
 task default: %w[thermite:build]

data/lib/tantiny/errors.rb

@@ -3,9 +3,18 @@
 module Tantiny
   class TantivyError < StandardError; end
 
-  class UnknownField < StandardError
+  class IndexWriterBusyError < StandardError
     def initialize
-      super("Can't find the specified field in the schema.")
+      msg = "Failed to acquire an index writer. "\
+        "Is there an active index with an exclusive writer already?"
+
+      super(msg)
+    end
+  end
+
+  class UnexpectedNone < StandardError
+    def initialize(type)
+      super("Didn't expect Option<#{type}> to be empty.")
     end
   end
 

data/lib/tantiny/helpers.rb

@@ -5,5 +5,15 @@ module Tantiny
     def self.timestamp(date)
       date.to_datetime.iso8601
     end
+
+    def self.with_lock(lockfile)
+      File.open(lockfile, File::CREAT) do |file|
+        file.flock(File::LOCK_EX)
+
+        yield
+
+        file.flock(File::LOCK_UN)
+      end
+    end
   end
 end

data/lib/tantiny/index.rb

@@ -2,18 +2,18 @@
 
 module Tantiny
   class Index
-    DEFAULT_INDEX_SIZE = 50_000_000
+    LOCKFILE = ".tantiny.lock"
+    DEFAULT_WRITER_MEMORY = 5_000_000 # 5MB
     DEFAULT_LIMIT = 10
 
     def self.new(path, **options, &block)
-      index_size = options[:size] || DEFAULT_INDEX_SIZE
-      default_tokenizer = options[:tokenizer] || Tokenizer.default
+      FileUtils.mkdir_p(path)
 
+      default_tokenizer = options[:tokenizer] || Tokenizer.default
       schema = Schema.new(default_tokenizer, &block)
 
       object = __new(
         path.to_s,
-        index_size,
         schema.default_tokenizer,
         schema.field_tokenizers.transform_keys(&:to_s),
         schema.text_fields.map(&:to_s),
@@ -24,15 +24,40 @@ module Tantiny
         schema.facet_fields.map(&:to_s)
       )
 
-      object.send(:schema=, schema)
+      object.send(:initialize, path, schema, **options)
 
       object
     end
 
+    def initialize(path, schema, **options)
+      @path = path
+      @schema = schema
+
+      @indexer_memory = options[:writer_memory] || DEFAULT_WRITER_MEMORY
+      @exclusive_writer = options[:exclusive_writer] || false
+
+      @active_transaction = Concurrent::ThreadLocalVar.new(false)
+      @transaction_semaphore = Mutex.new
+
+      acquire_index_writer if exclusive_writer?
+    end
+
     attr_reader :schema
 
-    def commit
-      __commit
+    def transaction
+      if inside_transaction?
+        yield
+      else
+        synchronize do
+          open_transaction!
+
+          yield
+
+          close_transaction!
+        end
+      end
+
+      nil
     end
 
     def reload
@@ -40,19 +65,23 @@ module Tantiny
     end
 
     def <<(document)
-      __add_document(
-        resolve(document, schema.id_field).to_s,
-        slice_document(document, schema.text_fields) { |v| v.to_s },
-        slice_document(document, schema.string_fields) { |v| v.to_s },
-        slice_document(document, schema.integer_fields) { |v| v.to_i },
-        slice_document(document, schema.double_fields) { |v| v.to_f },
-        slice_document(document, schema.date_fields) { |v| Helpers.timestamp(v) },
-        slice_document(document, schema.facet_fields) { |v| v.to_s }
-      )
+      transaction do
+        __add_document(
+          resolve(document, schema.id_field).to_s,
+          slice_document(document, schema.text_fields) { |v| v.to_s },
+          slice_document(document, schema.string_fields) { |v| v.to_s },
+          slice_document(document, schema.integer_fields) { |v| v.to_i },
+          slice_document(document, schema.double_fields) { |v| v.to_f },
+          slice_document(document, schema.date_fields) { |v| Helpers.timestamp(v) },
+          slice_document(document, schema.facet_fields) { |v| v.to_s }
+        )
+      end
     end
 
     def delete(id)
-      __delete_document(id.to_s)
+      transaction do
+        __delete_document(id.to_s)
+      end
     end
 
     def search(query, limit: DEFAULT_LIMIT, **smart_query_options)
@@ -79,8 +108,6 @@ module Tantiny
 
     private
 
-    attr_writer :schema
-
     def slice_document(document, fields, &block)
       fields.inject({}) do |hash, field|
         hash.tap { |h| h[field.to_s] = resolve(document, field) }
@@ -90,5 +117,56 @@ module Tantiny
     def resolve(document, field)
       document.is_a?(Hash) ? document[field] : document.send(field)
     end
+
+    def acquire_index_writer
+      __acquire_index_writer(@indexer_memory)
+    rescue TantivyError => e
+      case e.message
+      when /Failed to acquire Lockfile/
+        raise IndexWriterBusyError.new
+      else
+        raise
+      end
+    end
+
+    def release_index_writer
+      __release_index_writer
+    end
+
+    def commit
+      __commit
+    end
+
+    def open_transaction!
+      acquire_index_writer unless exclusive_writer?
+
+      @active_transaction.value = true
+    end
+
+    def close_transaction!
+      commit
+
+      release_index_writer unless exclusive_writer?
+
+      @active_transaction.value = false
+    end
+
+    def inside_transaction?
+      @active_transaction.value
+    end
+
+    def exclusive_writer?
+      @exclusive_writer
+    end
+
+    def synchronize(&block)
+      @transaction_semaphore.synchronize do
+        Helpers.with_lock(lockfile_path, &block)
+      end
+    end
+
+    def lockfile_path
+      @lockfile_path ||= File.join(@path, LOCKFILE)
+    end
   end
 end

data/lib/tantiny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tantiny
-  VERSION = "0.2.2" # {x-release-please-version}
+  VERSION = "0.3.0" # {x-release-please-version}
 end

data/lib/tantiny.rb

@@ -4,6 +4,8 @@ require "ruby-next/language/setup"
 RubyNext::Language.setup_gem_load_path
 
 require "rutie"
+require "concurrent"
+require "fileutils"
 
 require "tantiny/version"
 require "tantiny/errors"

data/sig/tantiny/helpers.rbs

@@ -2,5 +2,7 @@
 module Tantiny
   module Helpers
     def self.timestamp: ((Date | DateTime) date) -> String
+
+    def self.with_lock: (String lockfile) { (*untyped) -> void } -> void
   end
 end

data/sig/tantiny/index.rbs

@@ -1,6 +1,7 @@
 module Tantiny
   class Index
-    DEFAULT_INDEX_SIZE: Integer
+    LOCKFILE: String
+    DEFAULT_WRITER_MEMORY: Integer
     DEFAULT_LIMIT: Integer
 
     def self.new: (
@@ -10,7 +11,6 @@ module Tantiny
 
     def self.__new: (
       String path,
-      Integer index_size,
       Tokenizer default_tokenizer,
       Hash[String, Tokenizer] field_tokenizers,
       Array[String] text_fields,
@@ -21,9 +21,16 @@ module Tantiny
       Array[String] facet_fields
     ) -> Index
 
+    def initialize: (
+      String path,
+      Schema schema,
+      **untyped options
+    ) -> void
+
     attr_reader schema: Schema
 
-    def commit: () -> void
+    def transaction: () { (*untyped) -> void } -> void
+
     def reload: () -> void
     def <<: (untyped document) -> void
     def delete: (String id) -> void
@@ -62,9 +69,12 @@ module Tantiny
 
     def __search: (Query query, Integer limit) -> Array[String]
 
+    def __acquire_index_writer: (Integer overall_memory) -> void
+    def __release_index_writer: () -> void
+
     private
 
-    attr_writer schema: Schema
+    def commit: () -> void
 
     def slice_document: (
       untyped document,
@@ -78,5 +88,16 @@ module Tantiny
     ) -> Array[String]
 
     def resolve: (untyped document, Symbol field) -> untyped
+
+    def synchronize: () { (*untyped) -> void } -> void
+    def lockfile_path: () -> String
+
+    def exclusive_writer?: () -> bool
+    def acquire_index_writer: () -> void
+    def release_index_writer: () -> void
+
+    def open_transaction!: () -> void
+    def close_transaction!: () -> void
+    def inside_transaction?: () -> bool
   end
 end

data/src/helpers.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use rutie::{AnyException, Array, Exception, RString, Hash, Integer, Float, Boolean, Module};
-use tantivy::schema::{Field};
 use tantivy::tokenizer::Language;
 
 // Macro dependencies:
@@ -114,12 +113,15 @@ where
     }
 }
 
-impl TryUnwrap<Field> for Option<Field> {
-    fn try_unwrap(self) -> Field {
+impl<T> TryUnwrap<T> for Option<T> {
+    fn try_unwrap(self) -> T {
         if let Some(value) = self {
             value
         } else {
-            VM::raise_ex(AnyException::new("Tantiny::UnknownField", None));
+            VM::raise_ex(AnyException::new(
+                "Tantiny::UnexpectedNone",
+                Some(&*format!("{}", std::any::type_name::<T>())))
+            );
 
             self.unwrap()
         }

data/src/index.rs

@@ -11,9 +11,10 @@ use crate::query::{unwrap_query, RTantinyQuery};
 use crate::tokenizer::{unwrap_tokenizer, RTantinyTokenizer};
 
 pub struct TantinyIndex {
-    pub(crate) index_writer: IndexWriter,
-    pub(crate) index_reader: IndexReader,
     pub(crate) schema: Schema,
+    pub(crate) index: Index,
+    pub(crate) index_writer: Option<IndexWriter>,
+    pub(crate) index_reader: IndexReader,
 }
 
 scaffold!(RTantinyIndex, TantinyIndex, "Index");
@@ -22,6 +23,10 @@ pub(crate) fn unwrap_index(index: &RTantinyIndex) -> &TantinyIndex {
     index.get_data(&*TANTINY_INDEX_WRAPPER)
 }
 
+pub(crate) fn unwrap_index_mut(index: &mut RTantinyIndex) -> &mut TantinyIndex {
+    index.get_data_mut(&*TANTINY_INDEX_WRAPPER)
+}
+
 #[rustfmt::skip::macros(methods)]
 methods!(
     RTantinyIndex,
@@ -29,7 +34,6 @@ methods!(
 
     fn new_index(
         path: RString,
-        index_size: Integer,
         default_tokenizer: AnyObject,
         field_tokenizers: Hash,
         text_fields: Array,
@@ -41,7 +45,6 @@ methods!(
     ) -> RTantinyIndex {
         try_unwrap_params!(
             path: String,
-            index_size: i64,
             default_tokenizer: RTantinyTokenizer,
             field_tokenizers: HashMap<String, RTantinyTokenizer>,
             text_fields: Vec<String>,
@@ -103,9 +106,7 @@ methods!(
             tokenizers.register(&field, unwrap_tokenizer(&tokenizer).clone())
         }
 
-        let mut index_writer = index
-            .writer(index_size as usize)
-            .try_unwrap();
+        let index_writer = None;
 
         let index_reader = index
             .reader_builder()
@@ -114,7 +115,7 @@ methods!(
             .try_unwrap();
         
         klass().wrap_data(
-            TantinyIndex { index_writer, index_reader, schema },
+            TantinyIndex { index, index_writer, index_reader, schema },
             &*TANTINY_INDEX_WRAPPER
         )
     }
@@ -138,9 +139,8 @@ methods!(
             facet_fields: HashMap<String, String>
         );
 
-        
         let internal = unwrap_index(&_itself);
-        let index_writer = &internal.index_writer;
+        let index_writer = internal.index_writer.as_ref().try_unwrap();
         let schema = &internal.schema;
 
         let mut doc = Document::default();
@@ -191,7 +191,7 @@ methods!(
         try_unwrap_params!(id: String);
 
         let internal = unwrap_index(&_itself);
-        let index_writer = &internal.index_writer;
+        let index_writer = internal.index_writer.as_ref().unwrap();
 
         let id_field = internal.schema.get_field("id").try_unwrap();
         let doc_id = Term::from_field_text(id_field, &id);
@@ -201,9 +201,34 @@ methods!(
         NilClass::new()
     }
 
+    fn acquire_index_writer(
+        overall_memory: Integer
+    ) -> NilClass {
+        try_unwrap_params!(overall_memory: i64);
+
+        let internal = unwrap_index_mut(&mut _itself);
+
+        let mut index_writer = internal.index
+            .writer(overall_memory as usize)
+            .try_unwrap();
+
+        internal.index_writer = Some(index_writer);
+
+        NilClass::new()
+    }
+
+    fn release_index_writer() -> NilClass {
+        let internal = unwrap_index_mut(&mut _itself);
+
+        drop(internal.index_writer.as_ref().try_unwrap());
+        internal.index_writer = None;
+
+        NilClass::new()
+    }
+
     fn commit() -> NilClass {
-        let internal = _itself.get_data_mut(&*TANTINY_INDEX_WRAPPER);
-        let index_writer = &mut internal.index_writer;
+        let internal = unwrap_index_mut(&mut _itself);
+        let index_writer = internal.index_writer.as_mut().try_unwrap();
 
         index_writer.commit().try_unwrap();
 
@@ -254,6 +279,8 @@ pub(super) fn init() {
         klass.def_self("__new", new_index);
         klass.def("__add_document", add_document);
         klass.def("__delete_document", delete_document);
+        klass.def("__acquire_index_writer", acquire_index_writer);
+        klass.def("__release_index_writer", release_index_writer);
         klass.def("__commit", commit);
         klass.def("__reload", reload);
         klass.def("__search", search);

data/src/lib.rs

@@ -3,7 +3,6 @@ mod helpers;
 mod index;
 #[allow(improper_ctypes_definitions)]
 mod query;
-
 #[allow(improper_ctypes_definitions)]
 mod tokenizer;
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tantiny
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Baygeldin
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next
@@ -66,7 +66,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
 email:
 - a.baygeldin@gmail.com
 executables: []
@@ -83,7 +97,6 @@ files:
 - ext/Rakefile
 - lib/.rbnext/3.0/tantiny/schema.rb
 - lib/tantiny.rb
-- lib/tantiny.so
 - lib/tantiny/errors.rb
 - lib/tantiny/helpers.rb
 - lib/tantiny/index.rb
@@ -113,7 +126,7 @@ metadata:
   documentation_uri: https://github.com/baygeldin/tantiny/blob/master/README.md
   homepage_uri: https://github.com/baygeldin/tantiny
   source_code_uri: https://github.com/baygeldin/tantiny
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -129,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.7
-signing_key:
+signing_key: 
 specification_version: 4
 summary: Tiny full-text search for Ruby powered by Tantivy.
 test_files: []