swiftype-app-search 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ed5f865b5826a9e1f6ef4159e8666f40854d88507d5e385ade79843be1ec328
-  data.tar.gz: 8de8289db41e4b425c88890c7e9ec9d2347b6f234654c0813d9f79b51c40601c
+  metadata.gz: c0889b18cde354daea10527a1e192cd972e0d7c539fa4bbee73b2683de3b3822
+  data.tar.gz: 0b65d19dcf830652d055ead107abdc554dcb28f3f5d74d528d2be5d53cf15d63
 SHA512:
-  metadata.gz: 2fd5aafef38257cae51fc924825020cceb127c980d54c26e6011ee28a3b620d8143fa94e56d49de5fd9e646e3509f2242afbc425da220a013e040d6f6e2aa3f8
-  data.tar.gz: d78bda22152a9e4046582612c136a63bdd3a18daa0d1a305a847ac04a4f90b077a9805f17f7c638807fba3dd58702143b861fe29158a2032ec6a7c5cadc2c3da
+  metadata.gz: cfe38cefe4f27e5d3056041b6166ce7779f759b77600d10bf345959dfaa2661f76543d44fbaac028814da267620824a5112334b424c18c6b9ed3c1f9bdd49fe8
+  data.tar.gz: 1ceada4a0bbb951a2c4a3885f683a3d5fb148569cdeb386ce9a224d7621d0402a0e33a3e424fada53b017efa9d5c5efc3b2c837a51bca6eff6a411a4a70e5803

data/README.md

@@ -10,7 +10,7 @@ To install the gem, execute:
 gem install swiftype-app-search
 ```
 
-Or place `gem 'swiftype-app-search', '~> 0.1.3` in your `Gemfile` and run `bundle install`.
+Or place `gem 'swiftype-app-search', '~> 0.4.0` in your `Gemfile` and run `bundle install`.
 
 ## Usage
 
@@ -42,15 +42,10 @@ document = {
   :body => 'A wonderful video of a magnificent cat.'
 }
 
-begin
-  response = client.index_document(engine_name, document)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.index_document(engine_name, document)
 ```
 
-#### Indexing: Creating or Updating Documents
+#### Indexing: Creating or Replacing Documents
 
 ```ruby
 engine_name = 'favorite-videos'
@@ -69,26 +64,37 @@ documents = [
   }
 ]
 
-begin
-  response = client.index_documents(engine_name, documents)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.index_documents(engine_name, documents)
 ```
 
-#### Listing Documents
+#### Indexing: Updating Documents (Partial Updates)
+
+```ruby
+engine_name = 'favorite-videos'
+documents = [
+  {
+    :id => 'INscMGmhmX4',
+    :title => 'Updated title'
+  }
+]
+
+client.update_documents(engine_name, documents)
+```
+
+#### Retrieving Documents
 
 ```ruby
 engine_name = 'favorite-videos'
 document_ids = ['INscMGmhmX4', 'JNDFojsd02']
 
-begin
-  response = client.get_documents(engine_name, document_ids)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.get_documents(engine_name, document_ids)
+```
+
+#### Listing Documents
+```ruby
+engine_name = 'favorite-videos'
+
+client.list_documents(engine_name)
 ```
 
 #### Destroying Documents
@@ -97,23 +103,13 @@ end
 engine_name = 'favorite-videos'
 document_ids = ['INscMGmhmX4', 'JNDFojsd02']
 
-begin
-  response = client.destroy_documents(engine_name, document_ids)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.destroy_documents(engine_name, document_ids)
 ```
 
 #### Listing Engines
 
 ```ruby
-begin
-  response = client.list_engines
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.list_engines
 ```
 
 #### Retrieving Engines
@@ -121,12 +117,7 @@ end
 ```ruby
 engine_name = 'favorite-videos'
 
-begin
-  response = client.get_engine(engine_name)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.get_engine(engine_name)
 ```
 
 #### Creating Engines
@@ -134,12 +125,7 @@ end
 ```ruby
 engine_name = 'favorite-videos'
 
-begin
-  response = client.create_engine(engine_name)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.create_engine(engine_name)
 ```
 
 #### Destroying Engines
@@ -147,12 +133,7 @@ end
 ```ruby
 engine_name = 'favorite-videos'
 
-begin
-  response = client.destroy_engine(engine_name)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.destroy_engine(engine_name)
 ```
 
 #### Searching
@@ -164,12 +145,23 @@ search_fields = { :title => {} }
 result_fields = { :title => { :raw => {} } }
 options = { :search_fields => search_fields, :result_fields => result_fields }
 
-begin
-  response = client.search(engine_name, query, options)
-  puts response
-rescue SwiftypeAppSearch::ClientException => e
-  puts e
-end
+client.search(engine_name, query, options)
+```
+
+#### Multi-Search
+
+```ruby
+engine_name = 'favorite-videos'
+
+queries = [{
+  :query => 'cat',
+  :options => { :search_fields => { :title => {} }}
+},{
+  :query => 'dog',
+  :options => { :search_fields => { :body => {} }}
+}]
+
+client.multi_search(engine_name, queries)
 ```
 
 ## Running Tests

data/lib/swiftype-app-search/client/documents.rb

@@ -5,13 +5,23 @@ module SwiftypeAppSearch
   class Client
     module Documents
 
-      # Retrieve Documents from the API by IDs for the {App Search API}[https://swiftype.com/documentation/app-search/]
+      # Retrieve all Documents from the API for the {App Search API}[https://swiftype.com/documentation/app-search/]
       #
       # @param [String] engine_name the unique Engine name
-      # @param [Array<String>] ids an Array of Document IDs
+      # @option options see the {App Search API}[https://swiftype.com/documentation/app-search/] for supported options.
       #
       # @return [Array<Hash>] an Array of Documents
+      def list_documents(engine_name, options = {})
+        params = Utils.symbolize_keys(options)
+        request(:get, "engines/#{engine_name}/documents/list", params)
+      end
 
+      # Retrieve Documents from the API by IDs for the {App Search API}[https://swiftype.com/documentation/app-search/]
+      #
+      # @param [String] engine_name the unique Engine name
+      # @param [Array<String>] ids an Array of Document IDs
+      #
+      # @return [Hash] list results
       def get_documents(engine_name, ids)
         get("engines/#{engine_name}/documents", ids)
       end
@@ -46,6 +56,20 @@ module SwiftypeAppSearch
         post("engines/#{engine_name}/documents", documents)
       end
 
+      # Update a batch of documents using the {App Search API}[https://swiftype.com/documentation/app-search/].
+      #
+      # @param [String] engine_name the unique Engine name
+      # @param [Array] documents an Array of Document Hashes including valid ids
+      #
+      # @return [Array<Hash>] an Array of processed Document Status hashes
+      #
+      # @raise [SwiftypeAppSearch::InvalidDocument] when any documents have processing errors returned from the api
+      # @raise [Timeout::Error] when timeout expires waiting for statuses
+      def update_documents(engine_name, documents)
+        documents.map! { |document| normalize_document(document) }
+        patch("engines/#{engine_name}/documents", documents)
+      end
+
       # Destroy a batch of documents given a list of IDs
       #
       # @param [Array<String>] ids an Array of Document IDs

data/lib/swiftype-app-search/client/engines.rb

@@ -11,8 +11,10 @@ module SwiftypeAppSearch
         get("engines/#{engine_name}")
       end
 
-      def create_engine(engine_name)
-        post("engines", :name => engine_name)
+      def create_engine(engine_name, language = nil)
+        params = { :name => engine_name }
+        params[:language] = language if language
+        post("engines", params)
       end
 
       def destroy_engine(engine_name)

data/lib/swiftype-app-search/client/search.rb

@@ -7,11 +7,30 @@ module SwiftypeAppSearch
       # @param [String] query the search query
       # @option options see the {App Search API}[https://swiftype.com/documentation/app-search/] for supported search options.
       #
-      # @return [Array<Hash>] an Array of Document destroy result hashes
+      # @return [Hash] search results
       def search(engine_name, query, options = {})
         params = Utils.symbolize_keys(options).merge(:query => query)
         request(:post, "engines/#{engine_name}/search", params)
       end
+
+      # Run multiple searches for documents on a single request
+      #
+      # @param [String] engine_name the unique Engine name
+      # @param [{query: String, options: Hash}] searches to execute
+      # see the {App Search API}[https://swiftype.com/documentation/app-search/] for supported search options.
+      #
+      # @return [Array<Hash>] an Array of searh sesults
+      def multi_search(engine_name, searches)
+        params = searches.map do |search|
+          search = Utils.symbolize_keys(search)
+          query = search[:query]
+          options = search[:options] || {}
+          Utils.symbolize_keys(options).merge(:query => query)
+        end
+        request(:post, "engines/#{engine_name}/multi_search", {
+          queries: params
+        })
+      end
     end
   end
 end

data/lib/swiftype-app-search/version.rb

@@ -1,3 +1,3 @@
 module SwiftypeAppSearch
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/spec/client_spec.rb

@@ -98,6 +98,143 @@ describe SwiftypeAppSearch::Client do
         end
       end
     end
+
+    describe '#update_documents' do
+      let(:documents) { [document, second_document] }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+      let(:updates) { [ {
+        'id' => second_document_id,
+        'url' => 'https://www.example.com'
+      } ] }
+
+      subject { client.update_documents(engine_name, updates) }
+
+      before do
+        client.index_documents(engine_name, documents)
+      end
+
+      # Note that since indexing a document takes up to a minute,
+      # we don't expect this to succeed, so we simply verify that
+      # the request responded with the correct 'id', even though
+      # the 'errors' object likely contains errors.
+      it 'should update existing documents' do
+        response = subject
+        expect(subject).to match(['id' => second_document_id, 'errors' => anything])
+      end
+    end
+
+    describe '#get_documents' do
+      let(:documents) { [first_document, second_document] }
+      let(:first_document_id) { 'id' }
+      let(:first_document) { { 'id' => first_document_id, 'url' => 'https://www.youtube.com/watch?v=v1uyQZNg2vE' } }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+
+      subject { client.get_documents(engine_name, [first_document_id, second_document_id]) }
+
+      before do
+        client.index_documents(engine_name, documents)
+      end
+
+      it 'will return documents by id' do
+        response = subject
+        expect(response.size).to eq(2)
+        expect(response[0]['id']).to eq(first_document_id)
+        expect(response[1]['id']).to eq(second_document_id)
+      end
+    end
+
+    describe '#list_documents' do
+      let(:documents) { [first_document, second_document] }
+      let(:first_document_id) { 'id' }
+      let(:first_document) { { 'id' => first_document_id, 'url' => 'https://www.youtube.com/watch?v=v1uyQZNg2vE' } }
+      let(:second_document_id) { 'another_id' }
+      let(:second_document) { { 'id' => second_document_id, 'url' => 'https://www.youtube.com/watch?v=9T1vfsHYiKY' } }
+
+      before do
+        client.index_documents(engine_name, documents)
+      end
+
+      context 'when no options are specified' do
+        it 'will return all documents' do
+          response = client.list_documents(engine_name)
+          expect(response['results'].size).to eq(2)
+          expect(response['results'][0]['id']).to eq(first_document_id)
+          expect(response['results'][1]['id']).to eq(second_document_id)
+        end
+      end
+
+      context 'when options are specified' do
+        it 'will return all documents' do
+          response = client.list_documents(engine_name, {page: { size: 1, current: 2}})
+          expect(response['results'].size).to eq(1)
+          expect(response['results'][0]['id']).to eq(second_document_id)
+        end
+      end
+    end
+  end
+
+  context 'Search' do
+    # Note that since indexing a document takes up to a minute,
+    # don't actually expect results to be present, just that
+    # the request was made
+
+    before do
+      client.create_engine(engine_name) rescue SwiftypeAppSearch::BadRequest
+    end
+
+    after do
+      client.destroy_engine(engine_name) rescue SwiftypeAppSearch::NonExistentRecord
+    end
+
+    describe '#search' do
+      subject { client.search(engine_name, query, options) }
+      let (:query) { '' }
+      let (:options) { { 'page' => { 'size' => 1 } } }
+
+      it 'should execute a search query' do
+        response = subject
+        expect(response).to have_key('meta')
+        expect(response).to have_key('results')
+      end
+    end
+
+    describe '#multi_search' do
+      subject { client.multi_search(engine_name, queries) }
+
+      context 'when options are provided' do
+        let (:queries) { [
+          {'query': 'foo', 'options' => { 'page' => { 'size' => 1 } }},
+          {'query': 'bar', 'options' => { 'page' => { 'size' => 1 } }}
+        ] }
+
+        it 'should execute a multi search query' do
+          response = subject
+          expect(response.size).to eq(2)
+          expect(response[0]).to have_key('results')
+          expect(response[0]).to have_key('meta')
+          expect(response[1]).to have_key('results')
+          expect(response[1]).to have_key('meta')
+        end
+      end
+
+      context 'when options are omitted' do
+        let (:queries) { [
+          {'query': 'foo' },
+          {'query': 'bar' }
+        ] }
+
+        it 'should execute a multi search query' do
+          response = subject
+          expect(response.size).to eq(2)
+          expect(response[0]).to have_key('results')
+          expect(response[0]).to have_key('meta')
+          expect(response[1]).to have_key('results')
+          expect(response[1]).to have_key('meta')
+        end
+      end
+    end
   end
 
   context 'Engines' do
@@ -112,6 +249,12 @@ describe SwiftypeAppSearch::Client do
         expect { client.get_engine(engine_name) }.to_not raise_error
       end
 
+      it 'should accept an optional language parameter' do
+        expect { client.get_engine(engine_name) }.to raise_error(SwiftypeAppSearch::NonExistentRecord)
+        client.create_engine(engine_name, 'da')
+        expect(client.get_engine(engine_name)).to match('name' => anything, 'type' => anything, 'language' => 'da')
+      end
+
       it 'should return an engine object' do
         engine = client.create_engine(engine_name)
         expect(engine).to be_kind_of(Hash)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swiftype-app-search
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Quin Hoxie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-12 00:00:00.000000000 Z
+date: 2018-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print