pakyow-core 0.8rc1 → 0.8.rc4

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

@@ -0,0 +1,37 @@
+module Pakyow
+  module Config
+    class Logger
+      Config::Base.register_config(:logger, self)
+
+      class << self
+        attr_accessor :path, :name, :sync, :colorize, :auto_flush, :level
+
+        # Path to logs
+        def path
+          @path || "#{Config::Base.app.root}/logs"
+        end
+
+        def name
+          @name || "requests.log"
+        end
+
+        def sync
+          instance_variable_defined?(:@sync) ? @sync : true
+        end
+
+        def auto_flush
+          instance_variable_defined?(:@auto_flush) ? @auto_flush : true
+        end
+
+        def colorize
+          instance_variable_defined?(:@colorize) ? @colorize : true
+        end
+
+        def level
+          @level || Pakyow::Logger::LEVELS[:debug]
+        end
+
+      end
+    end
+  end
+end

data/pakyow-core/lib/core/{configuration → config}/server.rb

@@ -1,6 +1,8 @@
 module Pakyow
-  module Configuration
+  module Config
     class Server
+      Config::Base.register_config(:server, self)
+
       class << self
         attr_accessor :port, :host, :handler
         

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

@@ -0,0 +1,3 @@
+module Pakyow
+  class Error < StandardError; end
+end

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

@@ -1,19 +1,25 @@
 module Pakyow
 
-  # Helper methods that simply provide information (for use in binders)
-  module GeneralHelpers
-    def request
-      Pakyow.app.request
-    end
-    
-    def response
-      Pakyow.app.response
+  # For methods that should be accessible anywhere
+  module Helpers
+    def logger
+      request.logger
     end
-    
+
     def router
       RouteLookup.new
     end
 
+    def request
+      @request
+    end
+    alias_method :req, :request
+
+    def response
+      @response
+    end
+    alias_method :res, :response
+
     def params
       request.params
     end
@@ -25,14 +31,12 @@ module Pakyow
     def cookies
       request.cookies
     end
-  end
 
-  # Helper methods specific to delegates and controllers.
-  module Helpers
-    include GeneralHelpers
-    
-    def app
-      Pakyow.app
+    def config
+      Pakyow::Config::Base
     end
   end
+
+  # For methods that should only be accessible through App
+  module AppHelpers; end
 end

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

@@ -17,7 +17,7 @@ module Pakyow
           next if FileTest.directory?(path)
           next if path.split('.')[-1] != 'rb'
           
-          if Configuration::Base.app.auto_reload
+          if Config::Base.app.auto_reload
             if !@times[path] || (@times[path] && File.mtime(path) - @times[path] > 0)
               load(path)
               @times[path] = File.mtime(path)

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

@@ -1,28 +1,124 @@
+module Pakyow
+  class Logger
+    LEVELS = {
+      :debug   => 0,
+      :info    => 1,
+      :warn    => 2,
+      :error   => 3,
+      :fatal   => 4,
+      :unknown => 5,
+    }
+
+    LEVEL_COLORS = {
+      :debug   => :cyan,
+      :info    => :green,
+      :warn    => :yellow,
+      :error   => :red,
+      :fatal   => :red,
+      # :unknown => nil,
+    }
+
+    COLOR_TABLE = [
+      :black,
+      :red,
+      :green,
+      :yellow,
+      :blue,
+      :magenta,
+      :cyan,
+      :white,
+    ]
+
+    RESET_SEQ = "\033[0m"
+    COLOR_SEQ = "\033[%dm"
+    BOLD_SEQ  = "\033[1m"
+
+    def initialize(log = $stdout, level = 0, format = false, auto_flush = false)
+      @log, @level, @format, @auto_flush = log, level, format, auto_flush
+      @mutex = Mutex.new
+    end
+
+    def <<(msg = nil, severity = :unknown)
+      msg << "\n"
+
+      msg = format(msg, severity) if @format
+      @mutex.synchronize do
+        @log.write msg
+        @log.flush if @auto_flush
+      end
+    end
+
+    alias :write :<<
+
+    def add(severity, msg = nil)
+      severity ||= LEVELS[:unknown]
+      return if severity < @level
+
+      write(msg, severity)
+    end
+
+    alias :log :add
+
+    def debug(msg = nil)
+      add(LEVELS[:debug], msg)
+    end
+
+    def info(msg = nil)
+      add(LEVELS[:info], msg)
+    end
+
+    def warn(msg = nil)
+      add(LEVELS[:warn], msg)
+    end
+
+    def error(msg = nil)
+      add(LEVELS[:error], msg)
+    end
+
+    def fatal(msg = nil)
+      add(LEVELS[:fatal], msg)
+    end
+
+    def format(msg, level)
+      return msg unless color = level_color(level)
+      return COLOR_SEQ % (30 + COLOR_TABLE.index(color)) + msg + RESET_SEQ
+    end
+
+    def level_color(level)
+      LEVEL_COLORS[LEVELS.key(level)]
+    end
+
+    def close
+      @log.close
+    end
+
+  end
+end
+
 module Pakyow
   module Middleware
     class Logger
+      # handles logging after an error occurs
+      Pakyow::App.after(:error) {
+        error = request.error
+        Pakyow.logger.error "[500] #{error}\n" + error.backtrace.join("\n") + "\n\n"
+      }
+
       def initialize(app)
         @app = app
       end
-      
+
       def call(env)
+        env['rack.logger'] = Pakyow.logger
+
         result = nil
         difference = time { |began_at|
-          Log.enter "Processing #{env['PATH_INFO']} (#{env['REMOTE_ADDR']} at #{began_at}) [#{env['REQUEST_METHOD']}]"
-          
-          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
+          Pakyow.logger << "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']} for #{env['REMOTE_ADDR']} at #{began_at}"
+          result = @app.call(env)
         }
-        
-        Log.enter "Completed in #{difference}ms | #{Pakyow.app.response.status} | [#{Pakyow.app.request.url}]"
-        Log.enter
+
+        status = result[0]
+        Pakyow.logger << "#{status} (#{nice_status(status)}) in #{difference}ms\n"
 
         result
       end
@@ -30,7 +126,65 @@ module Pakyow
       def time
         s = Time.now
         yield(s)
-        (Time.now.to_f - s.to_f) * 1000.0
+        time = ((Time.now.to_f - s.to_f) * 1000.0)
+        (time * 10**2).round / (10**2).to_f
+      end
+
+      def nice_status(status)
+        {
+          100 => 'Continue',
+          101 => 'Switching Protocols',
+
+          200 => 'OK',
+          201 => 'Created',
+          202 => 'Accepted',
+          203 => 'Non-Authoritative Information',
+          204 => 'No Content',
+          205 => 'Reset Content',
+          206 => 'Partial Content',
+
+          300 => 'Multiple Choices',
+          301 => 'Moved Permanently',
+          302 => 'Found',
+          303 => 'See Other',
+          304 => 'Not Modified',
+          305 => 'Use Proxy',
+          306 => 'Switch Proxy',
+          307 => 'Temporary Redirect',
+
+          400 => 'Bad Request',
+          401 => 'Unauthorized',
+          402 => 'Payment Required',
+          403 => 'Forbidden',
+          404 => 'Not Found',
+          405 => 'Method Not Allowed',
+          406 => 'Not Acceptable',
+          407 => 'Proxy Authentication Required',
+          408 => 'Request Timeout',
+          409 => 'Conflict',
+          410 => 'Gone',
+          411 => 'Length Required',
+          412 => 'Precondition Failed',
+          413 => 'Request Entity Too Large',
+          414 => 'Request-URI Too Long',
+          415 => 'Unsupported Media Type',
+          416 => 'Requested Range Not Satisfiable',
+          417 => 'Expectation Failed',
+          418 => 'I\'m a teapot',
+
+          500 => 'Internal Server Error',
+          501 => 'Not Implemented',
+          502 => 'Bad Gateway',
+          503 => 'Service Unavailable',
+          504 => 'Gateway Timeout',
+          505 => 'HTTP Version Not Supported',
+          506 => 'Variant Also Negotiates',
+          507 => 'Insufficient Storage',
+          508 => 'Loop Detected',
+          509 => 'Bandwidth Limit Exceeded',
+          510 => 'Not Extended',
+          511 => 'Network Authentication Required'
+        }[status] || '?'
       end
     end
   end

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

@@ -4,24 +4,36 @@ module Pakyow
       def initialize(app)
         @app = app
       end
-      
+
       def call(env)
-        if is_static?(env)
-          response = Rack::Response.new
-          
+        static, resource_path = is_static?(env)
+
+        if static
           catch(:halt) do
-            Pakyow.app.send(File.open(File.join(Configuration::Base.app.public_dir, env['PATH_INFO'])))
+            app = Pakyow.app.dup
+            app.response = Response.new
+            app.request = Request.new(env)
+            app.send(File.open(resource_path))
           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']))
+        return false unless env['PATH_INFO'] =~ /\.(.*)$/
+
+        Config::App.resources.each_pair do |name, path|
+          resource_path = File.join(path, env['PATH_INFO'])
+          next unless File.exists?(resource_path)
+          return true, resource_path
+        end
+
+        return false
       end
     end
   end
 end
+

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

@@ -0,0 +1,19 @@
+module Pakyow
+  class MultiLog
+    def initialize(*targets)
+      @targets = targets
+    end
+
+    def write(*args)
+      @targets.each { |t| t.write(*args) }
+    end
+
+    def close
+      @targets.each(&:close)
+    end
+
+    def flush
+      @targets.each(&:flush)
+    end
+  end
+end

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

@@ -2,61 +2,81 @@ module Pakyow
 
   # The Request object.
   class Request < Rack::Request
-    attr_accessor :restful, :route_path, :controller, :action, :format, :error, :working_path, :working_method
+    attr_accessor :restful, :route_path, :controller, :action, :format, 
+    :error, :app, :path, :method, :paths, :methods, :formats
 
     def initialize(*args)
       super
 
-      self.setup(self.path)
+      @paths = []
+      @methods = []
+      @formats = []
+
+      @path = path_info
+      @method = request_method.downcase.to_sym
     end
 
-    # Easy access to path_info.
-    def path
-      self.path_info
+    def path=(path)
+      @paths << path
+      @path = path
     end
-    
-    # Determines the request method.
-    def method
-      request_method.downcase.to_sym
+
+    def method=(method)
+      @methods << method
+      @method = method
     end
 
     def format=(format)
-      @format = format ? format.to_sym : :html
-      
+      format = format ? format.to_sym : :html
+      @formats << format
+      @format = format
+
       # Set response type
-      Pakyow.app.response["Content-Type"] = Rack::Mime.mime_type(".#{@format}")
+      @app.response["Content-Type"] = Rack::Mime.mime_type(".#{@format}")
+    end
+
+    def first_path
+      @paths[0]
+    end
+
+    def first_method
+      @methods[0]
+    end
+
+    def first_format
+      @formats[0]
     end
 
     def session
       self.env['rack.session'] || {}
     end
-    
+
     def cookies
       @cookies ||= HashUtils.strhash(super)
     end
-    
+
     # Returns indifferent params (see {HashUtils.strhash} for more info on indifferent hashes).
     def params
       @params ||= HashUtils.strhash(super)
     end
-    
+
     # Returns array of url components.
     def path_parts
-      @url ||= self.path ? self.class.split_url(self.path) : []
+      @url ||= path ? self.class.split_url(path) : []
     end
 
     def referer
-      @referer ||= self.env['HTTP_REFERER']
+      @referer ||= env['HTTP_REFERER']
     end
-    
+
     # Returns array of referer components.
     def referer_parts
-      @referer_parts ||= self.referer ? self.class.split_url(self.referer) : []
+      @referer_parts ||= referer ? self.class.split_url(referer) : []
     end
 
-    def setup(path, method = nil)
-      self.set_request_format_from_path(path)
-      self.set_working_path_from_path(path, method)
+    def setup(path = self.path, method = nil)
+      set_request_format_from_path(path)
+      set_working_path_from_path(path, method)
     end
 
     #TODO move to util class
@@ -65,25 +85,27 @@ module Pakyow
       url.split('/').each { |r|
         arr << r unless r.empty?
       }
-      
+
       return arr
     end
-    
+
+    def has_route_vars?
+      return false if @route_path.nil?
+      return false if @route_path.is_a?(Regexp)
+      return true  if @route_path.index(':')
+    end
+
     protected
 
     def set_working_path_from_path(path, method)
       base_route, ignore_format = StringUtils.split_at_last_dot(path)
 
-      self.working_path = base_route
-      self.working_method = method || self.method
+      self.path = base_route
+      self.method = method || self.method
     end
 
     def set_request_format_from_path(path)
       path, format = StringUtils.split_at_last_dot(path)
-
-      #TODO why it no work without this? was working fine in application
-      return unless format
-
       self.format = ((format && (format[format.length - 1, 1] == '/')) ? format[0, format.length - 1] : format)
     end
   end