configurates 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0e9942377c030d89736ff37299d6ba12de638b48
+  data.tar.gz: 6a9f55676dbe4c957633bd664dcaea9df6bdcd3e
+SHA512:
+  metadata.gz: dcb4745cdfff415407998781a4bcf762a0914f5576cd47057b80a66df178ba7a78e83476c42f6737bdea6b5ad0403e81461f97a633f2a6992358319ae2c34aba
+  data.tar.gz: 0b2ee8cab588f48fc993e17e424c41542a963c9e181cb137b49579489e7fdd398ca7384dceb6249444b26396987b485101f93b0626a7543df0eba89b934e1e4c

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rspec',            '~> 3.5.0'
+  gem 'pry',              '~> 0.10.4'
+  gem 'rubocop',          '~> 0.42.0'
+end
+
+group :test do
+  gem 'rake',             '~> 11.2.2'
+end

data/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) <2016> Medvedu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/configurates.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'yaml'
+
+require File.join(__dir__, 'configurates', 'provider')
+require File.join(__dir__, 'configurates', 'provider', 'yaml')
+require File.join(__dir__, 'configurates', 'provider', 'environment')
+require File.join(__dir__, 'configurates', 'storage')
+
+#
+# Settings::Config is a module that provides agile way to work with
+# configuration, which can be useful for object initialization with default
+# settings. See details below:
+#
+# class MyClass
+#
+#   def initialize
+#     config = Settings::Config.create do
+#       merge_storage( Settings::Yaml.load('path/to/my/yaml/file'),
+#                      root: 'myclass/default' )
+#     end
+#
+#     if config.download?
+#       @power = config.power
+#       @value = config.actual.value
+#     else
+#       print config['WARNING_MESSAGE']
+#     end
+#   end
+# end
+#
+# This code demonstrates next concepts:
+#
+# First. You can choose what config part should be loaded. It can be useful for
+# small projects where you do not want to create more than one config file. It
+# means even if whole config placed in one place it is possible to load small
+# data/file part.
+#
+# Second. You can select an object from where configs can be loaded. By default
+# it can be Settings::Yaml or Settings::ENV provider
+#
+# Third. Chains are allowed.
+#
+#
+module Settings
+  #
+  #
+  #
+  class Config
+    attr_reader :root
+
+    include Provider
+
+    #
+    # Currently provider(s) can be registered only when we creating new instance
+    # based on Settings:Config class. It means self.create should be a higher
+    # function.
+    #
+    def self.create(&callback)
+      msg = 'Provider not being chosen'
+      raise NoBlockGiven, msg unless block_given?
+      new(&callback)
+    end
+
+    private
+
+    #
+    # Run &callback code in object instance.
+    #
+    def initialize(&callback)
+      instance_eval(&callback)
+    end
+
+    #
+    # Provide message redirect in the @root (storage) if it's possible.
+    #
+    def method_missing(msg, *args, &blk)
+      message_for_root?(msg) ? @root.send(msg, *args, &blk) : super
+    end
+
+    #
+    # And extend respond_to with storate's responses
+    #
+    def respond_to?(msg, include_private = false)
+      super || message_for_root?(msg) ? true : false
+    end
+
+    #
+    #
+    #
+    def message_for_root?(msg)
+      @root.send(:respond_to?, msg) ? true : false
+    end
+
+    #
+    # This is supposed to be raised when we trying to create instance for
+    # Settings::Config class without &codeblock
+    #
+    class NoBlockGiven < StandardError; end
+  end # class Settings::Config
+end # module Settings

data/lib/configurates/provider.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module Settings
+  #
+  # Module Provider is an inclusion for Settings::Config class.
+  #
+  # This module used for provider validations and data normalization.
+  #
+  # Details:
+  #
+  # Any provider (f.e. Settings::Yaml should respond to :data and :load
+  # methods, otherwise an exception will be raised.
+  #
+  # Any provider after provider.data method call should return non-empty hash,
+  # otherwise an exception will be raised.
+  #
+  # Provider should present non-empty sub-hash if optional parameter "#{root}"
+  # was used. For example for root: 'data/day1', original hash needs to include
+  # subhash like:
+  #
+  # hash = {…, …, data: {…, day1: { …, … }, … }, … }
+  #
+  module Provider
+    private
+
+    #
+    # Can be called only when Settings::Config class is initializing.
+    #
+    def merge_storage(provider, root: nil)
+      msg = "Provider #{provider} does not respond on :data or :load messages"
+      raise ProviderNotRespond, msg unless provider.class.respond_to?(:load) &&
+                                           provider.respond_to?(:data)
+
+      hsh = validate_and_extract_hash_from(provider)
+      extract_sub_hash_from(hsh, root)
+      defined?(@root) ? @root.merge(hsh) : @root = Storage.create(hsh)
+    end
+
+    #
+    # mutate hash unless root parameter is nil. Raise an exception if
+    # mutation result is not a valid hash.
+    #
+    def extract_sub_hash_from(hsh, root)
+      return hsh if root.nil?
+      tmp = hsh
+      root.split('/').each do |path|
+        tmp = tmp[path.to_sym]
+        msg = "No sub hash with symbol name '#{path}' for #{hsh} was found!"
+        raise RootNotExist, msg unless hash_valid?(tmp)
+      end
+      hsh.replace tmp
+    end
+
+    #
+    # encapsulate & extract & validate hash from provider
+    #
+    def validate_and_extract_hash_from(provider)
+      hsh = provider.data.dup
+      msg = "#{hsh} is not valid or empty Hash!"
+      raise HashNotValid, msg unless hash_valid?(hsh)
+      hsh
+    end
+
+    #
+    # valid hash is a non-empty hash object
+    #
+    def hash_valid?(hsh)
+      hsh.is_a?(Hash) && !hsh.empty? ? true : false
+    end
+
+    #
+    # This is supposed to be raised when provider not respond to :data
+    # or :load messages
+    #
+    class ProviderNotRespond < StandardError; end
+
+    #
+    # This is supposed to be raised when hash is not really a Hash or just
+    # when it is empty.
+    #
+    class HashNotValid < StandardError; end
+
+    #
+    # This is supposed to be raised when we cant extract a valid sub-hash
+    # from hash. In other words Root for hash not exist.
+    #
+    class RootNotExist < StandardError; end
+  end # module Settings::Provider
+end # module Settings

data/lib/configurates/provider/environment.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Settings
+  #
+  #
+  #
+  class ENV
+    #
+    #
+    #
+    def self.load(hsh)
+      new(hsh)
+    end
+
+    #
+    #
+    #
+    attr_reader :data
+
+    private
+
+    def initialize(hsh)
+      msg = "object #{hsh} should be an instance of Hash!"
+      raise HashNotValid, msg unless Hash === hsh
+      @data = hsh.dup
+    end
+
+    #
+    # This is supposed to be raised when self.load got a wrong object which
+    # can't response as a Hash.
+    #
+    class HashNotValid < StandardError; end
+  end # class Settings::YAML
+end # module Settings

data/lib/configurates/provider/yaml.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Settings
+  #
+  #
+  #
+  class Yaml
+    #
+    #
+    #
+    def self.load(path = nil)
+      path ||= '../configs/default.yml'
+      new(path)
+    end
+
+    #
+    #
+    #
+    attr_reader :data
+
+    private
+
+    def initialize(path)
+      @path = File.absolute_path(path)
+      begin
+        @data = YAML.load_file(@path)
+      rescue Errno::ENOENT
+        msg = "file with path: #{@path} not found!"
+        raise FileNotFound, msg
+      end
+    end
+
+    # file path
+    attr_reader :path
+
+    #
+    # This is supposed to be raised when file transerred to the self.load
+    # method wasn't found.
+    #
+    class FileNotFound < StandardError; end
+  end # class Settings::YAML
+end # module Settings

data/lib/configurates/storage.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+
+module Settings
+  #
+  #
+  #
+  class Storage
+    #
+    # Create new storage.
+    #
+    # Get hash and try to register each key as method or even sub-storage (it
+    # needs for nested hashes). Some keys are not allowed for method
+    # registration (f.e. when key = :42). All limitation about Ruby methods
+    # naming convention. You can get access to method with any name throw []
+    # thought.
+    #
+    # WARNING! Storage is case-sensitive! It means that keys :config and :Config
+    # are two different keys!
+    #
+    # Sample:
+    #
+    #
+    # hsh = { cinema: 'tiger',
+    #         rate: {3: 'excellent', 2: 'good', 1: 'overage', 0: 'not rated'},
+    #         watched: false,
+    #         'premier' 'soon'
+    #       }
+    #
+    #
+    # s = Storage.new(hsh)
+    #
+    # s.cinema     # => 'tiger'
+    # s.rate[0]    # => 'not rated'
+    # s.watched?   # => false
+    # s['premier'] # => soon
+    #
+    def self.create(hsh)
+      new hsh
+    end
+
+    #
+    # Alternative way to get stored value.
+    #
+    # How it can be used:
+    #
+    # conf[:load][:raise_on_error] # => true
+    # conf.load['skip_headers']    # => :yes
+    #
+    # Method will raise an ValueNotFound exception if nothing was found.
+    #
+    def [](arg)
+      return @storage[arg] unless @storage[arg].nil?
+      chaild = find_child_for_response(arg)
+      return chaild unless chaild.nil?
+      msg = "Variable with name '#{arg}' not found!"
+      raise ValueNotFound, msg
+    end
+
+    #
+    # NOT IMPLEMENTED!
+    #
+    def merge(_hsh)
+      raise StandardError, 'not implemented!'
+     end
+
+    private
+
+    #
+    # Initialization.
+    # Additional param "#{name}" is used only for nested storage naming.
+    #
+    def initialize(hsh, name = nil)
+      set_initial_values name
+      fill_in_storage hsh
+    end
+
+    #
+    # Slightly better way to tell about storage.
+    #
+    def to_ary
+      [nodes: @childs.map(&:name), variables: @storage.to_h]
+    end
+
+    #
+    #
+    #
+    def set_initial_values(name = nil)
+      @name    ||= name || 'root'
+      @childs  ||= []
+      @storage ||= {}
+    end
+
+    #
+    # For each pair "key: value" in #{"input_hsh"} we need to find a place where
+    # pairs can be stored. So, pairs with values === Hash is used to create new
+    # storages, other pairs will be stored in current storage.
+    #
+    def fill_in_storage(input_hsh)
+      tmp = input_hsh.dup
+      tmp.each_pair do |key, value|
+        case value
+        when Hash
+          @childs << Storage.new(value, key)
+        else
+          @storage[key] = value
+          register_methods_for key if key_can_be_a_method?(key)
+        end
+      end
+    end
+
+    #
+    # Unfortunately some names are not allowed to be registered as methods.
+    # With key_can_be_a_method we should determinate is it possible to
+    # define a method with "#{key}" name or not.
+    #
+    def key_can_be_a_method?(key)
+      key_as_string_valid_integer = key.to_s.to_i.to_s == key.to_s
+      key.is_a?(Integer) || key_as_string_valid_integer ? false : true
+    end
+
+    #
+    # Register method with #method_name.
+    #
+    # For TrueClass or FalseClass === @storage[method_name] it will
+    # define additional predicate method, like:
+    #
+    # config.skip_lazy_load? # => true
+    #
+    def register_methods_for(method_name)
+      define_singleton_method(method_name.to_sym) do
+        @storage[method_name]
+      end
+
+      return unless [true, false].include? @storage[method_name]
+      define_singleton_method("#{method_name.to_sym}?") do
+        @storage[method_name]
+      end
+    end
+
+    #
+    # Redirect message to childen node if this node can response to the message
+    # otherwise try to responce itself
+    #
+    def method_missing(method, *args, &blk)
+      child = find_child_for_response(method)
+      child.nil? ? super : child
+    end
+
+    #
+    # Return TRUE if storage or any childen node can response to the message
+    # otherwise return FALSE
+    #
+    def respond_to?(method, include_private = false)
+      super || find_child_for_response(method) ? true : false
+    end
+
+    #
+    # Look for nested node with the "#{name}". Since we working with hash we
+    # can believe that only one nested storage can be found (equal names
+    # disallowed).
+    #
+    def find_child_for_response(name)
+      @childs.select { |chaild| chaild.name == name }.first
+    end
+
+    protected
+
+    # Name for node. Root node has 'root' name.
+    attr_reader :name
+
+    # Subnodes array (childs) for current node. Can be empty.
+    attr_reader :childs
+
+    # Values array (storage) for methods registered in the node.
+    attr_reader :storage
+
+    #
+    # This is supposed to be raised when we didn't found assigned
+    # method for value in storage.
+    #
+    class ValueNotFound < StandardError; end
+  end # class Settings::Storage
+end # module Settings

data/readme.md

@@ -0,0 +1,98 @@
+# configurates
+
+## DESCRIPTION
+
+customizable_configuration is a lib that provides agile way to work with configuration, which can be useful for object initialization.
+
+## Travis CI
+
+https://travis-ci.org/Medvedu/customizable_configuration
+
+## SAMPLES
+
+### SAMPLE 1. BASICS
+
+```ruby
+conf = Settings::Config.create do
+  merge_storage Settings::Yaml.load('../configs/first.yml')
+end
+
+# Two ways to get an attribute:
+puts conf['string'] # => 4
+puts conf.string    # => 4
+
+# Any marchalized class is a valid data:
+puts conf.sample.dd.to_s # => 2016-09-05 05:42:35 +0300
+
+# Nested hash determitated as sub-storage
+puts conf.sample # => {:nodes=>[:cc],
+#                      :variables=>{:aa=>15,
+#                                   :bb=>[false, true],
+#                                   :dd=>2016-09-05 05:42:35 +0300} }
+
+# Access by [] to predicate
+puts conf[42].root? # => false
+```
+
+### SAMPLE 2. Tricks
+
+```ruby
+## PART 1 CASE-SENSIVITY
+
+# Warning! Keys are case-sensivity. It means that 'config' and 'Config' are
+# two different keys
+
+yaml = Settings::Config.create do
+  merge_storage Settings::Yaml.load('../configs/second.yml')
+end
+
+puts yaml.config # => {:nodes=>[], :variables=>{:param1=>"config/param1",
+#                                               :param2=>false, :param3=>[]}}
+
+puts yaml.Config # => {:nodes=>[:param3], :variables=>{:param1=>"Config/param1",
+#                                                      :param2=>[true]}}
+
+## PART 2 ROOT
+
+# Sometimes can be useful to load only a part of hash from file, so you can
+# use root parameter for merge_storage method:
+
+file = Settings::Yaml.load('../configs/second.yml')
+
+# You can load only YAML part (root: 'config')
+part1   = Settings::Config.create { merge_storage file, root: 'config' }
+puts part1.param1 # => config/param1
+
+# Or load even more deeper (root: 'Config/param3')
+part2 = Settings::Config.create { merge_storage file, root: 'Config/param3' }
+print part2.super_deep_array # => [1, 2, 3, 4]
+```
+
+###  SAMPLE 3. PROVIDERS
+
+```ruby
+## PART 1 ENV
+
+dynamic = Settings::Config.create do
+  merge_storage Settings::ENV.load( RbConfig::CONFIG )
+end
+
+puts dynamic["RUBY_VERSION_NAME"] # => ruby-2.3.0
+
+## PART 2 YAML
+
+yaml = Settings::Config.create do
+  merge_storage Settings::Yaml.load('../configs/second.yml')
+end
+
+puts yaml[:config][:param1] # => config/param1
+```
+
+## dependencies
+
+> Ruby 2.0.0 or higher
+
+## License
+----
+
+MIT, see [LICENSE](./LICENSE)

data/spec/config_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Settings::Config do
+  context '#create' do
+    it 'raises an NoBlockGiven exception when method was called without &block' do
+      expect { Settings::Config.create }.to raise_error Settings::Config::NoBlockGiven
+    end
+  end # context '#create'
+
+  context 'after #create' do
+    before :each do
+      @subject = described_class.create do
+        merge_storage Settings::ENV.load(param1: 'sample')
+      end
+    end
+
+    context '#method_missing' do
+      it 'redirect message call to storage when it needed' do
+        expect(@subject.param1).to_not be_nil
+      end
+    end # context "#method_missing"
+
+    context '#respond_to?' do
+      it 'redirect response_to? message call to storage when it needed' do
+        expect(@subject.send(:respond_to?, :param1)).to be_truthy
+      end
+    end # context 'respond_to?'
+  end # context 'after #create'
+
+end # describe Settings::Config

data/spec/customizable_configuration/provider/environment_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Settings::ENV do
+  let (:valid_hsh_sample) { {string: 'some_string', param: true } }
+  let (:not_hsh_sample)   { Time.new }
+
+  context '#load' do
+    it 'raises an HashNotValid exception for object that not is a hash' do
+      expect { described_class.load(not_hsh_sample) }
+        .to raise_error Settings::ENV::HashNotValid
+    end
+
+    it 'saves valid hash into .data field' do
+      obj = described_class.load valid_hsh_sample
+      expect(obj.data.length).to be > 0
+    end
+  end # context '#load'
+end # describe Settings::ENV

data/spec/customizable_configuration/provider/yaml_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Settings::Yaml do
+  let(:valid_file_path) { File.join RSpec::Core::RubyProject.root, 'configs', 'first.yml' }
+
+  context 'load' do
+    it 'loads a hash from file' do
+      provider = described_class.load(valid_file_path)
+      expect(provider.data.length).to be > 0
+    end
+
+    it 'raises FileNotFound exception when file not found' do
+      expect { described_class.load('file_that_can_not_exist') }
+        .to raise_error Settings::Yaml::FileNotFound
+    end
+  end # context 'load' do
+
+end # describe Settings::Yaml

data/spec/customizable_configuration/provider_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Settings::Config do
+  context 'Provider module' do
+
+    context '#merge_storage' do
+      it 'raises an ProviderNotRespond exception when provider does not respond to :load method' do
+        expect do
+          Settings::Config.create { merge_storage 'string_as_provider' }
+        end.to raise_error Settings::Config::ProviderNotRespond
+      end
+    end # context '#merge_storage'
+
+    context '#extract_sub_hash_from' do
+      it 'raises an RootNotExist exception when provider can not extract a hash' do
+        provider = Settings::ENV.load(param1: true, para2: false)
+        expect do
+          Settings::Config.create { merge_storage(provider, root: 'wrong/path') }
+        end.to raise_error Settings::Provider::RootNotExist
+      end
+    end # context '#extract_sub_hash_from'
+
+    context '#validate_and_extract_hash_from' do
+      it 'raises an HashNotValid exception when provider getting empty hash' do
+        expect do
+          Settings::Config.create { merge_storage Settings::ENV.load({}) }
+        end.to raise_error Settings::Config::HashNotValid
+      end
+    end # context '#validate_and_extract_hash_from'
+
+  end # context '#provider'
+end # describe Settings::Config

data/spec/customizable_configuration/storage_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Settings::Storage do
+  let(:hsh_sample) do
+    { nested_hsh: { param1: true, param2: false },
+      param1: 42,
+      param2: 15,
+      predicate: true,
+      'special_sample' => { 55 => 'good' } }
+  end
+
+  subject { described_class.new(hsh_sample) }
+
+  describe 'Storage' do
+    context 'after #create' do
+      it 'registers hash key as predicate method for booleans' do
+        expect(subject.predicate?).to be_truthy
+      end
+
+      it 'have a correct value assigned with registered method' do
+        expect(subject.param1).to eql(42)
+      end
+
+      context '#[]' do
+        it 'raises an ValueNotFound exception when argument for [] not valid' do
+          expect { subject[:param42] }
+            .to raise_error(Settings::Storage::ValueNotFound)
+        end
+
+        it 'gives value by access throw [] method' do
+          expect(subject[:param2]).to eql(15)
+        end
+
+        it 'provides chain call throw [] method' do
+          expect(subject[:nested_hsh][:param2]).to eql(false)
+        end
+
+        it 'allows to use numbers and strings as parameters' do
+          expect(subject['special_sample'][55]).to eql('good')
+        end
+      end # context "#[]"
+
+      context '#fill_in_storage' do
+        it 'registers hash key as method' do
+          expect(subject.send(:respond_to?, :param1)).to be_truthy
+        end
+
+        it 'registers a sub-storage for sub-hash' do
+          expect(subject.nested_hsh).to be_an_instance_of(Settings::Storage)
+        end
+      end # context "#fill_in_storage"
+
+      context '#method_missing' do
+        it 'redirect message call to sub-storage' do
+          expect(subject.nested_hsh.param1).to_not be_nil
+        end
+      end # context "#method_missing"
+
+      context '#respond_to?' do
+        it 'redirect response_to? message call to sub-storage' do
+          expect(subject.send(:respond_to?, :nested_hsh)).to be_truthy
+        end
+      end # context 'respond_to?'
+    end # context 'after #create'
+
+  end # describe "Storage"
+end # describe Settings::Storage

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require_relative '../lib/configurates'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: configurates
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+platform: ruby
+authors:
+- Kuzichev Michael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-07 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: kMedvedu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- Rakefile
+- lib/configurates.rb
+- lib/configurates/provider.rb
+- lib/configurates/provider/environment.rb
+- lib/configurates/provider/yaml.rb
+- lib/configurates/storage.rb
+- readme.md
+- spec/config_spec.rb
+- spec/customizable_configuration/provider/environment_spec.rb
+- spec/customizable_configuration/provider/yaml_spec.rb
+- spec/customizable_configuration/provider_spec.rb
+- spec/customizable_configuration/storage_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Medvedu/customizable_configuration
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: configurates is a lib that provides agile way to work with configuration,
+  which can be useful for object initialization
+test_files:
+- spec/spec_helper.rb
+- spec/customizable_configuration/storage_spec.rb
+- spec/customizable_configuration/provider_spec.rb
+- spec/customizable_configuration/provider/environment_spec.rb
+- spec/customizable_configuration/provider/yaml_spec.rb
+- spec/config_spec.rb
+has_rdoc: