ibrain-core 0.4.6 → 0.4.7

data/lib/ibrain/preferences/preferable_class_methods.rb

@@ -3,136 +3,138 @@
 require 'logger'
 require 'ibrain/encryptor'
 
-module Ibrain::Preferences::PreferableClassMethods
-  DEFAULT_ADMIN_FORM_PREFERENCE_TYPES = %i(
-    boolean
-    decimal
-    integer
-    password
-    string
-    text
-    encrypted_string
-  )
-
-  def defined_preferences
-    []
-  end
+module Ibrain::Preferences
+  module PreferableClassMethods
+    DEFAULT_ADMIN_FORM_PREFERENCE_TYPES = %i(
+      boolean
+      decimal
+      integer
+      password
+      string
+      text
+      encrypted_string
+    )
+
+    def defined_preferences
+      []
+    end
 
-  def preference(name, type, options = {})
-    options.assert_valid_keys(:default, :encryption_key)
+    def preference(name, type, options = {})
+      options.assert_valid_keys(:default, :encryption_key)
 
-    if type == :encrypted_string
-      preference_encryptor = preference_encryptor(options)
-      options[:default] = preference_encryptor.encrypt(options[:default])
-    end
+      if type == :encrypted_string
+        preference_encryptor = preference_encryptor(options)
+        options[:default] = preference_encryptor.encrypt(options[:default])
+      end
 
-    default = begin
-                given = options[:default]
-                if self <= Ibrain::Preferences::Configuration &&
-                    given.is_a?(Proc) &&
-                    given.lambda? &&
-                    given.arity.zero?
-                  Ibrain::Logger.warn <<~MSG
-                    The arity of a proc given as the default for a preference
-                    has changed from 0 to 1 on Ibrain 3.1. The Ibrain
-                    version for the loaded preference defaults is given as the
-                    proc's argument from this point on.
-
-                    If you don't need to return a different default value
-                    depending on the loaded Ibrain version, you can change
-                    the proc so that it doesn't have lambda semantics (lambdas
-                    raise when extra arguments are supplied, while raw procs
-                    don't). E.g.:
-
-                    preference :foo, :string, default: proc { true }
-
-                    If you want to branch on the provided Ibrain version, you can do like the following:
-
-                    preference :foo, :string, default: by_version(true, "3.2.0" => false)
-
-                  MSG
-                  ->(_default_context) { given.call }
-                elsif given.is_a?(Proc)
-                  given
-                else
-                  proc { given }
-                end
-    end
+      default = begin
+                  given = options[:default]
+                  if self <= Ibrain::Preferences::Configuration &&
+                     given.is_a?(Proc) &&
+                     given.lambda? &&
+                     given.arity.zero?
+                    Ibrain::Logger.warn <<~MSG
+                      The arity of a proc given as the default for a preference
+                      has changed from 0 to 1 on Ibrain 3.1. The Ibrain
+                      version for the loaded preference defaults is given as the
+                      proc's argument from this point on.
+
+                      If you don't need to return a different default value
+                      depending on the loaded Ibrain version, you can change
+                      the proc so that it doesn't have lambda semantics (lambdas
+                      raise when extra arguments are supplied, while raw procs
+                      don't). E.g.:
+
+                      preference :foo, :string, default: proc { true }
+
+                      If you want to branch on the provided Ibrain version, you can do like the following:
+
+                      preference :foo, :string, default: by_version(true, "3.2.0" => false)
+
+                    MSG
+                    ->(_default_context) { given.call }
+                  elsif given.is_a?(Proc)
+                    given
+                  else
+                    proc { given }
+                  end
+      end
 
-    # The defined preferences on a class are all those defined directly on
-    # that class as well as those defined on ancestors.
-    # We store these as a class instance variable on each class which has a
-    # preference. super() collects preferences defined on ancestors.
-    singleton_preferences = (@defined_singleton_preferences ||= [])
-    singleton_preferences << name.to_sym
+      # The defined preferences on a class are all those defined directly on
+      # that class as well as those defined on ancestors.
+      # We store these as a class instance variable on each class which has a
+      # preference. super() collects preferences defined on ancestors.
+      singleton_preferences = (@defined_singleton_preferences ||= [])
+      singleton_preferences << name.to_sym
 
-    define_singleton_method :defined_preferences do
-      super() + singleton_preferences
-    end
+      define_singleton_method :defined_preferences do
+        super() + singleton_preferences
+      end
 
-    # cache_key will be nil for new objects, then if we check if there
-    # is a pending preference before going to default
-    define_method preference_getter_method(name) do
-      value = preferences.fetch(name) do
-        default.call(*context_for_default)
+      # cache_key will be nil for new objects, then if we check if there
+      # is a pending preference before going to default
+      define_method preference_getter_method(name) do
+        value = preferences.fetch(name) do
+          default.call(*context_for_default)
+        end
+        value = preference_encryptor.decrypt(value) if preference_encryptor.present?
+        value
       end
-      value = preference_encryptor.decrypt(value) if preference_encryptor.present?
-      value
-    end
 
-    define_method preference_setter_method(name) do |value|
-      value = convert_preference_value(value, type, preference_encryptor)
-      preferences[name] = value
+      define_method preference_setter_method(name) do |value|
+        value = convert_preference_value(value, type, preference_encryptor)
+        preferences[name] = value
 
-      # If this is an activerecord object, we need to inform
-      # ActiveRecord::Dirty that this value has changed, since this is an
-      # in-place update to the preferences hash.
-      preferences_will_change! if respond_to?(:preferences_will_change!)
-    end
+        # If this is an activerecord object, we need to inform
+        # ActiveRecord::Dirty that this value has changed, since this is an
+        # in-place update to the preferences hash.
+        preferences_will_change! if respond_to?(:preferences_will_change!)
+      end
 
-    define_method preference_default_getter_method(name) do
-      default.call(*context_for_default)
-    end
+      define_method preference_default_getter_method(name) do
+        default.call(*context_for_default)
+      end
 
-    define_method preference_type_getter_method(name) do
-      type
+      define_method preference_type_getter_method(name) do
+        type
+      end
     end
-  end
 
-  def preference_getter_method(name)
-    "preferred_#{name}".to_sym
-  end
+    def preference_getter_method(name)
+      "preferred_#{name}".to_sym
+    end
 
-  def preference_setter_method(name)
-      "preferred_#{name}=".to_sym
-  end
+    def preference_setter_method(name)
+       "preferred_#{name}=".to_sym
+    end
 
-  def preference_default_getter_method(name)
-    "preferred_#{name}_default".to_sym
-  end
+    def preference_default_getter_method(name)
+      "preferred_#{name}_default".to_sym
+    end
 
-  def preference_type_getter_method(name)
-    "preferred_#{name}_type".to_sym
-  end
+    def preference_type_getter_method(name)
+      "preferred_#{name}_type".to_sym
+    end
 
-  def preference_encryptor(options)
-    key = options[:encryption_key] ||
-          ENV['IBRAIN_PREFERENCES_MASTER_KEY'] ||
-          Rails.application.credentials.secret_key_base
+    def preference_encryptor(options)
+      key = options[:encryption_key] ||
+            ENV['IBRAIN_PREFERENCES_MASTER_KEY'] ||
+            Rails.application.credentials.secret_key_base
 
-    Ibrain::Encryptor.new(key)
-  end
+      Ibrain::Encryptor.new(key)
+    end
 
-  # List of preference types allowed as form fields in the Ibrain admin
-  #
-  # Overwrite this method 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]
-  def allowed_admin_form_preference_types
-    DEFAULT_ADMIN_FORM_PREFERENCE_TYPES
+    # List of preference types allowed as form fields in the Ibrain admin
+    #
+    # Overwrite this method 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]
+    def allowed_admin_form_preference_types
+      DEFAULT_ADMIN_FORM_PREFERENCE_TYPES
+    end
   end
 end

data/lib/ibrain/user_class_handle.rb

@@ -1,27 +1,29 @@
 # frozen_string_literal: true
 
-# Configuration point for User model implementation.
-#
-# `Ibrain::UserClassHandle` allows you to configure your own implementation of a
-# User class or use an extension like `ibrain-auth`.
-#
-# @note Placeholder for name of Ibrain.user_class to ensure later evaluation at
-#  runtime.
-#
-#  Unfortunately, it is possible for classes to get loaded before
-#  Ibrain.user_class has been set in the initializer. As a result, they end up
-#  with class_name: "" in their association definitions. For obvious reasons,
-#  that doesn't work.
-#
-#  For now, Rails does not call to_s on the instance passed in until runtime.
-#  So this little hack provides a wrapper around Ibrain.user_class so that we
-#  can basically lazy-evaluate it. Yay! Problem solved forever.
-class Ibrain::UserClassHandle
-  # @return [String] the name of the user class as a string.
-  # @raise [RuntimeError] if Ibrain.user_class is nil
-  def to_s
-    fail "'Ibrain.user_class' has not been set yet." unless Ibrain.user_class
+module Ibrain
+  # Configuration point for User model implementation.
+  #
+  # `Ibrain::UserClassHandle` allows you to configure your own implementation of a
+  # User class or use an extension like `ibrain-auth`.
+  #
+  # @note Placeholder for name of Ibrain.user_class to ensure later evaluation at
+  #  runtime.
+  #
+  #  Unfortunately, it is possible for classes to get loaded before
+  #  Ibrain.user_class has been set in the initializer. As a result, they end up
+  #  with class_name: "" in their association definitions. For obvious reasons,
+  #  that doesn't work.
+  #
+  #  For now, Rails does not call to_s on the instance passed in until runtime.
+  #  So this little hack provides a wrapper around Ibrain.user_class so that we
+  #  can basically lazy-evaluate it. Yay! Problem solved forever.
+  class UserClassHandle
+    # @return [String] the name of the user class as a string.
+    # @raise [RuntimeError] if Ibrain.user_class is nil
+    def to_s
+      fail "'Ibrain.user_class' has not been set yet." unless Ibrain.user_class
 
-    "::#{Ibrain.user_class}"
+      "::#{Ibrain.user_class}"
+    end
   end
 end

data/lib/ibrain_core.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
-loader = Zeitwerk::Loader.new
-loader.tag = File.basename(__FILE__, ".rb")
-loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-loader.enable_reloading
-loader.setup
-loader.reload
+require 'ibrain/core'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ibrain-core
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - Tai Nguyen Van