Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
A little DSL for consuming RESTful web services.
tag: v0.6.0

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.


The Weary need REST

Weary is a tiny DSL for making the consumption of RESTful web services simple. It is the little brother to HTTParty. It provides a thin, gossamer-like layer over the Net/HTTP library.

The things it do:

  • Quickly build an interface to your favorite REST API.
  • Parse XML and JSON with the Crack library.
  • Authenticate, basically, with Basic Authentication.
  • Consume with OAuth

Browse the documentation here: Peruse the Wiki to discover libraries built with Weary and a more thorough review of the API.



You do have Rubygems right? You do use Gemcutter, right?

gem install weary

Quick Start

class TwitterUser < Weary::Base

    domain ""

    get "show" do |resource|
        resource.with = [:id, :user_id, :screen_name]

user =
me = => "markwunsch").perform
puts me["name"]

Hey, that's me!

How it works

Create a class that inherits from Weary::Base to give it methods to craft a resource request:

class Foo < Weary::Base

    declare "foo" do |resource|
        resource.url = "http://path/to/foo"

If you instantiate this class, you'll get an instance method named foo that crafts a GET request to "http://path/to/foo"

Besides the name of the resource, you can also give declare_resource a block like:

declare "foo" do |r|
    r.url = "path/to/foo"
    r.via = :post                           # defaults to :get
    r.requires = [:id, :bar]                # an array of params that the resource requires to be in the query/body
    r.with = [:blah]                        # an array of params that you can optionally send to the resource
    r.authenticates = false                 # does the method require authentication? defaults to false
    r.follows = false                       # if this is set to false, the formed request will not follow redirects.
    r.headers = {'Accept' => 'text/html'}   # send custom headers. defaults to nil.

So this would form a method:

x = => "mwunsch", :bar => 123)

That method would return a Weary::Request object. Use the perform method and get a Weary::Response that you could parse and/or examine.

Parsing the Body

Once you make your request with the fancy method that Weary created for you, you can do stuff with what it returns...which could be a good reason you're using Weary in the first place. Let's look at the above example:

x =
y = => "mwunsch", :bar => 123).perform.parse

Weary parses with Crack, but you're not beholden to it. You can get the raw Request body to have your way with:

x =
y = => "mwunsch", :bar => 123).perform

note: Weary used to have Nokogiri built in, using the #search method, but that was dropped.


Of course, you don't always have to use declare; that is a little too ambiguous. You can also use get, post, delete, etc. Those do the obvious.

Forming URLs

There are many ways to form URLs in Weary. You can define URLs for the entire class by typing:

class Foo < Weary::Base

    domain ""
    format :xml

    get "show_users"

If you don't supply a url when declaring the Resource, Weary will look to see if you've defined a domain, and will make a url for you. The above get declaration creates a url that looks like:

Weary DSL

You can create some defaults for all of our resources easily:

class Foo < Weary::Base

    def initialize(username,password)
        self.credentials username,password  #basic authentication
        self.defaults = {:user => username} #parameters that will be passed in every request     

    domain ""
    format :xml
    headers {'Accept' => 'text/html'}   # set headers

    post "update" {|r| r.authenticates = true}  # uses the defaults defined above!          

Then you can do something like this:

f ='me','secretz')

Which will create a POST Request for that will authenticate you, using basic authentication, with the username/password of "me"/"secrets" and will send the parameter {:user => "me"}. Easy.

There's more to discover in the Wiki.

Something went wrong with that request. Please try again.