hyper-max-sys 0.0.1

data/rails_admin-3.3.0/lib/rails_admin/config/fields/types/text.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/types/string_like'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Text < StringLike
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types.register(self)
+
+          register_instance_option :html_attributes do
+            {
+              required: required?,
+              cols: '48',
+              rows: '3',
+            }
+          end
+
+          register_instance_option :partial do
+            :form_text
+          end
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/fields/types/time.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/types/datetime'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Time < RailsAdmin::Config::Fields::Types::Datetime
+          RailsAdmin::Config::Fields::Types.register(self)
+
+          def parse_value(value)
+            abstract_model.model.type_for_attribute(name.to_s).serialize(super)&.change(year: 2000, month: 1, day: 1)
+          end
+
+          register_instance_option :filter_operators do
+            %w[default between] + (required? ? [] : %w[_separator _not_null _null])
+          end
+
+          register_instance_option :datepicker_options do
+            {
+              allowInput: true,
+              altFormat: flatpickr_format,
+              enableTime: true,
+              noCalendar: true,
+            }
+          end
+
+          register_instance_option :strftime_format do
+            '%H:%M'
+          end
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/fields/types/timestamp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/types/datetime'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Timestamp < RailsAdmin::Config::Fields::Types::Datetime
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types.register(self)
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/fields/types/uuid.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/types/string'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Uuid < RailsAdmin::Config::Fields::Types::String
+          RailsAdmin::Config::Fields::Types.register(self)
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/config/fields/types/wysihtml5.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/types/text'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        class Wysihtml5 < Text
+          # Register field type for the type loader
+          RailsAdmin::Config::Fields::Types.register(self)
+
+          # If you want to have a different toolbar configuration for wysihtml5
+          # you can use a Ruby hash to configure these options:
+          # https://github.com/bootstrap-wysiwyg/bootstrap3-wysiwyg
+          register_instance_option :config_options do
+            {
+              toolbar: {
+                fa: true,
+              },
+            }
+          end
+
+          register_instance_option :version do
+            '0.3.3'
+          end
+
+          register_instance_option :css_location do
+            "https://cdnjs.cloudflare.com/ajax/libs/bootstrap3-wysiwyg/#{version}/bootstrap3-wysihtml5.min.css"
+          end
+
+          register_instance_option :js_location do
+            "https://cdnjs.cloudflare.com/ajax/libs/bootstrap3-wysiwyg/#{version}/bootstrap3-wysihtml5.all.min.js"
+          end
+
+          register_instance_option :partial do
+            :form_wysihtml5
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'rails_admin/config/fields'
+require 'rails_admin/config/fields/association'
+
+module RailsAdmin
+  module Config
+    module Fields
+      module Types
+        @@registry = {}
+
+        def self.load(type)
+          @@registry.fetch(type.to_sym) { raise "Unsupported field datatype: #{type}" }
+        end
+
+        def self.register(type, klass = nil)
+          if klass.nil? && type.is_a?(Class)
+            klass = type
+            type = klass.name.to_s.demodulize.underscore
+          end
+          @@registry[type.to_sym] = klass
+        end
+
+        require 'rails_admin/config/fields/types/all'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    module Fields
+      # Default field factory loads fields based on their property type or
+      # association type.
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      mattr_reader :default_factory
+      @@default_factory = proc do |parent, properties, fields|
+        # If it's an association
+        if properties.association?
+          association = parent.abstract_model.associations.detect { |a| a.name.to_s == properties.name.to_s }
+          field = RailsAdmin::Config::Fields::Types.load("#{association.polymorphic? ? :polymorphic : properties.type}_association").new(parent, properties.name, association)
+        else
+          field = RailsAdmin::Config::Fields::Types.load(properties.type).new(parent, properties.name, properties)
+        end
+        fields << field
+        field
+      end
+
+      # Registry of field factories.
+      #
+      # Field factory is an anonymous function that receives the parent object,
+      # an array of field properties and an array of fields already instantiated.
+      #
+      # If the factory returns true then that property will not be run through
+      # the rest of the registered factories. If it returns false then the
+      # arguments will be passed to the next factory.
+      #
+      # By default a basic factory is registered which loads fields by their
+      # database column type. Also a password factory is registered which
+      # loads fields if their name is password. Third default factory is a
+      # devise specific factory which loads fields for devise user models.
+      #
+      # @see RailsAdmin::Config::Fields.register_factory
+      # @see rails_admin/config/fields/factories/password.rb
+      # @see rails_admin/config/fields/factories/devise.rb
+      @@registry = [@@default_factory]
+
+      # Build an array of fields by the provided parent object's abstract_model's
+      # property and association information. Each property and association is
+      # passed to the registered field factories which will populate the fields
+      # array that will be returned.
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      def self.factory(parent)
+        fields = []
+        # Load fields for all properties (columns)
+
+        parent.abstract_model.properties.each do |properties|
+          # Unless a previous factory has already loaded current field as well
+          next if fields.detect { |f| f.name == properties.name }
+
+          # Loop through factories until one returns true
+          @@registry.detect { |factory| factory.call(parent, properties, fields) }
+        end
+        # Load fields for all associations (relations)
+        parent.abstract_model.associations.reject { |a| a.type == :belongs_to }.each do |association| # :belongs_to are created by factory for belongs_to fields
+          # Unless a previous factory has already loaded current field as well
+          next if fields.detect { |f| f.name == association.name }
+
+          # Loop through factories until one returns true
+          @@registry.detect { |factory| factory.call(parent, association, fields) }
+        end
+        fields
+      end
+
+      # Register a field factory to be included in the factory stack.
+      #
+      # Factories are invoked lifo (last in first out).
+      #
+      # @see RailsAdmin::Config::Fields.registry
+      def self.register_factory(&block)
+        @@registry.unshift(block)
+      end
+    end
+  end
+end
+
+require 'rails_admin/config/fields/types'
+require 'rails_admin/config/fields/factories/password'
+require 'rails_admin/config/fields/factories/enum'
+require 'rails_admin/config/fields/factories/devise'
+require 'rails_admin/config/fields/factories/paperclip'
+require 'rails_admin/config/fields/factories/dragonfly'
+require 'rails_admin/config/fields/factories/carrierwave'
+require 'rails_admin/config/fields/factories/active_storage'
+require 'rails_admin/config/fields/factories/shrine'
+require 'rails_admin/config/fields/factories/action_text'
+require 'rails_admin/config/fields/factories/association'

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module Groupable
+      # Register a group instance variable and accessor methods for objects
+      # extending the has groups mixin. The extended objects must implement
+      # reader for a parent object which includes this module.
+      #
+      # @see RailsAdmin::Config::HasGroups.group
+      # @see RailsAdmin::Config::Fields::Group
+      def group(name = nil)
+        @group = parent.group(name) unless name.nil? # setter
+        @group ||= parent.group(:default) # getter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    # Provides accessor and autoregistering of model's description.
+    module HasDescription
+      attr_reader :description
+
+      def desc(description, &_block)
+        @description ||= description
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    # Provides accessors and autoregistering of model's fields.
+    module HasFields
+      # Defines a configuration for a field.
+      def field(name, type = nil, add_to_section = true, &block)
+        field = _fields.detect { |f| name == f.name }
+
+        # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
+        # unhide them if config specifically defines them
+        field.show if field && !field.instance_variable_get("@#{field.name}_registered").is_a?(Proc)
+        # Specify field as virtual if type is not specifically set and field was not
+        # found in default stack
+        if field.nil? && type.nil?
+          field = (_fields << RailsAdmin::Config::Fields::Types.load(:string).new(self, name, nil)).last
+
+        # Register a custom field type if one is provided and it is different from
+        # one found in default stack
+        elsif type && type != (field.nil? ? nil : field.type)
+          if field
+            properties = field.properties
+            field = _fields[_fields.index(field)] = RailsAdmin::Config::Fields::Types.load(type).new(self, name, properties)
+          else
+            properties = abstract_model.properties.detect { |p| name == p.name }
+            field = (_fields << RailsAdmin::Config::Fields::Types.load(type).new(self, name, properties)).last
+          end
+        end
+
+        # If field has not been yet defined add some default properties
+        if add_to_section && !field.defined
+          field.defined = true
+          field.order = _fields.count(&:defined)
+        end
+
+        # If a block has been given evaluate it and sort fields after that
+        field.instance_eval(&block) if block
+        field
+      end
+
+      # configure field(s) from the default group in a section without changing the original order.
+      def configure(name, type = nil, &block)
+        [*name].each { |field_name| field(field_name, type, false, &block) }
+      end
+
+      # include fields by name and apply an optional block to each (through a call to fields),
+      # or include fields by conditions if no field names
+      def include_fields(*field_names, &block)
+        if field_names.empty?
+          _fields.select { |f| f.instance_eval(&block) }.each do |f|
+            next if f.defined
+
+            f.defined = true
+            f.order = _fields.count(&:defined)
+          end
+        else
+          fields(*field_names, &block)
+        end
+      end
+
+      # exclude fields by name or by condition (block)
+      def exclude_fields(*field_names, &block)
+        block ||= proc { |f| field_names.include?(f.name) }
+        _fields.each { |f| f.defined = true } if _fields.select(&:defined).empty?
+        _fields.select { |f| f.instance_eval(&block) }.each { |f| f.defined = false }
+      end
+
+      # API candy
+      alias_method :exclude_fields_if, :exclude_fields
+      alias_method :include_fields_if, :include_fields
+
+      def include_all_fields
+        include_fields_if { true }
+      end
+
+      # Returns all field configurations for the model configuration instance. If no fields
+      # have been defined returns all fields. Defined fields are sorted to match their
+      # order property. If order was not specified it will match the order in which fields
+      # were defined.
+      #
+      # If a block is passed it will be evaluated in the context of each field
+      def fields(*field_names, &block)
+        return all_fields if field_names.empty? && !block
+
+        if field_names.empty?
+          defined = _fields.select(&:defined)
+          defined = _fields if defined.empty?
+        else
+          defined = field_names.collect { |field_name| _fields.detect { |f| f.name == field_name } }
+        end
+        defined.collect do |f|
+          unless f.defined
+            f.defined = true
+            f.order = _fields.count(&:defined)
+          end
+          f.instance_eval(&block) if block
+          f
+        end
+      end
+
+      # Defines configuration for fields by their type.
+      def fields_of_type(type, &block)
+        _fields.select { |f| type == f.type }.map! { |f| f.instance_eval(&block) } if block
+      end
+
+      # Accessor for all fields
+      def all_fields
+        ((ro_fields = _fields(true)).select(&:defined).presence || ro_fields).collect do |f|
+          f.section = self
+          f
+        end
+      end
+
+      # Get all fields defined as visible, in the correct order.
+      def visible_fields
+        i = 0
+        all_fields.collect { |f| f.with(bindings) }.select(&:visible?).sort_by { |f| [f.order, i += 1] } # stable sort, damn
+      end
+
+      def possible_fields
+        _fields(true)
+      end
+
+    protected
+
+      # Raw fields.
+      # Recursively returns parent section's raw fields
+      # Duping it if accessed for modification.
+      def _fields(readonly = false)
+        return @_fields if @_fields
+        return @_ro_fields if readonly && @_ro_fields
+
+        if instance_of?(RailsAdmin::Config::Sections::Base)
+          @_ro_fields = @_fields = RailsAdmin::Config::Fields.factory(self)
+        else
+          # parent is RailsAdmin::Config::Model, recursion is on Section's classes
+          @_ro_fields ||= parent.send(self.class.superclass.to_s.underscore.split('/').last)._fields(true).clone.freeze
+        end
+        readonly ? @_ro_fields : (@_fields ||= @_ro_fields.collect(&:clone))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/fields/group'
+
+module RailsAdmin
+  module Config
+    module HasGroups
+      # Accessor for a group
+      #
+      # If group with given name does not yet exist it will be created. If a
+      # block is passed it will be evaluated in the context of the group
+      def group(name, &block)
+        group = parent.groups.detect { |g| name == g.name }
+        group ||= (parent.groups << RailsAdmin::Config::Fields::Group.new(self, name)).last
+        group.tap { |g| g.section = self }.instance_eval(&block) if block
+        group
+      end
+
+      # Reader for groups that are marked as visible
+      def visible_groups
+        parent.groups.collect { |f| f.section = self; f.with(bindings) }.select(&:visible?).select do |g| # rubocop:disable Style/Semicolon
+          g.visible_fields.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    # Defines a visibility configuration
+    module Hideable
+      # Visibility defaults to true.
+      def self.included(klass)
+        klass.register_instance_option :visible? do
+          !root.try :excluded?
+        end
+      end
+
+      # Reader whether object is hidden.
+      def hidden?
+        !visible
+      end
+
+      # Writer to hide object.
+      def hide(&block)
+        visible block ? proc { instance_eval(&block) == false } : false
+      end
+
+      # Writer to show field.
+      def show(&block)
+        visible block || true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Config
+    module Inspectable
+      def inspect
+        set_named_instance_variables
+
+        instance_name = try(:name) || try(:abstract_model).try(:model).try(:name)
+        instance_name = instance_name ? "[#{instance_name}]" : ''
+
+        instance_vars = instance_variables.collect do |v|
+          instance_variable_name(v)
+        end.join(', ')
+
+        "#<#{self.class.name}#{instance_name} #{instance_vars}>"
+      end
+
+    private
+
+      def instance_variable_name(variable)
+        value = instance_variable_get(variable)
+        if self.class::NAMED_INSTANCE_VARIABLES.include?(variable)
+          if value.respond_to?(:name)
+            "#{variable}=#{value.name.inspect}"
+          else
+            "#{variable}=#{value.class.name}"
+          end
+        else
+          "#{variable}=#{value.inspect}"
+        end
+      end
+
+      def set_named_instance_variables
+        self.class.const_set('NAMED_INSTANCE_VARIABLES', []) unless defined?(self.class::NAMED_INSTANCE_VARIABLES)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rails_admin/config/model'
+
+module RailsAdmin
+  module Config
+    class LazyModel < BasicObject
+      def initialize(entity, &block)
+        @entity = entity
+        @deferred_blocks = [*block]
+        @initialized = false
+      end
+
+      def add_deferred_block(&block)
+        if @initialized
+          @model.instance_eval(&block)
+        else
+          @deferred_blocks << block
+        end
+      end
+
+      def target
+        @model ||= ::RailsAdmin::Config::Model.new(@entity)
+        # When evaluating multiple configuration blocks, the order of
+        # execution is important. As one would expect (in my opinion),
+        # options defined within a resource should take precedence over
+        # more general options defined in an initializer. This way,
+        # general settings for a number of resources could be specified
+        # in the initializer, while models could override these settings
+        # later, if required.
+        #
+        # CAVEAT: It cannot be guaranteed that blocks defined in an initializer
+        # will be loaded (and adde to @deferred_blocks) first. For instance, if
+        # the initializer references a model class before defining
+        # a RailsAdmin configuration block, the configuration from the
+        # resource will get added to @deferred_blocks first:
+        #
+        #     # app/models/some_model.rb
+        #     class SomeModel
+        #       rails_admin do
+        #         :
+        #       end
+        #     end
+        #
+        #     # config/initializers/rails_admin.rb
+        #     model = 'SomeModel'.constantize # blocks from SomeModel get loaded
+        #     model.config model do           # blocks from initializer gets loaded
+        #       :
+        #     end
+        #
+        # Thus, sort all blocks to execute for a resource by Proc.source_path,
+        # to guarantee that blocks from 'config/initializers' evaluate before
+        # blocks defined within a model class.
+        unless @deferred_blocks.empty?
+          @deferred_blocks.
+            partition { |block| block.source_location.first =~ %r{config/initializers} }.
+            flatten.
+            each { |block| @model.instance_eval(&block) }
+          @deferred_blocks = []
+        end
+        @initialized = true
+        @model
+      end
+
+      def method_missing(method_name, *args, &block)
+        target.send(method_name, *args, &block)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super || target.respond_to?(method_name, include_private)
+      end
+    end
+  end
+end