hyper-max-sys 0.0.1

data/rails_admin-3.3.0/lib/rails_admin/extensions/paper_trail/auditing_adapter.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/strip'
+
+module RailsAdmin
+  module Extensions
+    module PaperTrail
+      class VersionProxy
+        def initialize(version, user_class = User)
+          @version = version
+          @user_class = user_class
+        end
+
+        def message
+          @message = @version.event
+          @version.respond_to?(:changeset) && @version.changeset.present? ? @message + ' [' + @version.changeset.to_a.collect { |c| "#{c[0]} = #{c[1][1]}" }.join(', ') + ']' : @message
+        end
+
+        def created_at
+          @version.created_at
+        end
+
+        def table
+          @version.item_type
+        end
+
+        def username
+          begin
+            @user_class.find(@version.whodunnit).try(:email)
+          rescue StandardError
+            nil
+          end || @version.whodunnit
+        end
+
+        def item
+          @version.item_id
+        end
+      end
+
+      module ControllerExtension
+        def user_for_paper_trail
+          _current_user.try(:id) || _current_user
+        end
+      end
+
+      class AuditingAdapter
+        COLUMN_MAPPING = {
+          table: :item_type,
+          username: :whodunnit,
+          item: :item_id,
+          created_at: :created_at,
+          message: :event,
+        }.freeze
+        E_USER_CLASS_NOT_SET = <<~ERROR
+          Please set up PaperTrail's user class explicitly.
+
+              config.audit_with :paper_trail do
+                user_class { User }
+              end
+        ERROR
+        E_VERSION_MODEL_NOT_SET = <<~ERROR
+          Please set up PaperTrail's version model explicitly.
+
+              config.audit_with :paper_trail do
+                version_class { PaperTrail::Version }
+              end
+
+          If you have configured a model to use a custom version class
+          (https://github.com/paper-trail-gem/paper_trail#6a-custom-version-classes)
+          that configuration will take precedence over what you specify in `audit_with`.
+        ERROR
+
+        include RailsAdmin::Config::Configurable
+
+        def self.setup
+          raise 'PaperTrail not found' unless defined?(::PaperTrail)
+
+          RailsAdmin::Extensions::ControllerExtension.include ControllerExtension
+        end
+
+        def initialize(controller, user_class_name = nil, version_class_name = nil, &block)
+          @controller = controller
+          @controller&.send(:set_paper_trail_whodunnit)
+
+          user_class { user_class_name.to_s.constantize } if user_class_name
+          version_class { version_class_name.to_s.constantize } if version_class_name
+
+          instance_eval(&block) if block
+        end
+
+        register_instance_option :user_class do
+          User
+        rescue NameError
+          raise E_USER_CLASS_NOT_SET
+        end
+
+        register_instance_option :version_class do
+          PaperTrail::Version
+        rescue NameError
+          raise E_VERSION_MODEL_NOT_SET
+        end
+
+        register_instance_option :sort_by do
+          {id: :desc}
+        end
+
+        def latest(count = 100)
+          version_class.
+            order(sort_by).includes(:item).limit(count).
+            collect { |version| VersionProxy.new(version, user_class) }
+        end
+
+        def delete_object(_object, _model, _user)
+          # do nothing
+        end
+
+        def update_object(_object, _model, _user, _changes)
+          # do nothing
+        end
+
+        def create_object(_object, _abstract_model, _user)
+          # do nothing
+        end
+
+        def listing_for_model(model, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          listing_for_model_or_object(model, nil, query, sort, sort_reverse, all, page, per_page)
+        end
+
+        def listing_for_object(model, object, query, sort, sort_reverse, all, page, per_page = (RailsAdmin::Config.default_items_per_page || 20))
+          listing_for_model_or_object(model, object, query, sort, sort_reverse, all, page, per_page)
+        end
+
+      protected
+
+        # - model - a RailsAdmin::AbstractModel
+        def listing_for_model_or_object(model, object, query, sort, sort_reverse, all, page, per_page)
+          sort =
+            if sort.present?
+              {COLUMN_MAPPING[sort.to_sym] => sort_reverse ? :desc : :asc}
+            else
+              sort_by
+            end
+
+          current_page = page.presence || '1'
+
+          versions = object.nil? ? versions_for_model(model) : object.public_send(model.model.versions_association_name)
+          versions = versions.where('event LIKE ?', "%#{query}%") if query.present?
+          versions = versions.order(sort)
+          versions = versions.send(Kaminari.config.page_method_name, current_page).per(per_page) unless all
+          paginated_proxies = Kaminari.paginate_array([], total_count: versions.try(:total_count) || versions.count)
+          paginated_proxies = paginated_proxies.send(
+            paginated_proxies.respond_to?(Kaminari.config.page_method_name) ? Kaminari.config.page_method_name : :page,
+            current_page,
+          ).per(per_page)
+          versions.each do |version|
+            paginated_proxies << VersionProxy.new(version, user_class)
+          end
+          paginated_proxies
+        end
+
+        def versions_for_model(model)
+          model_name = model.model.name
+          base_class_name = model.model.base_class.name
+
+          options =
+            if base_class_name == model_name
+              {item_type: model_name}
+            else
+              {item_type: base_class_name, item_id: model.model.all}
+            end
+
+          version_class_for(model.model).where(options)
+        end
+
+        # PT can be configured to use [custom version
+        # classes](https://github.com/paper-trail-gem/paper_trail#6a-custom-version-classes)
+        #
+        # ```ruby
+        # has_paper_trail versions: { class_name: 'MyVersion' }
+        # ```
+        def version_class_for(model)
+          model.paper_trail.version_class
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/extensions/paper_trail.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'rails_admin/extensions/paper_trail/auditing_adapter'
+
+RailsAdmin.add_extension(:paper_trail, RailsAdmin::Extensions::PaperTrail, auditing: true)

data/rails_admin-3.3.0/lib/rails_admin/extensions/pundit/authorization_adapter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Extensions
+    module Pundit
+      # This adapter is for the Pundit[https://github.com/elabs/pundit] authorization library.
+      # You can create another adapter for different authorization behavior, just be certain it
+      # responds to each of the public methods here.
+      class AuthorizationAdapter
+        # This method is called first time only and used for setup
+        def self.setup
+          RailsAdmin::Extensions::ControllerExtension.include defined?(::Pundit::Authorization) ? ::Pundit::Authorization : ::Pundit
+        end
+
+        # See the +authorize_with+ config method for where the initialization happens.
+        def initialize(controller)
+          @controller = controller
+        end
+
+        # This method is called in every controller action and should raise an exception
+        # when the authorization fails. The first argument is the name of the controller
+        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
+        # AbstractModel instance that applies. The third argument is the actual model
+        # instance if it is available.
+        def authorize(action, abstract_model = nil, model_object = nil)
+          record = model_object || abstract_model&.model
+          raise ::Pundit::NotAuthorizedError.new("not allowed to #{action} this #{record}") if action && !policy(record).send(action_for_pundit(action))
+
+          @controller.instance_variable_set(:@_pundit_policy_authorized, true)
+        end
+
+        # This method is called primarily from the view to determine whether the given user
+        # has access to perform the action on a given model. It should return true when authorized.
+        # This takes the same arguments as +authorize+. The difference is that this will
+        # return a boolean whereas +authorize+ will raise an exception when not authorized.
+        def authorized?(action, abstract_model = nil, model_object = nil)
+          record = model_object || abstract_model&.model
+          policy(record).send(action_for_pundit(action)) if action
+        end
+
+        # This is called when needing to scope a database query. It is called within the list
+        # and bulk_delete/destroy actions and should return a scope which limits the records
+        # to those which the user can perform the given action on.
+        def query(_action, abstract_model)
+          @controller.send(:policy_scope, abstract_model.model.all)
+        rescue ::Pundit::NotDefinedError
+          abstract_model.model.all
+        end
+
+        # This is called in the new/create actions to determine the initial attributes for new
+        # records. It should return a hash of attributes which match what the user
+        # is authorized to create.
+        def attributes_for(action, abstract_model)
+          record = abstract_model&.model
+          policy(record).try(:attributes_for, action) || {}
+        end
+
+      private
+
+        def policy(record)
+          @controller.send(:policy, record)
+        rescue ::Pundit::NotDefinedError
+          ::ApplicationPolicy.new(@controller.send(:pundit_user), record)
+        end
+
+        def action_for_pundit(action)
+          action[-1, 1] == '?' ? action : "#{action}?"
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/extensions/pundit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'rails_admin/extensions/pundit/authorization_adapter'
+
+RailsAdmin.add_extension(:pundit, RailsAdmin::Extensions::Pundit, authorization: true)

data/rails_admin-3.3.0/lib/rails_admin/extensions/url_for_extension.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Extensions
+    module UrlForExtension
+      def url_for(options, *args)
+        case options[:id]
+        when Array
+          options[:id] = RailsAdmin.config.composite_keys_serializer.serialize(options[:id])
+        end
+        super options, *args
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/support/composite_keys_serializer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Support
+    module CompositeKeysSerializer
+      def self.serialize(keys)
+        keys.map { |key| key&.to_s&.gsub('_', '__') }.join('_')
+      end
+
+      def self.deserialize(string)
+        string.split('_').map { |key| key&.gsub('__', '_') }
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/support/csv_converter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module RailsAdmin
+  class CSVConverter
+    def initialize(objects = [], schema = nil)
+      @fields = []
+      @associations = []
+      schema ||= {}
+
+      return self if (@objects = objects).blank?
+
+      @model = objects.dup.first.class
+      @abstract_model = RailsAdmin::AbstractModel.new(@model)
+      @model_config = @abstract_model.config
+      @methods = [(schema[:only] || []) + (schema[:methods] || [])].flatten.compact
+      @fields = @methods.collect { |m| export_field_for(m) }.compact
+      @empty = ::I18n.t('admin.export.empty_value_for_associated_objects')
+      schema_include = schema.delete(:include) || {}
+
+      @associations = schema_include.each_with_object({}) do |(key, values), hash|
+        association = export_field_for(key)
+        next unless association&.association?
+
+        model_config = association.associated_model_config
+        abstract_model = model_config.abstract_model
+        methods = [(values[:only] || []) + (values[:methods] || [])].flatten.compact
+
+        hash[key] = {
+          association: association,
+          model: abstract_model.model,
+          abstract_model: abstract_model,
+          model_config: model_config,
+          fields: methods.collect { |m| export_field_for(m, model_config) }.compact,
+        }
+        hash
+      end
+    end
+
+    def to_csv(options = {})
+      if CSV::VERSION == '3.0.2'
+        raise <<~MSG
+          CSV library bundled with Ruby 2.6.0 has encoding issue, please upgrade Ruby to 2.6.1 or later.
+          https://github.com/ruby/csv/issues/62
+        MSG
+      end
+
+      options = HashWithIndifferentAccess.new(options)
+      encoding_to = Encoding.find(options[:encoding_to]) if options[:encoding_to].present?
+
+      csv_string = generate_csv_string(options)
+      csv_string = csv_string.encode(encoding_to, invalid: :replace, undef: :replace, replace: '?') if encoding_to
+
+      # Add a BOM for utf8 encodings, helps with utf8 auto-detect for some versions of Excel.
+      # Don't add if utf8 but user don't want to touch input encoding:
+      # If user chooses utf8, they will open it in utf8 and BOM will disappear at reading.
+      # But that way "English" users who don't bother and chooses to let utf8 by default won't get BOM added
+      # and will not see it if Excel opens the file with a different encoding.
+      csv_string = "\xEF\xBB\xBF#{csv_string}" if encoding_to == Encoding::UTF_8
+
+      [!options[:skip_header], (encoding_to || csv_string.encoding).to_s, csv_string]
+    end
+
+  private
+
+    def export_field_for(method, model_config = @model_config)
+      model_config.export.fields.detect { |f| f.name == method }
+    end
+
+    def generate_csv_string(options)
+      generator_options = (options[:generator] || {}).symbolize_keys.delete_if { |_, value| value.blank? }
+      method = @objects.respond_to?(:find_each) ? :find_each : :each
+
+      CSV.generate(**generator_options) do |csv|
+        csv << generate_csv_header unless options[:skip_header]
+
+        @objects.send(method) do |object|
+          csv << generate_csv_row(object)
+        end
+      end
+    end
+
+    def generate_csv_header
+      @fields.collect do |field|
+        ::I18n.t('admin.export.csv.header_for_root_methods', name: field.label, model: @abstract_model.pretty_name)
+      end +
+        @associations.flat_map do |_association_name, option_hash|
+          option_hash[:fields].collect do |field|
+            ::I18n.t('admin.export.csv.header_for_association_methods', name: field.label, association: option_hash[:association].label)
+          end
+        end
+    end
+
+    def generate_csv_row(object)
+      @fields.collect do |field|
+        field.with(object: object).export_value
+      end +
+        @associations.flat_map do |association_name, option_hash|
+          associated_objects = [object.send(association_name)].flatten.compact
+          option_hash[:fields].collect do |field|
+            associated_objects.collect { |ao| field.with(object: ao).export_value.presence || @empty }.join(',')
+          end
+        end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/support/datetime.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Support
+    class Datetime
+      # Ruby format options as a key and flatpickr format options as a value
+      FLATPICKR_TRANSLATIONS = {
+        '%A' => 'l',       # The  full  weekday  name ("Sunday")
+        '%a' => 'D',       # The abbreviated weekday name ("Sun")
+        '%B' => 'F',       # The  full  month  name ("January")
+        '%b' => 'M',       # The abbreviated month name ("Jan")
+        '%D' => 'm/d/y',   # American date format mm/dd/yy
+        '%d' => 'd',       # Day of the month (01..31)
+        '%-d' => 'j',      # Day of the month (1..31)
+        '%e' => 'j',       # Day of the month (1..31)
+        '%F' => 'Y-m-d',   # ISO 8601 date format
+        '%H' => 'H',       # Hour of the day, 24-hour clock (00..23)
+        '%-H' => 'H',      # Hour of the day, 24-hour clock (0..23)
+        '%h' => 'M',       # Same as %b
+        '%I' => 'G',       # Hour of the day, 12-hour clock (01..12)
+        '%-I' => 'h',      # Hour of the day, 12-hour clock (1..12)
+        '%k' => 'H',       # Hour of the day, 24-hour clock (0..23)
+        '%l' => 'h',       # Hour of the day, 12-hour clock (1..12)
+        '%-l' => 'h',      # Hour of the day, 12-hour clock (1..12)
+        '%M' => 'i',       # Minute of the hour (00..59)
+        '%-M' => 'i',      # Minute of the hour (00..59)
+        '%m' => 'm',       # Month of the year (01..12)
+        '%-m' => 'n',      # Month of the year (1..12)
+        '%P' => 'K',       # Meridian indicator ('am' or 'pm')
+        '%p' => 'K',       # Meridian indicator ('AM' or 'PM')
+        '%R' => 'H:i',     # 24-hour time (%H:%M)
+        '%r' => 'G:i:S K', # 12-hour time (%I:%M:%S %p)
+        '%S' => 'S',       # Second of the minute (00..60)
+        '%-S' => 's',      # Second of the minute (0..60)
+        '%s' => 'U',       # Number of seconds since 1970-01-01 00:00:00 UTC.
+        '%T' => 'H:i:S',   # 24-hour time (%H:%M:%S)
+        '%U' => 'W',       # Week number of the year.  The week starts with Sunday.  (00..53)
+        '%w' => 'w',       # Day of the week (Sunday is 0, 0..6)
+        '%X' => 'H:i:S',   # Same as %T
+        '%x' => 'm/d/y',   # Same as %D
+        '%Y' => 'Y',       # Year with century
+        '%y' => 'y',       # Year without a century (00..99)
+        '%%' => '%',
+      }.freeze
+
+      class << self
+        def to_flatpickr_format(strftime_format)
+          strftime_format.gsub(/(?<!%)(?<![-0-9:])\w/, '\\\\\0').gsub(/%([-0-9:]?\w)/) do |match|
+            # Timezone can't be handled by frontend, the server's one is always used
+            case match
+            when '%Z', '%:z' # Time zone as hour and minute offset from UTC with a colon (e.g. +09:00)
+              Time.zone.formatted_offset
+            when '%z' # Time zone as hour and minute offset from UTC (e.g. +0900)
+              Time.zone.formatted_offset(false)
+            else
+              FLATPICKR_TRANSLATIONS[match] or raise <<~MSG
+                Unsupported strftime directive '#{match}' was found. Please consider explicitly setting flatpickr_format instance option for the field.
+                  field(:name_of_field) { flatpickr_format '...' }
+              MSG
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/support/es_module_processor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Support
+    class ESModuleProcessor
+      def self.instance
+        @instance ||= new
+      end
+
+      def self.call(input)
+        instance.call(input)
+      end
+
+      def initialize; end
+
+      def call(input)
+        return unless input[:name] == 'rails_admin/application'
+
+        input[:data].gsub(/^((?:import|export) .+)$/) { "// #{Regexp.last_match(1)}" }
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/support/hash_helper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  class HashHelper
+    def self.symbolize(obj)
+      case obj
+      when Array
+        obj.each_with_object([]) do |val, res|
+          res << case val
+                 when Hash, Array then symbolize(val)
+                 when String      then val.to_sym
+                 else val
+                 end
+        end
+      when Hash
+        obj.each_with_object({}) do |(key, val), res|
+          nkey = key.is_a?(String) ? key.to_sym : key
+          nval =
+            case val
+            when Hash, Array then symbolize(val)
+            when String      then val.to_sym
+            else val
+            end
+          res[nkey] = nval
+        end
+      else
+        obj
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/version.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  class Version
+    MAJOR = 3
+    MINOR = 3
+    PATCH = 0
+    PRE = nil
+
+    class << self
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+
+      def js
+        JSON.parse(File.read("#{__dir__}/../../package.json"))['version']
+      end
+
+      def actual_js_version
+        case RailsAdmin.config.asset_source
+        when :webpacker, :webpack
+          js_version_from_node_modules
+        else
+          js
+        end
+      end
+
+      def warn_with_js_version
+        return unless Rails.env.development? || Rails.env.test?
+
+        case actual_js_version
+        when js
+          # Good
+        when nil
+          warn "[Warning] Failed to detect RailsAdmin npm package, did you run 'yarn install'?"
+        else
+          warn <<~MSG
+            [Warning] RailsAdmin npm package version inconsistency detected, expected #{js} but actually used is #{actual_js_version}.
+            This may cause partial or total malfunction of RailsAdmin frontend features.
+          MSG
+        end
+      end
+
+    private
+
+      def js_version_from_node_modules
+        JSON.parse(File.read(Rails.root.join('node_modules/rails_admin/package.json')))['version']
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rails_admin/engine'
+require 'rails_admin/abstract_model'
+require 'rails_admin/config'
+require 'rails_admin/config/const_load_suppressor'
+require 'rails_admin/extension'
+require 'rails_admin/extensions/cancancan'
+require 'rails_admin/extensions/pundit'
+require 'rails_admin/extensions/paper_trail'
+require 'rails_admin/support/csv_converter'
+require 'rails_admin/support/hash_helper'
+require 'yaml'
+
+module RailsAdmin
+  extend RailsAdmin::Config::ConstLoadSuppressor
+
+  # Setup RailsAdmin
+  #
+  # Given the first argument is a model class, a model class name
+  # or an abstract model object proxies to model configuration method.
+  #
+  # If only a block is passed it is stored to initializer stack to be evaluated
+  # on first request in production mode and on each request in development. If
+  # initialization has already occurred (in other words RailsAdmin.setup has
+  # been called) the block will be added to stack and evaluated at once.
+  #
+  # Otherwise returns RailsAdmin::Config class.
+  #
+  # @see RailsAdmin::Config
+  def self.config(entity = nil, &block)
+    if entity
+      RailsAdmin::Config.model(entity, &block)
+    elsif block_given?
+      RailsAdmin::Config::ConstLoadSuppressor.suppressing { yield(RailsAdmin::Config) }
+    else
+      RailsAdmin::Config
+    end
+  end
+
+  # Backwards-compatible with safe_yaml/load when SafeYAML isn't available.
+  # Evaluates available YAML loaders at boot and creates appropriate method,
+  # so no conditionals are required at runtime.
+  begin
+    require 'safe_yaml/load'
+    def self.yaml_load(yaml)
+      SafeYAML.load(yaml)
+    end
+  rescue LoadError
+    if YAML.respond_to?(:safe_load)
+      def self.yaml_load(yaml)
+        YAML.safe_load(yaml)
+      end
+    else
+      raise LoadError.new "Safe-loading of YAML is not available. Please install 'safe_yaml' or install Psych 2.0+"
+    end
+  end
+
+  def self.yaml_dump(object)
+    YAML.dump(object)
+  end
+end