Ananke

Ananke is a DSL that extends the functionality of Sinatra for easy creation of Restful Services and Resources:

#myapp.rb
require 'sinatra/base'
require 'sinatra/ananke'

resource :user do
all do
  [{:id => ]
end
end

Install the gem and run with:

gem install ananke
ruby myapp.rb

All Users http://localhost:4567/user One User http://localhost:4567/user/1

REST Resources

route defines a complete Resource, and constructs Sinatra Routes based on what's available in it's respective Repository. Routes are:

get     '/name/?'   -> Repository::Capitalize(name).all
get     '/name/id'  -> Repository::Capitalize(name).one(id)
post    '/name'     -> Repository::Capitalize(name).new(data)
put     '/name/id'  -> Repository::Capitalize(name).edit(id, data)
delete  '/name/id'  -> Repository::Capitalize(name).delete(id)

Repositories

The Default Repository can be changed:

ananke.default_repository = 'MyRepository'

HyperMedia

Linked

route :user do
id :id
linked :computer
end

module Repository
module User
  def self.one(id)
    [Return User for User Id]
  end
  def self.computer_id_list(id)
    [Return an array of single value id's]
  end
end
end

Repository Method:

[ResourceRepository].[linked name]_id_list

Routes Available/Registered:

/user/:id

Output:

{
user: {
        user_id: "1"
        name: "One"
      }
links:  [
          {
            rel: "self"
            uri: "/user/1"
          },
          {
            rel: "computer"
            uri: "/computer/2"
          }
        ]
}

The Respository for User needs to have a method that returns an array of id's for use in the HyperMedia links. The link to Self uses this method. The output will be something like this:

Link To and Route For

route :user do
id :id
link_to :car
end
route :car do
id :id
route_for :user
end

module Repository
module User
  def self.one(id)
    [Return User for User Id]
  end
end
module Car
  def self.user(id)
    [Return List of Cars for User Id]
  end
end
end

Routes Available/Registered:

/user/:id
/car/user/:id

Output:

{
user: {
        user_id: "1"
        name: "One"
      }
links:  [
          {
            rel: "self"
            uri: "/user/1"
          },
          {
            rel: "computer"
            uri: "/computer/user/1"
          }
        ]
}

This way of linking solves a lot of problems, and can also be used for searching support. route_for supports an optional 2nd parameter to specify the type of request it must register for:

route :car do
id :id
route_for :user, :post
end

The Called Repository can also have multiple input paramaters:

def some_method(id, name, email)
...
end

will need an incoming Request with these paramaters:

id, name, email

Media Type

The REST media type can be built up:

required :name
optional :country

Exposing the Media Type is on the cards.

Validation

Validation can be added on any field by providing arguments after a field declaration:

required :name, :length => 4

This will cause the paramater to be validated against the method defined in Ananke::Rules. Custom Rules can be added to the module and provided as arguments. Current Default included rules are:

length(min)

Validation Methods are Invoked in the Ananke::Rules context, and has access to a class variable named value, which holds the value for the currently valuated Parameter.

To Add a Custom Rule:

rule :name, do
value == [expected] ? nil : 'Not Expected Value'
end

required :name, :name

module Ananke
module Rules
  def validate_name
    value == [expected] ? nil : 'Not Expected Value'
  end
end
end

required :name, :name

or Advanced

module Ananke
module Rules
  def validate_name(extra)
    value == [expected using extra] ? nil : 'Not Expected Value'
  end
end
end

required :name, :name => extra

Future

A short list of future development:

- Refactor!
- Return Value Strategy
- Resource Exposes Media Type
- Lots more `bullet-proofing`
- ETag Support