angelo 0.4.1 → 0.5.0

data/lib/angelo/minitest/helpers.rb

@@ -134,9 +134,12 @@ module Angelo
       class Reactor
         include Celluloid::IO
         extend Cellper
+        def wait_for_stop
+          every(0.01){ terminate if Reactor.stop? }
+        end
       end
 
-      class ActorPool
+      class Actor
         include Celluloid
         extend Cellper
       end
@@ -144,7 +147,7 @@ module Angelo
     end
 
     class WebsocketHelper
-      include Celluloid::Logger
+      include Celluloid::Internals::Logger
 
       extend Forwardable
       def_delegator :@socket, :write
@@ -192,8 +195,11 @@ module Angelo
 
       def go
         @driver.start
-        while msg = @socket.readpartial(4096)
-          @driver.parse msg
+        begin
+          while msg = @socket.readpartial(4096)
+            @driver.parse msg
+          end
+        rescue EOFError, SystemCallError => e
         end
       end
 

data/lib/angelo/params_parser.rb

@@ -21,19 +21,28 @@ module Angelo
     end
 
     def parse_post_body
-      body = request.body.to_s
+      body = request_body rescue request.body.to_s
       case
       when form_encoded?
         parse_formencoded body
       when json? && !body.empty?
-        SymHash.new JSON.parse body
+        parsed_body = JSON.parse body
+        parsed_body = SymHash.new parsed_body if Hash === parsed_body
+        parsed_body
       else
         {}
       end
     end
 
     def parse_query_string_and_post_body
-      parse_query_string.merge! parse_post_body
+      parsed_body = parse_post_body
+      case parsed_body
+      when Hash
+        parse_query_string.merge! parse_post_body
+      when Array
+        self.request_body = parsed_body
+        parse_query_string
+      end
     end
 
     def form_encoded?

data/lib/angelo/responder.rb

@@ -1,7 +1,7 @@
 module Angelo
 
   class Responder
-    include Celluloid::Logger
+    include Celluloid::Internals::Logger
 
     class << self
 
@@ -30,8 +30,8 @@ module Angelo
     attr_accessor :connection, :mustermann, :request
     attr_writer :base
 
-    def initialize &block
-      @response_handler = block
+    def initialize method, &block
+      @method, @response_handler = method, block
     end
 
     def reset!
@@ -70,7 +70,7 @@ module Angelo
 
     def handle_error _error, type = :internal_server_error, report = @base.report_errors?
       err_msg = error_message _error
-      Angelo.log @connection, @request, nil, type, err_msg.size
+      Angelo.log @method, @connection, @request, nil, type, err_msg.size
       @connection.respond type, headers, err_msg
       @connection.close
       if report
@@ -170,11 +170,11 @@ module Angelo
         end
       end
 
-      status ||= @redirect.nil? ? :ok : :moved_permanently
-      headers LOCATION_HEADER_KEY => @redirect if @redirect
+      status ||= @redirect.nil? ? :ok : @redirect[1]
+      headers LOCATION_HEADER_KEY => @redirect[0] if @redirect
 
       if @chunked
-        Angelo.log @connection, @request, nil, status
+        Angelo.log @method, @connection, @request, nil, status
         @request.respond status, headers
         err = nil
         begin
@@ -190,7 +190,7 @@ module Angelo
         end
       else
         size = @body.nil? ? 0 : @body.size
-        Angelo.log @connection, @request, nil, status, size
+        Angelo.log @method, @connection, @request, nil, status, size
         @request.respond status, headers, @body
       end
 
@@ -198,11 +198,15 @@ module Angelo
       handle_error e, :internal_server_error
     end
 
-    def redirect url
-      @redirect = url
+    def redirect url, permanent = false
+      @redirect = [url, permanent ? :moved_permanently : :found]
       nil
     end
 
+    def redirect! url
+      redirect url, true
+    end
+
     def on_close= on_close
       raise ArgumentError.new unless Proc === on_close
       @on_close = on_close

data/lib/angelo/responder/eventsource.rb

@@ -4,7 +4,7 @@ module Angelo
 
       def initialize _headers = nil, &block
         headers _headers if _headers
-        super &block
+        super :get, &block
       end
 
       def request= request
@@ -40,7 +40,7 @@ module Angelo
       end
 
       def respond
-        Angelo.log @connection, @request, nil, :ok
+        Angelo.log :sse, @connection, @request, nil, :ok
         @request.respond 200, headers, nil
       end
 

data/lib/angelo/responder/websocket.rb

@@ -2,16 +2,6 @@ module Angelo
   class Responder
     class Websocket < Responder
 
-      class << self
-
-        attr_writer :on_pong
-
-        def on_pong
-          @on_pong ||= ->(e){}
-        end
-
-      end
-
       def request= request
         @params = nil
         @request = request
@@ -21,8 +11,7 @@ module Angelo
       def handle_request
         begin
           if @response_handler
-            Angelo.log @connection, @request, @websocket, :switching_protocols
-            @websocket.on_pong &Responder::Websocket.on_pong
+            Angelo.log :ws, @connection, @request, @websocket, :switching_protocols
             @base.filter :before
             @base.instance_exec(@websocket, &@response_handler)
             @base.filter :after
@@ -45,6 +34,8 @@ module Angelo
 
       def close_websocket
         @websocket.close
+      rescue IOError
+      ensure
         @base.websockets.remove_socket @websocket
       end
 

data/lib/angelo/server.rb

@@ -5,7 +5,7 @@ module Angelo
 
   class Server < Reel::Server::HTTP
     extend Forwardable
-    include Celluloid::Logger
+    include Celluloid::Internals::Logger
 
     def_delegators :@base, :websockets, :sses
 
@@ -51,11 +51,22 @@ module Angelo
         route! meth, connection, request
       end
     rescue URI::InvalidURIError => e
-      Angelo.log connection, request, nil, :bad_request
+      Angelo.log meth, connection, request, nil, :bad_request
       connection.respond :bad_request, DEFAULT_RESPONSE_HEADERS, e.message
     end
 
+    def post_override! meth, request
+      if meth == :post and request.headers.has_key? POST_OVERRIDE_REQUEST_HEADER_KEY
+        new_meth = request.headers[POST_OVERRIDE_REQUEST_HEADER_KEY].downcase.to_sym
+        meth = new_meth if POST_OVERRIDABLE.include? new_meth
+      end
+      meth
+    rescue
+      meth
+    end
+
     def route! meth, connection, request
+      meth = post_override! meth, request
       if rs = @base.routes[meth][request.path]
         responder = rs.dup
         responder.reset!
@@ -65,7 +76,7 @@ module Angelo
         responder.handle_request
         responder
       else
-        Angelo.log connection, request, nil, :not_found
+        Angelo.log meth, connection, request, nil, :not_found
         connection.respond :not_found, DEFAULT_RESPONSE_HEADERS, NOT_FOUND
       end
     end
@@ -77,7 +88,7 @@ module Angelo
     def static! meth, connection, request, local_path
       etag = etag_for local_path
       if request.headers[IF_NONE_MATCH_HEADER_KEY] == etag
-        Angelo.log connection, request, nil, :not_modified, 0
+        Angelo.log meth, connection, request, nil, :not_modified, 0
         connection.respond :not_modified
       else
         headers = {
@@ -96,7 +107,7 @@ module Angelo
           ETAG_HEADER_KEY => etag
 
         }
-        Angelo.log connection, request, nil, :ok, headers[CONTENT_LENGTH_HEADER_KEY]
+        Angelo.log meth, connection, request, nil, :ok, headers[CONTENT_LENGTH_HEADER_KEY]
         connection.respond :ok, headers, (meth == :head ? nil : File.read(local_path))
       end
     end

data/lib/angelo/stash.rb

@@ -3,7 +3,7 @@ module Angelo
   # utility class for stashing connected websockets in arbitrary contexts
   #
   module Stash
-    include Celluloid::Logger
+    include Celluloid::Internals::Logger
 
     module ClassMethods
 
@@ -29,6 +29,7 @@ module Angelo
     def initialize server, context = :default
       raise ArgumentError.new "symbol required" unless Symbol === context
       @context, @server = context, server
+      @mutex = Mutex.new
       stashes[@context] ||= []
     end
 
@@ -51,7 +52,8 @@ module Angelo
     # as needed
     #
     def each &block
-      stash.dup.each do |s|
+      stash_dup = @mutex.synchronize { stash.dup }
+      stash_dup.each do |s|
         begin
           yield s
         rescue Reel::SocketError, IOError, SystemCallError => e
@@ -69,6 +71,7 @@ module Angelo
       if stash.include? s
         warn "removing socket from context ':#{@context}' (#{peeraddrs[s][2]})"
         stash.delete s
+
         peeraddrs.delete s
       end
     end
@@ -83,12 +86,14 @@ module Angelo
     # ping_websockets task
     #
     def all_each
-      stashes.values.flatten.each do |s|
+      all_stashed = @mutex.synchronize { stashes.values.flatten }
+      all_stashed.each do |s|
         begin
           yield s
         rescue Reel::SocketError, IOError, SystemCallError => e
           debug "all - #{e.message}"
           remove_socket s
+          stashes.values.each {|_s| _s.delete s}
         end
       end
     end

data/lib/angelo/templates.rb

@@ -0,0 +1,166 @@
+require 'tilt'
+
+module Angelo
+  module Templates
+
+    # When this code refers to Tilt, use ::Tilt not Angelo::Tilt.
+
+    Tilt = ::Tilt
+
+    # Add instance methods to render views with each template engine
+    # I'm using.  The methods are called "haml", "markdown", etc.
+
+    # They render files (Symbols) or Strings, with no frills other
+    # than locals.  Files must be in the self.class.views_dir
+    # directory, with an extension that Tilt maps to the
+    # template_type.
+
+    # Angelo::Tilt::ERB includes an erb method built on top of _erb
+    # (below) which provides slightly differnet semantics.  For
+    # compatibilty, we don't overwrite that method here and instead
+    # define _erb.  At least for now.
+
+    [:haml, :markdown].each do |template_type|
+      define_method(template_type) do |view, opts = {}|
+        render(template_type, view, opts)
+      end
+    end
+
+    def _erb(view, opts = {})
+      render(:erb, view, opts)
+    end
+
+    private
+
+    def render(template_type, view, opts = {})
+      # Extract the options that belong to us.  Any remaining options
+      # will be passed to the engine when the template is instantiated.
+
+      locals = opts.delete(:locals) || {}
+      layout_engine = opts.delete(:layout_engine) || template_type
+      layout = 
+        if opts.has_key?(:layout)
+          layout = opts.delete(:layout)
+          case layout
+          when true
+            :layout
+          when nil
+            false
+          else
+            layout
+          end
+        else
+          # Use the default layout.
+          :layout
+        end
+
+      template = self.class.get_template(template_type, view, self.class.views_dir, opts)
+      if !template
+        raise ArgumentError, "Can't find template `#{view}' of type `#{template_type}'"
+      end
+
+      render = ->{ template.render(self, locals) }
+      if layout
+        layout_template = self.class.get_template(layout_engine, layout,
+            File.join(self.class.views_dir), opts)
+      end
+      if layout_template
+        layout_template.render(self, &render)
+      else
+        render.call
+      end
+    end
+
+    def self.included(klass)
+      klass.extend TemplateCaching
+    end
+
+    module TemplateCaching
+      # A Cache which, unlike Tilt::Cache, will cache nil so when a
+      # template isn't found we'll remmeber that and won't try/fail to
+      # load it again.  This happens most commonly when there is no
+      # default layout file.
+
+      # A pull request has been accepted for Tilt which makes
+      # Tilt::Cache work like our Cache so we can remove this when a
+      # new Tilt gem is released (currently 2.0.1), but Tilt doesn't
+      # seem to be getting much love these days.
+
+      class Cache
+        def initialize
+          @cache = {}
+        end
+
+        def fetch(*key)
+          @cache.fetch(key) do
+            @cache[key] = yield
+          end
+        end
+      end
+
+      # Create a template cache that all subclasses of Angelo::Base
+      # will share.  And a non_cache object that will stand in for the cache
+      # when reloading templates, which is set per-class.
+
+      @@template_cache = Cache.new
+      @@non_cache = Object.new.tap do |o|
+        def o.fetch(*args)
+          yield
+        end
+      end
+
+      def get_template(*args)
+        template_cache.fetch(*args) do
+          instantiate_template(*args)
+        end
+      end
+
+      private
+
+      def template_cache
+        @reload_templates ? @@non_cache : @@template_cache
+      end
+
+      def instantiate_template(template_type, view, views_dir, opts)
+        case view
+        when Symbol
+          instantiate_template_from_file(template_type, view.to_s, views_dir, opts)
+        when String
+          instantiate_template_from_string(template_type, view, opts)
+        else
+          raise ArgumentError, "view must be a Symbol or a String"
+        end
+      end
+
+      def instantiate_template_from_file(template_type, view, views_dir, opts)
+        # Find a file in the views directory with a correct extension
+        # for this template_type.
+        file = find_view_file_for_template_type(views_dir, view, template_type)
+        if file
+          # Use absolute filenames so backtraces have absolute filenames.
+          absolute_file = File.expand_path(file)
+          Tilt.new(absolute_file, opts)
+        end
+      end
+
+      def instantiate_template_from_string(template_type, string, opts)
+        # To make Tilt use a String as a template we pass Tilt.new a
+        # block that returns the String.  Passing a block makes
+        # Tilt.new ignore the file argument.  Except the file argument
+        # is still used to figure out which template engine to use.
+        # Fortunately we can just pass template_type, except the file
+        # argument needs to respond to to_str and symbols don't
+        # respond to that so we convert it to a String.
+        Tilt.new(template_type.to_s, opts) {string}
+      end
+
+      def find_view_file_for_template_type(views, name, template_type)
+        template_class = Tilt[template_type]
+        exts = Tilt.default_mapping.extensions_for(template_class).uniq
+        filenames = exts.map{|ext| File.join(views, "#{name}.#{ext}")}
+        filenames.find{|f| File.exists?(f)}
+      end
+    end
+
+  end
+end