configure_me 0.3.2 → 0.4.0

data/.rspec

@@ -1,3 +1,3 @@
 --colour
---format progress
+--format d
 --backtrace

data/{README.md → README.rdoc}

@@ -1,11 +1,11 @@
-## ConfigureMe
+= ConfigureMe
 
 A really simple gem for helping to manage dynamic application configuration.
 
-### Installation
+== Installation
     gem "configure_me"
 
-### Usage
+== Usage
 Using ConfigureMe is easy.  First, derive a class from ConfigureMe::Base.  Then define your settings just as you would attributes.
 
     class AppConfig < ConfigureMe::Base
@@ -31,7 +31,7 @@ Changes to the configuration are made the same way:
     # AppConfig.instance.min_password_length
     => 6
 
-### Nesting
+=== Nesting
 You can also nest configuration classes.  To nest one config under another, just call *nest_me* from inside the nested class, passing it the class you would like to nest it under.  When an instance of the parent class is created, an instance of the nested class will be instantiated at the same time.
 
     class MainConfig < ConfigureMe::Base
@@ -56,7 +56,7 @@ The default behaviour when nesting is to use the name of the nested class (exclu
     # AppConfig.instance.altextension.secret_weapon
     => "throwing star"
 
-## Persisting
+=== Persisting
 An easily editable configuration doesn't do any good without persisting it.  To store our configuration settings in the database, we need to generate an ActiveRecord model to store our settings.
 
     # rails g configure_me Setting
@@ -70,7 +70,7 @@ This will create a model/migration, and an initializer to let ConfigureMe know w
 
 Now, when updating any setting, the new value will be written to the database as well as stored in memory.   Settings are converted to YAML before being written, so complex values can be stored.  When accessing a setting, the database is always consulted first, and if no value is stored, the default is returned or, if no default was specified, nil.
 
-## Caching
+=== Caching
 To really crank up the performance, you can enable caching of values.  If you're paying attention, the method to enable this should be obvious.
 
     class AppConfig < ConfigureMe::Base
@@ -79,7 +79,7 @@ To really crank up the performance, you can enable caching of values.  If you're
 
 Now, when values are accessed, the cache will be referenced before falling back to other means.  If combined with *persist_me*, this can make dealing with dynamic site configuration perform much better than a database only solution.
 
-## Putting it all together
+=== Putting it all together
 
 Here's a complete configuration example:
 

data/Rakefile

@@ -2,23 +2,17 @@ require 'bundler'
 Bundler::GemHelper.install_tasks
 
 require 'rake'
-require 'rake/rdoctask'
 require 'rspec/core/rake_task'
-require 'cucumber'
-require 'cucumber/rake/task'
 
 RSpec::Core::RakeTask.new do |t|
   t.verbose = false
 end
 
 namespace :spec do
+  desc 'Generate coverage information with rcov'
   RSpec::Core::RakeTask.new(:rcov) do |t|
     t.rcov = true
     t.rcov_opts =  %w{--text-report --sort coverage}
     t.rcov_opts << %w{--exclude gems\/,spec\/}
   end
 end
-
-Cucumber::Rake::Task.new(:features) do |t|
-  t.cucumber_opts = 'features --format progress'
-end

data/configure_me.gemspec

@@ -15,16 +15,12 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "configure_me"
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
   s.require_paths = %w(lib)
 
-  s.add_dependency 'activemodel',   '~> 3.0.1'
-  s.add_dependency 'activesupport', '~> 3.0.1'
+  s.add_dependency 'rails',   '3.0.3'
 
-  s.add_development_dependency 'rspec',     '~> 2.0.1'
+  s.add_development_dependency 'rspec',     '~> 2.2.0'
   s.add_development_dependency 'rcov',      '~> 0.9.9'
   s.add_development_dependency 'mocha',     '~> 0.9.8'
-  s.add_development_dependency 'cucumber',  '~> 0.9.4'
-  s.add_development_dependency 'activerecord',  '~> 3.0.1'
 end

data/lib/configure_me/attribute_methods.rb

@@ -0,0 +1,88 @@
+module ConfigureMe
+  class Base
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+    attribute_method_suffix('', '=', '_before_type_cast')
+
+    class << self
+      def setting(name, *args)
+        class_settings[name.to_sym] = Setting.new(name.to_sym, *args)
+        define_attribute_methods(true)
+      end
+
+      def class_settings
+        @class_settings ||= {}
+      end
+
+      def define_attribute_methods(force = false)
+        return if class_settings.empty?
+        undefine_attribute_methods if force
+        super(class_settings.keys)
+      end
+    end
+  end
+  module AttributeMethods
+
+    def read_attribute(name)
+      name_sym = name.to_sym
+      value = attribute_before_type_cast(name)
+      self.class.class_settings[name_sym].convert(value)
+    end
+
+    def write_attribute(name, value)
+      name_sym = name.to_sym
+      make_dirty(name_sym)
+      temp_attributes[name_sym] = value
+    end
+
+    private
+
+    def temp_attributes
+      @temp_attributes ||= {}
+    end
+
+    def make_dirty(name)
+      self.send("#{name.to_s}_will_change!")
+    end
+
+    def make_clean
+      temp_attributes.clear
+      @changed_attributes.clear if defined?(@changed_attributes)
+    end
+
+    def attributes
+      attrs = {}
+      self.class.class_settings.keys.each do |key|
+        attrs[key.to_s] = attribute(key)
+      end
+      attrs
+    end
+
+    def attribute_before_type_cast(name)
+      name_sym = name.to_sym
+      if self.send "#{name.to_s}_changed?".to_sym
+        value = temp_attributes[name_sym]
+      else
+        value = read_cache(name_sym)
+        if value.nil?
+          value = read_persist(name_sym)
+          unless value.nil?
+            write_cache(name_sym, value)
+          end
+        end
+        if value.nil?
+          value = self.class.class_settings[name_sym].default
+        end
+      end
+      value
+    end
+
+    def attribute(name)
+      read_attribute(name)
+    end
+
+    def attribute=(name, value)
+      write_attribute(name, value)
+    end
+  end
+end

data/lib/configure_me/base.rb

@@ -1,85 +1,81 @@
-require 'active_model'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'singleton'
-require 'configure_me/settings'
-require 'configure_me/nesting'
-require 'configure_me/persisting'
-require 'configure_me/caching'
+
 
 module ConfigureMe
+
   class Base
-    include ActiveModel::AttributeMethods
-    include Settings
+    extend ActiveModel::Callbacks
+    include AttributeMethods
+    include Caching
+    include Identity
+    include Naming
     include Nesting
+    include Persistence
     include Persisting
-    include Caching
-    include Singleton
-    extend ActiveModel::Naming
+    include Validations
+    extend Loading
+    include ActiveModel::Conversion
 
-    class << self
-      def config_name
-        self.name.split('::').last.gsub(/^(.*)Config$/, '\1').downcase
+    def persisted?
+      true
+    end
+
+    def to_key
+      if persisted?
+        key = parent_config.nil? ? [] : parent_config.to_key
+        key << self.config_name
+        key
+      else
+        nil
       end
+    end
 
-      def from_hash(root, config)
-        if root.nil?
-          root = const_set("RootConfig", Class.new(ConfigureMe::Base))
-        end
+    def to_param
+      if persisted?
+        to_key.join('-')
+      else
+        nil
+      end
+    end
 
-        # Determine how many root keys there are.
-        #
-        # If more than one, create a new nested ConfigureMe::Base
-        # subclass for each key.
-        #
-        # If only one, just assign the values to the root config
-        if config.keys.length > 1
-          config.each_pair do |key, value|
-            if value.is_a?(Hash)
-              klass_name = "#{key}_config".camelize
-              c = root.const_set(klass_name, Class.new(ConfigureMe::Base))
-              from_hash(c, value)
-              c.send :nest_me, root
-            else
-              root.send :setting, key, :string, :default => value
-            end
-          end
-          root
-        else
-          from_hash(root, config.values.first)
-        end
+    class << self
+      def inherited(subclass)
+        super
+        configs << subclass
       end
 
-      def load(config)
-        case config
-        when Hash
-          from_hash(nil, config)
+      def method_missing(method_sym, *args)
+        if instance.respond_to?(method_sym)
+          instance.send(method_sym, *args)
         else
-          raise ::ArgumentError, "ConfigureMe: Not sure how to load type [#{config.class}]"
+          super
         end
       end
 
-      def method_missing(method, *args)
-        if instance.respond_to?(method)
-          instance.send(method, *args)
-        else
-          super
+      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
-    end
 
-    def parent
-      @parent || nil
-    end
+      def find_by_id(id)
+        configs.each do |config|
+          if config.config_key.eql?(id)
+            return config.instance
+          end
+        end
+        nil
+      end
 
-    def parent=(parent)
-      @parent = parent
-    end
+      private
 
-    def initialize
-      @children = {}
-      @settings = settings_from_class_settings
-      self.class.nested.each do |klass|
-        nest(klass)
+      def configs
+        @configs ||= []
       end
     end
   end

data/lib/configure_me/caching.rb

@@ -1,25 +1,30 @@
-require 'active_support/concern'
-
 module ConfigureMe
-  module Caching
-    extend ActiveSupport::Concern
-
-    included do
-      @caching = false
-    end
-
-    module ClassMethods
-      def cache_me(caching_key = nil)
+  class Base
+    class << self
+      def cache_me
         @caching = true
       end
 
       def caching?
-        @caching
+        @caching ||= false
+        @caching && !ConfigureMe.cache_object.nil?
       end
     end
+  end
 
-    def cache_key(name)
-      persistence_key(name)
+  module Caching
+    def read_cache(name)
+      if self.class.caching?
+        ConfigureMe.cache_object.read(self.storage_key(name))
+      else
+        nil
+      end
+    end
+
+    def write_cache(name, value)
+      if self.class.caching?
+        ConfigureMe.cache_object.write(self.storage_key(name), value)
+      end
     end
   end
 end

data/lib/configure_me/identity.rb

@@ -0,0 +1,15 @@
+module ConfigureMe
+  module Identity
+    def config_key
+      to_param
+    end
+
+    def config_name
+      self.class.name.split('::').last.gsub(/^(.*)Config$/, '\1').underscore
+    end
+
+    def storage_key(name)
+      "#{config_key}-#{name.to_s}"
+    end
+  end
+end

data/lib/configure_me/loading.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+
+module ConfigureMe
+  module Loading
+    def from_hash(root, config)
+
+      # Determine how many root keys there are.
+      #
+      # If more than one, create a new nested ConfigureMe::Base
+      # subclass for each key.
+      #
+      # If only one, just assign the values to the root config
+      if config.keys.length > 1
+        if root.nil?
+          root = define_custom_class('RootConfig')
+        end
+        config.each_pair do |key, value|
+          if value.is_a?(Hash)
+            klass_name = "#{key}_config".camelize
+            c = define_custom_class("#{key}_config".camelize)
+            from_hash(c, value)
+            c.send :nest_me, root
+          else
+            root.send :setting, key, :default => value
+          end
+        end
+        root
+      else
+        root = define_custom_class(config.keys.first.to_s.camelize)
+        from_hash(root, config.values.first)
+      end
+    end
+
+    def load(*args)
+      case args.first
+      when Hash
+        from_hash(nil, args.first)
+      when String
+        if File.exists?(args.first)
+          yml = YAML::load(File.open(args.first))
+          from_hash(nil, yml)
+        else
+          raise ::ArgumentError, "ConfigureMe: Invalid file: #{args.first}"
+        end
+      else
+        raise ::ArgumentError, "ConfigureMe: Not sure how to load type [#{args.class}]"
+      end
+    end
+
+    private
+
+    def define_custom_class(name)
+      remove_const(name.to_sym) if const_defined?(name)
+      const_set(name, Class.new(ConfigureMe::Base))
+    end
+  end
+end

data/lib/configure_me/naming.rb

@@ -0,0 +1,18 @@
+module ConfigureMe
+  class Base
+    extend ActiveModel::Naming
+
+    class << self
+      def model_name
+        if persisting?
+          ConfigureMe.persistence_klass.model_name
+        else
+          super
+        end
+      end
+    end
+  end
+
+  module Naming
+  end
+end

data/lib/configure_me/nesting.rb

@@ -1,36 +1,42 @@
-require 'active_support/concern'
-
 module ConfigureMe
-  module Nesting
-    extend ActiveSupport::Concern
-
-    included do
-      @@nested = []
-    end
-
-    module ClassMethods
+  class Base
+    class << self
       def nest_me(klass, name = nil)
-        klass.nest(self)
-        @nested_name = name || klass.config_name
-      end
-
-      def nested
-        @nested ||= []
-      end
-
-      def nest(klass)
-        nested << klass
+        klass.instance.nest(self)
       end
     end
+  end
+
+  module Nesting
 
     def nest(klass)
-      @children[klass.config_name] = klass.instance
-      klass.instance.parent = self
+      children[klass.instance.config_name.to_sym] = klass.instance
+      klass.instance.parent_config = self
       self.class_eval <<-EOF, __FILE__, __LINE__
-        def #{klass.config_name}
-          @children['#{klass.config_name}']
+        def #{klass.instance.config_name}
+          children[:#{klass.instance.config_name.to_s}]
         end
       EOF
     end
+
+    def parent_config
+      @parent_config ||= nil
+    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)
+      end
+      res
+    end
   end
 end

data/lib/configure_me/persistence.rb

@@ -0,0 +1,29 @@
+module ConfigureMe
+  class Base
+    extend ActiveModel::Callbacks
+    define_model_callbacks :save
+  end
+  module Persistence
+
+    def save(*)
+      run_callbacks :save do
+        persist_guard do
+          temp_attributes.each_pair do |k,v|
+            write_persist(k, v)
+          end
+        end
+        temp_attributes.each_pair do |k,v|
+          write_cache(k, v)
+        end
+        make_clean
+      end
+    end
+
+    def update_attributes(new_attrs)
+      new_attrs.each_pair do |k,v|
+        write_attribute(k, v)
+      end
+      save
+    end
+  end
+end

data/lib/configure_me/persisting.rb

@@ -1,34 +1,47 @@
-require 'active_support/concern'
-
 module ConfigureMe
-  module Persisting
-    extend ActiveSupport::Concern
-
-    #included do
-    #  @persisting = false
-    #end
-
-    module ClassMethods
-      def persist_me(persistence_key = nil)
-        if ConfigureMe.persistence_klass.nil?
-          raise ::RuntimeError, "ConfigureMe: persistence_klass is not set.  Make sure you have an initializer to assign it."
-        end
+  class Base
+    class << self
+      def persist_me
         @persisting = true
       end
 
       def persisting?
         @persisting ||= false
+        @persisting && !ConfigureMe.persistence_klass.nil?
       end
+    end
+  end
 
-      def persistence_key
-        self.config_name
+  module Persisting
+
+    def read_persist(name)
+      if self.class.persisting?
+        setting = ConfigureMe.persistence_klass.find_by_key(self.storage_key(name))
+
+        unless setting.nil?
+          YAML.load(setting.value)
+        end
+      else
+        nil
       end
     end
 
-    def persistence_key(name)
-      key = "#{self.class.persistence_key}_#{name.to_s}"
-      key = @parent.persistence_key(key) unless @parent.nil?
-      key
+    def write_persist(name, value)
+      if self.class.persisting?
+        setting = ConfigureMe.persistence_klass.find_or_create_by_key(self.storage_key(name))
+        setting.value = value.to_yaml
+        setting.save!
+      else
+        true
+      end
+    end
+
+    def persist_guard(&block)
+      if ConfigureMe.persistence_klass.respond_to?(:transaction)
+        ConfigureMe.persistence_klass.transaction({}, &block)
+      else
+        block.call
+      end
     end
   end
 end