Address review feedback

Author: benjben

modules/core/src/main/scala/com.snowplowanalytics.iglu/client/resolver/Resolver.scala

@@ -38,10 +38,9 @@ final case class Resolver[F[_]](repos: List[Registry], cache: Option[ResolverCac
   private[client] val allRepos: NonEmptyList[Registry] =
     NonEmptyList[Registry](Registry.EmbeddedRegistry, repos)
 
-  private val allIgluCentral = repos.collect {
+  private val allIgluCentral: Set[String] = repos.collect {
     case Registry.Http(config, connection)
-        if config.name.toLowerCase.matches(".*iglu[- ]?central.*") && connection.uri.toString
-          .contains("iglucentral") =>
+        if Option(connection).filter(_.uri.getHost.matches(""".*\biglucentral\b.*""")).isDefined =>
       config.name
   }.toSet
 
@@ -188,30 +187,38 @@ final case class Resolver[F[_]](repos: List[Registry], cache: Option[ResolverCac
   ): F[Either[ResolutionError, Json]] =
     lookupSchemaResult(schemaKey).map(_.map(_.value.schema))
 
+  /**
+   * Looks up all the schemas with the same model until `maxSchemaKey`.
+   * For the schemas of previous revisions, it starts with addition = 0
+   * and increments it until a NotFound.
+   *
+   * @param maxSchemaKey The SchemaKey until which schemas of the same model should get returned
+   * @return All the schemas if all went well, [[Resolver.SchemaResolutionError]] with the first error that happened
+   *         while looking up the schemas if something went wrong.
+   */
   def lookupSchemasUntil(
     maxSchemaKey: SchemaKey
   )(implicit
     F: Monad[F],
     L: RegistryLookup[F],
     C: Clock[F]
-  ): F[Either[SchemaResolutionError, List[RawSchema]]] = {
+  ): F[Either[SchemaResolutionError, List[SelfDescribingSchema[Json]]]] = {
 
     // If Iglu Central or any of its mirrors doesn't have a schema,
     // it should be considered NotFound, even if one of them returned an error
     def isNotFound(error: ResolutionError): Boolean = {
       val (igluCentral, custom) = error.value.partition { case (repo, _) =>
         allIgluCentral.contains(repo)
       }
-      custom.values.flatMap(_.errors).forall(_ == RegistryError.NotFound) &&
       (igluCentral.isEmpty || igluCentral.values.exists(
         _.errors.forall(_ == RegistryError.NotFound)
-      ))
+      )) && custom.values.flatMap(_.errors).forall(_ == RegistryError.NotFound)
     }
 
     def go(
       current: SchemaVer.Full,
-      acc: List[RawSchema]
-    ): F[Either[SchemaResolutionError, List[RawSchema]]] = {
+      acc: List[SelfDescribingSchema[Json]]
+    ): F[Either[SchemaResolutionError, List[SelfDescribingSchema[Json]]]] = {
       val currentSchemaKey = maxSchemaKey.copy(version = current)
       lookupSchema(currentSchemaKey).flatMap {
         case Left(e) =>
@@ -225,15 +232,17 @@ final case class Resolver[F[_]](repos: List[Registry], cache: Option[ResolverCac
           if (current.revision < maxSchemaKey.version.revision)
             go(
               current.copy(addition = current.addition + 1),
-              RawSchema(currentSchemaKey, json) :: acc
+              SelfDescribingSchema(SchemaMap(currentSchemaKey), json) :: acc
             )
           else if (current.addition < maxSchemaKey.version.addition)
             go(
               current.copy(addition = current.addition + 1),
-              RawSchema(currentSchemaKey, json) :: acc
+              SelfDescribingSchema(SchemaMap(currentSchemaKey), json) :: acc
             )
           else
-            Monad[F].pure(Right((RawSchema(currentSchemaKey, json) :: acc).reverse))
+            Monad[F].pure(
+              Right((SelfDescribingSchema(SchemaMap(currentSchemaKey), json) :: acc).reverse)
+            )
       }
     }
 
@@ -439,8 +448,6 @@ object Resolver {
   type SchemaListLookupResult = ResolverResult[SchemaListKey, SchemaList]
   type SupersededBy           = Option[SchemaVer.Full]
 
-  case class RawSchema(schemaKey: SchemaKey, json: Json)
-
   /**
    * The result of doing schema lookup
    *

modules/core/src/test/scala/com.snowplowanalytics.iglu.client/resolver/ResolverResultSpec.scala

@@ -32,7 +32,7 @@ import io.circe.Json
 import io.circe.literal._
 
 // Iglu Core
-import com.snowplowanalytics.iglu.core.{SchemaKey, SchemaVer}
+import com.snowplowanalytics.iglu.core.{SchemaKey, SchemaVer, SelfDescribingSchema}
 
 // This project
 import com.snowplowanalytics.iglu.client.ClientError._
@@ -44,11 +44,7 @@ import com.snowplowanalytics.iglu.client.resolver.registries.{
   RegistryError,
   RegistryLookup
 }
-import com.snowplowanalytics.iglu.client.resolver.Resolver.{
-  RawSchema,
-  SchemaItem,
-  SchemaResolutionError
-}
+import com.snowplowanalytics.iglu.client.resolver.Resolver.{SchemaItem, SchemaResolutionError}
 
 // Specs2
 import com.snowplowanalytics.iglu.client.SpecHelpers._
@@ -769,7 +765,7 @@ class ResolverResultSpec extends Specification with ValidatedMatchers with CatsE
 
   import ResolverSpecHelpers.LookupSchemasUntil._
 
-  def testLookupUntil(maxSchemaKey: SchemaKey, expected: List[RawSchema]) =
+  def testLookupUntil(maxSchemaKey: SchemaKey, expected: List[SelfDescribingSchema[Json]]) =
     for {
       resolver <- mkResolver
       result   <- resolver.lookupSchemasUntil(maxSchemaKey)

modules/core/src/test/scala/com.snowplowanalytics.iglu.client/resolver/ResolverSpecHelpers.scala

@@ -29,7 +29,13 @@ import io.circe.parser._
 
 // LRU Map
 import com.snowplowanalytics.iglu.core.circe.implicits._
-import com.snowplowanalytics.iglu.core.{SchemaKey, SchemaList, SchemaVer}
+import com.snowplowanalytics.iglu.core.{
+  SchemaKey,
+  SchemaList,
+  SchemaMap,
+  SchemaVer,
+  SelfDescribingSchema
+}
 import com.snowplowanalytics.lrumap.LruMap
 
 // This project
@@ -39,7 +45,6 @@ import com.snowplowanalytics.iglu.client.resolver.registries.{
   RegistryError,
   RegistryLookup
 }
-import com.snowplowanalytics.iglu.client.resolver.Resolver.RawSchema
 
 object ResolverSpecHelpers {
 
@@ -260,12 +265,13 @@ object ResolverSpecHelpers {
       revision: Int,
       addition: Int,
       embeddedFolder: String = "iglu-test-embedded"
-    ): RawSchema = {
+    ): SelfDescribingSchema[Json] = {
       val path =
         s"/$embeddedFolder/schemas/$vendor/$name/$format/$model-$revision-$addition"
       val content = Source.fromInputStream(getClass.getResourceAsStream(path)).mkString
       parse(content) match {
-        case Right(json) => RawSchema(getUntilSchemaKey(model, revision, addition), json)
+        case Right(json) =>
+          SelfDescribingSchema(SchemaMap(getUntilSchemaKey(model, revision, addition)), json)
         case Left(err) =>
           throw new IllegalArgumentException(s"$path can't be parsed as JSON : [$err]")
       }