This document discusses Sinatra, a Ruby web application framework built with Rack middleware. It provides examples of basic Sinatra applications and routes, and discusses how Sinatra apps can also be used as Rack middleware. It promotes some projects by the author including Amnesia for Memcached stats, Munch for recipe search, and Postie for postcode services implemented as Rack middleware. It also discusses related tools like Shotgun for reloading and Rack middleware like Rack::Cache.

1. sinatra,
rack &
middleware
This is made “soon after” railsconf, so you’ll just have to deal with the railsconf references

2. sinatra,
rack &
middleware
Ben Schwarz
@benschwarz
http://github.com/benschwarz
This is made “soon after” railsconf, so you’ll just have to deal with the railsconf references

3. sinatra

4. from the top

5. ... is fucking sweet

6. DSL

7. Built on Rack
More on that later

8. Blake Mizerany
@bmizerany

9. Ever wondered what Blake Mizerany
looks like at 8 am after a huge
fucking bender in “old” vegas?

11. Eyyeaahh.

12. So, that DSL

13. heres an example of the most simple sinatra application you could probably make. The ‘get’
referrers to the HTTP verb. You should probably recognise this from rails land. The next part
is the “route”, here I’m just mapping the index / root. “erb :index” will render index.erb,
sinatra also has haml support out of the box.

14. heres an example of the most simple sinatra application you could probably make. The ‘get’
referrers to the HTTP verb. You should probably recognise this from rails land. The next part
is the “route”, here I’m just mapping the index / root. “erb :index” will render index.erb,
sinatra also has haml support out of the box.

15. heres an example of the most simple sinatra application you could probably make. The ‘get’
referrers to the HTTP verb. You should probably recognise this from rails land. The next part
is the “route”, here I’m just mapping the index / root. “erb :index” will render index.erb,
sinatra also has haml support out of the box.

16. heres an example of the most simple sinatra application you could probably make. The ‘get’
referrers to the HTTP verb. You should probably recognise this from rails land. The next part
is the “route”, here I’m just mapping the index / root. “erb :index” will render index.erb,
sinatra also has haml support out of the box.

17. a ‘post’ example. you might notice the params hash is nothing new if you’ve come from rails
land.

18. a ‘post’ example. you might notice the params hash is nothing new if you’ve come from rails
land.

19. a ‘post’ example. you might notice the params hash is nothing new if you’ve come from rails
land.

20. a ‘post’ example. you might notice the params hash is nothing new if you’ve come from rails
land.

21. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

22. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

23. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

24. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

25. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

26. a slightly more advanced example. Here I create a mime type of :json and use before (read:
like before_filter) to set the :json content type before all routes. The .to_json method isn’t
Sinatra magic. In this case it comes from using datamappers’ aggrigates plugin, activerecord
of course has this built in.

27. This is called “Classic”
Sinatra application style
This means that the get and post (read: your application) is defined at the top level

28. Apps can also be defined in another way.
Modular apps are defined within their own namespace / class.
They inherit from Sinatra::Base

29. Apps can also be defined in another way.
Modular apps are defined within their own namespace / class.
They inherit from Sinatra::Base

30. Thats a “Modular”
Sinatra application
I’ll get into modular apps a little more later

31. Running it
So by now, if you’re unfamiliar with rack or sinatra you’ll might be thinking, “but we just got
passenger, ruby hosting has only now become ‘easy’”

32. Development

33. you could use the `rackup` command, but instead you should use ‘shotgun’ by Ryan
Tomayko, it handles application reloading (which is not present within the sinatra codebase)

34. Ryan Tomayko
@rtomayko

35. Ever wondered what Ryan Tomayko
looks like at 8 am after a huge
fucking bender in “old” vegas?

36. Not much earlier (5am) Ryan sent his wife an email saying “Melbourne, we’re going”. She
called in the morning to find out if he was mid-way across the pacific or not.

37. Production

38. Drop in a config.ru to
your application root
config.Rack-Up, rack uses this to load and configure rack applications and middleware

39. this is a simple config.ru file. its for a ‘classic’ application

40. For those “Modular”
applications

41. a rackup file (config.ru) example for a modular application

42. Then drop it under
passenger. Done
Of course you’ll need to read some docs, but its so trivial its not even worth mentioning

43. Heres the part where I
hock my own warez
Just some assorted things that I have found really fun or interesting in the last few months

44. Amnesia
Statistics for memcached instances

45. So thats all your hits, misses and basic stats to tell you what the hell your memcached
instances are doing. If they’re getting smashed. Etc. I know iseekgolf, a large australian
golfing website have used it, along with some engineyard customers. github and flickr also
checked it out which was pretty cool. Amnesia was a 2 session application, one for
implementation, the next to add the graphs etc. I think I spent about 5 hours total on it.

46. Munch
Recipes from websites re-represented
I showed this last month, its pretty simple so I’ll gloss over it.

47. Basically a aggregate search engine for cooking sites

48. Postie
Postie was originally a rails app, ported to merb

49. Pat Allan
@pat
Pat allan wrote it

50. Postie
A Rack middleware to provide postcode services
I decided to make the next natural progression and re-write it as a rack middleware

51. It has its own datamapper based sqlite backend. When a new build comes out, new data will
be installed along with the gem. Its quite small though.

52. Here is the basic api

53. Here is the basic api

54. Here is the basic api

57. Hold on, rack
middleware?
If you thought we were talking about sinatra, well, you’re right.

58. So how does that work?

59. Sinatra runs on Rack

60. Sinatra (wolf)
Rack (sheeps clothing)
This is a strange analogy. I don’t know.

61. So when you go and define you app in “modular style”, it can be used as a rack middleware.

62. a config.ru file to run your application as middleware, note the use of “use”.

63. a config.ru file to run your application as middleware, note the use of “use”.

64. a config.ru file to run your application as middleware, note the use of “use”.

65. In rails land, you do it like this

66. In rails land, you do it like this

67. In rails land, you do it like this

68. In rails land, you do it like this

69. Selected
middlewares

70. Rack::Cache

71. and again, its made by Ryan Tomayko

72. Reverse proxy
Like Squid or Varnish, but small and simple
It’ll set correct http headers. Thats really important. The main basis of this is that your
application pages can be cached by rack::cache and stop requests from even having to hit
your ruby process.

73. JSON-P
Json-p is for when you want to get callbacks for your json / ajax requests from your server.
The data will be returned wrapped within a callback method. This can make writing a
javascript based interface much faster and easier to implement.

74. instead of doing something like this

75. you can add a callback parameter

76. so instead of getting some result like we did earlier, a raw javascript / json “string” in the
browser that needs to be eval’d and looked after

77. you can get it back like this, it calls your method and can be handled more cleanly

78. JSON-P
part of rack-contrib
Json-p is for when you want to get callbacks for your json / ajax requests from your server.
The data will be returned wrapped within a callback method. This can make writing a
javascript based interface much faster and easier to implement.

79. Hancock
The last one I’ll show is “hancock”

80. A REAL implementation
of single-sign-on
Engine yard are using this internally and I really suggest that you read the code. There are
some videos available online and it stands as the best example of sinatra based rack
middleware. Hancock was the only real implementation of a sinatra based rack middleware
that he sinatra committers could point me at. I used it as a basis for learning how to pack
postie together.

81. Thanks
Special Thanks to Blake and Ryan for being good sports.

82. Thanks
http://sinatrarb.com
http://twitter.com/bmizerany
http://twitter.com/rtomayko
http://github.com/benschwarz/amnesia
http://github.com/benschwarz/munch
http://github.com/benschwarz/postie
http://github.com/rtomayko/shotgun
http://github.com/rack/rack-contrib
http://github.com/atmos/hancock/tree/master
http://github.com/atmos/hancock-client/tree/master
http://en.wikipedia.org/wiki/Single_sign-on
Special Thanks to Blake and Ryan for being good sports.