madmin 0.1.0 → 1.0.1

data/lib/madmin.rb

@@ -1,30 +1,41 @@
 require "madmin/engine"
-require "madmin/resourceable"
-require "madmin/resources"
+
+require "pagy"
 
 module Madmin
-  class NoResourcesError < StandardError; end
-  class ResourceNotFoundError < StandardError; end
-  class WrongArgumentError < StandardError; end
-  class UndefinedScopeError < StandardError; end
-  class ScopeWithArgumentsError < StandardError; end
+  autoload :Field, "madmin/field"
+  autoload :GeneratorHelpers, "madmin/generator_helpers"
+  autoload :Resource, "madmin/resource"
+
+  module Fields
+    autoload :Boolean, "madmin/fields/boolean"
+    autoload :Integer, "madmin/fields/integer"
+    autoload :String, "madmin/fields/string"
+    autoload :Text, "madmin/fields/text"
+    autoload :Date, "madmin/fields/date"
+    autoload :DateTime, "madmin/fields/date_time"
+    autoload :Decimal, "madmin/fields/decimal"
+    autoload :Json, "madmin/fields/json"
+    autoload :Enum, "madmin/fields/enum"
+    autoload :Float, "madmin/fields/float"
+    autoload :Time, "madmin/fields/time"
+    autoload :BelongsTo, "madmin/fields/belongs_to"
+    autoload :Polymorphic, "madmin/fields/polymorphic"
+    autoload :HasMany, "madmin/fields/has_many"
+    autoload :HasOne, "madmin/fields/has_one"
+    autoload :RichText, "madmin/fields/rich_text"
+    autoload :Attachment, "madmin/fields/attachment"
+    autoload :Attachments, "madmin/fields/attachments"
+  end
+
+  mattr_accessor :resources, default: []
 
-  autoload :Field,        "madmin/field"
-  autoload :Resourceable, "madmin/resourceable"
+  class << self
+    def resource_for(object)
+      Rails.application.eager_load!
 
-  class Field
-    autoload :Associatable, "madmin/field/associatable"
-    autoload :BelongsTo,    "madmin/field/belongs_to"
-    autoload :CheckBox,     "madmin/field/check_box"
-    autoload :DateTime,     "madmin/field/date_time"
-    autoload :Email,        "madmin/field/email"
-    autoload :HasMany,      "madmin/field/has_many"
-    autoload :HasOne,       "madmin/field/has_one"
-    autoload :Number,       "madmin/field/number"
-    autoload :Password,     "madmin/field/password"
-    autoload :Polymorphic,  "madmin/field/polymorphic"
-    autoload :Select,       "madmin/field/select"
-    autoload :TextArea,     "madmin/field/text_area"
-    autoload :Text,         "madmin/field/text"
+      klass_name = object.class.name
+      Madmin.resources.find { |r| r.model_name == klass_name }
+    end
   end
 end

data/lib/madmin/engine.rb

@@ -1,9 +1,12 @@
 module Madmin
   class Engine < ::Rails::Engine
-    isolate_namespace Madmin
+    initializer "madmin.autoload", before: :set_autoload_paths do |app|
+      app.config.paths.add "app/madmin/resources", eager_load: true
+      app.config.paths.add "app/madmin/fields", eager_load: true
+    end
 
     config.to_prepare do
-      Dir.glob("#{Rails.root}/app/madmin/**/*.rb").each { |r| require_dependency(r) }
+      Madmin.resources = []
     end
   end
 end

data/lib/madmin/field.rb

@@ -1,64 +1,40 @@
 module Madmin
   class Field
-    attr_reader :form
-    attr_reader :index
-    attr_reader :key
-    attr_reader :label
-    attr_reader :model
-    attr_reader :options
-    attr_reader :show
-    attr_reader :type
+    attr_reader :attribute_name, :model, :options
 
-    def initialize(args)
-      @key     = args[:key]
-      @options = args
-      @model   = args[:model]
-      @label   = option_or_default(:label, label_from_attribute(key))
-      @form    = option_or_default(:form, false)
-      @index   = option_or_default(:index, false)
-      @show    = option_or_default(:show, true)
+    def self.field_type
+      to_s.split("::").last.underscore
     end
 
-    ##
-    # Returns an array of key(s) to use in strong
-    # params for the resources controller.
-    def strong_params_keys
-      [key]
+    def initialize(attribute_name:, model:, **options)
+      @attribute_name = attribute_name
+      @model = model
+      @options = options
     end
 
-    ##
-    # Returns the partial path for the field type
-    def to_partial_path
-      "madmin/fields/#{self.class.to_s.split("Madmin::Field::").last.underscore}"
+    def value(record)
+      record.public_send(attribute_name)
     end
 
-    ##
-    # Returns the value for a given resource
-    def value_for(resource)
-      resource.send(key)
-    end
+    def to_partial_path(name)
+      unless %w[index show form].include? name
+        raise ArgumentError, "`partial` must be 'index', 'show', or 'form'"
+      end
 
-    private
+      "/madmin/fields/#{self.class.field_type}/#{name}"
+    end
 
-    ##
-    # This method takes an attribute and converts it
-    # into a human readable format for form labels.
-    def label_from_attribute(attribute)
-      attribute.to_s.humanize
+    def to_param
+      attribute_name
     end
 
-    ##
-    # This method verifies options are present
-    # (as a hash).
-    def options?
-      options.is_a?(Hash)
+    # Used for checking visibility of attribute on an view
+    def visible?(action, default: true)
+      options.fetch(action.to_sym, default)
     end
 
-    ##
-    # This method extracts the many option checks
-    # performed when assigning field options.
-    def option_or_default(key, default)
-      options? ? options.fetch(key, default) : default
+    def required?
+      model.validators_on(attribute_name).any? { |v| v.is_a? ActiveModel::Validations::PresenceValidator }
     end
   end
 end

data/lib/madmin/fields/attachment.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Attachment < Field
+    end
+  end
+end

data/lib/madmin/fields/attachments.rb

@@ -0,0 +1,9 @@
+module Madmin
+  module Fields
+    class Attachments < Field
+      def to_param
+        {attribute_name => []}
+      end
+    end
+  end
+end

data/lib/madmin/fields/belongs_to.rb

@@ -0,0 +1,18 @@
+module Madmin
+  module Fields
+    class BelongsTo < Field
+      def options_for_select(record)
+        association = record.class.reflect_on_association(attribute_name)
+
+        klass = association.klass
+        klass.all.map do |r|
+          ["#{klass.name} ##{r.id}", r.id]
+        end
+      end
+
+      def to_param
+        "#{attribute_name}_id"
+      end
+    end
+  end
+end

data/lib/madmin/fields/boolean.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Boolean < Field
+    end
+  end
+end

data/lib/madmin/fields/date.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Date < Field
+    end
+  end
+end

data/lib/madmin/fields/date_time.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class DateTime < Field
+    end
+  end
+end

data/lib/madmin/fields/decimal.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Decimal < Field
+    end
+  end
+end

data/lib/madmin/fields/enum.rb

@@ -0,0 +1,9 @@
+module Madmin
+  module Fields
+    class Enum < Field
+      def options_for_select(record)
+        model.defined_enums[attribute_name.to_s].keys
+      end
+    end
+  end
+end

data/lib/madmin/fields/float.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Float < Field
+    end
+  end
+end

data/lib/madmin/fields/has_many.rb

@@ -0,0 +1,18 @@
+module Madmin
+  module Fields
+    class HasMany < Field
+      def options_for_select(record)
+        association = record.class.reflect_on_association(attribute_name)
+
+        klass = association.klass
+        klass.all.map do |r|
+          ["#{klass.name} ##{r.id}", r.id]
+        end
+      end
+
+      def to_param
+        {"#{attribute_name.to_s.singularize}_ids".to_sym => []}
+      end
+    end
+  end
+end

data/lib/madmin/fields/has_one.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class HasOne < Field
+    end
+  end
+end

data/lib/madmin/fields/integer.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Integer < Field
+    end
+  end
+end

data/lib/madmin/fields/json.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Json < Field
+    end
+  end
+end

data/lib/madmin/fields/polymorphic.rb

@@ -0,0 +1,17 @@
+module Madmin
+  module Fields
+    class Polymorphic < Field
+      def options_for_select(record)
+        if (collection = options[:collection])
+          collection.call
+        else
+          []
+        end
+      end
+
+      def to_param
+        {attribute_name => %i[type value]}
+      end
+    end
+  end
+end

data/lib/madmin/fields/rich_text.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class RichText < Field
+    end
+  end
+end

data/lib/madmin/fields/string.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class String < Field
+    end
+  end
+end

data/lib/madmin/fields/text.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Text < Field
+    end
+  end
+end

data/lib/madmin/fields/time.rb

@@ -0,0 +1,6 @@
+module Madmin
+  module Fields
+    class Time < Field
+    end
+  end
+end

data/lib/madmin/generator_helpers.rb

@@ -4,6 +4,30 @@ module Madmin
       Rails::Generators.invoke(generator, args, generator_options)
     end
 
+    def route_namespace_exists?
+      File.readlines(Rails.root.join("config/routes.rb")).grep(/namespace :madmin/).size > 0
+    end
+
+    # Method copied from Rails 6.1 master
+    def route(routing_code, namespace: nil, sentinel: nil, indentation: 2)
+      routing_code = Array(namespace).reverse.reduce(routing_code) { |code, ns|
+        "namespace :#{ns} do\n#{indent(code, 2)}\nend"
+      }
+
+      log :route, routing_code
+      sentinel ||= /\.routes\.draw do\s*\n/m
+
+      in_root do
+        inject_into_file "config/routes.rb", optimize_indentation(routing_code, indentation), after: sentinel, verbose: false, force: false
+      end
+    end
+
+    # Method copied from Rails 6.1 master
+    def optimize_indentation(value, amount = 0)
+      return "#{value}\n" unless value.is_a?(String)
+      "#{value.strip_heredoc.indent(amount).chomp}\n"
+    end
+
     private
 
     def generator_options

data/lib/madmin/namespace.rb

@@ -0,0 +1,35 @@
+module Madmin
+  class Namespace
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    def resources
+      @resources ||= routes.map(&:first).uniq.map { |path|
+        Resource.new(namespace, path)
+      }
+    end
+
+    def routes
+      @routes ||= all_routes.select { |controller, _action|
+        controller.starts_with?("#{namespace}/")
+      }.map { |controller, action|
+        [controller.gsub(/^#{namespace}\//, ""), action]
+      }
+    end
+
+    def resources_with_index_route
+      routes.select { |_resource, route| route == "index" }.map(&:first).uniq
+    end
+
+    private
+
+    attr_reader :namespace
+
+    def all_routes
+      Rails.application.routes.routes.map do |route|
+        route.defaults.values_at(:controller, :action).map(&:to_s)
+      end
+    end
+  end
+end

data/lib/madmin/resource.rb

@@ -0,0 +1,176 @@
+module Madmin
+  class Resource
+    class_attribute :attributes, default: []
+    class_attribute :scopes, default: []
+
+    class << self
+      def inherited(base)
+        # Remove any old references
+        Madmin.resources.delete(base)
+        Madmin.resources << base
+
+        base.attributes = attributes.dup
+        base.scopes = scopes.dup
+        super
+      end
+
+      def model
+        model_name.constantize
+      end
+
+      def model_name
+        to_s.chomp("Resource").classify
+      end
+
+      def scope(name)
+        scopes << name
+      end
+
+      def attribute(name, type = nil, **options)
+        attributes << {
+          name: name,
+          field: field_for_type(name, type).new(**options.merge(attribute_name: name, model: model))
+        }
+      end
+
+      def friendly_name
+        model_name.gsub("::", " / ")
+      end
+
+      def index_path(options = {})
+        path = "/madmin/#{model.model_name.collection}"
+        path += "?#{options.to_param}" if options.any?
+        path
+      end
+
+      def new_path
+        "/madmin/#{model.model_name.collection}/new"
+      end
+
+      def show_path(record)
+        "/madmin/#{model.model_name.collection}/#{record.id}"
+      end
+
+      def edit_path(record)
+        "/madmin/#{model.model_name.collection}/#{record.id}/edit"
+      end
+
+      def param_key
+        model.model_name.param_key
+      end
+
+      def permitted_params
+        attributes.map { |a| a[:field].to_param }
+      end
+
+      def display_name(record)
+        "#{record.class} ##{record.id}"
+      end
+
+      private
+
+      def field_for_type(name, type)
+        type ||= infer_type(name)
+
+        {
+          binary: Fields::String,
+          blob: Fields::Text,
+          boolean: Fields::Boolean,
+          date: Fields::Date,
+          datetime: Fields::DateTime,
+          decimal: Fields::Decimal,
+          enum: Fields::Enum,
+          float: Fields::Float,
+          hstore: Fields::Json,
+          integer: Fields::Integer,
+          json: Fields::Json,
+          jsonb: Fields::Json,
+          primary_key: Fields::String,
+          string: Fields::String,
+          text: Fields::Text,
+          time: Fields::Time,
+          timestamp: Fields::Time,
+
+          # Postgres specific types
+          bit: Fields::String,
+          bit_varying: Fields::String,
+          box: Fields::String,
+          cidr: Fields::String,
+          circle: Fields::String,
+          citext: Fields::Text,
+          daterange: Fields::String,
+          inet: Fields::String,
+          int4range: Fields::String,
+          int8range: Fields::String,
+          interval: Fields::String,
+          line: Fields::String,
+          lseg: Fields::String,
+          ltree: Fields::String,
+          macaddr: Fields::String,
+          money: Fields::String,
+          numrange: Fields::String,
+          oid: Fields::String,
+          path: Fields::String,
+          point: Fields::String,
+          polygon: Fields::String,
+          tsrange: Fields::String,
+          tstzrange: Fields::String,
+          tsvector: Fields::String,
+          uuid: Fields::String,
+          xml: Fields::Text,
+
+          # Associations
+          attachment: Fields::Attachment,
+          attachments: Fields::Attachments,
+          belongs_to: Fields::BelongsTo,
+          polymorphic: Fields::Polymorphic,
+          has_many: Fields::HasMany,
+          has_one: Fields::HasOne,
+          rich_text: Fields::RichText
+        }.fetch(type)
+      rescue
+        raise ArgumentError, <<~MESSAGE
+          Couldn't find attribute or association '#{name}' with type '#{type}' on #{model} model
+
+            To fix this, either:
+
+            1. Remove 'attribute #{name}' from app/madmin/resources/#{model.to_s.underscore}_resource.rb
+            2. Or add the missing attribute or association to the #{model} model
+        MESSAGE
+      end
+
+      def infer_type(name)
+        name_string = name.to_s
+
+        if model.attribute_types.include?(name_string)
+          column_type = model.attribute_types[name_string]
+          if column_type.is_a? ActiveRecord::Enum::EnumType
+            :enum
+          else
+            column_type.type || :string
+          end
+        elsif (association = model.reflect_on_association(name))
+          type_for_association(association)
+        elsif model.reflect_on_association(:"rich_text_#{name_string}")
+          :rich_text
+        elsif model.reflect_on_association(:"#{name_string}_attachment")
+          :attachment
+        elsif model.reflect_on_association(:"#{name_string}_attachments")
+          :attachments
+        end
+      end
+
+      def type_for_association(association)
+        if association.has_one?
+          :has_one
+        elsif association.collection?
+          :has_many
+        elsif association.polymorphic?
+          :polymorphic
+        else
+          :belongs_to
+        end
+      end
+    end
+  end
+end