easy_conf 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78e252ae88731a6e0a71c05b14871714c50ba738
-  data.tar.gz: bce63f90b3310f312153995eb0441b17b009d21d
+  metadata.gz: 3c6dd25dd6e8987b0bb0a8138e492e74f2403729
+  data.tar.gz: 5f345c00d9a5a10d7be486fc2a137e79777a0c38
 SHA512:
-  metadata.gz: a53045c54df06d04bc67731d58b959f2ec6d6b062a1622d1734f02d568421543d0644de8a160ad20f4bd9c618a76875dc25f64be987d8e99e704e48cbd8cd98b
-  data.tar.gz: 2466eeae91287e081ec582eba490a5767f9e7e6d879f4eec65ea3d660ff655bbf88e21fc95388ab74c38d4a1afbb6ed14dc0af65d882227efe76b4a583ef61fa
+  metadata.gz: 5ce5669a0e0097fd16d6cce3e187a61195c672a90728cb6d040a034ae3674fbb21af8c5b31917d736d412405f46f5daa7bf6810b7aa68856947df1c725b96a5c
+  data.tar.gz: c2629b30b54cf086d52509ab924098fffe7dda9ac7637d4ca9f492f38f4d13fb07b9efcdbedfb61e41789e0d77acfcf558c133ad134b2c23a1b07927afae59d0

data/README.md

@@ -4,7 +4,9 @@ EasyConf, as its name suggest, is a gem for managing application configuration e
 
 You may wonder why I've created this gem. The answer is simple; because convention matters!
 
-I saw lots of applications written buy other awesome developers and I noticed that they are managing their configurations either by using config files or environment variables or even both! As a result of this, in this applications you can see something like  `ENV['foo']` and `Rails.application.config` mixed all around the source of the application. What a mess.
+I've seen lots of applications written by other awesome developers and I noticed that they are managing their configurations either by using config files or via environment variables or even both! As a result of this, in those applications you can see something like  `ENV['foo']` and `Rails.application.config` mixed all around the source of the application. What a mess.
+
+Directly accessing the source of configuration highly couples the way you configure your application with the application logic and if you want to change the way you configure the application you will have to touch the code itself which is bad.
 
 Beside of this complexity your production environment may have some restrictions you don't have on your own development environment. For example, if you are using Heroku you can't use config files to configure your application. Because you have to untrack config files on your VCS unless you have a good reason to track them. By using EasyConf while you can configure your application with config files also you can use environment variables on your production environment and this will give you a good abstraction on configuration!
 
@@ -28,16 +30,14 @@ Or install it yourself as:
 
 #### EasyConf configuration
 
-EasyConf requires its own configuration to determine where is configuration files. For Rails applications, create a file under config directory which looks like;
+EasyConf requires its own configuration to determine the source of the configurations etc. For Rails applications, create a file under config directory which looks like;
 
 ```ruby
 require 'easy_conf'
 
 EasyConf.configure do |config|
-  config.config_files    = ["#{Rails.root}/config/config.yml"]
-  config.inform_with     = :log
-  config.white_list_keys = [:foo]
-  config.environment     = :production
+  config.lookups = [EasyConf::Lookup::Env, EasyConf::Lookup::Yaml]
+  config.decoder = Proc.new { |value| value.upcase }
 end
 ```
 
@@ -78,18 +78,18 @@ Or if you want to get your configurations from config files as Hash, you can jus
 EasyConf.to_hash # { "foo" => "bar" }
 ```
 
-## Configuration Keys
-
-**config_files:** *Required! List of configuration files to be used.
-If you don't configure this, EasyConf can read configurations from only environment variables.
+## Available Configuration Backends
 
-**inform_with:** Optional. Information method used in case of error. Whether sliently puts log or raises exception. Valid options are `:log` and `:exception`. Default is `:log`.
+- Environment variables (EasyConf::Lookup::Env)
+- Yaml files (EasyConf::Lookup::Yaml)
+- Vault (EasyConf::Lookup::EVault)
+- Zookeeper (EasyConf::Lookup::Zookeeper)
 
-**white_list_keys:** Optional. List of config keys to be used. If this configuration is set, config keys which are not in this list won't be accessible through EasyConf!
+## Configuration Keys
 
-**black_list_keys:** Optional. List of config keys to be ignored. If this configuration is set, config keys which are in this list won't be accessible through EasyConf! *Note that, black list keys overrides white list keys.*
+**lookups:** Optional, default is `[EasyConf::Lookup::Env, EasyConf::Lookup::Yaml]`. List of lookups to be used to fetch the configuration. The lookup is basically the source of the configuration which. EasyConf implements `Env`, `YamlL`, `EVault` and `Zookeeper` lookups by default. You can also implement your own lookup, for more information about how to implement a lookup, you may have a look at the source of builtin lookups.
 
-**environment:** Optional. Specifies environment scope. For Rails applications, the value is same with Rails.
+**decoder:** Optional. The idea behind of having this key is, having configuration values as Ruby objects. If you set the ENV var FOO as `"--- 1\n...\n"` and set the `decoder` option as `Proc.new { |value| YAML.load(value) }` the return value of EasyConf.app_config.FOO will be `1` as Fixnum instead of String.
 
 ## TIPS
 
@@ -141,7 +141,6 @@ If you think storing configuration files at S3 is not good then you can use some
 ## TODO
 
 1. Write tests
-2. Write adapter for ZooKeeper
 
 ## Contributing
 

data/easy_conf.gemspec

@@ -19,7 +19,11 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "vault"
+  spec.add_dependency "zk", "~> 1.9"
+
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
 end

data/lib/easy_conf/app_config.rb

@@ -1,84 +1,25 @@
 module EasyConf
   class AppConfig # :nodoc
 
-    MESSAGES = {
-      unpermitted_key:  'Found unpermitted key'.freeze,
-      file_not_found:   'Configuration file not found'.freeze,
-      config_not_found: 'Configuration not found'.freeze,
-    }
-
-    EXCEPTIONS = {
-      unpermitted_key:  'UnpermittedConfigError'.freeze,
-      file_not_found:   'ConfigFileNotFoundError'.freeze,
-      config_not_found: 'ConfigNotFoundError'.freeze,
-    }
-
     def initialize
-      @table = __read_config
+      @dict = {}
     end
 
     def method_missing(meth, *args, &block)
-      return __notify(:unpermitted_key, meth) if __list_check(meth)
+      define_singleton_method(meth) do
+        @dict[meth]
+      end
 
-      __read_from_table(meth) || __read_from_env(meth) || __notify(:config_not_found, meth)
+      @dict[meth] = LookupVisitor.visit(meth)
     end
 
     def __keys
-      @table.keys
+      @dict.keys
     end
 
     def __to_hash
-      @table.dup
+      @dict.dup
     end
 
-    private
-      def __configuration
-        EasyConf.configuration
-      end
-
-      def __read_config
-        env = __configuration.environment.to_s
-
-        __configuration.config_files.inject({}) do |conf, config_file|
-          tmp = if File.exists?(config_file)
-            yaml_data = YAML.load_file(config_file)
-            env.blank? ? yaml_data : yaml_data.fetch(env, {})
-          else
-            __notify(:file_not_found, config_file) && {}
-          end
-          conf.merge(tmp)
-        end
-      end
-
-      def __read_from_table(key)
-        if val = @table[key.to_s]
-          define_singleton_method(key) { val }
-          send(key)
-        end
-      end
-
-      def __read_from_env(key)
-        if val = ENV[key.to_s]
-          define_singleton_method(key) { val }
-          send(key)
-        end
-      end
-
-      def __list_check(key)
-        (__configuration.black_list_keys.length > 0 && __configuration.black_list_keys.include?(key)) ||
-          (__configuration.black_list_keys.length == 0 &&
-            (__configuration.white_list_keys.length > 0 && !__configuration.white_list_keys.include?(key)))
-      end
-
-      def __notify(event, obj)
-        message = "#{MESSAGES[event]}: `#{obj}`"
-
-        if __configuration.inform_with == :exception
-          exception_class = "EasyConf::#{EXCEPTIONS[event]}"
-          raise exception_class.constantize.new(message)
-        else
-          puts message
-        end
-      end
   end
-end
+end

data/lib/easy_conf/configuration.rb

@@ -1,24 +1,41 @@
+require "ostruct"
+
 module EasyConf
   class Configuration # :nodoc
-    attr_accessor :config_files, :inform_with, :white_list_keys, :black_list_keys, :environment
+    attr_accessor :decoder
+    attr_reader :lookups
 
     def initialize
-      @config_files    = []
-      @inform_with     = :log
-      @white_list_keys = []
-      @black_list_keys = []
+      @lookups = []
     end
 
-    def white_list_keys=(keys)
-      @white_list_keys = keys.map(&:to_sym)
+    def lookups=(lookups)
+      @lookups = lookups.to_a
     end
 
-    def black_list_keys=(keys)
-      @black_list_keys = keys.map(&:to_sym)
+    def register_lookup(klass)
+      register_placeholder(klass.placeholder)
+      @lookups << klass
     end
 
-    def environment
-      @environment ||= defined?(Rails) ? Rails.env : nil
+    def de_register_lookup(klass)
+      @lookups -= [klass]
     end
+
+    private
+      def register_placeholder(placeholder)
+        check_placeholder_conflict!(placeholder)
+
+        instance_variable_set("@#{placeholder}_conf", OpenStruct.new)
+
+        define_singleton_method(placeholder) do
+          instance_variable_get("@#{placeholder}_conf")
+        end
+      end
+
+      def check_placeholder_conflict!(placeholder)
+        raise LookupNameConflictError.new(placeholder) if self.class.instance_methods(:false).include?(placeholder)
+      end
+
   end
-end
+end

data/lib/easy_conf/errors/config_not_found_error.rb

@@ -1,4 +1,4 @@
 module EasyConf
   class ConfigNotFoundError < IOError
   end
-end
+end

data/lib/easy_conf/errors/interface_error.rb

@@ -0,0 +1,3 @@
+module EasyConf
+  class InterfaceError < NotImplementedError; end
+end

data/lib/easy_conf/errors/lookup_name_conflict_error.rb

@@ -0,0 +1,13 @@
+module EasyConf
+  class LookupNameConflictError < RuntimeError
+
+    def initialize(name)
+      message = "`#{name}` placeholder is conflicting with the internal methods " \
+                "of the `EasyConf::Configuration` class. Register lookup with a " \
+                "different name to solve this issue!"
+
+      super(message)
+    end
+
+  end
+end

data/lib/easy_conf/lookup/abstract_lookup.rb

@@ -0,0 +1,51 @@
+require "ostruct"
+
+module EasyConf
+  module Lookup
+    class AbstractLookup
+
+      class << self
+        attr_writer :placeholder
+
+        def read(key)
+          raise_interface_error!
+        end
+
+        def placeholder
+          @placeholder ||= self.to_s.split('::').last.downcase
+        end
+
+        private
+          def raise_interface_error!
+            method_name   = caller_locations(1, 1)[0].label
+            error_message = "`#{method_name}` method should be implemented in `#{self.name}` class!"
+
+            raise EasyConf::InterfaceError.new(error_message)
+          end
+
+          def commit(raw_value)
+            throw(
+              :config_found,
+              apply_decoding(raw_value) || apply_default_decoding(raw_value) || raw_value
+            )
+          end
+
+          def apply_decoding(value)
+            if lookup_config && lookup_config.decoder
+              lookup_config.decoder.call(value)
+            end
+          end
+
+          def apply_default_decoding(value)
+            EasyConf.configuration.decoder.call(value) if EasyConf.configuration.decoder
+          end
+
+          def lookup_config
+            EasyConf.configuration.send(placeholder)
+          end
+
+      end
+
+    end
+  end
+end

data/lib/easy_conf/lookup/e_vault.rb

@@ -0,0 +1,59 @@
+require "vault"
+
+# Reads configurations from Vault.
+#
+# This lookup is NOT registered by default, you can register
+# it with;
+#
+#   EasyConf.register_lookup(EasyConf::Lookup::EVault)
+#
+# Beside the Vault configuration which has to be done seperately,
+# the lookup has one mandatory configuration key;
+#
+#   key_prefix : If you are already familiar with Vault, you may know that the values
+#                are stored in paths like 'secret/foo'. Here the key is foo and the
+#                value of foo is stored at secret engine. The prefix has to be set
+#                by the user depending on the way how they configured and use Vault.
+#
+# Configure as following;
+#
+# EasyConf.configure do |config|
+#   config.vault.key_prefix = 'secret/foo/bar'
+# end
+#
+# Additionally you can set the Vault configurations via ENV like so;
+#
+#   export VAULT_ADDR=http://127.0.0.1:8200
+#   export VAULT_TOKEN=token
+#   export VAULT_SSL_VERIFY=false
+module EasyConf
+  module Lookup
+    class EVault < AbstractLookup
+      self.placeholder = :vault
+
+      class << self
+        def read(key)
+          value = read_vault(key)
+          value && commit(value)
+        end
+
+        private
+          def read_vault(key)
+            vault_path = key_path(key)
+
+            secret = Vault.with_retries(Vault::HTTPError) do
+              Vault.logical.read(vault_path)
+            end
+
+            secret && secret.data && secret.data[:value]
+          end
+
+          def key_path(key)
+            "#{lookup_config.key_prefix}/#{key}"
+          end
+
+      end
+
+    end
+  end
+end

data/lib/easy_conf/lookup/env.rb

@@ -0,0 +1,22 @@
+# Reads configurations from YAML files.
+#
+# This lookup is registered by default, you can de-register
+# it with;
+#
+#   EasyConf.de_register_lookup(EasyConf::Lookup::Env)
+module EasyConf
+  module Lookup
+    class Env < AbstractLookup
+
+      class << self
+        def read(key)
+          value = ENV[key.to_s]
+          value && commit(value)
+        end
+      end
+
+    end
+  end
+end
+
+EasyConf.register_lookup(EasyConf::Lookup::Env)

data/lib/easy_conf/lookup/yaml.rb

@@ -0,0 +1,67 @@
+require "yaml"
+
+# Reads configurations from YAML files.
+#
+# This lookup is registered by default, you can de-register
+# it with;
+#
+#   EasyConf.de_register_lookup(EasyConf::Lookup::Yaml)
+#
+# The lookup has two configuration keys;
+#
+#   config_files : The list of files that the lookup will be performed against.
+#   scope        : If set, the configuration key will be searched in file under
+#                  the scope key. Use case of this config is, setting it as app
+#                  env so in one file you can have all the configs for all the
+#                  environments but the value this module will return will be
+#                  the one for that environment.
+#
+# Configure as following;
+#
+# EasyConf.configure do |config|
+#   config.yaml.config_files = [...]
+#   config.yaml.scope = Rails.env
+# end
+module EasyConf
+  module Lookup
+    class Yaml < AbstractLookup
+
+      class << self
+        def read(key)
+          value = dict[key.to_s]
+          !value.nil? && commit(value)
+        end
+
+        private
+          def dict
+            @dict ||= read_config_files
+          end
+
+          def read_config_files
+            config_files.reduce({}) do |memo, config_file|
+              read_config_file(config_file).each { |k, v| memo[k.to_s] = v }
+
+              memo
+            end
+          end
+
+          def read_config_file(config_file)
+            content = YAML.load_file(config_file)
+            scope ? content[scope] : content
+          end
+
+          def config_files
+            EasyConf.configuration.yaml.config_files.to_a
+          end
+
+          def scope
+            EasyConf.configuration.yaml.scope
+          end
+
+      end
+
+    end
+  end
+end
+
+EasyConf.register_lookup(EasyConf::Lookup::Yaml)

data/lib/easy_conf/lookup/zookeeper.rb

@@ -0,0 +1,63 @@
+require "zk"
+
+# Reads configurations from Zookeeper.
+#
+# This lookup is NOT registered by default, you can register
+# it with;
+#
+#   EasyConf.register_lookup(EasyConf::Lookup::Zookeeper)
+#
+# Beside the Zookeeper configuration which has to be done seperately,
+# the lookup has one mandatory configuration key;
+#
+#   key_prefix : If you are already familiar with Zookeeper, you may know that the values
+#                are stored in paths like 'my_app/foo'. Here the key is foo and the
+#                value of foo is stored at my_app directory. The prefix has to be set
+#                by the user depending on the way how they configured and use Zookeeper.
+#                Note that, leading / is a must. If the configuration is set on root path
+#                you can set `key_prefix` as empty string.
+#
+# Configure as following;
+#
+# EasyConf.configure do |config|
+#   config.zookeeper.key_prefix = '/my_app/foo'
+#   config.zookeeper.addresses = ['localhost:2181', 'localhost:2182', 'localhost:2183']
+# end
+#
+# Additionally you can set the Vault configurations via ENV like so;
+#
+#   export ZOOKEEPER_ADDR=localhost:2181,localhost:2182,localhost:2183
+module EasyConf
+  module Lookup
+    class Zookeeper < AbstractLookup
+
+      class << self
+        def read(key)
+          value = read_zookeeper(key)
+          value && commit(value)
+        end
+
+        private
+          def read_zookeeper(key)
+            zookeeper_path = key_path(key)
+
+            client.get(zookeeper_path)[0]
+          rescue ZK::Exceptions::NoNode
+          end
+
+          def client
+            @client ||= ZK.new(zookeeper_address)
+          end
+
+          def zookeeper_address
+            lookup_config.addresses ? lookup_config.addresses.join(',') : ENV['ZOOKEEPER_ADDR']
+          end
+
+          def key_path(key)
+            "#{lookup_config.key_prefix}/#{key}"
+          end
+      end
+
+    end
+  end
+end

data/lib/easy_conf/lookup_visitor.rb

@@ -0,0 +1,12 @@
+module EasyConf
+  class LookupVisitor
+
+    def self.visit(key)
+      catch(:config_found) do
+        EasyConf.configuration.lookups.each { |lookup| lookup.read(key) }
+        nil
+      end
+    end
+
+  end
+end

data/lib/easy_conf/version.rb

@@ -1,3 +1,3 @@
 module EasyConf
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/lib/easy_conf.rb

@@ -1,9 +1,11 @@
 require "easy_conf/version"
 require "easy_conf/app_config"
+require "easy_conf/lookup_visitor"
 require "easy_conf/configuration"
+require "easy_conf/errors/interface_error"
+require "easy_conf/errors/lookup_name_conflict_error"
 require "easy_conf/errors/config_not_found_error"
-require "easy_conf/errors/unpermitted_config_error"
-require "easy_conf/errors/config_file_not_found_error"
+require "easy_conf/lookup/abstract_lookup"
 
 module EasyConf
 
@@ -52,28 +54,38 @@ module EasyConf
       app_config.__to_hash
     end
 
+    # Registers a new lookup class to the lookup list.
+    #
+    # Example:
+    #
+    #   EasyConf.register_lookup(EasyConf::Lookup::Env)
+    def register_lookup(klass)
+      configuration.register_lookup(klass)
+    end
+
+    # De-registers the lookup class from the lookup list.
+    #
+    # Example:
+    #
+    #   EasyConf.de_register_lookup(EasyConf::Lookup::Env)
+    def de_register_lookup(klass)
+      configuration.de_register_lookup(klass)
+    end
+
     # Configures the EasyConf gem for the following keys;
     #
-    # config_files    : Required! List of configuration files to be used.
-    # inform_with     : Optional. Information method used in case of error.
-    #                   Whether sliently puts log or raises exception.
-    # white_list_keys : Optional. List of config keys to be used.
-    #                   If this configuration is set, config keys
-    #                   which are not in this list won't be
-    #                   accessible through EasyConf!
-    # black_list_keys : Optional! List of config keys to be ignored.
-    #                   If this configuration is set, config keys
-    #                   which are in this list won't be accessible
-    #                   through EasyConf!
-    # environment     : Optional. Specifies environment scope. For Rails
-    #                   applications, the value is same with Rails.
+    # lookups : Optional. An array of lookup classes. By default, EasyConf uses
+    #           ENV and YAML lookups.
+    # decoder : Optional. If you are encoding your config values before saving,
+    #           you can let EasyConf decode them automatically by setting this
+    #           with a `Proc`. This is usefull if you don't want to handle type
+    #           casting in your code.
     #
     # Example:
     #
     #   EasyConf.configure do |config|
-    #     config.config_files    = [config.yml]
-    #     config.white_list_keys = ['access_key', 'secret_key', ...]
-    #     config.black_list_keys = ['black_key', ...]
+    #     config.lookups = [EasyConf::Lookup::Env, EasyConf::Lookup::Yaml]
+    #     config.decoder = Proc.new { |value| YAML.load(value) }
     #   end
     def configure
       yield(configuration)
@@ -86,3 +98,8 @@ module EasyConf
   end
 
 end
+
+require "easy_conf/lookup/env"
+require "easy_conf/lookup/yaml"
+require "easy_conf/lookup/e_vault"
+require "easy_conf/lookup/zookeeper"

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: easy_conf
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Mehmet Emin İNAÇ
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-14 00:00:00.000000000 Z
+date: 2018-07-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: vault
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: EasyConf is a gem for reading configurations either from yaml files or
   from environment variables. With this gem you don't worry about where were your
   configurations.
@@ -74,9 +116,15 @@ files:
 - lib/easy_conf.rb
 - lib/easy_conf/app_config.rb
 - lib/easy_conf/configuration.rb
-- lib/easy_conf/errors/config_file_not_found_error.rb
 - lib/easy_conf/errors/config_not_found_error.rb
-- lib/easy_conf/errors/unpermitted_config_error.rb
+- lib/easy_conf/errors/interface_error.rb
+- lib/easy_conf/errors/lookup_name_conflict_error.rb
+- lib/easy_conf/lookup/abstract_lookup.rb
+- lib/easy_conf/lookup/e_vault.rb
+- lib/easy_conf/lookup/env.rb
+- lib/easy_conf/lookup/yaml.rb
+- lib/easy_conf/lookup/zookeeper.rb
+- lib/easy_conf/lookup_visitor.rb
 - lib/easy_conf/version.rb
 homepage: http://github.com/meinac/easy_conf
 licenses:
@@ -98,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Easily manage your app configurations.

data/lib/easy_conf/errors/config_file_not_found_error.rb

@@ -1,9 +0,0 @@
-module EasyConf
-  class ConfigFileNotFoundError < IOError
-
-    def backtrace
-      []
-    end
-
-  end
-end

data/lib/easy_conf/errors/unpermitted_config_error.rb

@@ -1,4 +0,0 @@
-module EasyConf
-  class UnpermittedConfigError < ArgumentError
-  end
-end