redisearch-rb 0.1.7 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 989e86efdc440fc616ee1741256c81b829ca69b0
-  data.tar.gz: 2f2d59a65e355750b045f317dc7e6619d120bb0b
+SHA256:
+  metadata.gz: 99d803efbd160ce83d3cf58a50b2e739540f143666dc87f18b04c3ff10766577
+  data.tar.gz: d83a8a81049e5b6266130f351d2c82381b12abaf93c1f616e7d602b2503d5abb
 SHA512:
-  metadata.gz: 3b61fc7f81b2d86c33142c3c01a3b2b79647b5d40c0f5cfdca094ac9710104c439e153f8c8ab68a29503c97cbedc64a7f440824e02521051f7b0a304a59c25e4
-  data.tar.gz: 9208b2b791c07ce5a0dc7b700e9cefc99030a255444500a5bc99103a053b6af167baa17a14120cd7111c8b55a6804bb65ad81e393406a6e642a4a28a6f2f0253
+  metadata.gz: abf6a993f32a3c93979763b3cf22e72a959fffd3d14c8ccf2fa44031b5f1c65a30ddad8715c1226ff7467f2b3ad4146be3edc806248073ec5e6926f75fc233fe
+  data.tar.gz: 524ed525611003f0ef515d2eee40ab4a4fcdef851083fa75b053011c1219187f1c2d1ff22c7d3fb6e456b7c53e6a0af42d12f9f6b32701bd91f0ea9a4d8be568

data/.travis.yml

@@ -7,12 +7,14 @@ before_install:
 - gem install bundler -v 1.14.6
 - git clone --depth 10 https://github.com/antirez/redis.git
 - cd redis
-- git fetch origin 4.0.1
-- git checkout ae43e164d4b09d7753e27bb7cba6f7f4f85326b3
+- git fetch && git fetch --tags
+- git checkout 4.0.6
 - make
 - cd ..
 - git clone --depth 1 https://github.com/RedisLabsModules/RediSearch.git
-- cd RediSearch/src
+- cd RediSearch
+- git fetch && git fetch --tags
+- git checkout v1.2.0
 - make all
-- ls -la *.so
 - cd ..
+

data/Gemfile

@@ -1,11 +1,11 @@
 source 'https://rubygems.org'
 
-ruby '2.4.1'
-
-gem 'redis', '~> 4.0.0.rc1'
+ruby '>=2.4.1'
 
+gem 'redis', '~> 4.0.1'
 group :development, :test do
   gem 'dotenv'
+  gem 'rake'
   gem 'subprocess'
   gem 'minitest', '~> 5.0'
 end

data/README.md

@@ -1,4 +1,5 @@
-[![Gem Version](https://badge.fury.io/rb/redisearch-rb.svg)](https://badge.fury.io/rb/redisearch-rb) ![travis-ci](https://travis-ci.org/vruizext/redisearch-rb.svg?branch=master)
+[![Gem Version](https://badge.fury.io/rb/redisearch-rb.svg)](https://badge.fury.io/rb/redisearch-rb) 
+[![travis-ci](https://travis-ci.org/vruizext/redisearch-rb.svg?branch=master)](https://travis-ci.org/vruizext/redisearch-rb)
 
 # redisearch-rb
 
@@ -10,8 +11,8 @@ http://redisearch.io/
 
 First of all, you need to install RediSearch, if you haven't yet:
 
-1. Install Redis 4.0.1 https://github.com/antirez/redis/releases/tag/4.0.1
-2. Install RediSearch http://redisearch.io/Quick_Start/
+1. Install Redis 4.0.1 or highger https://github.com/antirez/redis/releases/tag/4.0.1
+2. Install RediSearch 1.2.0 or higher http://redisearch.io/Quick_Start/
 3. Edit your `redis.conf` file and add a `loadmodule` directive to load the RediSearch module built in the step 2.
 
 To install this gem, add this line to your application's Gemfile:
@@ -43,7 +44,7 @@ In order to run the tests, it's necessary to set some env variables (see .env.ex
 ```ruby
 require 'redisearch-rb'
 
-redis = Redis.new(REDIS_URL)
+redis = Redis.new(url: REDIS_URL)
 redisearch_client = RediSearch.new('test_idx', redis)
 
 schema = ['title', 'TEXT', 'WEIGHT', '2.0',

data/lib/redisearch.rb

@@ -12,14 +12,26 @@ class RediSearch
   #
   # { verbatim: true, withscores: true, withsortkey: false }
 
-  CREATE_OPTIONS_FLAGS = [:nooffsets, :nofreqs, :noscoreidx, :nofields]
-  ADD_OPTIONS_FLAGS = [:nosave, :replace]
-  SEARCH_OPTIONS_FLAGS = [:nocontent, :verbatim, :nostopwords,  :withscores, :withsortkeys]
+  OPTIONS_FLAGS = {
+    add: [:nosave, :replace, :partial],
+    addhash: [:replace],
+    create: [:nooffsets, :nofreqs, :nohl, :nofields],
+    del: [:dd],
+    drop: [:keepdocs],
+    search: [:nocontent, :verbatim, :nostopwords, :withscores, :withsortkeys, :highlight, :summarize],
+    sugadd: [:incr],
+    sugget: [:fuzzy, :withscores],
+  }
 
   # Params options need an array with the values for the option
   #  { limit: ['0', '50'], sortby: ['year', 'desc'], return: ['2', 'title', 'year'] }
-  ADD_OPTIONS_PARAMS = [:language]
-  SEARCH_OPTIONS_PARAMS = [:filter, :return, :infields, :inkeys, :slop, :scorer, :sortby, :limit]
+  OPTIONS_PARAMS = {
+    add: [:language, :payload],
+    addhash: [:language],
+    create: [:stopwords],
+    search: [:filter, :return, :infields, :inkeys, :slop, :scorer, :sortby, :limit, :payload],
+    sugget: [:max],
+  }
 
   # Create RediSearch client instance
   #
@@ -36,11 +48,11 @@ class RediSearch
 
   # Create new index with the given `schema`
   # @param [Array] schema
-  #
+  # @param [Hash] opts options
   # Example:
   #
   #   redisearch = RediSearch.new('my_idx')
-  #   redisearch.create_idx(['title', 'TEXT', 'WEIGHT', '2.0', 'director', 'TEXT', 'WEIGHT', '1.0'])
+  #   redisearch.create_idx(['title', 'TEXT', 'WEIGHT', '2.0', 'director', 'TEXT', 'WEIGHT', '1.0', 'year', 'NUMERIC', 'SORTABLE'])
   #
   # See http://redisearch.io/Commands/#ftcreate
   #
@@ -53,14 +65,15 @@ class RediSearch
   #
   # See http://redisearch.io/Commands/#ftdrop
   # @return [String] "OK" on success
-  def drop_index
-    call(ft_drop)
+  def drop_index(opts = {})
+    call(ft_drop(opts))
   end
 
   # Add a single doc to the index, with the given `doc_id` and `fields`
   #
   # @param [String] doc_id id assigned to the document
   # @param [Array] fields name-value pairs to be indexed
+  # @param [Float] weight asigned by the user to the document
   # @param [Hash] opts optional parameters
   # Example:
   #
@@ -69,8 +82,8 @@ class RediSearch
   #
   # See http://redisearch.io/Commands/#ftadd
   # @return [String] "OK" on success
-  def add_doc(doc_id, fields, opts = {})
-    call(ft_add(doc_id, fields, opts))
+  def add_doc(doc_id, fields, opts = {}, weight = nil)
+    call(ft_add(doc_id, fields, opts, weight))
   end
 
   # Add a set of docs to the index. Uses redis `multi` to make a single bulk insert.
@@ -80,23 +93,58 @@ class RediSearch
   # Example:
   #
   #   redisearch = RediSearch.new('my_idx')
-  #   docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola'],
-  #           ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland']]
+  #   docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola'], 0.75],
+  #           ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland'], 0.95]
   #   redisearch.add_docs(docs)
   #
   # See http://redisearch.io/Commands/#ftadd
   # @return [String] "OK" on success
   def add_docs(docs, opts = {})
-    multi { docs.each { |doc_id, fields| @redis.call(ft_add(doc_id, fields, opts)) } }
+    docs.map { |doc_id, fields, weight| call(ft_add(doc_id, fields, opts, weight))}
+  end
+
+  # Adds a document to the index from an existing HASH key `doc_id` in Redis.
+  #
+  # @param [String] doc_id HASH key holding the fields that need to be indexed
+  # @param [Hash] opts optional parameters
+  # @param [Float]weight asigned by the user to the document
+  # Example:
+  #
+  #   redisearch = RediSearch.new('my_idx')
+  #   redisearch.add_hash('id_1', { weight: true })
+  #
+  # See http://redisearch.io/Commands/#ftadd
+  # @return [String] "OK" on success
+  def add_hash(doc_id, opts = {}, weight = nil)
+    call(ft_addhash(doc_id, opts, weight))
   end
 
   # Search the index with the given `query`
   # @param [String] query text query, see syntax here http://redisearch.io/Query_Syntax/
   # @param [Hash] opts options for the query
   #
-  #@return [Array] documents matching the query
+  # @return [Array] documents matching the query
   def search(query, opts = {})
-    results_to_hash(call(ft_search(query, opts)), opts)
+    build_docs(call(ft_search(query, opts)), opts)
+  end
+
+  # Fetch the contents of multiple documents
+  #
+  # @param [Array] doc_ids ids assigned to the document
+  # @return [Array] documents found for the ids given
+  def get_by_ids(doc_ids)
+    call(ft_mget(doc_ids)).map.with_index do |doc, i|
+      { 'id' => doc_ids[i] }.merge(Hash[*doc]) unless doc.empty?
+    end.compact
+  end
+
+  # Fetch a document by id
+  #
+  # @param [String] doc_id id assigned to the document
+  # @return [Hash] Hash containing document
+  def get_by_id(doc_id)
+    Hash[*call(ft_get(doc_id))]
+      .tap { |doc| doc['id'] = doc_id unless doc.empty? } || {}
   end
 
   # Return information and statistics on the index.
@@ -106,14 +154,92 @@ class RediSearch
     Hash[*call(ft_info)]
   end
 
-  private
+  # Deletes a document from the index
+  #
+  # See http://redisearch.io/Commands/#ftdel
+  #
+  # @param [String] doc_id id assigned to the document
+  # @return [int] 1 if the document was in the index, or 0 if not.
+  def delete_by_id(doc_id, opts = {})
+    call(ft_del(doc_id, opts))
+  end
 
-  def multi
-    @redis.with_reconnect { @redis.multi { yield } }
+  # Deletes all documents matching the query
+  #
+  # @param [String] query in the same format as used in `search`
+  # @param [Hash] opts options for the query, same  as in `search`
+  # @return [int] count of documents deleted
+  def delete_by_query(query, opts = {})
+    call(ft_search(query, opts.merge(nocontent: true)))[1..-1].map do |doc_id|
+      call(ft_del(doc_id, opts))
+    end.sum
+  end
+
+  # Adds a string to an auto-complete suggestion dictionary.
+  #
+  # See https://oss.redislabs.com/redisearch/Commands/#ftsugadd
+  #
+  # @param [String] dict_name the key used to store the dictionary
+  # @param [String] content the string that is going to be indexed
+  # @param [Hash] opts optional parameters
+  # @return [int] current size of the dictionary
+  def autocomplete_add(dict_name, content, score = 1.0, opts = {})
+    call(ft_sugadd(dict_name, content, score, opts))
+  end
+
+  # Gets completion suggestions for a prefix.
+  #
+  # See https://oss.redislabs.com/redisearch/Commands/#ftsugadd
+  #
+  # @param [String] dict_name the key used to store the dictionary
+  # @param [String] prefix the prefix to search / complete
+  # @param [Hash] opts optional parameters
+  # @return [Array] a list of the top suggestions matching the prefix,
+  # optionally with score after each entry
+  def autocomplete_get(dict_name, prefix, opts = {})
+    call(ft_sugget(dict_name, prefix, opts))
+  end
+
+  # Deletes a string from an auto-complete suggestion dictionary.
+  #
+  # See https://oss.redislabs.com/redisearch/Commands/#ftsugdel
+  #
+  # @param [String] dict_name the key used to store the dictionary
+  # @param [String] content the string that is going to be deleted
+  # @param [Hash] opts optional parameters
+  # @return [int] 1 if the string was found and deleted, 0 otherwise
+  def autocomplete_del(dict_name, content)
+    call(ft_sugdel(dict_name, content))
+  end
+
+  # Gets the current size of an auto-complete suggestion dictionary.
+  #
+  # See https://oss.redislabs.com/redisearch/Commands/#ftsugdel
+  #
+  # @param [String] dict_name the key used to store the dictionary
+  # @return [int] current size of the dictionary
+  def autocomplete_len(dict_name)
+    call(ft_suglen(dict_name))
   end
 
+  # Execute arbitrary command in redisearch index
+  # Only RediSearch commands are allowed
+  #
+  # @param [Array] command
+  # @return [mixed] The output returned by redis
   def call(command)
-    @redis.with_reconnect { @redis.call(command) }
+    raise ArgumentError.new("unknown/unsupported command '#{command.first}'") unless valid_command?(command.first)
+    @redis.with_reconnect { @redis.call(command.flatten) }
+  end
+
+  private
+
+  def with_reconnect
+    @redis.with_reconnect { yield }
+  end
+
+  def multi
+    @redis.with_reconnect { @redis.multi { yield } }
   end
 
   def add(doc_id, fields)
@@ -121,11 +247,11 @@ class RediSearch
   end
 
   def ft_create(schema, opts)
-    ['FT.CREATE', @idx_name , *create_options(opts), 'SCHEMA', *schema]
+    ['FT.CREATE', @idx_name , *serialize_options(opts, :create), 'SCHEMA', *schema]
   end
 
-  def ft_drop
-    ['FT.DROP', @idx_name]
+  def ft_drop(opts)
+    ['FT.DROP', @idx_name, *serialize_options(opts, :drop)]
   end
 
   def ft_info
@@ -133,45 +259,87 @@ class RediSearch
   end
 
   def ft_add(doc_id, fields, opts = {}, weight =  nil)
-    ['FT.ADD', @idx_name , doc_id, weight || DEFAULT_WEIGHT, *add_options(opts), 'FIELDS', *fields]
+    ['FT.ADD', @idx_name , doc_id, weight || DEFAULT_WEIGHT, *serialize_options(opts, :add), 'FIELDS', *fields]
+  end
+
+  def ft_addhash(doc_id, opts = {}, weight =  nil)
+    ['FT.ADDHASH', @idx_name , doc_id, weight || DEFAULT_WEIGHT, *serialize_options(opts, :add)]
   end
 
   def ft_search(query, opts)
-    ['FT.SEARCH', @idx_name, *query, *search_options(opts)].flatten
+    ['FT.SEARCH', @idx_name, *query, *serialize_options(opts, :search)].flatten
   end
 
-  def create_options(opts = {})
-    build_options(opts, CREATE_OPTIONS_FLAGS, [])
+  def ft_get(doc_id)
+    ['FT.GET', @idx_name , doc_id]
   end
 
-  def add_options(opts = {})
-    build_options(opts, ADD_OPTIONS_FLAGS, ADD_OPTIONS_PARAMS)
+  def ft_mget(doc_ids)
+    ['FT.MGET', @idx_name , *doc_ids]
   end
 
-  def search_options(opts = {})
-    build_options(opts, SEARCH_OPTIONS_FLAGS, SEARCH_OPTIONS_PARAMS)
+  def ft_del(doc_id, opts)
+    ['FT.DEL', @idx_name , doc_id, *serialize_options(opts, :del)]
   end
 
-  def build_options(opts, flags_keys, params_keys)
-    flags_keys.map do |key|
+  def ft_tagvals(field_name)
+    ['FT.TAGVALS', @idx_name , field_name]
+  end
+
+  def ft_explain(query, opts)
+    ['FT.EXPLAIN', @idx_name, *query, *serialize_options(opts, :search)].flatten
+  end
+
+  def ft_sugadd(dict_name, content, score, opts)
+    ['FT.SUGADD', dict_name , content, score, *serialize_options(opts, :sugadd)]
+  end
+
+  def ft_sugdel(dict_name, content)
+    ['FT.SUGDEL', dict_name , content]
+  end
+
+  def ft_suglen(dict_name)
+    ['FT.SUGLEN', dict_name]
+  end
+
+  def ft_sugget(dict_name, prefix,opts)
+    ['FT.SUGGET', dict_name , prefix, *serialize_options(opts, :sugget)]
+  end
+
+  def serialize_options(opts, method)
+     [flags_for_method(opts, method), params_for_method(opts, method)].flatten.compact
+  end
+
+  def flags_for_method(opts, method)
+    OPTIONS_FLAGS[method].to_a.map do |key|
       key.to_s.upcase if opts[key]
-    end.compact +
-    params_keys.map do |key|
+    end.compact
+  end
+
+  def params_for_method(opts, method)
+    OPTIONS_PARAMS[method].to_a.map do |key|
       [key.to_s.upcase, *opts[key]] unless opts[key].nil?
     end.compact
   end
 
-  def results_to_hash(results, opts = {})
-    return {} if results.nil? || results[0] == 0
+  def build_docs(results, opts = {})
+    return [] if results.nil? || results[0] == 0
     results.shift
-    offset = opts[:withscores] ? 1 : 0
-    rows_per_doc = 2 + offset
-    nr_of_docs = results.size / (2 + offset)
+    score_offset = opts[:withscores] ? 1 : 0
+    content_offset = opts[:nocontent] ? 0 : 1
+    rows_per_doc = 1 + content_offset + score_offset
+    nr_of_docs = results.size / rows_per_doc
     (0..nr_of_docs-1).map do |n|
-      doc = Hash[*results[rows_per_doc * n + 1 + offset]]
-      doc['score'] = results[rows_per_doc * n + offset] if offset > 0
+      doc = opts[:nocontent] ? {} : Hash[*results[rows_per_doc * n + content_offset + score_offset]]
+      doc['score'] = results[rows_per_doc * n + score_offset] if opts[:withscores]
       doc['id'] = results[rows_per_doc * n]
       doc
     end
   end
+
+  def valid_command?(command)
+    %w(FT.CREATE FT.ADD FT.ADDHASH FT.SEARCH FT.DEL FT.DROP FT.GET FT.MGET
+       FT.SUGADD FT.SUGGET FT.SUGDEL FT.SUGLEN FT.SYNADD FT.SYNUPDATE FT.SYNDUMP
+       FT.INFO FT.AGGREGATE FT.EXPLAIN FT.TAGVALS).include?(command)
+  end
 end

data/lib/redisearch/version.rb

@@ -1,3 +1,3 @@
 class RediSearch
-  VERSION = '0.1.7'
+  VERSION = '1.1.0'
 end

data/redisearch-rb.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
                         RediSearch is a Redis powered search engine, developed by RedisLabs. http://redisearch.io/"
   spec.homepage      = "https://github.com/vruizext/redisearch-rb"
   spec.license       = "MIT"
-
+  spec.required_ruby_version = '> 2.4.0'
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {test}/*`.split("\n")
 end

data/test/redisearch_test.rb

@@ -10,6 +10,7 @@ class RediSearchTest < Minitest::Test
     @redisearch_client = RediSearch.new('test_idx', @redis_client)
     @schema = ['title', 'TEXT', 'WEIGHT', '2.0',
                'director', 'TEXT', 'WEIGHT', '1.0',
+               'genre', 'TAG',
                'year', 'NUMERIC', 'SORTABLE']
 
   end
@@ -36,8 +37,19 @@ class RediSearchTest < Minitest::Test
 
   def test_drop_idx
     assert(@redisearch_client.create_index(@schema))
-    assert(@redisearch_client.drop_index)
+    doc = ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']
+    @redisearch_client.add_doc('id_1', doc)
+    @redisearch_client.drop_index
     assert_raises(Redis::CommandError) { @redisearch_client.info }
+    assert(@redis_client.hgetall('id_1').empty?)
+  end
+
+  def test_drop_idx_keep_documents
+    @redisearch_client.create_index(@schema)
+    doc = ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']
+    @redisearch_client.add_doc('id_1', doc)
+    @redisearch_client.drop_index({ keepdocs: true })
+    assert(@redis_client.hgetall('id_1').any?)
   end
 
   def test_add_doc
@@ -72,6 +84,36 @@ class RediSearchTest < Minitest::Test
     assert_includes(search_result.to_s, 'Ex Machina')
   end
 
+  def test_add_hash
+    assert(@redisearch_client.create_index(@schema))
+    doc = ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']
+    @redis_client.hmset('id_1', *doc)
+    assert(@redisearch_client.add_hash('id_1'))
+    assert_includes(@redis_client.call(['FT.SEARCH', 'test_idx', '@title:lost']).to_s, 'Lost in translation')
+  end
+
+  def test_get_by_id
+    assert(@redisearch_client.create_index(@schema))
+    docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']],
+            ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland', 'year', '2014']]]
+    assert(@redisearch_client.add_docs(docs))
+    doc = @redisearch_client.get_by_id('id_1')
+    assert_equal('id_1', doc['id'])
+    assert_equal('Lost in translation', doc['title'])
+  end
+
+  def test_get_by_ids
+    assert(@redisearch_client.create_index(@schema))
+    docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']],
+            ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland', 'year', '2014']]]
+    assert(@redisearch_client.add_docs(docs))
+    docs = @redisearch_client.get_by_ids(['id_1', 'id_2'])
+    assert_equal('id_1', docs[0]['id'])
+    assert_equal('Lost in translation', docs[0]['title'])
+    assert_equal('id_2', docs[1]['id'])
+    assert_equal('Ex Machina', docs[1]['title'])
+  end
+
   def test_search_simple_query
     assert(@redisearch_client.create_index(@schema))
     docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']],
@@ -82,6 +124,7 @@ class RediSearchTest < Minitest::Test
     assert matches.any? { |doc| 'Lost in translation' == doc['title'] }
     assert matches.any? { |doc| 'Ex Machina' == doc['title'] }
     matches.each { |doc| assert doc['score'].to_i > 0 }
+    assert_equal([], @redisearch_client.search('foobarwozzz'))
   end
 
   def test_search_field_selector
@@ -146,6 +189,40 @@ class RediSearchTest < Minitest::Test
     assert_equal 'id_2', matches[0]['id']
   end
 
+  def test_search_summarize
+    assert(@redisearch_client.create_index(@schema))
+    long_director = 'Steven ' * 80 + 'Sofia Coppola' + ' ' + 'Steven ' * 80
+    docs = [['id_1', ['title', 'Lost in translation', 'director',  long_director, 'year', '2004']],
+            ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland', 'year', '2014']],
+            ['id_3', ['title', 'Terminator', 'director', 'James Cameron', 'year', '1984']],
+            ['id_4', ['title', 'Blade Runner', 'director', 'Ridley Scott', 'year', '1982']]]
+    assert(@redisearch_client.add_docs(docs))
+    matches = @redisearch_client.search('Sofia', summarize: false)
+    assert_equal 1, matches.count
+    assert_equal long_director.size, matches[0]['director'].size
+
+    matches = @redisearch_client.search('Sofia', summarize: true)
+    assert_equal 1, matches.count
+    assert_in_epsilon 122, matches[0]['director'].size, 20
+  end
+
+  def test_search_highlight
+    assert(@redisearch_client.create_index(@schema))
+    long_director = 'Steven ' * 80 + 'Sofia Coppola' + ' ' + 'Steven ' * 80
+    docs = [['id_1', ['title', 'Lost in translation', 'director',  long_director, 'year', '2004']],
+            ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland', 'year', '2014']],
+            ['id_3', ['title', 'Terminator', 'director', 'James Cameron', 'year', '1984']],
+            ['id_4', ['title', 'Blade Runner', 'director', 'Ridley Scott', 'year', '1982']]]
+    assert(@redisearch_client.add_docs(docs))
+    matches = @redisearch_client.search('Sofia', highlight: false)
+    assert_equal 1, matches.count
+    assert_match(/^[^<]+$/, matches[0]['director'])
+
+    matches = @redisearch_client.search('Sofia', highlight: true)
+    assert_equal 1, matches.count
+    assert_match(/<b>/, matches[0]['director'])
+  end
+
   def test_index_info
     assert(@redisearch_client.create_index(@schema))
     doc = ['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']]
@@ -156,4 +233,36 @@ class RediSearchTest < Minitest::Test
     assert_equal 1, info['max_doc_id'].to_i
     assert_equal 5, info['num_terms'].to_i
   end
+
+  def test_delete_by_id
+    assert(@redisearch_client.create_index(@schema))
+    docs = [['id_1', ['title', 'Lost in translation', 'director', 'Sofia Coppola', 'year', '2004']],
+            ['id_2', ['title', 'Ex Machina', 'director', 'Alex Garland', 'year', '2014']],
+            ['id_3', ['title', 'Terminator', 'director', 'James Cameron', 'year', '1984']],
+            ['id_4', ['title', 'Blade Runner', 'director', 'Ridley Scott', 'year', '1982']]]
+    assert(@redisearch_client.add_docs(docs))
+    assert_equal(1, @redisearch_client.delete_by_id('id_1', { dd: false }))
+    assert_equal(1, @redisearch_client.delete_by_id('id_2', { dd: true }))
+    assert_empty(@redisearch_client.search('@title:lost'))
+    assert(@redisearch_client.get_by_id('id_1').any?)
+    assert(@redisearch_client.get_by_id('id_2').empty?)
+    assert(@redis_client.del('id_1'))
+    assert(@redisearch_client.get_by_id('id_1').empty?)
+  end
+
+  def test_auto_complete_suggestions
+    dict_name = 'test_suggestions'
+    @redisearch_client.autocomplete_add(dict_name, 'foobar', 2.0)
+    @redisearch_client.autocomplete_add(dict_name, 'foowoz', 1.0)
+    @redisearch_client.autocomplete_add(dict_name, 'foomeh', 0.85)
+    @redisearch_client.autocomplete_add(dict_name, 'woowoz', 1.0)
+    assert_equal(4, @redisearch_client.autocomplete_len(dict_name))
+    results = @redisearch_client.autocomplete_get(dict_name, 'foo')
+    assert_equal(3, results.count)
+    assert_equal('foobar', results.first)
+    assert_equal(4, @redisearch_client.autocomplete_get(dict_name, 'foo', { fuzzy: true }).count)
+    assert @redisearch_client.autocomplete_del(dict_name, 'foobar').to_i > 0
+    refute @redisearch_client.autocomplete_del(dict_name, 'foozzz').to_i > 0
+    assert_equal('foowoz', @redisearch_client.autocomplete_get(dict_name, 'foo').first)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redisearch-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 1.1.0
 platform: ruby
 authors:
 - Victor Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-08 00:00:00.000000000 Z
+date: 2020-11-15 00:00:00.000000000 Z
 dependencies: []
 description: |-
   A simple Ruby client library for RediSearch.
@@ -43,17 +43,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A simple Ruby client library for RediSearch