3 params added to the client in order to support all params in the doc: (#369)

- offset
- length
- disableExactOnAttributes

Author: spinach

Source/Query.swift

@@ -338,6 +338,13 @@ open class Query : AbstractQuery {
         }
     }
 
+    /// List of attributes on which you want to disable computation of the `exact` ranking criterion
+    /// The list must be a subset of the `searchableAttributes` index setting.
+    @objc public var disableExactOnAttributes: [String]? {
+        get { return Query.parseStringArray(self["disableExactOnAttributes"]) }
+        set { self["disableExactOnAttributes"] = Query.buildJSONArray(newValue) }
+    }
+    
     /// Applicable values for the `exactOnSingleWordQuery` parameter.
     public enum ExactOnSingleWordQuery: String {
         /// No exact on single word query.
@@ -422,6 +429,22 @@ open class Query : AbstractQuery {
         set { self["hitsPerPage"] = Query.buildUInt(newValue) }
     }
 
+    /// Offset of the first hit to return (zero-based).
+    ///
+    /// + Note: In most cases, page/hitsPerPage is the recommended method for pagination.
+    public var offset: UInt? {
+        get { return Query.parseUInt(self["offset"]) }
+        set { self["offset"] = Query.buildUInt(newValue) }
+    }
+    
+    /// Maximum number of hits to return. (1000 is the maximum)
+    ///
+    /// +Note: In most cases, page/hitsPerPage is the recommended method for pagination.
+    public var length: UInt? {
+        get { return Query.parseUInt(self["length"]) }
+        set { self["length"] = Query.buildUInt(newValue) }
+    }
+    
     // MARK: Parameters to control results content
 
     /// List of object attributes you want to retrieve (let you minimize the answer size). You can also use `*` to
@@ -974,6 +997,18 @@ open class Query : AbstractQuery {
         get { return AbstractQuery.toNumber(self.hitsPerPage) }
         set { self.hitsPerPage = newValue?.uintValue }
     }
+    
+    @objc(offset)
+    public var z_objc_offset: NSNumber? {
+        get { return AbstractQuery.toNumber(self.offset) }
+        set { self.offset = newValue?.uintValue }
+    }
+    
+    @objc(length)
+    public var z_objc_length: NSNumber? {
+        get { return AbstractQuery.toNumber(self.length) }
+        set { self.length = newValue?.uintValue }
+    }
 
     @objc(getRankingInfo)
     public var z_objc_getRankingInfo: NSNumber? {

Tests/ObjectiveCBridging.m

@@ -92,10 +92,13 @@ - (void)testQuery {
     query.removeWordsIfNoResults = @"allOptional";
     query.disableTypoToleranceOnAttributes = @[ @"foo", @"bar" ];
     query.removeStopWords = @[ @"en", @"fr" ];
+    query.disableExactOnAttributes = @[ @"foo", @"bar" ];
     query.exactOnSingleWordQuery = @"attribute";
     query.alternativesAsExact = @[ @"foo", @"bar" ];
     query.page = [NSNumber numberWithInt:6];
     query.hitsPerPage = [NSNumber numberWithInt:66];
+    query.offset = [NSNumber numberWithInt:4];
+    query.length = [NSNumber numberWithInt:4];
     query.attributesToRetrieve = @[ @"foo", @"bar" ];
     query.attributesToHighlight = @[ @"foo", @"bar" ];
     query.attributesToSnippet = @[ @"foo", @"bar" ];
@@ -511,6 +514,28 @@ - (void)test_hitsPerPage {
     XCTAssertEqualObjects(query2.hitsPerPage, value);
 }
 
+- (void)test_offset {
+    Query* query1 = [Query new];
+    XCTAssertNil(query1.offset);
+    
+    NSNumber* value = [NSNumber numberWithInt:4];
+    query1.offset = value;
+    XCTAssertEqualObjects(query1[@"offset"], @"4");
+    Query* query2 = [Query parse:[query1 build]];
+    XCTAssertEqualObjects(query2.offset, value);
+}
+
+- (void)test_length {
+    Query* query1 = [Query new];
+    XCTAssertNil(query1.length);
+    
+    NSNumber* value = [NSNumber numberWithInt:4];
+    query1.length = value;
+    XCTAssertEqualObjects(query1[@"length"], @"4");
+    Query* query2 = [Query parse:[query1 build]];
+    XCTAssertEqualObjects(query2.length, value);
+}
+
 - (void)test_getRankingInfo {
     Query* query1 = [Query new];
     XCTAssertNil(query1.getRankingInfo);

Tests/QueryTests.swift

@@ -263,6 +263,26 @@ class QueryTests: XCTestCase {
         XCTAssertEqual(query2.hitsPerPage, 50)
     }
 
+    func test_offset() {
+        let query1 = Query()
+        XCTAssertNil(query1.offset)
+        query1.offset = 4
+        XCTAssertEqual(query1.offset, 4)
+        XCTAssertEqual(query1["offset"], "4")
+        let query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.offset, 4)
+    }
+    
+    func test_length() {
+        let query1 = Query()
+        XCTAssertNil(query1.length)
+        query1.length = 4
+        XCTAssertEqual(query1.length, 4)
+        XCTAssertEqual(query1["length"], "4")
+        let query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.length, 4)
+    }
+    
     func test_allowTyposOnNumericTokens() {
         let query1 = Query()
         XCTAssertNil(query1.allowTyposOnNumericTokens)
@@ -703,6 +723,16 @@ class QueryTests: XCTestCase {
         XCTAssertEqual(query2.filters, VALUE)
     }
 
+    func test_disableExactOnAttributes() {
+        let query1 = Query()
+        XCTAssertNil(query1.disableExactOnAttributes)
+        query1.disableExactOnAttributes = ["foo", "bar"]
+        XCTAssertEqual(query1.disableExactOnAttributes!, ["foo", "bar"])
+        XCTAssertEqual(query1["disableExactOnAttributes"], "[\"foo\",\"bar\"]")
+        let query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.disableExactOnAttributes!, ["foo", "bar"])
+    }
+    
     func test_exactOnSingleWordQuery() {
         let query1 = Query()
         XCTAssertNil(query1.exactOnSingleWordQuery)