setting_accessors 0.0.1

data/lib/setting_accessors/setting_scaffold.rb

@@ -0,0 +1,252 @@
+#
+# Helper methods for the chosen setting model
+# They are in this module to leave the end developer some room for
+# his own methods in the setting model for his own methods.
+#
+
+module SettingAccessors::SettingScaffold
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.validates_with SettingAccessors::Validator
+    base.serialize :value
+
+    base.validates :name,
+                   :uniqueness => {:scope => [:assignable_type, :assignable_id]},
+                   :presence   => true
+  end
+
+  module ClassMethods
+    #
+    # Searches for a setting in the database and returns its value
+    #
+    # @param [String, Symbol] name
+    #   The setting's name
+    #
+    # @param [ActiveRecord::Base] assignable
+    #   If given, the setting searched has to be assigned to the given record
+    #   If not given, a global setting is searched
+    #
+    # @return [Object, NilClass]
+    #   If a setting is found, **its value** is returned.
+    #   If not, +nil+ is returned.
+    #
+    def [](name, assignable = nil)
+      self.setting_record(name, assignable).try(:value)
+    end
+
+    alias_method :get, :[]
+
+    #
+    # Tries to look the setting up using #get, if no existing setting is found,
+    # the setting's default value is returned.
+    #
+    def get_or_default(name, assignable = nil)
+      if (val = self[name, assignable]).nil?
+        self.new(:name => name, :assignable => assignable).default_value
+      else
+        val
+      end
+    end
+
+    #
+    # Creates or updates the setting with the given name
+    #
+    # @param [String, Symbol] name
+    #   The setting's name
+    #
+    # @param [Object] value
+    #   The new setting value
+    #
+    # @param [ActiveRecord::Base] assignable
+    #   The optional record this setting belongs to. If not
+    #   given, the setting is global.
+    #
+    # @param [Boolean] return_value
+    #   If set to +true+, only the setting's value is returned
+    #
+    # @return [Object, Setting]
+    #   Depending on +return_value+ either the newly created Setting record
+    #   or the newly assigned value.
+    #   This is due to the fact that Setting.my_setting = 'something' should
+    #   show the same behaviour as other attribute assigns in the system while
+    #   you  might still want to get validation errors on custom settings.
+    #
+    #   Please note that - if +return_value+ is set to +true+,
+    #   #save! is used instead of #save to ensure that validation
+    #   errors are noticed by the programmer / user.
+    #   As this is usually only the case when coming from method_missing,
+    #   it should not happen anyways
+    #
+    # @toto: Bless the rains down in Africa!
+    #
+    def create_or_update(name, value, assignable = nil, return_value = false)
+      setting       = self.setting_record(name, assignable)
+      setting     ||= self.new(:name => name, :assignable => assignable)
+      setting.set_value(value)
+
+      if return_value
+        setting.save!
+        setting.value
+      else
+        setting.save
+        setting
+      end
+    end
+
+    #
+    # Shortcut for #create_or_update
+    #
+    # @param [String, Symbol] name
+    #   The setting's name
+    #
+    # The second argument is an optional assignable
+    #
+    def []=(name, *args)
+      assignable = args.size > 1 ? args.first : nil
+      self.create_or_update(name, args.last, assignable, true)
+    end
+
+    #
+    # Creates a new setting for the given name and assignable,
+    # using the setting's default value stored in the config file
+    #
+    # If the setting already exists, its value will not be overridden
+    #
+    # @param [String] name
+    #   The setting's name
+    #
+    # @param [ActiveRecord::Base] assignable
+    #   An optional assignable
+    #
+    # @example Create a global default setting 'meaning_of_life'
+    #   Setting.create_default_setting(:meaning_of_life)
+    #
+    # @example Create a default setting for all users in the system
+    #   User.all.each { |u| Setting.create_default_setting(:some_setting, u) }
+    #
+    def create_default_setting(name, assignable = nil)
+      self.create_or_update(name, self.get_or_default(name, assignable), assignable)
+    end
+
+    #
+    # @return [Object] the default value for the given setting
+    #
+    def get_default_value(name, assignable = nil)
+      self.new(:name => name, :assignable => assignable).default_value
+    end
+
+    #
+    # Looks up a setting record for the given name and assignable
+    # Unlike the other methods here, this one actually returns a Setting object
+    # instead of its value.
+    #
+    # @return [Setting, NilClass] The found setting or nil if not existing
+    #
+    def setting_record(name, assignable = nil)
+      self.find_by(:name => name.to_s, :assignable => assignable)
+    end
+
+    #
+    # Tests, if the given value would be valid for the given
+    # setting name. This is done in this class method due to
+    # the process of setting creation through assigned records
+    # which does not allow going the "normal" way of testing whether
+    # a setting was saved correctly or not.
+    #
+    # @return [Array<String>] The validation errors for the setting's value
+    #
+    def validation_errors(name, value, assignable = nil)
+      s = self.new(:name => name, :value => value, :assignable => assignable)
+      s.valid?
+      s.errors.get(:value) || []
+    end
+  end
+
+  #
+  # @return [String] the localized setting name
+  #   they are stored in config/locales/settings.LOCALE.yml
+  #
+  def localized_name
+    i18n_lookup(:name)
+  end
+
+  #
+  # @return [String] the localized setting description
+  #   see #localized_name
+  #
+  def localized_description
+    i18n_lookup(:description)
+  end
+
+  #
+  # Performs an I18n lookup in the settings locale.
+  # Class based settings are store in 'settings.CLASS.NAME', globally defined settings
+  # in 'settings.global.NAME'
+  #
+  def i18n_lookup(key, options = {})
+    options[:scope] = [:settings, :global, self.name]
+    options[:scope] = [:settings, self.assignable.class.to_s.underscore, self.name] unless SettingAccessors::Internal.globally_defined_setting?(self.name)
+    I18n.t(key, options)
+  end
+
+  #
+  # @return [Object] the default value for the current setting
+  #
+  def default_value
+    data['default']
+  end
+
+  #
+  # @return [String] the setting's type as specified in settings.yml
+  #   If the setting wasn't specified, a polymorphic type is assumed
+  #
+  def value_type
+    data['type'] || 'polymorphic'
+  end
+
+  #
+  # @return [Object] the setting's value before it was type casted using the defined rule in settings.yml
+  #   See #value_before_type_cast for ActiveRecord attributes
+  #
+  # We can't use the name #value_before_type_cast here as it would
+  # shadow ActiveRecord's default one - which might still be needed.
+  #
+  def original_value
+    @original_value || self.value
+  end
+
+  #
+  # Sets the setting's value to the given one
+  # Performs automatic type casts
+  #
+  def set_value(new_value)
+    @original_value = new_value
+    self.value      = converter.convert(new_value)
+  end
+
+  private
+
+  def converter
+    @converter ||= SettingAccessors::Internal.converter(value_type)
+  end
+
+  def value_required?
+    !!validations['required']
+  end
+
+  #
+  # Accessor to the validations part of the setting's data
+  #
+  def validations
+    data['validates'] || {}
+  end
+
+  #
+  # @see {SettingAccessors::Internal#setting_data} for more information
+  #
+  def data
+    SettingAccessors::Internal.setting_data(name, assignable)
+  end
+
+end

data/lib/setting_accessors/validator.rb

@@ -0,0 +1,144 @@
+class SettingAccessors::Validator < ActiveModel::Validator
+
+  def validate(record)
+    record.send(:validations).each do |key, requirement|
+      if key.to_s == 'custom'
+        Array(requirement).each do |validation|
+          run_custom_validation(record, validation)
+        end
+      elsif built_in_validation?(key)
+        send("validate_#{key}", record, requirement)
+      else
+        raise ArgumentError.new("The invalid validation '#{key}' was given in model '#{defining_model(record).to_s}'")
+      end
+    end
+  end
+
+  private
+
+  def defining_model(record)
+    if SettingAccessors::Internal.globally_defined_setting?(record.name) || !record.assignable
+      SettingAccessors.setting_class
+    else
+      record.assignable.class
+    end
+  end
+
+  #
+  # Runs a custom validation method
+  # The method may either be a Proc or an instance method in +record+.+class+
+  #
+  def run_custom_validation(record, proc)
+    case proc
+    when Proc
+      proc.call(record)
+    when Symbol
+      if defining_model(record).respond_to?(proc)
+        defining_model(record).send(proc)
+      else
+        raise ArgumentError.new "The method '#{proc}' was set up as validation method in model '#{defining_model(record).name}', but doesn't exist."
+      end
+    else
+      raise ArgumentError.new "An invalid validations method was given ('#{proc}')"
+    end
+  end
+
+  #
+  # @return [TrueClass, FalseClass] +true+ if the given validation
+  #  is a built-in one.
+  #
+  def built_in_validation?(validation_name)
+    private_methods.include?("validate_#{validation_name}".to_sym)
+  end
+
+  #
+  # Validates that the setting's value is given
+  # accepts :allow_blank and :allow_nil as options
+  #
+  def validate_presence(record, requirement)
+    return true unless requirement
+
+    if requirement.is_a?(Hash)
+      if requirement['allow_blank'] && !record.value.nil? ||
+           requirement['allow_nil'] && record.value.nil? ||
+           record.value.present?
+        true
+      else
+        add_error record, :blank
+        false
+      end
+    else
+      add_error_if record.value.nil? || record.value == '', record, :blank
+    end
+  end
+
+  #
+  # Validates numericality of the setting's value based on the options given
+  # in settings.yml
+  #
+  def validate_numericality(record, options)
+    #Test if the value is Numeric in any way (float or int)
+    add_error_if(!parse_value_as_numeric(record.value), record, :not_a_number) && return
+
+    #If the validation was set to check for integer values, do that as well
+    add_error_if(options['only_integer'] && !parse_value_as_fixnum(record.value), record, :not_an_integer)
+  end
+
+  #
+  # Validates whether the given value is a valid boolean
+  #
+  def validate_boolean(record, requirement)
+    add_error_if(requirement && parse_value_as_boolean(record.value).nil?, record, :not_a_boolean)
+  end
+
+  #----------------------------------------------------------------
+  #                        Helper Methods
+  #----------------------------------------------------------------
+
+  def add_error(record, validation, options = {})
+    record.errors.add :value, validation, options
+  end
+
+  def add_error_if(cond, record, validation, options = {})
+    add_error(record, validation, options) if cond
+    cond
+  end
+
+  #
+  # Borrowed from Rails' numericality validator
+  # @return [Float, NilClass] the given String value as a float or nil
+  #   if the value was not a valid Numeric
+  #
+  def parse_value_as_numeric(raw_value)
+    Kernel.Float(raw_value) if raw_value !~ /\A0[xX]/
+  rescue ArgumentError, TypeError
+    nil
+  end
+
+  #
+  # Borrowed from Rails' numericality validator
+  #
+  # @return [Fixnum, NilClass] the given String value as an int or nil
+  #
+  def parse_value_as_fixnum(raw_value)
+    raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
+  end
+
+  #
+  # Tries to parse the given value as a boolean value
+  #
+  # @return [TrueClass, FalseClass, NilClass]
+  #
+  def parse_value_as_boolean(raw_value)
+    case raw_value
+      when TrueClass, FalseClass
+        raw_value
+      when String
+        return true  if %w[true 1].include?(raw_value.downcase)
+        return false if %w[false 0].include?(raw_value.downcase)
+        nil
+      else
+        nil
+    end
+  end
+end

data/lib/setting_accessors/version.rb

@@ -0,0 +1,3 @@
+module SettingAccessors
+  VERSION = '0.0.1'
+end

data/lib/tasks/setting_accessors_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :setting_accessors do
+#   # Task goes here
+# end

data/setting_accessors.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'setting_accessors/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'setting_accessors'
+  spec.version       = SettingAccessors::VERSION
+  spec.authors       = ["Stefan Exner"]
+  spec.email         = ["stex@sterex.de"]
+  spec.summary       = %q{A global key-value-store and virtual model columns}
+  spec.description   = %q{Adds a global key-value-store to Rails applications and allows adding typed columns
+                          to model classes without having to change the database layout.}
+  spec.homepage      = 'https://www.github.com/stex/setting_accessors'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency 'sqlite3', '~> 1.3'
+  spec.add_development_dependency 'shoulda', '~> 3.5'
+  spec.add_development_dependency 'minitest', '~> 5.5'
+  spec.add_development_dependency 'byebug', '~> 3.5'
+
+  spec.add_dependency 'rails', '~> 4'
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.