setting_accessors 0.0.1

data/lib/setting_accessors.rb

@@ -0,0 +1,26 @@
+require 'setting_accessors/version'
+require 'setting_accessors/accessor'
+require 'setting_accessors/converter'
+require 'setting_accessors/integration'
+require 'setting_accessors/integration_validator'
+require 'setting_accessors/internal'
+require 'setting_accessors/setting_scaffold'
+require 'setting_accessors/validator'
+
+ActiveRecord::Base.class_eval do
+  include SettingAccessors::Integration
+end
+
+module SettingAccessors
+  def self.setting_class
+    self.setting_class_name.constantize
+  end
+
+  def self.setting_class=(klass)
+    @@setting_class = klass.to_s
+  end
+
+  def self.setting_class_name
+    (@@setting_class ||= 'Setting').camelize
+  end
+end

data/lib/setting_accessors/accessor.rb

@@ -0,0 +1,148 @@
+#
+# Helper class to make accessing record specific settings easier
+#
+
+class SettingAccessors::Accessor
+
+  def initialize(record)
+    @record        = record
+    @temp_settings = {}
+  end
+
+  #
+  # Gets a setting's value
+  #
+  def [](key)
+    @temp_settings[key.to_sym] || SettingAccessors.setting_class.get(key, @record)
+  end
+
+  def has_key?(key)
+    @temp_settings.has_key?(key.to_sym)
+  end
+
+  #
+  # Writes a setting's value
+  #
+  def []=(key, val)
+    set_value_before_type_cast(key, val)
+    @temp_settings[key.to_sym] = SettingAccessors::Internal.converter(value_type(key)).convert(val)
+  end
+
+  #
+  # Tries to find a setting for this record.
+  # If none is found, will return the default setting value
+  # specified in the setting config file.
+  #
+  def get_or_default(key)
+    self[key] || SettingAccessors.setting_class.get_or_default(key, @record)
+  end
+
+  #
+  # Tries to find a setting for this record first.
+  # If none is found, tries to find a global setting with the same name
+  #
+  def get_or_global(key)
+    self[key] || SettingAccessors.setting_class.get(key)
+  end
+
+  #
+  # Tries to find a setting for this record first,
+  # if none is found, it will return the given value instead.
+  #
+  def get_or_value(key, value)
+    self.has_key?(key) ? self[key] : value
+  end
+
+  def get_with_fallback(key, fallback = nil)
+    return self[key] if fallback.nil?
+
+    case fallback.to_s
+      when 'default' then get_or_default(key)
+      when 'global'  then get_or_global(key)
+      else get_or_value(key, fallback)
+    end
+  end
+
+  #
+  # @return [String] the setting's value type in the +@record+'s context
+  #
+  def value_type(key)
+    SettingAccessors::Internal.setting_value_type(key, @record)
+  end
+
+  #----------------------------------------------------------------
+  #               ActiveRecord Helper Methods Emulation
+  #----------------------------------------------------------------
+
+  def value_was(key, fallback = nil)
+    return SettingAccessors.setting_class.get(key, @record) if fallback.nil?
+
+    case fallback.to_s
+      when 'default' then SettingAccessors.setting_class.get_or_default(key, @record)
+      when 'global'  then SettingAccessors.setting_class.get(key)
+      else fallback
+    end
+  end
+
+  def value_changed?(key)
+    self[key] != value_was(key)
+  end
+
+  def value_before_type_cast(key)
+    SettingAccessors::Internal.lookup_nested_hash(@values_before_type_casts, key.to_s) || self[key]
+  end
+
+  protected
+
+  #
+  # Keeps a record of the originally set value for a setting before it was
+  # automatically converted.
+  #
+  def set_value_before_type_cast(key, value)
+    @values_before_type_casts ||= {}
+    @values_before_type_casts[key.to_s] = value
+  end
+
+  #
+  # Validates the new setting values.
+  # If there is an accessor for the setting, the errors will be
+  # directly forwarded to it, otherwise to :base
+  #
+  # Please do not call this method directly, use the IntegrationValidator
+  # class instead, e.g.
+  #
+  #   validates_with SettingAccessors::IntegrationValidator
+  #
+  def validate!
+    @temp_settings.each do |key, value|
+      validation_errors = SettingAccessors.setting_class.validation_errors(key, value, @record)
+      validation_errors.each do |message|
+        if @record.respond_to?("#{key}=")
+          @record.errors.add(key, message)
+        else
+          @record.errors.add :base, :invalid_setting, :name => key, :message => message
+        end
+      end
+    end
+  end
+
+  #
+  # Saves the new setting values into the database
+  # Please note that there is no check if the values changed their
+  # in the meantime.
+  #
+  # Also, this method expects that the settings were validated
+  # before using #validate! and will therefore not perform
+  # validations itself.
+  #
+  def persist!
+    @temp_settings.each do |key, value|
+      Setting.create_or_update(key, value, @record)
+    end
+    flush!
+  end
+
+  def flush!
+    @temp_settings = {}
+  end
+end

data/lib/setting_accessors/converter.rb

@@ -0,0 +1,67 @@
+#
+# This class hopefully will hopefully one day mimic ActiveRecord's
+# attribute assigning methods, meaning that a conversion to the column type
+# is done as soon as a new value is assigned by the programmer.
+#
+# If the value cannot be parsed in the required type, +nil+ is assigned.
+# Please make sure that you specify the correct validations in settings.yml
+# to avoid this.
+#
+# Currently supported types:
+#   - Fixnum
+#   - String
+#   - Boolean
+#
+# If the type is 'polymorphic', it is not converted at all.
+#
+class SettingAccessors::Converter
+
+  def initialize(value_type)
+    @value_type = value_type
+  end
+
+  #
+  # Converts the setting's value to the correct type
+  #
+  def convert(new_value)
+    #If the value is set to be polymorphic, we don't have to convert anything.
+    return new_value if @value_type == 'polymorphic'
+
+    parse_method = :"parse_#{@value_type}"
+
+    if private_methods.include?(parse_method)
+      send(parse_method, new_value)
+    else
+      Rails.logger.warn("Invalid Setting type: #{@value_type}")
+      new_value
+    end
+  end
+
+  private
+
+  def parse_boolean(value)
+    case value
+      when TrueClass, FalseClass
+        value
+      when String
+        return true if %w[true 1].include?(value.downcase)
+        return false if %w[false 0].include?(value.downcase)
+        nil
+      when Fixnum
+        return true if value == 1
+        return false if value.zero?
+        nil
+      else
+        nil
+    end
+  end
+
+  def parse_integer(value)
+    value.to_i
+  end
+
+  def parse_string(value)
+    value.to_s
+  end
+
+end

data/lib/setting_accessors/integration.rb

@@ -0,0 +1,79 @@
+module SettingAccessors::Integration
+  def self.included(base)
+    base.validates_with SettingAccessors::IntegrationValidator
+
+    #After the main record was saved, we can save its settings.
+    #This is necessary as the record might have been a new record
+    #without an ID yet
+    base.after_save do
+      settings.send(:persist!)
+    end
+
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    #
+    # Generates a new accessor (=getter and setter) for the given setting
+    #
+    # @param [String, Symbol] setting_name
+    #   The setting's name
+    #
+    # @param [Hash] options
+    #   Options to customize the behaviour of the generated accessor
+    #
+    # @option options [Symbol, Object] :fallback (nil)
+    #   If set to +:default+, the getter will return the setting's default
+    #   value if no own value was specified for this record
+    #
+    #   If set to +:global+, the getter will try to find a global
+    #   setting if no record specific setting was found
+    #
+    #   If set to another value, this value is used by default
+    #
+    #   If not set at all or to +nil+, the getter will only search for a record specific
+    #   setting and return +nil+ if none was specified previously.
+    #
+    def setting_accessor(setting_name, options = {})
+      fallback = options.delete(:fallback)
+
+      SettingAccessors::Internal.set_class_setting(self, setting_name, options)
+
+      #Create a virtual column in the models column hash.
+      #This is currently not absolutely necessary, but will become important once
+      #Time etc. are supported. Otherwise, Rails won't be able to e.g. automatically
+      #create multi-param fields in forms.
+      self.columns_hash[setting_name.to_s] = OpenStruct.new(type: SettingAccessors::Internal.setting_value_type(setting_name, self.new).to_sym)
+
+      #Getter
+      define_method(setting_name) do
+        settings.get_with_fallback(setting_name, fallback)
+      end
+
+      # Setter
+      define_method("#{setting_name}=") do |new_value|
+        settings[setting_name] = new_value
+      end
+
+      #NAME_was
+      define_method("#{setting_name}_was") do
+        settings.value_was(setting_name, fallback)
+      end
+
+      #NAME_before_type_cast
+      define_method("#{setting_name}_before_type_cast") do
+        settings.value_before_type_cast(setting_name)
+      end
+
+      #NAME_changed?
+      define_method("#{setting_name}_changed?") do
+        settings.value_changed?(setting_name)
+      end
+    end
+  end
+
+  def settings
+    @settings_accessor ||= SettingAccessors::Accessor.new(self)
+  end
+end

data/lib/setting_accessors/integration_validator.rb

@@ -0,0 +1,15 @@
+#
+# This class handles model validations for assigned records, e.g.
+# if the settings are accessed using the Accessor class in this module.
+# Only the new temp values are validated using the setting config.
+#
+# The main work is still done in the Accessor class, so we don't have
+# to access its instance variables here, this class acts as a wrapper
+# for Rails' validation chain
+#
+
+class SettingAccessors::IntegrationValidator < ActiveModel::Validator
+  def validate(record)
+    record.settings.send(:validate!)
+  end
+end

data/lib/setting_accessors/internal.rb

@@ -0,0 +1,108 @@
+#
+# This module contains class methods used internally.
+#
+module SettingAccessors
+  module Internal
+
+    def self.ensure_nested_hash!(hash, *keys)
+      h = hash
+      keys.each do |key|
+        h[key] ||= {}
+        h = h[key]
+      end
+    end
+
+    def self.lookup_nested_hash(hash, *keys)
+      return nil if hash.nil?
+
+      h = hash
+      keys.each do |key|
+        return nil if h[key].nil?
+        h = h[key]
+      end
+      h
+    end
+
+    #
+    # Loads information about all settings from YAML file
+    # These are cached in the class so they don't have to be reloaded
+    # every time.
+    #
+    # Note: For development / test, this is flushed every time
+    #
+    def self.global_config
+      if Rails.env.test? || Rails.env.development?
+        YAML.load(File.open(Rails.root.join('config/settings.yml'))).deep_stringify_keys
+      else
+        @@config ||= YAML.load(File.open(Rails.root.join('config/settings.yml'))).deep_stringify_keys
+      end
+    end
+
+    #
+    # @return [TrueClass, FalseClass] +true+ if the setting is defined in config/settings.yml
+    #
+    def self.globally_defined_setting?(setting_name)
+      self.global_config[setting_name.to_s].present?
+    end
+
+    #
+    # Sets a class-specific setting
+    # For global settings, this is done in config/settings.yml
+    # Please do not call this method yourself, it is done automatically
+    # by using setting_accessor in your model class
+    #
+    def self.set_class_setting(klass, setting_name, options = {})
+      @@class_settings ||= {}
+
+      #If there are no options given, the setting *has* to be defined globally.
+      if options.empty? && !self.globally_defined_setting?(setting_name)
+        raise ArgumentError.new "The setting '#{setting_name}' in model '#{klass.to_s}' is neither globally defined nor did it receive options"
+
+      #A setting which is already globally defined, may not be re-defined on class base
+      elsif self.globally_defined_setting?(setting_name) && options.any?
+        raise ArgumentError.new("The setting #{setting_name} is already defined in config/settings.yml and may not be redefined in #{klass}")
+
+      #If the setting is defined on class base, we have to store its options
+      elsif options.any? && !self.globally_defined_setting?(setting_name)
+        self.ensure_nested_hash!(@@class_settings, klass.to_s)
+        @@class_settings[klass.to_s][setting_name.to_s] = options.deep_stringify_keys
+      end
+    end
+
+
+    #
+    # @return [Hash] configuration data regarding this setting
+    #
+    #   - If it's a globally defined setting, the value is taken from config/settings.yml
+    #   - If it's a setting defined in a setting_accessor call, the information is taken from this call
+    #   - Otherwise, an empty hash is returned
+    #
+    def self.setting_data(setting_name, assignable = nil)
+      (assignable && self.get_class_setting(assignable.class, setting_name)) ||
+          self.global_config[setting_name.to_s] ||
+          {}
+    end
+
+    #
+    # @return [String] the given setting's value type
+    #
+    def self.setting_value_type(*args)
+      self.setting_data(*args)['type'] || 'polymorphic'
+    end
+
+    #
+    # @return [SettingAccessors::Converter] A value converter for the given type
+    #
+    def self.converter(value_type)
+      @@converters ||= {}
+      @@converters[value_type.to_sym] ||= SettingAccessors::Converter.new(value_type)
+    end
+
+    #
+    # @return [Hash, NilClass] Information about a class specific setting or +nil+ if it wasn't set before
+    #
+    def self.get_class_setting(klass, setting_name)
+      self.lookup_nested_hash(@@class_settings, klass.to_s, setting_name.to_s)
+    end
+  end
+end