ibrain-core 0.4.5 → 0.4.6

data/lib/ibrain/preferences/configuration.rb

@@ -3,168 +3,166 @@
 require 'ibrain/core/versioned_value'
 require 'ibrain/preferences/preferable'
 
-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
+# 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
 
-    # @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
-      end
+  # @param preferences [Hash] a hash of preferences to set
+  def set(preferences)
+    preferences.each do |name, value|
+      set_preference name, value
     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)
-      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)
     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
-      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
     end
+  end
 
-    private
+  private
 
-    def context_for_default
-      [loaded_defaults]
-    end
+  def context_for_default
+    [loaded_defaults]
   end
 end

data/lib/ibrain/preferences/preferable.rb

@@ -4,180 +4,176 @@ require 'ibrain/preferences/preferable_class_methods'
 require 'active_support/concern'
 require 'active_support/core_ext/hash/keys'
 
-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
+# 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
+  # 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
+  # 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
 
-      # @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 [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 [Object] The default for preference +name+
-      def preference_default(name)
-        has_preference! name
-        send self.class.preference_default_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
 
-      # 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
+  # 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 [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 [Boolean] if preference exists on this class
+  def has_preference?(name)
+    defined_preferences.include?(name.to_sym)
+  end
 
-      # @return [Array<Symbol>] All preferences defined on this class
-      def defined_preferences
-        self.class.defined_preferences
-      end
+  # @return [Array<Symbol>] All preferences defined on this class
+  def defined_preferences
+    self.class.defined_preferences
+  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)
-          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)
       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')
-          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
+  # 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
-
-      def context_for_default
-        [].freeze
+    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
+
+  def context_for_default
+    [].freeze
+  end
 end