Changes in the safe wrapper (#74)

* Change expected schema

* Add flags for dotenv CLI to run the safe mode:

* Add flag to read the scheme file path

* Add directory to cabal file

* Add flag to omit schema

* Update README

* Edit CHANGELOG

* Use yml syntaxsis for default values

Author: CristhianMotoche

CHANGELOG.md

@@ -2,7 +2,10 @@
 ## Dotenv 0.5.2.0
 
 * Add `loadSafeFile` to typecheck the envs.
-* Add `-s` flag to the `dotenv` CLI tool to enable safe mode.
+* Add `(--schema|-s) FILE` flag to the `dotenv` CLI tool to enable safe mode.
+* Add `(--no-schema)` flag to the `dotenv` CLI tool to disable safe mode.
+* Turn safe mode on automatically when the `.schema.yml` file is present.
+* Make `required` optional in the `.schema.yml`.
 
 ## Dotenv 0.5.1.1
 

README.md

@@ -99,22 +99,21 @@ If the type-check succeeded the application is executed, otherwise you will get
 error with the types that mismatch.
 
 In order to use this functionality you can use the `loadSafeFile` which takes the same
-configuration value as the `loadFile` function. Also, you need to have a `.scheme.yml`
+configuration value as the `loadFile` function. Also, you need to have a `.schema.yml`
 in your current directory. This file must have the following structure:
 
 ```yaml
-- type: bool
-  envs:
-    - name: DOTENV
-      required: true
-    - name: OTHERENV
-      required: false
-- type: integer
-  envs:
-    - name: PORT
-      required: true
-    - name: TOKEN
-      required: true
+- name: DOTENV
+  type: bool
+  required: true
+- name: OTHERENV
+  type: bool
+- name: PORT
+  type: integer
+  required: true
+- name: TOKEN
+  type: text
+  required: false
 ```
 
 It is a list of type and envs. So, in this example, `DOTENV` must have a value
@@ -126,10 +125,11 @@ like `PORT` must be any integer. Currently, we are supporting the following type
 - `text` - Any text
 
 **require** specifies if the env var is obligatory or not. In case you set it to true
-but do not provide it, you wil get an exception.
+but do not provide it, you wil get an exception. When **required** is omited, the default
+value is `false`.
 
-**NOTE:** All the variables which are **required** in the `scheme.yml` must be defined
-in dotenvs.
+**NOTE:** All the variables which are **required** in the `schema.yml` must be defined
+in the dotenvs.
 
 ## Configuration
 
@@ -223,28 +223,29 @@ current environment settings. By invoking the program `env` in place
 of `myprogram` above you can see what the environment will look like
 after evaluating multiple Dotenv files.
 
-Adding the `-s` flag to dotenv will enable the safe mode to type check the env
-variables. For instance:
+The `--schema FILE` will get the envs configuration from the `FILE`. For instance:
 
 ```shell
 $ cat .env
 PORT=123a
-$ cat .scheme.yml
-- type: integer
-  envs:
-    - name: PORT
-      required: true
+$ cat .schema.yml
+- name: PORT
+  required: true
+  type: integer
 ```
 
 running `dotenv` will throw:
 
 ```shell
-$ dotenv -s "echo $PORT"
+$ dotenv -s .schema.yml "echo $PORT"
 dotenv: 1:4:
 unexpected 'a'
 expecting digit or end of input
 ```
 
+**NOTE:** The flag can be omited when the `.schema.yml` is in the current working
+directory. To disable type checking add the flag `--no-schema`.
+
 ## Author
 
 Justin Leitgeb

app/Main.hs

@@ -11,11 +11,11 @@ import Data.Monoid ((<>))
 import Options.Applicative
 import Paths_dotenv (version)
 
-import Control.Monad (when)
+import Control.Monad (void, unless)
 
 import Configuration.Dotenv (loadFile)
 import Configuration.Dotenv.Types (Config(..), defaultConfig)
-import Configuration.Dotenv.Scheme (readScheme, checkConfig)
+import Configuration.Dotenv.Scheme ( runSchemaChecker )
 
 import System.Process (system)
 import System.Exit (exitWith)
@@ -26,31 +26,36 @@ data Options = Options
   , override           :: Bool
   , program            :: String
   , args               :: [String]
-  , safeModeEnabled    :: Bool
+  , schemaFile         :: FilePath
+  , disableSchema      :: Bool
   } deriving (Show)
 
 main :: IO ()
 main = do
   Options{..} <- execParser opts
-  envs <- loadFile Config
-    { configExamplePath = dotenvExampleFiles
-    , configOverride = override
-    , configPath =
-        if null dotenvFiles
-          then configPath defaultConfig
-          else dotenvFiles
-    }
-  when safeModeEnabled (readScheme >>= checkConfig envs)
-  system (program ++ concatMap (" " ++) args) >>= exitWith
-    where
-      opts = info (helper <*> versionOption <*> config)
-        ( fullDesc
-       <> progDesc "Runs PROGRAM after loading options from FILE"
-       <> header "dotenv - loads options from dotenv files" )
-      versionOption =
-        infoOption
-          (showVersion version)
-          (long "version" <> short 'v' <> help "Show version of the program")
+  let configDotenv =
+        Config
+          { configExamplePath = dotenvExampleFiles
+          , configOverride = override
+          , configPath =
+              if null dotenvFiles
+                then configPath defaultConfig
+                else dotenvFiles
+          }
+   in do
+     void $ loadFile configDotenv
+     unless disableSchema
+       (runSchemaChecker schemaFile configDotenv)
+     system (program ++ concatMap (" " ++) args) >>= exitWith
+       where
+         opts = info (helper <*> versionOption <*> config)
+           ( fullDesc
+          <> progDesc "Runs PROGRAM after loading options from FILE"
+          <> header "dotenv - loads options from dotenv files" )
+         versionOption =
+           infoOption
+             (showVersion version)
+             (long "version" <> short 'v' <> help "Show version of the program")
 
 config :: Parser Options
 config = Options
@@ -73,6 +78,9 @@ config = Options
 
      <*> many (argument str (metavar "ARG"))
 
-     <*> switch ( long "safe"
-                  <> short 's'
-                  <> help "Reads the .scheme.yml file from the current directory to enable type checking of envs" )
+     <*> strOption ( long "schema"
+                      <> short 's'
+                      <> help "Set the file path for the schema.yml file"
+                      <> value ".schema.yml" )
+
+     <*> switch ( long "no-schema" <> help "Omit type checking" )

dotenv.cabal

@@ -88,6 +88,7 @@ library
 
   build-depends:         base >=4.7 && <5.0
                        , base-compat >= 0.4
+                       , directory
                        , megaparsec >= 6.0 && < 7.0
                        , process >= 1.4.3.0
                        , text
@@ -128,6 +129,7 @@ test-suite dotenv-test
   build-depends:       base >=4.7 && <5.0
                      , base-compat >= 0.4
                      , dotenv
+                     , directory
                      , megaparsec >= 6.0 && < 7.0
                      , hspec
                      , process >= 1.4.3.0

spec/Configuration/Dotenv/Scheme/ParseSpec.hs

@@ -21,20 +21,13 @@ spec = do
 specInstance :: Spec
 specInstance = describe "parse a config env file" $
   it "parses the env config values from a file" $
-    let expected :: Config
+    let expected :: [Env]
         expected =
-          Config [
-            EnvConf EnvBool
-              [ Env "DOTENV" True
-              , Env "OTHERENV" False
-              ]
-            , EnvConf EnvInteger
-              [ Env "PORT" True
-              , Env "TOKEN" False
-              ]
-            , EnvConf EnvText
-              [ Env "URL" True
-              ]
+            [ Env "DOTENV" EnvBool True
+            , Env "OTHERENV" EnvBool False
+            , Env "PORT" EnvInteger True
+            , Env "TOKEN" EnvInteger False
+            , Env "URL" EnvText True
             ]
      in do
        actual <- decodeFileEither "spec/fixtures/.scheme.yml"

spec/Configuration/Dotenv/SchemeSpec.hs

@@ -13,29 +13,26 @@ spec =
         context "when the required envs are defined" $
           it "should succeed the type check" $
             let schemeEnvs =
-                  Config
-                    [ EnvConf EnvBool [Env "FOO" True]
-                    , EnvConf EnvInteger [Env "BAR" False]
+                    [ Env "FOO" EnvBool True
+                    , Env "BAR" EnvInteger False
                     ]
                 dotenvs = [("FOO","true"), ("BAR","123")]
              in checkConfig dotenvs schemeEnvs `shouldReturn` ()
 
         context "when the not required envs are missing" $
           it "should succeed the type check" $
             let schemeEnvs =
-                  Config
-                    [ EnvConf EnvBool [Env "FOO" True]
-                    , EnvConf EnvInteger [Env "BAR" False]
+                    [ Env "FOO" EnvBool True
+                    , Env "BAR" EnvInteger False
                     ]
                 dotenvs = [("FOO","true")]
              in checkConfig dotenvs schemeEnvs `shouldReturn` ()
 
         context "when the required envs are missing" $
           it "should fail before the type check" $
             let schemeEnvs =
-                  Config
-                    [ EnvConf EnvBool [Env "FOO" True]
-                    , EnvConf EnvInteger [Env "BAR" False]
+                    [ Env "FOO" EnvBool True
+                    , Env "BAR" EnvInteger False
                     ]
                 dotenvs = [("BAR","123")]
                 msg = "The following envs: FOO must be in the dotenvs"
@@ -44,9 +41,8 @@ spec =
       context "when there are missing dotenvs in the scheme" $
         it "should fail before type checking" $
           let schemeEnvs =
-                Config
-                  [ EnvConf EnvBool [Env "FOO" True]
-                  , EnvConf EnvInteger [Env "BAR" False]
+                  [ Env "FOO" EnvBool True
+                  , Env "BAR" EnvInteger False
                   ]
               dotenvs = [("FOO","true"), ("BAR","123"), ("BAZ","text")]
               msg = "The following envs: BAZ must be in your scheme.yml"
@@ -55,10 +51,9 @@ spec =
       context "when there are missing scheme envs in the dotenv vars" $
         it "should fail before type checking" $
           let schemeEnvs =
-                Config
-                  [ EnvConf EnvBool [Env "FOO" True]
-                  , EnvConf EnvText [Env "BAZ" True]
-                  , EnvConf EnvInteger [Env "BAR" False]
+                  [ Env "FOO" EnvBool True
+                  , Env "BAZ" EnvText True
+                  , Env "BAR" EnvInteger False
                   ]
               dotenvs = [("FOO","true"), ("BAR","123")]
               msg = "The following envs: BAZ must be in the dotenvs"

spec/fixtures/.scheme.yml

@@ -1,16 +1,14 @@
-- type: bool
-  envs:
-    - name: DOTENV
-      required: true
-    - name: OTHERENV
-      required: false
-- type: integer
-  envs:
-    - name: PORT
-      required: true
-    - name: TOKEN
-      required: false
-- type: text
-  envs:
-    - name: URL
-      required: true
+- name: DOTENV
+  type: bool
+  required: true
+- name: OTHERENV
+  type: bool
+  required: false
+- name: PORT
+  type: integer
+  required: true
+- name: TOKEN
+  type: integer
+- name: URL
+  type: text
+  required: true

src/Configuration/Dotenv.hs

@@ -15,15 +15,13 @@
 module Configuration.Dotenv
   ( load
   , loadFile
-  , loadSafeFile
   , parseFile
   , onMissingFile )
  where
 
 import Control.Monad (liftM)
 import Configuration.Dotenv.Parse (configParser)
 import Configuration.Dotenv.ParsedVariable (interpolateParsedVariables)
-import Configuration.Dotenv.Scheme (readScheme, checkConfig)
 import Configuration.Dotenv.Types (Config(..))
 import Control.Monad.Catch
 import Control.Monad.IO.Class (MonadIO(..))
@@ -47,17 +45,6 @@ load ::
   -> m ()
 load override = mapM_ (applySetting override)
 
--- | @loadSafeFile@ parses the /.scheme.yml/ file and will perform the type checking
--- of the environment variables in the /.env/ file.
-loadSafeFile
-  :: MonadIO m
-  => Config
-  -> m [(String, String)]
-loadSafeFile config = do
-  envs <- loadFile config
-  liftIO (readScheme >>= checkConfig envs)
-  return envs
-
 -- | @loadFile@ parses the environment variables defined in the dotenv example
 -- file and checks if they are defined in the dotenv file or in the environment.
 -- It also allows to override the environment variables defined in the environment