misc: Updates some documentation and refactors a little bit (#154)

* doc: Update cabal Intro

* doc: Update cabal Intro

* ref: Move helpers to new module

* chore: Replace custom instance with library type

* fix: Include mtl in tests

* bump version 0.10.0.1

Author: CristhianMotoche

CHANGELOG.md

@@ -1,4 +1,8 @@
 ## MASTER
+## Dotenv 0.10.0.1
+### Modified
+* Modify docs.
+
 ## Dotenv 0.10.0.0
 ### Modified
 * `loadFile` change return type (back to `m ()`)

dotenv.cabal

@@ -1,42 +1,41 @@
 name:                dotenv
-version:             0.10.0.0
+version:             0.10.0.1
 synopsis:            Loads environment variables from dotenv files
 homepage:            https://github.com/stackbuilders/dotenv-hs
 description:
   .
   In most applications,
-  <http://12factor.net/config configuration should be separated from code>.
+  <https://12factor.net/config configuration should be separated from code>.
   While it usually works well to keep configuration in the
   environment, there are cases where you may want to store
   configuration in a file outside of version control.
   .
-  "Dotenv" files have become popular for storing configuration,
+  @Dotenv@ files have become popular for storing configuration,
   especially in development and test environments. In
   <https://github.com/bkeepers/dotenv Ruby>,
   <https://github.com/theskumar/python-dotenv Python> and
-  <https://www.npmjs.com/package/dotenv Javascript> there are libraries
+  <https://www.npmjs.com/package/dotenv JavaScript> there are libraries
   to facilitate loading of configuration options from configuration
   files. This library loads configuration to environment variables for
   programs written in Haskell.
   .
   To use, call `loadFile` from your application:
   .
-  > import Control.Monad (void)
   > import Configuration.Dotenv
-  > void $ loadFile defaultConfig
+  > loadFile defaultConfig
   .
   This package also includes an executable that can be used
   to inspect the results of applying one or more Dotenv files
   to the environment, or for invoking your executables with
   an environment after one or more Dotenv files is applied.
   .
-  See the <https://github.com/stackbuilders/dotenv-hs Github>
+  See the <https://github.com/stackbuilders/dotenv-hs#readme Github>
   page for more information on this package.
 license:             MIT
 license-file:        LICENSE
 author:              Justin Leitgeb
 maintainer:          hackage@stackbuilders.com
-copyright:           2015-2020 Stack Builders Inc.
+copyright:           2015-Present Stack Builders Inc.
 category:            Configuration
 build-type:          Simple
 extra-source-files:    spec/fixtures/.dotenv
@@ -97,6 +96,7 @@ library
                        , shellwords >= 0.1.3.0
                        , text
                        , exceptions >= 0.8 && < 0.11
+                       , mtl >= 2.3 && < 2.4
 
   hs-source-dirs:      src
   ghc-options:         -Wall
@@ -132,6 +132,7 @@ test-suite dotenv-test
                      , text
                      , exceptions >= 0.8 && < 0.11
                      , hspec-megaparsec >= 2.0 && < 3.0
+                     , mtl
 
   build-tools:        hspec-discover   >= 2.0 && < 3.0
 

src/Configuration/Dotenv.hs

@@ -24,9 +24,9 @@ import           Configuration.Dotenv.Environment    (getEnvironment, lookupEnv,
                                                       setEnv)
 import           Configuration.Dotenv.Parse          (configParser)
 import           Configuration.Dotenv.ParsedVariable (interpolateParsedVariables)
-import           Configuration.Dotenv.Types          (Config (..), ReaderT, ask,
-                                                      defaultConfig,
-                                                      liftReaderT, runReaderT)
+import           Configuration.Dotenv.Types          (Config (..), defaultConfig)
+import           Control.Monad.Trans                 (lift)
+import           Control.Monad.Reader                (ReaderT, ask, runReaderT)
 import           Control.Exception                   (throw)
 import           Control.Monad                       (unless, when)
 import           Control.Monad.Catch
@@ -97,20 +97,20 @@ applySetting kv@(k, v) = do
   if configOverride
     then info kv >> setEnv'
     else do
-      res <- liftReaderT . liftIO $ lookupEnv k
+      res <- lift . liftIO $ lookupEnv k
       case res of
         Nothing -> info kv >> setEnv'
         Just _  -> return kv
   where
-    setEnv' = liftReaderT . liftIO $ setEnv k v >> return kv
+    setEnv' = lift . liftIO $ setEnv k v >> return kv
 
 -- | The function logs in console when a variable is loaded into the
 -- environment.
 info :: MonadIO m => (String, String) -> DotEnv m ()
 info (key, value) = do
   Config {..} <- ask
   when configVerbose $
-    liftReaderT . liftIO $
+    lift . liftIO $
     putStrLn $ "[INFO]: Load env '" ++ key ++ "' with value '" ++ value ++ "'"
 
 -- | The helper allows to avoid exceptions in the case of missing files and

src/Configuration/Dotenv/Environment.hs

@@ -15,9 +15,11 @@ import System.Environment (getEnvironment, lookupEnv, setEnv, unsetEnv)
 #endif
 
 #if MIN_VERSION_base(4,11,0)
+-- | Re-export "System.Environment" or "System.Environment.Blank" helpers.
 lookupEnv :: String -> IO (Maybe String)
 lookupEnv = getEnv
 
+-- | Re-export "System.Environment" or "System.Environment.Blank" helpers.
 setEnv :: String -> String -> IO ()
 setEnv name value = Blank.setEnv name value True
 #endif

src/Configuration/Dotenv/Types.hs

@@ -12,10 +12,6 @@
 module Configuration.Dotenv.Types
   ( Config(..)
   , defaultConfig
-  , ask
-  , runReaderT
-  , liftReaderT
-  , ReaderT
   )
   where
 
@@ -39,26 +35,3 @@ defaultConfig =
     , configVerbose = False
     , allowDuplicates = True
     }
-
-
-newtype ReaderT r m a = ReaderT { runReaderT :: r -> m a }
-mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b
-mapReaderT f m = ReaderT $ f . runReaderT m
-instance (Functor m) => Functor (ReaderT r m) where
-    fmap f  = mapReaderT (fmap f)
-instance (Applicative m) => Applicative (ReaderT r m) where
-    pure    = liftReaderT . pure
-    f <*> v = ReaderT $ \ r -> runReaderT f r <*> runReaderT v r
-
-instance (Monad m) => Monad (ReaderT r m) where
-    return   = liftReaderT . return
-    m >>= k  = ReaderT $ \ r -> do
-      a <- runReaderT m r
-      runReaderT (k a) r
-    m >> k = ReaderT $ \ r -> runReaderT m r >> runReaderT k r
-
-liftReaderT :: m a -> ReaderT r m a
-liftReaderT m = ReaderT (const m)
-
-ask :: (Monad m) => ReaderT r m r
-ask = ReaderT return