feat(stemming): add support for stemming dictionaries API

- Add `Stemming`, `StemmingDictionaries` and `StemmingDictionary` classes
- Add `stemming` attribute to `Client` class
- Add integration tests for dictionary operations
- Update `collections_spec.rb` with stem dictionary field

Author: tharropoulos

lib/typesense.rb

@@ -32,3 +32,6 @@ module Typesense
 require_relative 'typesense/stats'
 require_relative 'typesense/operations'
 require_relative 'typesense/error'
+require_relative 'typesense/stemming'
+require_relative 'typesense/stemming_dictionaries'
+require_relative 'typesense/stemming_dictionary'

lib/typesense/client.rb

@@ -3,7 +3,7 @@
 module Typesense
   class Client
     attr_reader :configuration, :collections, :aliases, :keys, :debug, :health, :metrics, :stats, :operations,
-                :multi_search, :analytics, :presets
+                :multi_search, :analytics, :presets, :stemming
 
     def initialize(options = {})
       @configuration = Configuration.new(options)
@@ -18,6 +18,7 @@ def initialize(options = {})
       @stats = Stats.new(@api_call)
       @operations = Operations.new(@api_call)
       @analytics = Analytics.new(@api_call)
+      @stemming = Stemming.new(@api_call)
       @presets = Presets.new(@api_call)
     end
   end

lib/typesense/stemming.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Typesense
+  class Stemming
+    RESOURCE_PATH = "/stemming"
+
+    def initialize(api_call)
+      @api_call = api_call
+    end
+
+    def dictionaries
+      @dictionaries ||= StemmingDictionaries.new(@api_call)
+    end
+  end
+end

lib/typesense/stemming_dictionaries.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Typesense
+  class StemmingDictionaries
+    RESOURCE_PATH = "/stemming/dictionaries"
+
+    def initialize(api_call)
+      @api_call = api_call
+      @dictionaries = {}
+    end
+
+    def upsert(dict_id, words_and_roots_combinations)
+      words_and_roots_combinations_in_jsonl = if words_and_roots_combinations.is_a?(Array)
+          words_and_roots_combinations.map { |combo| Oj.dump(combo, mode: :compat) }.join("\n")
+        else
+          words_and_roots_combinations
+        end
+
+      result_in_jsonl = @api_call.perform_request(
+        "post",
+        endpoint_path("import"),
+        query_parameters: { id: dict_id },
+        body_parameters: words_and_roots_combinations_in_jsonl,
+        additional_headers: { "Content-Type" => "text/plain" },
+      )
+
+      if words_and_roots_combinations.is_a?(Array)
+        result_in_jsonl.split("\n").map { |r| Oj.load(r) }
+      else
+        result_in_jsonl
+      end
+    end
+
+    def retrieve
+      @api_call.get(endpoint_path)
+    end
+
+    def [](dict_id)
+      @dictionaries[dict_id] ||= StemmingDictionary.new(dict_id, @api_call)
+    end
+
+    private
+
+    def endpoint_path(operation = nil)
+      "#{StemmingDictionaries::RESOURCE_PATH}#{operation.nil? ? "" : "/#{URI.encode_www_form_component(operation)}"}"
+    end
+  end
+end

lib/typesense/stemming_dictionary.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Typesense
+  class StemmingDictionary
+    def initialize(id, api_call)
+      @dict_id = id
+      @api_call = api_call
+    end
+
+    def retrieve
+      @api_call.get(endpoint_path)
+    end
+
+    private
+
+    def endpoint_path
+      "#{StemmingDictionaries::RESOURCE_PATH}/#{URI.encode_www_form_component(@dict_id)}"
+    end
+  end
+end

spec/typesense/collections_spec.rb

@@ -100,6 +100,7 @@
             'optional' => false,
             'sort' => false,
             'stem' => false,
+            'stem_dictionary' => '',
             'store' => true
           },
           {
@@ -112,6 +113,7 @@
             'optional' => false,
             'sort' => true,
             'stem' => false,
+            'stem_dictionary' => '',
             'store' => true
           },
           {
@@ -124,6 +126,7 @@
             'optional' => false,
             'sort' => false,
             'stem' => false,
+            'stem_dictionary' => '',
             'store' => true
           }
         ]

spec/typesense/stemming_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require_relative "../spec_helper"
+
+describe "Stemming Dictionaries" do
+  let(:client) do
+    Typesense::Client.new(
+      nodes: [{ host: "localhost", port: "8108", protocol: "http" }],
+      api_key: "xyz",
+      connection_timeout_seconds: 10,
+    )
+  end
+
+  let(:dictionary_id) { "test_dictionary" }
+  let(:dictionary) do
+    [
+      { "root" => "exampleRoot1", "word" => "exampleWord1" },
+      { "root" => "exampleRoot2", "word" => "exampleWord2" },
+    ]
+  end
+
+  before { WebMock.disable! }
+  after { WebMock.enable! }
+
+  it "can upsert a dictionary" do
+    response = client.stemming.dictionaries.upsert(dictionary_id, dictionary)
+    expect(response).to eq(dictionary)
+  end
+
+  it "can retrieve a dictionary" do
+    response = client.stemming.dictionaries[dictionary_id].retrieve
+    expect(response["id"]).to eq(dictionary_id)
+    expect(response["words"]).to eq(dictionary)
+  end
+
+  it "can retrieve all dictionaries" do
+    response = client.stemming.dictionaries.retrieve
+    expect(response["dictionaries"].length).to eq(1)
+    expect(response["dictionaries"][0]).to eq(dictionary_id)
+  end
+end