tty-config 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f0321ad959e00b63f653d7f27a89964cdc24b103aab2052615e0ed3fdf284ce
-  data.tar.gz: 12df44d97821e84cb19620fadec565841d0de28abc1a4ba1cd8a05d9d1d6ec24
+  metadata.gz: '082839e3aab5e29ce83325a7c96c2c6ce636fde381f4dc4c39cf66309bdb10b7'
+  data.tar.gz: c0be15cc9d7e0f211fefe9a9e6317f3076b26bfe2bff4a13eb4c0b2ce68a6174
 SHA512:
-  metadata.gz: ebe68702be360238664adf912b42342df8e3e3be266d7e52d2be515d8f48373db53850688517f7c569f2b9674a88371a3205bad707d48a209c01d147af27c07f
-  data.tar.gz: af1c4f4586a6be640f65ebe01e0dcb88340860b4ae1645ba611135e618ca1b772c75eab2ab9744e0409dddac316154f2358d403e0950af20c25c1755ee7f16cc
+  metadata.gz: fb63f5a33972507ebdc97c4986117b93085314b2a66bd0ed455c2c7bda03ff520f69eee72b72350a868e9370ab287980e34ef60a008c0dbe4917cd6cce8a26bd
+  data.tar.gz: 88b31c1a9cc6023c9057b9ea8c7970e791d3de9c64118c8ddc0b753a48c643f5e62bd364c2089feccc40ca1977d821a5c0ab7ca6425ea7e5d69dcf04d03d43cd

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Change log
 
+## [v0.5.0] - 2021-05-23
+
+### Added
+* Add :create option to the #write method to control creating any missing directories
+* Add :path option to the #write method to specify a custom file path to write to
+* Add ability to specify a default value for a missing key in the #delete method
+* Add #env_separator for setting a string to separate parts in environment variable name
+
+### Changed
+* Change #delete to allow removing any subkey of a deeply nested key
+* Change #remove to require from keyword
+* Change #set_if_empty to use nested key fetching to check for value presence
+
+### Fixed
+* Fix Marshaller interface to copy extension names to a subclass
+
 ## [v0.4.0] - 2020-01-25
 
 ### Added
@@ -55,9 +71,10 @@
 
 * Initial implementation and release
 
+[v0.5.0]: https://github.com/piotrmurach/tty-config/compare/v0.4.0...v0.5.0
 [v0.4.0]: https://github.com/piotrmurach/tty-config/compare/v0.3.2...v0.4.0
 [v0.3.2]: https://github.com/piotrmurach/tty-config/compare/v0.3.1...v0.3.2
 [v0.3.1]: https://github.com/piotrmurach/tty-config/compare/v0.3.0...v0.3.1
 [v0.3.0]: https://github.com/piotrmurach/tty-config/compare/v0.2.0...v0.3.0
 [v0.2.0]: https://github.com/piotrmurach/tty-config/compare/v0.1.0...v0.2.0
-[v0.1.0]: https://github.com/piotrmurach/tty-config/compare/v0.1.0
+[v0.1.0]: https://github.com/piotrmurach/tty-config/compare/19cd277...v0.1.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Piotr Murach
+Copyright (c) 2018 Piotr Murach (piotrmurach.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,46 +1,46 @@
 <div align="center">
-  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://github.com/piotrmurach/tty/raw/master/images/tty.png" alt="tty logo" /></a>
+  <a href="https://ttytoolkit.org"><img width="130" src="https://github.com/piotrmurach/tty/raw/master/images/tty.png" alt="TTY Toolkit logo" /></a>
 </div>
 
 # TTY::Config [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 
 [![Gem Version](https://badge.fury.io/rb/tty-config.svg)][gem]
-[![Build Status](https://secure.travis-ci.org/piotrmurach/tty-config.svg?branch=master)][travis]
+[![Actions CI](https://github.com/piotrmurach/tty-config/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
 [![Build status](https://ci.appveyor.com/api/projects/status/2383i0dn3hlw9cnn?svg=true)][appveyor]
 [![Maintainability](https://api.codeclimate.com/v1/badges/dfac05073e1549e9dbb6/maintainability)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/github/piotrmurach/tty-config/badge.svg)][coverage]
-[![Inline docs](http://inch-ci.org/github/piotrmurach/tty-config.svg?branch=master)][inchpages]
+[![Inline docs](https://inch-ci.org/github/piotrmurach/tty-config.svg?branch=master)][inchpages]
 
 [gitter]: https://gitter.im/piotrmurach/tty
-[gem]: http://badge.fury.io/rb/tty-config
-[travis]: http://travis-ci.org/piotrmurach/tty-config
+[gem]: https://badge.fury.io/rb/tty-config
+[gh_actions_ci]: https://github.com/piotrmurach/tty-config/actions?query=workflow%3ACI
 [appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-config
 [codeclimate]: https://codeclimate.com/github/piotrmurach/tty-config/maintainability
 [coverage]: https://coveralls.io/github/piotrmurach/tty-config
-[inchpages]: http://inch-ci.org/github/piotrmurach/tty-config
+[inchpages]: https://inch-ci.org/github/piotrmurach/tty-config
 
-> Define, read and write any Ruby app configurations with a penchant for terminal clients.
+> A highly customisable application configuration interface for building terminal tools.
 
-**TTY::Config** provides app configuration component for [TTY](https://github.com/piotrmurach/tty) toolkit.
+**TTY::Config** provides application configuration component for [TTY](https://github.com/piotrmurach/tty) toolkit.
 
 ## Features
 
 This is a one-stop shop for all your configuration needs:
 
-* Read and write config files in YAML, JSON, TOML, INI, HCL and Java Properties formats
-* Add custom marshallers or override the built-in ones
-* Set and read settings for deeply nested keys
-* Set defaults for undefined settings
-* Read settings with indifferent access
-* Merge configuration settings from other hash objects
-* Read values from environment variables
+* [Read](#216-read) and [write](#217-write) config files in YAML, JSON, TOML, INI, HCL and Java Properties formats
+* Add [custom marshallers](#222-register_marshaller) or override the built-in ones
+* [Set](#21-set) and [read](#24-fetch) settings for deeply nested keys
+* [Set](#21-set) defaults for undefined settings
+* [Read](#24-fetch) settings with indifferent access
+* [Merge](#25-merge) configuration settings from other hash objects
+* Read values from [environment variables](#23-set_from_env)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tty-config'
+gem "tty-config"
 ```
 
 And then execute:
@@ -67,17 +67,18 @@ Or install it yourself as:
   * [2.9 delete](#29-delete)
   * [2.10 alias_setting](#210-alias_setting)
   * [2.11 validate](#211-validate)
-  * [2.12 env_prefix=](#212-env_prefix)
-  * [2.13 filename=](#213-filename)
-  * [2.14 extname=](#214-extname)
-  * [2.15 append_path](#215-append_path)
-  * [2.16 prepend_path](#216-prepend_path)
-  * [2.17 read](#217-read)
-  * [2.18 write](#218-write)
-  * [2.19 exist?](#219-exist)
-  * [2.20 autoload_env](#220-autoload_env)
-  * [2.21 register_marshaller](#221-register_marshaller)
-  * [2.22 unregister_marshaller](#222-register_marshaller)
+  * [2.12 filename=](#212-filename)
+  * [2.13 extname=](#213-extname)
+  * [2.14 append_path](#214-append_path)
+  * [2.15 prepend_path](#215-prepend_path)
+  * [2.16 read](#216-read)
+  * [2.17 write](#217-write)
+  * [2.18 exist?](#218-exist)
+  * [2.19 env_prefix=](#219-env_prefix)
+  * [2.20 env_separator=](#220-env_separator)
+  * [2.21 autoload_env](#221-autoload_env)
+  * [2.22 register_marshaller](#222-register_marshaller)
+  * [2.23 unregister_marshaller](#223-unregister_marshaller)
 * [3. Examples](#3-examples)
   * [3.1 Working with env vars](#31-working-with-env-vars)
   * [3.2 Working with optparse](#32-working-with-optparse)
@@ -88,27 +89,27 @@ Initialize the configuration and provide the name:
 
 ```ruby
 config = TTY::Config.new
-config.filename = 'investments'
+config.filename = "investments"
 ```
 
 Then configure values for different nested keys with `set` and `append`:
 
 ```ruby
-config.set(:settings, :base, value: 'USD')
+config.set(:settings, :base, value: "USD")
 config.set(:settings, :color, value: true)
-config.set(:coins, value: ['BTC'])
+config.set(:coins, value: ["BTC"])
 
-config.append('ETH', 'TRX', 'DASH', to: :coins)
+config.append("ETH", "TRX", "DASH", to: :coins)
 ```
 
 You can get any value by using `fetch`:
 
 ```ruby
 config.fetch(:settings, :base)
-# => 'USD'
+# => "USD"
 
 config.fetch(:coins)
-# => ['BTC', 'ETH', 'TRX', 'DASH']
+# => ["BTC", "ETH", "TRX", "DASH"]
 ```
 
 And call `write` to persist the configuration to `investments.yml` file:
@@ -150,8 +151,8 @@ class App
 
   def initialize
     @config = TTY::Config.new
-    @config.filename = 'investments'
-    @config.extname = '.toml'
+    @config.filename = "investments"
+    @config.extname = ".toml"
     @config.append_path Dir.pwd
     @config.append_path Dir.home
   end
@@ -169,22 +170,22 @@ end
 To set configuration setting use `set` method. It accepts any number of keys and value by either using `:value` keyword argument or passing a block:
 
 ```ruby
-config.set(:base, value: 'USD')
-config.set(:base) { 'USD' }
+config.set(:base, value: "USD")
+config.set(:base) { "USD" }
 ```
 
-The block version of specifying a value will mean that the value is evaluated every time its being read.
+The block version of specifying a value will mean that the value is evaluated every time it's being read.
 
 You can also specify deeply nested configuration settings by passing sequence of keys:
 
 ```ruby
-config.set :settings, :base, value: 'USD'
+config.set(:settings, :base, value: "USD")
 ```
 
 Which is equivalent to:
 
 ```ruby
-config.set 'settings.base', value: 'USD'
+config.set("settings.base", value: "USD")
 ```
 
 Internally all configuration settings are stored as string keys for ease of working with configuration files and command line application's inputs.
@@ -194,13 +195,13 @@ Internally all configuration settings are stored as string keys for ease of work
 To set a configuration setting only if it hasn't been set before use `set_if_empty`:
 
 ```ruby
-config.set_if_empty :base, value: 'USD'
+config.set_if_empty(:base, value: "USD")
 ```
 
 Similar to `set` it allows you to specify arbitrary sequence of keys followed by a key value or block:
 
 ```ruby
-config.set_if_empty :settings, :base, value: 'USD'
+config.set_if_empty(:settings, :base, value: "USD")
 ```
 
 ### 2.3 set_from_env
@@ -210,8 +211,8 @@ To read configuration options from environment variables use `set_from_env`. At
 Given the following environment variables:
 
 ```ruby
-ENV['HOST'] = '192.168.1.17'
-ENV['PORT'] = '7727'
+ENV["HOST"] = "192.168.1.17"
+ENV["PORT"] = "7727"
 ```
 
 You can make the config aware of the above env variables:
@@ -225,35 +226,35 @@ Then you can retrieve values like any other configuration option:
 
 ```ruby
 config.fetch(:host)
-# => '192.168.1.17'
+# => "192.168.1.17"
 config.fetch(:port)
-# => '7727'
+# => "7727"
 ```
 
 If you want the configuration key name to be different from `ENV` variable name use a block:
 
 ```ruby
-config.set_from_env(:host) { 'HOSTNAME' }
+config.set_from_env(:host) { "HOSTNAME" }
 config.set_from_env(:host) { :hostname }
 ```
 
 You can also configure settings for deeply nested keys:
 
 ```ruby
-config.set_from_env(:settings, :base) { 'CURRENCY' }
+config.set_from_env(:settings, :base) { "CURRENCY" }
 config.set_from_env(:settings, :base) { :currency }
-config.set_from_env('settings.base') { 'CURRENCY'}
-config.set_from_env('settings.base') { :currency}
+config.set_from_env("settings.base") { "CURRENCY" }
+config.set_from_env("settings.base") { :currency }
 ```
 
-And assuming `ENV['CURRENCY']=USD`:
+And assuming `ENV["CURRENCY"]=USD`:
 
 ```ruby
 config.fetch(:settings, :base)
 # => USD
 ```
 
-You can also prefix your environment variables. See [env_prefix=](#212-env_prefix)
+You can also prefix your environment variables with [env_prefix=](#219-env_prefix) or use a different separator with [env_separator](#220-env_separator).
 
 It's important to recognise that `set_from_env` doesn't record the value for the environment variables. They are read each time from the `ENV` when `fetch` is called.
 
@@ -262,8 +263,8 @@ It's important to recognise that `set_from_env` doesn't record the value for the
 To get a configuration setting use `fetch`, which can accept default value either with a `:default` keyword or a block that will be lazy evaluated:
 
 ```ruby
-config.fetch(:base, default: 'USD')
-config.fetch(:base) { 'USD' }
+config.fetch(:base, default: "USD")
+config.fetch(:base) { "USD" }
 ```
 
 Similar to `set` operation, `fetch` allows you to retrieve deeply nested values:
@@ -275,16 +276,16 @@ config.fetch(:settings, :base) # => USD
 Which is equivalent to:
 
 ```ruby
-config.fetch('settings.base')
+config.fetch("settings.base")
 ```
 
 `fetch` has indifferent access so you can mix string and symbol keys, all the following examples retrieve the value:
 
 ```ruby
 config.fetch(:settings, :base)
-config.fetch('settings', 'base')
-config.fetch(:settings', 'base')
-config.fetch('settings', :base)
+config.fetch("settings", "base")
+config.fetch(:settings, "base")
+config.fetch("settings", :base)
 ```
 
 ### 2.5 merge
@@ -295,7 +296,7 @@ To merge in other configuration settings as hash use `merge`:
 config.set(:a, :b, value: 1)
 config.set(:a, :c, value: 2)
 
-config.merge({'a' => {'c' => 3, 'd' => 4}})
+config.merge({"a" => {"c" => 3, "d" => 4}})
 
 config.fetch(:a, :c) # => 3
 config.fetch(:a, :d) # => 4
@@ -379,6 +380,14 @@ config.delete(:settings, :base)
 # "USD"
 ```
 
+You can provide an optional default value in a block that will be returned when a key is not set:
+
+```ruby
+config.delete(:settings, :unknown) { |key| "#{key} isn't set" }
+# =>
+# "unknown isn't set"
+```
+
 ### 2.10 alias_setting
 
 In order to alias a configuration setting to another name use `alias_setting`.
@@ -386,7 +395,7 @@ In order to alias a configuration setting to another name use `alias_setting`.
 For example, given an already existing setting:
 
 ```ruby
-config.set(:base, value: 'baz')
+config.set(:base, value: "baz")
 ```
 
 You can alias it to another name:
@@ -399,29 +408,29 @@ And then access like any other configuration setting:
 
 ```ruby
 config.fetch(:currency)
-# => 'USD'
+# => "USD"
 ```
 
 Deep nested configuration options are also supported:
 
 ```ruby
-config.set(:settings, :base, value: 'USD')
+config.set(:settings, :base, value: "USD")
 ```
 
 And then can be aliased like so:
 
 ```ruby
 config.alias_setting(:settings, :base, to: [:settings, :currency])
-config.alias_setting('settings.base', to [:settings, :currency])
+config.alias_setting("settings.base", to [:settings, :currency])
 ```
 
 You can then access the deep nested settings:
 
 ```ruby
 config.fetch(:settings, :currency)
-# => 'USD'
-config.fetch('settings.currency')
-# => 'USD'
+# => "USD"
+config.fetch("settings.currency")
+# => "USD"
 ```
 
 ### 2.11 validate
@@ -441,68 +450,37 @@ You can assign multiple validations for a given key and each of them will be run
 When setting value all the validations will be run:
 
 ```ruby
-config.set(:settings, :base, value: 'PL')
-# raises TTY::Config::ValidationError, 'Currency code needs to be 3 chars long.'
+config.set(:settings, :base, value: "PL")
+# raises TTY::Config::ValidationError, "Currency code needs to be 3 chars long."
 ```
 
-If the value s provided as a proc or a block then the validation will be delayed until the value is actually read:
+If the value is provided as a proc or a block then the validation will be delayed until the value is actually read:
 
 ```ruby
-config.set(:settings, :base) { 'PL' }
+config.set(:settings, :base) { "PL" }
 config.fetch(:settings, :base)
-# raises TTY::Config::ValidationError, 'Currency code needs to be 3 chars long.'
+# raises TTY::Config::ValidationError, "Currency code needs to be 3 chars long."
 ```
 
-### 2.12 env_prefix=
-
-Given the following variables:
-
-```ruby
-ENV['MYTOOL_HOST'] = '192.168.1.17'
-ENV['MYTOOL_PORT'] = ' 7727'
-```
-
-You can inform configuration about common prefix using `env_prefix`:
-
-```ruby
-config.env_prefix = 'mytool'
-```
-
-Then set configuration key name to environment variable name:
-
-```ruby
-config.set_from_env(:host)
-config.set_from_env(:port)
-```
-
-And finally retrieve the value:
-
-```ruby
-config.fetch(:host) 
-#=> '192.168.1.17'
-config.fetch(:port)
-# => '7727'
-```
-
-### 2.13 filename=
+### 2.12 filename=
 
 By default, **TTY::Config** searches for `config` named configuration file. To change this use `filename=` method without the extension name:
 
 ```ruby
-config.filename = 'investments'
+config.filename = "investments"
 ```
 
-Then any supported extensions will be search for such as `.yml`, `.json` and `.toml`.
+Then any supported extensions will be searched for such as `.yml`, `.json` and `.toml`.
 
-### 2.14 extname=
+### 2.13 extname=
 
-By default '.yml' extension is used to write configuration out to a file but you can change that with `extname=`:
+By default ".yml" extension is used to write configuration out to a file but you can change that with `extname=`:
 
 ```ruby
-config.extname = '.toml'
+config.extname = ".toml"
 ```
 
-### 2.15 append_path
+### 2.14 append_path
 
 You need to tell the **TTY::Config** where to search for configuration files. To search multiple paths for a configuration file use `append_path` or `prepend_path` methods.
 
@@ -514,9 +492,9 @@ config.append_path(Dir.home)  # look in user's home directory
 config.append_path(Dir.pwd)   # look in current working directory
 ```
 
-None of these paths are required, but you should provide at least one path if you wish to read configuration file.
+None of these paths are required, but you should provide at least one path if you wish to read a configuration file.
 
-### 2.16 prepend_path
+### 2.15 prepend_path
 
 The `prepend_path` allows you to add configuration search paths that should be searched first.
 
@@ -525,7 +503,7 @@ config.append_path(Dir.pwd)   # look in current working directory second
 config.prepend_path(Dir.home) # look in user's home directory first
 ```
 
-### 2.17 read
+### 2.16 read
 
 There are two ways for reading configuration files and both use the `read` method. One attempts to guess extension and format of your data, the other allows you to request specific extension and format.
 
@@ -544,7 +522,7 @@ For example, to find file called investments in the current directory do:
 
 ```ruby
 config.append_path(Dir.pwd)       # look in current working directory
-config.filename = 'investments'   # file to search for
+config.filename = "investments"   # file to search for
 ```
 
 Find and read the configuration file:
@@ -556,7 +534,7 @@ config.read
 You can also specify directly the file to read without setting up any search paths or filenames. If you specify a configuration with a known file extension, an appropriate format will be guessed, in this instance `TOML`:
 
 ```ruby
-config.read('./investments.toml')
+config.read("./investments.toml")
 ```
 
 In cases where you wish to specify a custom file extension, you will need to also specify the file format to use.
@@ -564,40 +542,70 @@ In cases where you wish to specify a custom file extension, you will need to als
 For example, if you have a configuration file formatted using `YAML` notation with extension called `.config`, to read it do:
 
 ```ruby
-config.read('investments.config', format: :yaml)
+config.read("investments.config", format: :yaml)
 ```
 
-### 2.18 write
+### 2.17 write
 
-By default **TTY::Config**, persists configuration file in the current working directory with a `config.yml` name. However, you can change that by specifying the filename and extension type:
+By default **TTY::Config**, persists configuration file in the current working directory with a `config.yml` name. However, you can change the default file name by specifying the `filename` and `extension` type:
 
 ```ruby
-config.filename = 'investments'
-config.extname = '.toml'
+config.filename = "investments"
+config.extname = ".toml"
 ```
 
-To write current configuration to a file, you can either specified direct location path and filename:
+Now, by invoking `write` you will persist the current configuration to `investments.toml` file.
 
 ```ruby
-config.write('./investments.toml')
+config.write   # writes "investments.toml" in the current directory
 ```
 
-Or, specify location paths to be searched for already existing configuration to overwrite:
+To write the current configuration to a file in a custom location, you can specify a direct location path and filename as an argument:
 
 ```ruby
-config.append_path(Dir.pwd)  # search current working directory
+config.write("/custom/path/to/investments.toml")
+# may raise an error if any of the path directories are missing
+```
 
-config.write
+Alternatively, if the filename doesn't need to change you can specify only a custom path using the `:path` keyword:
+
+```ruby
+config.write(path: "/custom/path/to")
+# may raise an error if any of the path directories are missing
+```
+
+If the `/custom/path/to` doesn't exist an error will be raised. You can set the `:create` option to make any missing directories in the path:
+
+```ruby
+config.write("/custom/path/to/investments.toml", create: true)
+config.write(path: "/custom/path/to", create: true)
+```
+
+When the `investments.toml` file already exists the `TTY::Config::WriteError` error will be raised.
+
+To create a configuration file regardless of whether it exists or not, use `:force` flag:
+
+```ruby
+config.write(force: true)
+config.write("/custom/path/to/investments.toml", force: true)
+config.write(path: "/custom/path/to", force: true)
 ```
 
-To create configuration file regardless whether it exists or not, use `:force` flag:
+By default, only the current directory is searched. You can specify additional location paths to be searched for already existing configuration to overwrite:
 
 ```ruby
-config.write(force: true)                        # overwrite any found config file
-config.write('./investments.toml', force: true)  # overwrite specific config file
+config.append_path("/custom/path/to")  # search in "/custom/path/to" for config file
 ```
 
-### 2.19 exist?
+By setting the `:create` option to `true`, you can ensure that even when no path is found that has a configuration file, the first location will be used and all missing directories created.
+
+To ensure that a configuration file is written no matter what, use both `:create` and `:force`:
+
+```ruby
+config.write(create: true, force: true)
+```
+
+### 2.18 exist?
 
 To check if a configuration file exists within the configured search paths use `exist?` method:
 
@@ -605,20 +613,79 @@ To check if a configuration file exists within the configured search paths use `
 config.exist? # => true
 ```
 
-### 2.20 autoload_env
+### 2.19 env_prefix=
+
+Given the following variables:
+
+```ruby
+ENV["MYTOOL_HOST"] = "127.0.0.1"
+ENV["MYTOOL_PORT"] = "7727"
+```
+
+You can inform configuration about common prefix using `env_prefix`:
+
+```ruby
+config.env_prefix = "mytool"
+```
+
+Then set configuration key name to environment variable name:
+
+```ruby
+config.set_from_env(:host)
+config.set_from_env(:port)
+```
+
+And retrieve the value:
+
+```ruby
+config.fetch(:host)
+# => "127.0.0.1"
+config.fetch(:port)
+# => "7727"
+```
+
+### 2.20 env_separator=
+
+By default, the `_` character is used to separate parts in the environment variable name and it can be changed using the `env_separator=` like so:
+
+```ruby
+config.env_separator = "___"
+```
+
+Given the following environment variable:
+
+```ruby
+ENV["SERVER__PORT"] = "123"
+```
+
+Then we can make configuration aware of the above variable name in one of these ways:
+
+```ruby
+config.set_from_env(:server, :port)
+config.set_from_env("server.port")
+````
+
+And retrieve the value:
+
+```ruby
+config.fetch(:server, :port)
+# => "123"
+```
+
+### 2.21 autoload_env
 
-The `autload_env` allows you to automatically read environment variables. In most cases you would combine it with [env_prefix=](#212-env_prefix) to only read a subset of variables. When using `autload_env`, anytime the `fetch` is called a corresponding environment variable will be checked.
+The `autoload_env` method allows you to automatically read environment variables. In most cases you would combine it with [env_prefix=](#219-env_prefix) to only read a subset of variables. When using `autoload_env`, anytime the `fetch` is called a corresponding environment variable will be checked.
 
 For example, given an environment variable `MYTOOL_HOST` set to `localhost`:
 
 ```ruby
-ENV['MYTOOL_HOST']=localhost
+ENV["MYTOOL_HOST"]=localhost
 ```
 
 And loading environment variables with a prefix of `MYTOOL`:
 
 ```ruby
-config.env_prefix = 'mytool'
+config.env_prefix = "mytool"
 config.autoload_env
 ```
 
@@ -626,10 +693,10 @@ You can retrieve value with:
 
 ```ruby
 config.fetch(:host)
-# => 'localhost'
+# => "localhost"
 ```
 
-### 2.21 register_marshaller
+### 2.22 register_marshaller
 
 There are number of built-in marshallers that handle the process of serializing internal configuration from and back into a desired format, for example, a `JSON` string.
 
@@ -696,9 +763,9 @@ Bear in mind that you can also override the built-in implementation of a marshal
 config.register_marshaller(:toml, MyTOMLMarshaller)
 ```
 
-### 2.22 unregister_marshaller
+### 2.23 unregister_marshaller
 
-By default, the **TTY::Config** is ready to recognize various extensions. See (2.17 read)[#217-read] section for more details. But, you're free to remove the default marshallers from the internal registry with `unregister_marshaller` method.
+By default, the **TTY::Config** is ready to recognize various extensions. See [2.16 read](#216-read) section for more details. But, you're free to remove the default marshallers from the internal registry with `unregister_marshaller` method.
 
 For example, to remove all the built-in marshallers do:
 
@@ -713,22 +780,22 @@ config.unregister_marshaller :yaml, :json, :toml, :ini, :hcl
 *TTY::Config* fully supports working with environment variables. For example, there are couple of environment variables that your configuration is interested in, which normally would be set in terminal but for the sake of this example we assign them:
 
 ```ruby
-ENV['MYTOOL_HOST'] = '192.168.1.17'
-ENV['MYTOOL_PORT'] = '7727'
+ENV["MYTOOL_HOST"] = "192.168.1.17"
+ENV["MYTOOL_PORT"] = "7727"
 ```
 
-Then in order to make your configuration aware of the above, you would use [env_prefix=](#212-env_prefix) and [set_from_env](#23-set_from_env):
+Then in order to make your configuration aware of the above, you would use [env_prefix=](#219-env_prefix) and [set_from_env](#23-set_from_env):
 
 ```ruby
-config.env_prefix = 'mytool'
+config.env_prefix = "mytool"
 config.set_from_env(:host)
 config.set_from_env(:port)
 ```
 
-Or automatically load all prefixed environment variables with [autoload_env](#220-autoload-env):
+Or automatically load all prefixed environment variables with [autoload_env](#221-autoload_env):
 
 ```ruby
-config.env_prefix = 'mytool'
+config.env_prefix = "mytool"
 config.autoload_env
 ```
 
@@ -736,9 +803,9 @@ And then retrieve values with [fetch](#24-fetch):
 
 ```ruby
 config.fetch(:host)
-#=> '192.168.1.17'
+#=> "192.168.1.17"
 config.fetch(:port)
-# => '7727'
+# => "7727"
 ```
 
 ### 3.2 Working with optparse
@@ -750,7 +817,7 @@ Let's assume you want to create a command line tool that among many options acce
 First, you need to parse the flags and store results away in options hash:
 
 ```ruby
-require 'optparse'
+require "optparse"
 
 options = {}
 
@@ -771,7 +838,7 @@ end
 option_parser.parse!
 ```
 
-Then, you craete a configuration instance:
+Then, you create a configuration instance:
 
 ```ruby
 config = TTY::Config.new
@@ -780,7 +847,7 @@ config = TTY::Config.new
 And setup config filename:
 
 ```ruby
-config_filename = options[:config_file_path] || 'config.yml'
+config_filename = options[:config_file_path] || "config.yml"
 ```
 
 As well as add configuration file locations to search in:
@@ -794,7 +861,7 @@ Once config is initialized, you can read the configuration from a config file:
 
 ```ruby
 begin
-  config.read(config_filename)  # by default the 'config.yml' is read
+  config.read(config_filename)  # by default the "config.yml" is read
 rescue TTY::Config::ReadError => read_error
   STDERR.puts "\nNo configuration file found:"
   STDERR.puts read_error
@@ -824,7 +891,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tty-config. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/tty-config. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -832,7 +899,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Tty::Config project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-config/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the TTY::Config project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-config/blob/master/CODE_OF_CONDUCT.md).
 
 ## Copyright