little_frankie 1.0.0.pre1

data/examples/web_sockets/server.rb

@@ -0,0 +1,60 @@
+#!ruby -I ../../lib -I lib
+require 'frankie'
+require 'faye/websocket'
+
+#
+# Open localhost:9000/public/index.html in the browser
+#
+
+Faye::WebSocket.load_adapter('thin')
+
+class WebSockets
+  def initialize app=nil, opts={}, &blk
+    @app = app
+    @path = opts.fetch :path, '/'
+    @blk = blk
+  end
+
+  def call env
+    return @app.call(env) unless env['PATH_INFO'] == @path
+
+    if Faye::WebSocket.websocket?(env)
+      ws = Faye::WebSocket.new(env)
+
+      if @blk
+        Proc.new(&@blk).call ws
+      else
+        handle ws
+      end
+
+      ws.rack_response
+    else
+      @app.call(env)
+    end
+  end
+
+  def handle ws
+  end
+end
+
+class App < Frankie::App
+  #Serve static assets from public folder
+  use Rack::Static, :urls => ["/public"]
+
+  use WebSockets, :path => '/websocket' do |ws|
+    ws.on :message do |event|
+      ws.send(event.data)
+    end
+
+    ws.on :close do |event|
+      p [:close, event.code, event.reason]
+      ws = nil
+    end
+  end
+
+  get '/frankie' do
+    'yep, you can still use frankie'
+  end
+end
+
+App.run! 9000

data/lib/little_frankie.rb

@@ -0,0 +1,9 @@
+require 'uri'
+require 'rack'
+
+require "little_frankie/version"
+require 'little_frankie/primitives'
+require 'little_frankie/request_scope'
+require 'little_frankie/route_signature'
+require 'little_frankie/class_level_api'
+require 'little_frankie/app'

data/lib/little_frankie/app.rb

@@ -0,0 +1,66 @@
+module LittleFrankie
+  class App
+    extend ClassLevelApi
+
+    RouteNotFoundError = Class.new StandardError
+
+    def initialize app=nil
+      @app = app || lambda {|env| Response.new '', 404 }
+      build_middleware_chain
+    end
+
+    def build_middleware_chain
+      @top = self.class.middlewares.reverse.reduce (self) do |prev, entry|
+        klass, args, blk = entry
+        klass.new prev, *args, &blk
+      end
+    end
+
+    def self.run! port=9292
+      middlewares.unshift Rack::ShowExceptions, Rack::CommonLogger
+
+      begin
+        Rack::Handler::Thin
+      rescue LoadError
+        Rack::Handler::WEBrick
+      end.run new, :Port => port
+    end
+
+    def handler_for_path method, path
+      self.class.routes.fetch(method.downcase.to_sym).each do |sig, h|
+        params = sig.match path
+        return [h, params] if params
+      end
+
+      raise RouteNotFoundError
+    end
+
+    def route req
+      begin
+        handler, params = handler_for_path req.request_method, req.path
+        req.params.merge! params
+        RequestScope.new(self, req).apply_to &handler
+      rescue KeyError, RouteNotFoundError
+        @app.call req.env
+      end
+    end
+
+    def _call env
+      route Request.new(env)
+    end
+
+    def call env
+      if @top == self
+        _call env
+      else
+        if not @initialized_chain
+          @initialized_chain = true
+          @top.call(env)
+        else
+          @initialized_chain = false
+          _call env
+        end
+      end
+    end
+  end
+end

data/lib/little_frankie/class_level_api.rb

@@ -0,0 +1,40 @@
+module LittleFrankie
+  module ClassLevelApi
+    HTTP_VERBS = [:delete, :get, :head, :options, :patch, :post, :put, :trace]
+    HTTP_VERBS.each do |method|
+      define_method method do |str, &blk|
+        (routes[method] ||= {})[RouteSignature.new(str)] = Proc.new &blk
+      end
+    end
+
+    def middlewares;  @middlewares  ||= []  end
+    def routes;       @routes       ||= {}  end
+    def before_hooks; @before_hooks ||= []  end
+    def after_hooks;  @after_hooks  ||= []  end
+
+    def use_protection! args={}
+      begin
+        require 'rack/protection'
+        middlewares.unshift [Rack::Protection, args]
+      rescue LoadError
+        puts "WARN: to use protection, you must install 'rack-protection' gem"
+      end
+    end
+
+    def before &blk
+      before_hooks << Proc.new(&blk)
+    end
+
+    def after &blk
+      after_hooks << Proc.new(&blk)
+    end
+
+    def use middleware, *args, &block
+      middlewares << [middleware, args, block]
+    end
+
+    def helpers *args
+      args.each {|m| RequestScope.add_helper_module m }
+    end
+  end
+end

data/lib/little_frankie/primitives.rb

@@ -0,0 +1,25 @@
+module LittleFrankie
+  class Request < Rack::Request
+  end
+
+  class Response < Rack::Response
+    attr_reader :raw_body
+
+    def initialize body=[], status=200, header={}
+      @raw_body = body
+      super body.to_s, status, header
+    end
+
+    def body= value
+      @raw_body = value
+      @body = []
+      @length = 0
+
+      if value.respond_to? :to_str
+        write value.to_str
+      elsif value.respond_to?(:each)
+        value.each {|part| write part.to_s }
+      end
+    end
+  end
+end

data/lib/little_frankie/request_scope.rb

@@ -0,0 +1,60 @@
+module LittleFrankie
+  class RequestScope
+    attr_reader :request, :app, :response
+
+    def self.add_helper_module m
+      include m
+    end
+
+    def initialize app, req
+      @app = app
+      @headers = {'Content-Type' => 'text/html'}
+      @status = 200
+      @request = req
+    end
+
+    def params
+      request.params
+    end
+
+    def headers hash={}
+      @headers.merge! hash
+    end
+
+    def session
+      request.session
+    end
+
+    def cookies
+      request.cookies
+    end
+
+    def status code
+      @status = code
+    end
+
+    def halt status, headers={}, body=''
+      @halt_response = Response.new body, status, @headers.merge(headers)
+    end
+
+    def redirect_to path
+      @redirect = path
+    end
+
+    def apply_to &handler
+      params.default_proc = proc {|h,k| h[k.to_s] || h[k.to_sym]}
+      app.class.before_hooks.each {|h| instance_eval &h }
+
+      @response = @halt_response || begin
+        Response.new instance_eval(&handler), @status, @headers
+      end
+
+      cookies.each {|k,v| @response.set_cookie k,v }
+      @response.redirect(@redirect) if @redirect
+
+      app.class.after_hooks.each {|h| instance_eval &h }
+      @response.finish
+      @response
+    end
+  end
+end

data/lib/little_frankie/route_signature.rb

@@ -0,0 +1,44 @@
+module LittleFrankie
+  class RouteSignature
+    NAME_PATTERN = /:(\S+)/
+
+    attr_reader :pattern
+    def initialize route
+      @pattern = if route.is_a? Regexp
+                   route
+                 else
+                   pattern_for route.dup
+                 end
+    end
+
+    def pattern_for string
+      return string unless string.include? ':'
+      string = "/#{string}" unless string.start_with? '/'
+      parts = string.split '/'
+
+      groups = parts.map do |part|
+        next part if part.empty?
+        next part unless part.start_with? ':'
+        name = NAME_PATTERN.match(part)[1]
+        %Q{(?<#{name}>\\S+)}
+      end.select {|s| !s.empty? }
+
+      %r(\/#{groups.join('\/')})
+    end
+
+    def match path
+      return (pattern == path ? {} : nil) if pattern.is_a?(String)
+      data = pattern.match path
+
+      if data
+        if pattern.respond_to? :names
+          Hash[data.names.map {|n| [n.to_sym, URI.unescape(data[n])]}]
+        else
+          {}
+        end
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/little_frankie/version.rb

@@ -0,0 +1,3 @@
+module LittleFrankie
+  VERSION = "1.0.0.pre1"
+end

data/little_frankie.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'little_frankie/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "little_frankie"
+  spec.version       = LittleFrankie::VERSION
+  spec.authors       = ["Andrei Lisnic"]
+  spec.email         = ["andrei.lisnic@gmail.com"]
+  spec.description   = %q{sinatra's little brother}
+  spec.summary       = %q{sinatra's little brother}
+  spec.homepage      = "https://github.com/alisnic/frankie"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/app_spec.rb

@@ -0,0 +1,144 @@
+require_relative 'spec_helper'
+
+describe App do
+  let (:app) { mock_app {} }
+
+  describe '.run!' do
+    #
+  end
+
+  it 'should have the class methods included' do
+    extended_modules_for(App).should include(ClassLevelApi)
+  end
+
+  it 'should return a rack response on call' do
+    response = app.get '/'
+    response.should be_a(Rack::Response)
+  end
+
+  it 'should return 404 for non-matched routes' do
+    response = app.get random_url
+    response.status.should == 404
+  end
+
+  it 'should match a route for any supported verbs' do
+    url = random_url
+    verb = ClassLevelApi::HTTP_VERBS.sample
+
+    app = mock_app do
+      send verb, url do
+        'foo'
+      end
+    end
+
+    res = app.send verb, url
+    res.body.should == 'foo'
+  end
+
+  it 'should support route patterns' do
+    app = mock_app do
+      get '/:name' do
+        "hello #{params[:name]}"
+      end
+    end
+
+    res = app.get '/foo'
+    res.body.should == "hello foo"
+  end
+
+  it 'should support adding before filers' do
+    app = mock_app do
+      before do
+        request.should_not == nil
+      end
+
+      get '/' do
+        "hello"
+      end
+    end
+
+    app.get('/')
+  end
+
+  it 'does not maintain state between requests' do
+    app = mock_app do
+      get '/state' do
+        @foo ||= "new"
+        body = "Foo: #{@foo}"
+        @foo = 'discard'
+        body
+      end
+    end
+
+    2.times do
+      response = app.get('/state')
+      response.should be_ok
+      'Foo: new'.should == response.body
+    end
+  end
+
+  it 'acts well as a middleware' do
+    app = lambda do |env|
+      [210, {}, ['Hello from downstream']]
+    end
+
+    app_class = frankie_app do
+      get '/' do
+        'hello'
+      end
+    end
+
+    frankie = app_class.new(app)
+    req = Rack::MockRequest.new frankie
+    res = req.get '/'
+    res.body.should == 'hello'
+
+    res2 = req.get '/ither'
+    res2.body.should == 'Hello from downstream'
+  end
+
+  it 'should support adding after filers' do
+    app = mock_app do
+      after do
+        response.should_not == nil
+      end
+
+      get '/' do
+        "hello"
+      end
+    end
+    app.get '/'
+  end
+
+  it 'should be able to set cookies' do
+    app_class = Class.new(App) do
+      post '/write' do
+        cookies.merge! params
+      end
+    end
+
+    req = Rack::MockRequest.env_for '/write?foo=bar', :method => :post
+    res = app_class.new.call(req)
+    res.headers['Set-Cookie'].should == 'foo=bar'
+  end
+
+  describe '.run!' do
+    before do
+      handler = begin
+                  Rack::Handler::Thin
+                rescue LoadError
+                  Rack::Handler::WEBrick
+                end
+      handler.stub :run
+    end
+
+    it 'should include the default middleware on top' do
+      kls = frankie_app do
+      end
+
+      kls.run!
+      kls.middlewares.first.should == Rack::ShowExceptions
+      kls.middlewares[1].should == Rack::CommonLogger
+    end
+  end
+end