ibrain-core 0.4.6 → 0.4.7

data/lib/ibrain/preferences/configuration.rb

@@ -3,166 +3,168 @@
 require 'ibrain/core/versioned_value'
 require 'ibrain/preferences/preferable'
 
-# This takes the preferrable methods and adds some
-# syntatic sugar to access the preferences
-#
-#   class App < Configuration
-#     preference :color, :string
-#   end
-#
-#   a = App.new
-#
-# Provides the following setters:
-#
-#   a.color = :blue
-#   a[:color] = :blue
-#   a.set color: :blue
-#   a.preferred_color = :blue
-#
-# and the following getters:
-#
-#   a.color
-#   a[:color]
-#   a.get :color
-#   a.preferred_color
-#
-class Ibrain::Preferences::Configuration
-  include Ibrain::Preferences::Preferable
-
-  # @!attribute [r] loaded_defaults
-  #   @return [String]
-  #     Some configuration defaults can be added or changed when a new Ibrain
-  #     version is released. Setting this to an older Ibrain version allows keeping
-  #     backward compatibility until the application code is updated to the new
-  #     defaults. Set via {#load_defaults}
-  attr_reader :loaded_defaults
-
-  attr_reader :load_defaults_called
-
-  def initialize
-    @loaded_defaults = Ibrain.ibrain_version
-    @load_defaults_called = false
-  end
+module Ibrain::Preferences
+  # This takes the preferrable methods and adds some
+  # syntatic sugar to access the preferences
+  #
+  #   class App < Configuration
+  #     preference :color, :string
+  #   end
+  #
+  #   a = App.new
+  #
+  # Provides the following setters:
+  #
+  #   a.color = :blue
+  #   a[:color] = :blue
+  #   a.set color: :blue
+  #   a.preferred_color = :blue
+  #
+  # and the following getters:
+  #
+  #   a.color
+  #   a[:color]
+  #   a.get :color
+  #   a.preferred_color
+  #
+  class Configuration
+    include Ibrain::Preferences::Preferable
+
+    # @!attribute [r] loaded_defaults
+    #   @return [String]
+    #     Some configuration defaults can be added or changed when a new Ibrain
+    #     version is released. Setting this to an older Ibrain version allows keeping
+    #     backward compatibility until the application code is updated to the new
+    #     defaults. Set via {#load_defaults}
+    attr_reader :loaded_defaults
+
+    attr_reader :load_defaults_called
+
+    def initialize
+      @loaded_defaults = Ibrain.ibrain_version
+      @load_defaults_called = false
+    end
 
-  # @param [String] Ibrain version from which take defaults when not
-  # overriden.
-  # @see #load_defaults
-  def load_defaults(version)
-    @loaded_defaults = version
-    @load_defaults_called = true
-    reset
-  end
+    # @param [String] Ibrain version from which take defaults when not
+    # overriden.
+    # @see #load_defaults
+    def load_defaults(version)
+      @loaded_defaults = version
+      @load_defaults_called = true
+      reset
+    end
 
-  def check_load_defaults_called(instance_constant_name = nil)
-    return if load_defaults_called || !Ibrain::Core.has_install_generator_been_run?
+    def check_load_defaults_called(instance_constant_name = nil)
+      return if load_defaults_called || !Ibrain::Core.has_install_generator_been_run?
 
-    target_name = instance_constant_name || "#{self.class.name}.new"
-    Ibrain::Deprecation.warn <<~MSG
-      It's recommended that you explicitly load the default configuration for
-      your current Ibrain version. You can do it by adding the following call
-      to your Ibrain initializer within the #{target_name} block:
+      target_name = instance_constant_name || "#{self.class.name}.new"
+      Ibrain::Deprecation.warn <<~MSG
+        It's recommended that you explicitly load the default configuration for
+        your current Ibrain version. You can do it by adding the following call
+        to your Ibrain initializer within the #{target_name} block:
 
-        config.load_defaults('#{Ibrain.ibrain_version}')
+          config.load_defaults('#{Ibrain.ibrain_version}')
 
-    MSG
-  end
+      MSG
+    end
 
-  # @yield [config] Yields this configuration object to a block
-  def configure
-    yield(self)
-  end
+    # @yield [config] Yields this configuration object to a block
+    def configure
+      yield(self)
+    end
 
-  # @!attribute preference_store
-  # Storage method for preferences.
-  attr_writer :preference_store
+    # @!attribute preference_store
+    # Storage method for preferences.
+    attr_writer :preference_store
 
-  def preference_store
-    @preference_store ||= default_preferences
-  end
+    def preference_store
+      @preference_store ||= default_preferences
+    end
 
-  # Replace the default legacy preference store, which stores preferences in
-  # the Ibrain_preferences table, with a plain in memory hash. This is faster
-  # and less error prone.
-  #
-  # This will set all preferences to their default values.
-  #
-  # These won't be loaded from or persisted to the database, so any desired
-  # changes must be made each time the application is started, such as in an
-  # initializer.
-  def use_static_preferences!
-    @preference_store = default_preferences
-  end
+    # Replace the default legacy preference store, which stores preferences in
+    # the Ibrain_preferences table, with a plain in memory hash. This is faster
+    # and less error prone.
+    #
+    # This will set all preferences to their default values.
+    #
+    # These won't be loaded from or persisted to the database, so any desired
+    # changes must be made each time the application is started, such as in an
+    # initializer.
+    def use_static_preferences!
+      @preference_store = default_preferences
+    end
 
-  # Replace the new static preference store with the legacy store which
-  # fetches preferences from the DB.
-  def use_legacy_db_preferences!
-    @preference_store = ScopedStore.new(self.class.name.underscore)
-  end
+    # Replace the new static preference store with the legacy store which
+    # fetches preferences from the DB.
+    def use_legacy_db_preferences!
+      @preference_store = ScopedStore.new(self.class.name.underscore)
+    end
 
-  alias_method :preferences, :preference_store
+    alias_method :preferences, :preference_store
 
-  # Reset all preferences to their default values.
-  def reset
-    set(default_preferences)
-  end
+    # Reset all preferences to their default values.
+    def reset
+      set(default_preferences)
+    end
 
-  alias :[] :get_preference
-  alias :[]= :set_preference
+    alias :[] :get_preference
+    alias :[]= :set_preference
 
-  alias :get :get_preference
+    alias :get :get_preference
 
-  # @param preferences [Hash] a hash of preferences to set
-  def set(preferences)
-    preferences.each do |name, value|
-      set_preference name, value
+    # @param preferences [Hash] a hash of preferences to set
+    def set(preferences)
+      preferences.each do |name, value|
+        set_preference name, value
+      end
     end
-  end
 
-  # Generates a different preference default depending on {#version_defaults}
-  #
-  # This method is meant to be used in the `default:` keyword argument for
-  # {.preference}. For instance, in the example, `foo`'s default was `true`
-  # until version 3.0.0.alpha, when it became `false`:
-  #
-  # @example
-  #   preference :foo, :boolean, default: by_version(true, "3.0.0.alpha" => false)
-  #
-  # @see #loaded_defaults
-  # @see Ibrain::Core::VersionedValue
-  def self.by_version(*args)
-    proc do |loaded_defaults|
-      Ibrain::Core::VersionedValue.new(*args).call(loaded_defaults)
+    # Generates a different preference default depending on {#version_defaults}
+    #
+    # This method is meant to be used in the `default:` keyword argument for
+    # {.preference}. For instance, in the example, `foo`'s default was `true`
+    # until version 3.0.0.alpha, when it became `false`:
+    #
+    # @example
+    #   preference :foo, :boolean, default: by_version(true, "3.0.0.alpha" => false)
+    #
+    # @see #loaded_defaults
+    # @see Ibrain::Core::VersionedValue
+    def self.by_version(*args)
+      proc do |loaded_defaults|
+        Ibrain::Core::VersionedValue.new(*args).call(loaded_defaults)
+      end
     end
-  end
 
-  def self.preference(name, type, options = {})
-    super
-    alias_method name.to_s, "preferred_#{name}"
-    alias_method "#{name}=", "preferred_#{name}="
-  end
+    def self.preference(name, type, options = {})
+      super
+      alias_method name.to_s, "preferred_#{name}"
+      alias_method "#{name}=", "preferred_#{name}="
+    end
 
-  def self.class_name_attribute(name, default:)
-    ivar = :"@#{name}"
+    def self.class_name_attribute(name, default:)
+      ivar = :"@#{name}"
 
-    define_method("#{name}=") do |class_name|
-      # If this is a named class constant, we should store it as a string to
-      # allow code reloading.
-      class_name = class_name.name if class_name.is_a?(Class) && class_name.name
+      define_method("#{name}=") do |class_name|
+        # If this is a named class constant, we should store it as a string to
+        # allow code reloading.
+        class_name = class_name.name if class_name.is_a?(Class) && class_name.name
 
-      instance_variable_set(ivar, class_name)
-    end
+        instance_variable_set(ivar, class_name)
+      end
 
-    define_method(name) do
-      class_name = instance_variable_get(ivar)
-      class_name ||= default
-      class_name = class_name.constantize if class_name.is_a?(String)
-      class_name
+      define_method(name) do
+        class_name = instance_variable_get(ivar)
+        class_name ||= default
+        class_name = class_name.constantize if class_name.is_a?(String)
+        class_name
+      end
     end
-  end
 
-  private
+    private
 
-  def context_for_default
-    [loaded_defaults]
+    def context_for_default
+      [loaded_defaults]
+    end
   end
 end

data/lib/ibrain/preferences/preferable.rb

@@ -4,176 +4,180 @@ require 'ibrain/preferences/preferable_class_methods'
 require 'active_support/concern'
 require 'active_support/core_ext/hash/keys'
 
-# Preferable allows defining preference accessor methods.
-#
-# A class including Preferable must implement #preferences which should return
-# an object responding to .fetch(key), []=(key, val), and .delete(key).
-#
-# It may also define a `#context_for_default` method. It should return an
-# array with the arguments to be provided to a proc used as the `default:`
-# keyword for a preference.
-#
-# The generated writer method performs typecasting before assignment into the
-# preferences object.
-#
-# Examples:
-#
-#   # Ibrain::Base includes Preferable and defines preferences as a serialized
-#   # column.
-#   class Settings < Ibrain::Base
-#     preference :color,       :string,  default: 'red'
-#     preference :temperature, :integer, default: 21
-#   end
-#
-#   s = Settings.new
-#   s.preferred_color # => 'red'
-#   s.preferred_temperature # => 21
-#
-#   s.preferred_color = 'blue'
-#   s.preferred_color # => 'blue'
-#
-#   # Typecasting is performed on assignment
-#   s.preferred_temperature = '24'
-#   s.preferred_color # => 24
-#
-#   # Modifications have been made to the .preferences hash
-#   s.preferences #=> {color: 'blue', temperature: 24}
-#
-#   # Save the changes. All handled by activerecord
-#   s.save!
-#
-# Each preference gets rendered as a form field in Ibrain backend.
-#
-# As not all supported preference types are representable as a form field, only
-# some of them get rendered per default. Arrays and Hashes for instance are
-# supported preference field types, but do not represent well as a form field.
-#
-# Overwrite +allowed_admin_form_preference_types+ in your class if you want to
-# provide more fields. If you do so, you also need to provide a preference field
-# partial that lives in:
-#
-# +app/views/ibrain/admin/shared/preference_fields/+
-#
-module Ibrain::Preferences::Preferable
-  extend ActiveSupport::Concern
-
-  included do
-    extend Ibrain::Preferences::PreferableClassMethods
-  end
-
-  # Get a preference
-  # @param name [#to_sym] name of preference
-  # @return [Object] The value of preference +name+
-  def get_preference(name)
-    has_preference! name
-    send self.class.preference_getter_method(name)
-  end
-
-  # Set a preference
-  # @param name [#to_sym] name of preference
-  # @param value [Object] new value for preference +name+
-  def set_preference(name, value)
-    has_preference! name
-    send self.class.preference_setter_method(name), value
-  end
+module Ibrain
+  module Preferences
+    # Preferable allows defining preference accessor methods.
+    #
+    # A class including Preferable must implement #preferences which should return
+    # an object responding to .fetch(key), []=(key, val), and .delete(key).
+    #
+    # It may also define a `#context_for_default` method. It should return an
+    # array with the arguments to be provided to a proc used as the `default:`
+    # keyword for a preference.
+    #
+    # The generated writer method performs typecasting before assignment into the
+    # preferences object.
+    #
+    # Examples:
+    #
+    #   # Ibrain::Base includes Preferable and defines preferences as a serialized
+    #   # column.
+    #   class Settings < Ibrain::Base
+    #     preference :color,       :string,  default: 'red'
+    #     preference :temperature, :integer, default: 21
+    #   end
+    #
+    #   s = Settings.new
+    #   s.preferred_color # => 'red'
+    #   s.preferred_temperature # => 21
+    #
+    #   s.preferred_color = 'blue'
+    #   s.preferred_color # => 'blue'
+    #
+    #   # Typecasting is performed on assignment
+    #   s.preferred_temperature = '24'
+    #   s.preferred_color # => 24
+    #
+    #   # Modifications have been made to the .preferences hash
+    #   s.preferences #=> {color: 'blue', temperature: 24}
+    #
+    #   # Save the changes. All handled by activerecord
+    #   s.save!
+    #
+    # Each preference gets rendered as a form field in Ibrain backend.
+    #
+    # As not all supported preference types are representable as a form field, only
+    # some of them get rendered per default. Arrays and Hashes for instance are
+    # supported preference field types, but do not represent well as a form field.
+    #
+    # Overwrite +allowed_admin_form_preference_types+ in your class if you want to
+    # provide more fields. If you do so, you also need to provide a preference field
+    # partial that lives in:
+    #
+    # +app/views/ibrain/admin/shared/preference_fields/+
+    #
+    module Preferable
+      extend ActiveSupport::Concern
+
+      included do
+        extend Ibrain::Preferences::PreferableClassMethods
+      end
 
-  # @param name [#to_sym] name of preference
-  # @return [Symbol] The type of preference +name+
-  def preference_type(name)
-    has_preference! name
-    send self.class.preference_type_getter_method(name)
-  end
+      # Get a preference
+      # @param name [#to_sym] name of preference
+      # @return [Object] The value of preference +name+
+      def get_preference(name)
+        has_preference! name
+        send self.class.preference_getter_method(name)
+      end
 
-  # @param name [#to_sym] name of preference
-  # @return [Object] The default for preference +name+
-  def preference_default(name)
-    has_preference! name
-    send self.class.preference_default_getter_method(name)
-  end
+      # Set a preference
+      # @param name [#to_sym] name of preference
+      # @param value [Object] new value for preference +name+
+      def set_preference(name, value)
+        has_preference! name
+        send self.class.preference_setter_method(name), value
+      end
 
-  # Raises an exception if the +name+ preference is not defined on this class
-  # @param name [#to_sym] name of preference
-  def has_preference!(name)
-    raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
-  end
+      # @param name [#to_sym] name of preference
+      # @return [Symbol] The type of preference +name+
+      def preference_type(name)
+        has_preference! name
+        send self.class.preference_type_getter_method(name)
+      end
 
-  # @param name [#to_sym] name of preference
-  # @return [Boolean] if preference exists on this class
-  def has_preference?(name)
-    defined_preferences.include?(name.to_sym)
-  end
+      # @param name [#to_sym] name of preference
+      # @return [Object] The default for preference +name+
+      def preference_default(name)
+        has_preference! name
+        send self.class.preference_default_getter_method(name)
+      end
 
-  # @return [Array<Symbol>] All preferences defined on this class
-  def defined_preferences
-    self.class.defined_preferences
-  end
+      # Raises an exception if the +name+ preference is not defined on this class
+      # @param name [#to_sym] name of preference
+      def has_preference!(name)
+        raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
+      end
 
-  # @return [Hash{Symbol => Object}] Default for all preferences defined on this class
-  def default_preferences
-      defined_preferences.index_with do |preference|
-        preference_default(preference)
+      # @param name [#to_sym] name of preference
+      # @return [Boolean] if preference exists on this class
+      def has_preference?(name)
+        defined_preferences.include?(name.to_sym)
       end
-  end
 
-  # Preference names representable as form fields in Ibrain backend
-  #
-  # Not all preferences are representable as a form field.
-  #
-  # Arrays and Hashes for instance are supported preference field types,
-  # but do not represent well as a form field.
-  #
-  # As these kind of preferences are mostly developer facing
-  # and not admin facing we should not render them.
-  #
-  # Overwrite +allowed_admin_form_preference_types+ in your class that
-  # includes +Ibrain::Preferable+ if you want to provide more fields.
-  # If you do so, you also need to provide a preference field partial
-  # that lives in:
-  #
-  # +app/views/ibrain/admin/shared/preference_fields/+
-  #
-  # @return [Array]
-
-  private
-
-  def convert_preference_value(value, type, preference_encryptor = nil)
-    return nil if value.nil?
-
-    case type
-    when :string, :text, :password
-      value.to_s
-    when :encrypted_string
-      preference_encryptor.encrypt(value.to_s)
-    when :decimal
-      begin
-        value.to_s.to_d
-      rescue ArgumentError
-        BigDecimal('0')
+      # @return [Array<Symbol>] All preferences defined on this class
+      def defined_preferences
+        self.class.defined_preferences
       end
-    when :integer
-      value.to_i
-    when :boolean
-      if !value ||
-          value.to_s =~ /\A(f|false|0|^)\Z/i ||
-          (value.respond_to?(:empty?) && value.empty?)
-        false
-      else
-        true
+
+      # @return [Hash{Symbol => Object}] Default for all preferences defined on this class
+      def default_preferences
+          defined_preferences.index_with do |preference|
+            preference_default(preference)
+          end
       end
-    when :array
-      raise TypeError, "Array expected got #{value.inspect}" unless value.is_a?(Array)
 
-      value
-    when :hash
-      raise TypeError, "Hash expected got #{value.inspect}" unless value.is_a?(Hash)
+      # Preference names representable as form fields in Ibrain backend
+      #
+      # Not all preferences are representable as a form field.
+      #
+      # Arrays and Hashes for instance are supported preference field types,
+      # but do not represent well as a form field.
+      #
+      # As these kind of preferences are mostly developer facing
+      # and not admin facing we should not render them.
+      #
+      # Overwrite +allowed_admin_form_preference_types+ in your class that
+      # includes +Ibrain::Preferable+ if you want to provide more fields.
+      # If you do so, you also need to provide a preference field partial
+      # that lives in:
+      #
+      # +app/views/ibrain/admin/shared/preference_fields/+
+      #
+      # @return [Array]
+
+      private
+
+      def convert_preference_value(value, type, preference_encryptor = nil)
+        return nil if value.nil?
+
+        case type
+        when :string, :text, :password
+          value.to_s
+        when :encrypted_string
+          preference_encryptor.encrypt(value.to_s)
+        when :decimal
+          begin
+            value.to_s.to_d
+          rescue ArgumentError
+            BigDecimal('0')
+          end
+        when :integer
+          value.to_i
+        when :boolean
+          if !value ||
+             value.to_s =~ /\A(f|false|0|^)\Z/i ||
+             (value.respond_to?(:empty?) && value.empty?)
+            false
+          else
+            true
+          end
+        when :array
+          raise TypeError, "Array expected got #{value.inspect}" unless value.is_a?(Array)
+
+          value
+        when :hash
+          raise TypeError, "Hash expected got #{value.inspect}" unless value.is_a?(Hash)
+
+          value
+        else
+          value
+        end
+      end
 
-      value
-    else
-      value
+      def context_for_default
+        [].freeze
+      end
     end
   end
-
-  def context_for_default
-    [].freeze
-  end
 end