angelo 0.3.3 → 0.4.0

data/lib/angelo/main.rb

@@ -0,0 +1,47 @@
+require "angelo"
+
+module Angelo
+  class Base
+    @angelo_main = true
+
+    # Takes a block and/or modules that define methods that can be
+    # used from within request handlers.  Methods can also be defined
+    # at the top level but they get defined as Object instance methods
+    # which isn't good.
+
+    module DSL
+      def helpers(*args, &block)
+        args.each do |mod|
+          include(mod)
+        end
+        block && class_exec(&block)
+      end
+    end
+
+  end
+end
+
+# The intent here is to add the DSL to the top-level object "main" by
+# creating an anonymous Angelo::Base subclass and forwarding the DSL
+# methods to it from the top-level object.  Then run the app at exit.
+#
+# If angelo/main is required from somewhere other than the top level,
+# all bets are off.
+
+if self.to_s == "main"
+  # We are probably at the top level.
+
+  require "forwardable"
+  self.extend Forwardable
+  @angelo_app = Class.new(Angelo::Base)
+  self.def_delegators :@angelo_app, *Angelo::Base::DSL.instance_methods
+
+  at_exit do
+    # Don't run @angelo_app on uncaught exceptions including exit
+    # being called which raises SystemExit.  The rationale being that
+    # exit means exit, not "run the server".
+    if $!.nil?
+      @angelo_app.run!
+    end
+  end
+end

data/lib/angelo/minitest/helpers.rb

@@ -9,25 +9,25 @@ module Angelo
 
       attr_reader :last_response
 
-      def define_app &block
-
+      def define_app app = nil, &block
         before do
-          app = Class.new Angelo::Base
-
-          app.class_eval { content_type :html }    # reset
+          if app.nil? && block
+            app = Class.new Angelo::Base do
+              content_type :html    # reset
+              class_eval &block
+            end
+          end
           Celluloid.logger.level = ::Logger::ERROR # see spec_helper.rb:9
 
-          app.class_eval &block
           @server = Angelo::Server.new app
           app.server = @server
-          $reactor = Reactor.new unless $reactor.alive?
+          $reactor = Reactor.new if $reactor == nil || !$reactor.alive?
         end
 
         after do
           sleep 0.1
           @server.terminate if @server and @server.alive?
         end
-
       end
 
       def hc
@@ -40,12 +40,8 @@ module Angelo
         url
       end
 
-      def hc_req method, path, params = {}, headers = {}
-        @last_response = if block_given?
-                           hc.__send__ method, url(path), params, headers, &Proc.new
-                         else
-                           hc.__send__ method, url(path), params, headers
-                         end
+      def hc_req method, path, params = {}, headers = {}, &block
+        @last_response = hc.__send__ method, url(path), params, headers, &block
       end
       private :hc_req
 
@@ -70,15 +66,8 @@ module Angelo
       private :http_req
 
       [:get, :post, :put, :delete, :options, :head].each do |m|
-        define_method m do |path, params = {}, headers = {}|
-
-          # http_req m, path, params, headers
-
-          if block_given?
-            hc_req m, path, params, headers, &Proc.new
-          else
-            hc_req m, path, params, headers
-          end
+        define_method m do |path, params = {}, headers = {}, &block|
+          hc_req m, path, params, headers, &block
         end
       end
 
@@ -114,6 +103,44 @@ module Angelo
         last_response.headers['Content-Type'].split(';').must_include JSON_TYPE
       end
 
+      module Cellper
+
+        @@stop = false
+        @@testers = {}
+
+        def define_action sym, &block
+          define_method sym, &block
+        end
+
+        def remove_action sym
+          remove_method sym
+        end
+
+        def unstop!
+          @@stop = false
+        end
+
+        def stop!
+          @@stop = true
+        end
+
+        def stop?
+          @@stop
+        end
+
+        def testers; @@testers; end
+      end
+
+      class Reactor
+        include Celluloid::IO
+        extend Cellper
+      end
+
+      class ActorPool
+        include Celluloid
+        extend Cellper
+      end
+
     end
 
     class WebsocketHelper
@@ -173,4 +200,5 @@ module Angelo
     end
 
   end
+
 end

data/lib/angelo/params_parser.rb

@@ -9,7 +9,7 @@ module Angelo
     EMPTY_JSON = '{}'
 
     def parse_formencoded str
-      str.split(AMPERSAND).reduce(Responder.symhash) do |p, kv|
+      str.split(AMPERSAND).reduce(SymHash.new) do |p, kv|
         key, value = kv.split(EQUALS).map {|s| CGI.unescape s}
         p[key] = value
         p
@@ -22,28 +22,18 @@ module Angelo
 
     def parse_post_body
       body = request.body.to_s
-      qs = parse_query_string
       case
       when form_encoded?
-        body = parse_formencoded body
-        qs.merge! body
-      when json?
-        body = EMPTY_JSON if body.empty?
-        body = JSON.parse body
-        recurse_symhash qs.merge! body
+        parse_formencoded body
+      when json? && !body.empty?
+        SymHash.new JSON.parse body
       else
-        qs
+        {}
       end
     end
 
-    def recurse_symhash h
-      h.each do |k,v|
-        if Hash === v
-          h[k] = Responder.symhash.merge! v
-          recurse_symhash h[k]
-        end
-      end
-      h
+    def parse_query_string_and_post_body
+      parse_query_string.merge! parse_post_body
     end
 
     def form_encoded?
@@ -64,4 +54,30 @@ module Angelo
 
   end
 
+  class SymHash < Hash
+
+    # Returns a Hash that allows values to be fetched with String or
+    # Symbol keys.
+    def initialize h = nil
+      super(){|hash,key| hash[key.to_s] if Symbol === key}
+      unless h.nil?
+        merge! h
+
+        # Replace values that are Hashes with SymHashes, recursively.
+        each do |k,v|
+          self[k] = case v
+                    when Hash
+                      SymHash.new(v)
+                    when Array
+                      v.map {|e| Hash === e ? SymHash.new(e) : e}
+                    else
+                      v
+                    end
+        end
+
+      end
+    end
+
+  end
+
 end

data/lib/angelo/responder.rb

@@ -25,17 +25,13 @@ module Angelo
         @default_headers
       end
 
-      def symhash
-        Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-      end
-
     end
 
-    attr_accessor :connection, :request
+    attr_accessor :connection, :mustermann, :request
     attr_writer :base
 
     def initialize &block
-      @response_handler = Base.compile! :request_handler, &block
+      @response_handler = block
     end
 
     def reset!
@@ -48,7 +44,7 @@ module Angelo
     def handle_request
       if @response_handler
         @base.filter :before
-        @body = catch(:halt) { @response_handler.bind(@base).call || EMPTY_STRING }
+        @body = catch(:halt) { @base.instance_exec(&@response_handler) || EMPTY_STRING }
 
         # TODO any real reason not to run afters with SSE?
         case @body
@@ -164,8 +160,13 @@ module Angelo
         @body = EMPTY_STRING
 
       else
-        unless @chunked and @body.respond_to? :each
-          raise RequestError.new "what is this? #{@body}"
+        if respond_with? :json and @body.respond_to? :to_json
+          @body = @body.to_json
+          raise "uhhh? #{@body}" unless String === @body
+        else
+          unless @chunked and @body.respond_to? :each
+            raise RequestError.new "what is this? #{@body}"
+          end
         end
       end
 

data/lib/angelo/responder/eventsource.rb

@@ -13,29 +13,30 @@ module Angelo
       end
 
       def handle_request
-        begin
-          if @response_handler
-            @base.filter :before
-            @body = catch(:halt) { @base.eventsource &@response_handler.bind(@base) }
-            if HALT_STRUCT === @body
-              raise RequestError.new 'unknown sse error' unless @body.body == :sse
-            end
-
-            # TODO any real reason not to run afters with SSE?
-            # @base.filter :after
-
-            respond
-          else
+        if !@response_handler
             raise NotImplementedError
+        end
+        @base.filter :before
+        @body = catch(:halt) do
+          @base.eventsource do |socket|
+            @base.instance_exec(socket, &@response_handler)
           end
-        rescue IOError => ioe
-          warn "#{ioe.class} - #{ioe.message}"
-        rescue RequestError => re
-          headers SSE_HEADER
-          handle_error re, re.type
-        rescue => e
-          handle_error e
         end
+        if HALT_STRUCT === @body
+          raise RequestError.new 'unknown sse error' unless @body.body == :sse
+        end
+
+        # TODO any real reason not to run afters with SSE?
+        # @base.filter :after
+
+        respond
+      rescue IOError => ioe
+        warn "#{ioe.class} - #{ioe.message}"
+      rescue RequestError => re
+        headers SSE_HEADER
+        handle_error re, re.type
+      rescue => e
+        handle_error e
       end
 
       def respond

data/lib/angelo/responder/websocket.rb

@@ -22,10 +22,9 @@ module Angelo
         begin
           if @response_handler
             Angelo.log @connection, @request, @websocket, :switching_protocols
-            @bound_response_handler ||= @response_handler.bind @base
             @websocket.on_pong &Responder::Websocket.on_pong
             @base.filter :before
-            @bound_response_handler[@websocket]
+            @base.instance_exec(@websocket, &@response_handler)
             @base.filter :after
           else
             raise NotImplementedError

data/lib/angelo/stash.rb

@@ -127,9 +127,11 @@ module Angelo
       extend Stash::ClassMethods
       include Stash
 
-      def event data
-        raise ArgumentError.new 'use #message method for "messages"' if @context == :default
-        each {|s| s.write Angelo::Base.sse_event(@context, data)}
+      def event *args
+        name, data = args
+        raise ArgumentError if @context == :default and data.nil?
+        data, name = name, @context if data.nil?
+        each {|s| s.write Angelo::Base.sse_event(name, data)}
         nil
       end
 

data/lib/angelo/tilt/erb.rb

@@ -13,16 +13,13 @@ module Angelo
       # hrm, sneaky
       #
       def self.included base
-
-        # TODO: remove at 0.4
-        warn "[DEPRECATED] Angelo::Tilt::ERB will be included by default in angelo >= 0.4"
-        raise "Angelo requires Tilt >= 2.0, you have #{::Tilt::VERSION}" unless ::Tilt::VERSION.to_i >= 2
-
         base.extend ClassMethods
       end
 
       module ClassMethods
 
+        @reload_templates = false
+
         def view_glob *glob
           File.join views_dir, *glob
         end
@@ -33,6 +30,7 @@ module Angelo
             return h if (block_given? && yield(v))
             sym.gsub! File::SEPARATOR, UNDERSCORE
             sym.gsub! /\.\w+?\.erb$/, EMPTY_STRING
+            sym.gsub! /^#{LAYOUTS_DIR}#{UNDERSCORE}/, EMPTY_STRING
             h[sym.to_sym] = ::Tilt::ERBTemplate.new v
             h
           end
@@ -40,22 +38,51 @@ module Angelo
 
         def templates type = DEFAULT_TYPE
           @templates ||= {}
-          @templates[type] ||= templatify('**', "*.#{type}.erb") do |v|
+          if reload_templates?
+            @templates[type] = load_templates(type)
+          else
+            @templates[type] ||= load_templates(type)
+          end
+        end
+
+        def load_templates type = DEFAULT_TYPE
+          templatify('**', "*.#{type}.erb") do |v|
             v =~ /^#{LAYOUTS_DIR}#{File::SEPARATOR}/
           end
         end
 
         def layout_templates type = DEFAULT_TYPE
-          @layout_templates ||= templatify LAYOUTS_DIR, "*.#{type}.erb"
+          if reload_templates?
+            @layout_templates = load_layout_templates(type)
+          else
+            @layout_templates ||= load_layout_templates(type)
+          end
+        end
+
+        def load_layout_templates type = DEFAULT_TYPE
+          templatify LAYOUTS_DIR, "*.#{type}.erb"
         end
 
         def default_layout type = DEFAULT_TYPE
           @default_layout ||= {}
-          if @default_layout[type].nil?
-            l = view_glob(DEFAULT_LAYOUT % type)
-            @default_layout[type] = ::Tilt::ERBTemplate.new l if File.exist? l
+          if reload_templates?
+            @default_layout[type] = load_default_layout(type)
+          else
+            @default_layout[type] ||= load_default_layout(type)
           end
-          @default_layout[type]
+        end
+
+        def load_default_layout type = DEFAULT_TYPE
+          l = view_glob(DEFAULT_LAYOUT % type)
+          ::Tilt::ERBTemplate.new l if File.exist? l
+        end
+
+        def reload_templates! on = true
+          @reload_templates = on
+        end
+
+        def reload_templates?
+          @reload_templates
         end
 
       end

data/lib/angelo/version.rb

@@ -1,3 +1,3 @@
 module Angelo
-  VERSION = '0.3.3'
+  VERSION = '0.4.0'
 end