webfx 0.0.6 → 0.0.7

data/lib/webfx.rb

@@ -1,72 +1,86 @@
 require 'json'
 
-class DeferrableBody
-  include EventMachine::Deferrable
-
-  def call(body)
-    body.each do |chunk|
-      @body_callback.call(chunk)
+class Request
+  attr_reader :user, :params, :body, :path, :method
+  
+  def initialize(env)
+    request = Rack::Request.new(env)
+    params = request.params  
+           
+    if params['_method']
+      method = params['_method']
+    else
+      method = request.request_method
     end
+    
+    @user = @@authenticate ? @@authenticate.call(params) : nil
+    @params = params
+    @body = params['file'] ? '' : (request.post? or request.put?) ? request.body.read : ''
+    @path = request.path
+    @method = method.downcase
   end
-
-  def each &blk
-    @body_callback = blk
-  end  
 end
 
 
-class MyResult
-  attr_reader :env
-   
-  def initialize(env)
-    @env = env
-  end
-end
+class Response
+  attr_writer :status, :header
 
+  class DeferrableBody
+    include EM::Deferrable
 
-class Context
+    def call(body)
+      body.each do |chunk|
+        @body_callback.call(chunk)
+      end
+    end
 
-  def initialize(method, me, env, body)
-    @method = method
-    @me = me
+    def each &blk
+      @body_callback = blk
+    end  
+  end
+  
+  def initialize(env)
     @env = env
-    @body = body
-  end 
- 
-  def respond(response)
-    @env['async.callback'].call [response[0], response[1], @body]
-    @body.call [response[2]]
+    @body = DeferrableBody.new
+    @status = nil
+    @header = nil
+  end
     
-    if response[0] < 400
-      @body.succeed
-    else
-      @body.fail
-    end
+  def fail(message)
+    @status = 500 if @status.nil?
+    @header = {'Content-Type' => 'text/plain'} if @header.nil?
+    @env['async.callback'].call [@status, @header, @body]
+    @body.call [message]
+    @body.fail
   end
- 
-  def succeed(result)
-    if result.kind_of? MyResult
-      respond result.env 
-      return
-    end
 
-    case @method
-      when 'get', 'post'
-        if result.kind_of? String and  ['{', '['].include? result.slice(0, 1) 
-          json = result
-        else
-          json = result.to_json
-        end
-        respond [200, {'Content-Type' => 'application/json'}, json]
-      else 
-        respond [200, {'Content-Type' => 'application/json'}, {:result => :success}.to_json]
+  def succeed(body)
+    @status = 200 if @status.nil?
+    @header = {'Content-Type' => 'application/json'} if @header.nil?
+    @env['async.callback'].call [@status, @header, @body]
+    
+    if @header['Content-Type'] == 'application/json' and 
+      not ((body.kind_of? String) and (['{', '['].include? body.slice(0, 1)))
+      body = body.to_json
     end
+    
+    @body.call [body]
+    @body.succeed
   end
-
-  def fail(message)
-    respond [500, {'Content-Type' => 'text/plain'},  message]
+  
+  def deleted
+    @status = 200 if @status.nil?
+    @header = {'Content-Type' => 'text/plain'} if @header.nil?
+    @env['async.callback'].call [@status, @header, @body]
+    @body.succeed
+  end
+  
+  def updated
+    @status = 200 if @status.nil?
+    @header = {'Content-Type' => 'text/plain'} if @header.nil?
+    @env['async.callback'].call [@status, @header, @body]
+    @body.succeed
   end
-
 end
 
 
@@ -102,75 +116,49 @@ class WebFx
   AsyncResponse = [-1, {}, []].freeze
     
   def call(env)
-
-    EventMachine::next_tick do
+    request = Request.new(env)
+    response = Response.new(env)
     
-      request = Rack::Request.new(env)
-        
-      def static(type, file, env)
-        begin
-          body = DeferrableBody.new
-          body.call [IO.read(file)]
-          env['async.callback'].call [200, { 'Content-Type' => type, 'Cache-Control' => 'public, max-age=86400' }, body]
-        rescue => e
-          env['async.callback'].call [404, { 'Content-Type' => 'text/plain'}, 'Not found.']
-        end
-      end
-
-      if request.path == '/'
-        static('text/html', 'public/index.html', env)
-      end
-
-      if request.path.match(/(.*).js$/)
-        static('text/javascript', "public/#{$1}.js", env)
-      end
-
-      if request.path.match(/(.*).css$/)
-        static('text/css', "public/#{$1}.css", env)
-      end
-
-      if request.path.match(/(.*).jpg$/)
-        static('image/jpg', ".#{$1}.jpg", env)
-      end
-
-      params = request.params
-     
-      if request.post?
-        if not params['file']
-          body = request.body.read
-          params.merge!(JSON.parse(body)) if body != ''
-        end
-      end
-           
-      force_method = params['_method']
-      if force_method
-        method = force_method
-        params.delete('_method')  
-      else
-        method = request.request_method
-      end
-      method.downcase!
-                         
-      me = @@authenticate ? @@authenticate.call(params) : nil
-      ctx = Context.new(method, me, env, DeferrableBody.new)
-
+    EM::next_tick do
       found = false
       
-      @@routes[method].each do |item|
+      @@routes[request.method].each do |item|
         if request.path[1..-1].match(item[:regexp])
           found = true
           case $~.length
-            when 1 then item[:fn].call(params, ctx)
-            when 2 then item[:fn].call($1, params, ctx)
-            when 3 then item[:fn].call($1, $2, params, ctx)
-            when 4 then item[:fn].call($1, $2, $3, params, ctx)
-            when 5 then item[:fn].call($1, $2, $3, $4, params, ctx)
-            else item[:fn].call($~, params, ctx)
+            when 1 then item[:fn].call(request, response)
+            when 2 then item[:fn].call($1, request, response)
+            when 3 then item[:fn].call($1, $2, request, response)
+            when 4 then item[:fn].call($1, $2, $3, request, response)
+            when 5 then item[:fn].call($1, $2, $3, $4, request, response)
+            else item[:fn].call($~, request, response)
           end                              
         end
       end
       
-      ctx.respond [404, {'Content-Type' => 'text/plain'}, 'Not found.'] if not found
+      if not found
+        def static(type, file, response)
+          begin
+            response.header = {'Content-Type' => type, 'Cache-Control' => 'public, max-age=86400'}
+            response.succeed(File.read(file))
+          rescue => e
+            response.fail(e.message)
+          end
+        end
+
+        if request.path == '/'
+          static('text/html', 'public/index.html', response)
+        elsif request.path.match(/(.*).js$/)
+          static('text/javascript', "public#{$1}.js", response)
+        elsif request.path.match(/(.*).css$/)
+          static('text/css', "public#{$1}.css", response)
+        elsif request.path.match(/(.*).jpg$/)
+          static('image/jpg', ".#{$1}.jpg", response)
+        else
+          response.status = 404
+          response.fail('Not found.')
+        end
+      end
     end
 
     AsyncResponse 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: webfx
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: []
 
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-06 00:00:00 -08:00
+date: 2011-01-08 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -62,6 +62,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Async for thin, EventMachine, very minimal, RESTful, json, sinatra-inspired framework.
+summary: Async for thin, EventMachine, heroku, very minimal, RESTful, json, sinatra-inspired framework.
 test_files: []