refactor

Author: jxnu-liguobin

README.md

@@ -69,50 +69,33 @@ autoCompilerPlugins := true
 addCompilerPlugin("org.bitlap" %% "validation-scala-plugin" % "latest version")
 ```
 
-### `@Validated`
-
-Add `@Validated` to method:
-```scala
-import bitlap.validation.extension.Validated
+### Cascade Validation
 
-@Validated def update(person1: Person, person2: Person)
-```
 Then, checking code will be automatically inserted during compilation and may throw an `IllegalArgumentException` if the constraint checking fails.
 
-If you do not wish to throw an exception directly, you should add a `bind: BindingResult` parameter to method:.
-```scala
-import bitlap.validation.extension.Validated
-
-@Validated def update(person1: Person, person2: Person, bind: BindingResult = BindingResult.default)
-```
-
-The plugin captures the `bind` parameters based on the type, so the name doesn't matter.
-
-### Cascade Validation
-
+If you do not wish to throw an exception directly, you should add a `bind: BindingResult` parameter to method:
 ```scala
 import jakarta.validation.Valid
-import bitlap.validation.extension.Validated
 import jakarta.validation.constraints.NotNull
 
-@Validated def validatedTwoParams(@Valid person1: Person, @Valid person2: Person): String
+def validatedTwoParams(@Valid person1: Person, @Valid person2: Person): String
 
-@Validated def validatedOneParams(@Valid person1: Person): String
+def validatedOneParams(@Valid person1: Person): String
 
-@Validated def validatedBindParams(@Valid person1: Person, bindingError: BindingResult = BindingResult.default): String
+// The plugin captures the `bind` parameters based on the type, so the name doesn't matter.
+def validatedBindParams(@Valid person1: Person, bindingError: BindingResult = BindingResult.default): String
 
-@Validated def validatedNotNullParams(@Valid @NotNull person1: Person): String
+def validatedNotNullParams(@Valid @NotNull person1: Person): String
 ```
 
 ### Non-Cascade Validation
 
 ```scala
-import bitlap.validation.extension.Validated
 import jakarta.validation.constraints.{ NotBlank, NotNull }
 
-@Validated def validatedNotNullParams(@NotNull person1: Person): String
+def validatedNotNullParams(@NotNull person1: Person): String
 
-@Validated def validatedNotEmptyParam(@NotBlank name: String): String
+def validatedNotEmptyParam(@NotBlank name: String): String
 ```
 
 ### Limitation

build.sbt

@@ -15,7 +15,7 @@ val jodaConvertVersion           = "2.2.3"
 val jodaTimeVersion              = "2.12.5"
 val specs2Version                = "4.20.3"
 val zioVersion                   = "2.0.19"
-val `example-dependency-version` = "0.0.0+106-e5acc4be-SNAPSHOT"
+val `example-dependency-version` = "0.0.0+100-22e7d34d+20231118-1835-SNAPSHOT"
 val supportCrossVersionList      = Seq(scala3_Version, scala2_13Version)
 
 inThisBuild(

docs/support-annotations.md

@@ -27,6 +27,7 @@ Validation of annotation constraints on generic parameters is not supported beca
 - NegativeOrZer
 - Positive
 - PositiveOrZero
+- NotNull
 
 ## `jakarta.validation`
 

examples/src/main/scala/bitlap/validation/examples/PersonNormalService.scala

@@ -7,25 +7,20 @@ import jakarta.validation.constraints.{ NotBlank, NotNull }
 final class PersonNormalService {
 
   // cascade
-  @Validated
   def validatedTwoParams(@Valid person1: Person, @Valid person2: Person): String =
     s"${person1.name} - $person2"
 
   // cascade
-  @Validated
   def validatedOneParam(@Valid person1: Person): String =
     s"${person1.name}"
 
   // cascade
-  @Validated
   def validatedBindParams(@Valid person1: Person, bindingError: BindingResult = BindingResult.default): String =
     s"${person1.name} - violationsCount: ${bindingError.violations.map(_.getMessage)}"
 
-  @Validated
   def validatedNotNullParam(@NotNull person1: Person): String =
     s"${person1.name}"
 
-  @Validated
   def validatedNotEmptyParam(@NotBlank name: String): String =
     s"$name"
 }

examples/src/main/scala/bitlap/validation/examples/PersonZioService.scala

@@ -8,31 +8,26 @@ import zio.*
 final class PersonZioService {
 
   // cascade
-  @Validated
   def zioValidatedTwoParams(
     @Valid person1: Person,
     @Valid person2: Person
   ): ZIO[Any, Nothing, String] =
     ZIO.succeed(s"${person1.name} - $person2")
 
   // cascade
-  @Validated
   def zioValidatedOneParam(@Valid person1: Person): ZIO[Any, Nothing, String] =
     ZIO.succeed(s"${person1.name}")
 
   // cascade
-  @Validated
   def zioValidatedBindParam(
     @Valid person1: Person,
     bindingError: BindingResult = BindingResult.default
   ): ZIO[Any, Nothing, String] =
     ZIO.succeed(s"${person1.name} - violationsCount: ${bindingError.violations.map(_.getMessage)}")
 
-  @Validated
   def zioValidatedNotNullParam(@NotNull person1: Person): ZIO[Any, Nothing, String] =
     ZIO.succeed(s"${person1.name}")
 
-  @Validated
   def zioValidatedNotEmptyParam(@NotBlank name: String): ZIO[Any, Nothing, String] =
     ZIO.succeed(s"$name")
 

validation-scala-core/src/main/scala/bitlap/validation/extension/Validated.scala

@@ -3,7 +3,6 @@ package bitlap.validation.plugin
 private[plugin] object TermsName {
 
   final val BindingResult_Class    = "bitlap.validation.extension.BindingResult"
-  final val Validated_Annotation   = "bitlap.validation.extension.Validated"
   final val Preconditions_Class    = "bitlap.validation.extension.Preconditions"
   final val ZioPreconditions_Class = "bitlap.validation.ext.ZioPreconditions"
   final val Zio_Class              = "zio.ZIO"
@@ -12,4 +11,41 @@ private[plugin] object TermsName {
   final val ValidateMethodArgsBinding_Method = "validateMethodArgsBinding"
   final val MethodIdentity_Class             = "bitlap.validation.extension.MethodIdentity"
 
+  object SupportAnnotations {
+
+    val values: Seq[String] = Seq(
+      "AssertFalse",
+      "AssertTrue",
+      "DecimalMax",
+      "DecimalMin",
+      "Digits",
+      "Future",
+      "Max",
+      "Min",
+      "Past",
+      "Pattern",
+      "Size",
+      "Email",
+      "NotBlank",
+      "PastOrPresent",
+      "FutureOrPresent",
+      "NotEmpty",
+      "Negative",
+      "NegativeOrZer",
+      "Positive",
+      "PositiveOrZero",
+      "CreditCardNumber",
+      "EAN",
+      "Length",
+      "LuhnCheck",
+      "Mod10Check",
+      "Mod11Check",
+      "NotEmpty",
+      "Range",
+      "URL",
+      "NotNull"
+    ).map(a => s"jakarta.validation.constraints.$a") ++
+      Seq("AssertNone", "AssertSome", "ByteSize").map(a => s"bitlap.validation.$a") ++
+      Seq("jakarta.validation.Valid")
+  }
 }

validation-scala-plugin/src/main/scala/bitlap/validation/plugin/TermsName.scala

@@ -15,6 +15,7 @@ import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.*
 import dotty.tools.dotc.core.Types.{ Type, * }
 import dotty.tools.dotc.plugins.PluginPhase
+import dotty.tools.dotc.printing.Printer
 import dotty.tools.dotc.report
 import dotty.tools.dotc.transform.*
 
@@ -25,10 +26,6 @@ final class ValidationMethodArgsPhase extends PluginPhase:
   override val runsAfter: Set[String]  = Set(Staging.name)
   override val runsBefore: Set[String] = Set(PickleQuotes.name)
 
-  @threadUnsafe private lazy val ValidatedAnnotationClass: Context ?=> ClassSymbol = requiredClass(
-    TermsName.Validated_Annotation
-  )
-
   @threadUnsafe private lazy val PreconditionsClass: Context ?=> TermSymbol = requiredModule(
     TermsName.Preconditions_Class
   )
@@ -54,14 +51,21 @@ final class ValidationMethodArgsPhase extends PluginPhase:
       return tree
     }
 
-    // to determine if there are main scala annotations
-    val optAnnotations = tree.symbol.annotations.collectFirst {
-      case annotation if annotation.symbol.name.asSimpleName == ValidatedAnnotationClass.name.asSimpleName =>
-        report.debugwarn(s"Validation found: ${TermsName.Validated_Annotation} on method: ${tree.name.show}")
-        ValidatedAnnotationClass
+    val constraintAnnotations =
+      tree.termParamss
+        .flatMap(_.flatMap(_.mods.annotations.map(_.symbol.showFullName.stripSuffix(".<init>"))))
+
+    val existsAnnotations = constraintAnnotations.collect {
+      case a if TermsName.SupportAnnotations.values.contains(a) =>
+        a
     }
-    if optAnnotations.isEmpty then return tree
-    val bindOpt        = tree.termParamss.flatten.find(_.tpt.symbol.showFullName == TermsName.BindingResult_Class)
+
+    if (existsAnnotations.isEmpty) return tree
+
+    // to determine if there are main scala annotations
+    report.debugwarn(s"Validation found: ${existsAnnotations.mkString(",")}")
+
+    val bindOpt = tree.termParamss.flatten.find(_.tpt.symbol.showFullName == TermsName.BindingResult_Class)
 
     mapDefDef(tree, bindOpt)
   }