configureasy 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27a4dc67f6dbb0c1a719a09453e3621c91365ea1
-  data.tar.gz: 7110800425b8880687c7a78e5c23b285b58d3705
+  metadata.gz: 53ec1f1f03b188c3ef934d0bf5e5d980a313825c
+  data.tar.gz: 082aa5e705f4488e4a65033df3e4d63a92731249
 SHA512:
-  metadata.gz: eb1870f7f84b47e4b08483dc958dc3de2cc4859b66d4066e38786c9f553cf28bc220a278797a8cc43aea450d244fb79365b5d398df0d5a0cd087abac4e35b23a
-  data.tar.gz: 2f88c2dfe20f5ed7b34ec131691c81a228e9b39104583b289620d1c81c98ffe4b548a65b62a25ad83d84806aac2429692e6d9c6e16d85db2137a3152c46592c3
+  metadata.gz: 8225a7f3d3c5c06eed1a38570699e119e74e905df538f8c6ce0dd9b3d0c840a5f53f00cada86987bb8e5476e9e6e0ce4934a26a5a951ccd2af1572878e21f6d0
+  data.tar.gz: b4cb540efa45c89b5955a06a37fc85b0e2c685b519843fb3b65ea36bfc1b6c15d8cb1da57e04700b914dfe635e01897e7c43185b46614a0a19656ca831c31c99

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: ysw4PXa6VEK0TrzqD7rO26tiSCcBF2Vkv

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -2,3 +2,17 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in configureasy.gemspec
 gemspec
+
+group :development do
+  gem 'terminal-notifier'
+  gem 'terminal-notifier-guard'
+  gem 'pry'
+  gem 'pry-nav'
+end
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'guard-rspec'
+  gem 'coveralls', require: false
+end

data/README.md

@@ -1,68 +1,114 @@
 Configureasy
 =============
 
-A forma mais simples de carregar arquivos de configuração em suas Classe/Módulos.
+[![Build Status](https://travis-ci.org/alexandreprates/configureasy.svg?branch=master)](https://travis-ci.org/alexandreprates/configureasy) [![Coverage Status](https://coveralls.io/repos/alexandreprates/configureasy/badge.svg)](https://coveralls.io/r/alexandreprates/configureasy) [![Inline docs](http://inch-ci.org/github/alexandreprates/configureasy.svg?branch=master)](http://inch-ci.org/github/alexandreprates/configureasy)
 
-## Instalação
+Configureasy is a library for load configs quickly and easily.
 
-Basta adicionar esta linha no seu Gemfile
+## Installation
+
+Add this line to your application's Gemfile:
 
 ```ruby
 gem 'configureasy'
 ```
 
-E entao executar:
+And then execute:
 
     $ bundle
 
-Ou instale manualmente:
+Or install it yourself as:
 
     $ gem install configureasy
 
-## Como usar
+## Usage
 
-Basta incluir na classe e começar a usar
+Load content of <i>config/database.yml</i>
 
 ```ruby
-class Foo
+# in ./config/database.yml
+# host: localhost
+# port: 1234
+
+class DBConfig
   include Configureasy
+  load_config :database
 end
 
-Foo.config.some_key_in_config
-# => 'some value for that key'
+# You can access config values
+DBConfig.database.host # => 'localhost'
+DBConfig.database.port # => 1234
 ```
 
-Por padrão ele busca um arquivo (.yml) no diretório _config_, caso precise especificar um nome diferente utilize o método _config_name_.
+Setting different method name
 
 ```ruby
-class Foo
+# in ./config/user_keys.yml
+# name: secret_key
+# value: secret_key_value
+
+class User
   include Configureasy
-  # load APP_ROOT/config/foo_config.yml
-  config_name :foo_config
+  load_config :user_keys, as: :keys
 end
+
+User.keys.name # => 'secret_key'
+User.keys.value # => 'secret_key_value'
 ```
 
-Caso precise você tambem pode especificar de onde carregar a configuração usando o método _config_filename_.
+Setting different folder
 
 ```ruby
-class Foo
+class Censor
   include Configureasy
-  # load APP_ROOT/.hide_dir/secrets.yml
-  config_filename '.hide_dir/secrets.yml'
+  load_config :forbidden_words, path: './blacklist'
+  # load './blacklist/forbidden_words.yml'
 end
 ```
 
-Caso precise ver o conteúdo original do arquivo utilize o método _raw_content_.
+Configureasy detect per environment configs
 
 ```ruby
-class Foo
+# in ./config/aws.yml
+# development:
+#   access: development_access
+#   secret: development_secret
+# production:
+#   access: production_access
+#   secret: production_secret
+
+class S3Storage
   include Configureasy
+  load_config :aws
+end
+
+# in development
+S3Storage.aws.access # => 'development_access'
+
+# in production
+S3Storage.aws.access # => 'production_access'
+```
+
+You can access config data as Hash
+
+```ruby
+# in ./config/access.yml
+# admin_group: 1
+# user_group: 2
+
+class User
+  require Configureasy
+  load_config :access
 end
 
-Foo.config.raw_content
-# => {'foo' => 'bar'}
+User.access.as_hash
+# => {'admin_group' => '1', 'user_group' => '2'}
 ```
 
-## Duvidas, questões e desconfianças em geral
+## Contributing
 
-mail me: ajfprates@gmail.com
+1. Fork it ( https://github.com/alexandreprates/configureasy/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

@@ -1,2 +1,5 @@
+require 'rspec/core/rake_task'
 require "bundler/gem_tasks"
 
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/configureasy.gemspec

@@ -8,20 +8,12 @@ Gem::Specification.new do |spec|
   spec.version       = Configureasy::VERSION
   spec.authors       = ["Alexandre Prates"]
   spec.email         = ["ajfprates@gmail.com"]
-  spec.summary       = %q{A Simple way to get configs in your Classes/Modules.}
-  spec.description   = %q{A Simple way to get configs in your Classes/Modules.}
-  spec.homepage      = "https://gitlab.ir7.com.br/videos/configureasy"
+  spec.summary       = %q{A Simple way to get configs.}
+  spec.description   = %q{A Simple way to get configs.}
+  spec.homepage      = "https://github.com/alexandreprates/configureasy"
   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{^(spec|features)/})
   spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-
-  spec.add_development_dependency "rspec", "~> 3.1"
-  spec.add_development_dependency "guard", "~> 2.10"
-  spec.add_development_dependency "guard-rspec", "~> 4.5"
 end

data/lib/configureasy.rb

@@ -29,10 +29,11 @@ module Configureasy
   # Class to raise error on invalid config file
   class ConfigInvalid < Exception; end
 
-  def self.included(receiver)
+  def self.included(receiver) # :nodoc:
     receiver.extend Configurable
   end
 end
 
 require 'configureasy/config'
+require 'configureasy/config_parser'
 require 'configureasy/configurable'

data/lib/configureasy/config.rb

@@ -1,15 +1,53 @@
 require 'ostruct'
 
-##
-# Class for store and retrive config values
+# Store data structure (Hash) and allow access values using method calling.
 #
-# Example
-#   >> Confugureasy::Config.new(foo: 'foo').foo
-#   => 'foo'
+#    Confugureasy::Config.new(foo: 'foo').foo
+#    # => 'foo'
 #
+#    Configureasy::Config.new(:foo => {:bar => :value}).foo.bar
+#    # => :value
+#
+# You can access values using [] too
+#
+#    Configureasy::Config.new(foo: 'bar')[:foo]
+#    # => 'bar'
+#
+# Beside you retrive data as hash
+#
+#    Configureasy::Config(foo: 'bar').as_hash
+#    # => {:foo => 'bar'}
 class Configureasy::Config < OpenStruct
-  # return config as hash
-  def raw_content
-    @table
+
+  # Convert a hash data into methods recursively.
+  # Params:
+  #  [+params+]:: Hash with data do convert
+  #
+  # Returns new instance of [Configureasy::Config].
+  def initialize(params = {})
+    @hash = params
+    params = params.inject({}) do |hash, data|
+      key, value = data
+      value = self.class.new(value) if value.is_a? Hash
+      hash.merge key.to_sym => value
+    end
+    super params
+  end
+
+  # Retrive some config value.
+  # Params:
+  #  [+key+]:: name of config
+  #
+  #    Configureasy::Config.new(foo: 'bar')[:foo]
+  #    # => 'bar'
+  #
+  # Returns config value, or nil if can't reach config value.
+  def [](key)
+    self.send key
+  end
+
+  # Returns config as hash.
+  def as_hash
+    @hash
   end
 end

data/lib/configureasy/config_parser.rb

@@ -0,0 +1,58 @@
+require 'yaml'
+
+# Load and parse content of config (YAML).
+# Raise exception if config file not found
+#
+#    parser = Configureasy::ConfigParser.new('./config/config.yml')
+#    # => <# Configureasy::ConfigParser ... >
+#    parser.parse
+#    # => {:hash => :content}
+#
+# Set environment to load specific part of config
+#
+#    parser = Configureasy::ConfigParser.new('./config/environments.yml', 'development')
+#    # => <# Configureasy::ConfigParser ... >
+#    parser.parse
+#    # => {:development => :content}
+class Configureasy::ConfigParser
+  # Get config filename
+  attr_reader :filename
+  # Get environment to load data
+  attr_reader :environment
+
+  # Initialize ConfigParser instance.
+  # Params:
+  #  [+filename+]:: name of config file.
+  #  [+environment+]:: load specific environment config (*optional*).
+  #
+  # <b>If config file not found raise an exeception.</b>
+  #
+  # Returns instance of [Configureasy::ConfigParser]
+  def initialize(filename, environment = nil)
+    raise "Config #{filename} not found" unless File.exist? filename
+    @filename = filename
+    @environment = environment || current_environment
+  end
+
+  # Returns config content
+  def parse
+    content = YAML.load_file(filename)
+    content.has_key?(self.environment) ? content[self.environment] : content
+  rescue
+    raise "Invalid config content for #{filename}"
+  end
+
+  # Returns config content as [Configureasy::Config]
+  def as_config
+    Configureasy::Config.new self.parse
+  end
+
+  private
+
+  # Gets the current environment.
+  # Returns current environment as string. If environment is not set returns 'development'
+  def current_environment
+    ENV['RUBY_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+  end
+
+end

data/lib/configureasy/configurable.rb

@@ -1,57 +1,72 @@
 require 'yaml'
 
+# Allows loading of different configuration files.
+#
+#    class Dumb
+#      include Configureasy
+#
+#      # create class method _config_ with content of config/config.yml
+#      load_config :config
+#
+#      # create class method _secrets_ with content for config/session_secrets.yml
+#      load_config :session_secrets, as: :secrets
+#
+#      # create class method _aws_keys_ with content for './aws/keys.yml'
+#      load_config :keys, as: :aws_keys, path: './aws'
+#    end
 module Configureasy::Configurable
-  # Setting config file name
-  #
-  # Example
-  #   config_name :foo
-  #   => APP_ROOT/config/foo.yml
-  #
-  #   config_name :bar
-  #   => APP_ROOT/config/bar.yml
-  #
-  def config_name(name = nil)
-    @config_name = name if name
-    @config_name || self.name.downcase
-  end
-
-  def config_filename(filename = nil)
-    @config_filename = File.expand_path filename if filename
-    @config_filename || File.expand_path("./config/#{config_name}.yml")
-  end
+  @@configurables = {}
 
-  # Load the config yaml and return Configureasy::Config instance
-  def config
-    @config ||= load_configs
+  # dinamically create method for access config data.
+  # Params:
+  #  [+file_basename+]:: config file name (by default in *config* directory)
+  #  [+as+]:: generated method name (by default same as file_basename)
+  #  [+path+]:: config path (by default './config')
+  def load_config(file_basename, options = {})
+    name = options[:as] || file_basename
+    path = options[:path] || './config'
+    filename = File.join path, "#{file_basename}.yml"
+    self.class.send(:define_method, name)              { _configurable_for(filename) }
+    self.class.send(:define_method, "#{name}_reload!") { _configurable_reload(filename) }
   end
 
-  # Looks for config file an return true if file exists
-  def have_config?
-    File.exist? config_filename
+  # @deprecated Please use {#load_config} instead.
+  # Setting config source filename.
+  # Params:
+  #  [+name+]:: the name of config file
+  #
+  #    # load contents for ./config/foo.yml
+  #    config_name :foo
+  #
+  #    # load contents for ./config/bar.yml
+  #    config_name :bar
+    def config_name(name = nil)
+    warn "[DEPRECATION] `config_name` is deprecated.  Please use `load_config` instead."
+    load_config name, as: 'config'
   end
 
-  # Reload configs
-  def reset_config!
-    @config = nil
-    config
+  # @deprecated Please use {#load_config} instead.
+  # Load config in specific location.
+  # Params
+  #  [+filename+]:: config filename
+  #
+  #    # load contents for /etc/my_configs.yml
+  #    config_filename '/etc/my_configs.yml'
+  def config_filename(filename = nil)
+    warn "[DEPRECATION] `config_filename` is deprecated.  Please use `load_config` instead."
+    basename = File.basename(filename, '.yml')
+    path = File.dirname(filename)
+    load_config basename, as: 'config', path: path
   end
 
   private
 
-  def load_configs
-    configs_hash = parse_configs
-    raise Configureasy::ConfigInvalid, "invalid config file '#{config_filename}'", caller unless configs_hash.is_a? Hash
-
-    Configureasy::Config.new configs_hash[_current_env] || configs_hash
-  end
-
-  def parse_configs
-    raise Configureasy::ConfigNotFound, "file not found '#{config_filename}'", caller unless have_config?
-    YAML.load_file config_filename
+  def _configurable_for(filename) # :nodoc:
+    @@configurables[filename.to_sym] || _configurable_reload(filename)
   end
 
-  def _current_env
-    ENV['RAILS_ENV'] || ENV['RUBY_ENV'] || ENV['RACK_ENV'] || 'development'
+  def _configurable_reload(filename) # :nodoc:
+    @@configurables[filename.to_sym] = Configureasy::ConfigParser.new(filename).as_config
   end
 
 end

data/lib/configureasy/version.rb

@@ -1,3 +1,3 @@
 module Configureasy
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/spec/lib/configureasy/config_parser_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Configureasy::ConfigParser do
+  describe '.new' do
+    before(:each) do
+      allow(File).to receive(:exist?) { true }
+      allow(ENV).to receive(:[]) { nil }
+    end
+
+    it "check if filename exists" do
+      expect(File).to receive(:exist?).with('missing_config.yml') { false }
+      expect { described_class.new('missing_config.yml') }.to raise_error "Config missing_config.yml not found"
+      expect(File).to receive(:exist?).with('missing_config.yml') { true }
+      expect(described_class.new 'missing_config.yml').to be_instance_of described_class
+    end
+
+    it "set environment to load data" do
+      allow(File).to receive(:exist?) { true }
+      expect(described_class.new('config.yml', 'stage').environment).to eq 'stage'
+    end
+
+    it "get RUBY_ENV" do
+      allow(ENV).to receive(:[]).with('RUBY_ENV') { 'ruby_env' }
+      expect(described_class.new('config.yml').environment).to eq 'ruby_env'
+    end
+
+    it "get RAILS_ENV" do
+      allow(ENV).to receive(:[]).with('RAILS_ENV') { 'rails_env' }
+      expect(described_class.new('config.yml').environment).to eq 'rails_env'
+    end
+
+    it "get RACK_ENV" do
+      allow(ENV).to receive(:[]).with('RACK_ENV') { 'rack_env' }
+      expect(described_class.new('config.yml').environment).to eq 'rack_env'
+    end
+  end
+
+  describe '#parse' do
+    it "return content of yml" do
+      allow(File).to receive(:exist?) { true }
+      allow(YAML).to receive(:load_file) { {'yaml' => 'content'} }
+      expect(described_class.new('config.yml').parse).to eq({'yaml' => 'content'})
+    end
+    it 'return config for environment' do
+      allow(File).to receive(:exist?) { true }
+      allow(YAML).to receive(:load_file) { {'development' => 'wrong', 'test' => 'wrong', 'stage' => 'correct'} }
+      allow(ENV).to receive(:[]).with('RUBY_ENV') { 'stage' }
+      expect(described_class.new('config.yml').parse).to eq('correct')
+    end
+  end
+
+  describe '#as_config' do
+    it 'return config as Configureasy::Config' do
+      allow(File).to receive(:exist?) { true }
+      allow(YAML).to receive(:load_file) { {'yaml' => 'content'} }
+      expect(described_class.new('config.yml').as_config).to be_instance_of Configureasy::Config
+    end
+  end
+
+end

data/spec/lib/configureasy/config_spec.rb

@@ -1,13 +1,24 @@
 require 'spec_helper'
 
 describe Configureasy::Config do
-  describe ".new" do
-    it "should store key/value as methods" do
-      expect(Configureasy::Config.new(foo: 'bar').foo).to eq('bar')
+  let(:values) { {'first_level' => {'second_level' => 'second_level_value'}, 'single_level' => 'single_level_value'} }
+  let(:config) { described_class.new(values) }
+  describe '.new' do
+    it 'convert multi level hash' do
+      expect(config.first_level.second_level).to eq 'second_level_value'
     end
   end
 
-  describe "#as_hash" do
+  describe '#[]' do
+    it 'return value for a key' do
+      expect(config[:single_level]).to eq 'single_level_value'
+    end
+  end
 
+  describe '#.as_hash' do
+    it "return raw content" do
+      expect(config.as_hash).to eq values
+    end
   end
+
 end

data/spec/lib/configureasy/configurable_spec.rb

@@ -1,81 +1,72 @@
 require 'spec_helper'
 
-class Foo
-  extend Configureasy::Configurable
-end
-
 describe Configureasy::Configurable do
-  describe ".config_name" do
-    it "by default config name is class name" do
-      expect(Foo.config_name).to eq('foo')
+  before(:each) do
+    allow(File).to receive(:exist?) { true }
+    allow(YAML).to receive(:load_file) { {'works' => 'true'} }
+  end
+
+  describe '.load_config' do
+    let(:dumb_class) do
+      Class.new do
+        extend Configureasy::Configurable
+        load_config :dumb_config
+        load_config :another_config
+      end
     end
 
-    it "changes config name" do
-      expect(Foo.config_name).to eq('foo')
-      Foo.config_name "bar"
-      expect(Foo.config_name).to eq('bar')
+    it 'dynamically generate methods' do
+      expect(dumb_class).to respond_to :dumb_config
     end
 
-    it "config name reflects on config_filename" do
-      Foo.config_name "other_conf"
-      expect(Foo.send :config_filename).to match(/other_conf\.yml$/)
+    it 'support more than one config' do
+      expect(dumb_class).to respond_to :another_config
     end
-  end
 
-  describe '.config_filename' do
-    it "set config filename" do
-      Foo.config_filename '.hidedir/secret_config.yml'
-      expect(Foo.config_filename).to end_with('.hidedir/secret_config.yml')
+    it 'return ConfigParser content' do
+      expect(dumb_class.dumb_config.works).to eq 'true'
     end
   end
 
-  describe '#config' do
-    let(:yaml_content) { {'development' => {'foo' => 'bar'}, 'test' => {'foo' => 'test'} } }
-
-    it "raise excepion when file missing" do
-      expect { Foo.config }.to raise_exception Configureasy::ConfigNotFound
+  describe '.config_reload!' do
+    let(:dumb_class) do
+      Class.new do
+        extend Configureasy::Configurable
+        load_config :config
+      end
     end
 
-    it "raise exception when file content is not valid yaml" do
-      allow(YAML).to receive(:load_file).and_return("wrong yaml content")
-      allow(File).to receive(:exist?).and_return(true)
-
-      expect { Foo.config }.to raise_exception Configureasy::ConfigInvalid
+    it 'reloading config file content' do
+      expect(dumb_class.config).not_to be dumb_class.config_reload!
     end
+  end
 
-    it "access values on config file" do
-      allow(YAML).to receive(:load_file).and_return(yaml_content)
-      allow(File).to receive(:exist?).and_return(true)
-
-      expect(Foo.config).to respond_to(:foo)
-      expect(Foo.config.foo).to eq('bar')
+  describe '.config_name' do
+    let(:dumb_class) do
+      Class.new do
+        extend Configureasy::Configurable
+        config_name :deprecated
+      end
     end
 
-    it "load contend for current environment" do
-      allow(YAML).to receive(:load_file).and_return(yaml_content)
-      allow(File).to receive(:exist?).and_return(true)
-
-      ENV['RUBY_ENV'] = 'development'
-      expect(Foo.reset_config!.foo).to eq('bar')
-
-      ENV['RUBY_ENV'] = 'test'
-      expect(Foo.reset_config!.foo).to eq('test')
-
-      ENV['RUBY_ENV'] = nil
-
-      ENV['RACK_ENV'] = 'development'
-      expect(Foo.reset_config!.foo).to eq('bar')
-      ENV['RACK_ENV'] = nil
-
-      ENV['RAILS_ENV'] = 'test'
-      expect(Foo.reset_config!.foo).to eq('test')
+    it "load config content into config method" do
+      expect(dumb_class).to respond_to :config
+      expect(dumb_class.config.works).to eq('true')
     end
+  end
 
-    it "config is kind of Configs class" do
-      allow(YAML).to receive(:load_file).and_return(yaml_content)
-      allow(File).to receive(:exist?).and_return(true)
+  describe '.config_filename' do
+    let(:dumb_class) do
+      Class.new do
+        extend Configureasy::Configurable
+        config_filename './deprecated/feature.yml'
+      end
+    end
 
-      expect(Foo.config).to be_kind_of(Configureasy::Config)
+    it "load config with filename into config method" do
+      expect(dumb_class).to respond_to :config
+      expect(dumb_class.config.works).to eq('true')
     end
   end
+
 end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
 require './lib/configureasy'
+require 'coveralls'
+Coveralls.wear!
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true

metadata

@@ -1,93 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: configureasy
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Alexandre Prates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-- !ruby/object:Gem::Dependency
-  name: guard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.10'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.5'
-description: A Simple way to get configs in your Classes/Modules.
+date: 2015-03-08 00:00:00.000000000 Z
+dependencies: []
+description: A Simple way to get configs.
 email:
 - ajfprates@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".coveralls.yml"
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -96,13 +28,15 @@ files:
 - configureasy.gemspec
 - lib/configureasy.rb
 - lib/configureasy/config.rb
+- lib/configureasy/config_parser.rb
 - lib/configureasy/configurable.rb
 - lib/configureasy/version.rb
+- spec/lib/configureasy/config_parser_spec.rb
 - spec/lib/configureasy/config_spec.rb
 - spec/lib/configureasy/configurable_spec.rb
 - spec/lib/configureasy_spec.rb
 - spec/spec_helper.rb
-homepage: https://gitlab.ir7.com.br/videos/configureasy
+homepage: https://github.com/alexandreprates/configureasy
 licenses:
 - MIT
 metadata: {}
@@ -125,8 +59,9 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: A Simple way to get configs in your Classes/Modules.
+summary: A Simple way to get configs.
 test_files:
+- spec/lib/configureasy/config_parser_spec.rb
 - spec/lib/configureasy/config_spec.rb
 - spec/lib/configureasy/configurable_spec.rb
 - spec/lib/configureasy_spec.rb