[Deprecate functionality] Remove loadSafeFile (#136)

* Remove references to loadSafeFile

* Update version in cabal file

* Update README

* Update changelog

Author: CristhianMotoche

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## MASTER
 
+## Dotenv 0.9.0.0
+* Remove `loadSafeFile`. Users must create their own parsers to convert the
+read values from `System.Environment` to another data type. Therefore,
+`loadSafeFile` won't be needed. We'll remove this functionality to reduce
+dependencies.
+
 ## Dotenv 0.8.1.0
 * Correct bounds for base. GHC support for versions older than 8.0 was dropped.
 

README.md

@@ -80,46 +80,6 @@ $ dotenv "echo $DATABASE"
 postgres://myusername@localhost/database
 ```
 
-### Type checking envs
-Env variables are simple strings. However, they can represent other types like
-integers, booleans, IP addresses, emails, URIs, and so on. We provide an interface
-that performs type checking after loading the envs and before running your application.
-If the type-check succeeded the application is executed, otherwise you will get an
-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 `.schema.yml`
-in your current directory. This file must have the following structure:
-
-```yaml
-- 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
-of `true` or `false` otherwise it won't be parsed as a boolean value. And envs
-like `PORT` must be any integer. Currently, we are supporting the following types:
-
-- `bool` - Accepts values `false` or `true`
-- `integer` - Accepts values of possitive integers
-- `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. When **required** is omited, the default
-value is `false`.
-
-**NOTE:** All the variables which are **required** in the `schema.yml` must be defined
-in the dotenvs.
-
 ## Configuration
 
 The first argument to `loadFile` specifies the configuration. You cans use

app/Main.hs

@@ -3,34 +3,27 @@
 
 module Main where
 
-import Data.Version (showVersion)
+import           Data.Version         (showVersion)
 #if !MIN_VERSION_base(4,13,0)
-import Data.Monoid ((<>))
+import           Data.Monoid          ((<>))
 #endif
 
-import Options.Applicative
-import Paths_dotenv (version)
+import           Options.Applicative
+import           Paths_dotenv         (version)
 
-import Control.Monad (void, unless)
+import           Control.Monad        (void)
 
-import Configuration.Dotenv
-  (Config(..)
-  , loadFile
-  , loadSafeFile
-  , defaultConfig
-  , defaultValidatorMap)
+import           Configuration.Dotenv (Config (..), defaultConfig, loadFile)
 
-import System.Process (system)
-import System.Exit (exitWith)
+import           System.Exit          (exitWith)
+import           System.Process       (system)
 
 data Options = Options
   { dotenvFiles        :: [String]
   , dotenvExampleFiles :: [String]
   , override           :: Bool
   , program            :: String
   , args               :: [String]
-  , schemaFile         :: FilePath
-  , disableSchema      :: Bool
   } deriving (Show)
 
 main :: IO ()
@@ -47,8 +40,6 @@ main = do
           }
    in do
      void $ loadFile configDotenv
-     unless disableSchema
-       (void $ loadSafeFile defaultValidatorMap schemaFile configDotenv)
      system (program ++ concatMap (" " ++) args) >>= exitWith
        where
          opts = info (helper <*> versionOption <*> config)
@@ -80,10 +71,3 @@ config = Options
      <*> argument str (metavar "PROGRAM")
 
      <*> many (argument str (metavar "ARG"))
-
-     <*> 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

@@ -1,5 +1,5 @@
 name:                dotenv
-version:             0.8.1.0
+version:             0.9.0.0
 synopsis:            Loads environment variables from dotenv files
 homepage:            https://github.com/stackbuilders/dotenv-hs
 description:
@@ -49,8 +49,6 @@ data-dir: spec/fixtures/
 data-files:
   .dotenv
   .dotenv.example
-  .scheme.yml
-  .dotenv.safe
 
 flag static
   description:        Creates static binary.
@@ -72,7 +70,6 @@ executable dotenv
                        , process
                        , text
                        , transformers >= 0.4 && < 0.6
-                       , yaml >= 0.8
   other-modules: Paths_dotenv
 
   hs-source-dirs:      app
@@ -92,10 +89,6 @@ library
                       , Configuration.Dotenv.ParsedVariable
                       , Configuration.Dotenv.Text
                       , Configuration.Dotenv.Types
-                      , Configuration.Dotenv.Scheme
-                      , Configuration.Dotenv.Scheme.Helpers
-                      , Configuration.Dotenv.Scheme.Parser
-                      , Configuration.Dotenv.Scheme.Types
 
   build-depends:         base >= 4.9 && < 5.0
                        , base-compat >= 0.4
@@ -106,7 +99,6 @@ library
                        , text
                        , transformers >=0.4 && < 0.6
                        , exceptions >= 0.8 && < 0.11
-                       , yaml >= 0.8
 
   hs-source-dirs:      src
   ghc-options:         -Wall
@@ -129,12 +121,6 @@ test-suite dotenv-test
                        , Configuration.Dotenv.Types
                        , Configuration.Dotenv.Parse
                        , Configuration.Dotenv.ParsedVariable
-                       , Configuration.Dotenv.SchemeSpec
-                       , Configuration.Dotenv.Scheme.ParseSpec
-                       , Configuration.Dotenv.Scheme
-                       , Configuration.Dotenv.Scheme.Helpers
-                       , Configuration.Dotenv.Scheme.Parser
-                       , Configuration.Dotenv.Scheme.Types
 
   build-depends:       base >= 4.9 && < 5.0
                      , base-compat >= 0.4
@@ -148,8 +134,7 @@ test-suite dotenv-test
                      , transformers >= 0.4 && < 0.6
                      , exceptions >= 0.8 && < 0.11
                      , hspec-megaparsec >= 2.0 && < 3.0
-                     , yaml >= 0.8
-  
+
   build-tools:        hspec-discover   >= 2.0 && < 3.0
 
   if flag(dev)

spec/Configuration/Dotenv/Scheme/ParseSpec.hs

@@ -1,31 +1,20 @@
-{-# LANGUAGE CPP #-}
+{-# LANGUAGE CPP               #-}
 {-# LANGUAGE OverloadedStrings #-}
 
 module Configuration.DotenvSpec (main, spec) where
 
-import Configuration.Dotenv.Types (Config(..))
-import Configuration.Dotenv.Environment
-  ( getEnvironment
-  , lookupEnv
-  , setEnv
-  , unsetEnv
-  )
-import Configuration.Dotenv
-  ( load
-  , loadFile
-  , loadSafeFile
-  , parseFile
-  , onMissingFile
-  )
-
-
-import Test.Hspec
-
-import System.Process (readCreateProcess, shell)
-import Control.Monad (liftM, void)
-import Data.Maybe (fromMaybe)
-import qualified Data.Text as T
-import qualified Data.Map.Lazy as M
+import           Configuration.Dotenv             (load, loadFile,
+                                                   onMissingFile, parseFile)
+import           Configuration.Dotenv.Environment (getEnvironment, lookupEnv,
+                                                   setEnv, unsetEnv)
+import           Configuration.Dotenv.Types       (Config (..))
+
+
+import           Test.Hspec
+
+import           Control.Monad                    (liftM, void)
+import           Data.Maybe                       (fromMaybe)
+import           System.Process                   (readCreateProcess, shell)
 
 main :: IO ()
 main = hspec spec
@@ -100,45 +89,6 @@ spec = do
           lookupEnv "UNICODE_TEST" `shouldReturn` Just "Manabí"
           lookupEnv "ANOTHER_ENV" `shouldReturn` Just "hello"
 
-  describe "loadSafeFile" $ after_ clearEnvs $
-    context "given a custom map" $ do
-      context "when the envs are written accordingly to the rules in the map" $
-        it "should validate accordingly to the rules in the custom map" $
-          let hasTwoLetters text = T.length text == 2
-              customMap = M.fromList
-                [ ("twoLetters", hasTwoLetters)
-                , ("bool", const True)
-                , ("text", const True)
-                , ("integer", const True)
-                ]
-              schemaFile = "spec/fixtures/.scheme.yml"
-              config = Config ["spec/fixtures/.dotenv.safe"] [] False
-              expectedEnvs =
-                [ ("DOTENV","true")
-                , ("OTHERENV","false")
-                , ("PORT","8000")
-                , ("URL","http://example.com")
-                , ("TWO","xD")
-                ]
-           in do
-             envs <- loadSafeFile customMap schemaFile config
-             envs `shouldMatchList` expectedEnvs
-
-      context "when the envs are written in an unexpected way" $
-        it "should throw an errorCall" $
-          let unexpectedFormat text = T.length text == 3
-              customMap = M.fromList
-                [ ("twoLetters", unexpectedFormat)
-                , ("bool", const True)
-                , ("text", const True)
-                , ("integer", const True)
-                ]
-              schemaFile = "spec/fixtures/.scheme.yml"
-              config = Config ["spec/fixtures/.dotenv.safe"] [] False
-           in void $ loadSafeFile customMap schemaFile config
-                `shouldThrow` anyErrorCall
-
-
   describe "parseFile" $ after_ clearEnvs $ do
     it "returns variables from a file without changing the environment" $ do
       lookupEnv "DOTENV" `shouldReturn` Nothing