hyper-max-sys 0.0.1

data/rails_admin-3.3.0/lib/rails_admin/config/configurable.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    # A module for all configurables.
+
+    module Configurable
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      def has_option?(name) # rubocop:disable Naming/PredicateName
+        options = self.class.instance_variable_get('@config_options')
+        options&.key?(name)
+      end
+
+      # Register an instance option for this object only
+      def register_instance_option(option_name, &default)
+        scope = class << self; self; end
+        self.class.register_instance_option(option_name, scope, &default)
+      end
+
+      def register_deprecated_instance_option(option_name, replacement_option_name = nil, &custom_error)
+        scope = class << self; self; end
+        self.class.register_deprecated_instance_option(option_name, replacement_option_name, scope, &custom_error)
+      end
+
+    private
+
+      def with_recurring(option_name, value_proc, default_proc)
+        # Track recursive invocation with an instance variable. This prevents run-away recursion
+        # and allows configurations such as
+        # label { "#{label}".upcase }
+        # This will use the default definition when called recursively.
+        Thread.current[:rails_admin_recurring] ||= {}
+        Thread.current[:rails_admin_recurring][self] ||= {}
+        if Thread.current[:rails_admin_recurring][self][option_name]
+          instance_eval(&default_proc)
+        else
+          Thread.current[:rails_admin_recurring][self][option_name] = true
+          instance_eval(&value_proc)
+        end
+      ensure
+        Thread.current[:rails_admin_recurring].delete(self)
+      end
+
+      module ClassMethods
+        # Register an instance option. Instance option is a configuration
+        # option that stores its value within an instance variable and is
+        # accessed by an instance method. Both go by the name of the option.
+        def register_instance_option(option_name, scope = self, &default)
+          options = scope.instance_variable_get('@config_options') ||
+                    scope.instance_variable_set('@config_options', {})
+
+          option_name = option_name.to_s
+          options[option_name] = nil
+
+          # If it's a boolean create an alias for it and remove question mark
+          if option_name.end_with?('?')
+            scope.send(:define_method, "#{option_name.chop!}?") do
+              send(option_name)
+            end
+          end
+
+          # Define getter/setter by the option name
+          scope.send(:define_method, option_name) do |*args, &block|
+            if !args[0].nil? || block
+              # Invocation with args --> This is the declaration of the option, i.e. setter
+              instance_variable_set("@#{option_name}_registered", args[0].nil? ? block : args[0])
+            else
+              # Invocation without args nor block --> It's the use of the option, i.e. getter
+              value = instance_variable_get("@#{option_name}_registered")
+              case value
+              when Proc
+                value = with_recurring(option_name, value, default)
+              when nil
+                value = instance_eval(&default)
+              end
+              value
+            end
+          end
+        end
+
+        def register_deprecated_instance_option(option_name, replacement_option_name = nil, scope = self)
+          scope.send(:define_method, option_name) do |*args, &block|
+            if replacement_option_name
+              ActiveSupport::Deprecation.warn("The #{option_name} configuration option is deprecated, please use #{replacement_option_name}.")
+              send(replacement_option_name, *args, &block)
+            elsif block_given?
+              yield
+            else
+              raise "The #{option_name} configuration option is removed without replacement."
+            end
+          end
+        end
+
+        # Register a class option. Class option is a configuration
+        # option that stores it's value within a class object's instance variable
+        # and is accessed by a class method. Both go by the name of the option.
+        def register_class_option(option_name, &default)
+          scope = class << self; self; end
+          register_instance_option(option_name, scope, &default)
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/const_load_suppressor.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    module ConstLoadSuppressor
+      class << self
+        @original_const_missing = nil
+
+        def suppressing
+          raise 'Constant Loading is already suppressed' if @original_const_missing
+
+          begin
+            @original_const_missing = Object.method(:const_missing)
+            intercept_const_missing
+            yield
+          ensure
+            Object.define_singleton_method(:const_missing, @original_const_missing)
+            @original_const_missing = nil
+          end
+        end
+
+        def allowing
+          if @original_const_missing
+            begin
+              Object.define_singleton_method(:const_missing, @original_const_missing)
+              yield
+            ensure
+              intercept_const_missing
+            end
+          else
+            yield
+          end
+        end
+
+      private
+
+        def intercept_const_missing
+          Object.define_singleton_method(:const_missing) do |name|
+            ConstProxy.new(name.to_s)
+          end
+        end
+      end
+
+      class ConstProxy < BasicObject
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def klass
+          @klass ||=
+            begin
+              unless ::Object.const_defined?(name)
+                ::Kernel.raise <<~MESSAGE
+                  The constant #{name} is not loaded yet upon the execution of the RailsAdmin initializer.
+                  We don't recommend to do this and may lead to issues, but if you really have to do so you can explicitly require it by adding:
+
+                    require '#{name.underscore}'
+
+                  on top of config/initializers/rails_admin.rb.
+                MESSAGE
+              end
+              name.constantize
+            end
+        end
+
+        def method_missing(method_name, *args, &block)
+          klass.send(method_name, *args, &block)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super || klass.respond_to?(method_name, include_private)
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/fields/association.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config'
+require 'rails_admin/config/fields/base'
+
+module RailsAdmin
+  module Config
+    module Fields
+      class Association < RailsAdmin::Config::Fields::Base
+        # Reader for the association information hash
+        def association
+          @properties
+        end
+
+        def method_name
+          nested_form ? :"#{name}_attributes" : association.key_accessor
+        end
+
+        register_instance_option :pretty_value do
+          v = bindings[:view]
+          [value].flatten.select(&:present?).collect do |associated|
+            amc = polymorphic? ? RailsAdmin.config(associated) : associated_model_config # perf optimization for non-polymorphic associations
+            am = amc.abstract_model
+            wording = associated.send(amc.object_label_method)
+            can_see = !am.embedded? && (show_action = v.action(:show, am, associated))
+            can_see ? v.link_to(wording, v.url_for(action: show_action.action_name, model_name: am.to_param, id: associated.id)) : ERB::Util.html_escape(wording)
+          end.to_sentence.html_safe.presence || '-'
+        end
+
+        # Accessor whether association is visible or not. By default
+        # association checks whether the child model is excluded in
+        # configuration or not.
+        register_instance_option :visible? do
+          @visible ||= !associated_model_config.excluded?
+        end
+
+        # use the association name as a key, not the association key anymore!
+        register_instance_option :label do
+          (@label ||= {})[::I18n.locale] ||= abstract_model.model.human_attribute_name association.name
+        end
+
+        # scope for possible associable records
+        register_instance_option :associated_collection_scope do
+          # bindings[:object] & bindings[:controller] available
+          associated_collection_scope_limit = (associated_collection_cache_all ? nil : 30)
+          proc do |scope|
+            scope.limit(associated_collection_scope_limit)
+          end
+        end
+
+        # inverse relationship
+        register_instance_option :inverse_of do
+          association.inverse_of
+        end
+
+        # preload entire associated collection (per associated_collection_scope) on load
+        # Be sure to set limit in associated_collection_scope if set is large
+        register_instance_option :associated_collection_cache_all do
+          @associated_collection_cache_all ||= dynamically_scope_by.blank? && (associated_model_config.abstract_model.count < associated_model_limit)
+        end
+
+        # client-side dynamic scoping
+        register_instance_option :dynamically_scope_by do
+          nil
+        end
+
+        # parses #dynamically_scope_by and returns a Hash in the form of
+        # {[form field name in this model]: [field name in the associated model]}
+        def dynamic_scope_relationships
+          @dynamic_scope_relationships ||=
+            Array.wrap(dynamically_scope_by).flat_map do |field|
+              field.is_a?(Hash) ? field.to_a : [[field, field]]
+            end.map do |field_name, target_name| # rubocop:disable Style/MultilineBlockChain
+              field = section.fields.detect { |f| f.name == field_name }
+              raise "Field '#{field_name}' was given for #dynamically_scope_by but not found in '#{abstract_model.model_name}'" unless field
+
+              target_field = associated_model_config.list.fields.detect { |f| f.name == target_name }
+              raise "Field '#{field_name}' was given for #dynamically_scope_by but not found in '#{associated_model_config.abstract_model.model_name}'" unless target_field
+              raise "Field '#{field_name}' in '#{associated_model_config.abstract_model.model_name}' can't be used for dynamic scoping because it's not filterable" unless target_field.filterable
+
+              [field.method_name, target_name]
+            end.to_h
+        end
+
+        # determines whether association's elements can be removed
+        register_instance_option :removable? do
+          association.foreign_key_nullable?
+        end
+
+        register_instance_option :eager_load do
+          !!searchable
+        end
+
+        register_instance_option :inline_add do
+          true
+        end
+
+        register_instance_option :inline_edit do
+          true
+        end
+
+        # Reader for the association's child model's configuration
+        def associated_model_config
+          @associated_model_config ||= RailsAdmin.config(association.klass)
+        end
+
+        # Reader for the association's child model object's label method
+        def associated_object_label_method
+          @associated_object_label_method ||= associated_model_config.object_label_method
+        end
+
+        # Reader for associated primary key
+        def associated_primary_key
+          association.primary_key
+        end
+
+        # Returns params which are to be set in modals
+        def associated_prepopulate_params
+          {}
+        end
+
+        # Reader whether this is a polymorphic association
+        def polymorphic?
+          association.polymorphic?
+        end
+
+        # Reader for nested attributes
+        register_instance_option :nested_form do
+          association.nested_options
+        end
+
+        # Reader for the association's value unformatted
+        def value
+          bindings[:object].send(association.name)
+        end
+
+        # Returns collection of all selectable records
+        def collection(scope = nil)
+          (scope || bindings[:controller].list_entries(associated_model_config, :index, associated_collection_scope, false)).
+            map { |o| [o.send(associated_object_label_method), format_key(o.send(associated_primary_key)).to_s] }
+        end
+
+        # has many?
+        def multiple?
+          true
+        end
+
+        def virtual?
+          true
+        end
+
+        def associated_model_limit
+          RailsAdmin.config.default_associated_collection_limit
+        end
+
+      private
+
+        def format_key(key)
+          if key.is_a?(Array)
+            RailsAdmin.config.composite_keys_serializer.serialize(key)
+          else
+            key
+          end
+        end
+      end
+    end
+  end
+end