Support nested belongs_to

[davidmathei]

Using belongs_to during registration of a resource naturally uses the "parent" as a scope for the "childs" overview. The childs controller expects a "parent_id" for the index page and the routes ar
e crafted accordingly.

As it stands, though, the "parent_id" is necessary for the overview but is not processed in all url's where it would be necessary.

Imagine a nesting of Continent, Country and City resources:

ActiveAdmin.register Continent do
  #...
end

ActiveAdmin.register Country do
  belongs_to :continent
end

ActiveAdmin.register City do
  belongs_to :country
end

Now the breadcrumb path shown while looking at a city or a city overview does not mention Continent (because it's parsed from the URL which does not contain that datapoint)
and the part linking to the country misses the continent_id. Following the link fails. I found a workaround at least for the breadcrumbs. Works for me, but is possibly not generalizable.

Adding a comment under a country or city fails in both cases: they only infer admin_city_path and admin_country_path respectively as targets, not admin_country_city_path etc. Would not work anyway because they are not given the extra parameter on invocation.

Finally the json/csv/xml exports ignore the parent relationship, I managed to work around that by monkeypatching but I'm not sure if that covers all families of URL's to be expected.

For the time being handling the comments is more problematic as the routes are defined during namespace registration.

Could it be that I'm on the wrong path using belongs_to? I can imaging that scope_to would work also, at the expense of adding the parent_id in al URL's which would fail also in the comment case.
Anyone else ran into this problem? Might also be the case that I overlooked something completely obvious ...

Cheers and thanks a lot so far!

download link fix:

class PaginatedCollection < ActiveAdmin::Component
   protected
   def build_download_format_links(formats = [:csv, :xml, :json])
      links = formats.collect do |format|
        #old: link_to format.to_s.upcase, { :format => format}.merge(request.query_parameters.except(:commit, :format))
        tmp_p = request.fullpath.split('?')
        new_path = tmp_p[0] + ".#{format}?" + tmp_p[1..-1].join('?') #the ugly fix
        link_to(format.to_s.upcase, new_path)
      end
      text_node [I18n.t('active_admin.download'), links].flatten.join("&nbsp;").html_safe
   end
end

The breadcrumb fix tries to establish the first notion of an instance mentioned in the path and works itself up along the belongs_to path.

[megatux]

Yes, we are seeing the same problem, some routes are not correctly generated.

[macfanatic]

Temprary workaround for the comment issue:

In app/timesheets.rb

ActiveAdmin.register Timesheet do
    controller do
        def comments
              @timesheet = Timesheet.find params[:id]
              redirect_to app_job_timesheet_path( @timesheet.job, @timesheet )
        end
    end
end

In routes.rb

    get 'app/timesheets/:id/comments', :to => 'app/timesheets#comments', :as => 'app_timesheet'

[reger]

I'm seeing the same problem, the routes don't seem to get built out all the way up the belongs_to relationships.

[alzeih]

I've written a hack to do this, this block below shows what I added to lib/active_admin/router.rb right after it sets up the parent route:

  # Add the next parent if it exists
  # This is horrible and should be done recursively
  if config.belongs_to? && config.belongs_to_config.target.belongs_to?
    routes_for_belongs_to_belongs_to = route_definition_block.dup
    route_definition_block = Proc.new do
      # If its optional, make the normal resource routes
      instance_eval &routes_for_belongs_to_belongs_to if config.belongs_to_config.target.belongs_to_config.optional?

      # Make the nested belongs_to routes
      # :only is set to nothing so that we don't clobber any existing routes on the resource
      resources config.belongs_to_config.target.belongs_to_config.target.underscored_resource_name.pluralize, :only => [] do
        instance_eval &routes_for_belongs_to_belongs_to
      end
    end
  end

I'm sure this is possible to generalise so it will act recursively, but I don't have the ruby knowledge to do so. However this will add ONE extra level of nesting, and can add as many as you need if you duplicate it again and modify it a little.

Feel free to use this in creating a pull request once it's less of a hack - if someone gives me a hand I'll do it myself.

[alzeih]

I also tried to use inherited_resources Nested belongs to : https://github.com/josevalim/inherited_resources

ActiveAdmin.register City do
  belongs_to :country do
    belongs_to :continent
  end
end

but the resource_url is wrong in lots of places, so it's still not right, even though the routes are generated correctly above.

I've gotten as far as it's not setting the route properly using the inherited_resource's UrlHelpers - but I can't find how active_admin is setting (or not setting) the parents_symbols. I'm fairly certain it's to do with the belongs_to method in active_admin not being the one in inherited_resources so it doesn't understand the nesting.

[alzeih]

I've written the start of a patch for this ( https://github.com/alzeih/active_admin/compare/master...patch-2 ) but it has a couple of caveats that I think should be fixed before it is merged in:

It only uses the belongs_to :continent, :country syntax for now - another belongs_to or a block won't nest them like the inherited_resources syntax

(As above) The routes are only generated by one extra level.

[rzhw]

Having this would be fantastic. I'm currently having to use a link with an appended param akin to ?q[country_id_eq] in order to get users to a resource three levels down.

[davidmathei]

Here's what I did. It's a minor monkeypatch on AA's breadcrumbs function (I keep the old one as a fallback) and some recursive hierarchy-tracing, following belongs_to relations.

There is a lot of defensive coding which might be not necessary and it might be a bit terser. Pull my ears if you find mistakes or no-no's , mind though, that the solution depends strongly on innards of the AA namespaces and might not work for future versions.

This approach still relies on the url and tries to give a complete upward path for all :belongs_to parents
I removed all defensive coding below to keep it readable.

monkeypatch

 module ActiveAdmin::ViewHelpers::BreadcrumbHelper

  alias :old_breadcrumb_links :breadcrumb_links

  def breadcrumb_links(path=nil)
    path ||= request.fullpath
    parts = path.gsub(/^\//,'').split('/')
    crumbs = []
    crumbs = Extension::HierarchySolver.crumble(parts)
    if crumbs
      crumbs.pop if parts.last =~ /^\d$/
    else
      crumbs = old_breadcrumb_links(path)
    end
    crumbs
  end
end

lib/extension/hierarchy_solver

module Extension
  class HierarchySolver
    class << self
      include ActionView::Helpers::UrlHelper
      def crumble pa
        namespace        = pa.first
        first_class_desc = make_combination(pa).reverse.find{|p| p[1] =~ /\d/}
        first_class      = instantiate(*first_class_desc)
        crumbs = [link_to(namespace.titlecase,'/' + namespace)]
        chain = find_parent_chain(namespace,first_class)
        chain.each_with_index do |inst,index|
          if index > 0
            parent = chain[index-1]
            indexpath = '/' +  [namespace,parent.class.name.underscore.pluralize,parent.id,inst.class.name.underscore.pluralize].join('/')
          else
            indexpath = '/' + [namespace,inst.class.name.underscore.pluralize].join('/')
          end
          detailpath = "#{indexpath}/#{inst.id}"
          crumbs << link_to(inst.class.name.underscore.pluralize.titlecase,indexpath)
          crumbs << link_to((inst.respond_to?(:display_name)) ? inst.display_name.titlecase : inst.id, detailpath)
        end
        crumbs
     end
     #this only works if the belongs_to parent-attribute is named following conventions:
     def find_parent _ns,object
        @nss ||= ActiveAdmin.application.namespaces
         ns = @nss[_ns.to_sym]
         resource = ns.resources.find_by_key(object.class.name)
         return nil unless resource.belongs_to?
         target = resource.belongs_to_config.target.underscored_resource_name
         object.send(target.to_sym)
      end

    private
      def instantiate clazz,id
        begin
          parent_class = clazz.singularize.camelcase.constantize
          obj = parent_class.find(id.to_i)
        rescue
          nil
        end
      end
      def make_combination arr
        #["admin", "things", "2", "apples", "1", "edit"]
        #->  [["admin", "things"], ["things", "2"], ["apples", "1"]] etc ...
        arr.zip(arr.dup.push(nil)[1..-1]).select{|item| (item[0] =~ /\d/).nil? }
      end
    end
  end
end

[rzhw]

@davidmathei I tried out your monkey patch, but it seems that find_parent_chain is missing; I tried writing my own replacement, but failed:

  def find_parent_chain _ns,object
    result = []
    while 1
      parent = find_parent _ns,object
      if parent.nil?
        return nil if result.empty?
        return result
      end
      _ns = parent.belongs_to_config.target.underscored_resource_name
      result << object.send(_ns.to_sym)
      object = instantiate(_ns,resource.id)
    end
  end

(I end up getting undefined method belongs_to?' for nil:NilClass, which corresponds to the method find_parent's line return nil unless resource.belongs_to?)

[davidmathei]

Oops ... sorry ... I had to edit the code heavily to edit out some project specific things and have not tested the code in isolation. At least: thanks for trying :-)

Here is the missing function, using find_parent and calling itself recursively.

  def find_parent_chain _ns,object, chain = []
    if object
      find_parent_chain(_ns,find_parent(_ns,object),chain.push(object))
    else
      chain.reverse
    end
  end

[rzhw]

No more exception! Think I need to actually figure out how to use recursive methods properly some time...

It seems that the breadcrumbs don't seem to be right just yet (I'm three levels down and it shows HOME / Third-Level-Model), but I'll continue hacking at this code. Thanks for it :)

[rzhw]

Alright, I sadly gave up on that code, but I did find a temporary workaround through looking at #78 and #977.

You'll need to create routes manually, so with the OP's example, you'd write:

namespace :admin do
  resources :continents do
    resources :countries do
      resources :cities
    end
  end
end

In cities.rb, instead of a standard belongs_to, write this:

controller do
  nested_belongs_to :continents, :countries
end
menu false

And you're done. So for this to be fixed, there just needs to be proper auto-generation of routes for resources nested deeper than two levels; this explains why the menu false was needed, as you'll get the resource listed in the menu, and have routes like admin_cities generated.

I'm currently testing this with resources nested four levels deep, and it seems to be fine so far.

[alzeih]

@a2h - my patch above will generate the routes to three levels deep, and with some duplication can do as many as you need. I've been too busy to figure out how to make it work more generally for any levels of nesting, but I don't see it as impossible to do.

I'd rather use the inherited_resources methods (like nested_belongs_to) and have automatic route generation too, but I haven't figured out how to do that yet.

[PapePathe]

+1