configure_me 0.3.2 → 0.4.0

data/lib/configure_me/setting.rb

@@ -1,27 +1,76 @@
+require 'active_support/core_ext/object/blank'
+
 module ConfigureMe
+  class InvalidDefault < StandardError; end
+  class UnsupportedType < StandardError; end
+  class InvalidConversion < StandardError; end
+  # == Setting
+  #
+  # There are two methods used to create a setting:
+  # 1. calling the class method <tt>setting</tt> from within an instance of ConfigureMe::Base
+  # 2. implicitly when a hash is fed to ConfigureMe::Base.load
   class Setting
     attr_reader :name, :type, :default
 
-    def initialize(owner, name, type, *args)
+    VALID_TYPES = [:string, :integer, :float, :boolean, :unknown]
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE']
+
+    def initialize(name, *args)
       options = args.extract_options!
 
-      @owner, @name, @type = owner, name.to_s, type
+      @name = name.to_s
       @default = options.key?(:default) ? options[:default] : nil
-    end
-
-    def define_methods!
-      @owner.define_attribute_methods(true)
+      @type = options.key?(:type) ? options[:type] : infer_type(@default)
+      raise UnsupportedType.new("Invalid type: #{@type}") unless VALID_TYPES.include?(@type)
     end
 
     def convert(value)
       case type
-      when :string    then value
-      when :text      then value
+      when :string    then convert_to_string(value)
       when :integer   then value.to_i rescue value ? 1 : 0
-      when :float     then value.to_f
-      when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_date(value)
-      when :boolean   then ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
-      else value
+      when :float     then value.to_f rescue value ? 1.0 : 0.0
+      when :boolean   then convert_to_boolean(value)
+      when :unknown
+        @type = infer_type(value)
+        convert(value)
+      end
+    end
+
+    private
+
+    def infer_type(value)
+      case value
+      when String
+        :string
+      when Fixnum
+        :integer
+      when Float
+        :float
+      when TrueClass, FalseClass
+        :boolean
+      when NilClass
+        :unknown
+      else
+        raise InvalidDefault.new("Unable to infer type from #{value.inspect}")
+      end
+    end
+
+    def convert_to_string(value)
+      case value
+      when String
+        value
+      when Fixnum, Float, TrueClass, FalseClass, NilClass
+        value.to_s
+      else
+        raise InvalidConversion.new("Unable to convert #{value.inspect} to string")
+      end
+    end
+
+    def convert_to_boolean(value)
+      if value.is_a?(String) && value.blank?
+        nil
+      else
+        TRUE_VALUES.include?(value)
       end
     end
   end

data/lib/configure_me/validations.rb

@@ -0,0 +1,33 @@
+require 'active_model'
+
+module ConfigureMe
+  class Base
+    include ActiveModel::Validations
+    define_model_callbacks :validation
+
+    def save(options={})
+      run_callbacks :validation do
+        perform_validations(options) ? super : false
+      end
+    end
+
+    def valid?(context = nil)
+      context ||= (persisted? ? :update : :create)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    protected
+
+    def perform_validations(options={})
+      if options[:validate] != false
+        valid?(options[:context])
+      else
+        true
+      end
+    end
+  end
+
+  module Validations
+  end
+end

data/lib/configure_me/version.rb

@@ -1,3 +1,3 @@
 module ConfigureMe
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/configure_me.rb

@@ -1,14 +1,36 @@
+require 'active_model'
+require 'singleton'
+
 module ConfigureMe
   class << self
-    def persist_with(klass)
-      @persistence_klass = klass
+    def init(options = {})
+      options = {:persist_with => nil, :cache_with => nil}.merge(options)
+      @persistence_klass = options[:persist_with]
+      @cache_object = options[:cache_with]
     end
 
     def persistence_klass
-      @persistence_klass ||= ::Setting
+      @persistence_klass ||= nil
+    end
+
+    def cache_object
+      @cache_object
     end
   end
+
+  class Base
+    include Singleton
+  end
 end
 
+require 'configure_me/attribute_methods'
+require 'configure_me/caching'
+require 'configure_me/identity'
+require 'configure_me/loading'
+require 'configure_me/naming'
+require 'configure_me/nesting'
+require 'configure_me/persistence'
+require 'configure_me/persisting'
 require 'configure_me/setting'
+require 'configure_me/validations'
 require 'configure_me/base'

data/lib/generators/configure_me/setup_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators/active_record'
+
+module ConfigureMe
+  class SetupGenerator < ActiveRecord::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    def generate_model
+      template 'model.rb', "app/models/#{singular_name}.rb"
+    end
+
+    def generate_migration
+      migration_template 'migration.rb', "db/migrate/create_#{plural_name}.rb"
+    end
+
+    def generate_initializer
+      template 'initializer.rb', 'config/initializers/init_configure_me.rb'
+    end
+  end
+end

data/lib/generators/configure_me/templates/initializer.rb

@@ -0,0 +1 @@
+ConfigureMe.init(:persist_with => <%= class_name %>, :cache_with => Rails.cache)

data/lib/generators/configure_me/templates/model.rb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/spec/configure_me/attribute_methods_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe ConfigureMe::AttributeMethods do
+  before {
+    @config_class = define_test_class('MyTestConfig', ConfigureMe::Base)
+  }
+  subject { @config_class.instance }
+  it 'make clean should clear the temp_attributes' do
+    subject.send(:temp_attributes).expects(:clear)
+    subject.send(:make_clean)
+  end
+end
+
+describe ConfigureMe::AttributeMethods, 'reading an attribute' do
+  before {
+    @config_class = define_test_class('MyTestConfig', ConfigureMe::Base)
+    @config_class.send(:setting, :testsetting, :default => 'foo')
+    @config = @config_class.instance
+    @config.stubs(:read_cache)
+    @config.stubs(:read_persist)
+  }
+  subject { @config }
+  it 'should call "read_attribute"' do
+    @config.expects(:read_attribute).with('testsetting')
+    subject.testsetting
+  end
+  context 'with a pristine instance' do
+    it 'should attempt to read from the cache' do
+      subject.expects(:read_cache)
+      subject.testsetting
+    end
+    it 'should attempt to read from the persistence store' do
+      subject.expects(:read_persist)
+      subject.testsetting
+    end
+    it 'should return the default value' do
+      subject.testsetting.should eql('foo')
+    end
+  end
+  context 'with a persisted value' do
+    context 'with a non-cached value' do
+      before { @config.stubs(:read_cache).returns(nil) }
+      it 'should attempt to read from the cache' do
+        subject.expects(:read_cache).returns(nil)
+        subject.testsetting
+      end
+      it 'should attempt to read from the persistence store' do
+        subject.expects(:read_persist)
+        subject.testsetting
+      end
+      it 'should write the value to the cache' do
+        subject.stubs(:read_persist).returns('persisted')
+        subject.expects(:write_cache).with(:testsetting, 'persisted')
+        subject.testsetting
+      end
+      it 'should return the persisted value' do
+        subject.stubs(:read_cache).returns('persisted')
+        subject.testsetting.should eql('persisted')
+      end
+    end
+
+    context 'with a cached value' do
+      before { @config.stubs(:read_cache).returns('cached') }
+      it 'should attempt to read from the cache' do
+        subject.expects(:read_cache).returns('cached')
+        subject.testsetting
+      end
+      it 'should not attempt to read from the persistence store' do
+        subject.expects(:read_persist).never
+        subject.testsetting
+      end
+      it 'should return the cached value' do
+        subject.testsetting.should eql('cached')
+      end
+    end
+  end
+
+  context 'with a dirty value' do
+    before { @config.stubs(:testsetting_changed?).returns(true) }
+    it 'should not attempt to read from the cache' do
+      subject.expects(:read_cache).never
+      subject.testsetting
+    end
+    it 'should not attempt to read from the persistence store' do
+      subject.expects(:read_persist).never
+      subject.testsetting
+    end
+    it 'should return the value from the temp_attributes hash' do
+      subject.expects(:temp_attributes).returns(:testsetting => 'iamdirty')
+      subject.testsetting.should eql('iamdirty')
+    end
+  end
+end
+
+describe ConfigureMe::AttributeMethods, 'writing an attribute' do
+  before {
+    @config_class = define_test_class('MyTestConfig', ConfigureMe::Base)
+    @config_class.send(:setting, :testsetting, :default => 'foo')
+    @config = @config_class.instance
+    @config.stubs(:read_cache)
+    @config.stubs(:read_persist)
+  }
+  subject { @config }
+
+  it 'should set the attribute to dirty' do
+    subject.expects(:make_dirty).with(:testsetting)
+    subject.testsetting = 'newvalue'
+  end
+  it 'should write the value to the temp_attributes hash' do
+    subject.testsetting = 'newvalue'
+    subject.send(:temp_attributes)[:testsetting].should eql('newvalue')
+  end
+end

data/spec/configure_me/base_spec.rb

@@ -1,103 +1,58 @@
 require 'spec_helper'
 
-describe ConfigureMe::Base do
-  class TestConfig < ConfigureMe::Base
+describe ConfigureMe do
+  it { should respond_to(:init) }
+  it { should respond_to(:persistence_klass) }
+  it { should respond_to(:cache_object) }
+  it 'should provide nil defaults for :init' do
+    ConfigureMe.init
+    ConfigureMe.persistence_klass.should be_nil
+    ConfigureMe.cache_object.should be_nil
   end
 
-  it { TestConfig.should respond_to(:setting) }
-  it { TestConfig.instance.should respond_to(:read_setting) }
-  it { TestConfig.instance.should respond_to(:write_setting) }
-  it { TestConfig.send(:persisting?).should be_false }
-
-  describe 'with a "color" setting with a default of "red"' do
-    before(:each) do
-      @klass = Class.new(ConfigureMe::Base)
-      @klass.send :setting, :color, :string, :default => 'red'
-    end
-
-    describe 'an instance ' do
-      it 'should respond to attribute_method?(:color) with true' do
-        @obj = @klass.instance
-        @obj.send(:attribute_method?, :color).should be_true
-      end
-
-      it 'should respond to attribute_method?(:size) with false' do
-        @obj = @klass.instance
-        @obj.send(:attribute_method?, :size).should be_false
-      end
-
-      it 'should respond to :color with "red"' do
-        @obj = @klass.instance
-        @obj.color.should eql('red')
-      end
-
-      it 'should store a new :color of "blue"' do
-        @obj = @klass.instance
-        @obj.color = 'blue'
-        @obj.color.should eql('blue')
-      end
-
-      it 'should raise error when setting an unknown attribute' do
-        @obj = @klass.instance
-        lambda { @obj.write_setting('size', 'big') }.should raise_error(NoMethodError)
-      end
-
-      it 'should assign from a hash' do
-        @obj = @klass.instance
-        @obj.send :settings=, {:color => 'blue'}
-        @obj.color.should eql('blue')
-      end
-    end
+  it 'should accept a hash of initialization arguments' do
+    ConfigureMe.init(:persist_with => 'foo', :cache_with => 'bar')
+    ConfigureMe.persistence_klass.should eql('foo')
+    ConfigureMe.cache_object.should eql('bar')
   end
+end
 
-  describe 'persisting' do
-    before(:each) do
-      @klass = TestConfig
-      @persistence = mock('PersistenceClass')
-      ConfigureMe.persist_with @persistence
-      @klass.send :setting, :color, :string, :default => 'red'
-      @klass.send :persist_me
-    end
+describe ConfigureMe::Base do
+  it 'should enforce the singleton pattern' do
+    lambda { ConfigureMe::Base.new }.should raise_error(NoMethodError)
+  end
 
-    it { @klass.send(:persisting?).should be_true }
-    it { @klass.should respond_to(:persistence_key) }
-    it { @klass.persistence_key.should eql('test') }
+  class BaseConfig < ConfigureMe::Base
+    setting :setting1, :type => :integer, :default => 12
+  end
 
-    describe 'with a non-persisted setting' do
-      before(:each) do
-        @obj = @klass.instance
-        @unpersisted = mock('UnpersistedSetting') do
-          stubs(:value=)
-        end
-        @persistence = mock('PersistenceClass')
-        ConfigureMe.persist_with @persistence
-      end
+  subject { BaseConfig.instance }
+  its(:persisted?) { should be_true }
+  its(:class) { should respond_to(:setting1) }
 
-      it { @obj.send(:persistence_key, :color).should eql('test_color') }
+  describe 'ActiveModel compliance' do
+    before { @config = define_test_class('TestConfig', ConfigureMe::Base).instance }
+    subject { @config }
+    it_should_behave_like "ActiveModel"
+  end
 
-      it 'should store updates to the database' do
-        @unpersisted = mock('UnpersistedSetting') do
-          expects(:value=)
-          expects(:save!)
-        end
-        @persistence.stubs(:find_or_create_by_key).returns(@unpersisted)
-        @obj.color = "blue"
-      end
+  describe 'find_by_id' do
+    subject { ConfigureMe::Base }
+    before {
+      @mock_config = mock('Config') do
+        stubs(:config_key).returns('the-right-one')
+        stubs(:instance).returns('instance')
+      end
+      @configs = [@mock_config]
+    }
+    it 'should return nil for an invalid id' do
+      subject.stubs(:configs).returns([])
+      subject.find_by_id('something').should be_nil
     end
 
-    describe 'with a persisted setting' do
-      before(:each) do
-        @obj = @klass.instance
-        @persisted = mock('PersistedSetting') do
-          stubs(:value).returns("blue".to_yaml)
-        end
-        @persistence.stubs(:find_by_key).returns(@persisted)
-        ConfigureMe.persist_with @persistence
-      end
-      
-      it 'should return a valid value' do
-        @obj.color.should eql("blue")
-      end
+    it 'should return a matching config' do
+      subject.stubs(:configs).returns(@configs)
+      subject.find_by_id('the-right-one').should eql('instance')
     end
   end
 end

data/spec/configure_me/caching_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe ConfigureMe::Caching, 'the class' do
+  subject { ConfigureMe::Base }
+  it { should respond_to(:cache_me) }
+  it { should respond_to(:caching?) }
+end
+
+describe ConfigureMe::Caching, 'caching?' do
+  before {
+    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
+    @caching_class.send(:cache_me)
+  }
+  subject { @caching_class }
+
+  context 'when cache_object is available' do
+    before { ConfigureMe.stubs(:cache_object).returns({}) }
+    specify { subject.caching?.should be_true }
+  end
+
+  context 'when cache_object is unavailable' do
+    before { ConfigureMe.stubs(:cache_object).returns(nil) }
+    specify { subject.caching?.should be_false }
+  end
+
+end
+
+describe ConfigureMe::Caching, 'when caching is enabled' do
+  before {
+    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
+    @caching_class.stubs(:caching?).returns(true)
+    @cache_object = mock('CacheObject') do
+      stubs(:read).returns('cached_value')
+      stubs(:write)
+    end
+    ConfigureMe.stubs(:cache_object).returns(@cache_object)
+  }
+  subject { @caching_class.instance }
+
+  it 'should attempt to read from the cache' do
+    ConfigureMe.expects(:cache_object).once.returns(@cache_object)
+    subject.read_cache('cachedsetting')
+  end
+
+  it 'should return the value from the cache' do
+    subject.read_cache('cachedsetting').should eql('cached_value')
+  end
+
+  it 'should attempt to write to the cache' do
+    @cache_object.expects(:write).once
+    subject.write_cache('cachedsetting', 'newvalue')
+  end
+end
+
+describe ConfigureMe::Caching, 'when caching is disabled' do
+  before {
+    @caching_class = define_test_class('CachingConfig', ConfigureMe::Base)
+    @caching_class.stubs(:caching?).returns(false)
+  }
+  subject { @caching_class.instance }
+
+  it 'should not attempt to read from the cache' do
+    ConfigureMe.expects(:cache_object).never
+    subject.read_cache('cachedsetting')
+  end
+
+  it 'should return nil when read_cache is called' do
+    subject.read_cache('cachedsetting').should be_nil
+  end
+
+  it 'should not attempt to write to the cache' do
+    ConfigureMe.expects(:cache_object).never
+    subject.write_cache('cachedsetting', 'newvalue')
+  end
+end

data/spec/configure_me/identity_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ConfigureMe::Identity do
+  before {
+    @parent_class = define_test_class('ParentConfig', ConfigureMe::Base)
+    @nested_class = define_test_class('NestedConfig', ConfigureMe::Base)
+  }
+
+  context 'a root class' do
+    subject { @parent_class.instance }
+    it { should respond_to(:config_key) }
+    it { should respond_to(:config_name) }
+    it { should respond_to(:storage_key) }
+    its(:config_name) { should eql('parent') }
+    its(:config_key) { should eql('parent') }
+    it 'should generate a valid storage key' do
+      subject.storage_key('foo').should eql('parent-foo')
+    end
+  end
+
+  context 'a nested class' do
+    before { @nested_class.send(:nest_me, @parent_class) }
+    subject { @nested_class.instance }
+    its(:config_name) { should eql('nested') }
+    its(:config_key) { should eql('parent-nested') }
+    it 'should generate a valid storage key' do
+      subject.storage_key('foo').should eql('parent-nested-foo')
+    end
+  end
+end

data/spec/configure_me/loading_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe ConfigureMe::Loading, 'a filename' do
+  subject { ConfigureMe::Base }
+  it 'should raise an error for a non-existent file' do
+    lambda { subject.load('foo') }.should raise_error(ArgumentError)
+  end
+
+  it 'should load an existing file' do
+    File.stubs(:exists?).returns(true)
+    File.stubs(:open).returns({:foo => 'bar'}.to_yaml)
+    subject.expects(:from_hash)
+    subject.load('avalidfile')
+  end
+end
+
+describe ConfigureMe::Loading, 'a hash' do
+  subject { ConfigureMe::Base }
+
+  context 'with :app => {:setting1 => \'foo\', :setting2 => 845}' do
+    before { @config = ConfigureMe::Base.load(:app => {:setting1 => 'foo', :setting2 => 845}) }
+    subject { @config.instance }
+    its(:config_name) { should eql('app') }
+
+    it { should respond_to(:setting1) }
+    it { should respond_to(:setting2) }
+    it { should_not respond_to(:setting3) }
+    its(:setting1) { should eql('foo') }
+    its(:setting2) { should eql(845) }
+    its(:parent_config) { should be_nil }
+  end
+
+  context 'with :group1 => {:setting1 => 6, :setting2 => \'foo\'}, :group2 => {:setting3 => 8, :setting4 => \'bar\'}' do
+    describe 'the instance' do
+      before {
+        @config = ConfigureMe::Base.load(
+          :group1 => {
+            :setting1 => 6,
+            :setting2 => 'foo'
+          },
+          :group2 => {
+            :setting3 => 8,
+            :setting4 => 'bar'
+          }
+        )
+      }
+
+      subject { @config.instance }
+      its(:config_name) { should eql('root') }
+      it { should respond_to(:group1) }
+      it { should respond_to(:group2) }
+      it { should_not respond_to(:group3) }
+
+      describe 'group1' do
+        subject { @config.group1 }
+        it { should_not be_nil }
+        it { should respond_to(:setting1) }
+        it { should respond_to(:setting2) }
+        it { should_not respond_to(:setting3) }
+        its(:setting1) { should eql(6) }
+        its(:setting2) { should eql('foo') }
+        its(:parent_config) { should eql(@config.instance) }
+      end
+
+      describe 'group2' do
+        subject { @config.instance.group2 }
+        it { should_not be_nil }
+        it { should respond_to(:setting3) }
+        it { should respond_to(:setting4) }
+        it { should_not respond_to(:setting1) }
+        its(:setting3) { should eql(8) }
+        its(:setting4) { should eql('bar') }
+        its(:parent_config) { should eql(@config.instance) }
+      end
+    end
+  end
+end
+
+describe ConfigureMe::Loading, 'something unsupported' do
+  subject { ConfigureMe::Base }
+  it 'should raise an exception' do
+    lambda { subject.load(123) }.should raise_error(ArgumentError)
+  end
+end

data/spec/configure_me/naming_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ConfigureMe::Naming do
+  class NamingConfig < ConfigureMe::Base
+  end
+
+  before {
+    @persistence_klass = mock('PersistenceKlass') do
+      stubs(:model_name).returns('persistence')
+    end
+    ConfigureMe.stubs(:persistence_klass).returns(@persistence_klass)
+  }
+  subject { NamingConfig }
+  context 'when persisting' do
+    before { NamingConfig.stubs(:persisting?).returns(true) }
+    its(:model_name) { should eql('persistence') }
+  end
+
+  context 'when not persisting' do
+    before { NamingConfig.stubs(:persisting?).returns(false) }
+    its(:model_name) { should_not eql('persistence') }
+  end
+end