env_parser 0.8.0 → 1.3.1

data/docs/class_list.html

@@ -4,9 +4,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta charset="utf-8" />
     
-      <link rel="stylesheet" href="css/full_list.css" type="text/css" media="screen" charset="utf-8" />
+      <link rel="stylesheet" href="css/full_list.css" type="text/css" media="screen" />
     
-      <link rel="stylesheet" href="css/common.css" type="text/css" media="screen" charset="utf-8" />
+      <link rel="stylesheet" href="css/common.css" type="text/css" media="screen" />
     
 
     
@@ -43,7 +43,7 @@
 
       <ul id="full_list" class="class">
         <li id="object_" class="odd"><div class="item" style="padding-left:30px"><span class='object_link'><a href="top-level-namespace.html" title="Top Level Namespace (root)">Top Level Namespace</a></span></div></li>
-<li id='object_EnvParser' class='even'><div class='item' style='padding-left:30px'><a class='toggle'></a> <span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span> &lt; Object<small class='search_info'>Top Level Namespace</small></div><ul><li id='object_EnvParser::Error' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/Error.html" title="EnvParser::Error (class)">Error</a></span> &lt; StandardError<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::TypeAlreadyDefined' class='collapsed even'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/TypeAlreadyDefined.html" title="EnvParser::TypeAlreadyDefined (class)">TypeAlreadyDefined</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::ValueNotAllowed' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/ValueNotAllowed.html" title="EnvParser::ValueNotAllowed (class)">ValueNotAllowed</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li></ul></li>
+<li id='object_EnvParser' class='even'><div class='item' style='padding-left:30px'><a class='toggle'></a> <span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span> &lt; Object<small class='search_info'>Top Level Namespace</small></div><ul><li id='object_EnvParser::AutoregisterFileNotFound' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/AutoregisterFileNotFound.html" title="EnvParser::AutoregisterFileNotFound (class)">AutoregisterFileNotFound</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::Error' class='collapsed even'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/Error.html" title="EnvParser::Error (class)">Error</a></span> &lt; StandardError<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::TypeAlreadyDefinedError' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/TypeAlreadyDefinedError.html" title="EnvParser::TypeAlreadyDefinedError (class)">TypeAlreadyDefinedError</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::Types' class='collapsed even'><div class='item' style='padding-left:45px'><a class='toggle'></a> <span class='object_link'><a href="EnvParser/Types.html" title="EnvParser::Types (module)">Types</a></span><small class='search_info'>EnvParser</small></div><ul><li id='object_EnvParser::Types::BaseTypes' class='collapsed'><div class='item' style='padding-left:60px'><span class='object_link'><a href="EnvParser/Types/BaseTypes.html" title="EnvParser::Types::BaseTypes (module)">BaseTypes</a></span><small class='search_info'>EnvParser::Types</small></div></li><li id='object_EnvParser::Types::ChronologyTypes' class='collapsed'><div class='item' style='padding-left:60px'><span class='object_link'><a href="EnvParser/Types/ChronologyTypes.html" title="EnvParser::Types::ChronologyTypes (module)">ChronologyTypes</a></span><small class='search_info'>EnvParser::Types</small></div></li><li id='object_EnvParser::Types::InternetTypes' class='collapsed'><div class='item' style='padding-left:60px'><span class='object_link'><a href="EnvParser/Types/InternetTypes.html" title="EnvParser::Types::InternetTypes (module)">InternetTypes</a></span><small class='search_info'>EnvParser::Types</small></div></li></ul></li><li id='object_EnvParser::UnknownTypeError' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/UnknownTypeError.html" title="EnvParser::UnknownTypeError (class)">UnknownTypeError</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::UnparseableAutoregisterSpec' class='collapsed even'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/UnparseableAutoregisterSpec.html" title="EnvParser::UnparseableAutoregisterSpec (class)">UnparseableAutoregisterSpec</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::ValueNotAllowedError' class='collapsed odd'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/ValueNotAllowedError.html" title="EnvParser::ValueNotAllowedError (class)">ValueNotAllowedError</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li><li id='object_EnvParser::ValueNotConvertibleError' class='collapsed even'><div class='item' style='padding-left:45px'><span class='object_link'><a href="EnvParser/ValueNotConvertibleError.html" title="EnvParser::ValueNotConvertibleError (class)">ValueNotConvertibleError</a></span> &lt; Error<small class='search_info'>EnvParser</small></div></li></ul></li>
 
       </ul>
     </div>

data/docs/css/style.css

@@ -52,6 +52,7 @@ body {
   background: #fff;
   padding: 1.2em;
   padding-top: 0.2em;
+  box-sizing: border-box;
 }
 
 @media (max-width: 920px) {
@@ -245,6 +246,7 @@ ul.toplevel { list-style: none; padding-left: 0; font-size: 1.1em; }
 
 dl.constants { margin-left: 10px; }
 dl.constants dt { font-weight: bold; font-size: 1.1em; margin-bottom: 5px; }
+dl.constants.compact dt { display: inline-block; font-weight: normal }
 dl.constants dd { width: 75%; white-space: pre; font-family: monospace; margin-bottom: 18px; }
 dl.constants .docstring .note:first-child { margin-top: 5px; }
 
@@ -326,13 +328,9 @@ ul.summary a, ul.summary a:visited {
   text-decoration: none; font-size: 1.1em;
 }
 ul.summary li { margin-bottom: 5px; }
-.summary .summary_signature {
-  padding: 4px 8px;
-  background: #f8f8f8;
-  border: 1px solid #f0f0f0;
-  border-radius: 5px;
-}
+.summary_signature { padding: 4px 8px; background: #f8f8f8; border: 1px solid #f0f0f0; border-radius: 5px; }
 .summary_signature:hover { background: #CFEBFF; border-color: #A4CCDA; cursor: pointer; }
+.summary_signature.deprecated { background: #ffe5e5; border-color: #e9dada; }
 ul.summary.compact li { display: inline-block; margin: 0px 5px 0px 0px; line-height: 2.6em;}
 ul.summary.compact .summary_signature { padding: 5px 7px; padding-right: 4px; }
 #content .summary_signature:hover a,
@@ -425,8 +423,8 @@ li.r2 { background: #fafafa; }
 #toc ol { padding-left: 1.8em; }
 #toc li { font-size: 1.1em; line-height: 1.7em; }
 #toc > ol > li { font-size: 1.1em; font-weight: bold; }
-#toc ol > ol { font-size: 0.9em; }
-#toc ol ol > ol { padding-left: 2.3em; }
+#toc ol > li > ol { font-size: 0.9em; }
+#toc ol ol > li > ol { padding-left: 2.3em; }
 #toc ol + li { margin-top: 0.3em; }
 #toc.hidden { padding: 10px; background: #fefefe; box-shadow: none; }
 #toc.hidden:hover { background: #fafafa; }
@@ -485,7 +483,7 @@ pre.code .rubyid_nth_ref { color: #6D79DE; }
 pre.code .regexp, .dregexp { color: #036A07; }
 pre.code a { border-bottom: 1px dotted #bbf; }
 /* inline code */
-p > code {
+*:not(pre) > code {
 	padding: 1px 3px 1px 3px;
 	border: 1px solid #E1E1E8;
 	background: #F7F7F9;

data/docs/file.README.html

@@ -6,15 +6,15 @@
 <title>
   File: README
   
-    &mdash; Documentation by YARD 0.9.11
+    &mdash; Documentation by YARD 0.9.26
   
 </title>
 
-  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/style.css" type="text/css" />
 
-  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" />
 
-<script type="text/javascript" charset="utf-8">
+<script type="text/javascript">
   pathId = "README";
   relpath = '';
 </script>
@@ -58,260 +58,249 @@
       </div>
 
       <div id="content"><div id='filecontents'>
-<h1 id="label-EnvParser+rdoc-image-3Ahttps-3A-2F-2Fbadge.fury.io-2Frb-2Fenv_parser.svg">EnvParser <a href="https://badge.fury.io/rb/env_parser"><img src="https://badge.fury.io/rb/env_parser.svg"></a></h1>
-
-<p>If your code uses environment variables, you know that <code>ENV</code>
-will always surface these as strings. Interpreting these strings as the
-value you <em>actually</em> want to see/use takes some work, however: for
-numbers you need to cast with <code>#to_i</code>/<code>#to_f</code>, for
-booleans you need to check for a specific value (<code>ENV['SOME_VAR'] ==
-&#39;true&#39;</code>), etc. Maybe you want to set non-trivial defaults
-(something other than <code>0</code> or <code>&#39;&#39;</code>)? Maybe you
-only want to allow values from a limited set? …</p>
-
-<p>Things can get out of control pretty fast, especially as the number of
-environment variables in play grows. Tools like <a
-href="https://github.com/bkeepers/dotenv">dotenv</a> help to make sure
-you&#39;re loading the correct set of <em>variables</em>, but EnvParser
-makes <em>the values themselves</em> usable with a minimum of effort.</p>
+<p><a href="https://rubygems.org/gems/env_parser"><img src="https://img.shields.io/github/v/release/nestor-custodio/env_parser?color=green&label=gem%20version"></a> <a href="https://github.com/nestor-custodio/env_parser/blob/master/LICENSE.txt"><img src="https://img.shields.io/github/license/nestor-custodio/env_parser"></a></p>
+
+<h1 id="label-EnvParser">EnvParser</h1>
+
+<p>If your code uses environment variables, you know that <code>ENV</code> will always surface these as strings. Interpreting these strings as the value you <em>actually</em> want to see/use takes some work, however: for numbers you need to cast with <code>to_i</code> or <code>to_f</code> … for booleans you need to check for a specific value (<code>ENV['SOME_VAR'] == &#39;true&#39;</code>) … maybe you want to set non-trivial defaults (something other than <code>0</code> or <code>&#39;&#39;</code>)? … maybe you only want to allow values from a limited set? …</p>
+
+<p>Things can get out of control pretty fast, especially as the number of environment variables in play grows. Tools like <a href="https://github.com/bkeepers/dotenv">dotenv</a> help to make sure you&#39;re loading the correct <strong>set</strong> of variables, but <a href="https://github.com/nestor-custodio/env_parser">EnvParser</a> makes <strong>the values themselves</strong> usable with a minimum of effort.</p>
+
+<p><a href="http://nestor-custodio.github.io/env_parser/EnvParser.html">Full documentation is available here</a>, but do read below for a crash course on availble featues!</p>
 
 <h2 id="label-Installation">Installation</h2>
+<ul><li>
+<p>If your project uses <a href="https://github.com/bundler/bundler">Bundler</a>:</p>
+</li><li>
+<p>Add one of the following to your application&#39;s Gemfile: "`ruby</p>
 
-<p>Add this line to your application&#39;s Gemfile:</p>
+<h2 id="label-For+on-demand+usage+...">For on-demand usage ...</h2>
 
-<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_gem'>gem</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>env_parser</span><span class='tstring_end'>&#39;</span></span>
-</code></pre>
+<p>## gem &#39;env_parser&#39;</p>
 
-<p>And then execute:</p>
+<h2 id="label-To+automatically+register+ENV">To automatically register ENV</h2>
 
-<pre class="code ruby"><code class="ruby">$ bundle</code></pre>
+<h2 id="label-constants+per+-22.env_parser.yml-22+...">constants per ".env_parser.yml" ...</h2>
 
-<p>Or install it yourself as:</p>
+<p>## gem &#39;env_parser&#39;, require: &#39;env_parser/autoregister&#39; "`</p>
+</li><li>
+<p>And then run a: <code>shell $ bundle install </code></p>
+</li><li>
+<p>Or, you can keep things simple with a manual install:  <code>shell   $ gem install env_parser </code></p>
+</li></ul>
 
-<pre class="code ruby"><code class="ruby">$ gem install env_parser</code></pre>
+<h2 id="label-Syntax+Cheat+Sheet">Syntax Cheat Sheet</h2>
+
+<pre class="code ruby"><code class="ruby">## Returns an ENV value parsed &quot;as&quot; a specific type:
+##
+EnvParser.parse env_key_as_a_symbol
+                as: …                          ## ➜ required
+                if_unset: …                    ## ➜ optional; default value
+                from_set: …                    ## ➜ optional; an Array or Range
+                validated_by: -&gt;(value) { … }  ## ➜ optional; may also be given as a block
+
+## Parse an ENV value and register it as a constant:
+##
+EnvParser.register env_key_as_a_symbol
+                   as: …                          ## ➜ required
+                   within: …                      ## ➜ optional; Class or Module
+                   if_unset: …                    ## ➜ optional; default value
+                   from_set: …                    ## ➜ optional; an Array or Range
+                   validated_by: -&gt;(value) { … }  ## ➜ optional; may also be given as a block
+
+## Registers all ENV variables as spec&#39;ed in &quot;.env_parser.yml&quot;:
+##
+EnvParser.autoregister  ## Note this is automatically called if your
+                        ## Gemfile included the &quot;env_parser&quot; gem with
+                        ## the &quot;require: &#39;env_parser/autoregister&#39;&quot; option.
+
+## Lets you call &quot;parse&quot; and &quot;register&quot; on ENV itself:
+##
+EnvParser.add_env_bindings  ## ENV.parse will now be a proxy for EnvParser.parse
+                            ## and ENV.register will now be a proxy for EnvParser.register
+</code></pre>
 
-<h2 id="label-Using+EnvParser">Using EnvParser</h2>
+<h2 id="label-Extended+How-To-Use">Extended How-To-Use</h2>
 
 <h4 id="label-Basic+Usage">Basic Usage</h4>
+<ul><li>
+<p><strong>Parsing <code>ENV</code> Values</strong></p>
+</li></ul>
 
-<pre class="code ruby"><code class="ruby"><span class='comment'>## Returns ENV[&#39;TIMEOUT_MS&#39;] as an Integer.
-</span><span class='comment'>## Yields 0 if ENV[&#39;TIMEOUT_MS&#39;] is unset or nil.
-</span><span class='comment'>##
-</span><span class='id identifier rubyid_timeout_ms'>timeout_ms</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='const'>ENV</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>TIMEOUT_MS</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span>
-
-<span class='comment'>## LESS TYPING, PLZ!  :(
-</span><span class='comment'>## If you pass in a Symbol instead of a String, EnvParser
-</span><span class='comment'>## will use the value behind the matching String key in ENV.
-</span><span class='comment'>## (i.e. passing in ENV[&#39;X&#39;] is equivalent to passing in :X)
-</span><span class='comment'>##
-</span><span class='id identifier rubyid_timeout_ms'>timeout_ms</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:TIMEOUT_MS</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span>
-</code></pre>
-<hr>
-
-<p>The named <code>:as</code> parameter is required. The list of allowed
-values is user-expandable, but allowed values out-of-the-box are:</p>
-<table>
-  <tbody>
-    <tr>
-      <th><code>:as</code> value</th>
-      <th>type returned</th>
-    </tr>
-  </tbody>
-  <tbody>
-    <tr>
-      <td>:string</td>
-      <td>String</td>
-    </tr>
-    <tr>
-      <td>:symbol</td>
-      <td>Symbol</td>
-    </tr>
-    <tr>
-      <td>:boolean</td>
-      <td>TrueValue / FalseValue</td>
-    </tr>
-    <tr>
-      <td>:int / :integer</td>
-      <td>Integer</td>
-    </tr>
-    <tr>
-      <td>:float / :decimal / :number</td>
-      <td>Float</td>
-    </tr>
-    <tr>
-      <td>:json</td>
-      <td>&lt; depends on JSON given &gt;</td>
-    </tr>
-    <tr>
-      <td>:array</td>
-      <td>Array</td>
-    </tr>
-    <tr>
-      <td>:hash</td>
-      <td>Hash</td>
-    </tr>
-  </tbody>
-</table>
-<p>Note JSON is parsed using <em>quirks-mode</em> (meaning &#39;true&#39;,
-&#39;25&#39;, and &#39;null&#39; are all considered valid, parseable JSON).</p>
-
-<h4 id="label-Setting+Non-Trivial+Defaults">Setting Non-Trivial Defaults</h4>
-
-<pre class="code ruby"><code class="ruby"><span class='comment'>## If the ENV variable you want is unset (nil) or blank (&#39;&#39;),
-</span><span class='comment'>## the return value is a sensible default for the given &quot;as&quot; type
-</span><span class='comment'>## (0 or 0.0 for numbers, an empty tring, an empty Array or Hash, etc).
-</span><span class='comment'>## Sometimes you want a non-trivial default, however.
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:MISSING_ENV_VARIABLE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span> <span class='comment'>## =&gt; 0
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:MISSING_ENV_VARIABLE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='int'>250</span> <span class='comment'>## =&gt; 250
-</span>
-<span class='comment'>## Note that &quot;if_unset&quot; values are used as-is, with no type conversion.
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:MISSING_ENV_VARIABLE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>Whoops!</span><span class='tstring_end'>&#39;</span></span> <span class='comment'>## =&gt; &#39;Whoops!&#39;
-</span></code></pre>
-
-<h4 id="label-Validating+Parsed+ENV+Values">Validating Parsed ENV Values</h4>
-
-<pre class="code ruby"><code class="ruby"><span class='comment'>## Sometimes setting the type alone is a bit too open-ended.
-</span><span class='comment'>## The &quot;from_set&quot; option lets you restrict the set of allowed values.
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:API_TO_USE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:symbol</span><span class='comma'>,</span> <span class='label'>from_set:</span> <span class='qsymbols_beg'>%i[</span><span class='tstring_content'>internal</span><span class='words_sep'> </span><span class='tstring_content'>external</span><span class='words_sep'>]</span>
-<span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:SOME_CUSTOM_NETWORK_PORT</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>from_set:</span> <span class='lparen'>(</span><span class='int'>1</span><span class='op'>..</span><span class='int'>65535</span><span class='rparen'>)</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='int'>80</span>
-
-<span class='comment'>## And if the value is not allowed...
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:NEGATIVE_NUMBER</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>from_set:</span> <span class='lparen'>(</span><span class='int'>1</span><span class='op'>..</span><span class='int'>5</span><span class='rparen'>)</span> <span class='comment'>## =&gt; raises EnvParser::ValueNotAllowed
-</span>
-
-<span class='comment'>## The &quot;validated_by&quot; option allows for more complex validation.
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:MUST_BE_LOWERCASE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:string</span><span class='comma'>,</span> <span class='label'>validated_by:</span> <span class='tlambda'>-&gt;</span><span class='lparen'>(</span><span class='id identifier rubyid_value'>value</span><span class='rparen'>)</span> <span class='tlambeg'>{</span> <span class='id identifier rubyid_value'>value</span> <span class='op'>==</span> <span class='id identifier rubyid_value'>value</span><span class='period'>.</span><span class='id identifier rubyid_downcase'>downcase</span> <span class='rbrace'>}</span>
-
-<span class='comment'>## ... but a block will also do the trick!
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span><span class='lparen'>(</span><span class='symbol'>:MUST_BE_LOWERCASE</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:string</span><span class='rparen'>)</span> <span class='lbrace'>{</span> <span class='op'>|</span><span class='id identifier rubyid_value'>value</span><span class='op'>|</span> <span class='id identifier rubyid_value'>value</span> <span class='op'>==</span> <span class='id identifier rubyid_value'>value</span><span class='period'>.</span><span class='id identifier rubyid_downcase'>downcase</span> <span class='rbrace'>}</span>
-<span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span><span class='lparen'>(</span><span class='symbol'>:CONNECTION_RETRIES</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='op'>&amp;</span><span class='symbol'>:nonzero?</span><span class='rparen'>)</span>
-</code></pre>
+<p>At its core, EnvParser is a straight-forward parser for string values (since that&#39;s all <code>ENV</code> ever gives you), allowing you to read a given string <strong><em>as</em></strong> a variety of types.</p>
+
+<p><code>ruby   ## Returns ENV['TIMEOUT_MS'] as an Integer,   ## or a sensible default (0) if ENV['TIMEOUT_MS'] is unset.   ##   timeout_ms = EnvParser.parse ENV['TIMEOUT_MS'], as: :integer </code></p>
+
+<p>You can check the full documentation for <a href="http://nestor-custodio.github.io/env_parser/EnvParser/Types.html">a list of all as types available right out of the box</a>.</p>
+<ul><li>
+<p><strong>How About Less Typing?</strong></p>
+</li></ul>
+
+<p>EnvParser is all about ~simplification~ &lt;s&gt;less typing&lt;/s&gt; <em>laziness</em>. If you pass in a symbol instead of a string, EnvParser will look to <code>ENV</code> and use the value from the corresponding (string) key.</p>
+
+<p><code>ruby   ## YAY, LESS TYPING!  😃   ## These two are the same:   ##   more_typing = EnvParser.parse ENV['TIMEOUT_MS'], as: :integer   less_typing = EnvParser.parse :TIMEOUT_MS, as: :integer </code></p>
+<ul><li>
+<p><strong>Registering Constants From <code>ENV</code> Values</strong></p>
+</li></ul>
+
+<p>The <code>EnvParser.register</code> method lets you “promote” <code>ENV</code> variables into their own constants, already parsed into the correct type.</p>
 
-<h4 id="label-Setting+Constants+From+ENV+Values">Setting Constants From ENV Values</h4>
-
-<pre class="code ruby"><code class="ruby"><span class='comment'>## Global constants...
-</span><span class='comment'>##
-</span><span class='const'>ENV</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>API_KEY</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span> <span class='comment'>## =&gt; &#39;unbreakable p4$$w0rd&#39; (Set elsewhere, like a &quot;.env&quot; file.)
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span> <span class='symbol'>:API_KEY</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:string</span>
-<span class='const'>API_KEY</span> <span class='comment'>## =&gt; &#39;unbreakable p4$$w0rd&#39; (registered within the Kernel module, so it&#39;s available everywhere)
-</span>
-<span class='comment'>## ... and class/module constants!
-</span><span class='comment'>##
-</span><span class='const'>ENV</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>ULTIMATE_LINK</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span> <span class='comment'>## =&gt; &#39;https://youtu.be/L_jWHffIx5E&#39; (Set elsewhere, like a &quot;.env&quot; file.)
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span> <span class='symbol'>:ULTIMATE_LINK</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:string</span><span class='comma'>,</span> <span class='label'>within:</span> <span class='const'>URI</span>
-<span class='const'>URI</span><span class='op'>::</span><span class='const'>ULTIMATE_LINK</span> <span class='comment'>## =&gt; &#39;https://youtu.be/L_jWHffIx5E&#39; (You know you want to check it out!)
-</span><span class='const'>ULTIMATE_LINK</span> <span class='comment'>## =&gt; raises NameError (the un-namespaced constant is only in scope within the URI module)
-</span>
-
-<span class='comment'>## You can also set multiple constants in one call, which is considerably cleaner to read:
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span> <span class='symbol'>:A</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:string</span>
-<span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span> <span class='symbol'>:B</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='int'>25</span>
-<span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span> <span class='symbol'>:C</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:boolean</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='kw'>true</span>
-
-<span class='comment'>## ... is equivalent to ...
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_register'><span class='object_link'><a href="EnvParser.html#register-class_method" title="EnvParser.register (method)">register</a></span></span><span class='lparen'>(</span>
-  <span class='label'>A:</span> <span class='lbrace'>{</span> <span class='label'>as:</span> <span class='symbol'>:string</span> <span class='rbrace'>}</span><span class='comma'>,</span>
-  <span class='label'>B:</span> <span class='lbrace'>{</span> <span class='label'>as:</span> <span class='symbol'>:integer</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='int'>25</span> <span class='rbrace'>}</span><span class='comma'>,</span>
-  <span class='label'>C:</span> <span class='lbrace'>{</span> <span class='label'>as:</span> <span class='symbol'>:boolean</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='kw'>true</span> <span class='rbrace'>}</span>
-<span class='rparen'>)</span>
+<p>“`ruby  <a href="'API_KEY'">ENV</a> ## =&gt; &#39;unbreakable p4$$w0rd&#39;</p>
+
+<p>EnvParser.register :API_KEY, as: :string  API_KEY ## =&gt; &#39;unbreakable p4$$w0rd&#39;  “`</p>
+
+<p>By default, <code>EnvParser.register</code> will create the requested constant within the Kernel module (making it available everywhere), but you can specify any class or module you like.</p>
+
+<p>“`ruby  <a href="'BEST_VIDEO'">ENV</a> ## =&gt; &#39;<a href="https://youtu.be/L_jWHffIx5E">youtu.be/L_jWHffIx5E</a>&#39;</p>
+
+<p>EnvParser.register :BEST_VIDEO, as: :string, within: URI  URI::BEST_VIDEO ## =&gt; &#39;<a href="https://youtu.be/L_jWHffIx5E">youtu.be/L_jWHffIx5E</a>&#39;  BEST_VIDEO ## =&gt; raises NameError  “`</p>
+
+<p>You can also register multiple constants with a single call, which is a bit cleaner.</p>
+
+<p>“`ruby  EnvParser.register :USERNAME, as: :string  EnvParser.register :PASSWORD, as: :string  EnvParser.register :MOCK_API, as: :boolean, within: MyClassOrModule }</p>
+
+<p>## … is equivalent to … ##</p>
+
+<p>EnvParser.register USERNAME: { as: :string },  PASSWORD: { as: :string },  MOCK_API: { as: :boolean, within: MyClassOrModule }  “`</p>
+<ul><li>
+<p><strong>Okay, But… How About Even Less Typing?</strong></p>
+</li></ul>
+
+<p>Calling <code>EnvParser.add_env_bindings</code> binds proxy <code>parse</code> and <code>register</code> methods onto <code>ENV</code>. With these bindings in place, you can call <code>parse</code> or <code>register</code> on <code>ENV</code> itself, which is more legible and feels more straight-forward.</p>
+
+<p>“`ruby  <a href="'SHORT_PI'">ENV</a> ## =&gt; &#39;3.1415926&#39;  <a href="'BETTER_PI'">ENV</a> ## =&gt; &#39;[“flaky crust”, “strawberry filling”]&#39;</p>
+
+<p>## Bind the proxy methods.  ##  EnvParser.add_env_bindings</p>
+
+<p>ENV.parse :SHORT_PI, as: :float ## =&gt; 3.1415926  ENV.register :BETTER_PI, as: :array ## Your constant is set!  “`</p>
+
+<p>Note that the proxy <code>ENV.parse</code> method will (naturally) <em>always</em> interpret the value given as an <code>ENV</code> key (converting it to a string, if necessary), which is slightly different from the original <code>EnvParser.parse</code> method.</p>
+
+<p>“`ruby  <a href="'SHORT_PI'">ENV</a> ## =&gt; &#39;3.1415926&#39;</p>
+
+<p>EnvParser.parse &#39;SHORT_PI&#39;, as: :float ## =&gt; &#39;SHORT_PI&#39; as a float: 0.0  EnvParser.parse :SHORT_PI , as: :float ## =&gt; <a href="'SHORT_PI'">ENV</a> as a float: 3.1415926</p>
+
+<p>## Bind the proxy methods.  ##  EnvParser.add_env_bindings</p>
+
+<p>ENV.parse &#39;SHORT_PI&#39;, as: :float ## =&gt; <a href="'SHORT_PI'">ENV</a> as a float: 3.1415926  ENV.parse :SHORT_PI , as: :float ## =&gt; <a href="'SHORT_PI'">ENV</a> as a float: 3.1415926  “`</p>
+
+<p>Note also that the <code>ENV.parse</code> and <code>ENV.register</code> binding is done safely and without polluting the method space for other objects.</p>
+
+<p><strong>All additional examples below will assume that <code>ENV</code> bindings are already in place, for brevity&#39;s sake.</strong></p>
+
+<h4 id="label-Ensuring+Usable+Values">Ensuring Usable Values</h4>
+<ul><li>
+<p><strong>Sensible Defaults</strong></p>
+</li></ul>
+
+<p>If the <code>ENV</code> variable you want is unset (<code>nil</code>) or blank (<code>&#39;&#39;</code>), the return value is a sensible default for the given <strong><em>as</em></strong> type: 0 or 0.0 for numbers, an empty string/array/hash, etc. Sometimes you want a non-trivial default, however. The <strong><em>if_unset</em></strong> option lets you specify a default that better meets your needs.</p>
+
+<p><code>ruby   ENV.parse :MISSING_VAR, as: :integer  ## =&gt; 0   ENV.parse :MISSING_VAR, as: :integer, if_unset: 250  ## =&gt; 250 </code></p>
+
+<p>Note these default values are used as-is with no type conversion, so exercise caution.</p>
+
+<p><code>ruby   ENV.parse :MISSING_VAR, as: :integer, if_unset: &#39;Careful!&#39;  ## =&gt; &#39;Careful!&#39; (NOT AN INTEGER) </code></p>
+<ul><li>
+<p><strong>Selecting From A Set</strong></p>
+</li></ul>
+
+<p>Sometimes setting the <strong><em>as</em></strong> type is a bit too open-ended. The <strong><em>from_set</em></strong> option lets you restrict the domain of allowed values.</p>
+
+<p>“`ruby  ENV.parse :API_TO_USE, as: :symbol, from_set: %i[internal external]  ENV.parse :NETWORK_PORT, as: :integer, from_set: (1..65535), if_unset: 80</p>
+
+<p>## And if the value is not in the allowed set …  ##  ENV.parse :TWELVE, as: :integer, from_set: (1..5) ## =&gt; raises EnvParser::ValueNotAllowedError  “`</p>
+<ul><li>
+<p><strong>Custom Validation Of Parsed Values</strong></p>
+</li></ul>
+
+<p>You can write your own, more complex validations by passing in a <strong><em>validated_by</em></strong> lambda or an equivalent block. The lambda/block should take one value and return true if the given value passes the custom validation.</p>
+
+<p>“`ruby  ## Via a “validated_by” lambda …  ##  ENV.parse :MUST_BE_LOWERCASE, as: :string, validated_by: -&gt;(value) { value == value.downcase }</p>
+
+<p>## … or with a block!  ##  ENV.parse(:MUST_BE_LOWERCASE, as: :string) { |value| value == value.downcase }  ENV.parse(:CONNECTION_RETRIES, as: :integer, &amp;:positive?)  “`</p>
+<ul><li>
+<p><strong>Defining Your Own EnvParser “<em>as</em>” Types</strong></p>
+</li></ul>
+
+<p>If you use a particular validation many times or are often manipulating values in the same way after EnvParser has done its thing, you may want to register a new type altogether. Defining a new type makes your code both more maintainable (all the logic for your special type is only defined once) and more readable (your <code>parse</code> calls aren&#39;t littered with type-checking cruft).</p>
+
+<p>Something as repetitive as:</p>
+
+<p>“`ruby  a = ENV.parse :A, as: :int, if_unset: 6  raise unless passes_all_my_checks?(a)</p>
+
+<p>b = ENV.parse :B, as: :int, if_unset: 6  raise unless passes_all_my_checks?(b)  “`</p>
+
+<p>… is perhaps best handled by defining a new type:</p>
+
+<p>“`ruby  EnvParser.define_type(:my_special_type_of_number, if_unset: 6) do |value|  value = value.to_i  unless passes_all_my_checks?(value)  raise(EnvParser::ValueNotConvertibleError, &#39;cannot parse as a “special type number”&#39;)  end</p>
+
+<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_value'>value</span>
 </code></pre>
 
-<h4 id="label-Binding+EnvParser+Proxies+Onto+ENV">Binding EnvParser Proxies Onto ENV</h4>
-
-<pre class="code ruby"><code class="ruby"><span class='comment'>## To allow for even cleaner usage, you can bind proxy &quot;parse&quot; and &quot;register&quot; methods onto ENV.
-</span><span class='comment'>## This is done cleanly and without polluting the method space for any other objects.
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_add_env_bindings'><span class='object_link'><a href="EnvParser.html#add_env_bindings-class_method" title="EnvParser.add_env_bindings (method)">add_env_bindings</a></span></span> <span class='comment'>## Sets up the proxy methods.
-</span>
-<span class='comment'>## Now you can call &quot;parse&quot; and &quot;register&quot; on ENV itself. Note that ENV&#39;s proxy &quot;parse&quot; method will
-</span><span class='comment'>## attempt to interpret any value given as an ENV key (converting to a String, if necessary).
-</span><span class='comment'>##
-</span><span class='const'>ENV</span><span class='lbracket'>[</span><span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>SHORT_PI</span><span class='tstring_end'>&#39;</span></span><span class='rbracket'>]</span> <span class='comment'>## =&gt; &#39;3.1415926&#39;
-</span><span class='const'>ENV</span><span class='period'>.</span><span class='id identifier rubyid_parse'>parse</span> <span class='symbol'>:SHORT_PI</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:float</span> <span class='comment'>## =&gt; 3.1415926
-</span><span class='const'>ENV</span><span class='period'>.</span><span class='id identifier rubyid_register'>register</span> <span class='symbol'>:SHORT_PI</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:float</span> <span class='comment'>## Your constant is set, my man!
-</span></code></pre>
-
-<h4 id="label-Defining+your+own+types+for+use+with+EnvParser">Defining your own types for use with EnvParser</h4>
-
-<pre class="code ruby"><code class="ruby"><span class='comment'>## If you use a particular validation many times, or are often manipulating values in the same way
-</span><span class='comment'>## after EnvParser has done its thing, you may want to register a new type altogether.
-</span><span class='comment'>##
-</span><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:A</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:int</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='kw'>nil</span>
-<span class='id identifier rubyid_raise'>raise</span> <span class='kw'>unless</span> <span class='id identifier rubyid_passes_all_my_checks?'>passes_all_my_checks?</span><span class='lparen'>(</span><span class='id identifier rubyid_a'>a</span><span class='rparen'>)</span>
-
-<span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:B</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:int</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='kw'>nil</span>
-<span class='id identifier rubyid_raise'>raise</span> <span class='kw'>unless</span> <span class='id identifier rubyid_passes_all_my_checks?'>passes_all_my_checks?</span><span class='lparen'>(</span><span class='id identifier rubyid_b'>b</span><span class='rparen'>)</span>
-
-<span class='comment'>## ... is perhaps best handled by defining a new type:
-</span><span class='comment'>##
-</span><span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_define_type'><span class='object_link'><a href="EnvParser.html#define_type-class_method" title="EnvParser.define_type (method)">define_type</a></span></span><span class='lparen'>(</span><span class='symbol'>:my_special_type_of_number</span><span class='comma'>,</span> <span class='label'>if_unset:</span> <span class='kw'>nil</span><span class='rparen'>)</span> <span class='kw'>do</span> <span class='op'>|</span><span class='id identifier rubyid_value'>value</span><span class='op'>|</span>
-  <span class='id identifier rubyid_value'>value</span> <span class='op'>=</span> <span class='id identifier rubyid_value'>value</span><span class='period'>.</span><span class='id identifier rubyid_to_i'>to_i</span>
-  <span class='id identifier rubyid_raise'>raise</span><span class='lparen'>(</span><span class='const'>StandardError</span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&#39;</span><span class='tstring_content'>this is not a &quot;special type&quot; number</span><span class='tstring_end'>&#39;</span></span><span class='rparen'>)</span> <span class='kw'>unless</span> <span class='id identifier rubyid_passes_all_my_checks?'>passes_all_my_checks?</span><span class='lparen'>(</span><span class='id identifier rubyid_value'>value</span><span class='rparen'>)</span>
-
-  <span class='id identifier rubyid_value'>value</span>
-<span class='kw'>end</span>
-
-<span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:A</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:my_special_type_of_number</span>
-<span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='const'><span class='object_link'><a href="EnvParser.html" title="EnvParser (class)">EnvParser</a></span></span><span class='period'>.</span><span class='id identifier rubyid_parse'><span class='object_link'><a href="EnvParser.html#parse-class_method" title="EnvParser.parse (method)">parse</a></span></span> <span class='symbol'>:B</span><span class='comma'>,</span> <span class='label'>as:</span> <span class='symbol'>:my_special_type_of_number</span>
-
-<span class='comment'>## Defining a new type makes your code both more maintainable (all the logic for your special type
-</span><span class='comment'>## is only defined once) and more readable (your &quot;parse&quot; calls aren&#39;t littered with type-checking
-</span><span class='comment'>## cruft).
-</span></code></pre>
-<hr>
-
-<p><a href="http://nestor-custodio.github.io/env_parser">Consult the repo
-docs</a> for the full EnvParser documentation.</p>
+<p>end</p>
+
+<p>a = ENV.parse :A, as: :my_special_type_of_number  b = ENV.parse :B, as: :my_special_type_of_number  “`</p>
+
+<h4 id="label-Auto-Registering+Constants">Auto-Registering Constants</h4>
+<ul><li>
+<p><strong>The <code>autoregister</code> Call</strong></p>
+</li></ul>
+
+<p>Consolidating all of your <code>EnvParser.register</code> calls into a single place only makes sense. A single <code>EnvParser.autoregister</code> call take a filename to read and process as a series of constant registration requests. If no filename is given, the default <code>&quot;.env_parser.yml&quot;</code> is assumed.</p>
+
+<p>You&#39;ll normally want to call <code>EnvParser.autoregister</code> as early in your application as possible. For Rails applications (and other frameworks that call <code>require &#39;bundler/setup&#39;</code>), requiring the EnvParser gem via …</p>
+
+<p><code>ruby   gem &#39;env_parser&#39;, require: &#39;env_parser/autoregister&#39; </code></p>
+
+<p>… will automatically make the autoregistration call for you as soon as the gem is loaded (which should be early enough for most uses). If this is <em>still</em> not early enough for your needs, you can always <code>require &#39;env_parser/autoregister&#39;</code> yourself even before <code>bundler/setup</code> is invoked.</p>
+<ul><li>
+<p><strong>The “.env_parser.yml” File</strong></p>
+</li></ul>
+
+<p>If you recall, multiple constants can be registered via a single <code>EnvParser.register</code> call:</p>
+
+<p>“`ruby  EnvParser.register :USERNAME, as: :string  EnvParser.register :PASSWORD, as: :string  EnvParser.register :MOCK_API, as: :boolean, within: MyClassOrModule }</p>
+
+<p>## … is equivalent to … ##</p>
+
+<p>EnvParser.register USERNAME: { as: :string },  PASSWORD: { as: :string },  MOCK_API: { as: :boolean, within: MyClassOrModule }  “`</p>
+
+<p>The autoregistraton file is intended to read as a YAML version of what you&#39;d pass to the single-call version of <code>EnvParser.register</code>: a single hash with keys for each of the constants you&#39;d like to register, with each value being the set of options to parse that constant.</p>
+
+<p>The equivalent autoregistration file for the above would be:</p>
+
+<p>“`yaml  USERNAME:  as: :string</p>
+
+<p>PASSWORD:  as: :string</p>
+
+<p>MOCK_API:  as: :boolean  within: MyClassOrModule  “`</p>
+
+<p>Because no Ruby <em>statements</em> can be safely represented via YAML, the set of <code>EnvParser.register</code> options available via autoregistration is limited to <strong><em>as</em></strong>, <strong><em>within</em></strong>, <strong><em>if_unset</em></strong>, and <strong><em>from_set</em></strong>. As an additional restriction, <strong><em>from_set</em></strong> (if given) must be an array, as ranges cannot be represented in YAML.</p>
 
 <h2 id="label-Feature+Roadmap+-2F+Future+Development">Feature Roadmap / Future Development</h2>
 
-<p>Additional features/options coming in the future:</p>
+<p>Additional features coming in the future:</p>
 <ul><li>
-<p>Round out the “as” type selection with things like <code>:url</code>,
-<code>:email</code>, etc.</p>
-</li><li>
-<p>… ?</p>
+<p>Continue to round out the <strong><em>as</em></strong> type selection as ideas come to mind, suggestions are made, and pull requests are submitted.</p>
 </li></ul>
 
 <h2 id="label-Contribution+-2F+Development">Contribution / Development</h2>
 
-<p>Bug reports and pull requests are welcome on GitHub at <a
-href="https://github.com/nestor-custodio/env_parser">github.com/nestor-custodio/env_parser</a>.</p>
-
-<p>After checking out the repo, run <code>bin/setup</code> to install
-dependencies. Then, run <code>rake spec</code> to run the tests. You can
-also run <code>bin/console</code> for an interactive prompt that will allow
-you to experiment.</p>
+<p>Bug reports and pull requests are welcome at: <a href="https://github.com/nestor-custodio/env_parser">github.com/nestor-custodio/env_parser</a></p>
 
-<p>Linting is courtesy of <a
-href="https://github.com/bbatsov/rubocop">Rubocop</a> and documentation is
-built using <a href="https://yardoc.org/">Yard</a>. Neither is included in
-the Gemspec; you&#39;ll need to install these locally to take advantage.</p>
+<p>After checking out the repo, run <code>bin/setup</code> to install dependencies. Then, run <code>bundle exec rspec</code> to run the tests. You can also run <code>bin/console</code> for an interactive prompt that will allow you to experiment.</p>
 
-<p>To install this gem onto your local machine, run <code>bundle exec rake
-install</code>. To release a new version, update the version number in
-<code>version.rb</code>, and then run <code>bundle exec rake
-release</code>, which will create a git tag for the version, push git
-commits and tags, and push the <code>.gem</code> file to <a
-href="https://rubygems.org">rubygems.org</a>.</p>
+<p>Linting is courtesy of <a href="https://docs.rubocop.org/">Rubocop</a> (<code>bundle exec rubocop</code>) and documentation is built using <a href="https://yardoc.org/">Yard</a> (<code>bundle exec yard</code>). Please ensure you have a clean bill of health from Rubocop and that any new features and/or changes to behaviour are reflected in the documentation before submitting a pull request.</p>
 
 <h2 id="label-License">License</h2>
 
-<p>The gem is available as open source under the terms of the <a
-href="https://opensource.org/licenses/MIT">MIT License</a>.</p>
+<p>EnvParser is available as open source under the terms of the <a href="https://tldrlegal.com/license/mit-license">MIT License</a>.</p>
 </div></div>
 
       <div id="footer">
-  Generated on Sun Dec 24 19:33:35 2017 by
+  Generated on Sat Jan  2 17:31:17 2021 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.9.11 (ruby-2.4.2).
+  0.9.26 (ruby-2.7.2).
 </div>
 
     </div>