Add support for a list of languages in the ignorePlurals query parameter

This change is similar to what was done for the `removeStopWords` parameter.

WARNING: This change is not backward-compatible; there is nothing much we can do about it if we want to support the new values.

Author: Clément Le Provost

Source/Query.swift

@@ -309,11 +309,49 @@ public class Query : NSObject, NSCopying {
         set { self["allowTyposOnNumericTokens"] = Query.buildBool(newValue) }
     }
 
-    /// If set to true, simple plural forms won’t be considered as typos (for example car/cars will be considered as
-    /// equal).
-    public var ignorePlurals: Bool? {
-        get { return Query.parseBool(self["ignorePlurals"]) }
-        set { self["ignorePlurals"] = Query.buildBool(newValue) }
+    /// Applicable values for the `ignorePlurals` parameter.
+    public enum IgnorePlurals: Equatable {
+        /// Enable/disable plurals on all supported languages.
+        case all(Bool)
+        /// Enable plurals on a specific set of languages, identified by their ISO code.
+        case selected([String])
+        
+        // NOTE: Associated values disable automatic conformance to `Equatable`, so we have to implement it ourselves.
+        static public func ==(lhs: IgnorePlurals, rhs: IgnorePlurals) -> Bool {
+            switch (lhs, rhs) {
+            case (let .all(lhsValue), let .all(rhsValue)): return lhsValue == rhsValue
+            case (let .selected(lhsValue), let .selected(rhsValue)): return lhsValue == rhsValue
+            default: return false
+            }
+        }
+    }
+    
+    /// Consider singular and plurals forms alike to be a match without typo. For example, "car" and "cars", or "foot"
+    /// and "feet", will be considered equivalent. This parameter can be:
+    ///
+    /// You may enable this option for all languages at once (`.all`) or for a specific subset (`.selected`).
+    ///
+    public var ignorePlurals: IgnorePlurals? {
+        get {
+            let stringValue = self["ignorePlurals"]
+            if let boolValue = Query.parseBool(stringValue) {
+                return .all(boolValue)
+            } else if let arrayValue = Query.parseStringArray(stringValue) {
+                return .selected(arrayValue)
+            } else {
+                return nil
+            }
+        }
+        set {
+            if let newValue = newValue {
+                switch newValue {
+                case let .all(boolValue): self["ignorePlurals"] = Query.buildBool(boolValue)
+                case let .selected(arrayValue): self["ignorePlurals"] = Query.buildStringArray(arrayValue)
+                }
+            } else {
+                self["ignorePlurals"] = nil
+            }
+        }
     }
 
     /// List of attributes you want to use for textual search (must be a subset of the `searchableAttributes` index setting).
@@ -1066,9 +1104,28 @@ public class Query : NSObject, NSCopying {
     }
 
     @objc(ignorePlurals)
-    public var z_objc_ignorePlurals: NSNumber? {
-        get { return Query.toNumber(self.ignorePlurals) }
-        set { self.ignorePlurals = newValue?.boolValue }
+    public var z_objc_ignorePlurals: Any? {
+        get {
+            if let value = ignorePlurals {
+                switch value {
+                case let .all(boolValue): return NSNumber(value: boolValue)
+                case let .selected(arrayValue): return arrayValue
+                }
+            } else {
+                return nil
+            }
+        }
+        set {
+            if let boolValue = newValue as? Bool {
+                ignorePlurals = .all(boolValue)
+            } else if let numberValue = newValue as? NSNumber {
+                ignorePlurals = .all(numberValue.boolValue)
+            } else if let arrayValue = newValue as? [String] {
+                ignorePlurals = .selected(arrayValue)
+            } else {
+                ignorePlurals = nil
+            }
+        }
     }
 
     @objc(advancedSyntax)

Tests/ObjectiveCBridging.m

@@ -348,11 +348,19 @@ - (void)test_ignorePlurals {
     Query* query1 = [Query new];
     XCTAssertNil(query1.ignorePlurals);
 
-    NSNumber* value = [NSNumber numberWithBool:YES];
-    query1.ignorePlurals = value;
-    XCTAssertEqualObjects(query1[@"ignorePlurals"], @"true");
-    Query* query2 = [Query parse:[query1 build]];
-    XCTAssertEqualObjects(query2.ignorePlurals, value);
+    NSArray* VALUES = @[ [NSNumber numberWithBool:YES], [NSNumber numberWithBool:NO], @[ @"de", @"en", @"fr"] ];
+    NSArray* RAW_VALUES = @[ @"true", @"false", @"de,en,fr" ];
+    for (int i = 0; i < VALUES.count; ++i) {
+        query1.ignorePlurals = VALUES[i];
+        XCTAssertEqualObjects(query1[@"ignorePlurals"], RAW_VALUES[i]);
+        Query* query2 = [Query parse:[query1 build]];
+        XCTAssertEqualObjects(query2.ignorePlurals, VALUES[i]);
+    }
+    
+    // WARNING: There is no validation of ISO codes, so any string is interpreted as a single language.
+    query1[@"ignorePlurals"] = @"invalid";
+    XCTAssertNotNil(query1.ignorePlurals);
+    XCTAssertEqual(1, ((NSArray*)query1.ignorePlurals).count);
 }
 
 - (void)test_advancedSyntax {

Tests/QueryTests.swift

@@ -150,17 +150,33 @@ class QueryTests: XCTestCase {
     func test_ignorePlurals() {
         let query1 = Query()
         XCTAssertNil(query1.ignorePlurals)
-        query1.ignorePlurals = true
-        XCTAssertEqual(query1.ignorePlurals, true)
+
+        query1.ignorePlurals = .all(true)
+        XCTAssertEqual(query1.ignorePlurals, .all(true))
         XCTAssertEqual(query1["ignorePlurals"], "true")
-        let query2 = Query.parse(query1.build())
-        XCTAssertEqual(query2.ignorePlurals, true)
+        var query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.ignorePlurals, .all(true))
 
-        query1.ignorePlurals = false
-        XCTAssertEqual(query1.ignorePlurals, false)
+        query1.ignorePlurals = .all(false)
+        XCTAssertEqual(query1.ignorePlurals, .all(false))
         XCTAssertEqual(query1["ignorePlurals"], "false")
         let query3 = Query.parse(query1.build())
-        XCTAssertEqual(query3.ignorePlurals, false)
+        XCTAssertEqual(query3.ignorePlurals, .all(false))
+
+        let VALUE = ["de", "en", "fr"]
+        query1.ignorePlurals = .selected(VALUE)
+        XCTAssertEqual(query1.ignorePlurals, .selected(VALUE))
+        XCTAssertEqual(query1["ignorePlurals"], "de,en,fr")
+        query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.ignorePlurals, .selected(VALUE))
+        
+        // WARNING: There's no validation of ISO codes, so any string is interpreted as a single code.
+        query1["ignorePlurals"] = "invalid"
+        XCTAssertNotNil(query1.ignorePlurals)
+        switch query1.ignorePlurals! {
+        case let .selected(values): XCTAssertEqual(1, values.count)
+        default: XCTFail()
+        }
     }
 
     func test_distinct() {