armstrong 0.2.8 → 0.3.0

data/README.md

@@ -40,13 +40,11 @@ There's a sample `mongrel2.conf` and `config.sqlite` in the `demo` folder, feel
 	require './lib/armstrong'
 	
 	get "/" do
-		reply_string "hello world"
+		"hello world"
 	end
 
 Just like in Sinatra, we state the verb we want to use, the path, and give it a block with the relevant code to execute. So far only 'GET' requests are supported but more will come out in later builds. 
 
-You can also call the `get_message` method which returns the request from the browser, and then reply to the request with `reply(request, message)`. `reply_string(message)` is a helper function that grabs the message and instantly replies to it with `message`.
-
 Now you should run `ruby armstrong_test.rb` and then visit [localhost:6767](http://localhost:6767/) and relish in the 'Hello World'.
 
 ## more functionality ##
@@ -55,12 +53,11 @@ commit e86c74aed added functionality for parameters in your path. These are simp
 
 	require 'armstrong'
 	
-	get "/:id" do
-		req = get_request
-		reply req, "id: #{req[:params]["id"]}"
+	get "/:id" do |env|
+		"id: #{env[:params]["id"]}"
 	end
 	
-The params are always going to be stored in the request, naturally.
+The params are always going to be stored in `env`, naturally.
 
 ## benchmarking ##
 

data/armstrong.gemspec

@@ -1,4 +1,4 @@
-Gem::Specification.new 'armstrong', '0.2.8' do |s|
+Gem::Specification.new 'armstrong', '0.3.0' do |s|
   s.description       = "Armstrong is an Mongrel2 fronted, actor-based web development framework similar in style to sinatra. With natively-threaded interpreters (Rubinius2), Armstrong provides true concurrency and high stability, by design."
   s.summary           = "Highly concurrent, sinatra-like framework"
   s.author            = "Artem Titoulenko"

data/bin/armstrong

@@ -72,8 +72,7 @@ servers = [armstrong_serv]
 inform if ARGV.empty?
 
 case ARGV[0]
-when 'c'
-when 'create'
+when 'create', 'c'
   inform if ARGV[1].nil?
   port = (ARGV[2].nil? ? 6767 : ARGV[2])
   mkdir ARGV[1]
@@ -85,8 +84,7 @@ when 'create'
   File.open("#{ARGV[1]}.rb", 'w') {|file| file.puts "require 'rubygems'\nrequire 'armstrong'\n\n"}
   puts "Created app #{ARGV[1]} that will run on port #{port}"
   
-when 's'
-when 'start'
+when 'start', 's'
   host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
   db = (ARGV[2].nil? ? 'config.sqlite' : ARGV[2])
   
@@ -101,9 +99,10 @@ when 'start'
   puts "now running #{file}.rb"
   puts `ruby #{file}.rb`
   
-when 't'
-when 'stop'
+when 'stop', 't'
   host = (ARGV[1].nil? ? 'localhost' : ARGV[1])
   puts `m2sh stop -host #{host}`
   puts "Stopped #{host}, I think"
+else
+  inform
 end

data/demo/armstrong_test.rb

@@ -1,15 +1,13 @@
 require '../lib/armstrong'
 
 get "/" do
-  reply_string "hello world"
+  "hello world"
 end
 
-get "/:id" do
-  req = get_request
-  reply req, "id: #{req[:params]["id"]}"
+get "/:id" do |env|
+  "id: #{env[:params]["id"]}"
 end
 
-get "/:id/do" do
-  req = get_request
-  reply req, "do: #{req[:params]["id"]}"
+get "/:id/do" do |env|
+  "do: #{env[:params]["id"]}"
 end

data/lib/armstrong/connection.rb

@@ -44,7 +44,7 @@ class Connection
     self.send(request[:uuid], [request[:id]], message)
   end
 
-  def reply_http(req, body, code=200, headers={"Content-type" => "text/html"})
+  def reply_http(req, code=200, headers={"Content-type" => "text/html"}, body="")
     self.reply(req, http_response(body, code, headers))
   end
   
@@ -52,7 +52,7 @@ class Connection
   def http_response(body, code, headers)
     headers['Content-Length'] = body.size
     headers_s = headers.map{|k, v| "%s: %s" % [k,v]}.join("\r\n")
-
+    
     "HTTP/1.1 #{code} #{StatusMessage[code.to_i]}\r\n#{headers_s}\r\n\r\n#{body}"
   end
   

data/lib/armstrong/data_structures.rb

@@ -1,6 +1,6 @@
 AddRoute = Struct.new :route, :method
 AddRoutes = Struct.new :routes
-ShowRoutes = Struct.new :this
-Request = Struct.new :data
+Request = Struct.new :env
 ConnectionInformation = Struct.new :connection
-Reply = Struct.new :data, :body, :code, :headers
+Reply = Struct.new :env, :code, :headers, :body
+MessageAndProc = Struct.new :env, :proccess

data/lib/armstrong/main_actors.rb

@@ -2,6 +2,7 @@ module Aleph
   class Base
     class << self
       attr_accessor :replier, :request_handler, :supervisor
+      attr_accessor :replier_proc, :request_handler_proc, :supervisor_proc, :container_proc
     end
   end
 end
@@ -17,21 +18,21 @@ def process_route(route, pattern, keys, values = [])
   params
 end
 
-Aleph::Base.replier = Proc.new do   
+Aleph::Base.replier_proc = Proc.new do   
   @name = "replier"
   puts "started (#{@name})"
   Actor.register(:replier, Actor.current)
+  Aleph::Base.replier = Actor.current
   conn = nil
   
   loop do
     Actor.receive do |msg|
       msg.when(ConnectionInformation) do |c|
-        #puts "replier: got connection information #{c.inspect}"
         conn = c.connection
       end
       msg.when(Reply) do |m|
         begin
-          conn.reply_http(m.data, m.body, m.code, m.headers)
+          conn.reply_http(m.env, m.code, m.headers, m.body)
         rescue Exception => e
           puts "Actor[:replier]: I messed up with exception: #{e.message}"
         end
@@ -40,40 +41,49 @@ Aleph::Base.replier = Proc.new do
   end
 end
 
-Aleph::Base.request_handler = Proc.new do
+# this nifty mess helps us just to use the output of the Procs that handle
+# the request instead of making the user manually catch messages and send 
+# them out to the replier. 
+
+Aleph::Base.container_proc = Proc.new do
+  data = Actor.receive
+  env, proccess = data.env, data.proccess
+  response = proccess.call(env)
+  if response.is_a? Array
+    #just like Rack: env, code, headers, body. HINT HINT
+    Aleph::Base.replier << Reply.new(env, response[0], response[1], response[2])
+  else
+    Aleph::Base.replier << Reply.new(env, 200, {"Content-Type" => "text/html"}, response)
+  end
+end
+
+Aleph::Base.request_handler_proc = Proc.new do
   @name = "request_handler"
   puts "started (#{@name})"
   Actor.register(:request_handler, Actor.current)
+  Aleph::Base.request_handler = Actor.current
   Actor.trap_exit = true
   
-  routes = []
+  routes = {}
   loop do
     Actor.receive do |f|
-      f.when(AddRoute) do |r|
-        routes << [r.route, r.method]
-      end
-      
       f.when(AddRoutes) do |r|
-        r.routes.each do |k|
-          routes << [k.route, k.method]
-        end
-      end
-
-      f.when(ShowRoutes) do |r|
-        routes.each {|s| puts s}
+        routes = r.routes
       end
 
       f.when(Request) do |r|
         failure = true
-        routes.each do |route|
-          if route[0][0].match(r.data[:path])
-            r.data[:params] = process_route(r.data[:path], route[0][0], route[0][1])
-            #puts r.data.inspect
-            Actor.spawn_link(&route[1]) << r.data
+        r.env[:headers] = JSON.parse(r.env[:headers])
+        verb = r.env[:headers]["METHOD"]
+        routes[verb].each do |route|
+          if route.route[0].match(r.env[:path])
+            r.env[:params] = process_route(r.env[:path], route.route[0], route.route[1])
+            Actor.spawn(&Aleph::Base.container_proc) << MessageAndProc.new(r.env, route.method)
             failure = false
+            break
           end
         end
-        Actor[:replier] << Reply.new(r.data, "404", 404, {'Content-type'=>'text/html'}) if failure
+        Aleph::Base.replier << Reply.new(r.env, 404, {'Content-type'=>'text/html'}, "<h1>404</h1>") if failure
       end
 
       # f.when(Actor::DeadActorError) do |exit|
@@ -84,9 +94,10 @@ Aleph::Base.request_handler = Proc.new do
 end
 
 #if this dies, all hell will break loose
-Aleph::Base.supervisor = Proc.new do
+Aleph::Base.supervisor_proc = Proc.new do
   puts "started (supervisor)"
   Actor.register(:supervisor, Actor.current)
+  Aleph::Base.supervisor = Actor.current
   Actor.trap_exit = true
   
   Actor.link(Actor[:replier])
@@ -98,9 +109,9 @@ Aleph::Base.supervisor = Proc.new do
         "#{exit.actor.name} died with reason: #{exit.reason}"
         case exit.actor.name
         when "request_handler"
-          Actor.spawn_link(&@request_handler)
+          Actor.spawn_link(&@request_handler_proc)
         when "replier"
-          Actor.spawn_link(&@replier)          
+          Actor.spawn_link(&@replier_proc)          
         end
       end
     end

data/lib/armstrong.rb

@@ -2,6 +2,7 @@ require 'actor'
 require 'rubygems'
 require 'lazy'
 require 'open-uri'
+require 'json'
 
 libdir = File.dirname(__FILE__)
 $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
@@ -9,23 +10,11 @@ $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 require "armstrong/connection"
 require 'armstrong/data_structures'
 require 'armstrong/main_actors'
-
-def get_request
-  return Actor.receive
-end
-
-def reply(request, body, code=200, headers={"Content-type" => "text/html"})
-  Actor[:replier] << Reply.new(request, body, code, headers)
-end
-
-def reply_string(body, code=200, headers={"Content-type" => "text/html"})
-  Actor[:replier] << Reply.new(Actor.receive, body, code, headers)
-end
   
 module Aleph
   class Base
     class << self
-      attr_accessor :conn, :routes, :pairs
+      attr_accessor :conn, :routes
       
       def new_uuid
         values = [
@@ -40,8 +29,16 @@ module Aleph
         "%04x%04x-%04x-%04x-%04x%06x%06x" % values
       end
       
-      def get(path, &block)
-        (@pairs ||= []) << AddRoute.new(compile(path), block)
+      def get(path, &block) route "GET", path, &block end
+      def put(path, &block)  route "PUT",  path, &block end
+      def post(path, &block) route "POST", path, &block end
+      def head(path, &block) route "HEAD", path, &block end
+      def delete(path, &block) route "DELETE", path, &block end
+      def patch(path, &block) route "PATCH", path, &block end
+      
+      def route(verb, path, &block)
+        @routes ||= {}
+        (@routes[verb] ||= []) << AddRoute.new(compile(path), block)
       end
       
       private
@@ -88,31 +85,31 @@ module Aleph
       
       #ensure that all actors are launched. Yea.
       done = Lazy::demand(Lazy::promise do |done|
-        Actor.spawn(&Aleph::Base.replier)
+        Actor.spawn(&Aleph::Base.replier_proc)
         done = Lazy::demand(Lazy::promise do |done|
-          Actor.spawn(&Aleph::Base.request_handler)
+          Actor.spawn(&Aleph::Base.request_handler_proc)
           done = Lazy::demand(Lazy::promise do |done|
-            Actor.spawn(&Aleph::Base.supervisor)
+            Actor.spawn(&Aleph::Base.supervisor_proc)
             done = true
           end)
         end)
       end)
       
-      Actor[:replier] << ConnectionInformation.new(@conn) if done
+      Aleph::Base.replier << ConnectionInformation.new(@conn) if done
       
       done = Lazy::demand(Lazy::Promise.new do |done|
-        Actor[:request_handler] << AddRoutes.new(@pairs)
+        Aleph::Base.request_handler << AddRoutes.new(@routes)
         done = true
       end)
 
-      if Actor[:supervisor] && Actor[:request_handler] && Actor[:replier] && done
+      if Aleph::Base.supervisor && Aleph::Base.request_handler && Aleph::Base.replier && done
         puts "","="*56,"Armstrong has launched on #{Time.now}","="*56, ""
       end
       
       # main loop
       loop do
         req = @conn.receive
-        Actor[:request_handler] << Request.new(req) if !req.nil?
+        Aleph::Base.request_handler << Request.new(req) if !req.nil?
       end
     end
   end
@@ -132,7 +129,7 @@ module Aleph
       end
     end
 
-    delegate :get
+    delegate :get, :post, :put, :patch, :delete, :head
 
     class << self
       attr_accessor :target

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: armstrong
 version: !ruby/object:Gem::Version 
-  hash: 2499712927119017196
+  hash: 3600368719662819624
   prerelease: 
   segments: 
   - 0
-  - 2
-  - 8
-  version: 0.2.8
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Artem Titoulenko
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-16 00:00:00 Z
+date: 2011-11-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: ffi