has_config 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ff4a936f1e2bb34db9f906368df5cc8e1933f03
-  data.tar.gz: f29d5a2372cc3ca6abecf6d4d0fc543467f94ca2
+  metadata.gz: 467718d32a9ceae8d77b03f88c69871653fae7c3
+  data.tar.gz: 2e83f05c531b9e6b0acb65ae67304759bb0c32c9
 SHA512:
-  metadata.gz: 9154daeeedbc0ca628ab5e3a2ee87a6685eef73a492f35ebdefec323f13d69cfff7524c2845d203da3a77826ae3e7974c4be90765f93d031edd02afa9a994783
-  data.tar.gz: 57b678e8f2e67a71139e884c236b9c0027189c6fe1fa83dc9f9abc4bca8bd23419e492e4fda12a94753112fbe418d148e42955ea94692822423882c05ea5478d
+  metadata.gz: 5af26b5b82655f08dd09cd21479e41da734e197289506a9de50fee7cc47232d192ecce3d8fe3e0a00590bc3059379b3589836d30bb326763a41d225c889a013f
+  data.tar.gz: 4f9ad634b7cd92dcf96c6bcabd13b718d98e6b4b6dfd82100bce8b32f96ec2dab25cc899a40d5c50101a6983673cf06a208e5bbd5a1845ae00aea6bd124abca1

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+---
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- test/

data/.rubocop.yml

@@ -0,0 +1,18 @@
+AllCops:
+  Exclude:
+    - test/**/*
+
+Metrics/LineLength:
+  Max: 120
+
+MethodLength:
+  Max: 20
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/PredicateName:
+  Enabled: false

data/.travis.yml

@@ -3,12 +3,22 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
+  - 2.3.1
 gemfile:
   - gemfiles/4.0.gemfile
   - gemfiles/4.1.gemfile
   - gemfiles/4.2.gemfile
+  - gemfiles/5.0.gemfile
+matrix:
+  exclude:
+    - rvm: 2.0
+      gemfile: gemfiles/5.0.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/5.0.gemfile
+    - rvm: 2.2
+      gemfile: gemfiles/5.0.gemfile
 addons:
-  postgresql: '9.3'
+  postgresql: '9.4'
 before_script:
   - psql -c 'create database has_config_test;' -U postgres
 script:

data/CHANGELOG.md

@@ -1,3 +1,10 @@
-## 0.1.0 (6/20/2015)
+## 0.2.0 (2016-08-20)
+
+* Full rewrite (Imported code from https://github.com/t27duck/cerulean)
+* Allow predefined settings in a configuration file
+* Allow chaining from models of the same setting
+* Removed grouping functionality
+
+## 0.1.0 (2015-06-20)
 
 * Initial release

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in has_config.gemspec
 gemspec
+
+gem 'codeclimate-test-reporter', require: nil

data/README.md

@@ -1,12 +1,18 @@
 # HasConfig
 
 [![Build Status](https://travis-ci.org/t27duck/has_config.svg?branch=master)](https://travis-ci.org/t27duck/has_config)
+[![Code Climate](https://codeclimate.com/github/t27duck/has_config/badges/gpa.svg)](https://codeclimate.com/github/t27duck/has_config)
+[![Test Coverage](https://codeclimate.com/github/t27duck/has_config/badges/coverage.svg)](https://codeclimate.com/github/t27duck/has_config/coverage)
 
-Tested against Ruby 2.0 - 2.2 with ActiveRecord 4.0 - 4.2
+When working with models in a large Rails project, you sometimes end up with "god objects" which start to be loaded down with several booleans, integers, and strings from select boxes that act as configuration options. As time goes on, you add more and more columns. As your database and user-base grows, adding even a single column more can bring your app to a hang during a deploy due to table locking or a slew of exceptions due to [issues and gotchas like this](https://github.com/rails/rails/issues/12330).
 
-When working with models in a large Rails project, you sometimes end up with "god objects" which start to be loaded down with several booleans, integers, and strings from select boxes that act as configuration options. As time goes on, you add more and more columns. As your database and user-base grows, adding even a single column more can bring your app to a hault during a deploy due to table locking or a slew of exceptions due to [issues and gotchas like this](https://github.com/rails/rails/issues/12330).
+In an attempt to cut down on cluttering your model with boolean columns, `has_config` allows you to have a single column contain all configuration switches you could ever want. Adding another configuration option to a model no longer requires a migration to add a column. You can also continue writing code as if the model had all of those individual attributes.
 
-In an attempt to cut down on cluttering your model with boolean columns, `has_config` allows you to have a single column contain all configuration switches you could ever want. Adding another configuration option to a model no longer requires a migration to add a column. You can also contiue writing code as if the model had all of those indiviual attributes.
+## Requirements
+
+Supported Rubies: 2.0, 2.1, 2.2, 2.3
+
+Supported versions of ActiveRecord: 4.0, 4.1, 4.2, 5.0
 
 ## Installation
 
@@ -34,54 +40,47 @@ class AddConfigurationToClients < ActiveRecord::Migration
 end
 ```
 
-We now want to make that column a serialized hash in our model and include the `HasConfig` module.
+We now want to make that column a serialized hash in our model and include the `HasConfig::ActiveReocrd::ModelAdapter` module.
 
 ```ruby
 class Client < ActiveRecord::Base
   serialize :configuration, Hash
-  include HasConfig
+  include HasConfig::ActiveRecord::ModelAdapter
 end
 ```
 
-If you are using PostgreSQL 9.2 or later, you can use the JSON data-type for the configuration column and not have to declare it as a serilaized attribute in the model as `ActiveRecord` will take care of that for you.
+If you are using PostgreSQL 9.2 or later, you can use the JSON or JSONB (if using Rails 4.2 or later) data-type for the configuration column and not have to declare it as a serilaized attribute in the model as `ActiveRecord` will take care of that for you.
 
-If you want to use a different column name, you may override the default by setting `self.configuration_column = 'other_column_name'` in the model.
-
-Finally, we're going to tell our model what configuration it'll hold. We do this via the `has_config` method the module provides. For now, here's a sensory overload example. We'll go into detail in the next part.
+If you want to use a different column name, you may override the default by setting `self.has_config_configuration_column = 'other_column_name'` in the model.
 
 ```ruby
 class Client < ActiveRecord::Base
   serialize :configuration, Hash
-  include HasConfig
-  has_config :primary_color, :string, default: 'green', group: :style
-  has_config :secondary_color, :string, group: :style
-  has_config :rate_limit, :integer, validations: { numericality: { only_integer: true } }
-  has_config :category, :string, validations: { inclusion: { in: CATEGORIES } }
-  has_config :active, :boolean, default: false
+  include HasConfig::ActiveRecord::ModelAdapter
+  has_config :primary_color, config: { type: :string, default: 'green' }
+  has_config :secondary_color, config: { type: :string }
+  has_config :rate_limit, config: { type: :integer, validations: { numericality: { only_integer: true } } }
+  has_config :category, config: { type: :string, validations: { inclusion: { in: CATEGORIES } } }
+  has_config :active, config: { type: :boolean, default: false }
 end
 ```
+The `has_config` method is the primary interface for adding a setting to a model. The first argument is a symbol that represents the name of the setting.
 
-Let's look at the `has_config` signature first before we go any further:
-
-```ruby
-  has_config(key, type, default:nil, group:nil, validations:{})
-```
-
-At minimum, you must provide a `key` and `type`. The `key` is what you'll call this configuraiton item. The `type` can be either `:string`, `:integer`, or `:boolean`.
+The `config` key is a hash that contains information describing your setting. The `type` is the only required key when including the `config` option.
 
-If a configuration item doesn't have a value, `nil` is returned by default. Or, you may provide your own default value with the `default` option.
+`type` is the datatype of your setting. Valid options are `string`, `integer`, and `boolean`.
 
-If you have a series of configuraiton items are are related, you can organize them together with the `group` option.
+`default` is the value that will be used if the record does not have this setting set. If no `default` is provided, `nil` will be used.
 
-To the app, each configuraiton item is like a pseudo attribute on the model. Modle attributes can have validations. Use the `validations` option to pass in a hash of options you'd normally pass into the `validates` method for a regular attribute on the model.
+`validations` allows the setting to use the standard ActiveRecord validations you'd use for any regular attribute.
 
 Ok, still with me? Back to our example...
 
 Here, the `Client` model has five configuration items on it: `primary_color`, `secondary_color`, `rate_limit`, `category`, and `active`. So, knowing what you just learned above...
 
-`primary_color` is a string with a default value of green and grouped in the "style" group of configuration options.
+`primary_color` is a string with a default value of "green".
 
-`secondary_color` is a string without a default. It too is in the "style" group.
+`secondary_color` is a string without a default.
 
 `rate_limit` is an integer that validates its value is in fact, an integer.
 
@@ -115,21 +114,118 @@ client.errors.full_messages
 
 Everything acts pretty much as you'd expect it too do. Configurations that fail validations make the record invalid. Passing in '1', 'true', `true`, etc casts boolean values. Passing in an empty string for an integer config casts as `nil`.
 
-Finally, you can access all configuration values under a specific group with the `configuration_for_group` method.
+## Chaining with other models with the same setting
+
+Let's say you have a `Client` model, a `Group` model, and a `User` model. A client has many groups and a group can have many users. A client can have configuration which globally affects all users; however, a group setting of the same name could override the global setting. HasConfig can handle this with relative ease.
+
+First, let's set up the models
+
+```ruby
+class Client < ActiveRecord::Base
+  has_many :groups
+  # ...
+  has_config :some_setting, config: { type: :integer, default: 3 }
+end
+
+
+class Group < ActiveRecord::Base
+  belongs_to :client
+  has_many :users
+
+  # ...
+  has_config :some_setting, config: { type: :integer }, parent: :client
+end
+````
+
+This introduces a new option for the `has_config` method: `parent`. The `parent` option specifies a method `HasConfig` can use to defer the setting value to another object.
+
+Assume we have a client and a group stored in our database:
 
 ```irb
-client.configuration_for_group(:style)
-=> {primary_color: 'green', secondary_color: nil}
+g = Group.first
+=> #<Group ...>
+g.client
+=> <#Client ...>
+g.some_setting
+=> nil
+g.some_setting(:resolve)
+=> 3
+g.some_setting = 1
+=> 1
+g.some_setting(:resolve)
+=> 1
+g.some_setting = nil
+=> nil
+g.some_setting(:resolve)
+=> 3
+```
+
+See what happened? Note the subtle change in how we reference the stting?
+
+When we pass the symbol `:resolve` into the setting's getter method, and is blank, we will defer to the setting in the parent (in this case, `Client`) and use that value. If you do not pass `:resolve` in the getter, the local value will be used.
+
+By default, `HasConfig` will go up the chain if the child model's value is `blank` (from `ActiveSupport`'s `blank?` method).
+
+You can chain as deep as you want as long as the object returned from `parent` includes a setting of the same name as the child. Meaning, your `User` model can chain `some_setting` up to `group` which can chain up to `client`.
+
+You do have some control over when `HasConfig` invokes the change via the `chain_on` option for the setting's config:
+
+```ruby
+# Chain will be invoked if the local value is `nil`
+has_config :setting1, config: { type: :string, chain_on: :nil }, parent: :some_method
+
+# Chain will be invoked if the local value is `false`
+has_config :setting2, config: { type: :string, chain_on: :false }, parent: :some_other_method
 ```
 
-## Testing
+## Configuration file
+
+An alternative to defining the definition of each setting in your model is to put them in a centralized configuration file.
+
+Giving a file located at `#{Rails.root}/config/has_config.rb`:
 
-Tests run using a PostgreSQL database called `has_config_test`. You should be able to just create a database named that and run `bundle exec rake test`.
+```ruby
+has_config :primary_color, config: { type: :string, default: 'green' }
+has_config :secondary_color, config: { type: :string }
+has_config :rate_limit, config: { type: :integer, validations: { numericality: { only_integer: true } } }
+has_config :category, config: { :string, validations: { inclusion: { in: CATEGORIES } } }
+has_config :active, config: { type: :boolean, default: false }
+````
+
+... and then somewhere in your app, call `HasConfig::Engine.load` (There's an optional `path:` argument to specify a different file path)
+
+This will load up pre-configured setting information in your app. You can then just refer to each setting by name in your model:
+
+```ruby
+class Client < ActiveRecord::Base
+  serialize :configuration, Hash
+  include HasConfig::ActiveRecord::ModelAdapter
+  has_config :primary_color
+  has_config :secondary_color
+  has_config :rate_limit
+  has_config :category
+  has_config :active
+end
+```
+
+You can also override the `default` and `validations` options for a pre-defined config:
+
+```ruby
+has_config :primary_color, config: { default: 'custom_value_unique_to_this_model' }
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/has_config/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
+Bug reports and pull requests are welcome on GitHub at https://github.com/t27duck/has_config.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -1,20 +1,19 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 
 task default: :test
 
-require "rake/testtask"
+require 'rake/testtask'
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  #t.pattern = "test/**/*_test.rb"
-  t.pattern = "test/test*.rb"
+  t.pattern = 'test/**/*_test.rb'
 end
 
-desc "Run a console with the environment loaded"
+desc 'Run a console with the environment loaded'
 task :console do
   require 'has_config'
 
-require 'active_record'
-require 'pg'
+  require 'active_record'
+  require 'pg'
   require 'irb'
   require 'irb/completion'
   ARGV.clear

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "has_config"
+require 'bundler/setup'
+require 'has_config'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "has_config"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/gemfiles/4.0.gemfile

@@ -1,5 +1,6 @@
 source "https://rubygems.org"
 
 gem "activerecord", "~> 4.0.0"
+gem "codeclimate-test-reporter", group: :test, require: nil
 
 gemspec :path=>"../"

data/gemfiles/4.1.gemfile

@@ -1,5 +1,6 @@
 source "https://rubygems.org"
 
 gem "activerecord", "~> 4.1.0"
+gem "codeclimate-test-reporter", group: :test, require: nil
 
 gemspec :path=>"../"

data/gemfiles/4.2.gemfile

@@ -1,5 +1,6 @@
 source "https://rubygems.org"
 
 gem "activerecord", "~> 4.2.0"
+gem "codeclimate-test-reporter", group: :test, require: nil
 
 gemspec :path=>"../"

data/gemfiles/5.0.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.0.0"
+gem "codeclimate-test-reporter", group: :test, require: nil
+
+gemspec :path=>"../"

data/has_config.gemspec

@@ -4,27 +4,30 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'has_config/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "has_config"
+  spec.name          = 'has_config'
   spec.version       = HasConfig::VERSION
-  spec.authors       = ["Tony Drake"]
-  spec.email         = ["t27duck@gmail.com"]
+  spec.authors       = ['Tony Drake']
+  spec.email         = ['t27duck@gmail.com']
 
-  spec.summary       = %q{Quick record-specific configuration for your models}
+  spec.summary       = 'Quick record-specific configuration for your models'
   spec.description   = <<-DESC
     Allows you to include and organize configuration options for each record in
     a model without the need of complex joins to settings tables or constantly
     adding random boolean and string columns
   DESC
-  spec.homepage      = "http://github.com/t27duck/has_config"
-  spec.license       = "MIT"
+  spec.homepage      = 'http://github.com/t27duck/has_config'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "activerecord", ">= 4.0"
-  spec.add_development_dependency "pg"
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'activerecord', '>= 4.0'
+  spec.add_development_dependency 'activesupport', '>= 4.0'
+  spec.add_development_dependency 'pg'
 end

data/lib/has_config.rb

@@ -1,93 +1,11 @@
-require "has_config/version"
+require 'has_config/version'
+require 'has_config/errors'
+require 'has_config/configuration'
+require 'has_config/value_parser'
+require 'has_config/chain'
+require 'has_config/engine'
+require 'has_config/active_record/processor'
+require 'has_config/active_record/model_adapter'
 
 module HasConfig
-  def self.included(base)
-    base.extend ClassMethods
-  end
-
-  def configuration_for_group(group_name)
-    group_config = {}
-    (self.class.configuration_groups[group_name.to_s] || {}).each do |config_name|
-      group_config[config_name.to_sym] = public_send(config_name)
-    end
-    group_config
-  end
-
-  module ClassMethods
-    def has_config(key, type, default:nil, group:nil, validations:{})
-      raise ArgumentError, "Invalid type #{type}" unless [:string, :integer, :boolean].include?(type)
-
-      define_configuration_getter(key, default, type == :boolean)
-      define_configuration_setter(key, type)
-      set_configuration_group(key, group) if group.present?
-      set_configuration_validations(key, validations) if validations.present?
-    end
-
-    def configuration_groups
-      @configuration_groups ||= {}
-    end
-
-    def configuration_column
-      @configuration_column ||= 'configuration'
-    end
-
-    def configuration_column=(column_name)
-      @configuration_column = column_name.to_s
-    end
-
-    private ####################################################################
-
-    def define_configuration_getter(key, default, include_boolean=false)
-      define_method(key) do
-        config = (attributes[self.class.configuration_column] || {})
-        config[key.to_s].nil? ? default : config[key.to_s]
-      end
-
-      if include_boolean
-        define_method("#{key}?") do
-          config = (attributes[self.class.configuration_column] || {})
-          config[key.to_s].nil? ? default : config[key.to_s]
-        end
-      end
-    end
-
-    def define_configuration_setter(key, type)
-      define_method("#{key}=") do |input|
-        config = (attributes[self.class.configuration_column] || {})
-        original_value = config[key.to_s]
-        parsed_value = nil
-
-        if !input.nil?
-          parsed_value = case type
-          when :string
-            input.to_s
-          when :integer
-            input.present? ? input.to_i : nil
-          when :boolean
-            ([true,1].include?(input) || input =~ (/(true|t|yes|y|1)$/i)) ? true : false
-          end
-        end
-
-        if original_value != parsed_value
-          config[key.to_s] = parsed_value
-          write_attribute(self.class.configuration_column, config)
-          public_send("#{self.class.configuration_column}_will_change!")
-        end
-
-        input
-      end
-    end
-
-    def set_configuration_group(key, group)
-      @configuration_groups ||= {}
-      @configuration_groups[group.to_s] ||= []
-      @configuration_groups[group.to_s] << key.to_s
-    end
-
-    def set_configuration_validations(key, validation_config)
-      validates key, validation_config
-    end
-
-  end
-
 end

data/lib/has_config/active_record/model_adapter.rb

@@ -0,0 +1,68 @@
+module HasConfig
+  module ActiveRecord
+    module ModelAdapter
+      DEFAULT_CONFIGURATION_COLUMN = 'configuration'.freeze
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def has_config_processor
+        @has_config_processor ||= HasConfig::ActiveRecord::Processor.new(self)
+      end
+
+      module ClassMethods
+        def has_config(key, parent: nil, config: {})
+          configuration = HasConfig::Engine.known_configurations[key.to_sym]
+          if config.present?
+            configuration = if configuration.nil?
+                              HasConfig::Configuration.new(key.to_sym, config)
+                            else
+                              HasConfig::Configuration.modify(configuration, config)
+                            end
+          end
+          raise HasConfig::UnknownConfig, "Unknown config #{key}" if configuration.nil?
+
+          define_has_config_getter(configuration, parent: parent)
+          define_has_config_setter(configuration)
+          apply_has_config_validations(configuration)
+        end
+
+        def has_config_configuration_column
+          @has_config_configuration_column ||= DEFAULT_CONFIGURATION_COLUMN
+        end
+
+        def has_config_configuration_column=(column_name)
+          @has_config_configuration_column = column_name.to_s
+        end
+
+        private ################################################################
+
+        def define_has_config_getter(configuration, parent: nil)
+          define_method(configuration.name) do |mode = :none|
+            has_config_processor.fetch(configuration, parent: parent, mode: mode)
+          end
+
+          if configuration.type == :boolean
+            define_method("#{configuration.name}?") do |mode = :none|
+              public_send(configuration.name, mode)
+            end
+          end
+        end
+
+        def define_has_config_setter(configuration)
+          define_method("#{configuration.name}=") do |value|
+            has_config_processor.set(configuration, value)
+            value
+          end
+        end
+
+        def apply_has_config_validations(configuration)
+          [configuration.validations].flatten.each do |validation|
+            validates configuration.name, validation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/has_config/active_record/processor.rb

@@ -0,0 +1,60 @@
+module HasConfig
+  module ActiveRecord
+    class Processor
+      def initialize(model)
+        @model = model
+      end
+
+      def fetch(configuration, parent: nil, mode: :none)
+        local = local_value(has_config_column_data, configuration)
+
+        if parent && mode == :resolve && HasConfig::Chain.invoke?(local, configuration.chain_on)
+          check_chain(configuration, parent)
+          parent_value = @model.public_send(parent).public_send(configuration.name, :resolve)
+          return parent_value unless parent_value.blank?
+        end
+
+        local
+      end
+
+      def set(configuration, value)
+        data          = has_config_column_data
+        parsed_value  = HasConfig::ValueParser.parse(value, configuration.type)
+
+        if data[configuration.name] != parsed_value
+          data[configuration.name] = parsed_value
+          @model.send(:write_attribute, has_config_column, data)
+          @model.public_send("#{has_config_column}_will_change!")
+        end
+      end
+
+      private ##################################################################
+
+      def has_config_column
+        @model.class.has_config_configuration_column
+      end
+
+      def has_config_column_data
+        @model.attributes[has_config_column] || {}
+      end
+
+      def local_value(data, configuration)
+        if data[configuration.name].nil?
+          configuration.default
+        else
+          data[configuration.name]
+        end
+      end
+
+      def check_chain(configuration, parent)
+        unless @model.respond_to?(parent)
+          raise HasConfig::InvalidChain, "#{parent} is not available on this model"
+        end
+
+        unless @model.public_send(parent).respond_to?(configuration.name)
+          raise HasConfig::InvalidChain, "#{configuration.name} not available on #{parent}"
+        end
+      end
+    end
+  end
+end

data/lib/has_config/chain.rb

@@ -0,0 +1,14 @@
+module HasConfig
+  class Chain
+    def self.invoke?(value, chain_on)
+      case chain_on
+      when :blank
+        value.blank?
+      when :nil
+        value.nil?
+      when :false
+        value == false
+      end
+    end
+  end
+end

data/lib/has_config/configuration.rb

@@ -0,0 +1,45 @@
+module HasConfig
+  class Configuration
+    CHAINING_OPTIONS  = %i(blank nil false).freeze
+    MODIFIABLE_ATTRS  = %i(chain_on default validations).freeze
+    VALID_TYPES       = %i(string integer boolean).freeze
+
+    attr_reader :name, :type
+    attr_accessor(*MODIFIABLE_ATTRS)
+
+    def self.modify(configuration, config)
+      configuration = configuration.dup
+      MODIFIABLE_ATTRS.each do |key|
+        configuration.public_send("#{key}=", config[key]) if config.key?(key)
+      end
+      configuration.validate
+      configuration
+    end
+
+    def initialize(name, type: nil, default: nil, validations: [], chain_on: :blank)
+      raise InvalidType, 'Type is required' if type.nil?
+
+      @chain_on     = chain_on.to_sym
+      @default      = default
+      @name         = name.to_s
+      @type         = type.to_sym
+      @validations  = [validations].flatten
+      validate
+    end
+
+    def validate
+      validate_configuration
+      validate_chain_on
+    end
+
+    private ####################################################################
+
+    def validate_configuration
+      raise InvalidType, "Invalid type #{type}" unless VALID_TYPES.include?(type)
+    end
+
+    def validate_chain_on
+      raise InvalidChainOption, "Invalid chainning option: #{chain_on}" unless CHAINING_OPTIONS.include?(chain_on)
+    end
+  end
+end

data/lib/has_config/engine.rb

@@ -0,0 +1,27 @@
+module HasConfig
+  class Engine
+    class ConfigurationFileReader
+      def has_config(name, config: {})
+        Engine.register_configuration Configuration.new(name, config)
+      end
+    end
+
+    def self.known_configurations
+      @known_configurations ||= {}
+    end
+
+    def self.load(path: 'config/has_config.rb')
+      raise ConfigurationFileNotFound, "No such file '#{path}'" unless File.exist?(path)
+      clear_configurations
+      ConfigurationFileReader.new.instance_eval(File.read(path))
+    end
+
+    def self.register_configuration(configuration)
+      known_configurations[configuration.name.to_sym] = configuration
+    end
+
+    def self.clear_configurations
+      @known_configurations = {}
+    end
+  end
+end

data/lib/has_config/errors.rb

@@ -0,0 +1,7 @@
+module HasConfig
+  ConfigurationFileNotFound = Class.new(StandardError)
+  InvalidChainOption        = Class.new(StandardError)
+  InvalidChain              = Class.new(StandardError)
+  InvalidType               = Class.new(StandardError)
+  UnknownConfig             = Class.new(StandardError)
+end

data/lib/has_config/value_parser.rb

@@ -0,0 +1,15 @@
+module HasConfig
+  class ValueParser
+    def self.parse(value, type)
+      return nil if value.nil?
+      case type
+      when :string
+        value.to_s
+      when :integer
+        value.present? ? value.to_i : nil
+      when :boolean
+        /\A(true|t|yes|y|1)\z/i === value.to_s
+      end
+    end
+  end
+end

data/lib/has_config/version.rb

@@ -1,3 +1,3 @@
 module HasConfig
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_config
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tony Drake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-12 00:00:00.000000000 Z
+date: 2016-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -76,7 +90,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
@@ -89,8 +105,16 @@ files:
 - gemfiles/4.0.gemfile
 - gemfiles/4.1.gemfile
 - gemfiles/4.2.gemfile
+- gemfiles/5.0.gemfile
 - has_config.gemspec
 - lib/has_config.rb
+- lib/has_config/active_record/model_adapter.rb
+- lib/has_config/active_record/processor.rb
+- lib/has_config/chain.rb
+- lib/has_config/configuration.rb
+- lib/has_config/engine.rb
+- lib/has_config/errors.rb
+- lib/has_config/value_parser.rb
 - lib/has_config/version.rb
 homepage: http://github.com/t27duck/has_config
 licenses:
@@ -104,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="