mini-max-mod 0.0.1

data/administrate-1.0.0/app/controllers/administrate/application_controller.rb

@@ -0,0 +1,279 @@
+module Administrate
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    def index
+      authorize_resource(resource_class)
+      search_term = params[:search].to_s.strip
+      resources = filter_resources(scoped_resource, search_term: search_term)
+      resources = apply_collection_includes(resources)
+      resources = order.apply(resources)
+      resources = paginate_resources(resources)
+      page = Administrate::Page::Collection.new(dashboard, order: order)
+      filters = Administrate::Search.new(scoped_resource, dashboard, search_term).valid_filters
+
+      render locals: {
+        resources: resources,
+        search_term: search_term,
+        page: page,
+        show_search_bar: show_search_bar?,
+        filters: filters
+      }
+    end
+
+    def show
+      render locals: {
+        page: Administrate::Page::Show.new(dashboard, requested_resource)
+      }
+    end
+
+    def new
+      resource = new_resource
+      authorize_resource(resource)
+      render locals: {
+        page: Administrate::Page::Form.new(dashboard, resource)
+      }
+    end
+
+    def edit
+      render locals: {
+        page: Administrate::Page::Form.new(dashboard, requested_resource)
+      }
+    end
+
+    def create
+      resource = new_resource(resource_params)
+      authorize_resource(resource)
+
+      if resource.save
+        yield(resource) if block_given?
+        redirect_to(
+          after_resource_created_path(resource),
+          notice: translate_with_resource("create.success")
+        )
+      else
+        render :new, locals: {
+          page: Administrate::Page::Form.new(dashboard, resource)
+        }, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if requested_resource.update(resource_params)
+        redirect_to(
+          after_resource_updated_path(requested_resource),
+          notice: translate_with_resource("update.success"),
+          status: :see_other
+        )
+      else
+        render :edit, locals: {
+          page: Administrate::Page::Form.new(dashboard, requested_resource)
+        }, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      if requested_resource.destroy
+        flash[:notice] = translate_with_resource("destroy.success")
+      else
+        flash[:error] = requested_resource.errors.full_messages.join("<br/>")
+      end
+      redirect_to after_resource_destroyed_path(requested_resource), status: :see_other
+    end
+
+    private
+
+    def filter_resources(resources, search_term:)
+      Administrate::Search.new(
+        resources,
+        dashboard,
+        search_term
+      ).run
+    end
+
+    def after_resource_destroyed_path(_requested_resource)
+      {action: :index}
+    end
+
+    def after_resource_created_path(requested_resource)
+      [namespace, requested_resource]
+    end
+
+    def after_resource_updated_path(requested_resource)
+      [namespace, requested_resource]
+    end
+
+    helper_method :nav_link_state
+    def nav_link_state(resource)
+      underscore_resource = resource.to_s.split("/").join("__")
+      (resource_name.to_s.pluralize == underscore_resource) ? :active : :inactive
+    end
+
+    # Whether the named action route exists for the resource class.
+    #
+    # @param resource [Class, String, Symbol] A class of resources, or the name
+    #   of a class of resources.
+    # @param action_name [String, Symbol] The name of an action that might be
+    #   possible to perform on a resource or resource class.
+    # @return [Boolean] `true` if a route exists for the resource class and the
+    #   action. `false` otherwise.
+    def existing_action?(resource, action_name)
+      routes.include?([resource.to_s.underscore.pluralize, action_name.to_s])
+    end
+    helper_method :existing_action?
+
+    def routes
+      @routes ||= Namespace.new(namespace).routes.to_set
+    end
+
+    def records_per_page
+      params[:per_page] || 20
+    end
+
+    def order
+      @order ||= Administrate::Order.new(
+        sorting_attribute,
+        sorting_direction,
+        sorting_column: sorting_column(
+          dashboard_attribute(sorting_attribute)
+        )
+      )
+    end
+
+    def sorting_column(dashboard_attribute)
+      return unless dashboard_attribute.try(:options)
+
+      dashboard_attribute.options.fetch(:sorting_column) {
+        dashboard_attribute.options.fetch(:order, nil)
+      }
+    end
+
+    def dashboard_attribute(attribute)
+      dashboard.attribute_types[attribute.to_sym] if attribute
+    end
+
+    def sorting_attribute
+      sorting_params.fetch(:order) { default_sorting_attribute }
+    end
+
+    def default_sorting_attribute
+      nil
+    end
+
+    def sorting_direction
+      sorting_params.fetch(:direction) { default_sorting_direction }
+    end
+
+    def default_sorting_direction
+      nil
+    end
+
+    def sorting_params
+      Hash.try_convert(request.query_parameters[resource_name]) || {}
+    end
+
+    def dashboard
+      @dashboard ||= dashboard_class.new
+    end
+
+    def requested_resource
+      @requested_resource ||= find_resource(params[:id]).tap do |resource|
+        authorize_resource(resource)
+      end
+    end
+
+    def find_resource(param)
+      scoped_resource.find(param)
+    end
+
+    def scoped_resource
+      resource_class.default_scoped
+    end
+
+    def apply_collection_includes(relation)
+      resource_includes = dashboard.collection_includes
+      return relation if resource_includes.empty?
+      relation.includes(*resource_includes)
+    end
+
+    def resource_params
+      params.require(resource_class.model_name.param_key)
+        .permit(dashboard.permitted_attributes(action_name))
+        .transform_values { |v| read_param_value(v) }
+    end
+
+    def read_param_value(data)
+      if data.is_a?(ActionController::Parameters) && data[:type]
+        if data[:type] == Administrate::Field::Polymorphic.to_s
+          GlobalID::Locator.locate(data[:value])
+        else
+          raise "Unrecognised param data: #{data.inspect}"
+        end
+      elsif data.is_a?(ActionController::Parameters)
+        data.transform_values { |v| read_param_value(v) }
+      elsif data.is_a?(String) && data.blank?
+        nil
+      else
+        data
+      end
+    end
+
+    delegate :dashboard_class, :resource_class, :resource_name, :namespace,
+      to: :resource_resolver
+    helper_method :namespace
+    helper_method :resource_name
+    helper_method :resource_class
+
+    def resource_resolver
+      @resource_resolver ||=
+        Administrate::ResourceResolver.new(controller_path)
+    end
+
+    def translate_with_resource(key)
+      t(
+        "administrate.controller.#{key}",
+        resource: resource_resolver.resource_title
+      )
+    end
+
+    def show_search_bar?
+      dashboard.attribute_types_for(
+        dashboard.all_attributes
+      ).any? { |_name, attribute| attribute.searchable? }
+    end
+
+    # Whether the current user is authorized to perform the named action on the
+    # resource.
+    #
+    # @param _resource [ActiveRecord::Base, Class, String, Symbol] The
+    #   temptative target of the action, or the name of its class.
+    # @param _action_name [String, Symbol] The name of an action that might be
+    #   possible to perform on a resource or resource class.
+    # @return [Boolean] `true` if the current user is authorized to perform the
+    #   action on the resource. `false` otherwise.
+    def authorized_action?(_resource, _action_name)
+      true
+    end
+    helper_method :authorized_action?
+
+    def new_resource(params = {})
+      resource_class.new(params)
+    end
+    helper_method :new_resource
+
+    def authorize_resource(resource)
+      if authorized_action?(resource, action_name)
+        resource
+      else
+        raise Administrate::NotAuthorizedError.new(
+          action: action_name,
+          resource: resource
+        )
+      end
+    end
+
+    def paginate_resources(resources)
+      resources.page(params[:_page]).per(records_per_page)
+    end
+  end
+end

data/administrate-1.0.0/app/controllers/concerns/administrate/punditize.rb

@@ -0,0 +1,52 @@
+module Administrate
+  module Punditize
+    if Object.const_defined?(:Pundit)
+      extend ActiveSupport::Concern
+
+      if Pundit.const_defined?(:Authorization)
+        include Pundit::Authorization
+      else
+        include Pundit
+      end
+
+      private
+
+      def policy_namespace
+        []
+      end
+
+      def scoped_resource
+        namespaced_scope = policy_namespace + [super]
+        policy_scope!(pundit_user, namespaced_scope)
+      end
+
+      def authorize_resource(resource)
+        namespaced_resource = policy_namespace + [resource]
+        authorize namespaced_resource
+      end
+
+      def authorized_action?(resource, action)
+        namespaced_resource = policy_namespace + [resource]
+        policy = Pundit.policy!(pundit_user, namespaced_resource)
+        policy.send(:"#{action}?")
+      end
+
+      def policy_scope!(user, scope)
+        policy_scope_class = Pundit::PolicyFinder.new(scope).scope!
+
+        begin
+          policy_scope = policy_scope_class.new(user, pundit_model(scope))
+        rescue ArgumentError
+          raise(Pundit::InvalidConstructorError,
+            "Invalid #<#{policy_scope_class}> constructor is called")
+        end
+
+        policy_scope.resolve
+      end
+
+      def pundit_model(record)
+        record.is_a?(Array) ? record.last : record
+      end
+    end
+  end
+end

data/administrate-1.0.0/app/helpers/administrate/application_helper.rb

@@ -0,0 +1,101 @@
+module Administrate
+  module ApplicationHelper
+    PLURAL_MANY_COUNT = 2.1
+    SINGULAR_COUNT = 1
+
+    def application_title
+      Rails.application.class.module_parent_name.titlecase
+    end
+
+    def render_field(field, locals = {})
+      locals[:field] = field
+      if (prefix = find_partial_prefix(field))
+        render locals: locals, partial: "#{prefix}/#{field.page}"
+      end
+    end
+
+    def find_partial_prefix(field)
+      field.partial_prefixes.detect do |prefix|
+        lookup_context.template_exists?(field.page, [prefix], true)
+      end
+    end
+
+    def requireness(field)
+      field.required? ? "required" : "optional"
+    end
+
+    def dashboard_from_resource(resource_name)
+      "#{resource_name.to_s.singularize}_dashboard".classify.constantize
+    end
+
+    def model_from_resource(resource_name)
+      dashboard = dashboard_from_resource(resource_name)
+      dashboard.try(:model) || resource_name.to_sym
+    end
+
+    # Unification of
+    # {Administrate::ApplicationController#existing_action? existing_action?}
+    # and
+    # {Administrate::ApplicationController#authorized_action?
+    # authorized_action?}
+    #
+    # @param target [ActiveRecord::Base, Class, Symbol, String] A resource,
+    #   a class of resources, or the name of a class of resources.
+    # @param action_name [String, Symbol] The name of an action that might be
+    #   possible to perform on a resource or resource class.
+    # @return [Boolean] Whether the action both (a) exists for the record class,
+    #   and (b) the current user is authorized to perform it on the record
+    #   instance or class.
+    def accessible_action?(target, action_name)
+      target = target.to_sym if target.is_a?(String)
+      target_class_or_class_name =
+        target.is_a?(ActiveRecord::Base) ? target.class : target
+
+      existing_action?(target_class_or_class_name, action_name) &&
+        authorized_action?(target, action_name)
+    end
+
+    def display_resource_name(resource_name, opts = {})
+      dashboard_from_resource(resource_name).resource_name(
+        count: opts[:singular] ? SINGULAR_COUNT : PLURAL_MANY_COUNT,
+        default: default_resource_name(resource_name, opts)
+      )
+    end
+
+    def sort_order(order)
+      case order
+      when "asc" then "ascending"
+      when "desc" then "descending"
+      else "none"
+      end
+    end
+
+    def resource_index_route(resource_name)
+      url_for(
+        action: "index",
+        controller: "/#{namespace}/#{resource_name}"
+      )
+    end
+
+    def sanitized_order_params(page, current_field_name)
+      collection_names = page.item_associations + [current_field_name]
+      association_params = collection_names.map do |assoc_name|
+        {assoc_name => %i[order direction page per_page]}
+      end
+      params.permit(:search, :id, :_page, :per_page, association_params)
+    end
+
+    def clear_search_params
+      params.except(:search, :_page).permit(
+        :per_page, resource_name => %i[order direction]
+      )
+    end
+
+    private
+
+    def default_resource_name(name, opts = {})
+      resource_name = (opts[:singular] ? name.to_s : name.to_s.pluralize)
+      resource_name.tr("/", "_").titleize
+    end
+  end
+end

data/administrate-1.0.0/app/views/administrate/application/_collection.html.erb

@@ -0,0 +1,102 @@
+<%#
+# Collection
+
+This partial is used on the `index` and `show` pages
+to display a collection of resources in an HTML table.
+
+## Local variables:
+
+- `collection_presenter`:
+  An instance of [Administrate::Page::Collection][1].
+  The table presenter uses `ResourceDashboard::COLLECTION_ATTRIBUTES` to determine
+  the columns displayed in the table
+- `resources`:
+  An ActiveModel::Relation collection of resources to be displayed in the table.
+  By default, the number of resources is limited by pagination
+  or by a hard limit to prevent excessive page load times
+
+[1]: http://www.rubydoc.info/gems/administrate/Administrate/Page/Collection
+%>
+
+<table aria-labelledby="<%= table_title %>" data-controller="table" data-action="click->table#visitDataUrl keydown->table#visitDataUrl">
+  <thead>
+    <tr>
+      <% collection_presenter.attribute_types.each do |attr_name, attr_type| %>
+        <th class="cell-label
+          cell-label--<%= attr_type.html_class %>
+          cell-label--<%= collection_presenter.ordered_html_class(attr_name) %>
+          cell-label--<%= "#{collection_presenter.resource_name}_#{attr_name}" %>"
+          scope="col"
+          <% if attr_type.sortable? %>
+            aria-sort="<%= sort_order(collection_presenter.ordered_html_class(attr_name)) %>"
+          <% end %>
+        >
+          <% if attr_type.sortable? %>
+            <%= link_to(params: sanitized_order_params(page, collection_field_name).merge(
+              collection_presenter.order_params_for(attr_name, key: collection_field_name)
+            )) do %>
+              <%= t(
+                "helpers.label.#{collection_presenter.resource_name}.#{attr_name}",
+                default: resource_class.human_attribute_name(attr_name).titleize,
+              ) %>
+              <% if collection_presenter.ordered_by?(attr_name) %>
+                <span class="cell-label__sort-indicator cell-label__sort-indicator--<%= collection_presenter.ordered_html_class(attr_name) %>">
+                  <svg aria-hidden="true">
+                    <use xlink:href="#icon-up-caret" />
+                  </svg>
+                </span>
+              <% end %>
+            <% end %>
+          <% else %>
+            <%= t(
+              "helpers.label.#{collection_presenter.resource_name}.#{attr_name}",
+              default: resource_class.human_attribute_name(attr_name).titleize,
+            ) %>
+          <% end %>
+        </th>
+      <% end %>
+      <%= render(
+        "collection_header_actions",
+        collection_presenter: collection_presenter,
+        page: page,
+        resources: resources,
+        table_title: "page-title"
+      ) %>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% resources.each do |resource| %>
+      <tr class="js-table-row"
+          <% if accessible_action?(resource, :show) %>
+            <%= %(tabindex=0 data-url=#{polymorphic_path([namespace, resource])}) %>
+          <% end %>
+          >
+        <% collection_presenter.attributes_for(resource).each do |attribute| %>
+          <td class="cell-data cell-data--<%= attribute.html_class %>">
+            <% if accessible_action?(resource, :show) -%>
+              <a href="<%= polymorphic_path([namespace, resource]) -%>"
+                 tabindex="-1"
+                 class="action-show"
+                 >
+                <%= render_field attribute %>
+              </a>
+            <% else %>
+              <%= render_field attribute %>
+            <% end -%>
+          </td>
+        <% end %>
+
+        <%= render(
+          "collection_item_actions",
+          collection_presenter: collection_presenter,
+          collection_field_name: collection_field_name,
+          page: page,
+          namespace: namespace,
+          resource: resource,
+          table_title: "page-title"
+        ) %>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/administrate-1.0.0/app/views/administrate/application/_collection_header_actions.html.erb

@@ -0,0 +1,4 @@
+<% [existing_action?(collection_presenter.resource_name, :edit),
+    existing_action?(collection_presenter.resource_name, :destroy)].count(true).times do %>
+  <th scope="col" class="cell-label--action-button"></th>
+<% end %>

data/administrate-1.0.0/app/views/administrate/application/_collection_item_actions.html.erb

@@ -0,0 +1,17 @@
+<% if existing_action?(collection_presenter.resource_name, :edit) %>
+  <td class="cell-label--action-button"><%= link_to(
+    t("administrate.actions.edit"),
+    [:edit, namespace, resource],
+    class: "action-edit",
+  ) if accessible_action?(resource, :edit) %></td>
+<% end %>
+
+<% if existing_action?(collection_presenter.resource_name, :destroy) %>
+  <td class="cell-label--action-button"><%= button_to(
+    t("administrate.actions.destroy"),
+    [namespace, resource],
+    class: "link link--danger",
+    method: :delete,
+    data: { turbo_confirm: t("administrate.actions.confirm") }
+  ) if accessible_action?(resource, :destroy) %></td>
+<% end %>

data/administrate-1.0.0/app/views/administrate/application/_flashes.html.erb

@@ -0,0 +1,21 @@
+<%#
+# Flash Partial
+
+This partial renders flash messages on every page.
+
+## Relevant Helpers:
+
+- `flash`:
+  Returns a hash,
+  where the keys are the type of flash (alert, error, notice, etc)
+  and the values are the message to be displayed.
+%>
+
+<% if flash.any? %>
+  <div class="flashes">
+    <% flash.each do |key, value| -%>
+      <% next unless value.respond_to?(:html_safe) %>
+      <div class="flash flash-<%= key %>"><%= value.html_safe %></div>
+    <% end -%>
+  </div>
+<% end %>

data/administrate-1.0.0/app/views/administrate/application/_form.html.erb

@@ -0,0 +1,60 @@
+<%#
+# Form Partial
+
+This partial is rendered on a resource's `new` and `edit` pages,
+and renders all form fields for a resource's editable attributes.
+
+## Local variables:
+
+- `page`:
+  An instance of [Administrate::Page::Form][1].
+  Contains helper methods to display a form,
+  and knows which attributes should be displayed in the resource's form.
+
+[1]: http://www.rubydoc.info/gems/administrate/Administrate/Page/Form
+%>
+
+<%= form_with(model: page.resource, url: [namespace, page.resource], scope: page.resource, local: true, class: "form") do |f| %>
+  <% if page.resource.errors.any? %>
+    <div id="error_explanation">
+      <h2>
+        <%= t(
+          "administrate.form.errors",
+          pluralized_errors: pluralize(page.resource.errors.count, t("administrate.form.error")),
+          resource_name: display_resource_name(page.resource_name, singular: true)
+        ) %>
+      </h2>
+
+      <ul>
+        <% page.resource.errors.full_messages.each do |message| %>
+          <li class="flash-error"><%= message %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <% page.attributes(controller.action_name).each do |title, attributes| -%>
+    <fieldset class="<%= "field-unit--nested" if title.present? %>">
+      <% if title.present? %>
+        <legend><%= t "helpers.label.#{f.object_name}.#{title}", default: title %></legend>
+      <% end %>
+
+      <% attributes.each do |attribute| %>
+        <div class="field-unit field-unit--<%= attribute.html_class %> field-unit--<%= requireness(attribute) %>">
+          <%= render_field attribute, f: f %>
+
+          <% hint_key = "administrate.field_hints.#{page.resource_name}.#{attribute.name}" %>
+          <% if I18n.exists?(hint_key) -%>
+            <div class="field-unit__hint">
+              <%= I18n.t(hint_key) %>
+            </div>
+          <% end -%>
+        </div>
+      <% end %>
+    </fieldset>
+  <% end -%>
+
+  <div class="form-actions">
+    <%= f.submit %>
+  </div>
+<% end %>

data/administrate-1.0.0/app/views/administrate/application/_icons.html.erb

@@ -0,0 +1,21 @@
+<svg hidden xmlns="http://www.w3.org/2000/svg">
+  <symbol id="icon-cancel" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <circle cx="12" cy="12" r="10"></circle>
+    <line x1="15" y1="9" x2="9" y2="15"></line><line x1="9" y1="9" x2="15" y2="15"></line>
+  </symbol>
+
+  <symbol id="icon-eyeglass" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <circle cx="11" cy="11" r="8"></circle>
+    <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+  </symbol>
+
+  <symbol id="icon-up-caret" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <polyline points="18 15 12 9 6 15"></polyline>
+  </symbol>
+
+  <symbol id="icon-question-mark" viewBox="0 0 24 24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <circle cx="12" cy="12" r="10"></circle>
+    <path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"></path>
+    <line x1="12" y1="17" x2="12.01" y2="17"></line>
+  <symbol>
+</svg>