meilisearch 0.1.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c31820aca925f28c1e53011587a9f6f2d9dfd210425ee3e1bce4c6e2728cb655
-  data.tar.gz: a74b7e2540093dc1f7fc65f5da4259cd2c07e17460ce2497be66899559cd0137
+  metadata.gz: 25dd43cb7f3a566eac6eb6b9cc195bf10fbb29a98b1b6b85efcfac3e5e068edd
+  data.tar.gz: 73631da64c2a50f196e459f5696fa0a2d2d4075778dba5dca5777bce99098d7e
 SHA512:
-  metadata.gz: 9b07704bb782d34b98b68b39e6a243f2882e22bc088e1ea3d66ca89f5371efa6843aa7a9b58251d3a9d0acb68825b65e61037a70f9b1ca0cd0e7e6a614aad5a3
-  data.tar.gz: c3a1018f981315a8e55135074ac88c688e94c8fab6ce0d2544c0db587d3ba3e9a91e24771455ddf32716c283931092c751ce4d7a413b45e9a26deaf4894f153e
+  metadata.gz: 4f2747c0d558e2cf31b6c169735f38a243ddfeac2a86b932b2e32c3ea47335350a045b10645c5e42687bd0e8dce8b0656d42ae51f1286dabdc403f5e4762ad3e
+  data.tar.gz: 9c78a7b30755ce6da5a81153108d52dd63203a251358d2b6a8d7811bce329b812970b77dacbbf9f9b42183229ef14c3a72e6bb37e7f828269c129b410066164b

data/lib/meilisearch.rb

@@ -2,6 +2,7 @@
 
 require 'meilisearch/version'
 require 'meilisearch/client'
+require 'meilisearch/index'
 
 module MeiliSearch
 end

data/lib/meilisearch/client.rb

@@ -1,86 +1,16 @@
 # frozen_string_literal: true
 
-require 'httparty'
-
-require 'meilisearch/error'
+require 'meilisearch/http_request'
 require 'meilisearch/client/keys'
 require 'meilisearch/client/stats'
 require 'meilisearch/client/health'
 require 'meilisearch/client/indexes'
-require 'meilisearch/client/documents'
-require 'meilisearch/client/prepare'
-require 'meilisearch/client/search'
 
 module MeiliSearch
-  class Client
-    include HTTParty
-
+  class Client < HTTPRequest
     include MeiliSearch::Client::Keys
     include MeiliSearch::Client::Stats
     include MeiliSearch::Client::Health
     include MeiliSearch::Client::Indexes
-    include MeiliSearch::Client::Documents
-    include MeiliSearch::Client::Prepare
-    include MeiliSearch::Client::Search
-
-    def initialize(url, api_key = nil)
-      # api_key is is for basic api authorization
-      @headers = {}
-      @headers['X-Meili-Api-Key'] = api_key if api_key
-      @headers['Content-Type'] = 'application/json'
-      @base_url = url
-    end
-
-    def get(path = '', query = {})
-      response = self.class.get(
-        (@base_url + path),
-        query: query,
-        headers: @headers
-      )
-      validate(response)
-    end
-
-    def post(path = '', body = nil)
-      if body.nil?
-        response = self.class.post(
-          (@base_url + path),
-          headers: @headers
-        )
-      else
-        response = self.class.post(
-          (@base_url + path),
-          body: body.to_json,
-          headers: @headers
-        )
-      end
-      validate(response)
-    end
-
-    def put(path = '', body = {})
-      response = self.class.put(
-        (@base_url + path),
-        body: body.to_json,
-        headers: @headers
-      )
-      validate(response)
-    end
-
-    def delete(path = '')
-      response = self.class.delete(
-        (@base_url + path),
-        headers: @headers
-      )
-      validate(response)
-    end
-
-    private
-
-    def validate(response)
-      unless response.success?
-        raise ClientError, "#{response.code}: #{response.message}\n#{response.body}"
-      end
-
-      response.parsed_response
-    end
   end
 end

data/lib/meilisearch/client/health.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  class Client
+  class Client < HTTPRequest
     module Health
-      def is_healthy?
-        get '/health'
+      def healthy?
+        http_get '/health'
         true
       rescue StandardError
         false
       end
 
       def health
-        get '/health'
+        http_get '/health'
       end
 
       def update_health(bool)
-        put '/health', health: bool
+        http_put '/health', health: bool
       end
     end
   end

data/lib/meilisearch/client/indexes.rb

@@ -1,30 +1,70 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  class Client
+  class Client < HTTPRequest
     module Indexes
       def indexes
-        get '/indexes'
+        http_get '/indexes'
       end
 
-      def index(index_uid)
-        get "/indexes/#{index_uid}"
+      def show_index(index_uid)
+        index_object(index_uid).show
       end
 
-      def create_index(index_uid, schema = nil)
-        if schema.nil?
-          post "/indexes/#{index_uid}"
-        else
-          post "/indexes/#{index_uid}", schema
-        end
+      # Usage:
+      # create_index('name')
+      # create_index(name: 'name')
+      # create_index(name: 'name', uid: 'uid')
+      # create_index(name: 'name', schema: {...})
+      # create_index(name: 'name', uid: 'uid', schema: {...})
+      def create_index(attributes)
+        body = if attributes.is_a?(Hash)
+                 attributes
+               else
+                 { name: attributes }
+               end
+        res = http_post '/indexes', body
+        index_object(res['uid'])
       end
 
-      def update_index(index_uid, schema = nil)
-        put "/indexes/#{index_uid}", schema
+      def delete_index(index_uid)
+        index_object(index_uid).delete
       end
 
-      def delete_index(index_uid)
-        delete "/indexes/#{index_uid}"
+      # Usage:
+      # index('uid')
+      # index(uid: 'uid')
+      # index(name: 'name') => WARNING: the name of an index is not guaranteed to be unique. This method will return the first occurrence. We recommend using the index uid instead.
+      # index(uid: 'uid', name: 'name') => only the uid field will be taken into account.
+      def index(identifier)
+        uid = index_uid(identifier)
+        raise IndexIdentifierError if uid.nil?
+
+        index_object(uid)
+      end
+      alias get_index index
+
+      private
+
+      def index_object(uid)
+        Index.new(uid, @base_url, @api_key)
+      end
+
+      def index_uid(identifier)
+        if identifier.is_a?(Hash)
+          identifier[:uid] || index_uid_from_name(identifier)
+        else
+          identifier
+        end
+      end
+
+      def index_uid_from_name(identifier)
+        index = indexes.find { |i| i['name'] == identifier[:name] }
+        if index.nil?
+          nil
+        else
+          index['uid']
+        end
       end
     end
   end

data/lib/meilisearch/client/keys.rb

@@ -1,26 +1,26 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  class Client
+  class Client < HTTPRequest
     module Keys
       def keys
-        get '/keys'
+        http_get '/keys'
       end
 
-      def key(key_hash)
-        get "/keys/#{key_hash}"
+      def key(key)
+        http_get "/keys/#{key}"
       end
 
       def create_key(options = {})
-        post '/keys', options
+        http_post '/keys', options
       end
 
-      def update_key(key_hash, options = {})
-        put "/keys/#{key_hash}", options
+      def update_key(key, options = {})
+        http_put "/keys/#{key}", options
       end
 
-      def delete_key(key_hash)
-        delete "/keys/#{key_hash}"
+      def delete_key(key)
+        http_delete "/keys/#{key}"
       end
     end
   end

data/lib/meilisearch/client/stats.rb

@@ -1,38 +1,22 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  class Client
+  class Client < HTTPRequest
     module Stats
       def version
-        get '/version'
+        http_get '/version'
       end
 
       def sysinfo
-        get '/sys-info'
+        http_get '/sys-info'
       end
 
-      def stats
-        get '/stats'
-      end
-
-      def stats_index(index_uid)
-        get "/stats/#{index_uid}"
-      end
-
-      def number_of_documents_in_index(index_uid)
-        stats_index(index_uid)['numberOfDocuments']
+      def pretty_sysinfo
+        http_get '/sys-info/pretty'
       end
 
-      def index_is_indexing?(index_uid)
-        stats_index(index_uid)['isIndexing']
-      end
-
-      def index_last_update(index_uid)
-        stats_index(index_uid)['lastUpdate']
-      end
-
-      def index_fields_frequency(index_uid)
-        stats_index(index_uid)['fieldsFrequency']
+      def stats
+        http_get '/stats'
       end
     end
   end

data/lib/meilisearch/error.rb

@@ -2,5 +2,33 @@
 
 module MeiliSearch
   class MeiliSearchError < StandardError; end
-  class ClientError < MeiliSearchError; end
+  class IndexIdentifierError < MeiliSearchError; end
+
+  class HTTPError < MeiliSearchError
+    attr_reader :status
+    attr_reader :message
+    attr_reader :http_body
+    attr_reader :http_body_message
+    attr_reader :details
+
+    alias code         status
+    alias body         http_body
+    alias body_message http_body_message
+
+    def initialize(status, message, http_body, details = nil)
+      @status = status
+      unless http_body.nil? || http_body.empty?
+        @http_body = JSON.parse(http_body)
+        @http_body_message = @http_body['message']
+      end
+      @message = message.capitalize
+      @message = "#{@message} - #{@http_body_message.capitalize}" unless @http_body_message.nil?
+      @details = details
+    end
+
+    def to_s
+      final_message = @details.nil? ? @message : "#{@message}. #{@details}"
+      "#{@status}: #{final_message}."
+    end
+  end
 end

data/lib/meilisearch/http_request.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'meilisearch/error'
+
+module MeiliSearch
+  class HTTPRequest
+    include HTTParty
+
+    def initialize(url, api_key = nil)
+      @base_url = url
+      @api_key = api_key
+      @headers = {
+        'Content-Type' => 'application/json',
+        'X-Meili-API-Key' => api_key
+      }.compact
+    end
+
+    def http_get(path = '', query = {})
+      response = self.class.get(
+        @base_url + path,
+        query: query,
+        headers: @headers
+      )
+      validate(response)
+    end
+
+    def http_post(path = '', body = nil)
+      response = if body.nil?
+                   self.class.post(
+                     @base_url + path,
+                     headers: @headers
+                   )
+                 else
+                   self.class.post(
+                     @base_url + path,
+                     body: body.to_json,
+                     headers: @headers
+                   )
+                 end
+      validate(response)
+    end
+
+    def http_put(path = '', body = {})
+      response = self.class.put(
+        @base_url + path,
+        body: body.to_json,
+        headers: @headers
+      )
+      validate(response)
+    end
+
+    def http_patch(path = '', body = {})
+      response = self.class.patch(
+        @base_url + path,
+        body: body.to_json,
+        headers: @headers
+      )
+      validate(response)
+    end
+
+    def http_delete(path = '')
+      response = self.class.delete(
+        @base_url + path,
+        headers: @headers
+      )
+      validate(response)
+    end
+
+    private
+
+    def validate(response)
+      raise HTTPError.new(response.code, response.message, response.body) unless response.success?
+
+      response.parsed_response
+    end
+  end
+end

data/lib/meilisearch/index.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'meilisearch/http_request'
+require 'meilisearch/index/base'
+require 'meilisearch/index/documents'
+require 'meilisearch/index/search'
+require 'meilisearch/index/stats'
+require 'meilisearch/index/settings'
+require 'meilisearch/index/updates'
+require 'meilisearch/index/stop_words'
+require 'meilisearch/index/synonyms'
+
+module MeiliSearch
+  class Index < HTTPRequest
+    include MeiliSearch::Index::Base
+    include MeiliSearch::Index::Documents
+    include MeiliSearch::Index::Search
+    include MeiliSearch::Index::Stats
+    include MeiliSearch::Index::Settings
+    include MeiliSearch::Index::Updates
+    include MeiliSearch::Index::StopWords
+    include MeiliSearch::Index::Synonyms
+
+    attr_reader :uid
+
+    def initialize(index_uid, url, api_key = nil)
+      @uid = index_uid
+      super(url, api_key)
+    end
+
+    def name
+      index_name_from_uid
+    end
+    alias get_name name
+
+    private
+
+    def index_name_from_uid
+      show['name']
+    end
+  end
+end

data/lib/meilisearch/index/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Base
+      def show
+        http_get "/indexes/#{@uid}"
+      end
+      alias show_index show
+
+      def schema
+        http_get "/indexes/#{@uid}/schema"
+      rescue HTTPError => e
+        raise if e.body_message != 'missing index schema'
+
+        nil
+      end
+      alias get_schema schema
+
+      def update_name(new_index_name)
+        http_put "/indexes/#{@uid}", name: new_index_name
+      end
+      alias update_index_name update_name
+
+      def update_schema(new_schema)
+        http_put "/indexes/#{@uid}/schema", new_schema
+      end
+      alias update_index_schema update_schema
+
+      def delete
+        http_delete "/indexes/#{@uid}"
+      end
+      alias delete_index delete
+    end
+  end
+end

data/lib/meilisearch/index/documents.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Documents
+      def document(document_id)
+        encode_document = URI.encode_www_form_component(document_id)
+        http_get "/indexes/#{@uid}/documents/#{encode_document}"
+      end
+      alias get_document document
+      alias get_one_document document
+
+      def documents(options = {})
+        http_get "/indexes/#{@uid}/documents", options
+      end
+      alias get_documents documents
+
+      def add_documents(documents)
+        documents = [documents] if documents.is_a?(Hash)
+        http_post "/indexes/#{@uid}/documents", documents
+      end
+      alias replace_documents add_documents
+      alias add_or_replace_documents add_documents
+
+      def update_documents(documents)
+        documents = [documents] if documents.is_a?(Hash)
+        http_put "/indexes/#{@uid}/documents", documents
+      end
+      alias add_or_update_documents update_documents
+
+      def clear_documents
+        http_delete "/indexes/#{@uid}/documents"
+      end
+      alias clear_all_documents clear_documents
+
+      def delete_documents(documents_ids)
+        if documents_ids.is_a?(Array)
+          http_post "/indexes/#{@uid}/documents/delete", documents_ids
+        else
+          delete_document(documents_ids)
+        end
+      end
+      alias delete_multiple_documents delete_documents
+
+      def delete_document(document_id)
+        encode_document = URI.encode_www_form_component(document_id)
+        http_delete "/indexes/#{@uid}/documents/#{encode_document}"
+      end
+      alias delete_one_document delete_document
+    end
+  end
+end

data/lib/meilisearch/index/search.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Search
+      def search(query, options = {})
+        http_get "/indexes/#{@uid}/search", { q: query }.merge(options)
+      end
+    end
+  end
+end

data/lib/meilisearch/index/settings.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Settings
+      def settings
+        http_get "/indexes/#{@uid}/settings"
+      end
+      alias get_settings settings
+
+      def add_or_replace_settings(options)
+        http_post "/indexes/#{@uid}/settings", options
+      end
+      alias add_settings add_or_replace_settings
+      alias replace_settings add_or_replace_settings
+
+      def reset_all_settings
+        body = {
+          rankingOrder: nil,
+          distinctField: nil,
+          rankingRules: nil
+        }
+        http_post "/indexes/#{@uid}/settings", body
+      end
+    end
+  end
+end

data/lib/meilisearch/index/stats.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Stats
+      def stats
+        http_get "/stats/#{@uid}"
+      end
+
+      def number_of_documents
+        stats['numberOfDocuments']
+      end
+
+      def indexing?
+        stats['isIndexing']
+      end
+
+      def last_update
+        stats['lastUpdate']
+      end
+
+      def fields_frequency
+        stats['fieldsFrequency']
+      end
+    end
+  end
+end

data/lib/meilisearch/index/stop_words.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module StopWords
+      def stop_words
+        http_get "/indexes/#{@uid}/stop-words"
+      end
+      alias get_stop_words stop_words
+
+      def add_stop_words(stop_words)
+        if stop_words.is_a?(Array)
+          http_patch "/indexes/#{@uid}/stop-words", stop_words
+        else
+          http_patch "/indexes/#{@uid}/stop-words", [stop_words]
+        end
+      end
+
+      def delete_stop_words(stop_words)
+        if stop_words.is_a?(Array)
+          http_post "/indexes/#{@uid}/stop-words", stop_words
+        else
+          http_post "/indexes/#{@uid}/stop-words", [stop_words]
+        end
+      end
+    end
+  end
+end

data/lib/meilisearch/index/synonyms.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Synonyms
+      def synonyms_of(synonym)
+        encode_synonym = URI.encode_www_form_component(synonym)
+        http_get "/indexes/#{@uid}/synonyms/#{encode_synonym}"
+      end
+      alias get_synonyms_of_one_sequence synonyms_of
+      alias get_synonyms_of synonyms_of
+
+      def all_synonyms
+        http_get "/indexes/#{@uid}/synonyms"
+      end
+      alias get_all_synonyms all_synonyms
+      alias get_all_sequences all_synonyms
+
+      def add_synonyms(synonyms)
+        http_post "/indexes/#{@uid}/synonyms", synonyms
+      end
+
+      def add_synonyms_one_way(input, synonyms)
+        add_synonyms(input: input, synonyms: synonyms)
+      end
+
+      def add_synonyms_multi_way(synonyms)
+        add_synonyms(synonyms: synonyms)
+      end
+
+      def update_synonym(synonym, new_synonyms)
+        encode_synonym = URI.encode_www_form_component(synonym)
+        http_put "/indexes/#{@uid}/synonyms/#{encode_synonym}", new_synonyms
+      end
+
+      def delete_synonym(synonym)
+        encode_synonym = URI.encode_www_form_component(synonym)
+        http_delete "/indexes/#{@uid}/synonyms/#{encode_synonym}"
+      end
+      alias delete_one_synonym delete_synonym
+
+      def batch_write_synonyms(synonyms)
+        http_post "/indexes/#{@uid}/synonyms/batch", synonyms
+      end
+
+      def clear_synonyms
+        http_delete "/indexes/#{@uid}/synonyms"
+      end
+      alias clear_all_synonyms clear_synonyms
+    end
+  end
+end

data/lib/meilisearch/index/updates.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  class Index < HTTPRequest
+    module Updates
+      def get_update_status(update_id)
+        http_get "/indexes/#{@uid}/updates/#{update_id}"
+      end
+
+      def get_all_update_status
+        http_get "/indexes/#{@uid}/updates"
+      end
+    end
+  end
+end

data/lib/meilisearch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  VERSION = '0.1.0'
+  VERSION = '0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meilisearch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Meili
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-20 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.17.1
-description: A simple ruby client for Meilisearch API. See https://github.com/meilisearch/MeiliDB
+description: An easy-to-use ruby client for Meilisearch API. See https://github.com/meilisearch/MeiliSearch
 email: bonjour@meilisearch.com
 executables: []
 extensions: []
@@ -32,18 +32,23 @@ extra_rdoc_files: []
 files:
 - lib/meilisearch.rb
 - lib/meilisearch/client.rb
-- lib/meilisearch/client/documents.rb
 - lib/meilisearch/client/health.rb
 - lib/meilisearch/client/indexes.rb
 - lib/meilisearch/client/keys.rb
-- lib/meilisearch/client/objects.rb
-- lib/meilisearch/client/prepare.rb
-- lib/meilisearch/client/search.rb
 - lib/meilisearch/client/stats.rb
-- lib/meilisearch/dataset.rb
 - lib/meilisearch/error.rb
+- lib/meilisearch/http_request.rb
+- lib/meilisearch/index.rb
+- lib/meilisearch/index/base.rb
+- lib/meilisearch/index/documents.rb
+- lib/meilisearch/index/search.rb
+- lib/meilisearch/index/settings.rb
+- lib/meilisearch/index/stats.rb
+- lib/meilisearch/index/stop_words.rb
+- lib/meilisearch/index/synonyms.rb
+- lib/meilisearch/index/updates.rb
 - lib/meilisearch/version.rb
-homepage: https://github.com/meilisearch/ruby-meili-api
+homepage: https://github.com/meilisearch/meilisearch-ruby
 licenses:
 - MIT
 metadata: {}
@@ -65,5 +70,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: A simple ruby client for Meilisearch API
+summary: An easy-to-use ruby client for Meilisearch API
 test_files: []

data/lib/meilisearch/client/documents.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module MeiliSearch
-  class Client
-    module Documents
-      def add_documents(index_name, documents)
-        documents.each_slice(1000).map do |slice|
-          post "/indexes/#{index_name}/documents", slice
-        end
-      end
-
-      def document(index_name, document_uid)
-        get "/indexes/#{index_name}/documents/#{document_uid}"
-      end
-
-      def get_all_documents(index_name)
-        get "/indexes/#{index_name}/documents"
-      end
-
-      def batch_documents
-        raise NotImplementedError
-      end
-
-      def update_documents
-        raise NotImplementedError
-      end
-
-      def delete_one_document(index_name, document_uid)
-        delete "/indexes/#{index_name}/documents/#{document_uid}"
-      end
-
-      def delete_multiple_documents(index_name, document_uids)
-        post "/indexes/#{index_name}/documents/delete", document_uids
-      end
-
-      def clear_all_documents(index_name)
-        delete "/indexes/#{index_name}/documents"
-      end
-    end
-  end
-end

data/lib/meilisearch/client/objects.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module MeiliSearch
-  class Client
-    module Objects
-      def add_objects(index_name, objects)
-        if objects.size <= 1000
-          post "/indexes/#{index_name}/objects", objects
-        else
-          objects.each_slice(1000) do |slice|
-            post "/indexes/#{index_name}/objects", slice
-          end
-        end
-      end
-
-      def object(index_name, object_identifier)
-        get "/indexes/#{index_name}/objects/#{object_identifier}"
-      end
-
-      def browse(index_name)
-        get "/indexes/#{index_name}/objects"
-      end
-
-      def batch_objects
-        raise NotImplementedError
-      end
-
-      def update_objects
-        raise NotImplementedError
-      end
-
-      def delete_objects(index_name, object_ids)
-        delete "/indexes/#{index_name}/objects", object_ids
-      end
-    end
-  end
-end

data/lib/meilisearch/client/prepare.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module MeiliSearch
-  class Client
-    module Prepare
-      def rollout
-        put '/prepare/rollout'
-      end
-    end
-  end
-end

data/lib/meilisearch/client/search.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module MeiliSearch
-  class Client
-    module Search
-      def search(index_uid, query, options = {})
-        get "/indexes/#{index_uid}/search", { q: query }.merge(options)
-      end
-    end
-  end
-end

data/lib/meilisearch/dataset.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module MeiliSearch
-  # This class represents the dataset we can index
-  class Dataset
-    class NotEnumerable < StandardError; end
-    class CannotDetermineHeader < StandardError; end
-    class ExtensionNotRecognized < StandardError; end
-
-    attr_accessor :data
-
-    def self.new_from_s3(s3_file)
-      filename = s3_file.filename.to_s
-      if filename.match?(/.csv$/)
-        data = CSV.parse(s3_file.download, headers: true)
-      elsif filename.match?(/.json$/)
-        data = JSON.parse(s3_file.download)
-      else
-        raise Dataset::ExtensionNotRecognized
-      end
-      new(data)
-    end
-
-    def initialize(data)
-      @data = data
-      raise Dataset::NotEnumerable unless enumerable?
-    end
-
-    def clean
-      encode_to_utf8
-      replace_nil_values
-      @data
-    end
-
-    def headers
-      if @data.class == Array
-        @data.first.keys
-      elsif @data.class == CSV::Table
-        @data.headers
-      else
-        raise CannotDetermineHeader
-      end
-    end
-
-    def schema
-      schema = headers.map do |attribute|
-        [attribute, [:indexed, :displayed]]
-      end.to_h
-
-      # Find first attribute containing id
-      identifier = headers.detect { |attribute| attribute[/id/i] }
-
-      # Then give it the :identifier attribute
-      schema[identifier].push :identifier
-      schema
-    end
-
-    private
-
-    def replace_nil_values
-      @data = @data.map do |record|
-        record.each do |key, value|
-          record[key] = '' if value.nil?
-        end
-      end
-    end
-
-    def encode_to_utf8
-      @data = @data.map(&:to_h).map(&:to_utf8)
-    end
-
-    def enumerable?
-      @data.respond_to? :each
-    end
-  end
-end