respond_to with custom format aliasing json format, is this possible?

Question

I have a situation where I'm returning json objects to my application which are built from YML files. Because to parse the yml file and return it as json I always have to do something like this:

format.json { render json: YAML.load(render_to_string :file => File.join(Rails.root,'app','views','home','icons.yml.erb'), :layout => false ) }

I would like to make this operation shorter, by creating a custom format that (however) result in a json, so I don't want to create a new mime type.

My idea is to write:

format.myformat

Which will automatically search for myaction.myformat.erb inside views/mycontroller directory, and will automatically parse the yaml file returning it as a json object.

Is this possible? If yes, how can I eventually do this?

Edit 1: I found an important suggestion in config/mime_types.rb:

Mime::Type.register_alias "text/html", :iphone

So I can alias a mime type, now the biggest problem is: how to define the default render action for a given format, like format.html does?

If I write

format.html

current_action.html.erb will be automatically rendered, how can I choose the correct method to render a custom format?

Edit 2:

I managed to create this code (inside a controller, through some helper methods I built):

  def icons
    respond_to do |format|
      format.extjson { render_to_extjson }
    end
  end

Is possible to make rails understand that if I write:

  def icons
    respond_to do |format|
      format.extjson
    end
  end

it has to do:

format.extjson { render_to_extjson }

by default?

Answer 1

This is not doable at the moment, I read a lot of rails sources and there isn't a way to access that method, so isn't possible to customize it.

I'll write a rails plugin to support this and eventually I'll post it here, but for sure the answer actually is: this can't be done.

Answer 2

You could do something like:

respond_to do |format|
  format.html { @foo = Foo.all(:limit => 10) }
  format.any(:atom, :rss) { @foo = Foo.all }
end

A longer post going into the guts of the render actions can be found here: http://ryanbigg.com/2009/04/how-rails-works-2-mime-types-respond_to/

Answer 3

While Josh's answer is a valid one, I would rather see your parsing code wrapped up into an object. If you put that object into app/models, it'll be testable and you can always verify any change to the logic with a test suite.

Another upside to this is that you can re-use the format.json call and make you controller that much simpler.