configuru 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5db1722e4793d1f8627e6c8c8b796cdac8e83d50
+  data.tar.gz: 9e45658f486a5d39da387eb2479c172b7aee5f4b
+SHA512:
+  metadata.gz: 6e8073b7a2cbfd96c44f92ed190c796a7a61cfcbc7363ecca705521a517f5bca2c0a7fe6fd0d88258e5316e1f3cc6542f18d5ffb33f76cc5dd6e66e536104474
+  data.tar.gz: ef1b06f4d8c2238f7414538a2b54ddfe70e2c0d857c86f1bd1d388a0ab3a0c755aeef2078a499b247445c42a6402c52c55137679309f84ae380a05f852bbfb13

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.env
+.rspec
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+**/.DS_Store

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.1.2
+
+branches:
+  only:
+    - master
+
+script: bundle exec rake spec
+
+before_install:
+  - gem update --system
+  - gem --version

data/CONTRIBUTORS.md

@@ -0,0 +1 @@
+* Andrey Pronin <moonfly.msk@gmail.com> aka moonfly (https://github.com/moonfly)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in configuru.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014 [CONTRIBUTORS.md](https://github.com/moonfly/configuru/master/CONTRIBUTORS.md)
+
+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/README.md

@@ -0,0 +1,83 @@
+# Configuru
+
+Provides convenient interface for managing configuration parameters for modules, classes and instances.
+Requires Ruby version >= 2.1.
+
+[![Build Status](https://travis-ci.org/moonfly/configuru.svg?branch=master)](https://travis-ci.org/moonfly/configuru)
+[![Coverage Status](https://img.shields.io/coveralls/moonfly/configuru.svg)](https://coveralls.io/r/moonfly/configuru?branch=master)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'configuru'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install configuru
+
+## Usage
+
+The typical usage scenario is provided below:
+
+```ruby
+require 'configuru'
+
+class MyClass
+  include Configuru::Configurable
+  provide_configuration
+  
+  def_config_param :secret_key, make_string: true, default: (ENV['SECRET_KEY_'] || '???')
+  def_config_param :color, default: :green, 
+                   convert: ->(val) { raise "Huh?" unless [:red,:green].include?(val); val }
+  def_config_param :percentage, make_float:true, min:0, max:100, default:100
+  
+  def initialize(options,&block)
+    configure(options,&block)
+    configuration.lock
+  end
+end
+
+my_inst = MyClass.new do |config|
+  config.secret_key = "VERY-SECR-ETKY"
+  config.color = :red
+  config.options_source = "/my/path/to/file/with/options.yml"
+end
+
+my_inst.configuration.color       #=> :red
+my_inst.configuration.secret_key  #=> "VERY-SECR-ETKY"
+my_inst.configuration.percentage  #=> 100
+```
+
+
+
+## Versioning
+
+Semantic versioning (http://semver.org/spec/v2.0.0.html) is used. 
+
+For a version number MAJOR.MINOR.PATCH, unless MAJOR is 0:
+
+1. MAJOR version is incremented when incompatible API changes are made,
+2. MINOR version is incremented when functionality is added in a backwards-compatible manner, 
+3. PATCH version is incremented when backwards-compatible bug fixes are made.
+
+Major version "zero" (0.y.z) is for initial development. Anything may change at any time. 
+The public API should not be considered stable. 
+
+## Dependencies
+
+Requires Ruby version >= 2.1
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/configuru/fork )
+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

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run RSpec tests (use rake spec SPEC_OPTS='...' to pass rspec options)"
+RSpec::Core::RakeTask.new(:spec)

data/configuru.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'configuru/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "configuru"
+  spec.version       = Configuru::VERSION
+  spec.authors       = ['moonfly (Andrey Pronin)']
+  spec.email         = ['moonfly.msk@gmail.com']
+  spec.summary       = %q{Configuration for your classes}
+  spec.description   = %q{Provides convenient interface for managing configuration parameters for modules, classes and instances.}
+  spec.homepage      = 'https://github.com/moonfly/configuru'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.rdoc_options = ['--charset=UTF-8']
+  spec.extra_rdoc_files = %w[README.md CONTRIBUTORS.md LICENSE.md]
+  
+  spec.required_ruby_version = '>= 2.1.0'
+  
+  spec.add_development_dependency 'bundler', '>= 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'coveralls'
+end

data/lib/configuru.rb

@@ -0,0 +1,3 @@
+require 'configuru/version'
+require 'configuru/config_methods'
+require 'configuru/configurable'

data/lib/configuru/config_methods.rb

@@ -0,0 +1,117 @@
+require 'yaml'
+
+module Configuru
+  module ConfigMethods
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Class methods
+    module ClassMethods
+      def param_names
+        @param_names ||= []
+      end
+      def param(name,options={})
+        param_names << name.to_sym
+      
+        inst_var = "@#{name.to_s}"
+        define_method(name) do
+          if !instance_variable_defined?(inst_var) && options.has_key?(:default)
+            instance_variable_set inst_var, options[:default]
+          end
+          instance_variable_get inst_var
+        end
+
+        define_method("#{name.to_s}=") do |value|
+          if options[:lockable] && is_locked
+            raise ArgumentError.new("'#{name.to_s}' cannot be set at this time")
+          end
+          if options[:not_nil] && value.nil?
+            raise ArgumentError.new("'#{name.to_s}' cannot be nil")
+          end
+          if options[:not_empty] && (value.nil? || value.empty?)
+            raise ArgumentError.new("'#{name.to_s}' cannot be empty")
+          end
+          if options.has_key?(:must_be) && !Array(options[:must_be]).include?(value.class)
+            valid_class = false
+            Array(options[:must_be]).each do |cname|
+              valid_class = true if value.is_a?(cname)
+            end
+            raise ArgumentError.new("Wrong class (#{value.class}) for '#{name.to_s}' value") unless valid_class
+          end
+          if options.has_key?(:must_respond_to)
+            Array(options[:must_respond_to]).each do |mname|
+              raise ArgumentError.new("'#{name.to_s}' must respond to '#{mname}'") unless value.respond_to?(mname)
+            end
+          end
+          value = Hash(value) if options[:make_hash]
+          value = Array(value) if options[:make_array]
+          value = String(value) if options[:make_string]
+          value = value.to_i if options[:make_int]
+          value = value.to_f if options[:make_float]
+          value = !!value if options[:make_bool]
+          if options.has_key?(:max) && (value > options[:max])
+            raise ArgumentError.new("'#{name.to_s}' must no be more than #{options[:max]}")
+          end
+          if options.has_key?(:min) && (value < options[:min])
+            raise ArgumentError.new("'#{name.to_s}' must no be less than #{options[:min]}")
+          end
+          if options.has_key?(:in) && !options[:in].include?(value)
+            raise ArgumentError.new("'#{name.to_s}' is out of range")
+          end
+          if options.has_key?(:convert)
+            if options[:convert].is_a? Symbol
+              value = send options[:convert], value
+            else
+              value = options[:convert].call( value )
+            end
+          end
+
+          instance_variable_set inst_var, value
+        end
+        name
+      end
+    end
+
+    # Instance methods
+    def lock(flag=true)
+      @locked = flag
+    end
+    def is_locked
+      @locked = false unless instance_variable_defined?(:@locked)
+      @locked
+    end
+    
+    def configure(options={})
+      Hash(options).each_pair do |name,value|
+        if name.to_sym == :options_source
+          self.options_source = value
+        else
+          send("#{name.to_s}=",value)
+        end
+      end
+      yield self if block_given?
+      self
+    end
+    def options_source=(value)
+      sub_options = case value
+        when Hash, Array then value
+        when IO, StringIO, Tempfile then 
+          YAML.load(value)
+        when String, Pathname
+          output = {}
+          File.open(value,"r") { |f| output = YAML.load(f) }
+          output
+        else
+          raise ArgumentError.new("Wrong argument class for options_source: #{value.class}")
+      end
+      if sub_options.is_a? Array
+        sub_options.each { |elem| self.options_source=elem }
+      else
+        configure(sub_options)
+      end
+    end
+    
+
+  end
+end

data/lib/configuru/configurable.rb

@@ -0,0 +1,45 @@
+module Configuru
+  module Configurable
+    
+    module ClassMethods
+      extend Forwardable
+      def_delegator :configuration_class, :param, :def_config_param
+      def configuration_class
+        @configuration_class ||= Class.new do
+          include Configuru::ConfigMethods 
+        end
+      end
+      def provide_configuration(limit_to=false)
+        unless [:base,:class,:module].include?(limit_to)
+          # Add methods to instance
+          include MainMethods
+          include InstanceMethods
+        end
+        unless [:instance,:instances].include?(limit_to)
+          # Add methods to base
+          extend MainMethods
+        end
+      end
+    end
+
+    module MainMethods
+      def configuration
+        @configuruation ||= configuration_class.new
+      end
+      def configure(options,&block)
+        configuration.configure(options,&block)
+      end
+    end
+    
+    module InstanceMethods
+      def configuration_class
+        self.class.configuration_class
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+  end
+end

data/lib/configuru/version.rb

@@ -0,0 +1,3 @@
+module Configuru
+  VERSION = "0.1.0"
+end

data/spec/configuru/config_methods_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe Configuru::ConfigMethods do
+  before(:each) { 
+    class TestSubjectClass
+      include Configuru::ConfigMethods
+    end
+    class TestIoSubjectClass
+      include Configuru::ConfigMethods
+      param :test1
+      param :test2
+    end
+  }
+  let(:subject) { TestSubjectClass.new }
+  let(:opts_spec) { Hash("test1" => "something1", :test2 => "something2") }
+  let(:opts_sio) { StringIO.new(opts_spec.to_yaml) }
+  
+  it 'includes class methods' do
+    expect(TestSubjectClass.methods).to include :param, :param_names
+  end
+  it 'returns itself from configure (smoke test)' do
+    expect(subject.configure).to eq subject
+  end
+  it 'allows defining parameters' do
+    class << subject
+      param :test
+    end
+    expect(subject).to respond_to :test
+    expect(subject).to respond_to :test=
+  end
+  
+  it 'allows settings variables passed as a hash and/or block' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    subject.configure({test1: "something1"}) do |cfg|
+      cfg.test2 = "something2"
+    end
+    expect(subject.test1).to eq "something1"
+    expect(subject.test2).to eq "something2"
+  end
+  
+  it 'keeps track of parameters' do
+    expect(TestIoSubjectClass.param_names).to include :test1, :test2
+  end
+
+  it 'allows loading options from Hash' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    subject.options_source = opts_spec
+    expect(subject.test1).to eq "something1"
+    expect(subject.test2).to eq "something2"
+  end
+
+  it 'allows loading options from StringIO' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    subject.options_source = opts_sio
+    expect(subject.test1).to eq "something1"
+    expect(subject.test2).to eq "something2"
+  end
+  
+  it 'allows loading options from an array of sources, later sources take precendence' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    opts_spec1 = opts_spec.clone
+    opts_spec1.delete("test1")
+    opts_spec1[:test2] = "something3"
+
+    subject.options_source = [opts_sio, opts_spec1]
+    expect(subject.test1).to eq "something1"
+    expect(subject.test2).to eq "something3"
+  end
+  
+  it 'allows loading options from sources several times, later sources take precendence' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    opts_spec1 = opts_spec.clone
+    opts_spec1.delete("test1")
+    opts_spec1[:test2] = "something3"
+
+    subject.options_source = opts_sio
+    subject.options_source = opts_spec1
+    expect(subject.test1).to eq "something1"
+    expect(subject.test2).to eq "something3"
+  end
+  
+  it 'does not allow loading options from an arbitrary value' do
+    class << subject
+      param :test1
+      param :test2
+    end
+    [10,"test1=1;test2=2",nil].each do |value|
+      expect{subject.options_source = value}.to raise_error
+    end
+  end
+
+  it 'allows loading options from File/IO' do
+    subject1 = nil
+    subject2 = nil
+    subject3 = nil
+    f = Tempfile.new("test_options.yaml")
+    begin
+      f << opts_spec.to_yaml
+      f.open
+      subject1 = TestIoSubjectClass.new.configure( options_source: f )
+      subject2 = TestIoSubjectClass.new.configure( options_source: f.path )
+      File.open( f.path ) do |real_f|
+        subject3 = TestIoSubjectClass.new.configure( options_source: real_f )
+      end
+    ensure
+      f.close
+      f.unlink
+    end
+    [ 
+      subject1,
+      subject2,
+      subject3
+    ].each do |s|
+      expect(s).not_to be_nil
+      expect(s.test1).to eq "something1"
+      expect(s.test2).to eq "something2"
+    end
+  end  
+
+  it 'allows specifying defaults' do
+    class << subject
+      param :test, default: "something3"
+    end
+    expect(subject.test).to eq "something3"
+  end
+
+  it 'allows restriciting value classes' do
+    class << subject
+      param :test, must_be: [Array,Hash]
+    end
+    expect{subject.test=[]}.not_to raise_error
+    expect{subject.test={}}.not_to raise_error
+    expect{subject.test=nil}.to raise_error
+    expect{subject.test=""}.to raise_error
+  end
+  it 'allows restriciting value classes through duck typing' do
+    class << subject
+      param :test, must_respond_to: [:each_pair, :size]
+    end
+    expect{subject.test=[]}.to raise_error
+    expect{subject.test={}}.not_to raise_error # the only one to respond to both :each_pair AND :size
+    expect{subject.test=nil}.to raise_error
+    expect{subject.test=""}.to raise_error
+  end
+
+  it 'allows locking selected variables' do
+    class << subject
+      param :test1, lockable: true
+      param :test2
+    end
+    expect{subject.test1="1"}.not_to raise_error
+    expect{subject.test2="1"}.not_to raise_error
+    expect(subject.test1).to eq "1"
+    expect(subject.test2).to eq "1"
+
+    subject.lock
+    expect(subject.is_locked).to eq true
+    expect{subject.test1="2"}.to raise_error
+    expect{subject.test2="2"}.not_to raise_error
+    expect(subject.test1).to eq "1"
+    expect(subject.test2).to eq "2"
+
+    subject.lock(false)
+    expect(subject.is_locked).to eq false
+    expect{subject.test1="3"}.not_to raise_error
+    expect{subject.test2="3"}.not_to raise_error
+    expect(subject.test1).to eq "3"
+    expect(subject.test2).to eq "3"
+  end
+  
+  it 'allows restricting setting nil or empty variables' do
+    class << subject
+      param :test1, not_nil: true
+      param :test2, not_empty: true
+    end
+    expect{subject.test1="1"}.not_to raise_error
+    expect{subject.test2="1"}.not_to raise_error
+    expect(subject.test1).to eq "1"
+    expect(subject.test2).to eq "1"
+
+    expect{subject.test1=nil}.to raise_error
+    expect{subject.test2=nil}.to raise_error
+    expect(subject.test1).to eq "1"
+    expect(subject.test2).to eq "1"
+
+    expect{subject.test1=""}.not_to raise_error
+    expect{subject.test2=""}.to raise_error
+    expect(subject.test1).to eq ""
+    expect(subject.test2).to eq "1"
+  end
+  
+  it 'allows converting to pre-defined types' do
+    class << subject
+      param :test_s, make_string: true
+      param :test_a, make_array: true
+      param :test_h, make_hash: true
+      param :test_i, make_int: true
+      param :test_f, make_float: true
+      param :test_b, make_bool: true
+    end
+    expect{subject.test_s=nil}.not_to raise_error
+    expect(subject.test_s).to be_a String
+    expect(subject.test_s).to eq ""
+
+    expect{subject.test_a=nil}.not_to raise_error
+    expect(subject.test_a).to be_a Array
+    expect(subject.test_a).to eq []
+    
+    expect{subject.test_h=nil}.not_to raise_error
+    expect(subject.test_h).to be_a Hash
+    expect(subject.test_h).to eq Hash.new
+    
+    expect{subject.test_i=nil}.not_to raise_error
+    expect(subject.test_i).to be_a Integer
+    expect(subject.test_i).to eq 0
+
+    expect{subject.test_f=nil}.not_to raise_error
+    expect(subject.test_f).to be_a Float
+    expect(subject.test_f).to eq 0.0
+    
+    expect{subject.test_b=nil}.not_to raise_error
+    expect(subject.test_b).to be_a FalseClass
+    expect(subject.test_b).to eq false
+  end
+  
+  it 'allows defining min/max boundaries for values' do
+    class << subject
+      param :test1, min: 10
+      param :test2, max: 'c'
+    end
+
+    expect{subject.test1=11}.not_to raise_error
+    expect{subject.test1=10}.not_to raise_error
+    expect{subject.test1=9}.to raise_error
+    
+    expect{subject.test2='b'}.not_to raise_error
+    expect{subject.test2='c'}.not_to raise_error
+    expect{subject.test2='d'}.to raise_error
+  end
+
+  it 'allows defining ranges for values' do
+    class << subject
+      param :test1, in: 3..7
+      param :test2, in: ['a','c']
+    end
+
+    expect{subject.test1=3}.not_to raise_error
+    expect{subject.test1=6}.not_to raise_error
+    expect{subject.test1=9}.to raise_error
+    
+    expect{subject.test2='a'}.not_to raise_error
+    expect{subject.test2='c'}.not_to raise_error
+    expect{subject.test2='b'}.to raise_error
+  end
+  
+  it 'allows specifying a custom conversion method' do
+    class << subject
+      def check_for_x(value)
+        raise "X is not allowed" if value == "x"
+        "ok"
+      end
+      param :test1, convert: :check_for_x
+      param :test2, convert: ->(value) { value+1 }
+    end
+    expect{subject.test1=3}.not_to raise_error
+    expect(subject.test1).to eq "ok"
+    expect{subject.test1="x"}.to raise_error
+    
+    expect{subject.test2=7}.not_to raise_error
+    expect(subject.test2).to eq 8
+  end
+end

data/spec/configuru/configurable_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Configuru::Configurable do
+  before(:each) do
+    module TestConfigurableModule
+      include Configuru::Configurable
+      provide_configuration
+      def_config_param :test1
+    end
+    module TestConfigurableModuleBase
+      include Configuru::Configurable
+      provide_configuration :base
+      def_config_param :test1
+    end
+    module TestConfigurableModuleInst
+      include Configuru::Configurable
+      provide_configuration :instances
+      def_config_param :test1
+    end
+
+    class TestConfigurableClass
+      include Configuru::Configurable
+      provide_configuration
+      def_config_param :test1
+    end
+    class TestConfigurableClassBase
+      include Configuru::Configurable
+      provide_configuration :base
+      def_config_param :test1
+    end
+    class TestConfigurableClassInst
+      include Configuru::Configurable
+      provide_configuration :instances
+      def_config_param :test1
+    end
+  end
+  
+  it 'works for modules at base-level' do
+    expect{TestConfigurableModuleBase.configure(test1: "1")}.not_to raise_error
+    expect(TestConfigurableModuleBase.configuration.test1).to eq "1"
+  end
+  it 'does not work for modules at instance-level' do
+    expect{TestConfigurableModuleInst.configure(test1: "1")}.to raise_error
+  end
+  
+  it 'works for classes at base-level' do
+    expect{TestConfigurableClassBase.configure(test1: "1")}.not_to raise_error
+    expect(TestConfigurableClassBase.configuration.test1).to eq "1"
+  end
+  it 'does not work for classes at instance-level' do
+    expect{TestConfigurableClassInst.configure(test1: "1")}.to raise_error
+  end
+  
+  it 'works for class instances at instance-level' do
+    subject = TestConfigurableClassInst.new
+    expect{subject.configure(test1: "1")}.not_to raise_error
+    expect(subject.configuration.test1).to eq "1"
+  end
+  it 'does not work for class instances at base-level' do
+    subject = TestConfigurableClassBase.new
+    expect{subject.configure(test1: "1")}.to raise_error
+  end
+  
+  it 'provides a separate configuration for each instance and class' do
+    subject1 = TestConfigurableClass.new
+    subject2 = TestConfigurableClass.new
+
+    expect{TestConfigurableClass.configure(test1: "0")}.not_to raise_error
+    expect{subject1.configure(test1: "1")}.not_to raise_error
+    expect{subject2.configure(test1: "2")}.not_to raise_error
+
+    expect(TestConfigurableClass.configuration.test1).to eq "0"
+    expect(subject1.configuration.test1).to eq "1"
+    expect(subject2.configuration.test1).to eq "2"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'configuru'

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: configuru
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- moonfly (Andrey Pronin)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  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: Provides convenient interface for managing configuration parameters for
+  modules, classes and instances.
+email:
+- moonfly.msk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CONTRIBUTORS.md
+- LICENSE.md
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTORS.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- configuru.gemspec
+- lib/configuru.rb
+- lib/configuru/config_methods.rb
+- lib/configuru/configurable.rb
+- lib/configuru/version.rb
+- spec/configuru/config_methods_spec.rb
+- spec/configuru/configurable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/moonfly/configuru
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Configuration for your classes
+test_files:
+- spec/configuru/config_methods_spec.rb
+- spec/configuru/configurable_spec.rb
+- spec/spec_helper.rb