mini-max-mod 0.0.1

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

@@ -0,0 +1,140 @@
+require_relative "associative"
+require "administrate/page/collection"
+require "administrate/order"
+
+module Administrate
+  module Field
+    class HasMany < Associative
+      DEFAULT_LIMIT = 5
+
+      def self.permitted_attribute(attr, _options = {})
+        # This may seem arbitrary, and improvable by using reflection.
+        # Worry not: here we do exactly what Rails does. Regardless of the name
+        # of the foreign key, has_many associations use the suffix `_ids`
+        # for this.
+        #
+        # Eg: if the associated table and primary key are `countries.code`,
+        # you may expect `country_codes` as attribute here, but it will
+        # be `country_ids` instead.
+        #
+        # See https://github.com/rails/rails/blob/b30a23f53b52e59d31358f7b80385ee5c2ba3afe/activerecord/lib/active_record/associations/builder/collection_association.rb#L48
+        {"#{attr.to_s.singularize}_ids": []}
+      end
+
+      def associated_collection(order = self.order)
+        Administrate::Page::Collection.new(
+          associated_dashboard,
+          order: order,
+          collection_attributes: options[:collection_attributes]
+        )
+      end
+
+      def attribute_key
+        permitted_attribute.keys.first
+      end
+
+      def associated_resource_options
+        candidate_resources.map do |associated_resource|
+          [
+            display_candidate_resource(associated_resource),
+            associated_resource.send(association_primary_key)
+          ]
+        end
+      end
+
+      def selected_options
+        return if data.empty?
+
+        data.map { |object| object.send(association_primary_key) }
+      end
+
+      def limit
+        options.fetch(:limit, DEFAULT_LIMIT)
+      end
+
+      def paginate?
+        limit.respond_to?(:positive?) ? limit.positive? : limit.present?
+      end
+
+      def permitted_attribute
+        self.class.permitted_attribute(
+          attribute,
+          resource_class: resource.class
+        )
+      end
+
+      def resources(page = 1, order = self.order)
+        resources = order.apply(data)
+        if paginate?
+          resources = resources.page(page).per(limit)
+        end
+        includes.any? ? resources.includes(*includes) : resources
+      end
+
+      def more_than_limit?
+        paginate? && data.size > limit
+      end
+
+      def data
+        @data ||= associated_class.none
+      end
+
+      def order_from_params(params)
+        Administrate::Order.new(
+          params.fetch(:order, sort_by),
+          params.fetch(:direction, direction),
+          sorting_column: sorting_column(
+            associated_dashboard_attribute(params.fetch(:order, sort_by))
+          )
+        )
+      end
+
+      def order
+        @order ||= Administrate::Order.new(
+          sort_by,
+          direction,
+          sorting_column: sorting_column(
+            associated_dashboard_attribute(sort_by)
+          )
+        )
+      end
+
+      private
+
+      def includes
+        associated_dashboard.collection_includes
+      end
+
+      def candidate_resources
+        if options.key?(:includes)
+          includes = options.fetch(:includes)
+          associated_class.includes(*includes).all
+        else
+          associated_class.all
+        end
+      end
+
+      def display_candidate_resource(resource)
+        associated_dashboard.display_resource(resource)
+      end
+
+      def sorting_column(dashboard_attribute)
+        return unless dashboard_attribute.try(:options)
+
+        dashboard_attribute.options.fetch(:sorting_column, nil)
+      end
+
+      def associated_dashboard_attribute(attribute)
+        associated_dashboard.attribute_types[attribute.to_sym] if attribute
+      end
+
+      def sort_by
+        options[:sort_by]
+      end
+
+      def direction
+        options[:direction]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class HasOne < Associative
+      def self.permitted_attribute(attr, options = {})
+        resource_class = options[:resource_class]
+        final_associated_class_name =
+          if options.key?(:class_name)
+            options.fetch(:class_name)
+          else
+            associated_class_name(resource_class, attr)
+          end
+        related_dashboard_attributes =
+          Administrate::ResourceResolver
+            .new("admin/#{final_associated_class_name}")
+            .dashboard_class.new.permitted_attributes + [:id]
+        {"#{attr}_attributes": related_dashboard_attributes}
+      end
+
+      def self.eager_load?
+        true
+      end
+
+      def nested_form
+        @nested_form ||= Administrate::Page::Form.new(
+          resolver.dashboard_class.new,
+          data || resolver.resource_class.new
+        )
+      end
+
+      def nested_show
+        @nested_show ||= Administrate::Page::Show.new(
+          resolver.dashboard_class.new,
+          data || resolver.resource_class.new
+        )
+      end
+
+      def linkable?
+        data.try(:persisted?)
+      end
+
+      def html_controller
+        "select"
+      end
+
+      private
+
+      def resolver
+        @resolver ||=
+          Administrate::ResourceResolver.new("admin/#{associated_class.name}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative "base"
+require "active_support/number_helper"
+
+module Administrate
+  module Field
+    class Number < Field::Base
+      def to_s
+        result = data.nil? ? "-" : format_string % value
+        result = format(result) if options[:format]
+        prefix + result + suffix
+      end
+
+      private
+
+      def format_string
+        "%.#{decimals}f"
+      end
+
+      def prefix
+        options[:prefix].to_s
+      end
+
+      def suffix
+        options[:suffix].to_s
+      end
+
+      def decimals
+        _left, right = data.to_s.split(".")
+        default = right.nil? ? 0 : right.size
+        options.fetch(:decimals, default)
+      end
+
+      def value
+        data * options.fetch(:multiplier, 1)
+      end
+
+      def format(result)
+        formatter = options[:format][:formatter]
+        formatter_options = options[:format][:formatter_options].to_h
+
+        ActiveSupport::NumberHelper
+          .try(formatter, result, **formatter_options) || result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Password < Field::Base
+      def self.searchable?
+        false
+      end
+
+      def self.sortable?
+        false
+      end
+
+      def truncate
+        data.to_s.gsub(/./, character)[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+
+      def character
+        options.fetch(:character, "•")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class Polymorphic < BelongsTo
+      def self.permitted_attribute(attr, _options = {})
+        {attr => %i[type value]}
+      end
+
+      def associated_resource_grouped_options
+        classes.map do |klass|
+          [klass.model_name.human, candidate_resources_for(klass).map do |resource|
+            [display_candidate_resource(resource), resource.to_global_id]
+          end]
+        end
+      end
+
+      def permitted_attribute
+        {attribute => %i[type value]}
+      end
+
+      def selected_global_id
+        data&.to_global_id
+      end
+
+      private
+
+      def associated_dashboard(klass = data.class)
+        "#{klass.name}Dashboard".constantize.new
+      end
+
+      def classes
+        klasses = options.fetch(:classes, [])
+        klasses.respond_to?(:call) ? klasses.call : klasses
+      end
+
+      private
+
+      def order
+        @_order ||= options.delete(:order)
+      end
+
+      def candidate_resources_for(klass)
+        order ? klass.order(order) : klass.all
+      end
+
+      def display_candidate_resource(resource)
+        associated_dashboard(resource.class).display_resource(resource)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "administrate/field/base"
+
+module Administrate
+  module Field
+    class RichText < Administrate::Field::Base
+      def to_s
+        data&.to_plain_text
+      end
+
+      def truncate
+        to_s.truncate(truncation_length)
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Select < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def selectable_options
+        values =
+          if options.key?(:collection)
+            options.fetch(:collection)
+          elsif active_record_enum?
+            active_record_enum_values
+          else
+            []
+          end
+
+        if values.respond_to? :call
+          values = values.arity.positive? ? values.call(self) : values.call
+        end
+
+        values
+      end
+
+      def include_blank_option
+        options.fetch(:include_blank, false)
+      end
+
+      def active_record_enum?
+        resource.class.defined_enums.key?(attribute.to_s)
+      end
+
+      def active_record_enum_values
+        resource.class.defined_enums[attribute.to_s].map(&:first)
+      end
+
+      def html_controller
+        "select"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class String < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Text < Administrate::Field::Base
+      def self.searchable?
+        false
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Time < Base
+      def time
+        I18n.localize(
+          data,
+          format: format
+        )
+      end
+
+      private
+
+      def format
+        options.fetch(:format, "%I:%M%p")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Url < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      def html_options
+        @options[:html_options] || {}
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Administrate
+  module GeneratorHelpers
+    def call_generator(generator, *args)
+      Rails::Generators.invoke(generator, args, generator_options)
+    end
+
+    private
+
+    def generator_options
+      {behavior: behavior}
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/namespace/resource.rb

@@ -0,0 +1,28 @@
+module Administrate
+  class Namespace
+    class Resource
+      attr_reader :namespace, :resource
+
+      def initialize(namespace, resource)
+        @namespace = namespace
+        @resource = resource
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def to_sym
+        name
+      end
+
+      def name
+        resource.to_s.gsub(/^#{namespace}\//, "").to_sym
+      end
+
+      def path
+        name.to_s.tr("/", "_")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Administrate
+  class Namespace
+    def initialize(namespace)
+      @namespace = namespace.to_sym
+    end
+
+    def resources
+      @resources ||= routes.map(&:first).uniq.map do |path|
+        Resource.new(namespace, path)
+      end
+    end
+
+    def routes
+      @routes ||= begin
+        prefix = "#{namespace}/".freeze
+        Rails.application.routes.routes.filter_map do |route|
+          next unless route.defaults[:controller]&.start_with?(prefix)
+
+          [
+            route.defaults[:controller].delete_prefix(prefix),
+            route.defaults[:action]
+          ]
+        end
+      end
+    end
+
+    def resources_with_index_route
+      routes.select { |_resource, route| route == "index" }.map(&:first).uniq
+    end
+
+    private
+
+    attr_reader :namespace
+  end
+end

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

@@ -0,0 +1,20 @@
+module Administrate
+  class NotAuthorizedError < StandardError
+    def initialize(action:, resource:)
+      @action = action
+      @resource = resource
+
+      case resource
+      when String, Symbol
+        super("Not allowed to perform #{action.inspect} on #{resource.inspect}")
+      when Module
+        super("Not allowed to perform #{action.inspect} on #{resource.name}")
+      else
+        super(
+          "Not allowed to perform #{action.inspect} on the given " +
+            resource.class.name
+        )
+      end
+    end
+  end
+end