jav_madmin 2.6.2

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/select.rb

@@ -0,0 +1,9 @@
+module Madmin
+  module Fields
+    class Select < Field
+      def options_for_select(record)
+        options.collection
+      end
+    end
+  end
+end

data/lib/madmin/fields/string.rb

@@ -0,0 +1,9 @@
+module Madmin
+  module Fields
+    class String < Field
+      def searchable?
+        options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
+      end
+    end
+  end
+end

data/lib/madmin/fields/text.rb

@@ -0,0 +1,9 @@
+module Madmin
+  module Fields
+    class Text < Field
+      def searchable?
+        options.fetch(:searchable, resource.model_column_names.include?(attribute_name.to_s))
+      end
+    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

@@ -0,0 +1,59 @@
+module Madmin
+  module GeneratorHelpers
+    ROUTES_FILE = {default: "config/routes.rb", separated: "config/routes/madmin.rb"}.freeze
+
+    def call_generator(generator, *args)
+      Rails::Generators.invoke(generator, args, generator_options)
+    end
+
+    def route_namespace_exists?
+      File.readlines(Rails.root.join(default_routes_file)).grep(/namespace :madmin/).size > 0
+    end
+
+    def rails6_1_and_up?
+      Gem.loaded_specs["rails"].version >= Gem::Version.new(6.1)
+    end
+
+    # Method copied from Rails 6.1 master
+    def route(routing_code, namespace: nil, sentinel: nil, indentation: 2, file: default_routes_file)
+      routing_code = Array(namespace).reverse.reduce(routing_code) { |code, ns|
+        "namespace :#{ns} do\n#{indent(code, 2)}\nend"
+      }
+
+      log :route, routing_code
+      sentinel ||= default_sentinel(file)
+
+      in_root do
+        inject_into_file file, 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 separated_routes_file?
+      default_routes_file.eql?(ROUTES_FILE[:separated])
+    end
+
+    def default_sentinel(file)
+      file.eql?(ROUTES_FILE[:default]) ? /\.routes\.draw do\s*\n/m : /namespace :madmin[^\n]*do\s*\n/m
+    end
+
+    def default_routes_file
+      if rails6_1_and_up? && File.exist?(ROUTES_FILE[:separated])
+        ROUTES_FILE[:separated]
+      else
+        ROUTES_FILE[:default]
+      end
+    end
+
+    def generator_options
+      {behavior: behavior}
+    end
+  end
+end

data/lib/madmin/member_action.rb

@@ -0,0 +1,19 @@
+module Madmin
+  # Wraps a member action block along with its options so views can decide
+  # where to render it. Responds to `to_proc` and `call` so it can be used
+  # anywhere the raw block was.
+  class MemberAction
+    attr_reader :block
+
+    def initialize(collection: false, &block)
+      @collection = collection
+      @block = block
+    end
+
+    def collection? = @collection
+
+    def call(*args, &blk) = block.call(*args, &blk)
+
+    def to_proc = block
+  end
+end

data/lib/madmin/menu.rb

@@ -0,0 +1,70 @@
+module Madmin
+  class Menu
+    def initialize
+      @children = {}
+    end
+
+    def reset
+      @children = {}
+    end
+
+    def before_render(&block)
+      if block_given?
+        @before_render = block
+      else
+        @before_render
+      end
+    end
+
+    def render(&block)
+      instance_eval(&@before_render) if @before_render
+
+      # Ensure all the resources have been added to the menu
+      Madmin.resources.each do |resource|
+        next if resource.menu_options == false
+        add resource.menu_options
+      end
+
+      items.each(&block)
+    end
+
+    module Node
+      def add(options)
+        options = options.dup
+
+        if (parent = options.delete(:parent))
+          @children[parent] ||= Item.new(label: parent)
+          @children[parent].add options
+        else
+          item = Item.new(**options)
+          @children[item.label] = item
+        end
+      end
+
+      def items
+        @children.values.sort do |a, b|
+          result = a.position <=> b.position
+          result = a.label <=> b.label if result == 0 # sort alphabetically for the same position
+          result
+        end
+      end
+    end
+
+    include Node
+
+    class Item
+      include Node
+
+      attr_reader :label, :url, :position, :parent, :children
+
+      def initialize(label:, url: nil, position: 99, parent: nil, **options)
+        @label = label
+        @url = url
+        @position = position
+        @parent = parent
+        @if = options.delete(:if)
+        @children = {}
+      end
+    end
+  end
+end

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,295 @@
+module Madmin
+  class Resource
+    Attribute = Data.define(:name, :type, :field)
+
+    class_attribute :attributes, default: ActiveSupport::OrderedHash.new
+    class_attribute :member_actions, default: []
+    class_attribute :collection_actions, default: []
+    class_attribute :scopes, default: []
+    class_attribute :menu_options, instance_reader: false
+
+    class << self
+      def inherited(base)
+        base.attributes = attributes.dup
+        base.member_actions = member_actions.dup
+        base.collection_actions = collection_actions.dup
+        base.scopes = scopes.dup
+        super
+      end
+
+      def model(value = nil)
+        if value
+          @model = value
+        else
+          @model ||= model_name.constantize
+        end
+      end
+
+      def model_find(id)
+        friendly_model? ? model.friendly.find(id) : model.find(id)
+      end
+
+      def model_name
+        to_s.chomp("Resource").classify
+      end
+
+      def scope(name)
+        scopes << name
+      end
+
+      # Label for a scope button on the index. Looks up
+      # madmin.scopes.<param_key>.<name>, then madmin.scopes.<name> in I18n,
+      # falling back to the humanized scope name. Override for custom labels.
+      def scope_label(name)
+        I18n.t("madmin.scopes.#{param_key}.#{name}", default: [:"madmin.scopes.#{name}", name.to_s.humanize])
+      end
+
+      def get_attribute(name)
+        attributes[name]
+      end
+
+      def attribute(name, type = nil, **options)
+        type ||= infer_type(name)
+        field = options.delete(:field) || field_for_type(type)
+
+        if field.nil?
+          Rails.logger.warn <<~MESSAGE
+            WARNING: Madmin could not infer a field type for `#{name}` attribute in `#{self.name}`. Defaulting to a String type.
+            #{caller.find { _1.start_with? Rails.root.to_s }}
+          MESSAGE
+          field = Fields::String
+        end
+
+        config = ActiveSupport::OrderedOptions.new.merge(options)
+        yield config if block_given?
+
+        # Form is an alias for new & edit but shouldn't override their values if explicitly set (true/false)
+        config.new = config[:form] if config[:new].nil?
+        config.edit = config[:form] if config[:edit].nil?
+
+        # New/create and edit/update need to match
+        config.create = config.new
+        config.update = config.edit
+
+        # Remove any nil values to use the defaults
+        config.compact!
+
+        attributes[name] = Attribute.new(
+          name: name,
+          type: type,
+          field: field.new(attribute_name: name, model: model, resource: self, options: config)
+        )
+      end
+
+      # Returns singular name
+      # For example: "Forum::Post" -> "Post"
+      def friendly_name
+        model.model_name.human
+      end
+
+      # Support for isolated namespaces
+      # Finds parent module class to include in polymorphic urls
+      def route_namespace
+        return @route_namespace if instance_variable_defined?(:@route_namespace)
+        namespace = model.module_parents.detect do |n|
+          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+        end
+        @route_namespace = (namespace ? namespace.name.underscore.to_sym : nil)
+      end
+
+      def index_path(options = {})
+        url_helpers.polymorphic_path([:madmin, route_namespace, model], options)
+      end
+
+      def new_path
+        url_helpers.polymorphic_path([:madmin, route_namespace, model], action: :new)
+      end
+
+      def show_path(record)
+        url_helpers.polymorphic_path([:madmin, route_namespace, becomes(record)])
+      end
+
+      def edit_path(record)
+        url_helpers.polymorphic_path([:madmin, route_namespace, becomes(record)], action: :edit)
+      end
+
+      def becomes(record)
+        record.instance_of?(model) ? record : record.becomes(model)
+      end
+
+      def param_key
+        model.model_name.param_key
+      end
+
+      def permitted_params
+        attributes.values.filter { |a| a.field.visible?(:form) }.map { |a| a.field.to_param }
+      end
+
+      def display_name(record)
+        "#{record.model_name.human} ##{record.id}"
+      end
+
+      def friendly_model?
+        model.respond_to? :friendly
+      end
+
+      def readonly?
+        false
+      end
+
+      def sortable_columns
+        model_column_names
+      end
+
+      def model_column_names
+        model.column_names
+      end
+
+      def searchable_attributes
+        attributes.values.select { |a| a.field.searchable? }
+      end
+
+      def member_action(collection: false, &block)
+        member_actions << MemberAction.new(collection: collection, &block)
+      end
+
+      # Member actions that should also render in each row on the index page
+      def collection_member_actions
+        member_actions.select { |action| action.respond_to?(:collection?) && action.collection? }
+      end
+
+      def collection_action(&block)
+        collection_actions << block
+      end
+
+      def field_for_type(type)
+        {
+          binary: Fields::String,
+          blob: Fields::Text,
+          boolean: Fields::Boolean,
+          currency: Fields::Currency,
+          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,
+          select: Fields::Select,
+          string: Fields::String,
+          text: Fields::Text,
+          time: Fields::Time,
+          timestamp: Fields::Time,
+          timestamptz: Fields::Time,
+          password: Fields::Password,
+          file: Fields::File,
+
+          # 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,
+          nested_has_many: Fields::NestedHasMany
+        }[type]
+      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
+
+        # has_secure_password
+        elsif model.attribute_types.include?("#{name_string}_digest") || name_string.ends_with?("_confirmation")
+          :password
+
+          # ActiveRecord Store
+        elsif model_store_accessors.include?(name)
+          :string
+        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
+
+      def url_helpers
+        @url_helpers ||= Rails.application.routes.url_helpers
+      end
+
+      def model_store_accessors
+        return [] unless model.respond_to?(:stored_attributes)
+
+        store_accessors = model.stored_attributes.values
+        store_accessors.flatten
+      end
+
+      def menu(options)
+        @menu_options = options
+      end
+
+      def menu_options
+        return false if @menu_options == false
+        @menu_options ||= {}
+        @menu_options.with_defaults(label: model.model_name.i18n_key.to_s, url: index_path)
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:madmin_resource, self)
+  end
+end

data/lib/madmin/resource_builder.rb

@@ -0,0 +1,88 @@
+module Madmin
+  class ResourceBuilder
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def associations
+      return [] unless model.respond_to?(:reflections)
+
+      model.reflections.reject { |name, association|
+        # Hide these special associations
+        name.starts_with?("rich_text") ||
+          name.ends_with?("_attachment") ||
+          name.ends_with?("_attachments") ||
+          name.ends_with?("_blob") ||
+          name.ends_with?("_blobs")
+      }.keys
+    end
+
+    def attributes
+      model.attribute_names + virtual_attributes - redundant_attributes
+    end
+
+    def store_accessors
+      return [] unless model.respond_to?(:stored_attributes)
+
+      model.stored_attributes.values.flatten
+    end
+
+    def virtual_attributes
+      return [] unless model.respond_to?(:attribute_types)
+
+      virtual = []
+
+      # has_secure_password columns
+      password_attributes = model.attribute_types.keys.select { |k| k.ends_with?("_digest") }.map { |k| k.delete_suffix("_digest") }
+      virtual += password_attributes.map { |attr| [attr, "#{attr}_confirmation"] }.flatten
+
+      # ActiveRecord Store columns
+      virtual += store_accessors.map(&:to_s)
+
+      # Add virtual attributes for ActionText and ActiveStorage
+      model.reflections.each do |name, association|
+        if name.starts_with?("rich_text")
+          virtual << name.split("rich_text_").last
+        elsif name.ends_with?("_attachment")
+          virtual << name.split("_attachment").first
+        elsif name.ends_with?("_attachments")
+          virtual << name.split("_attachments").first
+        end
+      end
+
+      virtual
+    end
+
+    def redundant_attributes
+      return [] unless model.respond_to?(:attribute_types)
+
+      redundant = []
+
+      # has_secure_password columns
+      redundant += model.attribute_types.keys.select { |k| k.ends_with?("_digest") }
+
+      # ActiveRecord Store columns
+      store_columns = model.stored_attributes.keys
+      redundant += store_columns.map(&:to_s)
+
+      model.reflections.each do |name, association|
+        if association.has_one?
+          next
+        elsif association.collection?
+          next
+        elsif association.polymorphic?
+          redundant << "#{name}_id"
+          redundant << "#{name}_type"
+        elsif name.starts_with?("rich_text")
+          redundant << name
+        else # belongs to
+          redundant << "#{name}_id"
+        end
+      end
+
+      redundant
+    end
+  end
+end

data/lib/madmin/search.rb

@@ -0,0 +1,62 @@
+# based on Administrate Search: https://github.com/thoughtbot/administrate/blob/main/lib/administrate/search.rb
+
+module Madmin
+  class Search
+    attr_reader :query
+
+    def initialize(scoped_resource, resource, term)
+      @resource = resource
+      @scoped_resource = scoped_resource
+      @query = term
+    end
+
+    def run
+      if query.blank?
+        @scoped_resource.all
+      else
+        search_results(@scoped_resource)
+      end
+    end
+
+    private
+
+    def search_results(resources)
+      resources.where(query_template, *query_values)
+    end
+
+    def query_template
+      search_attributes.map do |attr|
+        table_name = query_table_name(attr)
+        searchable_fields(attr).map do |field|
+          column_name = column_to_query(field)
+          "LOWER(CAST(#{table_name}.#{column_name} AS CHAR(256))) LIKE ?"
+        end.join(" OR ")
+      end.join(" OR ")
+    end
+
+    def searchable_fields(attr)
+      [attr.name]
+    end
+
+    def query_values
+      fields_count = search_attributes.sum do |attr|
+        searchable_fields(attr).count
+      end
+      ["%#{@query.downcase}%"] * fields_count
+    end
+
+    def search_attributes
+      @resource.searchable_attributes
+    end
+
+    def query_table_name(attr)
+      ::ActiveRecord::Base.connection.quote_table_name(@scoped_resource.table_name)
+    end
+
+    def column_to_query(attr)
+      ::ActiveRecord::Base.connection.quote_column_name(attr)
+    end
+
+    ActiveSupport.run_load_hooks(:madmin_search, self)
+  end
+end

data/lib/madmin/version.rb

@@ -0,0 +1,3 @@
+module Madmin
+  VERSION = "2.6.2"
+end