module InheritedResources::UrlHelpers

URLHelpers

When you use InheritedResources it creates some UrlHelpers for you. And they handle everything for you.

# /posts/1/comments
resource_url          # => /posts/1/comments/#{@comment.to_param}
resource_url(comment) # => /posts/1/comments/#{comment.to_param}
new_resource_url      # => /posts/1/comments/new
edit_resource_url     # => /posts/1/comments/#{@comment.to_param}/edit
collection_url        # => /posts/1/comments
parent_url            # => /posts/1

# /projects/1/tasks
resource_url          # => /projects/1/tasks/#{@task.to_param}
resource_url(task)    # => /projects/1/tasks/#{task.to_param}
new_resource_url      # => /projects/1/tasks/new
edit_resource_url     # => /projects/1/tasks/#{@task.to_param}/edit
collection_url        # => /projects/1/tasks
parent_url            # => /projects/1

# /users
resource_url          # => /users/#{@user.to_param}
resource_url(user)    # => /users/#{user.to_param}
new_resource_url      # => /users/new
edit_resource_url     # => /users/#{@user.to_param}/edit
collection_url        # => /users
parent_url            # => /

The nice thing is that those urls are not guessed during runtime. They are all created when you inherit.

Protected Instance Methods

create_resources_url_helpers!() click to toggle source

This method hard code url helpers in the class.

We are doing this because is cheaper than guessing them when our action is being processed (and even more cheaper when we are using nested resources).

When we are using polymorphic associations, those helpers rely on polymorphic_url Rails helper.

# File lib/inherited_resources/url_helpers.rb, line 48
def create_resources_url_helpers!
  resource_segments, resource_ivars = [], []
  resource_config = self.resources_configuration[:self]

  singleton   = resource_config[:singleton]
  uncountable = !singleton && resource_config[:route_collection_name] == resource_config[:route_instance_name]
  polymorphic = self.parents_symbols.include?(:polymorphic)

  # Add route_prefix if any.
  unless resource_config[:route_prefix].blank?
    if polymorphic
      resource_ivars << resource_config[:route_prefix]
    else
      resource_segments << resource_config[:route_prefix]
    end
  end

  # Deal with belongs_to associations and polymorphic associations.
  # Remember that we don't have to build the segments in polymorphic cases,
  # because the url will be polymorphic_url.
  #
  self.parents_symbols.each do |symbol|
    if symbol == :polymorphic
      resource_ivars << :parent
    else
      config = self.resources_configuration[symbol]
      if config[:singleton] && polymorphic
        resource_ivars << config[:instance_name]
      else
        resource_segments << config[:route_name]
      end
      if !config[:singleton]
        resource_ivars    << :"@#{config[:instance_name]}"
      end
    end
  end

  collection_ivars    = resource_ivars.dup
  collection_segments = resource_segments.dup

  # Generate parent url before we add resource instances.
  unless parents_symbols.empty?
    generate_url_and_path_helpers nil,   :parent, resource_segments, resource_ivars
    generate_url_and_path_helpers :edit, :parent, resource_segments, resource_ivars
  end

  # In singleton cases, we do not send the current element instance variable
  # because the id is not in the URL. For example, we should call:
  #
  #   project_manager_url(@project)
  #
  # Instead of:
  #
  #   project_manager_url(@project, @manager)
  #
  # Another exception in singleton cases is that collection url does not
  # exist. In such cases, we create the parent collection url. So in the
  # manager case above, the collection url will be:
  #
  #    project_url(@project)
  #
  # If the singleton does not have a parent, it will default to root_url.
  #
  collection_segments << resource_config[:route_collection_name] unless singleton
  resource_segments   << resource_config[:route_instance_name]
  resource_ivars      << :"@#{resource_config[:instance_name]}" unless singleton

  # Finally, polymorphic cases we have to give hints to the polymorphic url
  # builder. This works by attaching new ivars as symbols or records.
  #
  if polymorphic && singleton
    resource_ivars << resource_config[:instance_name]
    new_ivars       = resource_ivars
  end

  # If route is uncountable then add "_index" suffix to collection index route name
  if uncountable
    collection_segments << :"#{collection_segments.pop}_index"
  end

  generate_url_and_path_helpers nil,   :collection, collection_segments, collection_ivars
  generate_url_and_path_helpers :new,  :resource,   resource_segments,   new_ivars || collection_ivars
  generate_url_and_path_helpers nil,   :resource,   resource_segments,   resource_ivars
  generate_url_and_path_helpers :edit, :resource,   resource_segments,   resource_ivars

  if resource_config[:custom_actions]
    [*resource_config[:custom_actions][:resource]].each do | method |
      generate_url_and_path_helpers method, :resource, resource_segments, resource_ivars
    end
    [*resource_config[:custom_actions][:collection]].each do | method |
      generate_url_and_path_helpers method, :resources, collection_segments, collection_ivars
    end
  end
end
define_helper_method(prefix, name, suffix, segments) click to toggle source
# File lib/inherited_resources/url_helpers.rb, line 230
def define_helper_method(prefix, name, suffix, segments)
  method_name = [prefix, name, suffix].compact.join('_')
  params_method_name = ['', prefix, name, :params].compact.join('_')
  segments_method = [prefix, segments, suffix].compact.join('_')

  undef_method method_name if method_defined? method_name

  define_method method_name do |*given_args|
    given_args = send params_method_name, *given_args
    send segments_method, *given_args
  end
  protected method_name
end
define_params_helper(prefix, name, singleton, polymorphic, parent_index, ivars) click to toggle source
# File lib/inherited_resources/url_helpers.rb, line 196
def define_params_helper(prefix, name, singleton, polymorphic, parent_index, ivars)
  params_method_name = ['', prefix, name, :params].compact.join('_')

  undef_method params_method_name if method_defined? params_method_name

  define_method params_method_name do |*given_args|
    given_args = given_args.collect { |arg| arg.respond_to?(:permitted?) ? arg.to_h : arg }
    given_options = given_args.extract_options!

    args = ivars.map do |ivar|
      ivar.is_a?(Symbol) && ivar.to_s.start_with?('@') ? instance_variable_get(ivar) : ivar
    end
    args[parent_index] = parent if parent_index

    if !(singleton && name != :parent) && args.present? && name != :collection && prefix != :new
      resource = args.pop
      args.push(given_args.first || resource)
    end

    if polymorphic
      if name == :collection
        args[parent_index] = given_args.present? ? given_args.first : parent
      end
      if (name == :collection || name == :resource && prefix == :new) && !singleton
        args << (@_resource_class_new ||= resource_class.new)
      end
      args.compact! if self.resources_configuration[:polymorphic][:optional]
      args = [args]
    end
    args << given_options
  end
  protected params_method_name
end