padrino-core 0.10.6.a → 0.10.6.b

data/lib/padrino-core/logger.rb

@@ -1,10 +1,10 @@
 # Defines the log level for a Padrino project.
 PADRINO_LOG_LEVEL = ENV['PADRINO_LOG_LEVEL'] unless defined?(PADRINO_LOG_LEVEL)
+
 # Defines the logger used for a Padrino project.
-PADRINO_LOGGER    = ENV['PADRINO_LOGGER'] unless defined?(PADRINO_LOGGER)
+PADRINO_LOGGER = ENV['PADRINO_LOGGER'] unless defined?(PADRINO_LOGGER)
 
 module Padrino
-
   ##
   # @return [Padrino::Logger]
   #
@@ -35,21 +35,14 @@ module Padrino
   #   Padrino.logger = Buffered.new(STDOUT)
   #
   def self.logger=(value)
+    value.extend(Padrino::Logger::Extensions) unless (Padrino::Logger::Extensions === value)
     Thread.current[:padrino_logger] = value
   end
 
   ##
-  # Extensions to the built in Ruby logger.
+  # Padrinos internal logger, using all of Padrino log extensions.
   #
   class Logger
-
-    attr_accessor :level
-    attr_accessor :auto_flush
-    attr_reader   :buffer
-    attr_reader   :log
-    attr_reader   :init_args
-    attr_accessor :log_static
-
     ##
     # Ruby (standard) logger levels:
     #
@@ -58,6 +51,7 @@ module Padrino
     # :warn:: A warning
     # :info:: generic (useful) information about system operation
     # :debug:: low-level information for developers
+    # :devel:: Development-related information that is unnecessary in debug mode
     #
     Levels = {
       :fatal =>  7,
@@ -68,6 +62,159 @@ module Padrino
       :devel => -1,
     } unless const_defined?(:Levels)
 
+    module Extensions
+      ##
+      # Generate the logging methods for {Padrino.logger} for each log level.
+      #
+      Padrino::Logger::Levels.each_pair do |name, number|
+        define_method(name) do |*args|
+          return if number < level
+          if args.size > 1
+            bench(*args)
+          else
+            push(args * '', name)
+          end
+        end
+
+        define_method(:"#{name}?") do
+          number >= level
+        end
+      end
+
+      ##
+      # Append a to development logger a given action with time
+      #
+      # @param [string] action
+      #   The action
+      #
+      # @param [float] time
+      #   Time duration for the given action
+      #
+      # @param [message] string
+      #   The message that you want to log
+      #
+      # @example
+      #   logger.bench 'GET', started_at, '/blog/categories'
+      #   # => DEBUG - GET (0.056ms) - /blog/categories
+      #
+      def bench(action, began_at, message, level=:debug, color=:yellow)
+        @_pad  ||= 8
+        @_pad    = action.to_s.size if action.to_s.size > @_pad
+        duration = Time.now - began_at
+        color    = :red if duration > 1
+        push "%s (" % colorize(action.to_s.upcase.rjust(@_pad), color) + colorize("%0.4fms", :bold, color) % duration + ") %s" % message.to_s, level
+      end
+
+      ##
+      # Appends a message to the log. The methods yield to an optional block and
+      # the output of this block will be appended to the message.
+      #
+      # @param [String] message
+      #   The message that you want write to your stream
+      #
+      # @param [String] level
+      #   The level one of :debug, :warn etc...
+      #
+      #
+      def push(message = nil, level = nil)
+        add(Padrino::Logger::Levels[level], format(message, level))
+      end
+
+      ##
+      # Formats the log message. This method is a noop and should be implemented by other
+      # logger components such as {Padrino::Logger}.
+      #
+      # @param [String] message
+      #   The message to format
+      #
+      # @param [String,Symbol] level
+      #   The log level, one of :debug, :warn...
+      def format(message, level)
+        message
+      end
+
+      ##
+      # The debug level, with some style added. May be reimplemented.
+      #
+      # @example
+      #   stylized_level(:debug) => DEBUG
+      #
+      # @param [String,Symbol] level
+      #   The log level
+      #
+      def stylized_level(level)
+        level.to_s.upcase.rjust(7)
+      end
+
+      ##
+      # Colorizes a string for colored console output. This is a noop and can be reimplemented
+      # to colorize the string as needed.
+      #
+      # @see
+      #   ColorizedLogger
+      #
+      # @param [string]
+      #   The string to be colorized.
+      #
+      # @param [Array<Symbol>]
+      #   The colors to use. Should be applied in the order given.
+      def colorize(string, *colors)
+        string
+      end
+
+      ##
+      # Turns a logger with LoggingExtensions into a logger with colorized output.
+      #
+      # @example
+      #   Padrino.logger = Logger.new($stdout)
+      #   Padrino.logger.colorize!
+      #   Padrino.logger.debug("Fancy Padrino debug string")
+      def colorize!
+        self.extend(Colorize)
+      end
+    end
+
+    module Colorize
+      # Colors for levels
+      ColoredLevels = {
+        :fatal => [:bold, :red],
+        :error => [:red],
+        :warn  => [:yellow],
+        :info  => [:green],
+        :debug => [:cyan],
+        :devel => [:magenta]
+      } unless defined?(ColoredLevels)
+
+      ##
+      # Colorize our level
+      #
+      # @param [String, Symbol] level
+      #
+      # @see Padrino::Logging::ColorizedLogger::ColoredLevels
+      #
+      def colorize(string, *colors)
+        colors.each do |c|
+          string = string.send(c)
+        end
+        string
+      end
+
+      def stylized_level(level)
+        style = ColoredLevels[level].map { |c| "\e[%dm" % String.colors[c] } * ''
+        [style, super, "\e[0m"] * ''
+      end
+    end
+
+    include Extensions
+    include Colorize
+
+    attr_accessor :level
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+    attr_accessor :log_static
+
     @@mutex = {}
 
     ##
@@ -110,16 +257,6 @@ module Padrino
     }
     Config.merge!(PADRINO_LOGGER) if PADRINO_LOGGER
 
-    # Colors for levels
-    ColoredLevels = {
-      :fatal => [:bold, :red],
-      :error => [:red],
-      :warn  => [:yellow],
-      :info  => [:green],
-      :debug => [:cyan],
-      :devel => [:magenta]
-    } unless defined?(ColoredLevels)
-
     ##
     # Setup a new logger
     #
@@ -144,6 +281,7 @@ module Padrino
         when :stderr then $stderr
         else config[:stream] # return itself, probabilly is a custom stream.
       end
+
       Thread.current[:padrino_logger] = Padrino::Logger.new(config.merge(:stream => stream))
     end
 
@@ -174,7 +312,7 @@ module Padrino
     def initialize(options={})
       @buffer          = []
       @auto_flush      = options.has_key?(:auto_flush) ? options[:auto_flush] : true
-      @level           = options[:log_level] ? Levels[options[:log_level]] : Levels[:debug]
+      @level           = options[:log_level] ? Padrino::Logger::Levels[options[:log_level]] : Padrino::Logger::Levels[:debug]
       @log             = options[:stream]  || $stdout
       @log.sync        = true
       @mutex           = @@mutex[@log] ||= Mutex.new
@@ -183,18 +321,6 @@ module Padrino
       @log_static      = options.has_key?(:log_static) ? options[:log_static] : false
     end
 
-    ##
-    # Colorize our level
-    #
-    # @param [String, Symbol] level
-    #
-    # @see Padrino::Logger::ColoredLevels
-    #
-    def colored_level(level)
-      style = ColoredLevels[level].map { |c| "\e[%dm" % String.colors[c] } * ''
-      [style, level.to_s.upcase.rjust(7), "\e[0m"] * ''
-    end
-
     ##
     # Flush the entire buffer to the log object.
     #
@@ -217,42 +343,11 @@ module Padrino
     end
 
     ##
-    # Appends a message to the log. The methods yield to an optional block and
-    # the output of this block will be appended to the message.
-    #
-    # @param [String] message
-    #   The message that you want write to your stream
-    #
-    # @param [String] level
-    #   The level one of :debug, :warn etc...
-    #
-    #
-    def push(message = nil, level = nil)
-      write @format_message % [colored_level(level), Time.now.strftime(@format_datetime).yellow, message.to_s.strip]
-    end
-
-    ##
-    # Append a to development logger a given action with time
-    #
-    # @param [string] action
-    #   The action
-    #
-    # @param [float] time
-    #   Time duration for the given action
-    #
-    # @param [message] string
-    #   The message that you want to log
-    #
-    # @example
-    #   logger.bench 'GET', started_at, '/blog/categories'
-    #   # => DEBUG - GET (0.056ms) - /blog/categories
+    # Adds a message to the log - for compatibility with other loggers.
     #
-    def bench(action, began_at, message, level=:debug, color=:yellow)
-      @_pad  ||= 8
-      @_pad    = action.to_s.size if action.to_s.size > @_pad
-      duration = Time.now - began_at
-      color    = :red if duration > 1
-      push "%s (" % action.to_s.upcase.rjust(@_pad).send(color) + "%0.4fms".bold.send(color) % duration + ") %s" % message.to_s, level
+    # @private
+    def add(level, message = nil)
+      write(message)
     end
 
     ##
@@ -269,24 +364,12 @@ module Padrino
     end
     alias :write :<<
 
-    ##
-    # Generate the logging methods for {Padrino.logger} for each log level.
-    #
-    Levels.each_pair do |name, number|
-      define_method(name) do |*args|
-        return if number < level
-        if args.size > 1
-          bench(*args)
-        else
-          push(args * '', name)
-        end
-      end
-
-      define_method(:"#{name}?") do
-        number >= level
-      end
+    def format(message, level)
+      @format_message % [stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
     end
 
+    
+
     ##
     # Padrino::Loggger::Rack forwards every request to an +app+ given, and
     # logs a line in the Apache common log format to the +logger+, or
@@ -301,7 +384,6 @@ module Padrino
 
       def call(env) # @private
         env['rack.logger'] = Padrino.logger
-        env['rack.errors'] = Padrino.logger.log
         began_at = Time.now
         status, header, body = @app.call(env)
         log(env, status, header, began_at)
@@ -319,7 +401,7 @@ module Padrino
               env["PATH_INFO"],
               env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
               ' - ',
-              status.to_s[0..3].bold,
+              logger.colorize(status.to_s[0..3], :bold),
               ' ',
               code_to_name(status)
             ] * '',
@@ -343,3 +425,4 @@ module Kernel # @private
     Padrino.logger
   end
 end # Kernel
+

data/lib/padrino-core/server.rb

@@ -17,7 +17,7 @@ module Padrino
   #
   class Server < Rack::Server
     # Server Handlers
-    Handlers = [:thin, :mongrel, :webrick]
+    Handlers = [:thin, :mongrel, :trinidad, :webrick]
 
     # Starts the application on the available server with specified options.
     def self.start(app, opts={})

data/lib/padrino-core/version.rb

@@ -6,7 +6,7 @@
 #
 module Padrino
   # The version constant for the current version of Padrino.
-  VERSION = '0.10.6.a' unless defined?(Padrino::VERSION)
+  VERSION = '0.10.6.b' unless defined?(Padrino::VERSION)
 
   #
   # The current Padrino version.

data/test/test_logger.rb

@@ -1,4 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/helper')
+require 'lumberjack'
+require 'logger'
 
 describe "PadrinoLogger" do
 
@@ -98,3 +100,55 @@ describe "PadrinoLogger" do
     end
   end
 end
+
+describe "alternate logger: Lumberjack" do
+  def setup_logger
+    @log = StringIO.new
+    Padrino.logger = Lumberjack::Logger.new(@log, :level => :debug)
+  end
+
+  should "annotate the logger to support additional Padrino fancyness" do
+    setup_logger
+    Padrino.logger.debug("Debug message")
+    assert_match(/Debug message/, @log.string)
+  end
+
+  should "colorize log output after colorize! is called" do
+    setup_logger
+    Padrino.logger.colorize!
+
+    mock_app do
+      enable :logging
+      get("/"){ "Foo" }
+    end
+    get "/"
+
+    assert_match /\e\[1m200\e\[0m OK/, @log.string
+  end
+end
+
+describe "alternate logger: stdlib logger" do
+  def setup_logger
+    @log = StringIO.new
+    Padrino.logger = Logger.new(@log)
+  end
+
+  should "annotate the logger to support additional Padrino fancyness" do
+    setup_logger
+    Padrino.logger.debug("Debug message")
+    assert_match(/Debug message/, @log.string)
+  end
+
+  should "colorize log output after colorize! is called" do
+    setup_logger
+    Padrino.logger.colorize!
+
+    mock_app do
+      enable :logging
+      get("/"){ "Foo" }
+    end
+    get "/"
+
+    assert_match /\e\[1m200\e\[0m OK/, @log.string
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-core
 version: !ruby/object:Gem::Version 
-  hash: 98
+  hash: 99
   prerelease: 7
   segments: 
   - 0
   - 10
   - 6
-  - a
-  version: 0.10.6.a
+  - b
+  version: 0.10.6.b
 platform: ruby
 authors: 
 - Padrino Team
@@ -19,7 +19,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-23 00:00:00 Z
+date: 2012-01-23 00:00:00 -08:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: tilt
@@ -186,6 +187,7 @@ files:
 - test/test_restful_routing.rb
 - test/test_router.rb
 - test/test_routing.rb
+has_rdoc: true
 homepage: http://www.padrinorb.com
 licenses: []
 
@@ -217,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: padrino-core
-rubygems_version: 1.8.15
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: The required Padrino core gem
@@ -248,4 +250,3 @@ test_files:
 - test/test_restful_routing.rb
 - test/test_router.rb
 - test/test_routing.rb
-has_rdoc: