How to serve the latest API through application mime - Rails - ruby-on-rails

Question

Consider the following
namespace :api, defaults: {format: 'json'} do
namespace :v1 do
resources :users
resources :profiles
end
namespace :v2 do
resources :users
resources :profiles
end
end
instead of routing to api/v1 and api/v2, what i would like is set the accept header to use which ever i want it to serve and use the path api neglecting the version.
So if i set it to serve api/v1 the path should just be localhost:3000/api
i was going through this railcasts video
http://railscasts.com/episodes/350-rest-api-versioning?autoplay=true
but looking in comments there are variable issues with the code and the solution at time.
What is the best solution at the moment?
Replies from that link
Each time you create a new MIME type name (application/vnd.example.v1, application/vnd.example.v2, ...),
a kitten is hurt! don't do that! that's bad!
Use MIME parameters instead: application/vnd.example; version=1, application/vnd.example; version=2, ...
(version=, or level=, or v= or whatever you want, this is part of your design).
The semantic of a MIME type is that every document "flagged" with that type share the same "lineage",
and that two different names are not related, even if they share a same prefix.
By incorporating a version identifier into the MIME type name,
you are making the names distinct and are in the same case as if your V1 API was using text/html documents
whereas your V2 now uses image/png pictures instead.
The problem with the default is it will accept any mime type, as it will only check the boolean and not the string:
#default || req.headers['Accept'].include?("application/vnd.example.v#{#version}")
I mean, if we're expecting "application/vnd.github.v1", it will also accept "application/vnd.twitter.v1"

Answer 1

I've used the approach described in that Railscast in several projects, and haven't had any problems with it. I think it is a really good and up to date solution.
Place this in your /lib directory:
class ApiConstraints
def initialize(options)
#version = options[:version]
#default = options[:default]
end
def matches?(req)
#default || req.headers['Accept'].include?("application/vnd.yourdomain.v#{#version}")
end
end
Then define your routes as follows:
namespace :api, defaults: {format: 'json'} do
scope module: :v1, constraints: ApiConstraints.new(version: 1) do
resources :users
resources :profiles
end
scope module: :v2, constraints: ApiConstraints.new(version: 2, default: true) do
resources :users
resources :profiles
end
end
You can now access the API with end points like:
https://www.yourdomain.com/api/users
https://www.yourdomain.com/api/profiles
Which will serve up version 2 by default.
Or you can set an Accepts header like:
Accept: application/vnd.yourdomain.v1
and you'll get version 1 instead.
What's wrong with that?