noder 0.0.1 → 0.0.2

data/README.md

@@ -0,0 +1,327 @@
+Noder
+=====
+Node.js for Ruby
+
+Overview
+--------
+
+Noder brings the architecture of Node.js to Ruby. It focuses on the implementation of Node.js's HTTP-related support, as Ruby's standard library and other gems already provide great analogs of many of Node.js's other core modules.
+
+You may also be interested in [Expressr](https://github.com/tombenner/expressr) (Express.js for Ruby), which Noder was built to support, and [EM-Synchrony](https://github.com/igrigorik/em-synchrony). Noder runs on [EventMachine](https://github.com/eventmachine/eventmachine).
+
+Example
+-------
+
+A web server can be created and started using the following script:
+
+```ruby
+require 'noder'
+
+server = Noder::HTTP::Server.new do |request, response|
+  response.write_head(200, { 'Content-Type' => 'text/plain' })
+  response.end('Hello world!')
+end
+server.listen(1337, '127.0.0.1')
+```
+
+To start the app, put the code into a file named `my_server.rb` and run it:
+
+```bash
+$ ruby my_server.rb
+Running Noder at 127.0.0.1:1337...
+```
+
+HTTP
+----
+
+### Noder::HTTP::Server
+
+`Noder::HTTP::Server` lets you create and run HTTP servers.
+
+#### .new(options={}, &block)
+
+Creates the server.
+
+##### options
+
+* `:address` - The server's address (default: `'0.0.0.0'`)
+* `:port` - The server's port (default: `8000`)
+* `:environment` - The server's environment name (default: `'development'`)
+* `:threadpool_size` - The size of the server's threadpool default: `20`)
+* `:enable_ssl` - A boolean of whether SSL is enabled (default: `false`)
+* `:ssl_key` - A filepath to the SSL key (default: `nil`)
+* `:ssl_cert` - A filepath to the SSL cert (default: `nil`)
+
+##### &block
+
+A block that will be called for every request. It will be passed the request (a Noder::HTTP::Request) and response (a Noder::HTTP::Response) as arguments.
+
+#### #listen(port=nil, address=nil, options={}, &block)
+
+Starts accepting connections to the server. `options` are the same as the options in `.new`, and `&block` behaves the same as in `.new`.
+
+```ruby
+server = Noder::HTTP::Server.new
+server.listen(8001) do |request, response|
+  response.write("Hello world!")
+  response.end
+end
+```
+
+#### #close
+
+Stops the server. This is called when an `INT` or `TERM` signal is sent to a running server's process (e.g. when `Control-C` is pressed).
+
+#### Event 'request'
+
+Emitted for every request. The request and response are passed as arguments.
+
+```ruby
+server.on('request') do |request, response|
+  Noder.logger.info "Request params: #{request.params}"
+  response.set_header('MyHeader', 'My value')
+end
+```
+
+#### Event 'close'
+
+Emitted when the server is closing. No arguments are passed.
+
+```ruby
+server.on('close') do
+  Noder.logger.info "Stopping server..."
+end
+```
+
+### Noder::HTTP::Request
+
+A representation of an HTTP request.
+
+#### #params
+
+A hash of the request's params (the query string and POST data). The hash's keys are strings (e.g. `/?foo=bar` yields `{ 'foo' => 'bar' }`)
+
+#### #headers
+
+A hash of the request's headers (e.g. `{ 'Accept' => '*/*', 'User-Agent' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_5) [...]' }`).
+
+#### #request_method
+
+The request's verb (e.g. `'GET'`, `'POST'`, etc).
+
+#### #cookie
+
+The request's Cookie header (e.g. `'my_cookie=123; my_other_cookie=foo'`).
+
+#### #content_type
+
+The request's Content-Type header (e.g. `'application/x-www-form-urlencoded'`).
+
+#### #request_uri
+
+The request's path, without the query string (e.g. `'/users/1/profile'`).
+
+#### #query_string
+
+The request's query string (e.g. `/about?foo=bar&baz=1` yields `'foo=bar&baz=1'`).
+
+#### #protocol
+
+The request's protocol (e.g. `'HTTP/1.1'`).
+
+#### #ip
+
+The client's IP address (e.g. `'68.1.8.45'`).
+
+### Noder::HTTP::Response
+
+A representation of an HTTP response.
+
+#### #write(content)
+
+Writes the content to the response's body.
+
+```ruby
+response.write('Hello world!')
+```
+
+#### #write_head(status, headers={})
+
+Sets the response's status code and sets the specified headers (if any).
+
+```ruby
+response.write_head(500, { 'MyHeader' => 'My value' })
+```
+
+#### #status_code
+
+Gets or sets the response's status code
+
+```ruby
+response.status_code # 200
+response.status_code = 500
+```
+
+#### #set_header(name, value)
+
+Sets the specified header.
+
+```ruby
+response.set_header('MyHeader', 'My value')
+```
+
+#### #get_header(name, value)
+
+Gets the specified header.
+
+```ruby
+response.get_header('MyHeader') # 'My value'
+```
+
+#### #remove_header(name)
+
+Gets the specified header.
+
+```ruby
+response.remove_header('MyHeader')
+```
+
+#### #end(content=nil)
+
+Sends the response. This must be called on every response instance.
+
+If `content` is provided, it is equivalent to calling `write(content)` followed by `end`.
+
+Events
+------
+
+### Noder::Events::EventEmitter
+
+Include `EventEmitter` in classes which should manage events. For example:
+
+```ruby
+class MyServer
+  include Noder::Events::EventEmitter
+
+  def initialize(&block)
+    on('start', &block)
+    on('stop', proc { puts 'Stopping...' })
+  end
+
+  def run
+    emit('start')
+    emit('stop')
+  end
+end
+
+server = MyServer.new do
+  puts 'Starting up...'
+end
+server.on('start') do
+  puts 'Still starting up...'
+end
+
+server.run
+# Starting up...
+# Still starting up...
+# Stopping...
+```
+
+#### #on(event, callback=nil, options={}, &block)
+
+Adds a listener to the specified event. The listener can either be an instance of a Proc (as the `callback` argument) or a block.
+
+`add_listener` is an alias of `on`.
+
+#### #emit(event)
+
+Call the listeners for the specified event.
+
+#### #remove_listener(event, listener)
+
+Remove the listener. Listeners are compared using the `==` operator.
+
+```ruby
+listener = proc { puts 'Working...' }
+server.on('start', listener)
+server.remove_listener('start', listener)
+```
+
+#### #remove_all_listeners(event)
+
+Removes all of the listeners from the event. You probably don't want to call this on core Noder events.
+
+```ruby
+server.remove_all_listeners('start')
+```
+
+#### #set_max_listeners(event, count)
+
+Sets the maximum number of listeners for the specified event. A warning will be logged every time any additional listeners are added.
+
+```ruby
+server.set_max_listeners('start', 100)
+```
+
+#### #listeners(event)
+
+Returns an array of the listeners for the specified event.
+
+```ruby
+server.listeners('start')
+```
+
+#### #listener_count(event)
+
+Returns the number of listeners for the specified event.
+
+```ruby
+server.listener_count('start')
+```
+
+Logging
+-------
+
+Noder's `Logger` is available at `Noder.logger`. You can write to it:
+
+```ruby
+Noder.logger.debug 'My debug message...'
+Noder.logger.error 'My error message...'
+```
+
+You can modify it or replace it if you like, too:
+
+```ruby
+# Adjust attributes of the logger
+Noder.logger.level = Logger::DEBUG
+
+# Or create a custom Logger
+Noder.logger = Logger.new(STDOUT)
+Noder.logger.level = Logger::DEBUG
+```
+
+See the [Logger docs](http://www.ruby-doc.org/stdlib-2.0/libdoc/logger/rdoc/Logger.html) for more.
+
+HTTPS
+-----
+
+To support HTTPS, set `:enable_ssl` to `true` and set the `:ssl_key` and `:ssl_cert` values to the appropriate file paths:
+
+```ruby
+options = {
+  enable_ssl: true,
+  ssl_key: File.expand_path('../certs/key.pem', __FILE__),
+  ssl_cert: File.expand_path('../certs/cert.pem', __FILE__)
+}
+server = Noder::HTTP::Server.new(options)
+```
+
+Notes
+-----
+
+Noder is not currently a full implementation of Node.js, and some of its underlying architecture differs from Node.js's. If you see any places where it could be improved or added to, absolutely feel free to submit a PR.
+
+License
+-------
+
+Noder is released under the MIT License. Please see the MIT-LICENSE file for details.

data/lib/noder.rb

@@ -1,4 +1,21 @@
-require "#{directory}/noder/version.rb"
+require 'eventmachine'
+require 'logger'
+
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/noder/*.rb") { |file| require file }
 
 module Noder
+  class << self
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def with(operation, callback=nil, &block)
+      EM.defer(operation, callback || block)
+    end
+  end
 end

data/lib/noder/events.rb

@@ -0,0 +1,7 @@
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/events/**/*.rb") { |file| require file }
+
+module Noder
+  module Events
+  end
+end

data/lib/noder/events/em_event_node.rb

@@ -0,0 +1,55 @@
+module Noder
+  module Events
+    class EMEventNode
+      attr_accessor :callback, :next_node
+
+      def initialize(options={})
+        @callback = options[:callback]
+        @argument_keys = options[:argument_keys]
+        raise 'No callback provided' if @callback.nil?
+      end
+
+      def call(env)
+        if callback.respond_to?(:matches_env?) && !callback.matches_env?(env)
+          if next_node
+            operation = proc { next_node.call(env) }
+            EM.defer(operation)
+          end
+          return
+        end
+        operation = proc { call_operation(env) }
+        if next_node
+          callback = proc { |env| next_node.call(env) }
+          EM.defer(operation, callback)
+        else
+          EM.defer(operation)
+        end
+        env
+      end
+
+      protected
+
+      def call_operation(env)
+        @env = env
+        if @argument_keys
+          arguments = Utils.slice_hash(@env, @argument_keys).values
+        else
+          arguments = [@env]
+        end
+        perform_callback(arguments)
+        @env
+      end
+
+      def perform_callback(arguments)
+        continue_method = proc { EM.signal_loopbreak }
+        if @callback.is_a?(Proc)
+          @callback.call(*arguments, continue_method)
+        elsif @callback.is_a?(Class)
+          @env = @callback.new(continue_method).call(*arguments)
+        else
+          @env = @callback.call(*arguments, continue_method)
+        end
+      end
+    end
+  end
+end

data/lib/noder/events/event_emitter.rb

@@ -0,0 +1,78 @@
+module Noder
+  module Events
+    module EventEmitter
+      def event_stacks
+        @event_stacks ||= {}
+      end
+
+      def max_listener_counts
+        @max_listener_counts ||= {}
+      end
+
+      def on(event, callback=nil, options={}, &block)
+        max_count = max_listener_counts[event]
+        current_count = listener_count(event)
+        if max_count && current_count >= max_count
+          Noder.logger.warn "Maximum listener count exceeded for #{self.class} (max count is #{max_count}; current count is #{current_count})."
+        end
+        callback ||= block
+        options[:callback] = callback
+        event_stacks[event] ||= EventStack.new(node_class: node_class_for_event(event))
+        event_stacks[event].push(options)
+      end
+
+      def emit(event, *arguments)
+        return if event_stacks[event].nil?
+        event_stacks[event].call(*arguments)
+      end
+
+      def remove_listener(event, listener)
+        event_stacks[event].remove(listener)
+      end
+
+      def remove_all_listeners(event)
+        event_stacks[event].remove_all
+      end
+
+      def set_max_listeners(event, count)
+        max_listener_counts[event] = count
+      end
+
+      def listeners(event)
+        if event_stacks[event]
+          event_stacks[event].items.map { |item| item[:callback] }
+        else
+          []
+        end
+      end
+
+      def listener_count(event)
+        if event_stacks[event]
+          event_stacks[event].length
+        else
+          0
+        end
+      end
+
+      def event_stack(event)
+        event_stacks[event]
+      end
+
+      alias_method :add_listener, :on
+
+      protected
+
+      def set_node_class_for_event(klass, event)
+        event_node_classes[event] = klass
+      end
+
+      def event_node_classes
+        @event_node_classes ||= {}
+      end
+
+      def node_class_for_event(event)
+        event_node_classes[event] || EMEventNode
+      end
+    end
+  end
+end

data/lib/noder/events/event_node.rb

@@ -0,0 +1,43 @@
+module Noder
+  module Events
+    class EventNode
+      attr_accessor :callback, :next_node
+
+      def initialize(options={})
+        @callback = options[:callback]
+        @argument_keys = options[:argument_keys]
+        @has_continued = false
+        raise 'No callback provided' if @callback.nil?
+      end
+
+      def call(env)
+        @env = env
+        if @argument_keys
+          arguments = Utils.slice_hash(@env, @argument_keys).values
+        else
+          arguments = [@env]
+        end
+        perform_callback(arguments)
+        continue unless @has_continued
+      end
+
+      def continue(env=nil)
+        @has_continued = true
+        next_node.call(env || @env) if next_node
+      end
+
+      protected
+
+      def perform_callback(arguments)
+        continue_method = method(:continue)
+        if @callback.is_a?(Proc)
+          @callback.call(*arguments, continue_method)
+        elsif @callback.is_a?(Class)
+          @env = @callback.new(continue_method).call(*arguments)
+        else
+          @env = @callback.call(*arguments, continue_method)
+        end
+      end
+    end
+  end
+end

data/lib/noder/events/event_stack.rb

@@ -0,0 +1,63 @@
+module Noder
+  module Events
+    class EventStack
+      extend Forwardable
+
+      attr_reader :items
+
+      def_delegators :@items, :length
+
+      def initialize(options={})
+        @items = []
+        @node_class = options[:node_class] || EMEventNode
+      end
+
+      def push(options={})
+        @items << options
+      end
+
+      def insert_before(target_callback, item)
+        index = index_of_callback(target_callback)
+        raise "Item not found for callback: #{target_callback}" if index.nil?
+        @items.insert(index, item)
+      end
+
+      def replace(target_callback, item)
+        index = index_of_callback(target_callback)
+        raise "Item not found for callback: #{target_callback}" if index.nil?
+        @items[index] = item
+      end
+
+      def remove(target_callback)
+        index = index_of_callback(target_callback)
+        @items.delete_at(index) if index
+      end
+
+      def remove_all
+        @items = []
+      end
+
+      def index_of_callback(callback)
+        @items.index { |item| item[:callback] == callback }
+      end
+
+      def call(env=nil)
+        empty_node = @node_class.new({ callback: proc { |env| env } })
+        nodes = @items.map { |item| @node_class.new(item) }
+        first_node = nodes.reverse.inject(empty_node) do |next_node, current_node|
+          current_node.next_node = next_node
+          current_node
+        end
+        first_node.call(env)
+      end
+
+      protected
+
+      def does_item_match?(item, env)
+        callback = item[:callback]
+        return true unless callback.respond_to?(:matches_env?)
+        callback.matches_env?(env)
+      end
+    end
+  end
+end

data/lib/noder/events/listeners/base.rb

@@ -0,0 +1,13 @@
+module Noder
+  module Events
+    module Listeners
+      class Base
+        attr_accessor :callback
+        
+        def initialize(callback)
+          @callback = callback
+        end
+      end
+    end
+  end
+end

data/lib/noder/http.rb

@@ -0,0 +1,7 @@
+directory = File.dirname(File.absolute_path(__FILE__))
+Dir.glob("#{directory}/http/**/*.rb") { |file| require file }
+
+module Noder
+  module HTTP
+  end
+end

data/lib/noder/http/connection.rb

@@ -0,0 +1,52 @@
+require 'evma_httpserver'
+require 'socket'
+
+module Noder
+  module HTTP
+    class Connection < EM::Connection
+      include EventMachine::HttpServer
+
+      attr_accessor :app, :environment, :request_stack, :settings
+
+      def initialize(*args)
+        super(*args)
+        @settings = args[1]
+      end
+      
+      def post_init
+        super
+        if settings[:enable_ssl]
+          start_tls(:private_key_file => settings[:ssl_key], :cert_chain_file => settings[:ssl_cert], :verify_peer => false)
+        end
+      end
+
+      def process_http_request
+        env = {
+          connection: self,
+          request_env: request_env,
+          request: nil,
+          response: nil
+        }
+        EM.defer do
+          request_stack.call(env)
+        end
+      end
+
+      def request_env
+        port, ip = Socket.unpack_sockaddr_in(get_peername)
+        {
+          request_method: @http_request_method,
+          cookie: @http_cookie,
+          content_type: @http_content_type,
+          path_info: @http_path_info,
+          request_uri: @http_request_uri,
+          query_string: @http_query_string,
+          post_content: @http_post_content,
+          headers: @http_headers,
+          protocol: @http_protocol,
+          ip: ip
+        }
+      end
+    end
+  end
+end

data/lib/noder/http/listeners/not_found.rb

@@ -0,0 +1,20 @@
+module Noder
+  module HTTP
+    module Listeners
+      class NotFound < Events::Listeners::Base
+        def call(env)
+          callback.call(env) if callback
+          response = env[:response]
+          render_not_found(response) unless response.is_rendered?
+          env
+        end
+
+        def render_not_found(response)
+          response.status_code = 404
+          response.write('Not Found')
+          response.end
+        end
+      end
+    end
+  end
+end

data/lib/noder/http/listeners/request.rb

@@ -0,0 +1,13 @@
+module Noder
+  module HTTP
+    module Listeners
+      class Request < Events::Listeners::Base
+        def call(env)
+          env[:request] ||= Noder::HTTP::Request.new(env[:request_env])
+          callback.call(env) if callback
+          env
+        end
+      end
+    end
+  end
+end

data/lib/noder/http/listeners/response.rb

@@ -0,0 +1,13 @@
+module Noder
+  module HTTP
+    module Listeners
+      class Response < Events::Listeners::Base
+        def call(env)
+          env[:response] ||= Noder::HTTP::Response.new(env)
+          callback.call(env) if callback
+          env
+        end
+      end
+    end
+  end
+end

data/lib/noder/http/request.rb

@@ -0,0 +1,53 @@
+module Noder
+  module HTTP
+    class Request
+      attr_accessor :params
+      attr_reader :env
+      
+      def initialize(env)
+        @env = env
+        @query = HTTP::Utils.parse(env[:query_string])
+        @params = @query
+        if env[:post_content] && env[:post_content] != ''
+          @params.merge!(HTTP::Utils.parse(env[:post_content]))
+        end
+      end
+
+      def headers
+        @headers ||= HTTP::Utils.parse_headers(env[:headers])
+      end
+
+      def request_method
+        env[:request_method]
+      end
+
+      def cookie
+        env[:cookie]
+      end
+
+      def content_type
+        env[:content_type]
+      end
+
+      def request_uri
+        env[:request_uri]
+      end
+
+      def query_string
+        env[:query_string]
+      end
+
+      def post_content
+        env[:post_content]
+      end
+
+      def protocol
+        env[:protocol]
+      end
+
+      def ip
+        env[:ip]
+      end
+    end
+  end
+end

data/lib/noder/http/response.rb

@@ -0,0 +1,64 @@
+module Noder
+  module HTTP
+    class Response < EventMachine::DelegatedHttpResponse
+      attr_accessor :params
+
+      def initialize(env)
+        super(env[:connection])
+        @params = env[:request].params
+        @is_rendered = false
+      end
+
+      def write(content)
+        self.content ||=  ''
+        self.content << content
+      end
+
+      def write_head(status, headers={})
+        self.status = status
+        @headers.merge!(headers)
+      end
+
+      def status_code=(status)
+        self.status = status
+      end
+
+      def status_code
+        self.status
+      end
+
+      def set_header(name, value)
+        @headers[name] = value
+      end
+
+      def get_header(name)
+        @headers[name]
+      end
+
+      def remove_header(name)
+        @headers.delete(name)
+      end
+
+      def end(content=nil)
+        return if @is_rendered
+        @is_rendered = true
+        write(content) if content
+        send_response
+      end
+
+      def is_rendered?
+        @is_rendered
+      end
+
+      protected
+
+      def app
+        @delegate.app
+      end
+
+      def request_env
+        @delegate.request_env
+      end
+    end
+  end
+end

data/lib/noder/http/server.rb

@@ -0,0 +1,91 @@
+require 'em-synchrony'
+
+module Noder
+  module HTTP
+    class Server
+      include Events::EventEmitter
+
+      attr_accessor :options
+
+      def initialize(options={}, &block)
+        defaults = {
+          address: '0.0.0.0',
+          port: 8000,
+          app: nil,
+          environment: 'development',
+          threadpool_size: 20,
+          enable_ssl: false,
+          ssl_key: nil,
+          ssl_cert: nil
+        }
+        @options = defaults.merge(options)
+        # The 'close' event is emitted as EM is stopped, so we need to handle the callbacks outside of
+        # the EM event loop with Events::EventNode instead of Events::EMEventNode
+        set_node_class_for_event(Events::EventNode, 'close')
+        push_default_callbacks
+        on('request', &block) if block
+      end
+
+      def listen(port=nil, address=nil, options={}, &block)
+        @options.merge!(options)
+        @options[:port] = port if port
+        @options[:address] = address if address
+        EM.threadpool_size = @options[:threadpool_size]
+        EM.epoll
+        EM.synchrony do
+          trap('INT')  { close }
+          trap('TERM') { close }
+          # Listeners::NotFound should run after all other listeners, so we'll add it here
+          add_listener('request', Listeners::NotFound)
+
+          Noder.logger.info "Running Noder at #{@options[:address]}:#{@options[:port]}..."
+          emit('start')
+          connection_settings = Noder::Utils.slice_hash(@options, [:enable_ssl, :ssl_key, :ssl_cert])
+          EM.start_server(@options[:address], @options[:port], Noder::HTTP::Connection, block, connection_settings) do |connection|
+            connection.request_stack = event_stack('request')
+            connection.app = @options[:app]
+            connection.environment = @options[:environment]
+          end
+        end
+      end
+
+      def on(event, callback=nil, &block)
+        callback ||= block
+        case event
+        when 'request'
+          super('request', callback, argument_keys: [:request, :response])
+        when 'close'
+          super('close', callback)
+        else
+          super(event, callback)
+        end
+      end
+
+      def close
+        Noder.logger.info 'Stopping Noder...'
+        emit('close')
+        EM.stop
+      end
+
+      protected
+
+      def push_default_callbacks
+        default_callbacks.each do |event, items|
+          items.each do |item|
+            add_listener(event, item)
+          end
+        end
+      end
+
+      def default_callbacks
+        {
+          'close' => [],
+          'request' => [
+            Listeners::Request,
+            Listeners::Response
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/noder/http/utils.rb

@@ -0,0 +1,96 @@
+require 'uri'
+
+module Noder
+  module HTTP
+    module Utils
+      DEFAULT_SEP = /[&;] */n
+      
+      class << self
+        attr_accessor :key_space_limit
+      end
+
+      # The default number of bytes to allow parameter keys to take up.
+      # This helps prevent a rogue client from flooding a Request.
+      self.key_space_limit = 65536
+
+      class KeySpaceConstrainedParams
+        def initialize(limit = Utils.key_space_limit)
+          @limit  = limit
+          @size   = 0
+          @params = {}
+        end
+
+        def [](key)
+          @params[key]
+        end
+
+        def []=(key, value)
+          @size += key.size if key && !@params.key?(key)
+          raise RangeError, 'exceeded available parameter key space' if @size > @limit
+          @params[key] = value
+        end
+
+        def key?(key)
+          @params.key?(key)
+        end
+
+        def to_params_hash
+          hash = @params
+          hash.keys.each do |key|
+            value = hash[key]
+            if value.kind_of?(self.class)
+              hash[key] = value.to_params_hash
+            elsif value.kind_of?(Array)
+              value.map! {|x| x.kind_of?(self.class) ? x.to_params_hash : x}
+            end
+          end
+          hash
+        end
+      end
+
+      if defined?(::Encoding)
+        def unescape(s, encoding = Encoding::UTF_8)
+          URI.decode_www_form_component(s, encoding)
+        end
+      else
+        def unescape(s, encoding = nil)
+          URI.decode_www_form_component(s, encoding)
+        end
+      end
+      module_function :unescape
+
+      def parse(qs, d = nil, &unescaper)
+        unescaper ||= method(:unescape)
+
+        params = KeySpaceConstrainedParams.new
+
+        (qs || '').split(d ? /[#{d}] */n : DEFAULT_SEP).each do |p|
+          next if p.empty?
+          k, v = p.split('=', 2).map(&unescaper)
+
+          if cur = params[k]
+            if cur.class == Array
+              params[k] << v
+            else
+              params[k] = [cur, v]
+            end
+          else
+            params[k] = v
+          end
+        end
+
+        return params.to_params_hash
+      end
+      module_function :parse
+
+      def parse_headers(string)
+        string.split("\x00").reduce({}) do |hash, string|
+          key, value = string.split(': ', 2)
+          hash[key] = value
+          hash
+        end
+      end
+      module_function :parse_headers
+    end
+  end
+end

data/lib/noder/utils.rb

@@ -0,0 +1,10 @@
+require 'uri'
+
+module Noder
+  module Utils
+    def slice_hash(hash, keys)
+      keys.each_with_object({}) { |k, new_hash| new_hash[k] = hash[k] if hash.has_key?(k) }
+    end
+    module_function :slice_hash
+  end
+end

data/lib/noder/version.rb

@@ -1,3 +1,3 @@
 module Noder
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noder
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,56 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-07 00:00:00.000000000 Z
+date: 2014-05-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine_httpserver
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -34,10 +82,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/noder/events/em_event_node.rb
+- lib/noder/events/event_emitter.rb
+- lib/noder/events/event_node.rb
+- lib/noder/events/event_stack.rb
+- lib/noder/events/listeners/base.rb
+- lib/noder/events.rb
+- lib/noder/http/connection.rb
+- lib/noder/http/listeners/not_found.rb
+- lib/noder/http/listeners/request.rb
+- lib/noder/http/listeners/response.rb
+- lib/noder/http/request.rb
+- lib/noder/http/response.rb
+- lib/noder/http/server.rb
+- lib/noder/http/utils.rb
+- lib/noder/http.rb
+- lib/noder/utils.rb
 - lib/noder/version.rb
 - lib/noder.rb
 - MIT-LICENSE
-- Rakefile
 - README.md
 homepage: https://github.com/tombenner/noder
 licenses:

data/Rakefile

@@ -1,12 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-task :default => :test
-
-Rake::TestTask.new do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
-end