rename class

Author: MessiasLima

docs/supported-types.md

@@ -25,6 +25,7 @@ For types not listed here, register a [custom factory](custom-factories.md).
 | **Standard Library** | | |
 | `kotlin.uuid.Uuid` | `some<Uuid>()` | Requires `@OptIn(ExperimentalUuidApi::class)` |
 | `java.util.UUID` | `some<UUID>()` | |
+| `java.util.Optional<T>` | `some<Optional<String>>()` | See [NullableStrategy](configuration/nullable-strategy.md) |
 | `kotlin.time.Duration` | `some<Duration>()` | |
 | `java.time.Duration` | `some<java.time.Duration>()` | |
 | `kotlin.time.Instant` | `some<Instant>()` | |

src/main/kotlin/dev/appoutlet/some/config/SomeConfig.kt

@@ -17,7 +17,6 @@ import dev.appoutlet.some.resolver.FloatResolver
 import dev.appoutlet.some.resolver.IntResolver
 import dev.appoutlet.some.resolver.JavaDurationResolver
 import dev.appoutlet.some.resolver.JavaInstantResolver
-import dev.appoutlet.some.resolver.JavaOptionalResolver
 import dev.appoutlet.some.resolver.JavaUuidResolver
 import dev.appoutlet.some.resolver.JavaZonedDateTimeResolver
 import dev.appoutlet.some.resolver.KotlinDurationResolver
@@ -31,6 +30,7 @@ import dev.appoutlet.some.resolver.MapResolver
 import dev.appoutlet.some.resolver.NullableResolver
 import dev.appoutlet.some.resolver.NumberResolver
 import dev.appoutlet.some.resolver.ObjectResolver
+import dev.appoutlet.some.resolver.OptionalResolver
 import dev.appoutlet.some.resolver.SealedClassResolver
 import dev.appoutlet.some.resolver.SetResolver
 import dev.appoutlet.some.resolver.ShortResolver
@@ -119,7 +119,7 @@ data class SomeConfig(
             JavaInstantResolver(random),
             JavaDurationResolver(random),
             JavaZonedDateTimeResolver(random),
-            JavaOptionalResolver(this[NullableStrategy::class], random),
+            OptionalResolver(this[NullableStrategy::class], random),
             BigDecimalResolver(random),
             BigIntegerResolver(random),
             LocalDateResolver(random),

…et/some/resolver/JavaOptionalResolver.kt …outlet/some/resolver/OptionalResolver.ktsrc/main/kotlin/dev/appoutlet/some/resolver/JavaOptionalResolver.kt renamed to src/main/kotlin/dev/appoutlet/some/resolver/OptionalResolver.kt src/main/kotlin/dev/appoutlet/some/resolver/JavaOptionalResolver.kt renamed to src/main/kotlin/dev/appoutlet/some/resolver/OptionalResolver.kt

@@ -3,11 +3,11 @@ package dev.appoutlet.some.resolver
 import dev.appoutlet.some.config.NullableStrategy
 import dev.appoutlet.some.core.ResolverChain
 import dev.appoutlet.some.core.TypeResolver
+import dev.appoutlet.some.exception.SomeCircularReferenceException
 import java.util.Optional
 import kotlin.random.Random
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
-import kotlin.reflect.full.createType
 import kotlin.reflect.full.isSubclassOf
 
 /**
@@ -21,17 +21,43 @@ import kotlin.reflect.full.isSubclassOf
  * @param nullableStrategy Strategy for resolving optional types. Defaults to [NullableStrategy.default] when null.
  * @param random Random source used by [NullableStrategy.Random].
  */
-class JavaOptionalResolver(
+class OptionalResolver(
     nullableStrategy: NullableStrategy?,
     private val random: Random
 ) : TypeResolver {
+    /**
+     * Resolved nullable strategy used to decide whether the resulting [Optional] is empty or present.
+     *
+     * Initialized from the constructor parameter, falling back to [NullableStrategy.default] when null.
+     */
     private val nullableStrategy = nullableStrategy ?: NullableStrategy.default
 
+    /**
+     * Returns `true` when [type] is a subclass of [Optional].
+     *
+     * @param type The type to inspect.
+     * @return `true` if the type's classifier is a [KClass] that extends [Optional], `false` otherwise.
+     */
     override fun canResolve(type: KType): Boolean {
         val kClass = type.classifier as? KClass<*> ?: return false
         return kClass.isSubclassOf(Optional::class)
     }
 
+    /**
+     * Resolves an [Optional] of the wrapped type described by [type].
+     *
+     * The behavior depends on the configured [nullableStrategy]:
+     * - [NullableStrategy.AlwaysNull] – always returns [Optional.empty].
+     * - [NullableStrategy.NeverNull] – always returns a present [Optional] containing the resolved value.
+     * - [NullableStrategy.Random] – returns [Optional.empty] with probability defined by the strategy.
+     * - [NullableStrategy.NullOnCircularReference] – resolves the wrapped type and returns it inside a
+     *   present [Optional]. If the chain throws [SomeCircularReferenceException], returns [Optional.empty].
+     *
+     * @param type The [Optional] type to resolve. Its first type argument is used as the wrapped value type.
+     * @param chain Resolver chain used to generate the wrapped value.
+     * @return An [Optional] that may be empty or present depending on the active strategy.
+     * @throws IllegalArgumentException If the [Optional] type uses a star projection.
+     */
     override fun resolve(type: KType, chain: ResolverChain): Any {
         val valueType = requireNotNull(type.arguments.firstOrNull()?.type) {
             "Star projection not supported in Optional"
@@ -48,12 +74,11 @@ class JavaOptionalResolver(
                 }
             }
             is NullableStrategy.NullOnCircularReference -> {
-                val nullableValueType = (valueType.classifier as? KClass<*>)?.createType(
-                    arguments = valueType.arguments,
-                    nullable = true
-                ) ?: valueType
-
-                Optional.ofNullable(chain.resolve(nullableValueType))
+                try {
+                    Optional.ofNullable(chain.resolve(valueType))
+                } catch (_: SomeCircularReferenceException) {
+                    Optional.empty<Any>()
+                }
             }
         }
     }

…ome/resolver/JavaOptionalResolverTest.kt …et/some/resolver/OptionalResolverTest.ktsrc/test/kotlin/dev/appoutlet/some/resolver/JavaOptionalResolverTest.kt renamed to src/test/kotlin/dev/appoutlet/some/resolver/OptionalResolverTest.kt src/test/kotlin/dev/appoutlet/some/resolver/JavaOptionalResolverTest.kt renamed to src/test/kotlin/dev/appoutlet/some/resolver/OptionalResolverTest.kt

@@ -10,7 +10,7 @@ import kotlin.test.assertIs
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
-class JavaOptionalResolverTest {
+class OptionalResolverTest {
     @Test
     fun `JavaOptionalResolver generates Optional values`() {
         val result: Optional<String> = some()
@@ -57,41 +57,20 @@ class JavaOptionalResolverTest {
         val result: OptionalCircular = some {
             strategy(NullableStrategy.NullOnCircularReference)
         }
-
         assertNotNull(result)
-        // Since Optional<OptionalCircular> is treated as OptionalCircular?,
-        // and we are at the first level of circularity for OptionalCircular,
-        // it should resolve to a non-null OptionalCircular, but wrapped in Optional.
-
-        // Wait, if it's the first time it sees OptionalCircular, it should resolve it.
-        // If it's a circular reference, it should be null.
-
-        // Let's re-examine how ResolverChain works.
-        // resolve(OptionalCircular)
-        //   -> ClassResolver resolves OptionalCircular
-        //     -> resolve(Optional<OptionalCircular>)
-        //       -> JavaOptionalResolver
-        //         -> resolve(OptionalCircular?)
-        //           -> NullableResolver
-        //             -> resolve(OptionalCircular)
-        //               -> CIRCULAR REFERENCE!
-
-        // If NullableStrategy is NullOnCircularReference, resolve(OptionalCircular?) returns null.
-        // So Optional.ofNullable(null) is Optional.empty().
-
         assertFalse(result.optional.isPresent, "Circular reference should result in empty optional")
     }
 
     @Test
     fun `JavaOptionalResolver canResolve detects Optional types`() {
-        val resolver = JavaOptionalResolver(NullableStrategy.default, kotlin.random.Random.Default)
+        val resolver = OptionalResolver(NullableStrategy.default, kotlin.random.Random.Default)
         assertTrue(resolver.canResolve(typeOf<Optional<String>>()))
         assertTrue(resolver.canResolve(typeOf<Optional<Int>>()))
     }
 
     @Test
     fun `JavaOptionalResolver rejects non-Optional types`() {
-        val resolver = JavaOptionalResolver(NullableStrategy.default, kotlin.random.Random.Default)
+        val resolver = OptionalResolver(NullableStrategy.default, kotlin.random.Random.Default)
         assertFalse(resolver.canResolve(typeOf<String>()))
         assertFalse(resolver.canResolve(typeOf<List<String>>()))
     }