rails_base 0.51.0

data/lib/rails_base/configuration/app.rb

@@ -0,0 +1,52 @@
+require 'rails_base/configuration/base'
+
+module RailsBase
+  module Configuration
+    class App < Base
+      DEFAULT_VALUES = {
+        base_url: {
+          type: :string,
+          default: ENV.fetch('BASE_URL', 'http://localhost'),
+          description: 'Base url. Used for things like SSO.'
+        },
+        base_port: {
+          type: :string_nil,
+          default: ENV.fetch('BASE_URL_PORT', nil),
+          description: 'Base port. Used for things like SSO.'
+        },
+        web_name_logged_in: {
+          type: :string_proc,
+          default: ->(user) { Rails.application.class.parent_name },
+          description: 'Name of the application when authenticated user is present. Name in the tab of the browser. Allows for dynamic tab names'
+        },
+        web_name_logged_out: {
+          type: :string_proc,
+          default: ->(*) { Rails.application.class.parent_name },
+          description: 'Name of the application when no authenticated user. Name in the tab of the browser. Allows for dynamic tab names'
+        },
+        web_title_logged_in: {
+          type: :string_proc,
+          default: ->(user) { Rails.application.class.parent_name },
+          description: 'Title in nav for the web when logged in. String or proc accepted. When proc, current user will be passed in.'
+        },
+        web_title_logged_out: {
+          type: :string_proc,
+          default: ->(*) { Rails.application.class.parent_name },
+          description: 'Title in nav for the web when logged in. String or proc accepted. When proc, current user will be passed in.'
+        },
+        communication_name: {
+          type: :string_proc,
+          default: ->(*) { Rails.application.class.parent_name },
+          description: 'Name used when communicating with users.'
+        },
+        favicon_path: {
+          type: :string_nil,
+          default: 'rails_base/favicon.ico',
+          description: 'Favicon path'
+        },
+      }
+
+      attr_accessor *DEFAULT_VALUES.keys
+    end
+  end
+end

data/lib/rails_base/configuration/appearance.rb

@@ -0,0 +1,131 @@
+require 'rails_base/configuration/base'
+require 'rails_base/configuration/display/table_header'
+require 'rails_base/configuration/display/table_body'
+require 'rails_base/configuration/display/background_color'
+require 'rails_base/configuration/display/navbar'
+require 'rails_base/configuration/display/text'
+require 'rails_base/configuration/display/footer'
+require 'rails_base/configuration/display/btn_primary'
+require 'rails_base/configuration/display/btn_secondary'
+require 'rails_base/configuration/display/btn_success'
+require 'rails_base/configuration/display/btn_danger'
+require 'rails_base/configuration/display/btn_warning'
+require 'rails_base/configuration/display/btn_info'
+require 'rails_base/configuration/display/btn_light'
+require 'rails_base/configuration/display/btn_dark'
+
+module RailsBase
+  module Configuration
+    class Appearance < Base
+      BUTTONS = [
+        :btn_primary,
+        :btn_secondary,
+        :btn_success,
+        :btn_danger,
+        :btn_warning,
+        :btn_info,
+        :btn_light,
+        :btn_dark,
+      ]
+
+      DOWNSTREAM_CLASSES = [
+        :t_header,
+        :t_body,
+        :bg_color,
+        :navbar,
+        :text,
+        :footer,
+
+      ] + BUTTONS
+
+      SKIP_DOWNSTREAM_CLASSES = [:footer]
+      DARK_MODE = :dark
+      LIGHT_MODE = :light
+      MATCH_OS = :match_os
+
+      ALLOWABLE_TYPES = {
+        DARK_MODE => 'Dark Mode',
+        LIGHT_MODE => 'Light Mode',
+      }
+
+      APPEARANCE_TYPES = ALLOWABLE_TYPES.merge(MATCH_OS => 'Match System')
+
+      DEFAULT_VALUES = {
+        enabled: {
+          type: :boolean,
+          default: true,
+          description: 'When disabled, the user will be forced into default_mode when appropriate'
+        },
+        default_mode: {
+          type: :values,
+          expect_values: APPEARANCE_TYPES.keys,
+          default: LIGHT_MODE,
+          description: 'Default mode to set when mode not found in cookies/session',
+        },
+
+        math_os_dark: {
+          type: :values,
+          expect_values: ALLOWABLE_TYPES.keys,
+          default: DARK_MODE,
+          description: 'Mode to set when OS returns dark mode (useful when more than light/dark mode',
+        },
+      }
+
+      attr_accessor *DEFAULT_VALUES.keys
+      attr_reader *DOWNSTREAM_CLASSES
+
+      def initialize
+        #####
+        # all display classes are required to have ALLOWABLE_TYPES as default values
+        #####
+        @t_header = Configuration::Display::TableHeader.new
+        @t_body = Configuration::Display::TableBody.new
+        @bg_color = Configuration::Display::BackgroundColor.new
+        @navbar = Configuration::Display::Navbar.new
+        @text = Configuration::Display::Text.new
+        @footer = Configuration::Display::Footer.new
+
+        @btn_primary = Configuration::Display::BtnPrimary.new
+        @btn_secondary = Configuration::Display::BtnSecondary.new
+        @btn_success = Configuration::Display::BtnSuccess.new
+        @btn_danger = Configuration::Display::BtnDanger.new
+        @btn_warning = Configuration::Display::BtnWarning.new
+        @btn_info = Configuration::Display::BtnInfo.new
+        @btn_light = Configuration::Display::BtnLight.new
+        @btn_dark = Configuration::Display::BtnDark.new
+
+        _validate_values
+        super()
+      end
+
+      def validate!
+        super()
+        DOWNSTREAM_CLASSES.each do |variable|
+          instance_variable_get("@#{variable}").validate!
+        end
+      end
+
+      def assign_default_values!
+        super()
+        DOWNSTREAM_CLASSES.each do |variable|
+          instance_variable_get("@#{variable}").assign_default_values!
+        end
+      end
+
+      private
+      def _validate_values
+        DOWNSTREAM_CLASSES.each do |var|
+          next if SKIP_DOWNSTREAM_CLASSES.include?(var)
+
+          ALLOWABLE_TYPES.each do |k, v|
+            next if public_send(var).respond_to?("#{k}_mode")
+
+            raise ArgumentError, "#{var} does not respond to #{k}_mode"
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails_base/configuration/authentication.rb

@@ -0,0 +1,37 @@
+require 'rails_base/configuration/base'
+
+module RailsBase
+  module Configuration
+    class Authentication < Base
+      DEFAULT_SESSION = 60.days
+      MIN_SESSION = 5.minutes
+
+      DEFAULT_MFA_TIME = 7.day
+      MIN_MFA_TIME = 1.day
+
+      DEFAULT_VALUES = {
+        session_timeout: {
+          type: :duration,
+          default: ENV.fetch('SESSION_TIMEOUT_IN_SECONDS', DEFAULT_SESSION).to_i.seconds,
+          custom: ->(val) { val.to_i >= MIN_SESSION },
+          msg: "session_timeout must be a duration. Greater than #{MIN_SESSION}",
+          on_assignment: ->(val, _instance) { Devise.timeout_in = val },
+          description: 'Debug purposes. How long to keep admin_velocity_max attempts',
+        },
+        session_timeout_warning: {
+          type: :boolean,
+          default: true,
+          description: 'Display a timeout warning. When disabled, user will be logged out without warning',
+        },
+        mfa_time_duration: {
+          type: :duration,
+          default: DEFAULT_MFA_TIME,
+          custom: ->(val) { val.to_i > MIN_MFA_TIME },
+          msg: "mfa_time_duration must be a duration. Greater than #{MIN_MFA_TIME}",
+          description: 'Max time between when MFA will be required',
+        }
+      }
+      attr_accessor *DEFAULT_VALUES.keys
+    end
+  end
+end

data/lib/rails_base/configuration/base.rb

@@ -0,0 +1,209 @@
+module RailsBase
+  module Configuration
+    class Base
+      class InvalidConfiguration < StandardError; end;
+      class InvalidCustomConfiguration < StandardError; end;
+      class ConfigurationAlreadyEstablished < StandardError; end;
+
+      def self._allow_write_block?
+        true
+      end
+
+      def self._unset_allow_write!
+        define_singleton_method('_allow_write_block?') do
+          false
+        end
+      end
+
+      ALLOWED_TYPES = {
+        boolean: -> (val) { [TrueClass, FalseClass].include?(val.class) },
+        proc: -> (val) { [Proc].include?(val.class) },
+        integer: -> (val) { [Integer].include?(val.class) },
+        string: -> (val) { [String].include?(val.class) },
+        symbol: -> (val) { [Symbol].include?(val.class) },
+        symbol_class: -> (val) { [Symbol].include?(val.class) || val.superclass === ActiveJob::QueueAdapters },
+        duration: -> (val) { [ActiveSupport::Duration].include?(val.class) },
+        string_nil: -> (val) { [String, NilClass].include?(val.class) },
+        string_proc: -> (val) { [String, Proc].include?(val.class) },
+        array: -> (val) { [Array].include?(val.class) },
+        hash: -> (val) { [Hash].include?(val.class) },
+        path: -> (val) { [Pathname].include?(val.class) },
+        klass: -> (_val) { true },
+        values: -> (_val) { true },
+      }
+
+      def initialize
+        override_methods!
+        assign_default_values!
+        def_convenience_methods
+      end
+
+      # on any object you Base inherited object yoyu can call
+      # `.dig(:chain1, :chain2, :chain3)
+      def dig(*args, default: nil, &block)
+        current = self.public_send(args[0])
+
+        args[1..-1].each do |key|
+          return current || default if current.nil?
+
+          current = current.public_send(key)
+        end
+        current
+      rescue StandardError
+        if block_given?
+          yield block
+        else
+          default
+        end
+      end
+
+      def assign_default_values!
+        self.class::DEFAULT_VALUES.each do |key, object|
+          val = object[:default_assign_on_boot] ? object[:default_assign_on_boot].call : object[:default]
+          public_send(:"#{key}=", val)
+        end
+        true
+      end
+
+      def override_methods!
+        self.class::DEFAULT_VALUES.each do |key, object|
+          self.class.define_method(:"#{key}=") do |value|
+            raise ConfigurationAlreadyEstablished, "Unable to assign [#{_name}.#{key}]. Assignment must happen on boot" unless self.class._allow_write_block?
+
+            instance_variable_set(:"@#{key}", value)
+          end
+          if object[:type] == :array
+            self.class.define_method(:"#{key}<<") do |value|
+              raise ConfigurationAlreadyEstablished, "Unable to assign [#{_name}.#{key}]. Assignment must happen on boot" unless self.class._allow_write_block?
+
+              curr = instance_variable_get(:"@#{key}")
+              curr << value
+              instance_variable_set(:"@#{key}", curr)
+            end
+          end
+          if object[:type] == :hash
+            self.class.define_method(:"#{key}.merge") do |value|
+              raise ConfigurationAlreadyEstablished, "Unable to assign [#{_name}.#{key}]. Assignment must happen on boot" unless self.class._allow_write_block?
+
+              curr = instance_variable_get(:"@#{key}")
+              curr.merge(value)
+              instance_variable_set(:"@#{key}", curr)
+            end
+          end
+        end
+      end
+
+      def validate!
+        custom_validations
+        self.class::DEFAULT_VALUES.each do |key, object|
+          value = instance_variable_get("@#{key}".to_sym)
+          validate_var!(key: key, var: value, type: object[:type])
+          validate_custom_rule!(var: value, custom: object[:custom], key: key, msg: object[:msg])
+          validate_klass_type!(key: key, var: value, type: object[:type], klass_type: object[:klass_type])
+          validate_values_included!(key: key, var: value, type: object[:type], expect_values: object[:expect_values])
+          if object[:on_assignment]
+            if object[:on_assignment].is_a? Array
+              object[:on_assignment].each do |elem|
+                elem.call(value, self)
+              end
+            else
+              object[:on_assignment].call(value, self)
+            end
+          end
+        end
+        true
+      end
+
+      private
+
+      def custom_validations
+      end
+
+      def def_convenience_methods
+        self.class::DEFAULT_VALUES.each do |key, object|
+          if object[:type] == :boolean
+            self.class.define_method("#{key}?") do
+              return false unless dependents_true?(key)
+
+              public_send(key)
+            end
+          elsif object[:type] == :proc
+            self.class.define_method("#{key}?") do |current_user|
+              return false unless dependents_true?(key)
+
+              public_send(key).call(current_user)
+            end
+          elsif object[:type] == :string_proc
+            self.class.define_method("#{key}") do |*args|
+              return false unless dependents_true?(key)
+
+              if instance_variable_get("@#{key}".to_sym).is_a? Proc
+                instance_variable_get("@#{key}".to_sym).call(args[0])
+              else
+                instance_variable_get("@#{key}".to_sym)
+              end
+            end
+          else
+            self.class.define_method("#{key}") do
+              return false unless dependents_true?(key)
+
+              instance_variable_get("@#{key}".to_sym)
+            end
+          end
+        end
+      end
+
+      def dependents_true?(key)
+        dependents = self.class::DEFAULT_VALUES[key][:dependents] || []
+
+        dependents.all? { |s| s.call(self) }
+      end
+
+      def validate_var!(var:,  type:, key:)
+        proc = ALLOWED_TYPES.fetch(type)
+        return if proc.call(var)
+
+        raise InvalidConfiguration, "#{_name}.#{key} expects a #{type}."
+      end
+
+      def validate_klass_type!(var:, type:, key:, klass_type:)
+        return if klass_type.nil?
+
+        boolean =
+          if var.is_a? Array
+            var.all? { |s| klass_type.include?(s.class) }
+          else
+            klass_type.include?(var.class)
+          end
+        return if boolean
+
+        raise InvalidConfiguration, "#{_name}.#{key} expects all members to be a #{klass_type}. Received: [#{var.class}]"
+      end
+
+      def validate_values_included!(key:, var:, type:, expect_values:)
+        return if expect_values.nil?
+        values =
+          if expect_values.is_a? Proc
+            expect_values.call(self)
+          else
+            expect_values
+          end
+
+        return if values.include?(var)
+
+        raise InvalidConfiguration, "#{_name}.#{key} expects value to be included in [#{values}]. Received: [#{var}]"
+      end
+
+      def _name
+        self.class.name.demodulize
+      end
+
+      def validate_custom_rule!(var:, custom:, key:, msg:)
+        return if custom.nil?
+        return if custom.call(var)
+
+        raise InvalidCustomConfiguration, msg
+      end
+    end
+  end
+end

data/lib/rails_base/configuration/display/background_color.rb

@@ -0,0 +1,25 @@
+require 'rails_base/configuration/base'
+
+module RailsBase
+  module Configuration
+    module Display
+      class BackgroundColor < Base
+
+        DEFAULT_VALUES = {
+          dark_mode: {
+            type: :string_nil,
+            default: 'bg-secondary',
+            description: 'Background to use in Dark mode'
+          },
+          light_mode: {
+            type: :string_nil,
+            default: '',
+            description: 'Background to use in light mode'
+          },
+        }
+
+        attr_accessor *DEFAULT_VALUES.keys
+      end
+    end
+  end
+end