settingcrazy 0.0.2

data/lib/settingcrazy/namespace.rb

@@ -0,0 +1,14 @@
+module SettingCrazy
+  class Namespace
+    attr_reader :template
+
+    def initialize(name, options = {})
+      @name     = name.to_sym
+      @template = options[:template]
+    end
+
+    def name
+      @name.to_s
+    end
+  end
+end

data/lib/settingcrazy/namespaced_settings_proxy.rb

@@ -0,0 +1,18 @@
+module SettingCrazy
+  class NamespacedSettingsProxy < SettingsProxy
+    def initialize(model, namespace)
+      @model      = model
+      @namespace  = namespace
+      @template   = namespace.template
+    end
+
+    protected
+      def build_value(key, value)
+        @model.setting_values.build(:key => key, :value => value, :namespace => @namespace.name)
+      end
+
+      def setting_values
+        @model.setting_values.select{ |sv| sv.namespace == @namespace.name }
+      end
+  end
+end

data/lib/settingcrazy/setting_value.rb

@@ -0,0 +1,11 @@
+module SettingCrazy
+  class SettingValue < ActiveRecord::Base
+    attr_accessible :key, :value, :namespace
+    serialize :value
+    belongs_to :settable, :polymorphic => true
+
+    def self.namespace(namespace)
+      where(:namespace => namespace)
+    end
+  end
+end

data/lib/settingcrazy/settings_proxy.rb

@@ -0,0 +1,107 @@
+module SettingCrazy
+  class SettingsProxy
+    attr_reader :template
+
+    def initialize(model, template)
+      @model      = model
+      @template   = template
+      @namespaces = model.class._setting_namespaces
+      # TODO: It would probably be a good idea to memoize the NamespacedSettingsProxies
+    end
+
+    def []=(key, value)
+      if @namespaces && namespace = @namespaces[key.to_sym]
+        return NamespacedSettingsProxy.new(@model, namespace).bulk_assign(value)
+      end
+
+      value.reject!(&:blank?) if value.respond_to?(:reject!)
+      sv = setting_record(key)
+      if sv.blank?
+        build_value(key, value)
+      else
+        sv.value = value
+      end
+    end
+
+    def [](key)
+      if @namespaces && namespace = @namespaces[key.to_sym]
+        return NamespacedSettingsProxy.new(@model, namespace)
+      end
+      sv = setting_record(key)
+      if sv.blank?
+        parent_value(key) || template_default_value(key) || nil
+      else
+        sv.value
+      end
+    end
+
+    def bulk_assign(attributes)
+      attributes.each do |(k,v)|
+        self[k] = v
+      end
+    end
+
+    def delete(key)
+      @model.setting_values.delete(setting_record(key))
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name =~ /=$/
+        attribute = method_name[0...-1]
+        self[attribute] = args.first
+      else
+        self[method_name]
+      end
+    end
+
+    def parent_settings
+      return nil unless @model.class._inheritor.present?
+      @model.class._inheritor.parent_settings_for(@model)
+    end
+
+    def each(&block)
+      setting_values.each(&block)
+    end
+
+    def map(&block)
+      setting_values.map(&block)
+    end
+
+    def inspect
+      @model.reload unless @model.new_record?
+      self.to_hash.inspect
+    end
+
+    def to_hash
+      setting_values.inject({}) do |hash, sv|
+        hash[sv.key] = sv.value
+        hash
+      end.symbolize_keys
+    end
+
+    protected
+      def template_default_value(key)
+        template.present? ? template.defaults[key] : nil
+      end
+
+      def parent_value(key)
+        parent_settings.present? ? parent_settings[key] : nil
+      end
+
+      def setting_record(attribute)
+        # Check valid template attrs
+        if template.present? && !template.valid_option?(attribute)
+          raise ActiveRecord::UnknownAttributeError
+        end
+        setting_values.select{|sv| sv.key.to_sym == attribute.to_sym }.last # When updating an existing setting_value, the new value comes after the existing value in the array.
+      end
+
+      def build_value(key, value)
+        @model.setting_values.build(:key => key, :value => value)
+      end
+
+      def setting_values
+        @model.setting_values
+      end
+  end
+end

data/lib/settingcrazy/settings_validator.rb

@@ -0,0 +1,43 @@
+class SettingsValidator < ActiveModel::Validator
+  attr_accessor :record, :settings, :template
+
+  def validate(record)
+    self.record  = record
+    self.settings = record.settings
+    self.template = settings.template
+
+    if record.persisted? && template.present? # Not to valid setting_values for unsaved owner & Validate only if the template exists
+      template.enums.symbolize_keys.each do |key, name_value_pairs|
+        enum_options  = template.enum_options(key)
+        current_value = settings.send(key)
+
+        validate_presence(key, current_value)                            if enum_options[:required]
+        validate_singleness(key, current_value)                      unless enum_options[:multiple]
+        validate_dependent(key, current_value, enum_options[:dependent]) if enum_options[:dependent] && current_value.present?
+        validate_range(key, current_value, name_value_pairs.values)      if enum_options[:type] != 'text' && current_value.present?
+      end
+    end
+  end
+
+  protected
+    def validate_presence(key, value)
+      @record.errors.add key, "Setting, '#{template.name_for(key)}', is required" if value.blank?
+    end
+
+    def validate_singleness(key, value)
+      @record.errors.add key, "Cannot save multiple values for Setting, '#{template.name_for(key)}'" if value.instance_of?(Array)
+    end
+
+    def validate_dependent(key, value, conditions)
+      conditions.each do |dependent_on_key, dependent_on_value|
+        @record.errors.add key, "'#{template.name_for(key)}' can only be specified if '#{template.name_for(dependent_on_key)}' is set to '#{dependent_on_value}'" unless settings.send(dependent_on_key) == dependent_on_value
+      end
+    end
+
+    def validate_range(key, value, enum_values)
+      values = value.instance_of?(Array) ? value : [value]
+      values.each do |v|
+        @record.errors.add key, "'#{v}' is not a valid setting for '#{template.name_for(key)}'" unless enum_values.include?(v)
+      end
+    end
+end

data/lib/settingcrazy/template.rb

@@ -0,0 +1,2 @@
+require_relative 'template/base'
+require_relative 'template/enum'

data/lib/settingcrazy/template/base.rb

@@ -0,0 +1,66 @@
+module SettingCrazy
+  module Template
+    class Base
+
+      class << self
+
+        def enum(id, name=id.to_s, options={}, &block)
+          enums[id] = SettingCrazy::Template::Enum.new(name, options, &block)
+        end
+
+        def enums
+          @enums ||= {}
+        end
+
+        def enum_options(key)
+          enums[key].options
+        end
+
+        # Returns an array suitable for use in options_for_select helper
+        # Example:
+        #
+        #   options_for_select(GoogleSettings::Campaign.options(:platform))
+        #
+        def options(name)
+          enum = enums[name]
+          return [] if enum.blank?
+          enum.to_a
+        end
+
+        def name_for(id)
+          raise "No setting with id '#{id}'" unless enums.has_key?(id)
+          enums[id].name
+        end
+
+        # Returns the available options for the setting object
+        def available_options(key=nil)
+          key.nil? ? enums : enums[key.to_sym]
+        end
+
+        # Returns whether single keyword valid
+        # TODO: Allow passing of key or array of keys
+        def valid_option?(key)
+          key = key.to_s.gsub(/\=$/,'').to_sym #strip setter (=) from key, so can just check options hash
+          available_options.keys.include?(key)
+        end
+
+        def defaults
+          {}
+        end
+
+        # # Maybe too complicated
+        # def self.validator_klass
+        #   class_eval <<-STR
+        #     class MyValidator < ActiveModel::Validator
+        #       validates :display, :presence => true
+        #     end
+        #   STR
+        # end
+
+        # def validator
+        #   self.class.validator.new
+        # end
+      end
+    end
+  end
+end

data/lib/settingcrazy/template/enum.rb

@@ -0,0 +1,19 @@
+module SettingCrazy
+  module Template
+
+    class Enum < Hash
+      attr_reader :name, :options
+
+      def initialize(name, options, &block)
+        super()
+        @name    = name
+        @options = options
+        instance_eval(&block)
+      end
+
+      def value(enum_value, description = enum_value)
+        self[description] = enum_value
+      end
+    end
+  end
+end

data/lib/settingcrazy/version.rb

@@ -0,0 +1,3 @@
+module SettingCrazy
+  VERSION = "0.0.2"
+end

data/settingcrazy.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/settingcrazy/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Dan Draper"]
+  gem.email         = ["daniel@codefire.com"]
+  gem.description   = %q{An advanced setting manager for ActiveRecord models}
+  gem.summary       = %q{An advanced setting manager for ActiveRecord models}
+  gem.homepage      = ""
+
+  gem.add_development_dependency "rspec", "~> 2.11.0"
+  gem.add_development_dependency "activerecord", "~> 3"
+  gem.add_development_dependency "sqlite3"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "settingcrazy"
+  gem.require_paths = ["lib"]
+  gem.version       = SettingCrazy::VERSION
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe SettingCrazy do
+  describe "settings from parent" do
+
+    context "when parent present" do
+      let!(:farm) { Farm.create(:name => "Old MacDonald's") }
+      let!(:duck) { farm.ducks.create(:name => "Drake", :quacks => 10) }
+      subject     { duck.settings }
+      
+      before do
+        farm.settings.color = "brown"
+        farm.save!
+      end
+
+      its(:color) { should == "brown" }
+    end
+
+    context "when there is no parent" do
+      let!(:duck) { Duck.create(:name => "Drake", :quacks => 10) }
+      subject     { duck.settings }
+      its(:color) { should be(nil) }
+    end
+
+    context "from a specific namespace on the parent" do
+      let!(:scenario) { Scenario.create(:name => "Scen") }
+      let!(:campaign) { scenario.campaigns.create(:name => "Regular campaign") }
+      subject         { campaign.settings }
+
+      before do
+        scenario.settings.yahoo.network = "don't care"
+        scenario.settings.google.network = "search"
+        scenario.save!
+      end
+
+      its(:network) { should == "search" }
+    end
+
+    context "from a specific namespace on the parent but set via a Proc" do
+      let!(:scenario)           { Scenario.create(:name => "Scen") }
+      let!(:clever_campaign_g)  { scenario.clever_campaigns.create(:name => "Clever campaign", :setting_namespace => "google") }
+      let!(:clever_campaign_y)  { scenario.clever_campaigns.create(:name => "Clever campaign", :setting_namespace => "yahoo") }
+
+      before do
+        scenario.settings.yahoo.network = "something"
+        scenario.settings.google.network = "another thing"
+        scenario.save!
+      end
+
+      context "yahoo" do
+        subject       { clever_campaign_y.settings }
+        its(:network) { should == "something" }
+      end
+
+      context "google" do
+        subject       { clever_campaign_g.settings }
+        its(:network) { should == "another thing" }
+      end
+    end
+  end
+    
+  context "when the parent has a template" do
+    subject { note.settings }
+
+    context "and the parent is present" do
+      let!(:_case) { Case.create(:name => "Snowtown") }
+      let!(:note)  { _case.notes.create(:name => "The Murderer") }
+      its(:foo)    { should == "1234" }
+    end
+
+    context "but the parent is missing" do
+      let!(:note) { Note.create(:name => "Orphaned") }
+      its(:foo)   { should be(nil) }
+    end
+  end
+end

data/spec/mass_assignment_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe VendorInstance do
+  let(:model) { VendorInstance.create(:name => "VI") }
+  subject { model.settings }
+
+  context "settings direct assignment" do
+    before do
+      model.settings = {
+        :foo => "1234",
+        :bar => "abcd"
+      }
+      model.save!
+    end
+
+    its(:foo) { should == "1234" }
+    its(:bar) { should == "abcd" }
+  end
+
+  context "mass assignment" do
+    before do
+      model.attributes = {
+        :settings => {
+          :foo => "some value",
+          :wee => "another",
+        }
+      }
+      model.save!
+    end
+
+    its(:foo) { should == "some value" }
+    its(:wee) { should == "another" }
+  end
+
+  describe "setting namespaces" do
+    let(:model) { Scenario.create(:name => "Scenario") }
+    subject     { model.settings.google }
+
+    context "direct assignment" do
+      before do
+        model.settings.google = {
+          :foo => "1234",
+          :bar => "abcd"
+        }
+        model.save!
+      end
+
+      its(:foo) { should == "1234" }
+      its(:bar) { should == "abcd" }
+    end
+
+    context "mass assignment" do
+      before do
+        model.attributes = {
+          :settings => {
+            :google => {
+              :foo => "some value",
+              :wee => "another",
+            }
+          }
+        }
+        model.save!
+      end
+
+      its(:foo) { should == "some value" }
+      its(:wee) { should == "another" }
+    end
+  end
+end