hyper-max-sys 0.0.1

data/rails_admin-3.3.0/lib/generators/rails_admin/importmap_formatter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'importmap/packager'
+
+module RailsAdmin
+  class ImportmapFormatter
+    attr_reader :packager
+
+    def initialize(path = 'config/importmap.rails_admin.rb')
+      @packager = Importmap::Packager.new(path)
+    end
+
+    def format
+      imports = packager.import("rails_admin@#{RailsAdmin::Version.js}", from: 'jspm.io')
+
+      # Use ESM compatible version to work around https://github.com/cljsjs/packages/issues/1579
+      imports['@popperjs/core'].gsub!('lib/index.js', 'dist/esm/popper.js')
+
+      # Tidy up jQuery UI dependencies
+      jquery_uis = imports.keys.filter { |key, _| key =~ /jquery-ui/ }
+      imports['jquery-ui/'] = imports[jquery_uis.first].gsub(%r{(@[^/@]+)/[^@]+$}, '\1/')
+      imports.reject! { |key, _| jquery_uis.include? key }
+
+      pins = ['pin "rails_admin", preload: true', packager.pin_for('rails_admin/src/rails_admin/base', imports.delete('rails_admin'))]
+      (pins + imports.map { |package, url| packager.pin_for(package, url) }).join("\n")
+    end
+  end
+end

data/rails_admin-3.3.0/lib/generators/rails_admin/install_generator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails_admin/version'
+require File.expand_path('utils', __dir__)
+
+module RailsAdmin
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+    include Generators::Utils::InstanceMethods
+
+    argument :_namespace, type: :string, required: false, desc: 'RailsAdmin url namespace'
+    class_option :asset, type: :string, required: false, default: nil, desc: 'Asset delivery method [options: webpacker, webpack, sprockets, importmap, vite]'
+    desc 'RailsAdmin installation generator'
+
+    def install
+      if File.read(File.join(destination_root, 'config/routes.rb')).include?('mount RailsAdmin::Engine')
+        display "Skipped route addition, since it's already there"
+      else
+        namespace = ask_for('Where do you want to mount rails_admin?', 'admin', _namespace)
+        route("mount RailsAdmin::Engine => '/#{namespace}', as: 'rails_admin'")
+      end
+      if File.exist? File.join(destination_root, 'config/initializers/rails_admin.rb')
+        insert_into_file 'config/initializers/rails_admin.rb', "  config.asset_source = :#{asset}\n", after: "RailsAdmin.config do |config|\n"
+      else
+        template 'initializer.erb', 'config/initializers/rails_admin.rb'
+      end
+      display "Using [#{asset}] for asset delivery method"
+      case asset
+      when 'webpack'
+        configure_for_webpack
+      when 'importmap'
+        configure_for_importmap
+      when 'webpacker'
+        configure_for_webpacker5
+      when 'vite'
+        configure_for_vite
+      when 'sprockets'
+        configure_for_sprockets
+      else
+        raise "Unknown asset source: #{asset}"
+      end
+    end
+
+  private
+
+    def asset
+      return options['asset'] if options['asset']
+
+      if defined?(Webpacker)
+        'webpacker'
+      elsif Rails.root.join('webpack.config.js').exist?
+        'webpack'
+      elsif Rails.root.join('config/importmap.rb').exist?
+        'importmap'
+      elsif defined?(ViteRuby)
+        'vite'
+      else
+        'sprockets'
+      end
+    end
+
+    def configure_for_sprockets
+      gem 'sassc-rails'
+    end
+
+    def configure_for_webpacker5
+      run "yarn add rails_admin@#{RailsAdmin::Version.js}"
+      template 'rails_admin.webpacker.js', 'app/javascript/packs/rails_admin.js'
+      template 'rails_admin.scss.erb', 'app/javascript/stylesheets/rails_admin.scss'
+      # To work around https://github.com/railsadminteam/rails_admin/issues/3565
+      add_package_json_field('resolutions', {'rails_admin/@fortawesome/fontawesome-free' => '^5.15.0'})
+    end
+
+    def configure_for_vite
+      vite_source_code_dir = ViteRuby.config.source_code_dir
+      run "yarn add rails_admin@#{RailsAdmin::Version.js} sass"
+      template('rails_admin.vite.js', File.join(vite_source_code_dir, 'entrypoints', 'rails_admin.js'))
+      @fa_font_path = '@fortawesome/fontawesome-free/webfonts'
+      template('rails_admin.scss.erb', File.join(vite_source_code_dir, 'stylesheets', 'rails_admin.scss'))
+    end
+
+    def configure_for_webpack
+      run "yarn add rails_admin@#{RailsAdmin::Version.js}"
+      template 'rails_admin.js', 'app/javascript/rails_admin.js'
+      webpack_config = File.join(destination_root, 'webpack.config.js')
+      marker = %r{application: ["']./app/javascript/application.js["']}
+      if File.exist?(webpack_config) && File.read(webpack_config) =~ marker
+        insert_into_file 'webpack.config.js', %(,\n    rails_admin: "./app/javascript/rails_admin.js"), after: marker
+      else
+        say 'Add `rails_admin: "./app/javascript/rails_admin.js"` to the entry section in your webpack.config.js.', :red
+      end
+      setup_css({'build' => 'webpack --config webpack.config.js'})
+    end
+
+    def configure_for_importmap
+      run "yarn add rails_admin@#{RailsAdmin::Version.js}"
+      template 'rails_admin.js', 'app/javascript/rails_admin.js'
+      require_relative 'importmap_formatter'
+      add_file 'config/importmap.rails_admin.rb', ImportmapFormatter.new.format
+      setup_css
+    end
+
+    def setup_css(additional_script_entries = {})
+      gem 'cssbundling-rails'
+      rake 'css:install:sass'
+
+      @fa_font_path = '.'
+      template 'rails_admin.scss.erb', 'app/assets/stylesheets/rails_admin.scss'
+      asset_config = %{Rails.application.config.assets.paths << Rails.root.join("node_modules/@fortawesome/fontawesome-free/webfonts")\n}
+      if File.exist? File.join(destination_root, 'config/initializers/assets.rb')
+        append_to_file 'config/initializers/assets.rb', asset_config
+      else
+        add_file 'config/initializers/assets.rb', asset_config
+      end
+      add_package_json_field('scripts', additional_script_entries.merge({'build:css' => 'sass ./app/assets/stylesheets/rails_admin.scss:./app/assets/builds/rails_admin.css --no-source-map --load-path=node_modules'}), <<~INSTRUCTION)
+        Taking 'build:css' as an example, if you're already have application.sass.css for the sass build, the resulting script would look like:
+          sass ./app/assets/stylesheets/application.sass.scss:./app/assets/builds/application.css ./app/assets/stylesheets/rails_admin.scss:./app/assets/builds/rails_admin.css --no-source-map --load-path=node_modules
+      INSTRUCTION
+    end
+
+    def add_package_json_field(name, entries, instruction = nil)
+      display "Add #{name} to package.json"
+      package = begin
+        JSON.parse(File.read(File.join(destination_root, 'package.json')))
+      rescue Errno::ENOENT, JSON::ParserError
+        {}
+      end
+      if package[name] && (package[name].keys & entries.keys).any?
+        say <<~MESSAGE, :red
+          You need to merge "#{name}": #{JSON.pretty_generate(entries)} into the existing #{name} in your package.json.#{instruction && "\n#{instruction}"}
+        MESSAGE
+      else
+        package[name] ||= {}
+        entries.each do |entry, value|
+          package[name][entry] = value
+        end
+        add_file 'package.json', "#{JSON.pretty_generate(package)}\n"
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/generators/rails_admin/templates/initializer.erb

@@ -0,0 +1,42 @@
+RailsAdmin.config do |config|
+  config.asset_source = :<%= asset %>
+
+  ### Popular gems integration
+
+  ## == Devise ==
+  # config.authenticate_with do
+  #   warden.authenticate! scope: :user
+  # end
+  # config.current_user_method(&:current_user)
+
+  ## == CancanCan ==
+  # config.authorize_with :cancancan
+
+  ## == Pundit ==
+  # config.authorize_with :pundit
+
+  ## == PaperTrail ==
+  # config.audit_with :paper_trail, 'User', 'PaperTrail::Version' # PaperTrail >= 3.0.0
+
+  ### More at https://github.com/railsadminteam/rails_admin/wiki/Base-configuration
+
+  ## == Gravatar integration ==
+  ## To disable Gravatar integration in Navigation Bar set to false
+  # config.show_gravatar = true
+
+  config.actions do
+    dashboard                     # mandatory
+    index                         # mandatory
+    new
+    export
+    bulk_delete
+    show
+    edit
+    delete
+    show_in_app
+
+    ## With an audit adapter, you can add:
+    # history_index
+    # history_show
+  end
+end

data/rails_admin-3.3.0/lib/generators/rails_admin/templates/rails_admin.js

@@ -0,0 +1 @@
+import "rails_admin/src/rails_admin/base";

data/rails_admin-3.3.0/lib/generators/rails_admin/templates/rails_admin.scss.erb

@@ -0,0 +1 @@
+<%= @fa_font_path ? %{$fa-font-path: "#{@fa_font_path}";\n} : '' %>@import "rails_admin/src/rails_admin/styles/base";

data/rails_admin-3.3.0/lib/generators/rails_admin/templates/rails_admin.vite.js

@@ -0,0 +1,2 @@
+import "~/stylesheets/rails_admin.scss";
+import "rails_admin/src/rails_admin/base";

data/rails_admin-3.3.0/lib/generators/rails_admin/templates/rails_admin.webpacker.js

@@ -0,0 +1,2 @@
+import "rails_admin/src/rails_admin/base";
+import "../stylesheets/rails_admin.scss";

data/rails_admin-3.3.0/lib/generators/rails_admin/utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Generators
+    module Utils
+      module InstanceMethods
+        def display(output, color = :green)
+          say("           -  #{output}", color)
+        end
+
+        def ask_for(wording, default_value = nil, override_if_present_value = nil)
+          if override_if_present_value.present?
+            display("Using [#{override_if_present_value}] for question '#{wording}'") && override_if_present_value
+          else
+            ask("           ?  #{wording} Press <enter> for [#{default_value}] >", :yellow).presence || default_value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'rails_admin/support/datetime'
+
+module RailsAdmin
+  class AbstractModel
+    cattr_accessor :all
+    attr_reader :adapter, :model_name
+
+    class << self
+      def reset
+        @@all = nil
+      end
+
+      def all(adapter = nil)
+        @@all ||= Config.models_pool.collect { |m| new(m) }.compact
+        adapter ? @@all.select { |m| m.adapter == adapter } : @@all
+      end
+
+      alias_method :old_new, :new
+      def new(m)
+        m = m.constantize unless m.is_a?(Class)
+        (am = old_new(m)).model && am.adapter ? am : nil
+      rescue *([LoadError, NameError] + (defined?(ActiveRecord) ? ['ActiveRecord::NoDatabaseError'.constantize, 'ActiveRecord::ConnectionNotEstablished'.constantize] : []))
+        puts "[RailsAdmin] Could not load model #{m}, assuming model is non existing. (#{$ERROR_INFO})" unless Rails.env.test?
+        nil
+      end
+
+      @@polymorphic_parents = {}
+
+      def polymorphic_parents(adapter, model_name, name)
+        @@polymorphic_parents[adapter.to_sym] ||= {}.tap do |hash|
+          all(adapter).each do |am|
+            am.associations.select(&:as).each do |association|
+              (hash[[association.klass.to_s.underscore, association.as].join('_').to_sym] ||= []) << am.model
+            end
+          end
+        end
+        @@polymorphic_parents[adapter.to_sym][[model_name.to_s.underscore, name].join('_').to_sym]
+      end
+
+      # For testing
+      def reset_polymorphic_parents
+        @@polymorphic_parents = {}
+      end
+    end
+
+    def initialize(model_or_model_name)
+      @model_name = model_or_model_name.to_s
+      ancestors = model.ancestors.collect(&:to_s)
+      if ancestors.include?('ActiveRecord::Base') && !model.abstract_class? && model.table_exists?
+        initialize_active_record
+      elsif ancestors.include?('Mongoid::Document')
+        initialize_mongoid
+      end
+    end
+
+    # do not store a reference to the model, does not play well with ActiveReload/Rails3.2
+    def model
+      @model_name.constantize
+    end
+
+    def quoted_table_name
+      table_name
+    end
+
+    def quote_column_name(name)
+      name
+    end
+
+    def to_s
+      model.to_s
+    end
+
+    def config
+      Config.model self
+    end
+
+    def to_param
+      @model_name.split('::').collect(&:underscore).join('~')
+    end
+
+    def param_key
+      @model_name.split('::').collect(&:underscore).join('_')
+    end
+
+    def pretty_name
+      model.model_name.human
+    end
+
+    def where(conditions)
+      model.where(conditions)
+    end
+
+    def each_associated_children(object)
+      associations.each do |association|
+        case association.type
+        when :has_one
+          child = object.send(association.name)
+          yield(association, [child]) if child
+        when :has_many
+          children = object.send(association.name)
+          yield(association, Array.new(children))
+        end
+      end
+    end
+
+    def format_id(id)
+      id
+    end
+
+    def parse_id(id)
+      id
+    end
+
+  private
+
+    def initialize_active_record
+      @adapter = :active_record
+      require 'rails_admin/adapters/active_record'
+      extend Adapters::ActiveRecord
+    end
+
+    def initialize_mongoid
+      @adapter = :mongoid
+      require 'rails_admin/adapters/mongoid'
+      extend Adapters::Mongoid
+    end
+
+    def parse_field_value(field, value)
+      value.is_a?(Array) ? value.map { |v| field.parse_value(v) } : field.parse_value(value)
+    end
+
+    class StatementBuilder
+      def initialize(column, type, value, operator)
+        @column = column
+        @type = type
+        @value = value
+        @operator = operator
+      end
+
+      def to_statement
+        return if [@operator, @value].any? { |v| v == '_discard' }
+
+        unary_operators[@operator] || unary_operators[@value] ||
+          build_statement_for_type_generic
+      end
+
+    protected
+
+      def get_filtering_duration
+        FilteringDuration.new(@operator, @value).get_duration
+      end
+
+      def build_statement_for_type_generic
+        build_statement_for_type || begin
+          case @type
+          when :date
+            build_statement_for_date
+          when :datetime, :timestamp, :time
+            build_statement_for_datetime_or_timestamp
+          end
+        end
+      end
+
+      def build_statement_for_type
+        raise 'You must override build_statement_for_type in your StatementBuilder'
+      end
+
+      def build_statement_for_integer_decimal_or_float
+        case @value
+        when Array
+          val, range_begin, range_end = *@value.collect do |v|
+            next unless v.to_i.to_s == v || v.to_f.to_s == v
+
+            @type == :integer ? v.to_i : v.to_f
+          end
+          case @operator
+          when 'between'
+            range_filter(range_begin, range_end)
+          else
+            column_for_value(val) if val
+          end
+        else
+          if @value.to_i.to_s == @value || @value.to_f.to_s == @value
+            @type == :integer ? column_for_value(@value.to_i) : column_for_value(@value.to_f)
+          end
+        end
+      end
+
+      def build_statement_for_date
+        start_date, end_date = get_filtering_duration
+        if start_date
+          start_date = begin
+            start_date.to_date
+          rescue StandardError
+            nil
+          end
+        end
+        if end_date
+          end_date = begin
+            end_date.to_date
+          rescue StandardError
+            nil
+          end
+        end
+        range_filter(start_date, end_date)
+      end
+
+      def build_statement_for_datetime_or_timestamp
+        start_date, end_date = get_filtering_duration
+        start_date = start_date.beginning_of_day if start_date.is_a?(Date)
+        end_date = end_date.end_of_day if end_date.is_a?(Date)
+        range_filter(start_date, end_date)
+      end
+
+      def unary_operators
+        raise 'You must override unary_operators in your StatementBuilder'
+      end
+
+      def range_filter(_min, _max)
+        raise 'You must override range_filter in your StatementBuilder'
+      end
+
+      class FilteringDuration
+        def initialize(operator, value)
+          @value = value
+          @operator = operator
+        end
+
+        def get_duration
+          case @operator
+          when 'between'   then between
+          when 'today'     then today
+          when 'yesterday' then yesterday
+          when 'this_week' then this_week
+          when 'last_week' then last_week
+          else default
+          end
+        end
+
+        def today
+          [Date.today, Date.today]
+        end
+
+        def yesterday
+          [Date.yesterday, Date.yesterday]
+        end
+
+        def this_week
+          [Date.today.beginning_of_week, Date.today.end_of_week]
+        end
+
+        def last_week
+          [1.week.ago.to_date.beginning_of_week,
+           1.week.ago.to_date.end_of_week]
+        end
+
+        def between
+          [@value[1], @value[2]]
+        end
+
+        def default
+          [default_date, default_date]
+        end
+
+      private
+
+        def default_date
+          Array.wrap(@value).first
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/active_record/association.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class Association
+        attr_reader :association, :model
+
+        def initialize(association, model)
+          @association = association
+          @model = model
+        end
+
+        def name
+          association.name.to_sym
+        end
+
+        def pretty_name
+          name.to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          association.macro
+        end
+
+        def field_type
+          if polymorphic?
+            :polymorphic_association
+          else
+            :"#{association.macro}_association"
+          end
+        end
+
+        def klass
+          if options[:polymorphic]
+            polymorphic_parents(:active_record, association.active_record.name.to_s, name) || []
+          else
+            association.klass
+          end
+        end
+
+        def primary_key
+          return nil if polymorphic?
+
+          value =
+            case type
+            when :has_one
+              association.klass.primary_key
+            else
+              association.association_primary_key
+            end
+
+          if value.is_a? Array
+            :id
+          else
+            value.to_sym
+          end
+        end
+
+        def foreign_key
+          if association.options[:query_constraints].present?
+            association.options[:query_constraints].map(&:to_sym)
+          elsif association.foreign_key.is_a?(Array)
+            association.foreign_key.map(&:to_sym)
+          else
+            association.foreign_key.to_sym
+          end
+        end
+
+        def foreign_key_nullable?
+          return true if foreign_key.nil? || type != :has_many
+
+          (column = klass.columns_hash[foreign_key.to_s]).nil? || column.null
+        end
+
+        def foreign_type
+          options[:foreign_type].try(:to_sym) || :"#{name}_type" if options[:polymorphic]
+        end
+
+        def foreign_inverse_of
+          nil
+        end
+
+        def key_accessor
+          case type
+          when :has_many, :has_and_belongs_to_many
+            :"#{name.to_s.singularize}_ids"
+          when :has_one
+            :"#{name}_id"
+          else
+            if foreign_key.is_a?(Array)
+              :"#{name}_id"
+            else
+              foreign_key
+            end
+          end
+        end
+
+        def as
+          options[:as].try :to_sym
+        end
+
+        def polymorphic?
+          options[:polymorphic] || false
+        end
+
+        def inverse_of
+          options[:inverse_of].try :to_sym
+        end
+
+        def read_only?
+          (klass.all.instance_exec(&scope).readonly_value if scope.is_a?(Proc) && scope.arity == 0) ||
+            association.nested? ||
+            false
+        end
+
+        def nested_options
+          model.nested_attributes_options.try { |o| o[name.to_sym] }
+        end
+
+        def association?
+          true
+        end
+
+        delegate :options, :scope, to: :association, prefix: false
+        delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/active_record/object_extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      module ObjectExtension
+        def assign_attributes(attributes)
+          super if attributes
+        end
+      end
+    end
+  end
+end