mini-max-mod 0.0.1

data/administrate-1.0.0/lib/administrate/base_dashboard.rb

@@ -0,0 +1,145 @@
+require "administrate/field/belongs_to"
+require "administrate/field/boolean"
+require "administrate/field/date_time"
+require "administrate/field/date"
+require "administrate/field/email"
+require "administrate/field/has_many"
+require "administrate/field/has_one"
+require "administrate/field/number"
+require "administrate/field/polymorphic"
+require "administrate/field/rich_text"
+require "administrate/field/select"
+require "administrate/field/string"
+require "administrate/field/text"
+require "administrate/field/time"
+require "administrate/field/url"
+require "administrate/field/password"
+
+module Administrate
+  class BaseDashboard
+    include Administrate
+
+    DASHBOARD_SUFFIX = "Dashboard".freeze
+
+    class << self
+      def model
+        to_s.chomp(DASHBOARD_SUFFIX).classify.constantize
+      end
+
+      def resource_name(opts)
+        model.model_name.human(opts)
+      end
+    end
+
+    def attribute_types
+      self.class::ATTRIBUTE_TYPES
+    end
+
+    def attribute_type_for(attribute_name)
+      attribute_types.fetch(attribute_name) do
+        fail attribute_not_found_message(attribute_name)
+      end
+    end
+
+    def attribute_types_for(attribute_names)
+      attribute_names.each_with_object({}) do |name, attributes|
+        attributes[name] = attribute_type_for(name)
+      end
+    end
+
+    def all_attributes
+      attribute_types.keys
+    end
+
+    def form_attributes(action = nil)
+      action =
+        case action
+        when "update" then "edit"
+        when "create" then "new"
+        else action
+        end
+      specific_form_attributes_for(action) || self.class::FORM_ATTRIBUTES
+    end
+
+    def specific_form_attributes_for(action)
+      return unless action
+
+      cname = "FORM_ATTRIBUTES_#{action.upcase}"
+
+      self.class.const_get(cname) if self.class.const_defined?(cname)
+    end
+
+    def permitted_attributes(action = nil)
+      attributes = form_attributes action
+
+      if attributes.is_a? Hash
+        attributes = attributes.values.flatten
+      end
+
+      attributes.map do |attr|
+        attribute_types[attr].permitted_attribute(
+          attr,
+          resource_class: self.class.model,
+          action: action
+        )
+      end.uniq
+    end
+
+    def show_page_attributes
+      self.class::SHOW_PAGE_ATTRIBUTES
+    end
+
+    def collection_attributes
+      if self.class::COLLECTION_ATTRIBUTES.is_a?(Hash)
+        self.class::COLLECTION_ATTRIBUTES.values.flatten
+      else
+        self.class::COLLECTION_ATTRIBUTES
+      end
+    end
+
+    def search_attributes
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable?
+      end
+    end
+
+    def display_resource(resource)
+      "#{resource.class} ##{resource.id}"
+    end
+
+    def collection_includes
+      attribute_includes(collection_attributes)
+    end
+
+    def item_associations
+      attributes = if show_page_attributes.is_a?(Hash)
+        show_page_attributes.values.flatten
+      else
+        show_page_attributes
+      end
+      attribute_associated attributes
+    end
+
+    private
+
+    def attribute_not_found_message(attr)
+      "Attribute #{attr} could not be found in #{self.class}::ATTRIBUTE_TYPES"
+    end
+
+    def attribute_includes(attributes)
+      attributes.map do |key|
+        field = attribute_type_for(key)
+
+        key if field.eager_load?
+      end.compact
+    end
+
+    def attribute_associated(attributes)
+      attributes.map do |key|
+        field = attribute_type_for(key)
+
+        key if field.associative?
+      end.compact
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/custom_dashboard.rb

@@ -0,0 +1,15 @@
+module Administrate
+  class CustomDashboard
+    include Administrate
+
+    class << self
+      def resource_name(_opts)
+        named_resource.pluralize.titleize
+      end
+
+      def resource(resource_name)
+        define_singleton_method(:named_resource) { resource_name }
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/engine.rb

@@ -0,0 +1,52 @@
+require "kaminari"
+
+require "administrate/namespace/resource"
+require "administrate/not_authorized_error"
+require "administrate/page/form"
+require "administrate/page/show"
+require "administrate/page/collection"
+require "administrate/order"
+require "administrate/resource_resolver"
+require "administrate/search"
+require "administrate/namespace"
+
+module Administrate
+  class Engine < ::Rails::Engine
+    isolate_namespace Administrate
+
+    @@javascripts = []
+    @@stylesheets = []
+
+    initializer "administrate.assets.precompile" do |app|
+      app.config.assets.precompile += [
+        "administrate/application.js",
+        "administrate/application.css"
+      ]
+    end
+
+    initializer "administrate.action_text" do
+      ActiveSupport.on_load :action_text_rich_text do
+        require "administrate/field/rich_text"
+      end
+    end
+
+    def self.add_javascript(script)
+      @@javascripts << script
+    end
+
+    def self.add_stylesheet(stylesheet)
+      @@stylesheets << stylesheet
+    end
+
+    def self.stylesheets
+      @@stylesheets
+    end
+
+    def self.javascripts
+      @@javascripts
+    end
+
+    add_javascript "administrate/application"
+    add_stylesheet "administrate/application"
+  end
+end

data/administrate-1.0.0/lib/administrate/field/associative.rb

@@ -0,0 +1,72 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Associative < Base
+      def self.foreign_key_for(resource_class, attr)
+        reflection(resource_class, attr).foreign_key
+      end
+
+      def self.association_primary_key_for(resource_class, attr)
+        reflection(resource_class, attr).association_primary_key
+      end
+
+      def self.associated_class(resource_class, attr)
+        reflection(resource_class, attr).klass
+      end
+
+      def self.associated_class_name(resource_class, attr)
+        associated_class(resource_class, attr).name
+      end
+
+      def self.reflection(resource_class, attr)
+        resource_class.reflect_on_association(attr)
+      end
+
+      def display_associated_resource
+        associated_dashboard.display_resource(data)
+      end
+
+      def associated_class
+        if option_given?(:class_name)
+          associated_class_name.constantize
+        else
+          self.class.associated_class(resource.class, attribute)
+        end
+      end
+
+      def associated_class_name
+        if option_given?(:class_name)
+          options.fetch(:class_name)
+        else
+          self.class.associated_class_name(
+            resource.class,
+            attribute
+          )
+        end
+      end
+
+      def html_controller
+        "select"
+      end
+
+      private
+
+      def associated_dashboard
+        "#{associated_class_name}Dashboard".constantize.new
+      end
+
+      def association_primary_key
+        self.class.association_primary_key_for(resource.class, attribute)
+      end
+
+      def foreign_key
+        self.class.foreign_key_for(resource.class, attribute)
+      end
+
+      def option_given?(name)
+        options.key?(name)
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/base.rb

@@ -0,0 +1,119 @@
+require_relative "deferred"
+require "active_support/core_ext/string/inflections"
+
+module Administrate
+  module Field
+    class Base
+      def self.with_options(options = {})
+        Deferred.new(self, options)
+      end
+
+      def self.html_class
+        field_type.dasherize
+      end
+
+      def self.associative?
+        self < Associative
+      end
+
+      def self.eager_load?
+        false
+      end
+
+      def self.searchable?
+        false
+      end
+
+      def self.sortable?
+        true
+      end
+
+      def self.field_type
+        to_s.split("::").last.underscore
+      end
+
+      def self.permitted_attribute(attr, _options = nil)
+        attr
+      end
+
+      def self.partial_prefixes
+        @partial_prefixes ||=
+          if superclass.respond_to?(:partial_prefixes)
+            local_partial_prefixes + superclass.partial_prefixes
+          else
+            local_partial_prefixes
+          end
+      end
+
+      def self.local_partial_prefixes
+        ["fields/#{field_type}"]
+      end
+
+      def initialize(attribute, data, page, options = {})
+        @attribute = attribute
+        @page = page
+        @resource = options.delete(:resource)
+        @options = options
+        @data = read_value(data)
+      end
+
+      def html_class
+        self.class.html_class
+      end
+
+      def html_controller
+        nil
+      end
+
+      def name
+        attribute.to_s
+      end
+
+      def read_value(data)
+        if options.key?(:getter)
+          if options[:getter].respond_to?(:call)
+            options[:getter].call(self)
+          else
+            resource.try(options[:getter])
+          end
+        elsif data.nil?
+          resource.try(attribute)
+        else
+          data
+        end
+      end
+
+      def partial_prefixes
+        self.class.partial_prefixes
+      end
+
+      def required?
+        return false unless resource.class.respond_to?(:validators_on)
+
+        resource.class.validators_on(attribute).any? do |v|
+          next false unless v.instance_of?(ActiveRecord::Validations::PresenceValidator)
+
+          options = v.options
+          next false if options.include?(:if)
+          next false if options.include?(:unless)
+
+          if (on_option = options[:on])
+            if on_option == :create && !resource.persisted?
+              next true
+            end
+
+            if on_option == :update && resource.persisted?
+              next true
+            end
+
+            next false
+          end
+
+          true
+        end
+      end
+
+      attr_reader :attribute, :data, :options, :page, :resource
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/belongs_to.rb

@@ -0,0 +1,55 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class BelongsTo < Associative
+      def self.permitted_attribute(attr, options = {})
+        resource_class = options[:resource_class]
+        foreign_key_for(resource_class, attr)
+      end
+
+      def self.eager_load?
+        true
+      end
+
+      def permitted_attribute
+        foreign_key
+      end
+
+      def associated_resource_options
+        candidate_resources.map do |resource|
+          [
+            display_candidate_resource(resource),
+            resource.send(association_primary_key)
+          ]
+        end
+      end
+
+      def selected_option
+        data&.send(association_primary_key)
+      end
+
+      def include_blank_option
+        options.fetch(:include_blank, true)
+      end
+
+      private
+
+      def candidate_resources
+        scope =
+          if options[:scope]
+            options[:scope].arity.positive? ? options[:scope].call(self) : options[:scope].call
+          else
+            associated_class.all
+          end
+
+        order = options.delete(:order)
+        order ? scope.reorder(order) : scope
+      end
+
+      def display_candidate_resource(resource)
+        associated_dashboard.display_resource(resource)
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/boolean.rb

@@ -0,0 +1,15 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Boolean < Base
+      def to_s
+        if data.nil?
+          "-"
+        else
+          data.to_s
+        end
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/date.rb

@@ -0,0 +1,24 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Date < Base
+      def date
+        I18n.localize(
+          data.in_time_zone(timezone).to_date,
+          format: format
+        )
+      end
+
+      private
+
+      def format
+        options.fetch(:format, :default)
+      end
+
+      def timezone
+        options.fetch(:timezone, ::Time.zone)
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/date_time.rb

@@ -0,0 +1,31 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class DateTime < Base
+      def date
+        I18n.localize(
+          data.in_time_zone(timezone).to_date,
+          format: format
+        )
+      end
+
+      def datetime
+        I18n.localize(
+          data.in_time_zone(timezone),
+          format: format
+        )
+      end
+
+      private
+
+      def format
+        options.fetch(:format, :default)
+      end
+
+      def timezone
+        options.fetch(:timezone, ::Time.zone)
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/deferred.rb

@@ -0,0 +1,59 @@
+require "active_support/core_ext/module/delegation"
+
+module Administrate
+  module Field
+    class Deferred
+      def initialize(deferred_class, options = {})
+        @deferred_class = deferred_class
+        @options = options
+      end
+
+      attr_reader :deferred_class, :options
+
+      def new(*args)
+        new_options = args.last.respond_to?(:merge) ? args.pop : {}
+        deferred_class.new(*args, options.merge(new_options))
+      end
+
+      def ==(other)
+        other.respond_to?(:deferred_class) &&
+          deferred_class == other.deferred_class &&
+          options == other.options
+      end
+
+      def getter
+        options.fetch(:getter, nil)
+      end
+
+      def associative?
+        deferred_class.associative?
+      end
+
+      def eager_load?
+        deferred_class.eager_load?
+      end
+
+      def searchable?
+        if options.key?(:getter)
+          false
+        else
+          options.fetch(:searchable, deferred_class.searchable?)
+        end
+      end
+
+      def searchable_fields
+        options.fetch(:searchable_fields)
+      end
+
+      def sortable?
+        options.fetch(:sortable, deferred_class.sortable?)
+      end
+
+      def permitted_attribute(attr, opts = {})
+        deferred_class.permitted_attribute(attr, options.merge(opts))
+      end
+
+      delegate :html_class, to: :deferred_class
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/field/email.rb

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Email < Field::Base
+      def self.searchable?
+        true
+      end
+    end
+  end
+end