ibrain-core 0.1.0

data/lib/ibrain/encryptor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ibrain
+  # Ibrain::Encryptor is a thin wrapper around ActiveSupport::MessageEncryptor.
+  class Encryptor
+    # @param key [String] the 256 bits signature key
+    def initialize(key = Ibrain::Config.ibrain_encryptor_key)
+      key = Rails.application.secrets.secret_key_base.byteslice(0..31) if key.blank?
+
+      @crypt = ActiveSupport::MessageEncryptor.new(key)
+    end
+
+    # Encrypt a value
+    # @param value [String] the value to encrypt
+    # @return [String] the encrypted value
+    def encrypt(value)
+      @crypt.encrypt_and_sign(value)
+    end
+
+    # Decrypt an encrypted value
+    # @param encrypted_value [String] the value to decrypt
+    # @return [String] the decrypted value
+    def decrypt(encrypted_value)
+      @crypt.decrypt_and_verify(encrypted_value)
+    end
+  end
+end

data/lib/ibrain/i18n.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+module Ibrain
+  def self.i18n_available_locales
+    I18n.available_locales.select do |locale|
+      I18n.t('ibrain.i18n.this_file_language', locale: locale, fallback: false, default: nil)
+    end
+  end
+
+  # This value is used as a count for the pluralization helpers related to I18n
+  # ex: Ibrain::Order.model_name.human(count: Ibrain::I18N_GENERIC_PLURAL)
+  # Related to Ibrain issue #1164, this is needed to avoid problems with
+  # some pluralization calculators
+  I18N_GENERIC_PLURAL = 2.1
+end

data/lib/ibrain/logger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ibrain
+  class Logger
+    class << self
+      def info(message)
+        Rails.logger.info("[Ibrain] #{message}")
+      end
+
+      def warn(message)
+        Rails.logger.warn("[Ibrain] #{message}")
+      end
+
+      def debug(message)
+        Rails.logger.debug { "[Ibrain] #{message}" }
+      end
+
+      def error(message)
+        Rails.logger.error("[Ibrain] #{message}")
+      end
+    end
+  end
+end

data/lib/ibrain/permission_sets/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module PermissionSets
+    # This is the base class used for crafting permission sets.
+    #
+    # This is used by {Ibrain::RoleConfiguration} when adding custom behavior to {Ibrain::Ability}.
+    # See one of the subclasses for example structure such as {Ibrain::PermissionSets::UserDisplay}
+    #
+    # @see Ibrain::RoleConfiguration
+    # @see Ibrain::PermissionSets
+    class Base
+      # @param ability [CanCan::Ability]
+      #   The ability that will be extended with the current permission set.
+      #   The ability passed in must respond to #user
+      def initialize(ability)
+        @ability = ability
+      end
+
+      # Activate permissions on the ability. Put your can and cannot statements here.
+      # Must be overriden by subclasses
+      def activate!
+        raise NotImplementedError.new
+      end
+
+      private
+
+      attr_reader :ability
+
+      delegate :can, :cannot, :user, to: :ability
+    end
+  end
+end

data/lib/ibrain/permission_sets/super_user.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ibrain
+  module PermissionSets
+    class SuperUser < PermissionSets::Base
+      def activate!
+        can :manage, :all
+      end
+    end
+  end
+end

data/lib/ibrain/permission_sets.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'ibrain/permission_sets/base'
+require 'ibrain/permission_sets/super_user'

data/lib/ibrain/permitted_attributes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ibrain
+  # Ibrain::PermittedAttributes contains the attributes permitted through strong
+  # params in various controllers in the frontend. Extensions and stores that
+  # need additional params to be accepted can mutate these arrays to add them.
+  module PermittedAttributes
+    ATTRIBUTES = [
+      :address_attributes,
+      :user_attributes
+    ]
+
+    mattr_reader(*ATTRIBUTES)
+
+    @@address_attributes = [
+      :id, :name, :address1, :address2, :city, :country_id, :state_id,
+      :zipcode, :phone, :state_name, :province_id, :ward_id, :district_id
+    ]
+
+    # Intentionally leaving off email here to prevent privilege escalation
+    # by changing a user with higher priveleges' email to one a lower-priveleged
+    # admin owns. Creating a user with an email is handled separate at the
+    # controller level.
+    @@user_attributes = [:name, :email, :provider, :uid, :first_name, :last_name, :password, :password_confirmation]
+  end
+end

data/lib/ibrain/preferences/configuration.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+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
+
+    # @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?
+
+      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}')
+
+      MSG
+    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
+
+    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 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
+
+    # Reset all preferences to their default values.
+    def reset
+      set(default_preferences)
+    end
+
+    alias :[] :get_preference
+    alias :[]= :set_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
+    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.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
+
+        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
+    end
+
+    private
+
+    def context_for_default
+      [loaded_defaults]
+    end
+  end
+end

data/lib/ibrain/preferences/preferable.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+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
+
+      # 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
+
+      # @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
+
+      # 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
+
+      # @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
+      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
+      end
+
+      def context_for_default
+        [].freeze
+      end
+    end
+  end
+end

data/lib/ibrain/preferences/preferable_class_methods.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'ibrain/encryptor'
+
+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)
+
+      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
+
+      # 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
+
+      # 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
+
+      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
+
+      define_method preference_default_getter_method(name) do
+        default.call(*context_for_default)
+      end
+
+      define_method preference_type_getter_method(name) do
+        type
+      end
+    end
+
+    def preference_getter_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_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
+
+      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
+    end
+  end
+end

data/lib/ibrain/user_class_handle.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+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}"
+    end
+  end
+end

data/lib/ibrain_core.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'ibrain/core'