activeadmin_addons_rails6 1.7.2

data/lib/activeadmin_addons/support/custom_builder.rb

@@ -0,0 +1,91 @@
+module ActiveAdminAddons
+  class CustomBuilder
+    attr_accessor :context, :model, :args, :block
+
+    def initialize(context, model, *args, &block)
+      @context = context
+      @model = model
+      @args = *args
+      @block = block
+    end
+
+    def render
+      raise NotImplementedError
+    end
+
+    def self.create_view_methods
+      builder_class = self
+      builder_name = builder_method_name
+
+      ::ActiveAdmin::Views::TableFor.class_eval do
+        define_method("#{builder_name}_column") do |*args, &block|
+          column(*args) { |model| builder_class.new(self, model, *args, &block).render }
+        end
+      end
+
+      ::ActiveAdmin::Views::AttributesTable.class_eval do
+        define_method("#{builder_name}_row") do |*args, &block|
+          row(*args) { |model| builder_class.new(self, model, *args, &block).render }
+        end
+      end
+    end
+
+    def self.builder_method_name
+      name.underscore.to_s.split("/").last.chomp("_builder")
+    end
+
+    protected
+
+    def resource_url
+      admin_resource&.route_instance_path(model, {})
+    end
+
+    def enabled_controller_action?(action)
+      admin_controller_actions.include?(action)
+    end
+
+    def admin_controller_actions
+      (admin_controller&.action_methods&.to_a || []).map(&:to_sym)
+    end
+
+    def admin_controller
+      context&.controller
+    end
+
+    def admin_resource
+      context.active_admin_resource_for(model.class)
+    end
+
+    def data
+      @data ||= block ? block.call(model) : model.send(attribute)
+    end
+
+    def options
+      @options ||= has_opts? ? args.last : {}
+    end
+
+    def class_name
+      model.model_name.param_key
+    end
+
+    # attachment_column :foto
+    # attachment_column :foto, style: :hola
+    # attachment_column "Mi Foto", :foto
+    # attachment_column "Mi Foto", :foto, {}
+    # attachment_column :foto do
+    # end
+    def attribute
+      @attribute ||= has_label? ? args[1] : args[0]
+    end
+
+    def has_label?
+      has_opts? ? args.length == 3 : args.length == 2
+    end
+
+    def has_opts?
+      @has_opts ||= args.last.is_a?(Hash)
+    end
+
+    create_view_methods
+  end
+end

data/lib/activeadmin_addons/support/enumerize_formtastic_support.rb

@@ -0,0 +1,18 @@
+module ActiveAdminAddons
+  module RansackFormBuilderExtension
+    def input(method, options = {})
+      if object.is_a?(::Ransack::Search)
+        klass = object.klass
+
+        if klass.respond_to?(:enumerized_attributes) && (attr = klass.enumerized_attributes[method])
+          options[:collection] ||= attr.options
+          options[:as] = :select
+        end
+      end
+
+      super(method, options)
+    end
+  end
+end
+
+::Formtastic::FormBuilder.send :prepend, ActiveAdminAddons::RansackFormBuilderExtension

data/lib/activeadmin_addons/support/input_base.rb

@@ -0,0 +1,53 @@
+require_relative "input_helpers/input_options_handler"
+require_relative "input_helpers/input_methods"
+require_relative "input_helpers/input_html_helpers"
+
+module ActiveAdminAddons
+  class InputBase < Formtastic::Inputs::StringInput
+    include InputOptionsHandler
+    include InputMethods
+    include InputHtmlHelpers
+
+    def to_html
+      load_input_class
+      load_control_attributes
+      render_custom_input
+      if parts.any?
+        return input_wrapping { parts_to_html }
+      else
+        super
+      end
+    end
+
+    def input_html_options
+      # maxwidth and size are added by Formtastic::Inputs::StringInput
+      # but according to the HTML standard these are not valid attributes
+      # on the inputs provided by this module
+      super.except(:maxlength, :size).merge(control_attributes)
+    end
+
+    def parts_to_html
+      parts.flatten.join("\n").html_safe
+    end
+
+    def load_input_class
+      load_class(self.class.to_s.underscore.dasherize)
+    end
+
+    def load_control_attributes
+      # Override on child classes if needed
+    end
+
+    def render_custom_input
+      # Override on child classes if needed
+    end
+
+    def parts
+      @parts ||= []
+    end
+
+    def concat(part)
+      parts << part
+    end
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/filter_input.rb

@@ -0,0 +1,8 @@
+require_relative "filter_input_methods"
+
+module ActiveAdminAddons
+  module FilterInput
+    include ActiveAdmin::Inputs::Filters::Base
+    include FilterInputMethods
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/filter_input_methods.rb

@@ -0,0 +1,32 @@
+require_relative "input_methods"
+
+module ActiveAdminAddons
+  module FilterInputMethods
+    include InputMethods
+
+    def object_class
+      valid_object.klass
+    end
+
+    def input_value
+      result = valid_object.conditions.find do |condition|
+        condition.attributes.map(&:name).include?(valid_method.to_s)
+      end
+
+      return unless result
+      result.values.first.value
+    end
+
+    def eq_input_name
+      "#{valid_method}_eq"
+    end
+
+    def gteq_input_name
+      "#{method}_gteq"
+    end
+
+    def lteq_input_name
+      "#{method}_lteq"
+    end
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/input_html_helpers.rb

@@ -0,0 +1,43 @@
+module ActiveAdminAddons
+  module InputHtmlHelpers
+    include InputMethods
+
+    def prefixed_method
+      "#{model_name}_#{valid_method}"
+    end
+
+    def method_to_input_name
+      "#{model_name}[#{valid_method}]"
+    end
+
+    def method_to_input_array_name
+      "#{method_to_input_name}[]"
+    end
+
+    def method_to_input_id(id)
+      raise "invalid input id" if id.blank?
+      "#{prefixed_method}_#{id}"
+    end
+
+    def selected_values_id
+      "#{prefixed_method}_selected_values"
+    end
+
+    def empty_input_id
+      "#{prefixed_method}_empty"
+    end
+
+    def build_separator
+      template.content_tag(:span, "-", class: "separator")
+    end
+
+    def build_hidden_control(id, name, value = nil)
+      builder.hidden_field(
+        valid_method,
+        id: id,
+        name: name,
+        value: value
+      )
+    end
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/input_methods.rb

@@ -0,0 +1,67 @@
+module ActiveAdminAddons
+  module InputMethods
+    def model_name
+      valid_object.class.to_s.underscore.tr('/', '_')
+    end
+
+    def valid_method
+      raise "invalid method given" if method.blank?
+      method
+    end
+
+    def valid_object
+      raise "blank object given" if @object.blank?
+      @object
+    end
+
+    def object_class
+      valid_object.class
+    end
+
+    def association_name
+      valid_method.to_s.singularize.chomp("_id")
+    end
+
+    def method_model
+      @options[:method_model] ||
+        object_class.reflect_on_association(association_name).try(:klass) ||
+        association_name.classify.constantize
+    end
+
+    def tableize_method
+      association_name.tableize
+    end
+
+    def input_related_items
+      valid_object.send(tableize_method)
+    rescue NoMethodError
+      raise "no association called #{tableize_method} on #{model_name} model"
+    end
+
+    def input_value
+      @input_value ||= valid_object.send(valid_method)
+    end
+
+    def translated_method
+      valid_object.class.human_attribute_name(valid_method)
+    end
+
+    def url_from_method
+      url = ["/"]
+
+      if ActiveAdmin.application.default_namespace.present?
+        url << "#{ActiveAdmin.application.default_namespace}/"
+      end
+
+      url << tableize_method
+      url.join("")
+    end
+
+    def build_virtual_attr
+      attribute_name = "virtual_#{valid_method}_attr"
+      fail "#{attribute_name} is already defined" if valid_object.respond_to?(attribute_name)
+      valid_object.singleton_class.send(:attr_accessor, attribute_name)
+      attribute_name
+    end
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/input_options_handler.rb

@@ -0,0 +1,90 @@
+module ActiveAdminAddons
+  module InputOptionsHandler
+    def control_attributes
+      result = {}
+      result[:class] = css_classes.compact.join(" ") if css_classes.any?
+
+      data_attr_options.each do |attribute, item|
+        result[:data] ||= {}
+        result[:data][attribute] = formatted_option_value(item)
+      end
+
+      attr_options.each do |attribute, item|
+        result[attribute] = formatted_option_value(item)
+      end
+
+      result
+    end
+
+    def data_attr_options
+      @data_attr_options || {}
+    end
+
+    def attr_options
+      @attr_options || {}
+    end
+
+    def css_classes
+      @css_classes || []
+    end
+
+    def load_data_attr(attr_name, options = {})
+      @data_attr_options ||= {}
+      @data_attr_options[attr_name.to_sym] = load_option_attr(attr_name, options)
+    end
+
+    def load_attr(attr_name, options = {})
+      @attr_options ||= {}
+      @attr_options[attr_name.to_sym] = load_option_attr(attr_name, options)
+    end
+
+    def load_class(class_attr)
+      @css_classes ||= []
+      return if class_attr.blank?
+      class_attr = class_attr.strip
+      @css_classes << class_attr
+      class_attr
+    end
+
+    def get_data_attr_value(attr_name)
+      item = data_attr_options[attr_name.to_sym]
+      return unless item
+      item[:value]
+    end
+
+    private
+
+    def formatted_option_value(item)
+      return item[:value].send(item[:formatter]) if item[:formatter]
+      item[:value]
+    end
+
+    def load_option_attr(attr_name, options)
+      value = calculate_attr_value(attr_name, options)
+      item = { value: value }
+      item[:formatter] = options[:formatter] unless options[:formatter].blank?
+      item
+    end
+
+    def calculate_attr_value(attr_name, attr_options)
+      value = attr_options[:value] || @options[attr_name]
+
+      if !empty_value?(value)
+        if value.is_a?(Proc)
+          return template.instance_eval(&value)
+        else
+          return value
+        end
+      end
+
+      default_value = attr_options[:default]
+      return unless default_value
+      return default_value.call if default_value.is_a?(Proc)
+      default_value
+    end
+
+    def empty_value?(value)
+      value.nil? || value == ""
+    end
+  end
+end

data/lib/activeadmin_addons/support/input_helpers/select_helpers.rb

@@ -0,0 +1,89 @@
+module ActiveAdminAddons
+  module SelectHelpers
+    include InputMethods
+    include InputOptionsHandler
+
+    def array_to_select_options
+      selected_values = input_value.is_a?(Array) ? input_value : input_value.to_s.split(",")
+      array = collection.map(&:to_s) + selected_values
+      array.sort.map do |value|
+        option = { id: value, text: value }
+        option[:selected] = "selected" if selected_values.include?(value)
+        option
+      end.uniq
+    end
+
+    def initial_collection_to_select_options
+      initial_options = [[nil]] # add blank option
+      selected = selected_item
+
+      if selected
+        selected_option = item_to_select_option(selected)
+        initial_options << [selected_option[:text], selected_option[:id]]
+      end
+
+      initial_options
+    end
+
+    def collection_to_select_options
+      complete_collection = collection + selected_collection
+      complete_collection.map do |item|
+        option = item_to_select_option(item)
+        yield(item, option) if block_given?
+
+        if selected_collection.include?(item)
+          load_data_attr(:selected, value: option.dup, formatter: :to_json)
+          option[:selected] = "selected"
+        end
+
+        option
+      end.uniq
+    end
+
+    def item_to_select_option(item)
+      return unless item
+      {
+        id: item.send((valid_options[:value] || :id)),
+        text: item.send((valid_options[:display_name] || :name))
+      }
+    end
+
+    def active_record_select?
+      active_record_relation?(collection) &&
+        active_record_relation?(selected_collection)
+    rescue NameError
+      false
+    end
+
+    def selected_collection
+      @selected_collection ||= begin
+        if active_record_relation?(collection)
+          collection.model.where(id: input_value)
+        else
+          method_model.where(id: input_value)
+        end
+      end
+    end
+
+    def selected_item
+      @selected_item ||= selected_collection.first
+    end
+
+    private
+
+    def active_record_relation?(value)
+      klass = value.class.name
+      klass == "ActiveRecord::Relation" ||
+        klass == "ActiveRecord::Associations::CollectionProxy"
+    end
+
+    def valid_options
+      raise "missing @options hash" unless !!@options
+      @options
+    end
+
+    def collection
+      valid_options[:collection] || []
+    end
+  end
+end