Skip to content

Commit 5da5cd8

Browse files
blast-hardcheeseblast-hardcheese
authored
Merge pull request #1873 from blast-hardcheese/delete-dead-code
Delete second set of Deferred* and resolve()
2 parents 65f8b58 + e9d1680 commit 5da5cd8

File tree

10 files changed

+67
-164
lines changed

10 files changed

+67
-164
lines changed

‎modules/core/src/main/scala/dev/guardrail/core/ResolvedType.scala‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -20,10 +20,10 @@ case class MapRawType(items: ReifiedRawType) ex
2020

2121
sealed trait ResolvedType[L <: LA]
2222
case class Resolved[L <: LA](tpe: L#Type, classDep: Option[L#TermName], defaultValue: Option[L#Term], rawType: ReifiedRawType) extends ResolvedType[L]
23-
sealed trait LazyResolvedType[L <: LA] extends ResolvedType[L]
24-
case class Deferred[L <: LA](value: String) extends LazyResolvedType[L]
25-
case class DeferredArray[L <: LA](value: String, containerTpe: Option[L#Type]) extends LazyResolvedType[L]
26-
case class DeferredMap[L <: LA](value: String, containerTpe: Option[L#Type]) extends LazyResolvedType[L]
23+
sealed trait LazyResolvedType[L <: LA] extends ResolvedType[L] { def value: String }
24+
case class Deferred[L <: LA](value: String) extends LazyResolvedType[L]
25+
case class DeferredArray[L <: LA](value: String, containerTpe: Option[L#Type]) extends LazyResolvedType[L]
26+
case class DeferredMap[L <: LA](value: String, containerTpe: Option[L#Type]) extends LazyResolvedType[L]
2727

2828
object ResolvedType {
2929
def resolveReferences[L <: LA, F[_]: Monad](

‎modules/core/src/main/scala/dev/guardrail/generators/OpenAPIGenerator.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -273,8 +273,8 @@ class OpenAPIGenerator[L <: LA] extends OpenAPITerms[L, Target] {
273273
override def resolveType(name: String, protocolElems: List[StrictProtocolElems[L]]) =
274274
Target.fromOption(protocolElems.find(_.name == name), UserError(s"Unable to resolve ${name}"))
275275

276-
override def fallbackResolveElems(lazyElems: List[LazyProtocolElems[L]]) =
277-
Target.raiseUserError(s"Unable to resolve: ${lazyElems.map(_.name)}")
276+
override def fallbackResolveElems(lazyElems: List[core.LazyResolvedType[L]]) =
277+
Target.raiseUserError(s"Unable to resolve: ${lazyElems.map(_.value).mkString(",")}")
278278

279279
private def buildExtractor[A](components: Tracker[Option[Components]], label: String, proj: Components => ju.Map[String, A])(
280280
ref: Tracker[String]

‎modules/core/src/main/scala/dev/guardrail/terms/OpenAPITerms.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ abstract class OpenAPITerms[L <: LA, F[_]] {
5252
def getType(model: Tracker[Schema[_]]): F[Tracker[String]]
5353
def fallbackPropertyTypeHandler(prop: Tracker[Schema[_]]): F[L#Type]
5454
def resolveType(name: String, protocolElems: List[StrictProtocolElems[L]]): F[StrictProtocolElems[L]]
55-
def fallbackResolveElems(lazyElems: List[LazyProtocolElems[L]]): F[List[StrictProtocolElems[L]]]
55+
def fallbackResolveElems(lazyElems: List[core.LazyResolvedType[L]]): F[List[StrictProtocolElems[L]]]
5656

5757
def dereferenceHeader(ref: Tracker[String], components: Tracker[Option[Components]]): F[Tracker[headers.Header]]
5858
def dereferenceParameter(ref: Tracker[String], components: Tracker[Option[Components]]): F[Tracker[Parameter]]

‎modules/core/src/main/scala/dev/guardrail/terms/protocol/Discriminator.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ import dev.guardrail.core.Tracker
88
import dev.guardrail.languages.LA
99
import dev.guardrail.terms.{ LanguageTerms, OpenAPITerms }
1010

11-
case class Discriminator[L <: LA](propertyName: String, mapping: Map[String, ProtocolElems[L]])
11+
case class Discriminator[L <: LA](propertyName: String, mapping: Map[String, StrictProtocolElems[L]])
1212

1313
object Discriminator {
1414
def fromSchema[L <: LA, F[_]: Monad](schema: Tracker[Schema[_]])(implicit Sc: LanguageTerms[L, F], Sw: OpenAPITerms[L, F]): F[Option[Discriminator[L]]] =

‎modules/core/src/main/scala/dev/guardrail/terms/protocol/ProtocolElems.scala‎

Lines changed: 0 additions & 115 deletions
This file was deleted.

‎modules/core/src/main/scala/dev/guardrail/terms/protocol/StrictProtocolElems.scala‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
package dev.guardrail.terms.protocol
2+
3+
import dev.guardrail.languages.LA
4+
import dev.guardrail.terms.RenderedEnum
5+
6+
case class StaticDefns[L <: LA](className: String, extraImports: List[L#Import], definitions: List[L#Definition])
7+
8+
sealed trait StrictProtocolElems[L <: LA] { def name: String }
9+
case class RandomType[L <: LA](name: String, tpe: L#Type) extends StrictProtocolElems[L]
10+
11+
sealed trait NestedProtocolElems[L <: LA] extends StrictProtocolElems[L]
12+
13+
case class ClassDefinition[L <: LA](
14+
name: String,
15+
tpe: L#TypeName,
16+
fullType: L#Type,
17+
cls: L#ClassDefinition,
18+
staticDefns: StaticDefns[L],
19+
parents: List[SuperClass[L]] = Nil
20+
) extends NestedProtocolElems[L]
21+
22+
case class ADT[L <: LA](name: String, tpe: L#TypeName, fullType: L#Type, trt: L#Trait, staticDefns: StaticDefns[L]) extends StrictProtocolElems[L]
23+
24+
case class EnumDefinition[L <: LA](
25+
name: String,
26+
tpe: L#TypeName,
27+
fullType: L#Type,
28+
elems: RenderedEnum[L],
29+
cls: L#ClassDefinition,
30+
staticDefns: StaticDefns[L]
31+
) extends NestedProtocolElems[L]

‎modules/java-support/src/main/scala/dev/guardrail/generators/java/jackson/JacksonGenerator.scala‎

Lines changed: 7 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -363,7 +363,7 @@ class JacksonGenerator private (implicit Cl: CollectionsLibTerms[JavaLanguage, T
363363
Sc: LanguageTerms[JavaLanguage, Target],
364364
Cl: CollectionsLibTerms[JavaLanguage, Target],
365365
Sw: OpenAPITerms[JavaLanguage, Target]
366-
): Target[ProtocolElems[JavaLanguage]] = {
366+
): Target[StrictProtocolElems[JavaLanguage]] = {
367367
import Cl._
368368
import Sc._
369369

@@ -589,7 +589,7 @@ class JacksonGenerator private (implicit Cl: CollectionsLibTerms[JavaLanguage, T
589589
Sc: LanguageTerms[JavaLanguage, Target],
590590
Cl: CollectionsLibTerms[JavaLanguage, Target],
591591
Sw: OpenAPITerms[JavaLanguage, Target]
592-
): Target[ProtocolElems[JavaLanguage]] = {
592+
): Target[StrictProtocolElems[JavaLanguage]] = {
593593
import Cl._
594594
import Fw._
595595
val model: Option[Tracker[Schema[Object]]] = abstractModel
@@ -616,16 +616,16 @@ class JacksonGenerator private (implicit Cl: CollectionsLibTerms[JavaLanguage, T
616616

617617
private def plainTypeAlias(
618618
clsName: String
619-
)(implicit Fw: FrameworkTerms[JavaLanguage, Target], Sc: LanguageTerms[JavaLanguage, Target]): Target[ProtocolElems[JavaLanguage]] = {
619+
)(implicit Fw: FrameworkTerms[JavaLanguage, Target], Sc: LanguageTerms[JavaLanguage, Target]): Target[StrictProtocolElems[JavaLanguage]] = {
620620
import Fw._
621621
for {
622622
tpe <- objectType(None)
623623
res <- typeAlias(clsName, tpe)
624624
} yield res
625625
}
626626

627-
private def typeAlias(clsName: String, tpe: Type): Target[ProtocolElems[JavaLanguage]] =
628-
(RandomType[JavaLanguage](clsName, tpe): ProtocolElems[JavaLanguage]).pure[Target]
627+
private def typeAlias(clsName: String, tpe: Type): Target[StrictProtocolElems[JavaLanguage]] =
628+
(RandomType[JavaLanguage](clsName, tpe): StrictProtocolElems[JavaLanguage]).pure[Target]
629629

630630
private def fromArray(clsName: String, arr: Tracker[ArraySchema], concreteTypes: List[PropMeta[JavaLanguage]], components: Tracker[Option[Components]])(
631631
implicit
@@ -634,7 +634,7 @@ class JacksonGenerator private (implicit Cl: CollectionsLibTerms[JavaLanguage, T
634634
Sc: LanguageTerms[JavaLanguage, Target],
635635
Cl: CollectionsLibTerms[JavaLanguage, Target],
636636
Sw: OpenAPITerms[JavaLanguage, Target]
637-
): Target[ProtocolElems[JavaLanguage]] =
637+
): Target[StrictProtocolElems[JavaLanguage]] =
638638
for {
639639
deferredTpe <- ModelResolver.modelMetaType[JavaLanguage, Target](arr, components)
640640
tpe <- extractArrayType(deferredTpe, concreteTypes)
@@ -900,10 +900,7 @@ class JacksonGenerator private (implicit Cl: CollectionsLibTerms[JavaLanguage, T
900900
pkgImports <- packageObjectImports()
901901
pkgObjectContents <- packageObjectContents()
902902
implicitsObject <- implicitsObject()
903-
904-
polyADTElems <- ProtocolElems.resolve[JavaLanguage, Target](polyADTs)
905-
strictElems <- ProtocolElems.resolve[JavaLanguage, Target](elems)
906-
} yield ProtocolDefinitions[JavaLanguage](strictElems ++ polyADTElems, protoImports, pkgImports, pkgObjectContents, implicitsObject))
903+
} yield ProtocolDefinitions[JavaLanguage](elems ++ polyADTs, protoImports, pkgImports, pkgObjectContents, implicitsObject))
907904
}
908905

909906
// returns a tuple of (requiredTerms, optionalTerms)

‎modules/scala-support/src/main/scala/dev/guardrail/generators/scala/circe/CirceProtocolGenerator.scala‎

Lines changed: 7 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -180,10 +180,7 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
180180
pkgImports <- packageObjectImports()
181181
pkgObjectContents <- packageObjectContents()
182182
implicitsObject <- implicitsObject()
183-
184-
polyADTElems <- ProtocolElems.resolve[ScalaLanguage, Target](polyADTs)
185-
strictElems <- ProtocolElems.resolve[ScalaLanguage, Target](elems)
186-
} yield ProtocolDefinitions[ScalaLanguage](strictElems ++ polyADTElems, protoImports, pkgImports, pkgObjectContents, implicitsObject))
183+
} yield ProtocolDefinitions[ScalaLanguage](elems ++ polyADTs, protoImports, pkgImports, pkgObjectContents, implicitsObject))
187184
}
188185

189186
private[this] def isFile(typeName: String, format: Option[String]): Boolean =
@@ -322,7 +319,7 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
322319
Sc: LanguageTerms[ScalaLanguage, Target],
323320
Cl: CollectionsLibTerms[ScalaLanguage, Target],
324321
Sw: OpenAPITerms[ScalaLanguage, Target]
325-
): Target[ProtocolElems[ScalaLanguage]] = {
322+
): Target[StrictProtocolElems[ScalaLanguage]] = {
326323
import Cl._
327324
import Sc._
328325

@@ -521,7 +518,6 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
521518
if (parents.isEmpty && props.isEmpty) Left("Entity isn't model"): Either[String, ClassDefinition[ScalaLanguage]]
522519
else tpe.toRight("Empty entity name").map(ClassDefinition[ScalaLanguage](clsName.last, _, fullType, defn, finalStaticDefns, parents))
523520
}
524-
525521
}
526522

527523
// NB: In OpenAPI 3.1 ObjectSchema was broadly replaced with JsonSchema.
@@ -712,7 +708,7 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
712708
Sc: LanguageTerms[ScalaLanguage, Target],
713709
Cl: CollectionsLibTerms[ScalaLanguage, Target],
714710
Sw: OpenAPITerms[ScalaLanguage, Target]
715-
): Target[ProtocolElems[ScalaLanguage]] = {
711+
): Target[StrictProtocolElems[ScalaLanguage]] = {
716712
import Cl._
717713
import Fw._
718714
val model: Option[Tracker[Schema[Object]]] = abstractModel
@@ -739,16 +735,16 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
739735

740736
private def plainTypeAlias(
741737
clsName: String
742-
)(implicit Fw: FrameworkTerms[ScalaLanguage, Target], Sc: LanguageTerms[ScalaLanguage, Target]): Target[ProtocolElems[ScalaLanguage]] = {
738+
)(implicit Fw: FrameworkTerms[ScalaLanguage, Target], Sc: LanguageTerms[ScalaLanguage, Target]): Target[StrictProtocolElems[ScalaLanguage]] = {
743739
import Fw._
744740
for {
745741
tpe <- objectType(None)
746742
res <- typeAlias(clsName, tpe)
747743
} yield res
748744
}
749745

750-
private def typeAlias(clsName: String, tpe: scala.meta.Type): Target[ProtocolElems[ScalaLanguage]] =
751-
(RandomType[ScalaLanguage](clsName, tpe): ProtocolElems[ScalaLanguage]).pure[Target]
746+
private def typeAlias(clsName: String, tpe: scala.meta.Type): Target[StrictProtocolElems[ScalaLanguage]] =
747+
(RandomType[ScalaLanguage](clsName, tpe): StrictProtocolElems[ScalaLanguage]).pure[Target]
752748

753749
private def fromArray(clsName: String, arr: Tracker[ArraySchema], concreteTypes: List[PropMeta[ScalaLanguage]], components: Tracker[Option[Components]])(
754750
implicit
@@ -757,7 +753,7 @@ class CirceProtocolGenerator private (circeVersion: CirceModelGenerator, applyVa
757753
Sc: LanguageTerms[ScalaLanguage, Target],
758754
Cl: CollectionsLibTerms[ScalaLanguage, Target],
759755
Sw: OpenAPITerms[ScalaLanguage, Target]
760-
): Target[ProtocolElems[ScalaLanguage]] =
756+
): Target[StrictProtocolElems[ScalaLanguage]] =
761757
for {
762758
deferredTpe <- ModelResolver.modelMetaType[ScalaLanguage, Target](arr, components)
763759
tpe <- extractArrayType(deferredTpe, concreteTypes)

0 commit comments

Comments
 (0)