James on Software

My friend Mina put together something similar for our purposes, only he also has some controller magic so that you can easily refer to a polymorphic resource's parent from the polymorphic resource's controller.

I've pointed him at your post so hopefully he'll comment with details.

Hi, sorry for the late reply.

While what I've done isn't as pluginized, I see that we've both re-invented the same wheel albeit sith slightly different conventions.

Basically I stuck with the notion of "parent" with these helpers in ApplicationController:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

  #
  # Returns a hash of parent => id pairs extracted from the nested URL params
  #
  def parents_hash

    # Caching
    if @parents_hash.nil?
      @parents_hash = {}
      request.path_parameters.each do |key, value|
        next unless key =~ /^(.+)_id$/
        @parents_hash[$1] = value.to_i
      end
    end
    
    return @parents_hash
    
  end

  #
  # Similar to parents_hash but returns an array of hashes (first element is oldest parent, then later.. etc)
  # Each array element is a hash containing :name, :id
  #
  def parents_array

    # Caching
    if @parents_array.nil? 
      hash = parents_hash
      @parents_array = []
      path_parts = request.path.split("/")
      path_parts.each do |part|
        next unless part =~ /^[a-z_]+$/
        singular = part.singularize or next
        next unless hash.has_key?(singular)
        @parents_array << {
          :name =>  singular,
          :id =>  hash[singular]
        }
      end
    end

    return @parents_array

  end

  #
  # Returns a parent object extracted from a nested URL
  # Takes an array index of depth (how far up parents to get) - defaults to -1 (most immediate)
  # Returns nil if no such parent exists
  def parent(level = -1)

    #Caching
    @parent ||= {}
    unless @parent.has_key?(level)
      if hash = parents_array[level]
        @parent[level] = hash[:name].classify.constantize.find(hash[:id])
      else
        @parent[level] = nil
      end
    end

    return @parent[level]

  end

  #
  # Returns an array of parent objects
  #
  def parents

    # Caching
    if @parents.nil?
      @parents = []
      parents_array.each_index do |i|
        @parents << parent(i)
      end
    end

    return @parents

  end

The bulk of the code above is to provide support for the parent(x) function which returns an ActiveRecord instance of parent X - x is optional and defaults to -1 which means for a url like this: http://domain.com/categories/20/posts/19 parent will return the AR instance of Category id 20

That in itself is awesomely helpful since in PostsController for example you can do:

1
2

def index
   (parent ? parent.posts : Post).find(:all)

Now on to the URL helpers I ended up creating a family of poly* URL generators (polypath/polyurl/polyppath/polypurl).. The ones with _p in their name automatically prepend parents defined above so you can generate a URL that automatically includes "your parents":

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

  #
  # The magic method to construct polymorphic urls
  # Takes any combination of:
  #   * Instances of AR: Adds /model_name_plural/instance_id
  #   * Symbols: Adds ;symbol_name
  #   * Strings: Adds /string
  #   * Arrays: Flattens and follows above rules
  #   * Hashes: Turns into query params
  #   * Anything else: Raises an error
  #
  def poly_path(*args)

    path = ""
    qs = {}

    args.flatten.each do |a|
      next if a.blank?
      if a.kind_of? ActiveRecord::Base
        path += "/" + a.class.to_s.pluralize.underscore + "/" + a.to_param
      elsif a.is_a? Symbol
        path += ";" + a.to_s
      elsif a.is_a? String
        path += "/" + a
      elsif a.is_a? Hash
        qs = qs.merge(a)
      else
        raise "Don't know how to handle #{a.class}"
      end
    end

    path = "/" + path unless path =~ /^\//
    path = path + qs.to_query_string unless qs.blank?

    return path
  end

  #
  # Same as poly_path but returns a URL instead of just a path
  #
  def poly_url(*args)
     request.protocol + request.host + request.port_string + poly_path(*args)
  end

  #
  # A shortcut to poly_path(parents, ...)
  #
  def poly_p_path(*args)
    poly_path(parents, args)
  end

  #
  # A shortcut to poly_url(parents, ...)
  #
  def poly_p_url(*args)
    poly_url(parents, args)
  end

When I have some time I'll check out your plugin and would happily post back delta features I find in common.

finally, I hope the blog keeps all the formatting above.. there's no preview comment.. here it goes.. :)

Have you looked at the ResourceFu plugin? I'm using it for polymorphic attendees to both webinars and training courses. I haven't found any documentation outside the readme but it works really well once you understand it.