little_frankie 1.0.0.pre1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d8d154d7208cae8c066755e72e8b892639cbbed
+  data.tar.gz: 22b3c70a5a6032e0e507bcc13a5ff73335e5ec48
+SHA512:
+  metadata.gz: 57e1e6c341510d7e85dbc994fd95dbf0d2f30548bc7f291f771ef17bbdbac394bac80cb4942bb285a2c057dbb938859f25371723b809cb10d7c3e6dcb971a445
+  data.tar.gz: f88e9ab513a33e867a73ddd231b0d01a6a6c1828911054918ddcb9175e93da9a9cf679fb0707a41e235812678f5a4b0a71c6309f07fcb6ed0b80614318ca7b1c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order rand

data/.ruby-gemset

@@ -0,0 +1 @@
+frankie

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rack'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrei Lisnic
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Performance.md

@@ -0,0 +1,65 @@
+# Frankie vs Sinatra performance test
+
+Note: all the tests below were made using Thin as a webserver. Httperf was
+choosen as the tool to do that. Bench settings: `--num-conns 10000`
+
+Hardware: Intel(R) Core(TM) i7-2620M CPU @ 2.70GHz, 6 GB DDR3
+
+## Results
+
+| Benchmark | Frankie (req/s) | Sinatra (req/s) |
+|-----------|:---------------:|:---------------:|
+| Simple    |__5012__         |2534             |
+| UrlPattern|__4564__         |2338             |
+| Filters   |__4510__         |2465             |
+| Helpers   |__4737__         |2663             |
+
+See below the code for each benchmark
+
+## Code
+### Simple
+
+    class App < Frankie::App #(or Sinatra::Base)
+      get '/' do
+        'Hello World!'
+      end
+    end
+    
+### UrlPattern
+    class App < Frankie::App #(or Sinatra::Base)
+      get '/hello/:name' do
+        "Hello #{params[:name]}!"
+      end
+    end
+
+### Filters
+    class App < Frankie::App #(or Sinatra::Base)
+      before do
+        request
+      end
+    
+      after do
+        response
+      end
+    
+      get '/' do
+        'Hello World!'
+      end
+    end
+    
+### Helpers
+    module Dude
+      def da_request_man
+        request
+      end
+    end
+    
+    class App < Frankie::App #(or Sinatra::Base)
+      helpers Dude
+    
+      get '/' do
+        da_request_man
+        'Hello World!'
+      end
+    end
+

data/README.md

@@ -0,0 +1,167 @@
+# Frankie
+Sinatra's little brother.
+
+- [TOP](#frankie)
+- [Motivation](#motivation)
+- [Philosophy](#philosophy)
+- [Why use Frankie instead of Sinatra](#why-use-frankie-instead-of-sinatra)
+- [Usage](#usage)
+    - [Running](#running)
+    - [Defining routes](#defining-routes)
+    - [Request scope](#request-scope)
+    - [Filters](#filters)
+    - [Middleware](#middleware)
+    - [Helpers](#helpers)
+- [FAQ](#f-a-q)
+- [Contributing](#contributing)
+
+# Motivation
+My efforts to write __Frankie__ started when I wanted to understand how __Sinatra__ works, and stumbled upon the [base.rb][0]. The majority of the classes that are used by sinatra are in one single file, which makes it nearly impossible for a new person to grasp.
+
+[I've tried to change the situation][1], but unfortunately, my initiative was premature for the sinatra project (considering their plans).
+
+I wanted to understand how sinatra works, but the code was pretty challenging. So I decided I should re-implement the basic things sinatra has. Thus, __Frankie__ was born.
+
+# Philosophy
+Frankie should have only the bare minimum to write basic web servers comfortably,
+everything else should be in a extension (see frankie extensions). It is also
+trivial to use frankie to build large and complex app, by writing multiple sub
+apps and using Rack to mount them, or by using those sub apps in the "main" app
+as middleware.
+
+# Why use Frankie instead of Sinatra
+- It's very small (~250 LOC), which is just a little overhead on top of Rack.
+- Sinatra is a drop-in replacement for Frankie. Anytime you feel that you need more, you can just change your app to inherit from `Sinatra::Base`, your code will still work, and you will be able to use any of the Sinatra features.
+- It's __~2 times faster__ than Sinatra (see [Performance][performance] for details)
+- You want to dig into the source code and change to your needs (Frankie's source code is more welcoming)
+- Each Frankie app is a Rack middleware, so it can be used inside of Sinatra, Rails, or any other Rack-based app.
+
+# Usage
+
+A Frankie app must _always_ be in a class which inherits from `Frankie::App`.
+
+    class App < Frankie::App
+        get '/' do
+            'Hello, World'
+        end
+    end
+
+## Running
+There are two ways to run a Frankie app __directly__ [[?]](#middleware):
+
+- be requiring it in a `config.ru` file, and then passing it as argument to the
+Rack's `run` function:
+
+        #config.ru
+        require 'app'
+        run App.new
+      
+- by using the `run!` method directly on the app class:
+
+        #app.rb
+        #...App class definition...
+      
+        App.run!
+        
+`run!` takes the port number as optional argument (the default port is 9292). Also the `run!` method will include 2 default middlewares to make the development easier: Rack::CommonLogger and Rack::ShowExceptions. This will show all requests in the log, and will provide useful details in the case a error occurs during a request.
+
+
+## Defining routes
+
+Frankie supports the following verbs for defining a route: delete, get, head, options, patch, post, put and trace.
+
+    class App < Frankie::App
+        post '/' do
+            'You Posted, dude!'
+        end
+    end
+
+Frankie also suports basic URL patterns:
+
+    class App < Frankie::App
+        get '/greet/:first_name/:last_name' do
+            # The last expression in the block is _always_ considered the response body.
+            "Hello #{params[:first_name]} #{params[:last_name]}!"
+        end
+    end
+
+Each block that is passed to a route definition is evaluated in the context of a request scope. See below what methods are available there.
+
+## Request scope
+As was said above, when you pass a block to a route definition, that block is evaluated in the context of a [RequestScope][2]. This means that several methods/objects available inside that block:
+
+- `request` - A `Rack::Request` object which encapsulates the request to that route. (see [Rack::Request documentation][3] for more info)
+- `params` - a hash which contains both POST body params and GET querystring params.
+- `headers` - allows you to read/add headers to the response (ex: `headers 'Content-Type' => 'text/html'`)
+- `status` - allows you to set the status of the response (ex: `status 403`)
+- `redirect_to` - sets the response to redirect (ex: `redirect_to 'http://google.com'`)
+- `cookies` - a hash which allows you to access/modify/remove cookies (ex: `cookies[:foo] = 'bar'`)
+- `session` - a hash which allows you to access/modify/remove session variables (ex: `session[:foo] = 'bar'`)
+
+## Filters
+
+Unlike Sinatra, Frankie supports only "generic" before and after filters. This means that you can't execute a filter depending on a URL pattern.
+
+    class App < Frankie::App
+        before do
+            headers 'Content-Type' => 'text/html'
+        end
+
+        after do
+            puts response.inspect
+        end
+
+        get '/' do
+            'hello'
+        end
+    end
+
+Before and after filters are also evaluated in a RequestScope context. A little exception are the after filters, which can access the __response__ object ([Rack::Response][4]).
+
+## Middleware
+
+A Fankie app is a Rack middleware, which means that it can be used inside of Sinatra, Rails, or any other Rack-based app:
+
+    class MyApp < Sinatra::Base
+        use MyFrankieApp
+    end
+
+Frankie also supports middleware itself, and that means you can use Rack middleware (or a Sinatra app) inside a Frankie app:
+
+    class App < Frankie::App
+        #this will serve all the files in the "public" folder
+        use Rack::Static :url => ['public']
+        use SinatraApp
+    end
+    
+I recommend looking at [the list of Rack middlewares][rack-middleware]
+
+## Helpers
+
+Frankie supports helpers as Sinatra does:
+
+    class App < Frankie::App
+        helpers MyHelperModule
+    end
+
+Using a helper implies that the helper module is included in the [RequestScope][2], and that all the methods in that module will be available inside a route definition block.
+
+# F. A. Q.
+TBD.
+
+
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[0]: https://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb
+[1]: https://github.com/sinatra/sinatra/pull/716
+[2]: https://github.com/alisnic/frankie/blob/master/lib/frankie/request_scope.rb
+[3]: http://rack.rubyforge.org/doc/classes/Rack/Request.html
+[4]: http://rack.rubyforge.org/doc/classes/Rack/Response.html
+[performance]: https://github.com/alisnic/frankie/blob/master/Performance.md
+[rack-middleware]: https://github.com/rack/rack/wiki/List-of-Middleware

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/benchmarks/filters/frankie.rb

@@ -0,0 +1,18 @@
+#!ruby -I ../../lib -I lib
+require 'frankie'
+
+class App < Frankie::App
+  before do
+    request
+  end
+
+  after do
+    response
+  end
+
+  get '/' do
+    'Hello World!'
+  end
+end
+
+App.run!

data/benchmarks/filters/sinatra.rb

@@ -0,0 +1,17 @@
+#!ruby -I ../../lib -I lib
+require 'sinatra'
+
+class App < Sinatra::Base
+  before do
+    request
+  end
+
+  after do
+    response
+  end
+
+  get '/' do
+    'Hello World!'
+  end
+end
+

data/benchmarks/helpers/frankie.rb

@@ -0,0 +1,19 @@
+#!ruby -I ../../lib -I lib
+require 'frankie'
+
+module Dude
+  def da_request_man
+    request
+  end
+end
+
+class App < Frankie::App
+  helpers Dude
+
+  get '/' do
+    da_request_man
+    'Hello World!'
+  end
+end
+
+App.run!

data/benchmarks/helpers/sinatra.rb

@@ -0,0 +1,18 @@
+#!ruby -I ../../lib -I lib
+require 'sinatra'
+
+module Dude
+  def da_request_man
+    request
+  end
+end
+
+class App < Sinatra::Base
+  helpers Dude
+
+  get '/' do
+    da_request_man
+    'Hello World!'
+  end
+end
+

data/benchmarks/simple/frankie.rb

@@ -0,0 +1,10 @@
+#!ruby -I ../../lib -I lib
+require 'frankie'
+
+class App < Frankie::App
+  get '/' do
+    'Hello World!'
+  end
+end
+
+App.run!

data/benchmarks/simple/sinatra.rb

@@ -0,0 +1,9 @@
+#!ruby -I ../../lib -I lib
+require 'sinatra'
+
+class App < Sinatra::Base
+  get '/' do
+    'Hello World!'
+  end
+end
+

data/benchmarks/url_pattern/frankie.rb

@@ -0,0 +1,10 @@
+#!ruby -I ../../lib -I lib
+require 'frankie'
+
+class App < Frankie::App
+  get '/hello/:name' do
+    "Hello #{params[:name]}!"
+  end
+end
+
+App.run!

data/benchmarks/url_pattern/sinatra.rb

@@ -0,0 +1,8 @@
+#!ruby -I ../../lib -I lib
+require 'sinatra'
+
+class App < Sinatra::Base
+  get '/hello/:name' do
+    "Hello #{params[:name]}!"
+  end
+end

data/examples/active_record/.gitignore

@@ -0,0 +1 @@
+db/*.sqlite3

data/examples/active_record/Gemfile

@@ -0,0 +1,14 @@
+source 'http://rubygems.org'
+
+gem 'activerecord', :require => 'active_record'
+gem 'sqlite3'
+gem 'rack'
+gem 'thin'
+
+group :development do
+  #
+end
+
+group :production do
+  #
+end