redi_search 5.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 140fad214c11689ac648949c29c17409c96164ca68e9c6cc5cb694b291aa685c
-  data.tar.gz: 7ba282b0a28eb08c5a8064d3d26afd6c1b97935991f55bd5b69ff50c5a3b7eec
+  metadata.gz: 44546188ac7648ecd413eea9c79c93fc76c23009476f585a2bf600e2da4afe3b
+  data.tar.gz: eb8b6db657a5f671a8d0da0f69653d97301f8c2d116cfc9427b5105133312495
 SHA512:
-  metadata.gz: df96fa21f24f4fec24c66c64b447775a01eb9de86fbf5b30fd028a101363f8036e612d2a2d9b49ed4f09c6dcc14bbcbe7f9a9893be5dcc4dcec7aa4a75db9c95
-  data.tar.gz: 63c12659be3dc7fdfd790c5f4bab980e970ae5943273c2bda750ba0b43c0ddab50390cb718193130ee7658dd6b6384eed96881619ce49699bb7914c5687643fc
+  metadata.gz: adda3ec25f90ea2a4b372549c1d1903a48774b890c9fd589e43ef87c7bccb11f19282f0e5b34df46026c7fffd4e3826ec4d6ef9d1a0216100846f5ece6f1bab7
+  data.tar.gz: a1dc85af4e881b0ad63ae54f4b36cbaead28f2558fdf48674d82ef996bd7bc4482f417c92df920ca4480a20ad05fc190c14300c45467b35c91db23b296fa6d0e

data/.github/workflows/lint.yml

@@ -4,17 +4,17 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby 3.0
+    - name: Set up Ruby 3.1
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0
+        ruby-version: 3.1
     - name: Install rubocop
       run: |
         gem install rubocop rubocop-performance rubocop-minitest rubocop-rake

data/.github/workflows/tests.yml

@@ -4,14 +4,14 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   unit:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [ '2.7', '3.0' ]
+        ruby: [ '2.7', '3.0', '3.1' ]
         gemfile: [ 'Gemfile', 'gemfiles/activerecord_60.gemfile', 'gemfiles/activerecord_61.gemfile', 'gemfiles/activerecord_70.gemfile'  ]
     steps:
     - uses: actions/checkout@v2
@@ -29,17 +29,20 @@ jobs:
       run: BUNDLE_GEMFILE=${{ matrix.gemfile }} bundle exec rake test:unit
   integration:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        redisearch: [ '2.0.14', '2.2.7' ]
     services:
       redisearch:
-        image: redislabs/redisearch:2.0.12
+        image: redislabs/redisearch:${{ matrix.redisearch }}
         ports:
           - 6379:6379
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby 3.0
+    - name: Set up Ruby 3.1
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.0
+        ruby-version: 3.1
     - name: Install dependencies
       run: |
         sudo apt-get install libsqlite3-dev -y

data/Gemfile

@@ -7,6 +7,7 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 gemspec
 
 gem "appraisal", "~> 2.2"
+gem "debug"
 gem "faker"
 gem "mocha"
 gem "rubocop"

data/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <a href="https://github.com/npezza93/redi_search">
-    <img src="https://raw.githubusercontent.com/npezza93/redi_search/master/.github/logo.svg?sanitize=true" width="350">
+    <img src="https://raw.githubusercontent.com/npezza93/redi_search/main/.github/logo.svg?sanitize=true" width="350">
   </a>
 </p>
 
@@ -103,17 +103,19 @@ defining what a search index is. According to [Swiftype](https://swiftype.com):
 ## Schema
 
 This defines the fields and the properties of those fields in the index. A
-schema is a hash, with field names as the keys, and the field type(and options)
-as the value. Each field can be one of four types: geo, numeric, tag, or text
-and can have many options. A simple example of a schema is:
+schema is a simple DSL. Each field can be one of four types: geo, numeric, tag,
+or text and can have many options. A simple example of a schema is:
 ```ruby
-{ first_name: :text, last_name: :text }
+RediSearch::Schema.new do
+  text_field :first_name
+  text_field :last_name
+end
 ```
 
 The supported options for each type are as follows:
 
 ##### Text field
-With no options: `{ name: :text }`
+With no options: `text_field :name`
 
 <details>
   <summary>Options</summary>
@@ -122,7 +124,7 @@ With no options: `{ name: :text }`
       <b>weight</b> (default: 1.0)
       <ul>
         <li>Declares the importance of this field when calculating result accuracy. This is a multiplication factor.</li>
-        <li>Ex: <code>{ name: { text: { weight: 2 } } }</code></li>
+        <li>Ex: <code>text_field :name, weight: 2</code></li>
       </ul>
     </li>
     <li>
@@ -137,7 +139,7 @@ With no options: `{ name: :text }`
           </ul>
         </li>
         <li>
-          Ex: <code>{ name: { text: { phonetic: 'dm:en' } } }</code>
+          Ex: <code>text_field :name, phonetic: 'dm:en'</code>
         </li>
       </ul>
     </li>
@@ -145,28 +147,28 @@ With no options: `{ name: :text }`
       <b>sortable</b> (default: false)
       <ul>
         <li>Allows the user to later sort the results by the value of this field (this adds memory overhead so do not declare it on large text fields).</li>
-        <li>Ex: <code>{ name: { text: { sortable: true } } }</code></li>
+        <li>Ex: <code>text_field :name, sortable: true</code></li>
       </ul>
     </li>
     <li>
       <b>no_index</b> (default: false)
       <ul>
         <li>Field will not be indexed. This is useful in conjunction with <code>sortable</code>, to create fields whose update using PARTIAL will not cause full reindexing of the document. If a field has <code>no_index</code> and doesn't have <code>sortable</code>, it will just be ignored by the index.</li>
-        <li>Ex: <code>{ name: { text: { no_index: true } } }</code></li>
+        <li>Ex: <code>text_field :name, no_index: true</code></li>
       </ul>
     </li>
     <li>
       <b>no_stem</b> (default: false)
       <ul>
         <li>Disable stemming when indexing its values. This may be ideal for things like proper names.</li>
-        <li>Ex: <code>{ name: { text: { no_stem: true } } }</code></li>
+        <li>Ex: <code>text_feidl :name, no_stem: true</code></li>
       </ul>
     </li>
   </ul>
 </details>
 
 ##### Numeric field
-With no options: `{ price: :numeric }`
+With no options: `numeric_field :price`
 
 <details>
   <summary>Options</summary>
@@ -175,21 +177,21 @@ With no options: `{ price: :numeric }`
       <b>sortable</b> (default: false)
       <ul>
         <li>Allows the user to later sort the results by the value of this field (this adds memory overhead so do not declare it on large text fields).</li>
-        <li>Ex: <code>{ id: { numeric: { sortable: true } } }</code></li>
+        <li>Ex: <code>numeric_field :id, sortable: true</code></li>
       </ul>
     </li>
     <li>
       <b>no_index</b> (default: false)
       <ul>
         <li>Field will not be indexed. This is useful in conjunction with <code>sortable</code>, to create fields whose update using PARTIAL will not cause full reindexing of the document. If a field has <code>no_index</code> and doesn't have <code>sortable</code>, it will just be ignored by the index.</li>
-        <li>Ex: <code>{ id: { numeric: { no_index: true } } }</code></li>
+        <li>Ex: <code>numeric_field :id, no_index: true</code></li>
       </ul>
     </li>
   </ul>
 </details>
 
 ##### Tag field
-With no options: `{ tag: :tag }`
+With no options: `tag_field :tag`
 
 <details>
   <summary>Options</summary>
@@ -198,28 +200,28 @@ With no options: `{ tag: :tag }`
       <b>sortable</b> (default: false)
       <ul>
         <li>Allows the user to later sort the results by the value of this field (this adds memory overhead so do not declare it on large text fields).</li>
-        <li>Ex: <code>{ tag: { tag: { sortable: true } } }</code></li>
+        <li>Ex: <code>tag_field :tag, sortable: true</code></li>
       </ul>
     </li>
     <li>
       <b>no_index</b> (default: false)
       <ul>
         <li>Field will not be indexed. This is useful in conjunction with <code>sortable</code>, to create fields whose update using PARTIAL will not cause full reindexing of the document. If a field has <code>no_index</code> and doesn't have <code>sortable</code>, it will just be ignored by the index.</li>
-        <li>Ex: <code>{ tag: { tag: { no_index: true } } }</code></li>
+        <li>Ex: <code>tag_field :tag, no_index: true</code></li>
       </ul>
     </li>
     <li>
       <b>separator</b> (default: ",")
       <ul>
         <li>Indicates how the text contained in the field is to be split into individual tags. The default is ,. The value must be a single character.</li>
-        <li>Ex: <code>{ tag: { tag: { separator: ',' } } }</code></li>
+        <li>Ex: <code>tag_field :tag, separator: ','</code></li>
       </ul>
     </li>
   </ul>
 </details>
 
 ##### Geo field
-With no options: `{ place: :geo }`
+With no options: `geo_field :place`
 
 <details>
   <summary>Options</summary>
@@ -228,14 +230,14 @@ With no options: `{ place: :geo }`
       <b>sortable</b> (default: false)
       <ul>
         <li>Allows the user to later sort the results by the value of this field (this adds memory overhead so do not declare it on large text fields).</li>
-        <li>Ex: <code>{ place: { geo: { sortable: true } } }</code></li>
+        <li>Ex: <code>geo_field :place, sortable: true</code></li>
       </ul>
     </li>
     <li>
       <b>no_index</b> (default: false)
       <ul>
         <li>Field will not be indexed. This is useful in conjunction with <code>sortable</code>, to create fields whose update using PARTIAL will not cause full reindexing of the document. If a field has <code>no_index</code> and doesn't have <code>sortable</code>, it will just be ignored by the index.</li>
-        <li>Ex: <code>{ place: { geo: { no_index: true } } }</code></li>
+        <li>Ex: <code>geo_field :place, no_index: true</code></li>
       </ul>
     </li>
   </ul>
@@ -250,12 +252,10 @@ You can fetch a `Document` using `.get` class methods.
 given `document_id`.
 
 You can also make a `Document` instance using the
-`.for_object(index, record, serializer: nil, only: [])` class method. It takes
+`.for_object(index, record, only: [])` class method. It takes
 an `Index` instance and a Ruby object. That object must respond to all the
-fields specified in the `Index`'s `Schema` or pass a serializer class that
-accepts the object and responds to all the fields specified in the `Index`'s
-`Schema`. `only` accepts an array of fields from the schema and limits the
-fields that are passed to the `Document`.
+fields specified in the `Index`'s `Schema`. `only` accepts an array of fields
+from the schema and limits the fields that are passed to the `Document`.
 
 Once you have an instance of a `Document`, it responds to all the fields
 specified in the `Index`'s `Schema` as methods and `document_id`. `document_id`
@@ -271,10 +271,12 @@ Finally there is a `#del` method that will remove the `Document` from the
 ## Index
 
 To initialize an `Index`, pass the name of the `Index` as a string or symbol
-and the `Schema`.
+and the `Schema` block.
 
 ```ruby
-RediSearch::Index.new(name_of_index, schema)
+RediSearch::Index.new(name_of_index) do
+  text_field :foobar
+end
 ```
 
 #### Available Commands
@@ -330,8 +332,10 @@ RediSearch::Index.new(name_of_index, schema)
   - Removes a `Document` from the `Index`.
 - `document_count`
   - Returns the number of `Document`s in the `Index`
-- `add_field(field_name, schema)`
-  - Adds a new field to the `Index`. Ex: `index.add_field(:first_name, text: { phonetic: "dm:en" })`
+- `add_field(name, type, **options, &block)`
+  - Adds a new field to the `Index`.
+  - The block and options are optional.
+  - Ex: `index.add_field(:first_name, :text, phonetic: "dm:en")`
 - `reindex(documents, recreate: false)`
    - If `recreate` is `true` the `Index` will be dropped and recreated
 
@@ -343,7 +347,7 @@ be chained together. When searching, an array of `Document`s is returned
 which has public reader methods for all the schema fields.
 
 ```ruby
-main ❯ index = RediSearch::Index.new("user_idx", name: { text: { phonetic: "dm:en" } })
+main ❯ index = RediSearch::Index.new("user_idx") { text_field :name, phonetic: "dm:en" }
 main ❯ index.add RediSearch::Document.for_object(index, User.new("10039", "Gene", "Volkman"))
 main ❯ index.add RediSearch::Document.for_object(index, User.new("9998", "Jeannie", "Ledner"))
 main ❯ index.search("john")
@@ -473,7 +477,7 @@ returns an array where each element contains suggestions for each search term
 and a normalized score based on its occurrences in the index.
 
 ```ruby
-main ❯ index = RediSearch::Index.new("user_idx", name: { text: { phonetic: "dm:en" } })
+main ❯ index = RediSearch::Index.new("user_idx") { text_field :name, phonetic: "dm:en" }
 main ❯ index.spellcheck("jimy")
   RediSearch (1.1ms)  FT.SPELLCHECK user_idx jimy DISTANCE 1
   => [#<RediSearch::Spellcheck::Result:0x00007f805591c670
@@ -495,10 +499,10 @@ keyword argument from inside your model. Ex:
 
 ```ruby
 class User < ApplicationRecord
-  redi_search schema: {
-    first: { text: { phonetic: "dm:en" } },
-    last: { text: { phonetic: "dm:en" } }
-  }
+  redi_search do
+    text_field :first, phonetic: "dm:en"
+    text_field :last, phonetic: "dm:en"
+  end
 end
 ```
 
@@ -515,21 +519,16 @@ similarly to `RediSearch::Index#reindex`. Some of the differences include:
     particular field.
 
 
-The `redi_search` class method also takes an optional `serializer` argument
-which takes the class name of a serializer. The serializer must respond to all
-the fields in a schema as methods. We don't serialize to a JSON object since
-RediSearch doesn't serialize documents that way.
+While defining the schema you can optionally pass it a block. If no block is
+passed the `name` will called on the model to get the value. If a block is
+passed the value for the field is obtained through calling the block.
 
 ```ruby
 class User < ApplicationRecord
-  redi_search schema: {
-    name: { text: { phonetic: "dm:en" } }
-  }, serializer: UserSerializer
-end
-
-class UserSerializer < SimpleDelegator
-  def name
-    "#{first_name} #{last_name}"
+  redi_search do
+    text_field :name do
+      "#{first_name} #{last_name}"
+    end
   end
 end
 ```
@@ -553,13 +552,13 @@ optional `index_prefix` argument which gets prepended to the index name:
 
 ```ruby
 class User < ApplicationRecord
-  redi_search schema: {
-    first: { text: { phonetic: "dm:en" } },
-    last: { text: { phonetic: "dm:en" } }
-  }, index_prefix: 'prefix'
+  redi_search index_prefix: 'prefix' do
+    text_field :first, phonetic: "dm:en"
+    text_field :last, phonetic: "dm:en"
+  end
 end
 
-User.redi_search_index.name
+User.search_index.name
 # => prefix_users_development
 ```
 
@@ -568,13 +567,13 @@ after creating and updating and will be removed from the `Index` upon
 destruction.
 
 There are a few more convenience methods that are publicly available:
-- `redi_search_document`
+- `search_document`
   - Returns the record as a `RediSearch::Document` instance
-- `redi_search_delete_document`
+- `remove_from_index`
   - Removes the record from the `Index`
-- `redi_search_add_document`
+- `add_to_index`
   - Adds the record to the `Index`
-- `redi_search_index`
+- `search_index`
   - Returns the `RediSearch::Index` instance
 
 
@@ -608,4 +607,4 @@ The gem is available as open source under the terms of the
 
 Everyone interacting in the RediSearch project’s codebases, issue trackers, chat
 rooms and mailing lists is expected to follow the [code of
-conduct](https://github.com/npezza93/redi_search/blob/master/CODE_OF_CONDUCT.md).
+conduct](https://github.com/npezza93/redi_search/blob/main/CODE_OF_CONDUCT.md).

data/bin/console

@@ -19,10 +19,14 @@ ActiveRecord::Migration.create_table :users do |t|
 end
 
 class User < ActiveRecord::Base
-  redi_search schema: {
-    first: { text: { phonetic: "dm:en" } },
-    last: { text: { phonetic: "dm:en" } }
-  }
+  redi_search do
+    text_field :first, phonetic: "dm:en"
+    text_field :last, phonetic: "dm:en"
+    tag_field :tags
+    text_field :name, phonetic: "dm:en" do
+      "#{first} #{last}"
+    end
+  end
 end
 
 def seed_users(count = 10_000)

data/bin/publish

@@ -8,7 +8,7 @@ require_relative "../lib/redi_search/version"
 # path to your application root.
 APP_ROOT = Pathname.new File.expand_path("..", __dir__)
 MASTER_CHECK = <<~MASTER_CHECK
-  if [ $(git symbolic-ref --short -q HEAD) != 'master' ];
+  if [ $(git symbolic-ref --short -q HEAD) != 'main' ];
     then exit 1;
   fi
 MASTER_CHECK
@@ -20,7 +20,7 @@ end
 
 abort("\n== Version Type incorrect ==") unless VERSION_TYPES.include?(ARGV[0])
 
-abort("\n== Not on master") unless system(MASTER_CHECK)
+abort("\n== Not on main") unless system(MASTER_CHECK)
 
 current_version = RediSearch::VERSION.split(".").map(&:to_i)
 

data/gemfiles/activerecord_60.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "appraisal", "~> 2.2"
+gem "debug"
 gem "faker"
 gem "mocha"
 gem "rubocop"

data/gemfiles/activerecord_61.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "appraisal", "~> 2.2"
+gem "debug"
 gem "faker"
 gem "mocha"
 gem "rubocop"

data/gemfiles/activerecord_70.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "appraisal", "~> 2.2"
+gem "debug"
 gem "faker"
 gem "mocha"
 gem "rubocop"
@@ -10,6 +11,6 @@ gem "rubocop-minitest"
 gem "rubocop-performance"
 gem "simplecov"
 gem "sqlite3"
-gem "activerecord", "~> 7.0.0.alpha1"
+gem "activerecord", "~> 7.0.1"
 
 gemspec path: "../"

data/lib/redi_search/add_field.rb

@@ -2,16 +2,18 @@
 
 module RediSearch
   class AddField
-    def initialize(index, field_name, schema)
-      @index = index
-      @field_name = field_name
-      @raw_schema = schema
+    def initialize(index, name, type, **options, &block)
+      @index   = index
+      @name    = name
+      @type    = type
+      @options = options
+      @block   = block
     end
 
     def call!
-      index.schema.add_field(field_name, raw_schema)
+      field = index.schema.add_field(name, type, **options, &block)
 
-      RediSearch.client.call!(*command).ok?
+      RediSearch.client.call!("ALTER", index.name, "SCHEMA", "ADD", *field).ok?
     end
 
     def call
@@ -22,14 +24,6 @@ module RediSearch
 
     private
 
-    attr_reader :index, :field_name, :raw_schema
-
-    def command
-      ["ALTER", index.name, "SCHEMA", "ADD", *field_schema]
-    end
-
-    def field_schema
-      @field_schema ||= Schema.make_field(field_name, raw_schema).to_a
-    end
+    attr_reader :index, :name, :type, :options, :block
   end
 end

data/lib/redi_search/client.rb

@@ -3,8 +3,6 @@
 require "redis"
 require "active_support/notifications"
 
-require "redi_search/client/response"
-
 module RediSearch
   class Client
     def initialize(redis = Redis.new)
@@ -20,9 +18,9 @@ module RediSearch
     end
 
     def multi
-      Response.new(redis.multi do
+      Response.new(redis.multi do |pipeline|
         instrument("pipeline", query: ["begin pipeline"])
-        capture_pipeline { yield }
+        capture_pipeline(pipeline) { yield }
         instrument("pipeline", query: ["finish pipeline"])
       end)
     end
@@ -32,14 +30,18 @@ module RediSearch
     attr_reader   :redis
     attr_accessor :pipeline
 
-    def capture_pipeline
-      self.pipeline = true
+    def capture_pipeline(pipeline)
+      self.pipeline = pipeline
       yield
       self.pipeline = false
     end
 
     def send_command(command, *params)
-      Response.new(redis.call(command, *params))
+      if pipeline
+        Response.new(pipeline.call(command, *params))
+      else
+        Response.new(redis.call(command, *params))
+      end
     end
 
     def instrument(action, payload, &block)

data/lib/redi_search/document.rb

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
 
-require "redi_search/document/display"
-require "redi_search/document/finder"
-
 module RediSearch
   class Document
     include Display
 
     class << self
-      def for_object(index, record, serializer: nil, only: [])
-        object_to_serialize = serializer&.new(record) || record
-
-        field_values = index.schema.fields.map(&:name).filter_map do |field|
-          next unless only.empty? || only.include?(field)
+      def for_object(index, record, only: [])
+        field_values = index.schema.fields.filter_map do |field|
+          next unless only.empty? || only.include?(field.name)
 
-          [field.to_s, object_to_serialize.public_send(field)]
+          [field.name.to_s, field.serialize(record)]
         end.to_h
 
-        new(index, object_to_serialize.id, field_values)
+        new(index, record.id, field_values)
       end
 
       def get(index, document_id)
@@ -48,7 +43,7 @@ module RediSearch
 
     def redis_attributes
       attributes.flat_map do |field, value|
-        [field, index.schema[field.to_sym].serialize(value)]
+        [field, index.schema[field.to_sym].coerce(value)]
       end
     end
 

data/lib/redi_search/index.rb

@@ -1,19 +1,12 @@
 # frozen_string_literal: true
 
-require "redi_search/hset"
-require "redi_search/create"
-require "redi_search/schema"
-require "redi_search/search"
-require "redi_search/spellcheck"
-require "redi_search/add_field"
-
 module RediSearch
   class Index
     attr_reader :name, :schema, :model
 
-    def initialize(name, schema, model = nil)
+    def initialize(name, model = nil, &schema)
       @name = name.to_s
-      @schema = Schema.new(schema)
+      @schema = Schema.new(&schema)
       @model = model
     end
 
@@ -94,8 +87,8 @@ module RediSearch
       info.num_docs.to_i
     end
 
-    def add_field(field_name, schema)
-      AddField.new(self, field_name, schema).call!
+    def add_field(name, type, **options, &block)
+      AddField.new(self, name, type, **options, &block).call!
     end
 
     private