pakyow-core 0.6.3.1 → 0.7.0

data/pakyow-core/bin/pakyow

@@ -9,6 +9,9 @@ if ARGV.first == 'new'
 elsif ARGV.first == 'server'
   ARGV.shift
   require 'commands/server'
+elsif ARGV.first == 'console'
+  ARGV.shift
+  require 'commands/console'
 elsif ARGV.first == '--help' || ARGV.first == '-h' || ARGV.empty?
   puts File.open(File.join(CORE_PATH, 'commands/USAGE')).read
 end

data/pakyow-core/lib/commands/USAGE-CONSOLE

@@ -0,0 +1,12 @@
+Usage:
+  pakyow console [environment]
+  
+Description:
+    The 'pakyow console' command stages the application and starts an interactive
+    session. If environment is not specified, the default_environment defined by 
+    your application will be used.
+
+Example:
+    pakyow console development
+
+    This starts the console with the 'development' configuration.

data/pakyow-core/lib/commands/console.rb

@@ -0,0 +1,18 @@
+if ARGV.first == '--help' || ARGV.first == '-h'
+  puts File.open(File.join(CORE_PATH, 'commands/USAGE-CONSOLE')).read
+else
+  $:.unshift(Dir.pwd)
+
+  require File.join('config', 'application')
+  PakyowApplication::Application.stage(ARGV.first)
+  
+  def reload
+    puts "Reloading..."
+    Pakyow.app.reload
+  end
+  
+  require 'irb'
+  ARGV.clear
+  IRB.start
+end
+

data/pakyow-core/lib/core/application.rb

@@ -1,18 +1,18 @@
 module Pakyow
   class Application
     class << self
-      attr_accessor :routes_proc, :middleware_proc, :configurations, :error_handlers
-      
+      attr_accessor :routes_proc, :handlers_proc, :middleware_proc, :configurations
+
       # Sets the path to the application file so it can be reloaded later.
       #
       def inherited(subclass)
         Pakyow::Configuration::App.application_path = parse_path_from_caller(caller[0])
       end
-      
+
       def parse_path_from_caller(caller)
         caller.match(/^(.+)(:?:\d+(:?:in `.+')?$)/)[1]
       end
-      
+
       # Runs the application. Accepts the environment(s) to run, for example:
       # run(:development)
       # run([:development, :staging])
@@ -20,47 +20,45 @@ module Pakyow
       def run(*args)
         return if running?
         @running = true
-        
-        self.builder.run(self.prepare(*args))
+        self.builder.run(self.prepare(args))
         detect_handler.run(builder, :Host => Pakyow::Configuration::Base.server.host, :Port => Pakyow::Configuration::Base.server.port)
       end
-      
+
       # Stages the application. Everything is loaded but the application is
       # not started. Accepts the same arguments as #run.
       #
       def stage(*args)
         return if staged?
         @staged = true
-        
-        prepare(*args)
+        prepare(args)
       end
-      
+
       def builder
         @builder ||= Rack::Builder.new
       end
-      
+
       def prepared?
         @prepared
       end
-      
+
       # Returns true if the application is running.
       #
       def running?
         @running
       end
-      
+
       # Returns true if the application is staged.
       #
       def staged?
         @staged
       end
-      
+
       # Convenience method for base configuration class.
       #
       def config
         Pakyow::Configuration::Base
       end
-      
+
       # Creates configuration for a particular environment. Example:
       # configure(:development) { app.auto_reload = true }
       #
@@ -68,68 +66,64 @@ module Pakyow
         self.configurations ||= {}
         self.configurations[environment] = block
       end
-      
+
       # Creates routes. Example:
       # routes { get '/' { # do something } }
       #
       def routes(&block)
         self.routes_proc = block
       end
-      
-      # Creates an error handler (currently 404 and 500 errors are handled). 
+
+      # Creates handlers for later execution.
       # The handler can be created one of two ways:
       #
-      # Define a controller/action for a particular error:
-      # error(404, :ApplicationController, :handle_404)
+      # Define a controller/action handler with an associate response status:
+      # handler(name, 404, :ApplicationController, :handle_404)
       #
-      # Specify a block for a particular error:
-      # error(404) { # handle error }
+      # Specify a block as a handler:
+      # handler(name, 404) { # handle error }
       #
-      def error(*args, &block)
-        self.error_handlers ||= {}
-        code, controller, action = args
-        
-        if block
-          self.error_handlers[code] = block
-        else
-          self.error_handlers[code] = {
-            :controller => controller, 
-            :action => action
-          }
-        end
+      # If a controller calls #invoke_handler!(name) then the
+      # handler defined for that code will be invoked.
+      #
+      def handlers(&block)
+        self.handlers_proc = block
       end
-      
+
       def middleware(&block)
         self.middleware_proc = block
       end
-      
+
       protected
-      
+
       # Prepares the application for running or staging and returns an instance
       # of the application.
-      def prepare(*args)
+      def prepare(args)
         self.load_config args.empty? || args.first.nil? ? [Configuration::Base.app.default_environment] : args
         return if prepared?
-        
+
         self.builder.use(Rack::MethodOverride)
         self.builder.instance_eval(&self.middleware_proc) if self.middleware_proc
+        self.builder.use(Pakyow::Static) if Configuration::Base.app.static
+        self.builder.use(Pakyow::Logger) if Configuration::Base.app.log
+        self.builder.use(Pakyow::Reloader) if Configuration::Base.app.auto_reload
         
         @prepared = true
-        
+
         $:.unshift(Dir.pwd) unless $:.include? Dir.pwd
         return self.new
       end
-      
+
       def load_config(args)
         if self.configurations
           args << Configuration::Base.app.default_environment if args.empty?
           args.each do |env|
-            next unless config = self.configurations[env]
+            next unless config = self.configurations[env.to_sym]
             Configuration::Base.instance_eval(&config)
           end
         end
       end
-      
+
       def detect_handler
         ['thin', 'mongrel', 'webrick'].each do |server|
           begin
@@ -142,153 +136,172 @@ module Pakyow
     end
 
     include Helpers
-    
-    attr_accessor :request, :response, :presenter, :route_store, :restful_routes
-    
+
+    attr_accessor :request, :response, :presenter, :route_store, :restful_routes, :handler_store
+
     def initialize
       Pakyow.app = self
-      
-      # Create static handler
-      @static_handler = Rack::File.new(Configuration::Base.app.public_dir)
-      
+      @handler_name_to_code = {}
+      @handler_code_to_name = {}
+
       # This configuration option will be set if a presenter is to be used
       if Configuration::Base.app.presenter
         # Create a new instance of the presenter
         self.presenter = Configuration::Base.app.presenter.new
       end
-      
+
       # Load application files
-      load_app
+      load_app(false)
     end
-    
+
     # Interrupts the application and returns response immediately.
     #
-    def interrupt!
-      @interrupted = true
+    def halt!
       throw :halt, self.response
     end
-    
+
+    def invoke_route!(route, method=nil)
+      self.request.working_path = route
+      self.request.working_method = method if method
+      block = prepare_route_block(route, self.request.working_method)
+      throw :new_block, block
+    end
+
+    def invoke_handler!(name_or_code)
+      if block = @handler_store[name_or_code]
+        # we are given a name
+        code = @handler_name_to_code[name_or_code]
+        self.response.status = code if code
+        throw :new_block, block
+      elsif name = @handler_code_to_name[name_or_code]
+        # we are given a code
+        block = @handler_store[name]
+        self.response.status = name_or_code
+        throw :new_block, block
+      else
+        # no block to be found
+        # do we assume code if a number and set status?
+        self.response.status = name_or_code if name_or_code.is_a?(Fixnum)
+        # still need to stop execution, I think? But do nothing.
+        throw :new_block, nil
+      end
+    end
+
     # Called on every request.
     #
     def call(env)
-      start_time = Time.now.to_f
-      
-      # Handle static files
-      if env['PATH_INFO'] =~ /\.(.*)$/ && File.exists?(File.join(Configuration::Base.app.public_dir, env['PATH_INFO']))
-        @static = true
-        @static_handler.call(env)        
-      else
-        # The request object
-        self.request = Request.new(env)
-        
-        # Reload application files
-        load_app
-        
-        if Configuration::Base.app.presenter
-          # Handle presentation for this request
-          self.presenter.present_for_request(request)
+      self.request = Request.new(env)
+      self.response = Rack::Response.new
+      self.request.working_path = self.request.path
+      self.request.working_method = self.request.method
+
+      has_route = false
+      catch(:halt) {
+        route_block = prepare_route_block(self.request.path, self.request.method)
+        has_route = true if route_block
+
+        if self.presenter
+          self.presenter.prepare_for_request(self.request)
         end
-        
-        Log.enter "Processing #{env['PATH_INFO']} (#{env['REMOTE_ADDR']} at #{Time.now}) [#{env['REQUEST_METHOD']}]"
-        
-        # The response object
-        self.response = Rack::Response.new
-        rhs = nil
-        just_the_path, format = StringUtils.split_at_last_dot(self.request.path)
-        self.request.format = ((format && (format[format.length - 1, 1] == '/')) ? format[0, format.length - 1] : format)
-        catch(:halt) do
-          rhs, packet = @route_store.get_block(just_the_path, self.request.method)
-          request.params.merge!(HashUtils.strhash(packet[:vars]))
-
-          self.request.route_spec = packet[:data][:route_spec] if packet[:data]
-          restful_info = packet[:data][:restful] if packet[:data]
-          self.request.restful = restful_info
-          rhs.call() if rhs && !Pakyow::Configuration::App.ignore_routes
+
+        has_route = trampoline(route_block) if !Pakyow::Configuration::App.ignore_routes
+
+        if self.presenter
+          self.response.body = [self.presenter.content]
         end
-        
-        if !self.interrupted?
-          if Configuration::Base.app.presenter
-            self.response.body = [self.presenter.content]
-          end
-          
-          # 404 if no facts matched and no views were found
-          if !rhs && (!self.presenter || !self.presenter.presented?)
-            self.handle_error(404)
-            
-            Log.enter "[404] Not Found"
-            self.response.status = 404
+
+        # 404 if no route matched and no views were found
+        if !has_route && (!self.presenter || !self.presenter.presented?)
+          Log.enter "[404] Not Found"
+          handler404 = @handler_store[@handler_code_to_name[404]] if @handler_code_to_name[404]
+          if handler404
+            catch(:halt) {
+              if self.presenter
+                self.presenter.prepare_for_request(self.request)
+              end
+              trampoline(handler404)
+              if self.presenter then
+                self.response.body = [self.presenter.content]
+              end
+            }
           end
+          self.response.status = 404
         end
-        
-        return finish!
-      end
+      } #end :halt catch block
+
+      # This needs to be in the 'return' position (last statement)
+      finish!
+
     rescue StandardError => error
       self.request.error = error
-      self.handle_error(500)
-      
-      Log.enter "[500] #{error}\n"
-      Log.enter error.backtrace.join("\n") + "\n\n"
-      
-      # self.response = Rack::Response.new
-      
+      handler500 = @handler_store[@handler_code_to_name[500]] if @handler_code_to_name[500]
+        if handler500
+          catch(:halt) {
+            if self.presenter
+              self.presenter.prepare_for_request(self.request)
+            end
+            trampoline(handler500)
+            if self.presenter then
+              self.response.body = [self.presenter.content]
+            end
+          } #end :halt catch block
+        end
+      self.response.status = 500
+
       if Configuration::Base.app.errors_in_browser
-        # Show errors in browser
         self.response.body = []
         self.response.body << "<h4>#{CGI.escapeHTML(error.to_s)}</h4>"
         self.response.body << error.backtrace.join("<br />")
       end
-      
-      self.response.status = 500
-      return finish!
-    ensure
-      unless @static
-        end_time = Time.now.to_f
-        difference = ((end_time - start_time) * 1000).to_f
-
-        Log.enter "Completed in #{difference}ms | #{self.response.status} | [#{self.request.url}]"
-        Log.enter
+
+      begin
+        # caught by other middleware (e.g. logger)
+        throw :error, error
+      rescue ArgumentError
       end
+
+      finish!
     end
-    
-    # Sends a file in the response (immediately). Accepts a File object. Mime 
+
+    # Sends a file in the response (immediately). Accepts a File object. Mime
     # type is automatically detected.
     #
-    def send_file(source_file, send_as = nil, type = nil)
+    def send_file!(source_file, send_as = nil, type = nil)
       path = source_file.is_a?(File) ? source_file.path : source_file
       send_as ||= path
       type    ||= Rack::Mime.mime_type(".#{send_as.split('.')[-1]}")
-      
+
       data = ""
       File.open(path, "r").each_line { |line| data << line }
-      
+
       self.response = Rack::Response.new(data, self.response.status, self.response.header.merge({ "Content-Type" => type }))
-      interrupt!
+      halt!
     end
-    
-    # Sends data in the response (immediately). Accepts the data, mime type, 
+
+    # Sends data in the response (immediately). Accepts the data, mime type,
     # and optional file name.
     #
-    def send_data(data, type, file_name = nil)
+    def send_data!(data, type, file_name = nil)
       status = self.response ? self.response.status : 200
-      
+
       headers = self.response ? self.response.header : {}
       headers = headers.merge({ "Content-Type" => type })
       headers = headers.merge({ "Content-disposition" => "attachment; filename=#{file_name}"}) if file_name
-      
+
       self.response = Rack::Response.new(data, status, headers)
-      interrupt!
+      halt!
     end
-    
+
     # Redirects to location (immediately).
     #
-    def redirect_to(location, status_code = 302)
+    def redirect_to!(location, status_code = 302)
       headers = self.response ? self.response.header : {}
       headers = headers.merge({'Location' => location})
-      
+
       self.response = Rack::Response.new('', status_code, headers)
-      interrupt!
+      halt!
     end
-    
+
     # Registers a route for GET requests. Route can be defined one of two ways:
     # get('/', :ControllerClass, :action_method)
     # get('/') { # do something }
@@ -296,62 +309,62 @@ module Pakyow
     # Routes for namespaced controllers (e.g. Admin::ControllerClass) can be defined like this:
     # get('/', :Admin_ControllerClass, :action_method)
     #
-    def get(route, controller = nil, action = nil, &block)
-      register_route(route, block, :get, controller, action)
+    def get(route, *args, &block)
+      register_route(:user, route, block, :get, *args)
     end
-    
+
     # Registers a route for POST requests (see #get).
     #
-    def post(route, controller = nil, action = nil, &block)
-      register_route(route, block, :post, controller, action)
+    def post(route, *args, &block)
+      register_route(:user, route, block, :post, *args)
     end
-    
+
     # Registers a route for PUT requests (see #get).
     #
-    def put(route, controller = nil, action = nil, &block)
-      register_route(route, block, :put, controller, action)
+    def put(route, *args, &block)
+      register_route(:user, route, block, :put, *args)
     end
-    
+
     # Registers a route for DELETE requests (see #get).
     #
-    def delete(route, controller = nil, action = nil, &block)
-      register_route(route, block, :delete, controller, action)
+    def delete(route, *args, &block)
+      register_route(:user, route, block, :delete, *args)
     end
-    
+
     # Registers the default route (see #get).
     #
-    def default(controller = nil, action = nil, &block)
-      register_route('/', block, :get, controller, action)
+    def default(*args, &block)
+      register_route(:user, '/', block, :get, *args)
     end
-    
-    # Creates REST routes for a resource. Arguments: url, controller, model
+
+    # Creates REST routes for a resource. Arguments: url, controller, model, hooks
     #
-    def restful(*args, &block)
-      url, controller, model = args
-      
+    def restful(url, controller, *args, &block)
+      model, hooks = parse_restful_args(args)
+
       with_scope(:url => url.gsub(/^[\/]+|[\/]+$/,""), :model => model) do
         nest_scope(&block) if block_given?
-        
+
         @restful_routes         ||= {}
         @restful_routes[model]  ||= {} if model
-        
+
         @@restful_actions.each do |opts|
-          action_url = current_path          
+          action_url = current_path
           if suffix = opts[:url_suffix]
             action_url = File.join(action_url, suffix)
           end
-          
+
           # Create the route
-          register_route(action_url, nil, opts[:method], controller, opts[:action], :restful)
-          
+          register_route(:restful, action_url, nil, opts[:method], controller, opts[:action], hooks)
+
           # Store url for later use (currently used by Binder#action)
           @restful_routes[model][opts[:action]] = action_url if model
         end
-        
+
         remove_scope
       end
     end
-    
+
     @@restful_actions = [
       { :action => :edit, :method => :get, :url_suffix => 'edit/:id' },
       { :action => :show, :method => :get, :url_suffix => ':id' },
@@ -361,108 +374,196 @@ module Pakyow
       { :action => :index, :method => :get },
       { :action => :create, :method => :post }
     ]
-    
+
+    def hook(name, controller = nil, action = nil, &block)
+      block = build_controller_block(controller, action) if controller
+      @route_store.add_hook(name, block)
+    end
+
+    def handler(name, *args, &block)
+      code, controller, action = parse_handler_args(args)
+
+      if block_given?
+        @handler_store[name] = block
+      else
+        @handler_store[name] = build_controller_block(controller, action)
+      end
+
+      if code
+        @handler_name_to_code[name] = code
+        @handler_code_to_name[code] = name
+      end
+    end
+
+    #TODO: don't like this...
+    def reload
+      load_app
+    end
+
     protected
-    
-    def interrupted?
-      @interrupted
+
+    def prepare_route_block(route, method)
+      set_request_format_from_route(route)
+
+      controller_block, packet = @route_store.get_block(route, method)
+
+      self.request.params.merge!(HashUtils.strhash(packet[:vars]))
+      self.request.route_spec = packet[:data][:route_spec] if packet[:data]
+      self.request.restful = packet[:data][:restful] if packet[:data]
+
+      controller_block
     end
-    
+
+    def trampoline(block)
+      last_call_has_block = (block == nil) ? false : true
+      while block do
+        block = catch(:new_block) {
+          block.call()
+          # Getting here means that call() returned normally (not via a throw)
+          :fall_through
+        } # end :invoke_route catch block
+        # If invoke_route! or invoke_handler! was called in the block, block will have a new value (nil or block).
+        # If neither was called, block will be :fall_through
+
+        if block == nil
+          last_call_has_block = false
+        elsif block == :fall_through
+          last_call_has_block = true
+          block = nil
+        end
+
+        if block && self.presenter
+          self.presenter.prepare_for_request(self.request)
+        end
+      end
+      last_call_has_block
+    end
+
+    def parse_route_args(args)
+      controller = args[0] if args[0] && (args[0].is_a?(Symbol) || args[0].is_a?(String))
+      action = args[1] if controller
+      hooks = args[2] if controller
+      unless controller
+        hooks = args[0] if args[0] && args[0].is_a?(Hash)
+      end
+      return controller, action, hooks
+    end
+
+    def parse_restful_args(args)
+      model = args[0] if args[0] && (args[0].is_a?(Symbol) || args[0].is_a?(String))
+      hooks = args[1] if model
+      unless model
+        hooks = args[0] if args[0] && args[0].is_a?(Hash)
+      end
+      return model, hooks
+    end
+
+    def parse_handler_args(args)
+      code = args[0] if args[0] && args[0].is_a?(Fixnum)
+      controller = args[1] if code && args[1]
+      action = args[2] if controller && args[2]
+      unless code
+        controller = args[0] if args[0]
+        action = args[1] if controller && args[1]
+      end
+      return code, controller, action
+    end
+
     # Handles route registration.
     #
-    def register_route(route, block, method, controller = nil, action = nil, type = :user)
+    def register_route(type, route, block, method, *args)
+      controller, action, hooks = parse_route_args(args)
       if controller
-        controller = eval(controller.to_s)
-        action ||= Configuration::Base.app.default_action
-        
-        block = lambda {
-          instance = controller.new
-          request.controller  = instance
-          request.action      = action
-          
-          instance.send(action)
-        }
+        block = build_controller_block(controller, action)
       end
 
       data = {:route_type=>type, :route_spec=>route}
       if type == :restful
         data[:restful] = {:restful_action=>action}
       end
-      @route_store.add_route(route, block, method, data)
+      @route_store.add_route(route, block, method, data, hooks)
     end
-    
+
+    def build_controller_block(controller, action)
+      controller = eval(controller.to_s)
+      action ||= Configuration::Base.app.default_action
+
+      block = lambda {
+        instance = controller.new
+        request.controller  = instance
+        request.action      = action
+
+        instance.send(action)
+      }
+
+      block
+    end
+
+    def set_request_format_from_route(route)
+      route, format = StringUtils.split_at_last_dot(route)
+      self.request.format = ((format && (format[format.length - 1, 1] == '/')) ? format[0, format.length - 1] : format)
+    end
+
     def with_scope(opts)
       @scope         ||= {}
       @scope[:path]  ||= []
       @scope[:model] = opts[:model]
-      
+
       @scope[:path] << opts[:url]
-      
+
       yield
     end
-    
+
     def remove_scope
       @scope[:path].pop
     end
-    
+
     def nest_scope(&block)
       @scope[:path].insert(-1, ":#{StringUtils.underscore(@scope[:model].to_s)}_id")
       yield
       @scope[:path].pop
     end
-    
+
     def current_path
       @scope[:path].join('/')
     end
-    
-    def handle_error(code)
-      return unless self.class.error_handlers
-      return unless handler = self.class.error_handlers[code]
-      
-      if handler.is_a? Proc
-        Pakyow.app.instance_eval(&handler)
-      else
-        c = eval(handler[:controller].to_s).new
-        c.send(handler[:action])
-      end
-      
-      self.response.body = [self.presenter.content]
-    end
-    
+
     def set_cookies
       if self.request.cookies && self.request.cookies != {}
         self.request.cookies.each do |key, value|
-          if value.is_a?(Hash)
+          if value.nil?
+            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800 * -1 }.merge({:value => value}))
+          elsif value.is_a?(Hash)
             self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800}.merge(value))
-          elsif value.is_a?(String)
-            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800}.merge({:value => value}))
           else
-            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800 * -1 }.merge({:value => value}))
+            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800}.merge({:value => value}))
           end
         end
       end
     end
-    
+
     # Reloads all application files in application_path and presenter (if specified).
     #
-    def load_app
-      return if @loaded && !Configuration::Base.app.auto_reload
-      @loaded = true
-      
-      # Reload Application
-      load(Configuration::App.application_path)
-      
+    def load_app(reload_app = true)
+      load(Configuration::App.application_path) if reload_app
+
       @loader = Loader.new unless @loader
       @loader.load!(Configuration::Base.app.src_dir)
-      
+
+      load_handlers
       load_routes
-      
+
       # Reload views
-      if Configuration::Base.app.presenter
-        self.presenter.reload!
+      if self.presenter
+        self.presenter.load
       end
     end
-    
+
+    def load_handlers
+      @handler_store = {}
+      self.instance_eval(&self.class.handlers_proc) if self.class.handlers_proc
+    end
+
     def load_routes
       @route_store = RouteStore.new
       self.instance_eval(&self.class.routes_proc) if self.class.routes_proc
@@ -471,13 +572,7 @@ module Pakyow
     # Send the response and cleanup.
     #
     def finish!
-      @interrupted = false
-      @static = false
-      
-      # Set cookies
       set_cookies
-
-      # Finished
       self.response.finish
     end
 

data/pakyow-core/lib/core/base.rb

@@ -6,7 +6,10 @@ module Pakyow
   autoload :Request,        'core/request'
   autoload :Loader,         'core/loader'
   autoload :Application,    'core/application'
-  autoload :RouteStore,    'core/route_store'
+  autoload :RouteStore,     'core/route_store'
+  autoload :Logger,         'core/logger'
+  autoload :Static,         'core/static'
+  autoload :Reloader,       'core/reloader'
 
   # utils
   autoload :StringUtils,    'utils/string'

data/pakyow-core/lib/core/configuration/app.rb

@@ -5,7 +5,7 @@ module Pakyow
         attr_accessor :dev_mode, :log, :public_dir, :root, :log_dir, 
         :presenter, :default_action, :ignore_routes, :error_level, 
         :default_environment, :application_path, :log_name, :src_dir,
-        :auto_reload, :errors_in_browser
+        :auto_reload, :errors_in_browser, :static
         
         # Displays development-specific warnings.
         #
@@ -67,6 +67,15 @@ module Pakyow
         def application_path
           @application_path
         end
+        
+        # Handle static files?
+        #
+        # For best performance, should be set to false if static files are 
+        # handled by a web server (e.g. Nginx)
+        #
+        def static
+          @static || true
+        end
       end
     end
   end

data/pakyow-core/lib/core/log.rb

@@ -7,15 +7,15 @@ module Pakyow
     def self.puts(text = "")
       return if !Configuration::Base.app.log
       
-      @@console ||= Logger.new($stdout)
+      @@console ||= $stdout
       @@console << "#{text}\r\n"
       
       dir = "#{Configuration::Base.app.log_dir}"
       
       if File.exists?(dir)
-        @@file ||= Logger.new("#{dir}/#{Configuration::Base.app.log_name}")
-        @@file    << "#{text}\r\n"
-      end    
+        @@file ||= File.open("#{dir}/#{Configuration::Base.app.log_name}", 'a')
+        @@file.write "#{text}\r\n"
+      end
     end
 
     class << self

data/pakyow-core/lib/core/logger.rb

@@ -0,0 +1,33 @@
+module Pakyow
+  class Logger
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      began_at = Time.now
+      
+      Log.enter "Processing #{env['PATH_INFO']} (#{env['REMOTE_ADDR']} at #{began_at}) [#{env['REQUEST_METHOD']}]"
+      
+      result = nil
+      
+      if error = catch(:error) { 
+                  result = @app.call(env)
+                  nil 
+                }
+        Log.enter "[500] #{error}\n"
+        Log.enter error.backtrace.join("\n") + "\n\n"
+        
+        result = Pakyow.app.response.finish
+      end
+      
+      ended_at = Time.now.to_f
+      difference = ((ended_at - began_at.to_f) * 1000).to_f
+
+      Log.enter "Completed in #{difference}ms | #{Pakyow.app.response.status} | [#{Pakyow.app.request.url}]"
+      Log.enter
+      
+      result
+    end
+  end
+end

data/pakyow-core/lib/core/reloader.rb

@@ -0,0 +1,12 @@
+module Pakyow
+  class Reloader
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      @app.reload
+      @app.call(env)
+    end
+  end
+end

data/pakyow-core/lib/core/request.rb

@@ -2,7 +2,7 @@ module Pakyow
 
   # The Request object.
   class Request < Rack::Request
-    attr_accessor :restful, :route_spec, :controller, :action, :format, :error
+    attr_accessor :restful, :route_spec, :controller, :action, :format, :error, :working_path, :working_method
 
     # Easy access to path_info.
     def path

data/pakyow-core/lib/core/route_store.rb

@@ -5,24 +5,29 @@ module Pakyow
       @order = 1
       @store =
           {
-              # string routes are stored, for each method, as a hash of 'route'=>{:block=>b,:order=>n}
+              # string routes are stored, for each method, as a hash of 'route'=>{:block=>b,:order=>n,:hooks=>{...}}}
             :string => {:get=>{}, :post=>{}, :put=>{}, :delete=>{}},
 
-              # regex routes are stored, for each method, as an array of hashes {:regex=>r,:block=>b,:order=>n,:vars=>{n=>var}}
+              # regex routes are stored, for each method, as an array of hashes {:regex=>r,:block=>b,:order=>n,:vars=>{n=>var},:hooks=>{...}}
               # they are in definition order in the array
-            :regex => {:get=>[], :post=>[], :put=>[], :delete=>[]}
+            :regex => {:get=>[], :post=>[], :put=>[], :delete=>[]},
 
               # :order is a global order across both string and regex routes.
+
+              # hooks are blocks stored by name and used to augment returned block from get_block
+              :hooks => {}
           }
     end
 
-    def add_route(route_spec, block, method, data)
+    def add_route(route_spec, block, method, data, hooks)
       route_spec = normalize_route(route_spec)
+      hooks = normalize_hooks(hooks)
       route_to_match, vars = build_route_matcher(route_spec, data)
       
       if route_to_match.is_a?(String)
         @store[:string][method][route_to_match]={:block => block,
                                                  :order => @order,
+                                                 :hooks => hooks,
                                                  :data => data}
         @order = @order + 1
       elsif route_to_match.is_a?(Regexp)
@@ -30,6 +35,7 @@ module Pakyow
                                    :block => block,
                                    :order => @order,
                                    :vars => vars,
+                                   :hooks => hooks,
                                    :data => data}
         @order = @order + 1
       else
@@ -43,6 +49,10 @@ module Pakyow
 
     end
 
+    def add_hook(name, hook)
+      @store[:hooks][name] = hook
+    end
+
     # returns block, {:vars=>{:var=>matched_value, ...}, :data=>data}
     def get_block(route, method)
       route = normalize_route(route)
@@ -63,25 +73,55 @@ module Pakyow
       if string_route_match && regex_route_match
         if string_route_match[:order] < regex_route_match[:order]
           data = string_route_match[:data]
-          return string_route_match[:block], {:vars=>{}, :data=>data}
+          return build_hooked_block(string_route_match[:block], string_route_match[:hooks]),
+                  {:vars=>{}, :data=>data}
         else
           data = regex_route_match[:data]
-          return regex_route_match[:block], {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
+          return build_hooked_block(regex_route_match[:block], regex_route_match[:hooks]),
+                  {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
         end
       elsif string_route_match
         data = string_route_match[:data]
-        return string_route_match[:block], {:vars=>{}, :data=>data}
+        return build_hooked_block(string_route_match[:block], string_route_match[:hooks]),
+                {:vars=>{}, :data=>data}
       elsif regex_route_match
         data = regex_route_match[:data]
-        return regex_route_match[:block], {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
+        return build_hooked_block(regex_route_match[:block], regex_route_match[:hooks]),
+                {:vars=>build_regex_var_values(regex_route_match[:vars], match_data), :data=>data}
       else
-        return nil, {:vars=>{}, :data=>nil}
+        return nil,
+                {:vars=>{}, :data=>nil}
       end
 
     end
 
     private
 
+    def build_hooked_block(block, hooks)
+      unless hooks
+        return block
+      end
+      lambda {
+        hooks[:before].map { |h|
+          @store[:hooks][h].call() if @store[:hooks][h]
+        } if hooks && hooks[:before]
+
+        hooks[:around].map { |h|
+          @store[:hooks][h].call() if @store[:hooks][h]
+        } if hooks && hooks[:around]
+
+        block.call()
+
+        hooks[:around].map { |h|
+          @store[:hooks][h].call() if @store[:hooks][h]
+        } if hooks && hooks[:around]
+
+        hooks[:after].map { |h|
+          @store[:hooks][h].call() if @store[:hooks][h]
+        } if hooks && hooks[:after]
+      }
+    end
+
     # Returns a regex and an array of variable info
     def build_route_matcher(route_spec, data)
       return route_spec, [] if route_spec.is_a?(Regexp)
@@ -160,6 +200,14 @@ module Pakyow
       route_spec
     end
 
+    def normalize_hooks(hooks)
+      hooks.each_pair { |k,v|
+        unless v.is_a?(Array)
+          hooks[k] = [v]
+        end
+      } if hooks
+    end
+
     def build_regex_var_values(vars_info, match_data)
       var_values = {}
       vars_info.each { |vi|

data/pakyow-core/lib/core/static.rb

@@ -0,0 +1,25 @@
+module Pakyow
+  class Static
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      if is_static?(env)
+        Pakyow.app.response = Rack::Response.new
+        
+        catch(:halt) do
+          Pakyow.app.send_file!(File.join(Configuration::Base.app.public_dir, env['PATH_INFO']))
+        end
+      else
+        @app.call(env)
+      end
+    end
+    
+    private
+    
+    def is_static?(env)
+      env['PATH_INFO'] =~ /\.(.*)$/ && File.exists?(File.join(Configuration::Base.app.public_dir, env['PATH_INFO']))
+    end
+  end
+end

metadata

@@ -1,54 +1,53 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pakyow-core
-version: !ruby/object:Gem::Version 
-  hash: 113
+version: !ruby/object:Gem::Version
+  version: 0.7.0
   prerelease: 
-  segments: 
-  - 0
-  - 6
-  - 3
-  - 1
-  version: 0.6.3.1
 platform: ruby
-authors: 
+authors:
 - Bryan Powell
 - Bret Young
 autorequire: 
 bindir: pakyow-core/bin
 cert_chain: []
-
-date: 2011-09-13 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-19 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rack
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70115565134460 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 1
-        - 3
-        version: "1.3"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *70115565134460
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70115565133760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: *70115565133760
 description: pakyow-core
 email: bryan@metabahn.com
-executables: 
+executables:
 - pakyow
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - pakyow-core/CHANGES
 - pakyow-core/README
 - pakyow-core/MIT-LICENSE
+- pakyow-core/lib/commands/console.rb
 - pakyow-core/lib/commands/server.rb
 - pakyow-core/lib/commands/USAGE
+- pakyow-core/lib/commands/USAGE-CONSOLE
 - pakyow-core/lib/commands/USAGE-NEW
 - pakyow-core/lib/commands/USAGE-SERVER
 - pakyow-core/lib/core/application.rb
@@ -59,15 +58,19 @@ files:
 - pakyow-core/lib/core/helpers.rb
 - pakyow-core/lib/core/loader.rb
 - pakyow-core/lib/core/log.rb
+- pakyow-core/lib/core/logger.rb
 - pakyow-core/lib/core/presenter_base.rb
+- pakyow-core/lib/core/reloader.rb
 - pakyow-core/lib/core/request.rb
 - pakyow-core/lib/core/route_store.rb
+- pakyow-core/lib/core/static.rb
 - pakyow-core/lib/generators/pakyow/app/app_generator.rb
 - pakyow-core/lib/generators/pakyow/app/templates/app/lib/application_controller.rb
 - pakyow-core/lib/generators/pakyow/app/templates/app/views/main.html
 - pakyow-core/lib/generators/pakyow/app/templates/app/views/pakyow.html
 - pakyow-core/lib/generators/pakyow/app/templates/config/application.rb
 - pakyow-core/lib/generators/pakyow/app/templates/config.ru
+- pakyow-core/lib/generators/pakyow/app/templates/logs/requests.log
 - pakyow-core/lib/generators/pakyow/app/templates/public/favicon.ico
 - pakyow-core/lib/generators/pakyow/app/templates/rakefile
 - pakyow-core/lib/generators/pakyow/app/templates/README
@@ -76,41 +79,29 @@ files:
 - pakyow-core/lib/utils/hash.rb
 - pakyow-core/lib/utils/string.rb
 - pakyow-core/bin/pakyow
-has_rdoc: true
 homepage: http://pakyow.com
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - pakyow-core/lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 57
-      segments: 
-      - 1
-      - 8
-      - 7
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
       version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: pakyow-core
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: pakyow-core
 test_files: []
-
+has_rdoc: