Almost Sinatra

A Sinatra implementation in less than 10 lines. Dependencies: Tilt and Rack (like Sinatra) and Backports. Only works on Ruby 1.9.

Features:

• all template engines Sinatra supports
• get/post/put/delete
• before filters
• configure/set/enable/disable/...
• session/params
• support for helpers
• stand alone usage
• inline templates
• thread safe

Features missing:

• serving static files, use Rack::File or something, or code like this:

    get('/foo.txt') { File.read '/foo.txt' }
  

  or just don't do it. Patch for this will be accepted if it doesn't add another line.

Installation

Copy the contents of almost_sinatra.rb into your app file (at the top), that way you also avoid running the wrong version by accident.

Try it

$ ruby example.rb
What Sinatra implementation should I use?
[R]eal Sinatra
[A]lmost Sinatra
>> a

Modular style

When pasting the Almost Sinatra code into your file, replace Application=$a with Base=$a (second line atm, but don't expect me to update the readme if I move stuff around).

Performance

It's just amazing. No code is faster than no code.

$ sloccount alomst_sinatra.rb
Total Physical Source Lines of Code (SLOC)                = 8
Development Effort Estimate, Person-Years (Person-Months) = 0.00 (0.02)
 (Basic COCOMO model, Person-Months = 2.4 * (KSLOC**1.05))
Schedule Estimate, Years (Months)                         = 0.04 (0.51)
 (Basic COCOMO model, Months = 2.5 * (person-months**0.38))
Estimated Average Number of Developers (Effort/Schedule)  = 0.03
Total Estimated Cost to Develop                           = $ 170
 (average salary = $56,286/year, overhead = 2.40).

$ sloccount ../sinatra
Total Physical Source Lines of Code (SLOC)                = 5,771
Development Effort Estimate, Person-Years (Person-Months) = 1.26 (15.12)
 (Basic COCOMO model, Person-Months = 2.4 * (KSLOC**1.05))
Schedule Estimate, Years (Months)                         = 0.58 (7.02)
 (Basic COCOMO model, Months = 2.5 * (person-months**0.38))
Estimated Average Number of Developers (Effort/Schedule)  = 2.15
Total Estimated Cost to Develop                           = $ 170,198
 (average salary = $56,286/year, overhead = 2.40).

As you can see Sinatra is 1000000% more expensive than Almost Sinatra!

Generated using David A. Wheeler's 'SLOCCount'.

Coding guidelines

• keep code under ten lines, this includes require and whatnot

• avoid spaces and newlines if possible

• wrap at 200 characters to make it readable on a terminal

• newlines may be used instead of ; to improve readability

• use map instead of each, it's shorter

• store constants in global variables to dry up your code (like $f = File)

• if you have one loop, reuse it. instead of this:

    ['a','b'].map{|e|...}
    [Rack::Something].map{|e|...}
  

  do this:

    ['a','b',Rack::Something].map{|e|(e==e.to_s)?(...):(...)}
  

  Safes a line!

• e.to_s==e is shorter than e.is_a? String or String===e

• use ->{} instead of proc or lambda (this is why it depends on 1.9)

• add methods for class scope to $o and for instance scope to $a (or $o), see http://www.sinatrarb.com/intro#Scopes%20and%20Binding

• don't include tests. tests just bloat the code base. just commit, the users will complain if you break anything.

About Versioning

Versions are to Software what Git is to SVN.