setting_accessors 0.3.0 → 1.0.0

data/lib/setting_accessors/converters/polymorphic_converter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SettingAccessors
+  module Converters
+    class PolymorphicConverter < Base
+      def parse_value
+        value
+      end
+    end
+  end
+end

data/lib/setting_accessors/converters/string_converter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SettingAccessors
+  module Converters
+    class StringConverter < Base
+      def parse_value
+        value.to_s
+      end
+    end
+  end
+end

data/lib/setting_accessors/helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SettingAccessors
+  module Helpers
+    class Error < StandardError; end
+    class NestedHashKeyNotFoundException < Error; end
+
+    def ensure_nested_hash!(hash, *keys)
+      h = hash
+      keys.each do |key|
+        h[key] ||= {}
+        h = h[key]
+      end
+    end
+
+    def lookup_nested_hash(hash, *keys)
+      fail NestedHashKeyNotFoundException if hash.nil?
+
+      h = hash
+      keys.each do |key|
+        fail NestedHashKeyNotFoundException unless h.key?(key)
+
+        h = h[key]
+      end
+      h
+    end
+  end
+end

data/lib/setting_accessors/integration.rb

@@ -1,117 +1,103 @@
-module SettingAccessors::Integration
-  def self.included(base)
-    base.validates_with SettingAccessors::IntegrationValidator
+# frozen_string_literal: true
+
+module SettingAccessors
+  module Integration
+    def self.included(base)
+      # 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!)
+
+        # From AR 5.1 on, #_update actually checks whether the changed "attributes" are actually
+        # table columns or not. If no actual changed columns were found, the record is not changed and
+        # only the after_* callbacks are executed.
+        # This means that the settings are persisted, but the record's +updated_at+ column is not updated.
+        #
+        # This workaround triggers a #touch on the record in case no actual column change already
+        # triggered a timestamp update.
+        #
+        # TODO: This might lead to #after_commit being triggered twice, once by #update_* and once by #touch
+        touch if @_setting_accessors_touch_assignable
+        @_setting_accessors_touch_assignable = false
+      end
 
-    # 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!)
+      base.extend ClassMethods
     end
 
-    base.extend ClassMethods
-  end
-
-  module ClassMethods
+    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
+      #
+      def setting_accessor(setting_name, **options)
+        generator = AccessorGenerator.new(setting_name, **options)
+        generator.assign_setting!(self)
+      end
+    end
 
     #
-    # Generates a new accessor (=getter and setter) for the given setting
-    #
-    # @param [String, Symbol] setting_name
-    #   The setting's name
+    # Previously read setting values have to be refreshed if a record is reloaded.
+    # Without this, #reload'ing a record would not update its setting values to the
+    # latest database version if they were previously read.
     #
-    # @param [Hash] options
-    #   Options to customize the behaviour of the generated accessor
+    # Example to demonstrate the problem with this override:
+    #   user = User.create(:a_boolean => true)
+    #   user_alias = User.find(user.id)
+    #   user.a_boolean = !user_alias.a_boolean
+    #   user.save
+    #   user_alias.reload
+    #   user_alias.a_boolean
+    #   #=> true
     #
-    # @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
+    def reload(*)
+      super.tap { @settings = nil }
+    end
+
     #
-    #   If set to +:global+, the getter will try to find a global
-    #   setting if no record specific setting was found
+    # Adds changed settings to ActiveModel's list of changed attributes.
+    # This is necessary for #changed? to work correctly without actually overriding
+    # the method itself.
     #
-    #   If set to another value, this value is used by default
+    # TODO: Check if it makes more sense to hook into AR5's AttributeMutationTracker instead
     #
-    #   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.
+    # @return [Hash] All changed attributes
     #
-    def setting_accessor(setting_name, options = {})
-      fallback = options.delete(:fallback)
-
-      SettingAccessors::Internal.set_class_setting(self, setting_name, options)
-
-      setting_type = SettingAccessors::Internal.setting_value_type(setting_name, self).to_sym
-
-      #Add the setting's name to the list of setting_accessors for this class
-      SettingAccessors::Internal.add_setting_accessor_name(self, setting_name)
-
-      # Getter
-      define_method(setting_name) do
-        settings.get_with_fallback(setting_name, fallback)
-      end
-
-      # Getter alias for boolean settings
-      alias_method "#{setting_name}?", setting_name if setting_type == :boolean
-
-      # 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
+    def changed_attributes
+      super.merge(settings.changed_settings)
+    end
 
-      #NAME_changed?
-      define_method("#{setting_name}_changed?") do
-        settings.value_changed?(setting_name)
+    #
+    # Marks the record to be #touch'd after updating it in case no actual
+    # attributes were involved and only settings were changed.
+    # This is necessary for ActiveRecord >= 5.1 which will not perform the
+    # timestamp updates if it thinks nothing actually changed.
+    #
+    if Gem.loaded_specs['activerecord'].version >= Gem::Version.create('5.1')
+      def _update_record(*)
+        super.tap do |affected_rows|
+          # Workaround to trigger a #touch if necessary, see +after_save+ callback further up
+          @_setting_accessors_touch_assignable = affected_rows.zero?
+        end
       end
     end
-  end
-
-  #
-  # Previously read setting values have to be refreshed if a record is reloaded.
-  # Without this, #reload'ing a record would not update its setting values to the
-  # latest database version if they were previously read.
-  #
-  # Example to demonstrate the problem with this override:
-  #   user = User.create(:a_boolean => true)
-  #   user_alias = User.find(user.id)
-  #   user.a_boolean = !user_alias.a_boolean
-  #   user.save
-  #   user_alias.reload
-  #   user_alias.a_boolean
-  #   #=> true
-  #
-  def reload(*)
-    super
-    @settings_accessor = nil
-    self
-  end
-
-  def as_json(options = {})
-    json = super options
 
-    setting_names = SettingAccessors::Internal.setting_accessor_names(self.class)
-    if only = options[:only]
-      setting_names &= Array(only).map(&:to_s)
-    elsif except = options[:except]
-      setting_names -= Array(except).map(&:to_s)
+    def as_json(options = {})
+      super.tap do |json|
+        SettingAccessors::Internal.json_setting_names(self.class, **options).each do |setting_name|
+          json[setting_name.to_s] = send(setting_name)
+        end
+      end
     end
 
-    setting_names.each do |setting_name|
-      json[setting_name.to_s] = send(setting_name)
+    def settings
+      @settings ||= SettingAccessors::SettingSet.new(self)
     end
-    json
-  end
-
-  def settings
-    @settings_accessor ||= SettingAccessors::Accessor.new(self)
   end
 end

data/lib/setting_accessors/internal.rb

@@ -1,48 +1,14 @@
+# frozen_string_literal: true
+
 #
 # This module contains class methods used internally.
 #
 module SettingAccessors
   module Internal
+    extend Helpers
 
-    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?
+    def self.class_settings
+      @@class_settings ||= {}
     end
 
     #
@@ -52,20 +18,14 @@ module SettingAccessors
     # 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
+      # If there are no options given, the setting *has* to be defined globally.
+      if options.empty?
+        raise ArgumentError, "The setting '#{setting_name}' in model '#{klass}' is lacking options."
+      # If the setting is defined on class base, we have to store its options
+      else
+        ensure_nested_hash!(class_settings, klass.to_s)
+        class_settings[klass.to_s][setting_name.to_s] = options.deep_stringify_keys
+        add_setting_accessor_name(klass, setting_name)
       end
     end
 
@@ -80,32 +40,30 @@ module SettingAccessors
       # As a convenience function (and to keep the existing code working),
       # it is possible to provide a class or an instance of said class
       assignable_class &&= assignable_class.class unless assignable_class.is_a?(Class)
-
-      (assignable_class && self.get_class_setting(assignable_class, setting_name)) ||
-          self.global_config[setting_name.to_s] ||
-          {}
+      (assignable_class && get_class_setting(assignable_class, setting_name)) || {}
     end
 
     #
     # @return [String] the given setting's value type
     #
     def self.setting_value_type(*args)
-      self.setting_data(*args)['type'] || 'polymorphic'
+      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)
+      Converters.const_get("#{value_type.to_s.camelize}Converter")
     end
 
     #
-    # @return [Hash, NilClass] Information about a class specific setting or +nil+ if it wasn't set before
+    # @return [Hash, nil] 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)
+      lookup_nested_hash(class_settings, klass.to_s, setting_name.to_s)
+    rescue ::SettingAccessors::Helpers::NestedHashKeyNotFoundException
+      nil
     end
 
     #
@@ -124,8 +82,23 @@ module SettingAccessors
     #
     def self.setting_accessor_names(klass)
       @@setting_accessor_names ||= {}
-      self.lookup_nested_hash(@@setting_accessor_names, klass.to_s) || []
+      lookup_nested_hash(@@setting_accessor_names, klass.to_s) || []
     end
 
+    #
+    # Mainly a helper for #as_json calls.
+    # Evaluates the given options and determines the setting names to be returned.
+    #
+    def self.json_setting_names(klass, **options)
+      setting_names = setting_accessor_names(klass)
+
+      if options[:only]
+        setting_names & Array(options[:only]).map(&:to_s)
+      elsif options[:except]
+        setting_names - Array(options[:except]).map(&:to_s)
+      else
+        setting_names
+      end
+    end
   end
-end
+end

data/lib/setting_accessors/setting_scaffold.rb

@@ -1,252 +1,185 @@
+# frozen_string_literal: true
+
 #
 # 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
+module SettingAccessors
+  module SettingScaffold
 
-    base.validates :name,
-                   :uniqueness => {:scope => [:assignable_type, :assignable_id]},
-                   :presence   => true
-  end
+    def self.included(base)
+      base.extend ClassMethods
+      base.serialize :value
 
-  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)
+      base.validates :name,
+                     uniqueness: {scope: [:assignable_type, :assignable_id]},
+                     presence: true
     end
 
-    alias_method :get, :[]
+    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 get(name, assignable = nil)
+        setting_record(name, assignable).try(:value)
+      end
 
-    #
-    # 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
+      alias [] get
+
+      #
+      # Tries to look the setting up using #get, if no existing setting is found,
+      # the setting's default value is returned.
+      #
+      # This only works for class-wise settings, meaning that an assignable has to be present.
+      #
+      def get_or_default(name, assignable)
+        if (val = get(name, assignable)).nil?
+          new(name: name, assignable: assignable).default_value
+        else
+          val
+        end
       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
+      #
+      # 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] The newly set value
+      #
+      # @toto: Bless the rains down in Africa!
+      #
+      def set(name, value, assignable: nil)
+        (setting_record(name, assignable) || new(name: name, assignable: assignable)).tap do |setting|
+          setting.raw_value = value
+          setting.save
+        end.value
       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)
+      #
+      # An alias for #set with a slightly different API.
+      # This allows the following usage:
+      #    Setting['my_setting', my_assignable] ||= new_value
+      #
+      def []=(name, *args)
+        assignable = args.size > 1 ? args.first : nil
+        set(name, args.last, assignable: assignable)
+      end
+
+      #
+      # @return [Object] the default value for the given setting
+      #
+      def get_default_value(name, assignable = nil)
+        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)
+        find_by(name: name.to_s, assignable: assignable)
+      end
+
+      #
+      # Makes accessing settings a little easier.
+      # Examples:
+      #
+      #   #Loading **the value** of a global setting named "my_setting"
+      #   Setting.my_setting
+      #
+      #   #Setting **the value** of a global setting named "my_setting"
+      #   Setting.my_setting = [1,2,3,4,5]
+      #
+      #   #Loading **the value** of an assigned setting named "cool_setting"
+      #   #+some_cool_user+ is here an instance of ActiveRecord::Base
+      #   Setting.cool_setting(some_cool_user)
+      #
+      def method_missing(method, *args, &block)
+        method_name = method.to_s
+
+        if method_name.last == '='
+          return set(method_name[0..-2], args.first)
+        elsif args.size <= 1
+          return get(method_name, args.first)
+        end
+
+        super
+      end
     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
+    # @return [Object] the default value for the current setting
     #
-    # @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)
+    def default_value
+      data['default'].freeze
     end
 
     #
-    # @return [Object] the default value for the given setting
+    # @return [String] the setting's type as specified in settings.yml
+    #   If the setting wasn't specified, a polymorphic type is assumed
     #
-    def get_default_value(name, assignable = nil)
-      self.new(:name => name, :assignable => assignable).default_value
+    def value_type
+      data['type'] || 'polymorphic'
     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 [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
     #
-    # @return [Setting, NilClass] The found setting or nil if not existing
+    # 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 setting_record(name, assignable = nil)
-      self.find_by(:name => name.to_s, :assignable => assignable)
+    def raw_value
+      @raw_value || value
     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.
+    # Sets the new setting value by converting the raw value automatically.
     #
-    # @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[:value] || []
+    def raw_value=(new_value)
+      @raw_value = new_value
+      self.value = converter.new(new_value).convert
     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'].freeze
-  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
+    private
 
-  def value_required?
-    !!validations['required']
-  end
-
-  #
-  # Accessor to the validations part of the setting's data
-  #
-  def validations
-    data['validates'] || {}
-  end
+    def converter
+      @converter ||= SettingAccessors::Internal.converter(value_type)
+    end
 
-  #
-  # @see {SettingAccessors::Internal#setting_data} for more information
-  #
-  def data
-    SettingAccessors::Internal.setting_data(name, assignable)
+    #
+    # @see {SettingAccessors::Internal#setting_data} for more information
+    #
+    def data
+      SettingAccessors::Internal.setting_data(name, assignable)
+    end
   end
-
 end