Merge branch 'dev'

Author: adeharo9

CMakeLists.txt

@@ -1,6 +1,6 @@
 #----------------------- PROJECT CONFIGURATION -------------------------
 cmake_minimum_required(VERSION 3.10)
-project(cpp-dotenv VERSION 0.1.0)
+project(cpp-dotenv VERSION 0.2.0)
 
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

README.md

@@ -1,6 +1,8 @@
 # cpp-dotenv
 
-C++ implementation of nodejs [dotenv](https://github.com/motdotla/dotenv) project. Loads environment variables from .env for C++ projects.
+![version 0.2.0](https://img.shields.io/badge/version-0.2.0-blue)
+
+C++ implementation of NodeJS [dotenv](https://github.com/motdotla/dotenv) project. Loads environment variables from `.env` for C++ projects.
 
 **Please take into account this is still a developing project.**
 
@@ -12,6 +14,9 @@ C++ implementation of nodejs [dotenv](https://github.com/motdotla/dotenv) projec
 2. [Usage](#usage)
    1. [CMake](#cmake)
 3. [Examples](#examples)
+   1. [Basic usage](#basic-usage)
+   2. [Reference renaming](#reference-renaming)
+   3. [Several dotenv files](#several-dotenv-files)
 4. [Grammar](#grammar)
 
 ## Dependencies
@@ -34,6 +39,8 @@ using namespace dotenv;
 
 For convenience, **cpp-dotenv** auto-configures a class object (which is instance of the singleton class `dotenv`) by calling the `load_dotenv()` method at the very beginning of your file (just right before the end of `dotenv.h`) and trying to load a `.env` file, although if you need to add-in your own files (like `.myenv`), simply re-run the loading step passing the file name as parameter; everything new will show up on the `dotenv` instances.
 
+By default, already-defined environment variables are not overwritten even if redefined in some of the loaded files. This behavior can be changed, however, by calling the `load_config()` function with the `overwrite` parameter set to `true`. For an example, take a look at [this one](#several-dotenv-files).
+
 Also for convenience, there is a namespace-global pre-loaded reference variable to the `dotenv` singleton class instance named `env`. Simply use it as you would use a dotenv object on NodeJS, or you can define your own references:
 
 ```cpp
@@ -56,6 +63,8 @@ After this, you might use the library as described in [usage](#usage); no extra
 
 ## Examples
 
+### Basic usage
+
 Assume the following `.env` file:
 
 ```env
@@ -80,8 +89,34 @@ using namespace std;
 
 int main()
 {
-    auto& dotenv = env;  // Reference re-naming
+    cout << "DB_NAME: " << env["DB_NAME"] << endl;
+    cout << "eval \"" << env["COMMAND"] << " " << env["HOST"] << "\"" << endl;
+}
+```
 
+would produce the following output:
+
+```shell
+$ ./main
+  DB_NAME: DontDoThisAtHome
+  eval "ping 8.8.8.8"
+```
+
+### Reference renaming
+
+Assuming the same `.env` file as in the [previous case](#basic-usage), the predefined `env` reference can be easily renamed and used just exactly as the original one.
+
+The following code:
+
+```cpp
+#include "dotenv.h"
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    auto& dotenv = dotenv::env;
     cout << "DB_NAME: " << dotenv["DB_NAME"] << endl;
     cout << "eval \"" << dotenv["COMMAND"] << " " << dotenv["HOST"] << "\"" << endl;
 }
@@ -95,6 +130,59 @@ $ ./main
   eval "ping 8.8.8.8"
 ```
 
+### Several dotenv files
+
+The situation of having several different dotenv files is no stranger one (`.env` for private configuration variables, `.pubenv` for public variables, etc.). Loading several files in addition to the default one and overwritting any variables that are redefined on the files can be done as follows:
+
+Assume the following `.env` file:
+
+```env
+# DB THINGS
+DB_NAME=DontDoThisAtHome
+DB_PASS=such_security
+```
+
+And the following `.pubenv` file:
+
+```env
+# CONNECTIONS THINGS
+COMMAND=ping
+HOST=8.8.8.8
+MESSAGE="Hey buddy!"
+```
+
+The following source file:
+
+```cpp
+#include "dotenv.h"
+#include <iostream>
+
+using namespace dotenv;
+using namespace std;
+
+int main()
+{
+    env.load_dotenv(".env", true);
+    env.load_dotenv(".pubenv", true);
+    cout << "DB_NAME: " << env["DB_NAME"] << endl;
+    cout << "eval \"" << env["COMMAND"] << " " << env["HOST"] << "\"" << endl;
+}
+```
+
+would produce the following output:
+
+```shell
+$ ./main
+  DB_NAME: DontDoThisAtHome
+  eval "ping 8.8.8.8"
+```
+
 ## Grammar
 
 For the geeks, you can check the grammar I've implemented on the `grammar/env.g4` file. Despite being written in an ANTLR4 fashion, I've implemented a simple recursive parser myself given the basic nature of the language. The parser and its methods are publicly available under the `dotenv::parser` class.
+
+## Known issues
+
+The complete list of issues con be consulted at the [issues page](https://github.com/adeharo9/cpp-dotenv/issues).
+
+1. [Variable resolution on values not yet vailable](https://github.com/adeharo9/cpp-dotenv/issues/3)

dotenv.h

@@ -8,7 +8,7 @@
 #include <vector>
 
 
-#ifdef _DEBUG
+#if defined(_DEBUG) || defined(__DEBUG)
     #include <iostream>
 
     #define DEBUG_ENTER(x) std::cerr << "ENTER " << row_count << ":" << col_count << " " << #x << std::endl
@@ -255,33 +255,59 @@ namespace dotenv
         inline void SINGLE_UNQUOTED_STRING()
         {
             DEBUG_ENTER(SINGLE_UNQUOTED_STRING);
-            while (not token_is(SQ_C)) { next(); }
+            while (not token_is(SQ_C))
+            {
+                if (token_is(BS_C))
+                {
+                    possible_escaped_sequence();
+                }
+                else
+                {
+                    next();
+                }
+            }
             DEBUG_EXIT(SINGLE_UNQUOTED_STRING);
         }
 
         inline void DOUBLE_UNQUOTED_STRING()
         {
             DEBUG_ENTER(DOUBLE_UNQUOTED_STRING);
-            while (not token_is(DQ_C)) { next(); }
+            while (not token_is(DQ_C))
+            {
+                if (token_is(BS_C))
+                {
+                    possible_escaped_sequence();
+                }
+                else
+                {
+                    next();
+                }
+            }
             DEBUG_EXIT(DOUBLE_UNQUOTED_STRING);
         }
 
         inline void UNQUOTED_KEY()
         {
+            DEBUG_ENTER(UNQUOTED_KEY);
             match(UNQUOTED_KEY_CHAR);
             while (token_is(UNQUOTED_KEY_CHAR)) { match(UNQUOTED_KEY_CHAR); }
+            DEBUG_EXIT(UNQUOTED_KEY);
         }
 
         inline void UNQUOTED_VALUE()
         {
+            DEBUG_ENTER(UNQUOTED_VALUE);
             match(UNQUOTED_VALUE_CHAR);
             while (token_is(UNQUOTED_VALUE_CHAR)) { match(UNQUOTED_VALUE_CHAR); }
+            DEBUG_EXIT(UNQUOTED_VALUE);
         }
 
         inline void UNQUOTED_COMMENT()
         {
+            DEBUG_ENTER(UNQUOTED_COMMENT);
             match(UNQUOTED_COMMENT_CHAR);
             while (token_is(UNQUOTED_COMMENT_CHAR)) { match(UNQUOTED_COMMENT_CHAR); }
+            DEBUG_EXIT(UNQUOTED_COMMENT);
         }
 
         inline void NL()
@@ -290,6 +316,24 @@ namespace dotenv
             match(NL_C);
         }
 
+        inline void possible_escaped_sequence()
+        {
+            match(BS_C);
+            for (auto& equivalence: ESCAPED_EQUIVALENCES)
+            {
+                if (equivalence.first == token)
+                {
+                    if (bond and binded != nullptr) { binded -> pop_back(); }
+                    else if (bond and binded == nullptr) { throw std::runtime_error("something weird happened to this pointer"); }
+
+                    token = equivalence.second;
+                    next();
+
+                    break;
+                }
+            }
+        }
+
         inline void eof()
         {
             if (not is.eof()) { syntax_err(); }
@@ -382,18 +426,20 @@ namespace dotenv
 
     private:
 
-        static const char CS_C = '#';
-        static const char EQ_C = '=';
-        static const char SP_C = ' ';
-        static const char SQ_C = '\'';
-        static const char DQ_C = '\"';
-        static const char TB_C = '\t';
-        static const char NL_C = '\n';
-        static const char CR_C = '\r';
+        static const char CS_C = '#';   // Comment (sharp)
+        static const char EQ_C = '=';   // Equal sign
+        static const char SP_C = ' ';   // Space
+        static const char SQ_C = '\'';  // Single quote
+        static const char DQ_C = '\"';  // Double quote
+        static const char TB_C = '\t';  // Tabulator
+        static const char NL_C = '\n';  // Newline
+        static const char CR_C = '\r';  // Carriage return
+        static const char BS_C = '\\';  // Backslash
         static const container SP;
         static const container UNQUOTED_KEY_CHAR;
         static const container UNQUOTED_VALUE_CHAR;
         static const container UNQUOTED_COMMENT_CHAR;
+        static const std::vector<std::pair<char, char>> ESCAPED_EQUIVALENCES;
 
     };
 
@@ -440,6 +486,21 @@ namespace dotenv
         CR_C
     };
 
+    const std::vector<std::pair<char, char>> parser::ESCAPED_EQUIVALENCES
+    {
+        { '?' , '?'  },
+        { '\'', '\'' },
+        { '"' , '"'  },
+        { '\\', '\\' },
+        { 'a' , '\a' },
+        { 'b' , '\b' },
+        { 'f' , '\f' },
+        { 'n' , '\n' },
+        { 'r' , '\r' },
+        { 't' , '\t' },
+        { 'v' , '\v' }
+    };
+
     class dotenv
     {
     private:
@@ -460,8 +521,6 @@ namespace dotenv
                 env_file.close();
             }
 
-            _config = true;
-
             return *this;
         }
 
@@ -473,8 +532,6 @@ namespace dotenv
 
         inline const value_type operator[](const key_type& k) const
         {
-            if (not _config) { throw std::logic_error(config_err); }
-
             const char* value = std::getenv(k.c_str());
 
             if (value == nullptr)
@@ -508,14 +565,12 @@ namespace dotenv
         bool _config = false;
 
         static const std::string env_filename;
-        static const std::string config_err;
         static dotenv _instance;
 
     };
 
 
     const std::string dotenv::env_filename = ".env";
-    const std::string dotenv::config_err = "config() method must be called first";
     dotenv dotenv::_instance;