mini-max-mod 0.0.1

data/administrate-1.0.0/lib/generators/administrate/dashboard/dashboard_generator.rb

@@ -0,0 +1,168 @@
+require "rails/generators/named_base"
+
+module Administrate
+  module Generators
+    class DashboardGenerator < Rails::Generators::NamedBase
+      ATTRIBUTE_TYPE_MAPPING = {
+        boolean: "Field::Boolean",
+        date: "Field::Date",
+        datetime: "Field::DateTime",
+        enum: "Field::Select",
+        float: "Field::Number",
+        integer: "Field::Number",
+        time: "Field::Time",
+        text: "Field::Text",
+        string: "Field::String",
+        uuid: "Field::String"
+      }
+
+      ATTRIBUTE_OPTIONS_MAPPING = {
+        # procs must be defined in one line!
+        enum: {searchable: false,
+               collection: ->(field) { field.resource.class.send(field.attribute.to_s.pluralize).keys }},
+        float: {decimals: 2}
+      }
+
+      DEFAULT_FIELD_TYPE = "Field::String.with_options(searchable: false)"
+      COLLECTION_ATTRIBUTE_LIMIT = 4
+      READ_ONLY_ATTRIBUTES = %w[id created_at updated_at]
+
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards live",
+        default: "admin"
+      )
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_dashboard_definition
+        scope = regular_class_path.join("/")
+
+        template(
+          "dashboard.rb.erb",
+          Rails.root.join("app/dashboards/#{scope}/#{file_name}_dashboard.rb")
+        )
+      end
+
+      def create_resource_controller
+        scope = "#{namespace}/#{regular_class_path.join("/")}"
+        destination = Rails.root.join(
+          "app/controllers/#{scope}/#{file_name.pluralize}_controller.rb"
+        )
+
+        template("controller.rb.erb", destination)
+      end
+
+      private
+
+      def namespace
+        options[:namespace]
+      end
+
+      def attributes
+        attrs = (
+          klass.reflections.keys +
+          klass.columns.map(&:name) -
+          redundant_attributes
+        )
+
+        primary_key = attrs.delete(klass.primary_key)
+        created_at = attrs.delete("created_at")
+        updated_at = attrs.delete("updated_at")
+
+        [
+          primary_key,
+          *attrs.sort,
+          created_at,
+          updated_at
+        ].compact
+      end
+
+      def form_attributes
+        attributes - READ_ONLY_ATTRIBUTES
+      end
+
+      def redundant_attributes
+        klass.reflections.keys.flat_map do |relationship|
+          redundant_attributes_for(relationship)
+        end.compact
+      end
+
+      def redundant_attributes_for(relationship)
+        case association_type(relationship)
+        when "Field::Polymorphic"
+          [relationship + "_id", relationship + "_type"]
+        when "Field::BelongsTo"
+          relationship + "_id"
+        end
+      end
+
+      def field_type(attribute)
+        type = column_type_for_attribute(attribute.to_s)
+
+        if type
+          ATTRIBUTE_TYPE_MAPPING.fetch(type, DEFAULT_FIELD_TYPE) +
+            options_string(ATTRIBUTE_OPTIONS_MAPPING.fetch(type, {}))
+        else
+          association_type(attribute)
+        end
+      end
+
+      def column_type_for_attribute(attr)
+        if enum_column?(attr)
+          :enum
+        else
+          column_types(attr)
+        end
+      end
+
+      def enum_column?(attr)
+        klass.respond_to?(:defined_enums) &&
+          klass.defined_enums.key?(attr)
+      end
+
+      def column_types(attr)
+        klass.columns.find { |column| column.name == attr }.try(:type)
+      end
+
+      def association_type(attribute)
+        relationship = klass.reflections[attribute.to_s]
+        if relationship.has_one?
+          "Field::HasOne"
+        elsif relationship.collection?
+          "Field::HasMany"
+        elsif relationship.polymorphic?
+          "Field::Polymorphic"
+        else
+          "Field::BelongsTo"
+        end
+      end
+
+      def klass
+        @klass ||= Object.const_get(class_name)
+      end
+
+      def options_string(options)
+        if options.any?
+          ".with_options(#{inspect_hash_as_ruby(options)})"
+        else
+          ""
+        end
+      end
+
+      def inspect_hash_as_ruby(hash)
+        hash.map do |key, value|
+          v_str = value.respond_to?(:call) ? proc_string(value) : value.inspect
+          "#{key}: #{v_str}"
+        end.join(", ")
+      end
+
+      def proc_string(value)
+        source = value.source_location
+        proc_string = IO.readlines(source.first)[source.second - 1]
+        proc_string[/->[^}]*} | (lambda|proc).*end/x]
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/dashboard/templates/controller.rb.erb

@@ -0,0 +1,46 @@
+module <%= namespace.to_s.camelize %>
+  class <%= class_name.pluralize %>Controller < <%= namespace.to_s.camelize %>::ApplicationController
+    # Overwrite any of the RESTful controller actions to implement custom behavior
+    # For example, you may want to send an email after a foo is updated.
+    #
+    # def update
+    #   super
+    #   send_foo_updated_email(requested_resource)
+    # end
+
+    # Override this method to specify custom lookup behavior.
+    # This will be used to set the resource for the `show`, `edit`, and `update`
+    # actions.
+    #
+    # def find_resource(param)
+    #   Foo.find_by!(slug: param)
+    # end
+
+    # The result of this lookup will be available as `requested_resource`
+
+    # Override this if you have certain roles that require a subset
+    # this will be used to set the records shown on the `index` action.
+    #
+    # def scoped_resource
+    #   if current_user.super_admin?
+    #     resource_class
+    #   else
+    #     resource_class.with_less_stuff
+    #   end
+    # end
+
+    # Override `resource_params` if you want to transform the submitted
+    # data before it's persisted. For example, the following would turn all
+    # empty values into nil values. It uses other APIs such as `resource_class`
+    # and `dashboard`:
+    #
+    # def resource_params
+    #   params.require(resource_class.model_name.param_key).
+    #     permit(dashboard.permitted_attributes(action_name)).
+    #     transform_values { |value| value == "" ? nil : value }
+    # end
+
+    # See https://administrate-demo.herokuapp.com/customizing_controller_actions
+    # for more information
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/dashboard/templates/dashboard.rb.erb

@@ -0,0 +1,68 @@
+require "administrate/base_dashboard"
+
+class <%= class_name %>Dashboard < Administrate::BaseDashboard
+  # ATTRIBUTE_TYPES
+  # a hash that describes the type of each of the model's fields.
+  #
+  # Each different type represents an Administrate::Field object,
+  # which determines how the attribute is displayed
+  # on pages throughout the dashboard.
+  ATTRIBUTE_TYPES = {
+<% attributes.each do |attr| -%>
+    <%= attr %>: <%= field_type(attr) %>,
+<% end -%>
+  }.freeze
+
+  # COLLECTION_ATTRIBUTES
+  # an array of attributes that will be displayed on the model's index page.
+  #
+  # By default, it's limited to four items to reduce clutter on index pages.
+  # Feel free to add, remove, or rearrange items.
+  COLLECTION_ATTRIBUTES = %i[
+<%=
+  attributes.first(COLLECTION_ATTRIBUTE_LIMIT).map do |attr|
+    "    #{attr}"
+  end.join("\n")
+%>
+  ].freeze
+
+  # SHOW_PAGE_ATTRIBUTES
+  # an array of attributes that will be displayed on the model's show page.
+  SHOW_PAGE_ATTRIBUTES = %i[
+<%=
+  attributes.map do |attr|
+    "    #{attr}"
+  end.join("\n")
+%>
+  ].freeze
+
+  # FORM_ATTRIBUTES
+  # an array of attributes that will be displayed
+  # on the model's form (`new` and `edit`) pages.
+  FORM_ATTRIBUTES = %i[
+<%=
+  form_attributes.map do |attr|
+    "    #{attr}"
+  end.join("\n")
+%>
+  ].freeze
+
+  # COLLECTION_FILTERS
+  # a hash that defines filters that can be used while searching via the search
+  # field of the dashboard.
+  #
+  # For example to add an option to search for open resources by typing "open:"
+  # in the search field:
+  #
+  #   COLLECTION_FILTERS = {
+  #     open: ->(resources) { resources.where(open: true) }
+  #   }.freeze
+  COLLECTION_FILTERS = {}.freeze
+
+  # Overwrite this method to customize how <%= file_name.pluralize.humanize.downcase %> are displayed
+  # across all pages of the admin dashboard.
+  #
+  # def display_resource(<%= file_name %>)
+  #   "<%= class_name %> ##{<%= file_name %>.id}"
+  # end
+end

data/administrate-1.0.0/lib/generators/administrate/field/field_generator.rb

@@ -0,0 +1,31 @@
+module Administrate
+  module Generators
+    class FieldGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def template_field_object
+        template(
+          "field_object.rb.erb",
+          "app/fields/#{file_name}_field.rb"
+        )
+      end
+
+      def copy_partials
+        copy_partial(:show)
+        copy_partial(:index)
+        copy_partial(:form)
+      end
+
+      private
+
+      def copy_partial(partial_name)
+        partial = "_#{partial_name}.html.erb"
+
+        copy_file(
+          partial,
+          "app/views/fields/#{file_name}_field/#{partial}"
+        )
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/field/templates/_form.html.erb

@@ -0,0 +1,6 @@
+<div class="field-unit__label">
+  <%= f.label field.attribute %>
+</div>
+<div class="field-unit__field">
+  <%= f.text_field field.attribute %>
+</div>

data/administrate-1.0.0/lib/generators/administrate/field/templates/_index.html.erb

@@ -0,0 +1 @@
+<%= field.to_s %>

data/administrate-1.0.0/lib/generators/administrate/field/templates/_show.html.erb

@@ -0,0 +1 @@
+<%= field.to_s %>

data/administrate-1.0.0/lib/generators/administrate/field/templates/field_object.rb.erb

@@ -0,0 +1,7 @@
+require "administrate/field/base"
+
+class <%= class_name %>Field < Administrate::Field::Base
+  def to_s
+    data
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/install/install_generator.rb

@@ -0,0 +1,91 @@
+if defined?(Zeitwerk)
+  Zeitwerk::Loader.eager_load_all
+else
+  Rails.application.eager_load!
+end
+
+require "rails/generators/base"
+require "administrate/generator_helpers"
+require "administrate/namespace"
+
+module Administrate
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Administrate::GeneratorHelpers
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards will live",
+        default: "admin"
+      )
+
+      def run_routes_generator
+        if dashboard_resources.none?
+          call_generator("administrate:routes", "--namespace", namespace)
+          Rails.application.reload_routes!
+        end
+      end
+
+      def create_dashboard_controller
+        template(
+          "application_controller.rb.erb",
+          "app/controllers/#{namespace}/application_controller.rb"
+        )
+      end
+
+      def run_dashboard_generators
+        singular_dashboard_resources.each do |resource|
+          call_generator "administrate:dashboard", resource,
+            "--namespace", namespace
+        end
+      end
+
+      def model_check
+        if valid_dashboard_models.none?
+          puts "WARNING: Add models before installing Administrate."
+        end
+      end
+
+      private
+
+      def namespace
+        options[:namespace]
+      end
+
+      def singular_dashboard_resources
+        dashboard_resources.map(&:to_s).map(&:singularize)
+      end
+
+      def dashboard_resources
+        Administrate::Namespace.new(namespace).resources
+      end
+
+      def valid_dashboard_models
+        database_models - invalid_dashboard_models
+      end
+
+      def database_models
+        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+      end
+
+      def invalid_dashboard_models
+        (models_without_tables + namespaced_models + unnamed_constants).uniq
+      end
+
+      def models_without_tables
+        database_models.reject(&:table_exists?)
+      end
+
+      def namespaced_models
+        database_models.select { |model| model.to_s.include?("::") }
+      end
+
+      def unnamed_constants
+        ActiveRecord::Base.descendants.reject { |d| d.name == d.to_s }
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/install/templates/application_controller.rb.erb

@@ -0,0 +1,21 @@
+# All Administrate controllers inherit from this
+# `Administrate::ApplicationController`, making it the ideal place to put
+# authentication logic or other before_actions.
+#
+# If you want to add pagination or other controller-level concerns,
+# you're free to overwrite the RESTful controller actions.
+module <%= namespace.camelize %>
+  class ApplicationController < Administrate::ApplicationController
+    before_action :authenticate_admin
+
+    def authenticate_admin
+      # TODO Add authentication logic here.
+    end
+
+    # Override this value to specify the number of elements to display at a time
+    # on index pages. Defaults to 20.
+    # def records_per_page
+    #   params[:per_page] || 20
+    # end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/routes/routes_generator.rb

@@ -0,0 +1,96 @@
+if defined?(Zeitwerk)
+  Zeitwerk::Loader.eager_load_all
+else
+  Rails.application.eager_load!
+end
+
+require "rails/generators/base"
+require "administrate/generator_helpers"
+require "administrate/namespace"
+require "generators/administrate/test_record"
+
+module Administrate
+  module Generators
+    class RoutesGenerator < Rails::Generators::Base
+      include Administrate::GeneratorHelpers
+
+      source_root File.expand_path("../templates", __FILE__)
+      class_option(
+        :namespace,
+        type: :string,
+        desc: "Namespace where the admin dashboards live",
+        default: "admin"
+      )
+
+      def insert_dashboard_routes
+        if valid_dashboard_models.any?
+          route(dashboard_routes)
+        end
+      end
+
+      def warn_about_invalid_models
+        invalid_dashboard_models.each do |model|
+          puts "WARNING: Unable to generate a dashboard for #{model}."
+          if namespaced_models.include?(model)
+            puts "       - Administrate does not yet support namespaced models."
+          end
+          if models_without_tables.include?(model)
+            puts "       - It is not connected to a database table."
+            puts "         Make sure your database migrations are up to date."
+          end
+        end
+
+        unnamed_constants.each do |invalid_model|
+          puts "NOTICE: Skipping dynamically generated model #{invalid_model}."
+        end
+      end
+
+      private
+
+      def namespace
+        options[:namespace]
+      end
+
+      def dashboard_resources
+        valid_dashboard_models.map do |model|
+          model.to_s.pluralize.underscore
+        end
+      end
+
+      def valid_dashboard_models
+        database_models - invalid_dashboard_models
+      end
+
+      def database_models
+        ActiveRecord::Base.descendants
+          .reject(&:abstract_class?)
+          .reject { |k| k < Administrate::Generators::TestRecord }
+          .sort_by(&:to_s)
+      end
+
+      def invalid_dashboard_models
+        (models_without_tables + namespaced_models + unnamed_constants).uniq
+      end
+
+      def models_without_tables
+        database_models.reject(&:table_exists?)
+      end
+
+      def namespaced_models
+        database_models.select { |model| model.to_s.include?("::") }
+      end
+
+      def unnamed_constants
+        ActiveRecord::Base.descendants.reject { |d| d.name == d.to_s }
+      end
+
+      def dashboard_routes
+        ERB.new(File.read(routes_file_path)).result(binding)
+      end
+
+      def routes_file_path
+        File.expand_path(find_in_source_paths("routes.rb.erb"))
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/routes/templates/routes.rb.erb

@@ -0,0 +1,5 @@
+namespace :<%= namespace %> do
+<% dashboard_resources.each do |resource| %>    resources :<%= resource %>
+<%end%>
+    root to: "<%= dashboard_resources.first %>#index"
+  end

data/administrate-1.0.0/lib/generators/administrate/test_record.rb

@@ -0,0 +1,21 @@
+module Administrate
+  module Generators
+    # This class serves only to work around a strange behaviour in Rails 7
+    # with Ruby 3.
+    #
+    # After running the spec for DashboardGenerator, the fake models that
+    # it generates (eg: Foo, Shipment) linger around despite being removed
+    # explicitly. This causes RouteGenerator to take them into
+    # account and generate routes for them, which its spec doesn't expect,
+    # causing a spec failure.
+    #
+    # To avoid this, the spec for DashboardGenerator defines its fake models
+    # as children of TestRecord. Then RoutesGenerator explicitly filters
+    # child classes of TestRecord when figuring out what models exist.
+    #
+    # Discussion at https://github.com/thoughtbot/administrate/pull/2324
+    class TestRecord < ApplicationRecord
+      self.abstract_class = true
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/views/edit_generator.rb

@@ -0,0 +1,16 @@
+require "administrate/view_generator"
+
+module Administrate
+  module Generators
+    module Views
+      class EditGenerator < Administrate::ViewGenerator
+        source_root template_source_path
+
+        def copy_edit
+          copy_resource_template("edit")
+          copy_resource_template("_form")
+        end
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/views/field_generator.rb

@@ -0,0 +1,50 @@
+require "administrate/view_generator"
+
+module Administrate
+  module Generators
+    module Views
+      class FieldGenerator < Administrate::ViewGenerator
+        def self.template_source_path
+          File.expand_path(
+            "../../../../../app/views/fields/",
+            __FILE__
+          )
+        end
+
+        source_root template_source_path
+
+        def copy_partials
+          resource_path = args.first.try(:underscore)
+
+          if resource_path == "all"
+            entries = Dir.entries(self.class.template_source_path)
+            field_types = entries.reject { |name| name[0] == "." }
+
+            field_types.each do |field_type|
+              copy_field_partials(field_type)
+            end
+          else
+            copy_field_partials(resource_path)
+          end
+        end
+
+        private
+
+        def copy_field_partials(resource_path)
+          copy_field_partial(resource_path, :index)
+          copy_field_partial(resource_path, :show)
+          copy_field_partial(resource_path, :form)
+        end
+
+        def copy_field_partial(resource_path, partial_name)
+          template_file = "#{resource_path}/_#{partial_name}.html.erb"
+
+          copy_file(
+            template_file,
+            "app/views/fields/#{template_file}"
+          )
+        end
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/views/form_generator.rb

@@ -0,0 +1,15 @@
+require "administrate/view_generator"
+
+module Administrate
+  module Generators
+    module Views
+      class FormGenerator < Administrate::ViewGenerator
+        source_root template_source_path
+
+        def copy_form
+          copy_resource_template("_form")
+        end
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/views/index_generator.rb

@@ -0,0 +1,21 @@
+require "administrate/view_generator"
+
+module Administrate
+  module Generators
+    module Views
+      class IndexGenerator < Administrate::ViewGenerator
+        source_root template_source_path
+
+        def copy_template
+          copy_resource_template("index")
+          copy_resource_template("_collection")
+          copy_resource_template("_collection_header_actions")
+          copy_resource_template("_collection_item_actions")
+          copy_resource_template("_index_header")
+          copy_resource_template("_pagination")
+          copy_resource_template("_search")
+        end
+      end
+    end
+  end
+end