activeadmin-rails 1.7.0

data/lib/active_admin/view_helpers/download_format_links_helper.rb

@@ -0,0 +1,58 @@
+module ActiveAdmin
+  module ViewHelpers
+    module DownloadFormatLinksHelper
+
+      def build_download_formats(download_links)
+        download_links = instance_exec(&download_links) if download_links.is_a?(Proc)
+
+        if download_links.is_a?(Array) && !download_links.empty?
+          download_links
+        elsif download_links == false
+          []
+        else
+          self.class.formats
+        end
+      end
+
+      def build_download_format_links(formats = self.class.formats)
+        params = request.query_parameters.except :format, :commit
+        div class: "download_links" do
+          span I18n.t('active_admin.download')
+          formats.each do |format|
+            a format.upcase, href: url_for(params: params, format: format)
+          end
+        end
+      end
+
+      def self.included base
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        # A ready only of formats to make available in index/paginated
+        # collection view.
+        # @return [Array]
+        # @see add_format for information on adding custom download link
+        # formats
+        def formats
+          @formats ||= [:csv, :xml, :json]
+          @formats.clone
+        end
+
+        # Adds a mime type to the list of available formats available for data
+        # export. You must register the extension prior to adding it here.
+        # @param [Symbol] format the mime type to add
+        # @return [Array] A copy of the updated formats array.
+        def add_format(format)
+          unless Mime::Type.lookup_by_extension format
+            raise ArgumentError, "Please register the #{format} mime type with `Mime::Type.register`"
+          end
+          @formats << format unless formats.include? format
+          formats
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/fields_for.rb

@@ -0,0 +1,50 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      # Flatten a params Hash to an array of fields.
+      #
+      # @param params [Hash]
+      # @param options [Hash] :namespace and :except
+      #
+      # @return [Array] of [Hash] with one element.
+      #
+      # @example
+      #   fields_for_params(scope: "all", users: ["greg"])
+      #     => [ {"scope" => "all"} , {"users[]" => "greg"} ]
+      #
+      def fields_for_params(params, options = {})
+        namespace = options[:namespace]
+        except    = Array.wrap(options[:except]).map &:to_s
+
+        params.flat_map do |k, v|
+          next if namespace.nil? && %w(controller action commit utf8).include?(k.to_s)
+          next if except.include?(k.to_s)
+
+          if namespace
+            k = "#{namespace}[#{k}]"
+          end
+
+          case v
+          when String
+            { k => v }
+          when Symbol
+            { k => v.to_s }
+          when Hash
+            fields_for_params(v, namespace: k)
+          when Array
+            v.map do |v|
+              { "#{k}[]" => v }
+            end
+          when nil
+            { k => '' }
+          when TrueClass, FalseClass
+            { k => v }
+          else
+            raise "I don't know what to do with #{v.class} params: #{v.inspect}"
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/active_admin/view_helpers/flash_helper.rb

@@ -0,0 +1,14 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FlashHelper
+
+      # Returns all the flash keys to display in any Active Admin view.
+      # This method removes the :timedout key that Devise uses by default.
+      # Note Rails >= 4.1 normalizes keys to strings automatically.
+      def flash_messages
+        @flash_messages ||= flash.to_hash.with_indifferent_access.except(*active_admin_application.flash_keys_to_except)
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/form_helper.rb

@@ -0,0 +1,20 @@
+module ActiveAdmin
+  module ViewHelpers
+    module FormHelper
+
+      def active_admin_form_for(resource, options = {}, &block)
+        Arbo::Context.new({}, self) do
+          active_admin_form_for resource, options, &block
+        end.render_in.html_safe
+      end
+
+      def hidden_field_tags_for(params, options = {})
+        fields_for_params(params.to_unsafe_hash, options).map do |kv|
+          k, v = kv.first
+          hidden_field_tag k, v, id: sanitize_to_id("hidden_active_admin_#{k}")
+        end.join("\n").html_safe
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/layout_helper.rb

@@ -0,0 +1,32 @@
+module ActiveAdmin
+  module ViewHelpers
+    module LayoutHelper
+
+      def action_items_for_action
+        if active_admin_config && active_admin_config.action_items?
+          active_admin_config.action_items_for(params[:action], self)
+        else
+          []
+        end
+      end
+
+      def body_classes
+        Arbo::HTML::ClassList.new [
+          params[:action],
+          params[:controller].tr('/', '_'),
+          'active_admin', 'logged_in',
+          active_admin_namespace.name.to_s + '_namespace'
+        ]
+      end
+
+      # Returns the sidebar sections to render for the current action
+      def sidebar_sections_for_action
+        if active_admin_config && active_admin_config.sidebar_sections?
+          active_admin_config.sidebar_sections_for(params[:action], self)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/view_helpers/method_or_proc_helper.rb

@@ -0,0 +1,97 @@
+module MethodOrProcHelper
+
+  # This method will either call the symbol on self or instance_exec the Proc
+  # within self. Any args will be passed along to the method dispatch.
+  #
+  # Calling with a Symbol:
+  #
+  #     call_method_or_exec_proc(:to_s) #=> will call #to_s
+  #
+  # Calling with a Proc
+  #
+  #     my_proc = Proc.new{ to_s }
+  #     call_method_or_exec_proc(my_proc) #=> will instance_exec in self
+  #
+  def call_method_or_exec_proc(symbol_or_proc, *args)
+    case symbol_or_proc
+    when Symbol, String
+      send(symbol_or_proc, *args)
+    when Proc
+      instance_exec(*args, &symbol_or_proc)
+    else
+      symbol_or_proc
+    end
+  end
+
+  # Many times throughout the views we want to either call a method on an object
+  # or instance_exec a proc passing in the object as the first parameter. This
+  # method wraps that pattern.
+  #
+  # Calling with a String or Symbol:
+  #
+  #     call_method_or_proc_on(@my_obj, :size) same as @my_obj.size
+  #
+  # Calling with a Proc:
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     call_method_or_proc_on(@my_obj, proc)
+  #
+  # By default, the Proc will be instance_exec'd within self. If you would rather
+  # not instance exec, but just call the Proc, then pass along `exec: false` in
+  # the options hash.
+  #
+  #     proc = Proc.new{|s| s.size }
+  #     call_method_or_proc_on(@my_obj, proc, exec: false)
+  #
+  # You can pass along any necessary arguments to the method / Proc as arguments. For
+  # example:
+  #
+  #     call_method_or_proc_on(@my_obj, :find, 1) #=> @my_obj.find(1)
+  #
+  def call_method_or_proc_on(receiver, *args)
+    options = { exec: true }.merge(args.extract_options!)
+
+    symbol_or_proc = args.shift
+
+    case symbol_or_proc
+    when Symbol, String
+      receiver.public_send symbol_or_proc.to_sym, *args
+    when Proc
+      if options[:exec]
+        instance_exec(receiver, *args, &symbol_or_proc)
+      else
+        symbol_or_proc.call(receiver, *args)
+      end
+    else
+      symbol_or_proc
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This helper takes care of
+  # returning the content when String or call call_method_or_proc_on when Symbol or Proc.
+  #
+  def render_or_call_method_or_proc_on(obj, string_symbol_or_proc, options = {})
+    case string_symbol_or_proc
+    when Symbol, Proc
+      call_method_or_proc_on(obj, string_symbol_or_proc, options)
+    else
+      string_symbol_or_proc
+    end
+  end
+
+  # This method is different from the others in that it calls `instance_exec` on the receiver,
+  # passing it the proc. This evaluates the proc in the context of the receiver, thus changing
+  # what `self` means inside the proc.
+  def render_in_context(context, obj, *args)
+    context = self if context.nil? # default to `self` only when nil
+    case obj
+    when Proc
+      context.instance_exec *args, &obj
+    when Symbol
+      context.public_send obj, *args
+    else
+      obj
+    end
+  end
+end

data/lib/active_admin/view_helpers/scope_name_helper.rb

@@ -0,0 +1,16 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ScopeNameHelper
+
+      def scope_name(scope)
+        case scope.name
+        when Proc then
+          self.instance_exec(&scope.name).to_s
+        else
+          scope.name.to_s
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/sidebar_helper.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module ViewHelpers
+    module SidebarHelper
+
+      def skip_sidebar!
+        @skip_sidebar = true
+      end
+
+      def skip_sidebar?
+        @skip_sidebar == true
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/title_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module TitleHelper
+
+      def title(_title)
+        @page_title = _title
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers/view_factory_helper.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module ViewHelpers
+    module ViewFactoryHelper
+
+      def view_factory
+        active_admin_namespace.view_factory
+      end
+
+    end
+  end
+end

data/lib/active_admin/view_helpers.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module ViewHelpers
+
+    # Require all ruby files in the view helpers dir
+    Dir[File.expand_path('../view_helpers', __FILE__) + "/*.rb"].each{|f| require f }
+
+    include ActiveAdminApplicationHelper
+    include AutoLinkHelper
+    include BreadcrumbHelper
+    include DisplayHelper
+    include LayoutHelper
+    include MethodOrProcHelper
+    include SidebarHelper
+    include FormHelper
+    include TitleHelper
+    include ViewFactoryHelper
+    include FlashHelper
+    include ScopeNameHelper
+
+  end
+end

data/lib/active_admin/views/components/action_link.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module Views
+    class ActionLink < Arbo::HTML::Span
+      builder_method :action_link
+
+      def build(name, path, options = {})
+        @tag_name = 'span'
+        set_attribute(:class, :action_item)
+        text_node link_to(localizer.t(name), path, options)
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/active_admin_form.rb

@@ -0,0 +1,163 @@
+module ActiveAdmin
+  module Views
+    class FormtasticProxy < ::Arbo::Rails::Forms::FormBuilderProxy
+      def split_string_on(string, match)
+        return "" unless string && match
+        part_1 = string.split(Regexp.new("#{match}\\z")).first
+        [part_1, match]
+      end
+
+      def opening_tag
+        @opening_tag || ""
+      end
+
+      def closing_tag
+        @closing_tag || ""
+      end
+
+      def render_in(context = arbo_context)
+        pos = context.output_buffer.length
+        context.output_buffer << opening_tag.html_safe
+        children.map { |element| element.render_in(context) }
+        context.output_buffer << closing_tag.html_safe
+        pos > 0 ? context.output_buffer.to_str[pos..] : context.output_buffer
+      end
+
+      def to_s
+        opening_tag + children.to_s + closing_tag
+      end
+    end
+
+    class ActiveAdminForm < FormtasticProxy
+      builder_method :active_admin_form_for
+
+      def build(resource, options = {}, &block)
+        @resource = resource
+        options = options.deep_dup
+        options[:builder] ||= ActiveAdmin::FormBuilder
+        form_string = helpers.semantic_form_for(resource, options) do |f|
+          @form_builder = f
+        end
+
+        @opening_tag, @closing_tag = split_string_on(form_string, "</form>")
+        instance_eval(&block) if block_given?
+
+        # Rails sets multipart automatically if a file field is present,
+        # but the form tag has already been rendered before the block eval.
+        if multipart? && @opening_tag !~ /multipart/
+          @opening_tag.sub!(/<form/, '<form enctype="multipart/form-data"')
+        end
+      end
+
+      def inputs(*args, &block)
+        if block_given?
+          form_builder.template.assigns[:has_many_block] = true
+        end
+        if block_given? && block.arity == 0
+          wrapped_block = proc do
+            wrap_it = form_builder.already_in_an_inputs_block ? true : false
+            form_builder.already_in_an_inputs_block = true
+            content = form_builder.template.capture do
+              block.call
+            end
+            form_builder.already_in_an_inputs_block = wrap_it
+            content
+          end
+          insert_tag(SemanticInputsProxy, form_builder, *args, &wrapped_block)
+        else
+          # Set except option to prevent sensitive fields from being shown in forms by default.
+          opts = args.extract_options!
+          opts[:except] ||= []
+          ActiveAdmin.application.filter_attributes.each { |e| opts[:except] << e }
+          args << opts
+
+          proxy_call_to_form(:inputs, *args, &block)
+        end
+      end
+
+      def input(*args)
+        proxy_call_to_form :input, *args
+      end
+
+      def actions(*args, &block)
+        block_given? ?
+          insert_tag(SemanticActionsProxy, form_builder, *args, &block) :
+          actions(*args) { commit_action_with_cancel_link }
+      end
+
+      def commit_action_with_cancel_link
+        add_create_another_checkbox
+        action(:submit)
+        cancel_link
+      end
+
+      def add_create_another_checkbox
+        if %w(new create).include?(helpers.action_name) && active_admin_config && active_admin_config.create_another
+          current_arbo_element.add_child(create_another_checkbox)
+        end
+      end
+
+      def has_many(*args, &block)
+        insert_tag(HasManyProxy, form_builder, *args, &block)
+      end
+
+      def multipart?
+        form_builder && form_builder.multipart?
+      end
+
+      def object
+        form_builder.object
+      end
+
+      def form_buffers
+        raise "'form_buffers' has been removed from ActiveAdmin::FormBuilder, please read https://github.com/varyonic/activeadmin/blob/main/docs/5-forms.md for details."
+      end
+
+      private
+
+      def create_another_checkbox
+        create_another = params[:create_another]
+        label = @resource.class.model_name.human
+        Arbo::Context.new do
+          li class: 'create_another' do
+            input(
+              checked: create_another,
+              id: 'create_another',
+              name: 'create_another',
+              type: 'checkbox'
+            )
+            label(I18n.t('active_admin.create_another', model: label), for: 'create_another')
+          end
+        end
+      end
+    end
+
+    class SemanticInputsProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        html_options = args.extract_options!
+        html_options[:class] ||= "inputs"
+        legend = args.shift if args.first.is_a?(::String)
+        legend = html_options.delete(:name) if html_options.key?(:name)
+        legend_tag = legend ? "<legend><span>#{legend}</span></legend>" : ""
+        fieldset_attrs = html_options.map {|k, v| %Q{#{k}="#{v}"} }.join(" ")
+        @opening_tag = "<fieldset #{fieldset_attrs}>#{legend_tag}<ol>"
+        @closing_tag = "</ol></fieldset>"
+        super(*(args << html_options), &block)
+      end
+    end
+
+    class SemanticActionsProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        @opening_tag = "<fieldset class=\"actions\"><ol>"
+        @closing_tag = "</ol></fieldset>"
+        super(*args, &block)
+      end
+    end
+
+    class HasManyProxy < FormtasticProxy
+      def build(form_builder, *args, &block)
+        text_node form_builder.has_many(*args, &block)
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/attributes_panel.rb

@@ -0,0 +1,23 @@
+module ActiveAdmin
+  module Views
+
+    class AttributesPanel < ActiveAdmin::Component
+      builder_method :attributes_panel
+      builder_method :attributes_table # TODO: deprecate
+
+      def build(*args, &block)
+        opts = args.extract_options!
+        table_title = if opts.has_key?(:title)
+                        render_or_call_method_or_proc_on(resource, opts[:title])
+                      else
+                        ActiveAdmin::Localizers.resource(active_admin_config).t(:details)
+                      end
+        resource_columns = args.present? ? args : active_admin_config.resource_columns
+        panel(table_title) do
+          attributes_table_for(resource, *resource_columns, &block)
+          active_admin_comments_for(resource) if active_admin_config.comments?
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/views/components/attributes_table.rb

@@ -0,0 +1,94 @@
+module ActiveAdmin
+  module Views
+
+    class AttributesTable < ActiveAdmin::Component
+      builder_method :attributes_table_for
+
+      def build(obj, *attrs)
+        @collection     = Array.wrap(obj)
+        @resource_class = @collection.first.class
+        options = { }
+        options[:for] = @collection.first if single_record?
+        super(options)
+        @table = table
+        build_colgroups
+        rows(*attrs)
+      end
+
+      def rows(*attrs)
+        attrs.each {|attr| row(attr) }
+      end
+
+      def row(*args, &block)
+        title   = args[0]
+        options = args.extract_options!
+        classes = [:row]
+        if options[:class]
+          classes << options[:class]
+        elsif title.present?
+          classes << "row-#{title.to_s.parameterize(separator: "_")}"
+        end
+        options[:class] = classes.join(' ')
+
+        @table << tr(options) do
+          th do
+            header_content_for(title)
+          end
+          @collection.each do |record|
+            td do
+              content_for(record, block || title)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def default_id_for_prefix
+        'attributes_table'
+      end
+
+      # Build Colgroups
+      #
+      # Colgroups are only necessary for a collection of records; not
+      # a single record.
+      def build_colgroups
+        return if single_record?
+        reset_cycle(self.class.to_s)
+        within @table do
+          col # column for row headers
+          @collection.each do |record|
+            classes = Arbo::HTML::ClassList.new
+            classes << cycle(:even, :odd, name: self.class.to_s)
+            classes << dom_class_name_for(record)
+            col(id: dom_id_for(record), class: classes)
+          end
+        end
+      end
+
+      def header_content_for(attr)
+        if @resource_class.respond_to?(:human_attribute_name)
+          @resource_class.human_attribute_name(attr, default: attr.to_s.titleize)
+        else
+          attr.to_s.titleize
+        end
+      end
+
+      def empty_value
+        span I18n.t('active_admin.empty'), class: "empty"
+      end
+
+      def content_for(record, attr)
+        value = helpers.format_attribute record, attr
+        value.blank? && current_arbo_element.children.to_s.empty? ? empty_value : value
+        # Don't add the same Arbre twice, while still allowing format_attribute to call status_tag
+        current_arbo_element << value unless current_arbo_element.children.include? value
+      end
+
+      def single_record?
+        @single_record ||= @collection.size == 1
+      end
+    end
+
+  end
+end

data/lib/active_admin/views/components/blank_slate.rb

@@ -0,0 +1,17 @@
+module ActiveAdmin
+  module Views
+    # Build a Blank Slate
+    class BlankSlate < ActiveAdmin::Component
+      builder_method :blank_slate
+
+      def default_class_name
+        'blank_slate_container'
+      end
+
+      def build(content)
+        super(span(content.html_safe, class: "blank_slate"))
+      end
+
+    end
+  end
+end