anyway_config 1.4.4 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af77cb70b9fea95ccb938643fcf462f04ef0087a1b3811de9e9f66e696f29ad5
-  data.tar.gz: 771eeb316a5a11d9bd8072dd7f506ddd5a02d36995ccf2facec3f40dcbc412ea
+  metadata.gz: 2d8ed2249df0baa740893d459922e839793eab4cef51b9410e2c618393ba88a7
+  data.tar.gz: 587d0578b716af5035e393ab29eabff5aea163d44f705ed9b245eb51d083b4f4
 SHA512:
-  metadata.gz: 87d5c17d6ec017474112df69685edcdfe9c7547ae7ad82b4338a4dd3493afeef50d6102fe87e7b0a5070aa6ad48f4872371515f32443a443bc324a67dcdfd918
-  data.tar.gz: 7c4cb678483573bb6a4db45ea5c78bbf1d077fcc7e5486fe4e420cae2c4de09224611d1925cdddebdc80ea767e140870b81bbcf39ce2be9515761846db70cc13
+  metadata.gz: 5fb7bcf6b692b6fc75f4eb0ca3170787defac2063d646ca8c9ec77d3563e526c58dc16af77e42bf6d293da21d8303d6d82afca723e2b97e528b243702f1c38b5
+  data.tar.gz: b89c278a7436c024f61894f59c885704c2cf4ae539bb382825181fe13d5f787662c6aafdc39b7d49ba9f4ee1c9535128e3fadb7904016c790907010e165996b9

data/README.md

@@ -3,7 +3,10 @@
 
 # Anyway Config
 
-Rails/Ruby plugin/application configuration tool which allows you to load parameters from different sources: YAML, Rails secrets, environment.
+**NOTE:** this readme shows doc for the upcoming 2.0 version (`2.0.0.pre` is available on RubyGems).
+For version 1.x see [1-4-stable branch](https://github.com/palkan/anyway_config/tree/1-4-stable).
+
+Rails/Ruby plugin/application configuration tool which allows you to load parameters from different sources: YAML, Rails secrets/credentials, environment.
 
 Allows you to easily follow the [twelve-factor application](https://12factor.net/config) principles and adds zero complexity to your development process.
 
@@ -15,6 +18,8 @@ Libraries using Anyway Config:
 
 - [Sniffer](https://github.com/aderyabin/sniffer)
 
+- [Blood Contracts](https://github.com/sclinede/blood_contracts)
+
 - [and others](https://github.com/palkan/anyway_config/network/dependents).
 
 ## Installation
@@ -24,9 +29,9 @@ Libraries using Anyway Config:
 ```ruby
 # my-cool-gem.gemspec
 Gem::Specification.new do |spec|
-  ...
-  spec.add_dependency "anyway_config", "~> 1.0"
-  ...
+  # ...
+  spec.add_dependency "anyway_config", "2.0.0.pre"
+  # ...
 end
 ```
 
@@ -34,7 +39,7 @@ end
 
 ```ruby
 # Gemfile
-gem "anyway_config", "~> 1.0"
+gem "anyway_config", "2.0.0.pre"
 ```
 
 3) Install globally:
@@ -50,11 +55,11 @@ $ gem install anyway_config
 Create configuration class:
 
 ```ruby
-require 'anyway'
+require "anyway"
 
 module MyCoolGem
   class Config < Anyway::Config
-    attr_config user: 'root', password: 'root', host: 'localhost'
+    attr_config user: "root", password: "root", host: "localhost"
   end
 end
 ```
@@ -62,7 +67,7 @@ end
 `attr_config` creates accessors and default values. If you don't need default values just write:
 
 ```ruby
-attr_config :user, :password, host: 'localhost'
+attr_config :user, :password, host: "localhost", options: {}
 ```
 
 Then create an instance of the config class and use it:
@@ -74,33 +79,43 @@ module MyCoolGem
   end
 end
 
-MyCoolGem.config.user #=> 'root'
+MyCoolGem.config.user #=> "root"
 ```
 
-#### Customize name
+#### Config name
+
+Anyway Config relies on the notion of _config name_ to populate data.
+
+By default, Anyway Config uses the config class name to infer the config name using the following rules:
+- if the class name has a form of `<Module>::Config` then use the module name (`SomeModule::Config => "somemodule"`)
+- if the class name has a form of `<Something>Config` then use the class name prefix (`SomeConfig => "some"`)
 
-By default, Anyway Config uses the namespace (the outer module name) as the config name, but you can set it manually:
+**NOTE:** in both cases the config name is a **downcased** module/class prefix, not underscored.
+
+You can also specify the config name explicitly (it's required in cases when you class name doesn't match any of the patterns above):
 
 ```ruby
 module MyCoolGem
   class Config < Anyway::Config
     config_name :cool
-    attr_config user: 'root', password: 'root', host: 'localhost', options: {}
+    attr_config user: "root", password: "root", host: "localhost", options: {}
   end
 end
 ```
 
 #### Customize env variable names prefix
 
-By default, Anyway Config uses underscored config name as a prefix for env variable names (e.g.
-`config_name :my_app` will result to parsing `MY_APP_HOST` variable). You can set env prefix
-explicitly, and it will be used as is:
+By default, Anyway Config uses upcased config name as a prefix for env variable names (e.g.
+`config_name :my_app` will result to parsing `MY_APP_` prefix).
+
+You can set env prefix explicitly:
 
 ```ruby
 module MyCoolGem
   class Config < Anyway::Config
+    config_name :cool_gem
     env_prefix :really_cool # now variables, starting wih `REALLY_COOL_`, will be parsed
-    attr_config user: 'root', password: 'root', host: 'localhost', options: {}
+    attr_config user: "root", password: "root", host: "localhost", options: {}
   end
 end
 ```
@@ -108,18 +123,16 @@ end
 #### Provide explicit values
 
 Sometimes it's useful to set some parameters explicitly during config initialization.
-You can do that using `overrides` option:
+You can do that by passing a Hash into `.new` method:
 
 ```ruby
 config = MyCoolGem::Config.new(
-  overrides: {
-    user: 'john',
-    password: 'rubyisnotdead'
-  }
+  user: "john",
+  password: "rubyisnotdead"
 )
 
 # The value would not be overriden from other sources (such as YML file, env)
-config.user == 'john'
+config.user == "john"
 ```
 
 ### Dynamic configuration
@@ -127,32 +140,121 @@ config.user == 'john'
 You can also create configuration objects without pre-defined schema (just like `Rails.application.config_for` but more [powerful](#railsapplicationconfig_for-vs-anywayconfigfor)):
 
 ```ruby
-# load data from config/my_app.yml, secrets.my_app (if using Rails), ENV["MYAPP_*"]
+# load data from config/my_app.yml, secrets.my_app (if using Rails), ENV["MY_APP_*"]
+# MY_APP_VALUE=42
 config = Anyway::Config.for(:my_app)
+config.value #=> 42
+
+# you can specify the config file path or env prefix
+config = Anyway::Config.for(:my_app, config_path: "my_config.yml", env_prefix: "MYAPP")
 ```
 
 ### Using with Rails
 
+**NOTE:** version 2.x supports Rails >= 5.0; for Rails 4.x use version 1.x of the gem.
+
 Your config will be filled up with values from the following sources (ordered by priority from low to high):
 
-- `RAILS_ROOT/config/my_cool_gem.yml` (for the current `RAILS_ENV`, supports `ERB`). You can override this setting
-through special environment variable – 'MYCOOLGEM_CONF' – containing the path to the YAML file.
+- `RAILS_ROOT/config/my_cool_gem.yml` (for the current `RAILS_ENV`, supports `ERB`):
 
-- `Rails.application.secrets.my_cool_gem`
+```yml
+test:
+  host: localhost
+  port: 3002
+
+development:
+  host: localhost
+  port: 3000
+```
+
+**NOTE:** you can override the default YML lookup path by setting `MYCOOLGEM_CONF` env variable.
+
+- `Rails.application.secrets.my_cool_gem` (if `secrets.yml` present):
+
+```yml
+# config/secrets.yml
+development:
+  my_cool_gem:
+    port: 4444
+```
+
+- `Rails.application.credentials` (if supported):
+
+```yml
+my_cool_gem:
+  host: secret.host
+```
 
 - `ENV['MYCOOLGEM_*']`.
 
+#### `app/configs`
+
+You can store application-level config classes in `app/configs` folder.
+
+Anyway Config automatically adds this folder to Rails autoloading system to make it possible to
+autoload configs even during the configuration phase.
+
+Consider an example: setting the Action Mailer host name for Heroku review apps.
+
+We have the following config to fetch the Heroku provided [metadata](https://devcenter.heroku.com/articles/dyno-metadata):
+
+```ruby
+# This data is provided by Heroku Dyno Metadadata add-on.
+class HerokuConfig < Anyway::Config
+  attr_config :app_id, :app_name,
+              :dyno_id, :release_version,
+              :slug_commit
+
+  def hostname
+    "#{app_name}.herokuapp.com"
+  end
+end
+```
+
+Then in `config/application.rb` you can do the following:
+
+```ruby
+config.action_mailer.default_url_options = {host: HerokuConfig.new.hostname}
+```
+
 ### Using with Ruby
 
-By default, Anyway Config is looking for a config YAML at `./config/<config-name>.yml` e.g. `./config/my_cool_gem.yml`.
-You can override this location the same way as for Rails.
+When you're using Anyway Config in non-Rails environment, we're looking for a YANL config file
+at `./config/<config-name>.yml`.
 
-Environmental variables work the same way too.
+You can override this setting through special environment variable – 'MYCOOLGEM_CONF' – containing the path to the YAML file.
 
+**NOTE:** in pure Ruby apps we have no knowledge of _environments_ (`test`, `development`, `production`, etc.); thus we assume that the YAML contains values for a single environment:
 
-### Config clear and reload
+```yml
+host: localhost
+port: 3000
+```
+
+Environmental variables work the same way as with Rails.
+
+### Local files
+
+It's useful to have personal, user-specific configuration in development, which extends the project-wide one.
+
+We support this by looking at _local_ files when loading the configuration data:
+- `<config_name>.local.yml` files (next to\* the _global_ `<config_name>.yml`)
+- `config/credentials/local.yml.enc` (for Rails >= 6, generate it via `rails credentials:edit --environment local`).
+
+\* If the YAML config path is not default (i.e. set via `<CONFIG_NAME>_CONF`), we lookup the local
+config at this location, too.
+
+Local configs are meant for using in development and only loaded if `Anyway::Settings.use_local_files` is `true` (which is true by default if `RACK_ENV` or `RAILS_ENV` env variable is equal to `"development"`).
+
+**NOTE:** in Rails apps you can use `Rails.applicaiton.configuration.anyway_config.use_local_files`.
 
-There are `#clear` and `#reload` functions on your config (which do exactly what they state).
+Don't forget to add `*.local.yml` (and `config/credentials/local.*`) to your `.gitignore`.
+
+**NOTE:** local YAML configs for Rails app must be environment-free (i.e. you shouldn't have top-level `development:` key).
+
+### Reload configuration
+
+There are `#clear` and `#reload` methods which do exactly what they state.
 
 Note: `#reload` also accepts `overrides` key to provide explicit values (see above).
 
@@ -194,7 +296,7 @@ end
 
 config = MyConfig.new
 
-config.parse_options!(%w(--host localhost --port 3333 --log-level debug))
+config.parse_options!(%w[--host localhost --port 3333 --log-level debug])
 
 config.host # => "localhost"
 config.port # => 3333
@@ -211,10 +313,12 @@ Rails 4.2 introduced new feature: `Rails.application.config_for`. It looks very
 
 | Feature       | Rails         | Anyway Config |
 | ------------- |:-------------:| -----:|
-| load data from `config/app.yml`     | yes | yes |
-| load data from `secrets`      | no      |   yes |
-| load data from environment | no   |   yes |
-| return Hash with indifferent access | no | yes |
+| load data from `config/app.yml`      | yes | yes |
+| load data from `secrets`      | no       |   yes |
+| load data from `credentials`  | no       |   yes |
+| load data from environment    | no       |   yes |
+| local config files            | no       |   yes |
+| return Hash with indifferent access | no | yes  |
 | support ERB within `config/app.yml` | yes | yes* |
 | raise errors if file doesn't exist | yes | no |
 
@@ -224,23 +328,18 @@ But the main advantage of Anyway::Config is that it can be used [without Rails](
 
 ## How to set env vars
 
-Environmental variables for your config should start with your config name, uppercased and underscore-free.
-
-For example, if your module is called "MyCoolGem" then the env var "MYCOOLGEM_PASSWORD" is used as `config.password`.
+Environmental variables for your config should start with your config name, uppercased.
 
-Environment variables are type-casted (case-insensitive).
-
-Examples:
+For example, if your config name is "mycoolgem" then the env var "MYCOOLGEM_PASSWORD" is used as `config.password`.
 
+Environment variables are automatically serialized:
 - `"True"`, `"t"` and `"yes"` to `true`;
-
 - `"False"`, `"f"` and `"no"` to `false`;
-
 - `"nil"` and `"null"` to `nil` (do you really need it?);
-
 - `"123"` to 123 and `"3.14"` to 3.14.
 
 *Anyway Config* supports nested (_hashed_) env variables. Just separate keys with double-underscore.
+
 For example, "MYCOOLGEM_OPTIONS__VERBOSE" is parsed as `config.options["verbose"]`.
 
 Array values are also supported:
@@ -253,13 +352,50 @@ config.ids #=> [1,2,3]
 If you want to provide a text-like env variable which contains commas then wrap it into quotes:
 
 ```ruby
-MYCOOLGEM="Nif-Nif, Naf-Naf and Nouf-Nouf"
+MYCOOLGEM = "Nif-Nif, Naf-Naf and Nouf-Nouf"
 ```
 
+## Test helpers
+
+We provide the `with_env` test helper to test code in the context of the specified environment variables values:
+
+```ruby
+describe HerokuConfig, type: :config do
+  subject { described_class.new }
+
+  specify do
+    # Ensure that the env vars are set to the specified
+    # values within the block and reset to the previous values
+    # outside of it.
+    with_env(
+      "HEROKU_APP_NAME" => "kin-web-staging",
+      "HEROKU_APP_ID" => "abc123",
+      "HEROKU_DYNO_ID" => "ddyy",
+      "HEROKU_RELEASE_VERSION" => "v0",
+      "HEROKU_SLUG_COMMIT" => "3e4d5a"
+    ) do
+      is_expected.to have_attributes(
+        app_name: "kin-web-staging",
+        app_id: "abc123",
+        dyno_id: "ddyy",
+        release_version: "v0",
+        slug_commit: "3e4d5a"
+      )
+    end
+  end
+end
+```
+
+If you want to delete the env var, pass `nil` as the value.
+
+This helper is automatically included to RSpec if `RAILS_ENV` or `RACK_ENV` env variable is equal to "test". It's only available for the example with the tag `type: :config` or with the path `spec/configs/...`.
+
+You can add it manually by requiring `"anyway/testing/helpers"` and including the `Anyway::Test::Helpers` module (into RSpec configuration or Minitest test class).
+
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/anyway_config.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/anyway.rb

@@ -2,11 +2,31 @@
 
 module Anyway # :nodoc:
   require "anyway/version"
+
   require "anyway/config"
   require "anyway/rails/config" if defined?(::Rails::VERSION)
   require "anyway/env"
 
-  def self.env
-    @env ||= ::Anyway::Env.new
+  # Use Settings name to not confuse with Config.
+  #
+  # Settings contain the library-wide configuration.
+  class Settings
+    class << self
+      # Define whether to load data from
+      # *.yml.local (or credentials/local.yml.enc)
+      attr_accessor :use_local_files
+    end
+
+    # By default, use local files only in development (that's the purpose if the local files)
+    self.use_local_files = (ENV["RACK_ENV"] == "development" || ENV["RAILS_ENV"] == "development")
   end
+
+  class << self
+    def env
+      @env ||= ::Anyway::Env.new
+    end
+  end
+
+  require "anyway/railtie" if defined?(::Rails::VERSION)
+  require "anyway/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"
 end

data/lib/anyway/config.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require 'anyway/ext/jruby' if defined? JRUBY_VERSION
-require 'anyway/ext/deep_dup'
-require 'anyway/ext/deep_freeze'
-require 'anyway/ext/hash'
-require 'anyway/ext/string_serialize'
-require 'anyway/option_parser_builder'
+require "anyway/optparse_config"
+require "anyway/dynamic_config"
+
+require "anyway/ext/jruby" if defined? JRUBY_VERSION
+require "anyway/ext/deep_dup"
+require "anyway/ext/deep_freeze"
+require "anyway/ext/hash"
+require "anyway/ext/string_serialize"
 
 module Anyway # :nodoc:
   if defined? JRUBY_VERSION
@@ -21,108 +23,116 @@ module Anyway # :nodoc:
   # Provides `attr_config` method to describe
   # configuration parameters and set defaults
   class Config
-    class << self
-      attr_reader :defaults, :config_attributes, :option_parser_extension
+    include OptparseConfig
+    include DynamicConfig
 
+    class << self
       def attr_config(*args, **hargs)
-        @defaults ||= {}
-        @config_attributes ||= []
-
         new_defaults = hargs.deep_dup
         new_defaults.stringify_keys!
+
         defaults.merge! new_defaults
 
         new_keys = (args + new_defaults.keys) - config_attributes
-        @config_attributes += new_keys
+        config_attributes.push(*new_keys)
         attr_accessor(*new_keys)
       end
 
-      def config_name(val = nil)
-        return (@config_name = val.to_s) unless val.nil?
+      def defaults
+        return @defaults if instance_variable_defined?(:@defaults)
 
-        @config_name = underscore_name unless defined?(@config_name)
-        @config_name
+        @defaults =
+          if superclass < Anyway::Config
+            superclass.defaults.deep_dup
+          else
+            {}
+          end
       end
 
-      def ignore_options(*args)
-        args.each do |name|
-          option_parser_descriptors[name.to_s][:ignore] = true
-        end
-      end
+      def config_attributes
+        return @config_attributes if instance_variable_defined?(:@config_attributes)
 
-      def describe_options(**hargs)
-        hargs.each do |name, desc|
-          option_parser_descriptors[name.to_s][:desc] = desc
-        end
+        @config_attributes =
+          if superclass < Anyway::Config
+            superclass.config_attributes.dup
+          else
+            []
+          end
       end
 
-      def flag_options(*args)
-        args.each do |name|
-          option_parser_descriptors[name.to_s][:flag] = true
-        end
-      end
+      def config_name(val = nil)
+        return (@explicit_config_name = val.to_s) unless val.nil?
+
+        return @config_name if instance_variable_defined?(:@config_name)
 
-      def extend_options(&block)
-        @option_parser_extension = block
+        @config_name = explicit_config_name || build_config_name
       end
 
-      def option_parser_options
-        config_attributes.each_with_object({}) do |key, result|
-          descriptor = option_parser_descriptors[key.to_s]
-          next if descriptor[:ignore] == true
+      def explicit_config_name
+        return @explicit_config_name if instance_variable_defined?(:@explicit_config_name)
 
-          result[key] = descriptor
-        end
+        @explicit_config_name =
+          if superclass.respond_to?(:explicit_config_name)
+            superclass.explicit_config_name
+          end
+      end
+
+      def explicit_config_name?
+        !explicit_config_name.nil?
       end
 
       def env_prefix(val = nil)
-        return (@env_prefix = val.to_s) unless val.nil?
+        return (@env_prefix = val.to_s.upcase) unless val.nil?
 
-        @env_prefix
-      end
+        return @env_prefix if instance_variable_defined?(:@env_prefix)
 
-      # Load config as Hash by any name
-      #
-      # Example:
-      #
-      #   my_config = Anyway::Config.for(:my_app)
-      #   # will load data from config/my_app.yml, secrets.my_app, ENV["MY_APP_*"]
-      def for(name)
-        new(name: name, load: false).load_from_sources
+        @env_prefix =
+          if superclass < Anyway::Config && superclass.explicit_config_name?
+            superclass.env_prefix
+          else
+            config_name.upcase
+          end
       end
 
       private
 
-      def option_parser_descriptors
-        @option_parser_descriptors ||= Hash.new { |h, k| h[k] = {} }
-      end
+      def build_config_name
+        unless name
+          raise "Please, specify config name explicitly for anonymous class " \
+            "via `config_name :my_config`"
+        end
 
-      def underscore_name
-        return unless name
+        # handle two cases:
+        # - SomeModule::Config => "some_module"
+        # - SomeConfig => "some"
+        unless name =~ /^(\w+)(\:\:)?Config$/
+          raise "Couldn't infer config name, please, specify it explicitly" \
+            "via `config_name :my_config`"
+        end
 
-        word = name[/^(\w+)/]
-        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-        word.downcase!
-        word
+        Regexp.last_match[1].tap(&:downcase!)
       end
     end
 
     attr_reader :config_name, :env_prefix
 
-    # Instantiate config with specified name, loads the data and applies overrides
+    # Instantiate config instance.
     #
     # Example:
     #
-    #   my_config = Anyway::Config.new(name: :my_app, load: true, overrides: { some: :value })
+    #   my_config = Anyway::Config.new()
+    #
+    #   # provide some values explicitly
+    #   my_config = Anyway::Config.new({some: :value})
     #
-    def initialize(name: nil, load: true, overrides: {})
-      @config_name = name || self.class.config_name
+    def initialize(overrides = {})
+      @config_name = self.class.config_name
 
       raise ArgumentError, "Config name is missing" unless @config_name
 
-      @env_prefix = self.class.env_prefix || @config_name
+      @env_prefix = self.class.env_prefix
 
-      self.load(overrides) if load
+      load(overrides)
     end
 
     def reload(overrides = {})
@@ -139,43 +149,49 @@ module Anyway # :nodoc:
     end
 
     def load(overrides = {})
-      config = load_from_sources((self.class.defaults || {}).deep_dup)
+      base_config = (self.class.defaults || {}).deep_dup
+
+      base_config.deep_merge!(
+        load_from_sources(
+          name: config_name,
+          env_prefix: env_prefix,
+          config_path: resolve_config_path(config_name, env_prefix)
+        )
+      )
+
+      base_config.merge!(overrides) unless overrides.nil?
 
-      config.merge!(overrides) unless overrides.nil?
-      config.each do |key, val|
+      base_config.each do |key, val|
         set_value(key, val)
       end
     end
 
-    def load_from_sources(config = {})
-      # Handle anonymous configs
-      return config unless config_name
-
-      load_from_file(config)
-      load_from_env(config)
+    def load_from_sources(**options)
+      base_config = {}
+      each_source(options) do |config|
+        base_config.deep_merge!(config) if config
+      end
+      base_config
     end
 
-    def load_from_file(config)
-      config.deep_merge!(parse_yml(config_path) || {}) if config_path && File.file?(config_path)
-      config
+    def each_source(options)
+      yield load_from_file(options)
+      yield load_from_env(options)
     end
 
-    def load_from_env(config)
-      config.deep_merge!(env_part)
-      config
-    end
+    def load_from_file(name:, env_prefix:, config_path:, **_options)
+      file_config = load_from_yml(config_path)
 
-    def option_parser
-      @option_parser ||= begin
-        parser = OptionParserBuilder.call(self.class.option_parser_options) do |key, arg|
-          set_value(key, arg.is_a?(String) ? arg.serialize : arg)
-        end
-        self.class.option_parser_extension&.call(parser, self) || parser
+      if Anyway::Settings.use_local_files
+        local_config_path = config_path.sub(/\.yml/, ".local.yml")
+        file_config.deep_merge!(load_from_yml(local_config_path))
       end
+
+      file_config
     end
 
-    def parse_options!(options)
-      option_parser.parse!(options)
+    def load_from_env(name:, env_prefix:, **_options)
+      Anyway.env.fetch(env_prefix)
     end
 
     def to_h
@@ -184,26 +200,28 @@ module Anyway # :nodoc:
       end.deep_dup.deep_freeze
     end
 
+    def resolve_config_path(name, env_prefix)
+      Anyway.env.fetch(env_prefix).delete("conf") || default_config_path(name)
+    end
+
     private
 
-    def env_part
-      Anyway.env.fetch(env_prefix)
+    def set_value(key, val)
+      send("#{key}=", val) if respond_to?(key)
     end
 
-    def config_path
-      env_part.delete('conf') || default_config_path
-    end
+    def load_from_yml(path)
+      return {} unless File.file?(path)
 
-    def default_config_path
-      "./config/#{config_name}.yml"
+      parse_yml(path)
     end
 
-    def set_value(key, val)
-      send("#{key}=", val) if respond_to?(key)
+    def default_config_path(name)
+      "./config/#{name}.yml"
     end
 
     def parse_yml(path)
-      require 'yaml'
+      require "yaml"
       if defined?(ERB)
         YAML.safe_load(ERB.new(File.read(path)).result, [], [], true)
       else