configure_me 0.5.0 → 0.6.0

data/.rvmrc

@@ -1 +1 @@
-rvm use 1.9.2@configure_me
+rvm use --create 1.9.2@configure_me

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/configure_me.gemspec

@@ -19,8 +19,11 @@ Gem::Specification.new do |s|
   s.require_paths = %w(lib)
 
   s.add_dependency 'activerecord',    '~> 3.1.0'
+  s.add_dependency 'activesupport',   '~> 3.1.0'
 
   s.add_development_dependency 'rspec',         '~> 2.7.0'
   s.add_development_dependency 'simplecov',     '~> 0.5.4'
   s.add_development_dependency 'mocha',         '~> 0.10.0'
+  s.add_development_dependency 'guard-rspec',   '~> 0.5.10'
+  s.add_development_dependency 'libnotify',     '~> 0.6.0'
 end

data/lib/configure_me/attribute_methods.rb

@@ -1,10 +1,15 @@
 module ConfigureMe
-  class Base
-    include ActiveModel::AttributeMethods
-    include ActiveModel::Dirty
-    attribute_method_suffix('', '=', '_before_type_cast')
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::AttributeMethods
+      include ActiveModel::Dirty
+      attribute_method_suffix('', '=', '_before_type_cast')
+      extend OverriddenClassMethods
+    end
 
-    class << self
+    module OverriddenClassMethods
       def setting(name, *args)
         class_settings[name.to_sym] = Setting.new(name.to_sym, *args)
         define_attribute_methods(true)
@@ -20,8 +25,6 @@ module ConfigureMe
         super(class_settings.keys)
       end
     end
-  end
-  module AttributeMethods
 
     def read_attribute(name)
       name_sym = name.to_sym

data/lib/configure_me/base.rb

@@ -6,7 +6,6 @@ module ConfigureMe
     extend ActiveModel::Callbacks
     include AttributeMethods
     include Caching
-    include Identity
     include Naming
     include Nesting
     include Persistence
@@ -22,7 +21,7 @@ module ConfigureMe
     def to_key
       if persisted?
         key = parent_config.nil? ? [] : parent_config.to_key
-        key << self.config_name
+        key << self.class.config_name
         key
       else
         nil
@@ -37,36 +36,49 @@ module ConfigureMe
       end
     end
 
+    def config_key
+      to_param
+    end
+
+    def storage_key(name)
+      "#{config_key}-#{name.to_s}"
+    end
+
     class << self
       def inherited(subclass)
         super
         configs << subclass
       end
 
-      def method_missing(method_sym, *args)
-        if instance.respond_to?(method_sym)
-          instance.send(method_sym, *args)
-        else
-          super
-        end
+      def config_name
+        self.name.demodulize.gsub(/^(.*)Config$/, '\1').underscore
       end
 
-      def respond_to?(method_sym, include_private = false)
-        instance.children.each_pair do |name, instance|
-          if name.to_s.eql?(method_sym.to_s)
-            return true
-          end
-        end
-        if class_settings.key?(method_sym)
-          return true
-        end
-        super
-      end
+      #def method_missing(method_sym, *args)
+      #  if instance.respond_to?(method_sym)
+      #    instance.send(method_sym, *args)
+      #  else
+      #    super
+      #  end
+      #end
+
+      #def respond_to?(method_sym, include_private = false)
+      #  instance.children.each_pair do |name, instance|
+      #    if name.to_s.eql?(method_sym.to_s)
+      #      return true
+      #    end
+      #  end
+      #  if class_settings.key?(method_sym)
+      #    return true
+      #  end
+      #  super
+      #end
 
       def find_by_id(id)
         configs.each do |config|
           if config.config_key.eql?(id)
-            return config.instance
+            #return config.instance
+            return config.new
           end
         end
         nil

data/lib/configure_me/caching.rb

@@ -1,6 +1,8 @@
 module ConfigureMe
-  class Base
-    class << self
+  module Caching
+    extend ActiveSupport::Concern
+
+    module ClassMethods
       def cache_me
         @caching = true
       end
@@ -10,9 +12,7 @@ module ConfigureMe
         @caching && !ConfigureMe.cache_object.nil?
       end
     end
-  end
 
-  module Caching
     def read_cache(name)
       if self.class.caching?
         ConfigureMe.cache_object.read(self.storage_key(name))

data/lib/configure_me/loading.rb

@@ -50,8 +50,8 @@ module ConfigureMe
     private
 
     def define_custom_class(name)
-      remove_const(name.to_sym) if const_defined?(name)
-      const_set(name, Class.new(ConfigureMe::Base))
+      Object.send(:remove_const, name) if Object.const_defined?(name)
+      Object.const_set(name, Class.new(ConfigureMe::Base))
     end
   end
 end

data/lib/configure_me/naming.rb

@@ -1,8 +1,13 @@
 module ConfigureMe
-  class Base
-    extend ActiveModel::Naming
+  module Naming
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Naming
+      extend OverriddenClassMethods
+    end
 
-    class << self
+    module OverriddenClassMethods
       def model_name
         if persisting?
           ConfigureMe.persistence_klass.model_name
@@ -12,7 +17,4 @@ module ConfigureMe
       end
     end
   end
-
-  module Naming
-  end
 end

data/lib/configure_me/nesting.rb

@@ -1,42 +1,48 @@
 module ConfigureMe
-  class Base
-    class << self
+  module Nesting
+    extend ActiveSupport::Concern
+
+    module ClassMethods
       def nest_me(klass, name = nil)
-        klass.instance.nest(self)
+        klass.nested_classes[self.config_name.to_sym] = self
+        klass.class_eval <<-EOF, __FILE__, __LINE__
+          def #{self.config_name}
+            @#{self.config_name} ||= begin
+              config = self.class.nested_classes["#{self.config_name}".to_sym].new
+              config.parent_config = self
+              self.children["#{self.config_name}".to_sym] = config
+              config
+            end
+          end
+        EOF
       end
-    end
-  end
 
-  module Nesting
-
-    def nest(klass)
-      children[klass.instance.config_name.to_sym] = klass.instance
-      klass.instance.parent_config = self
-      self.class_eval <<-EOF, __FILE__, __LINE__
-        def #{klass.instance.config_name}
-          children[:#{klass.instance.config_name.to_s}]
-        end
-      EOF
+      def nested_classes
+        @nested_classes ||= {}
+      end
     end
 
-    def parent_config
-      @parent_config ||= nil
-    end
+    module InstanceMethods
 
-    def parent_config=(parent_config)
-      @parent_config = parent_config
-    end
+      def parent_config
+        @parent_config ||= nil
+      end
 
-    def children
-      @children ||= {}
-    end
+      def parent_config=(parent_config)
+        @parent_config = parent_config
+      end
+
+      def children
+        @children ||= {}
+      end
 
-    def all_configs
-      res = [self]
-      children.values.each do |child|
-        res.concat(child.all_configs)
+      def all_configs
+        res = [self]
+        children.values.each do |child|
+          res.concat(child.all_configs)
+        end
+        res
       end
-      res
     end
   end
 end

data/lib/configure_me/persistence.rb

@@ -1,9 +1,10 @@
 module ConfigureMe
-  class Base
-    extend ActiveModel::Callbacks
-    define_model_callbacks :save
-  end
   module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      define_model_callbacks :save
+    end
 
     def save(*)
       run_callbacks :save do

data/lib/configure_me/persisting.rb

@@ -1,6 +1,8 @@
 module ConfigureMe
-  class Base
-    class << self
+  module Persisting
+    extend ActiveSupport::Concern
+
+    module ClassMethods
       def persist_me
         @persisting = true
       end
@@ -10,9 +12,6 @@ module ConfigureMe
         @persisting && !ConfigureMe.persistence_klass.nil?
       end
     end
-  end
-
-  module Persisting
 
     def read_persist(name)
       if self.class.persisting?

data/lib/configure_me/validations.rb

@@ -1,9 +1,13 @@
 require 'active_model'
 
 module ConfigureMe
-  class Base
-    include ActiveModel::Validations
-    define_model_callbacks :validation
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations
+      define_model_callbacks :validation
+    end
 
     def save(options={})
       run_callbacks :validation do
@@ -27,7 +31,4 @@ module ConfigureMe
       end
     end
   end
-
-  module Validations
-  end
 end

data/lib/configure_me/version.rb

@@ -1,3 +1,3 @@
 module ConfigureMe
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/configure_me.rb

@@ -1,5 +1,5 @@
 require 'active_model'
-require 'singleton'
+require 'active_support'
 
 module ConfigureMe
   class << self
@@ -17,15 +17,10 @@ module ConfigureMe
       @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'

data/spec/lib/configure_me/attribute_methods_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe ConfigureMe::AttributeMethods do
+  class AttributeTester
+    include ConfigureMe::AttributeMethods
+  end
+
+  let(:test_class) { define_test_class('MyTestConfig', AttributeTester) }
+  subject { test_class.new }
+  it 'make_clean should clear the temp_attributes' do
+    subject.send(:temp_attributes).expects(:clear)
+    subject.send(:make_clean)
+  end
+
+  describe 'reading an attribute' do
+    before {
+      test_class.send(:setting, :testsetting, :default => 'foo')
+      @config = test_class.new
+      @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 'writing an attribute' do
+    before {
+      test_class.send(:setting, :testsetting, :default => 'foo')
+      @config = test_class.new
+      @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
+end

data/spec/lib/configure_me/base_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+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 '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 ConfigureMe::Base do
+
+  class BaseTesterConfig < ConfigureMe::Base
+    setting :setting1, :type => :integer, :default => 12
+  end
+
+  subject { BaseTesterConfig.new }
+  its(:persisted?) { should be_true }
+
+  describe 'to_key' do
+    context 'without a parent config' do
+      before {
+        subject.stubs(:parent_config).returns(nil)
+      }
+      its(:to_key) { should eql(['base_tester']) }
+    end
+    context 'with a parent config' do
+      let(:parent_config) {
+        mock('ParentConfig') do
+          stubs(:to_key).returns(['parent'])
+        end
+      }
+      before {
+        subject.stubs(:parent_config).returns(parent_config)
+      }
+      its(:to_key) { should eql(['parent', 'base_tester']) }
+    end
+  end
+
+  describe 'to_param' do
+    context 'with a root config' do
+      its(:to_param) { should eql('base_tester') }
+    end
+    context 'with a nested config' do
+      before { subject.stubs(:to_key).returns(['parent', 'base_tester']) }
+      its(:to_param) { should eql('parent-base_tester') }
+    end
+  end
+
+  describe 'storage_key' do
+    specify { subject.storage_key('foo').should eql('base_tester-foo') }
+  end
+
+  describe 'ActiveModel compliance' do
+    subject { define_test_class('TestConfig', ConfigureMe::Base).new }
+    it_should_behave_like "ActiveModel"
+  end
+
+  describe 'find_by_id' do
+    subject { ConfigureMe::Base }
+    let(:configs) { [stub(:config_key => 'the-right-one', :new => 'object')] }
+    it 'should return nil for an invalid id' do
+      subject.stubs(:configs).returns([])
+      subject.find_by_id('something').should be_nil
+    end
+
+    it 'should return a matching config' do
+      subject.stubs(:configs).returns(configs)
+      subject.find_by_id('the-right-one').should eql('object')
+    end
+  end
+end

data/spec/lib/configure_me/caching_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe ConfigureMe::Caching do
+  class CachingTester
+    include ConfigureMe::Caching
+  end
+  let(:caching_class) { define_test_class('CachingConfig', CachingTester) }
+  subject { CachingTester }
+  it { should respond_to(:cache_me) }
+  it { should respond_to(:caching?) }
+
+  describe 'caching?' do
+    before {
+      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
+
+  context 'when caching is enabled' do
+    let(:cache_object) { stub(:read => 'cached_value', :write => true) }
+    before {
+      caching_class.stubs(:caching?).returns(true)
+      ConfigureMe.stubs(:cache_object).returns(cache_object)
+      @caching_obj = caching_class.new
+      @caching_obj.stubs(:storage_key).returns('cache_tester')
+    }
+    subject { @caching_obj }
+
+    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
+
+  context 'when caching is disabled' do
+    before {
+      caching_class.stubs(:caching?).returns(false)
+    }
+    subject { caching_class.new }
+
+    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
+end