Address review comments.

client/jackson/src/main/kotlin/net/corda/jackson/JacksonSupport.kt

@@ -40,23 +40,23 @@ object JacksonSupport {
         fun partyFromName(partyName: String): Party?
         fun partyFromX500Name(name: X500Name): Party?
         fun partyFromKey(owningKey: PublicKey): Party?
-        fun partiesFromName(query: String, exactMatch: Boolean): Set<Party>
+        fun partiesFromName(query: String): Set<Party>
     }
 
-    class RpcObjectMapper(val rpc: CordaRPCOps, factory: JsonFactory) : PartyObjectMapper, ObjectMapper(factory) {
+    class RpcObjectMapper(val rpc: CordaRPCOps, factory: JsonFactory, val fuzzyIdentityMatch: Boolean) : PartyObjectMapper, ObjectMapper(factory) {
         @Suppress("OverridingDeprecatedMember", "DEPRECATION")
         override fun partyFromName(partyName: String): Party? = rpc.partyFromName(partyName)
         override fun partyFromX500Name(name: X500Name): Party? = rpc.partyFromX500Name(name)
         override fun partyFromKey(owningKey: PublicKey): Party? = rpc.partyFromKey(owningKey)
-        override fun partiesFromName(query: String, exactMatch: Boolean) = rpc.partiesFromName(query, exactMatch)
+        override fun partiesFromName(query: String) = rpc.partiesFromName(query, fuzzyIdentityMatch)
     }
 
-    class IdentityObjectMapper(val identityService: IdentityService, factory: JsonFactory) : PartyObjectMapper, ObjectMapper(factory) {
+    class IdentityObjectMapper(val identityService: IdentityService, factory: JsonFactory, val fuzzyIdentityMatch: Boolean) : PartyObjectMapper, ObjectMapper(factory) {
         @Suppress("OverridingDeprecatedMember", "DEPRECATION")
         override fun partyFromName(partyName: String): Party? = identityService.partyFromName(partyName)
         override fun partyFromX500Name(name: X500Name): Party? = identityService.partyFromX500Name(name)
         override fun partyFromKey(owningKey: PublicKey): Party? = identityService.partyFromKey(owningKey)
-        override fun partiesFromName(query: String, exactMatch: Boolean) = identityService.partiesFromName(query, exactMatch)
+        override fun partiesFromName(query: String) = identityService.partiesFromName(query, fuzzyIdentityMatch)
     }
 
     class NoPartyObjectMapper(factory: JsonFactory) : PartyObjectMapper, ObjectMapper(factory) {
@@ -64,7 +64,7 @@ object JacksonSupport {
         override fun partyFromName(partyName: String): Party? = throw UnsupportedOperationException()
         override fun partyFromX500Name(name: X500Name): Party? = throw UnsupportedOperationException()
         override fun partyFromKey(owningKey: PublicKey): Party? = throw UnsupportedOperationException()
-        override fun partiesFromName(query: String, exactMatch: Boolean) = throw UnsupportedOperationException()
+        override fun partiesFromName(query: String) = throw UnsupportedOperationException()
     }
 
     val cordaModule: Module by lazy {
@@ -109,17 +109,31 @@ object JacksonSupport {
         }
     }
 
-    /** Mapper requiring RPC support to deserialise parties from names */
+    /**
+     * Creates a Jackson ObjectMapper that uses RPC to deserialise parties from string names.
+     *
+     * If [fuzzyIdentityMatch] is false, fields mapped to [Party] objects must be in X.500 name form and precisely
+     * match an identity known from the network map. If true, the name is matched more leniently but if the match
+     * is ambiguous a [JsonParseException] is thrown.
+     */
     @JvmStatic @JvmOverloads
-    fun createDefaultMapper(rpc: CordaRPCOps, factory: JsonFactory = JsonFactory()): ObjectMapper = configureMapper(RpcObjectMapper(rpc, factory))
+    fun createDefaultMapper(rpc: CordaRPCOps, factory: JsonFactory = JsonFactory(),
+                            fuzzyIdentityMatch: Boolean = false): ObjectMapper = configureMapper(RpcObjectMapper(rpc, factory, fuzzyIdentityMatch))
 
     /** For testing or situations where deserialising parties is not required */
     @JvmStatic @JvmOverloads
     fun createNonRpcMapper(factory: JsonFactory = JsonFactory()): ObjectMapper = configureMapper(NoPartyObjectMapper(factory))
 
-    /** For testing with an in memory identity service */
+    /**
+     * Creates a Jackson ObjectMapper that uses an [IdentityService] directly inside the node to deserialise parties from string names.
+     *
+     * If [fuzzyIdentityMatch] is false, fields mapped to [Party] objects must be in X.500 name form and precisely
+     * match an identity known from the network map. If true, the name is matched more leniently but if the match
+     * is ambiguous a [JsonParseException] is thrown.
+     */
     @JvmStatic @JvmOverloads
-    fun createInMemoryMapper(identityService: IdentityService, factory: JsonFactory = JsonFactory()) = configureMapper(IdentityObjectMapper(identityService, factory))
+    fun createInMemoryMapper(identityService: IdentityService, factory: JsonFactory = JsonFactory(),
+                             fuzzyIdentityMatch: Boolean = false) = configureMapper(IdentityObjectMapper(identityService, factory, fuzzyIdentityMatch))
 
     private fun configureMapper(mapper: ObjectMapper): ObjectMapper = mapper.apply {
         enable(SerializationFeature.INDENT_OUTPUT)
@@ -175,7 +189,7 @@ object JacksonSupport {
                 val principal = X500Name(parser.text)
                 mapper.partyFromX500Name(principal) ?: throw JsonParseException(parser, "Could not find a Party with name $principal")
             } else {
-                val nameMatches = mapper.partiesFromName(parser.text, false)
+                val nameMatches = mapper.partiesFromName(parser.text)
                 if (nameMatches.isEmpty()) {
                     val key = try {
                         parsePublicKeyBase58(parser.text)

node/src/main/kotlin/net/corda/node/services/identity/InMemoryIdentityService.kt

@@ -87,13 +87,7 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate>,
     @Deprecated("Use partyFromX500Name")
     override fun partyFromName(name: String): Party? = principalToParties[X500Name(name)]?.party
     override fun partyFromX500Name(principal: X500Name): Party? = principalToParties[principal]?.party
-    override fun partyFromAnonymous(party: AbstractParty): Party? {
+    override fun partyFromAnonymous(party: AbstractParty) = party as? Party ?: partyFromKey(party.owningKey)
-        return if (party is Party) {
-            party
-        } else {
-            partyFromKey(party.owningKey)
-        }
-    }
     override fun partyFromAnonymous(partyRef: PartyAndReference) = partyFromAnonymous(partyRef.party)
     override fun requirePartyFromAnonymous(party: AbstractParty): Party {
         return partyFromAnonymous(party) ?: throw IllegalStateException("Could not deanonymise party ${party.owningKey.toStringShort()}")
@@ -109,6 +103,11 @@ class InMemoryIdentityService(identities: Iterable<PartyAndCertificate>,
                     results += party
                 } else if (!exactMatch) {
                     // We can imagine this being a query over a lucene index in future.
+                    //
+                    // Kostas says: We can easily use the Jaro-Winkler distance metric as it is best suited for short
+                    // strings such as entity/company names, and to detect small typos. We can also apply it for city
+                    // or any keyword related search in lists of records (not raw text - for raw text we need indexing)
+                    // and we can return results in hierarchical order (based on normalised String similarity 0.0-1.0).
                     if (component.contains(query, ignoreCase = true))
                         results += party
                 }

node/src/main/kotlin/net/corda/node/shell/InteractiveShell.kt

@@ -184,7 +184,7 @@ object InteractiveShell {
     private val yamlInputMapper: ObjectMapper by lazy {
         // Return a standard Corda Jackson object mapper, configured to use YAML by default and with extra
         // serializers.
-        JacksonSupport.createInMemoryMapper(node.services.identityService, YAMLFactory()).apply {
+        JacksonSupport.createInMemoryMapper(node.services.identityService, YAMLFactory(), true).apply {
             val rpcModule = SimpleModule()
             rpcModule.addDeserializer(InputStream::class.java, InputStreamDeserializer)
             registerModule(rpcModule)