Merge branch 'feat/exactOnSingleWordQuery'

Author: Clément Le Provost

ChangeLog.md

@@ -7,6 +7,8 @@ Change Log
   corresponding property had to be degraded from `Bool?` to `AnyObject?`; as a consequence, the getter suffers from an
   incompatible change (but not the setter).
 - (#79) Support `aroundRadius=all` in query parameters.
+- (#76) Support the `exactOnSingleWordQuery` query parameter
+- (#76) Support the `alternativesAsExact` query parameter
 
 
 ## 3.2.1 (2016-05-27)

Source/Query.swift

@@ -459,6 +459,79 @@ public func ==(lhs: LatLng, rhs: LatLng) -> Bool {
         }
     }
 
+    /// This parameter control how the exact ranking criterion is computed when the query contains one word.
+    @objc public var exactOnSingleWordQuery: String? {
+        get { return exactOnSingleWordQuery_?.rawValue }
+        set { exactOnSingleWordQuery_ = newValue == nil ? nil : ExactOnSingleWordQuery(rawValue: newValue!) }
+    }
+    public enum ExactOnSingleWordQuery: String {
+        /// No exact on single word query.
+        case None = "none"
+        /// Exact set to 1 if the query word is found in the record. The query word needs to have at least 3 chars and
+        /// not be part of our stop words dictionary.
+        case Word = "word"
+        /// (Default) Exact set to 1 if there is an attribute containing a string equals to the query.
+        case Attribute = "attribute"
+    }
+    public var exactOnSingleWordQuery_: ExactOnSingleWordQuery? {
+        get {
+            if let value = get("exactOnSingleWordQuery") {
+                return ExactOnSingleWordQuery(rawValue: value)
+            } else {
+                return nil
+            }
+        }
+        set {
+            set("exactOnSingleWordQuery", value: newValue?.rawValue)
+        }
+    }
+    
+    /// Specify the list of approximation that should be considered as an exact match in the ranking formula.
+    ///
+    /// - `ignorePlurals`: alternative word added by the ignore plurals feature
+    /// - `singleWordSynonym`: single word synonym (For example “NY” = “NYC”)
+    /// - `multiWordsSynonym`: synonym over multiple words (For example “NY” = “New York”)
+    ///
+    /// The default value is `ignorePlurals,singleWordSynonym`.
+    ///
+    @objc public var alternativesAsExact: [String]? {
+        get { return Query.parseStringArray(get("alternativesAsExact")) }
+        set { set("alternativesAsExact", value: newValue?.joinWithSeparator(",")) }
+    }
+    public enum AlternativesAsExact: String {
+        /// Alternative word added by the ignore plurals feature.
+        case IgnorePlurals = "ignorePlurals"
+        /// Single word synonym (For example “NY” = “NYC”).
+        case SingleWordSynonym = "singleWordSynonym"
+        /// Synonym over multiple words (For example “NY” = “New York”).
+        case MultiWordsSynonym = "multiWordsSynonym"
+    }
+    public var alternativesAsExact_: [AlternativesAsExact]? {
+        get {
+            if let rawValues = alternativesAsExact {
+                var values = [AlternativesAsExact]()
+                for rawValue in rawValues {
+                    if let value = AlternativesAsExact(rawValue: rawValue) {
+                        values.append(value)
+                    }
+                }
+                return values
+            } else {
+                return nil
+            }
+        }
+        set {
+            var rawValues : [String]?
+            if newValue != nil {
+                rawValues = []
+                for value in newValue! {
+                    rawValues?.append(value.rawValue)
+                }
+            }
+            alternativesAsExact = rawValues
+        }
+    }
+    
     // MARK: Pagination parameters
 
     /// Pagination parameter used to select the page to retrieve. Page is zero-based and defaults to 0. Thus, to

Tests/QueryTests.swift

@@ -659,4 +659,53 @@ class QueryTests: XCTestCase {
         XCTAssertEqual(query2.filters, VALUE)
     }
 
+    func test_exactOnSingleWordQuery() {
+        let query1 = Query()
+        XCTAssertNil(query1.exactOnSingleWordQuery_)
+        XCTAssertNil(query1.exactOnSingleWordQuery)
+        
+        let ALL_VALUES = [Query.ExactOnSingleWordQuery.None, Query.ExactOnSingleWordQuery.Word, Query.ExactOnSingleWordQuery.Attribute]
+        for value in ALL_VALUES {
+            query1.exactOnSingleWordQuery_ = value
+            XCTAssertEqual(query1.exactOnSingleWordQuery_, value)
+            XCTAssertEqual(query1.exactOnSingleWordQuery, value.rawValue)
+            XCTAssertEqual(query1["exactOnSingleWordQuery"], value.rawValue)
+            let query2 = Query.parse(query1.build())
+            XCTAssertEqual(query2.exactOnSingleWordQuery_, value)
+            
+            query1.exactOnSingleWordQuery = value.rawValue
+            XCTAssertEqual(query1.exactOnSingleWordQuery_, value)
+            XCTAssertEqual(query1.exactOnSingleWordQuery, value.rawValue)
+            XCTAssertEqual(query1["exactOnSingleWordQuery"], value.rawValue)
+        }
+        
+        query1["exactOnSingleWordQuery"] = "invalid"
+        XCTAssertNil(query1.exactOnSingleWordQuery_)
+        XCTAssertNil(query1.exactOnSingleWordQuery)
+        
+        query1.exactOnSingleWordQuery = "invalid"
+        XCTAssertNil(query1["exactOnSingleWordQuery"])
+        XCTAssertNil(query1.exactOnSingleWordQuery_)
+        XCTAssertNil(query1.exactOnSingleWordQuery)
+    }
+    
+    func test_alternativesAsExact() {
+        let query1 = Query()
+        XCTAssertNil(query1.alternativesAsExact_)
+        XCTAssertNil(query1.alternativesAsExact)
+
+        let VALUES = [Query.AlternativesAsExact.IgnorePlurals, Query.AlternativesAsExact.SingleWordSynonym, Query.AlternativesAsExact.MultiWordsSynonym]
+        let RAW_VALUES = ["ignorePlurals", "singleWordSynonym", "multiWordsSynonym"]
+        query1.alternativesAsExact_ = VALUES
+        XCTAssertEqual(query1.alternativesAsExact_!, VALUES)
+        XCTAssertEqual(query1.alternativesAsExact!, RAW_VALUES)
+        XCTAssertEqual(query1["alternativesAsExact"], RAW_VALUES.joinWithSeparator(","))
+        let query2 = Query.parse(query1.build())
+        XCTAssertEqual(query2.alternativesAsExact_!, VALUES)
+        
+        query1.alternativesAsExact = RAW_VALUES
+        XCTAssertEqual(query1.alternativesAsExact_!, VALUES)
+        XCTAssertEqual(query1.alternativesAsExact!, RAW_VALUES)
+        XCTAssertEqual(query1["alternativesAsExact"], RAW_VALUES.joinWithSeparator(","))
+    }
 }