Introduce DotEnvRoot#allVariablesOrNull()

CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Added
+
+- `(Map<String, String?>) env.allVariablesOrNull()` to get all environment variables includes variables specified in `.env` includes null variables.
+  - The Plugin set key if defined in .env template files, but it could not be retrieved as nullable value entries by using allVariables()
+  - By using allVariablesOrNull instead of allVariables, it is possible to retrieve all environment variables, including those that are only defined in the .env template (which means their values are null).
+
+### Deprecated
+
+- `val (Map<String, String>) env.allVariables`
+  - Replace to use a method `(Map<String, String>) env.allVariables()` instead.
+
 ## [2.0.0] - 2022-03-02
 
 ### Added

README.md

@@ -66,7 +66,8 @@ Support subproject-only variables and extensions.
   if environment variable was not set.
 - `(String?) env.fetchOrNull(name: String)` : Returns an environment variable, or null if environment variable was not
   set.
-- `(Map<String, String) env.allVariables` : Returns all environment variables.
+- `(Map<String, String) env.allVariables()` : Returns all environment variables.
+- `(Map<String, String?) env.allVariablesOrNull()` : Returns all environment variables includes null values.
 - [See more examples](/examples)
 
 ## License

examples/basic/build.gradle.kts

@@ -3,6 +3,13 @@ plugins {
     id("co.uzzu.dotenv.gradle") version "2.0.0"
 }
 
+val keys = listOf(
+    "FOO",
+    "BAR",
+    "BAZ",
+    "QUX"
+)
+
 println(env.FOO.orElse("default_foo"))
 println(env.BAR.orNull())
 try {
@@ -13,4 +20,12 @@ try {
 println(env.QUX.value)
 
 // All environment variables which are merged with variables specified in .env files.
-env.allVariables
+print("#allVariables() (filtered by keys in .env.template and .env): ")
+println(env.allVariables().filterKeys { keys.contains(it) })
+
+// All environment variables which are merged with variables specified in .env files includes null.
+// The Plugin set key if defined in .env template files, but it could not be retrieved as nullable value entries by using allVariables()
+// By using allVariablesOrNull instead of allVariables, it is possible to retrieve all environment variables, including those that are only defined in the .env template (which means their values are null).
+env.allVariablesOrNull()
+print("#allVariablesOrNull() (filtered by keys in .env.template and .env): ")
+println(env.allVariablesOrNull().filterKeys { keys.contains(it) })

plugin/src/main/kotlin/co/uzzu/dotenv/EnvProviders.kt

@@ -13,12 +13,22 @@ interface EnvProvider {
      * @return All environment variables.
      */
     fun getenv(): Map<String, String>
+
+    /**
+     * @return All environment variables includes null values.
+     */
+    fun getenvOrNull(): Map<String, String?>
 }
 
 /**
  * EnvProvider implementation using System#getenv
  */
 class SystemEnvProvider : EnvProvider {
     override fun getenv(name: String): String? = System.getenv(name)
-    override fun getenv(): Map<String, String> = System.getenv().filterValues { it != null }
+
+    override fun getenv(): Map<String, String> = System.getenv()
+        .mapNotNull { (key, value) -> value?.let { key to it } }
+        .toMap()
+
+    override fun getenvOrNull(): Map<String, String?> = System.getenv()
 }

plugin/src/main/kotlin/co/uzzu/dotenv/gradle/DotEnvProperties.kt

@@ -12,6 +12,7 @@ open class DotEnvRoot(
     /**
      * @return All environment variables which are merged with variables specified in .env files.
      */
+    @Deprecated("Replace to use DotEnvRoot#allVariables()")
     val allVariables: Map<String, String>
         get() {
             val results = envProvider.getenv().toMutableMap()
@@ -55,6 +56,34 @@ open class DotEnvRoot(
     fun fetchOrNull(name: String): String? =
         envProvider.getenv()[name]
             ?: dotenvMap[name]
+
+    /**
+     * @return All environment variables which are merged with variables specified in .env files.
+     */
+    fun allVariables(): Map<String, String> {
+        val results = envProvider.getenv().toMutableMap()
+        dotenvMap.forEach { (key, value) ->
+            if (value != null && results[key] == null) {
+                results[key] = value
+            }
+        }
+        return results.toMap()
+    }
+
+    /**
+     * @return All environment variables which are merged with variables specified in .env files, and which includes null values.
+     * The Plugin set key if defined in .env template files, but it could not be retrieved as nullable value entries by using allVariables()
+     * By using allVariablesOrNull instead of allVariables, it is possible to retrieve all environment variables, including those that are only defined in the .env template (which means their values are null).
+     */
+    fun allVariablesOrNull(): Map<String, String?> {
+        val results = envProvider.getenvOrNull().toMutableMap()
+        dotenvMap.forEach { (key, value) ->
+            if (results[key] == null) {
+                results[key] = value
+            }
+        }
+        return results.toMap()
+    }
 }
 
 /**

plugin/src/test/kotlin/co/uzzu/dotenv/InMemoryEnvProvider.kt

@@ -1,8 +1,13 @@
 package co.uzzu.dotenv
 
 class InMemoryEnvProvider(
-    private val map: Map<String, String>
+    private val map: Map<String, String?>
 ) : EnvProvider {
     override fun getenv(name: String): String? = map[name]
+
     override fun getenv(): Map<String, String> = map
+        .mapNotNull { (key, value) -> value?.let { key to it } }
+        .toMap()
+
+    override fun getenvOrNull(): Map<String, String?> = map.toMap()
 }

plugin/src/test/kotlin/co/uzzu/dotenv/gradle/AllVariablesOrNullTest.kt

@@ -0,0 +1,48 @@
+package co.uzzu.dotenv.gradle
+
+import assertk.assertThat
+import assertk.assertions.contains
+import org.gradle.testkit.runner.GradleRunner
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+
+class AllVariablesOrNullTest {
+
+    @TempDir
+    lateinit var projectDir: File
+
+    @Test
+    fun nullValuesDefinedByTemplate() {
+        RootProject(projectDir) {
+            settingsGradle()
+            buildGradle(
+                """
+                plugins {
+                    base
+                    id("co.uzzu.dotenv.gradle")
+                }
+                println("Result: ${'$'}{env.allVariablesOrNull().filterKeys { it == "HOGE" }}")
+                """.trimIndent()
+            )
+            file(
+                ".env.template",
+                """
+                HOGE=
+                """.trimIndent()
+            )
+            file(
+                ".env",
+                """
+                """.trimIndent()
+            )
+        }
+
+        val result = GradleRunner.create()
+            .withPluginClasspath()
+            .withProjectDir(projectDir)
+            .build()
+
+        assertThat(result.output).contains("Result: {HOGE=null}")
+    }
+}

plugin/src/test/kotlin/co/uzzu/dotenv/gradle/DotEnvRootTest.kt

@@ -111,7 +111,7 @@ class DotEnvRootTest {
                 "QUUX" to null
             )
         )
-        val allVariables = root.allVariables
+        val allVariables = root.allVariables()
         assertAll(
             { assertEquals("env", allVariables["FOO"]) },
             { assertEquals("env", allVariables["BAR"]) },
@@ -121,4 +121,35 @@ class DotEnvRootTest {
             { assertEquals(null, allVariables["CORGE"]) }
         )
     }
+
+    @Test
+    fun allVariablesOrNull() {
+        val envProvider = InMemoryEnvProvider(
+            mapOf(
+                "FOO" to "env",
+                "BAR" to "env",
+                "CORGE" to null,
+            )
+        )
+        val root = DotEnvRoot(
+            envProvider,
+            mapOf(
+                "BAR" to "dotenv",
+                "BAZ" to "dotenv",
+                "QUX" to "dotenv",
+                "QUUX" to null,
+            )
+        )
+        val allVariables = root.allVariablesOrNull()
+        assertAll(
+            { assertEquals("env", allVariables["FOO"]) },
+            { assertEquals("env", allVariables["BAR"]) },
+            { assertEquals("dotenv", allVariables["BAZ"]) },
+            { assertEquals("dotenv", allVariables["QUX"]) },
+            { assertEquals(null, allVariables["QUUX"]) },
+            { assertTrue(allVariables.containsKey("QUUX")) },
+            { assertEquals(null, allVariables["CORGE"]) },
+            { assertTrue(allVariables.containsKey("CORGE")) },
+        )
+    }
 }