ramaze 2008.06 → 2008.11

data/lib/ramaze/log/hub.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Logging
+  module Logger
 
     # Bundles different informer instances and sends incoming messages to each.
     # This is the default with Informer as only member.

data/lib/ramaze/log/informer.rb

@@ -2,129 +2,127 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Logging
-    module Logger
-
-      # A minimal logger for Ramaze, supports files, CLI, colors and some
-      # customization.
-
-      class Informer
-        include Logging
-
-        attr_accessor :out, :colorize, :log_levels
-
-        # Should Ramaze try to use colors?
-        trait :colorize => true
-
-        # parameter for Time.now.strftime
-        trait :timestamp => "%Y-%m-%d %H:%M:%S"
-
-        # This is how the final output is arranged.
-        trait :format => "[%time] %prefix  %text"
-
-        # Which tag should be in what color
-        COLORS = {
-          :dev   => :blue,
-          :debug => :yellow,
-          :info  => :green,
-          :warn  => :red,
-          :error => :red,
-        }
-
-        # Create a new instance of Informer.
-        # You can spcify
-        #
-        # Examples:
-        #   Informer.new                    #=> logs to stdout with all levels being
-        #                                       shown.
-        #   Informer.new($stderr)           #=> same, but to stderr
-        #   Informer.new("foo.log")         #=> same, but logs to the file foo.log
-        #                                       (or creates it if it doesn't exist yet)
-        #   Informer.new($stdout, [:info])  #=> show only #info messages to stdout.
-
-        def initialize(out = $stdout, log_levels = [:debug, :error, :info, :warn])
-          @colorize = false
-
-          @out =
-            case out
-            when STDOUT, :stdout, 'stdout'
-              $stdout
-            when STDERR, :stderr, 'stderr'
-              $stderr
-            when IO
+  module Logger
+
+    # A minimal logger for Ramaze, supports files, CLI, colors and some
+    # customization.
+
+    class Informer
+      include Logging
+
+      attr_accessor :out, :colorize, :log_levels
+
+      # Should Ramaze try to use colors?
+      trait :colorize => true
+
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Which tag should be in what color
+      COLORS = {
+        :dev   => :blue,
+        :debug => :yellow,
+        :info  => :green,
+        :warn  => :red,
+        :error => :red,
+      }
+
+      # Create a new instance of Informer.
+      # You can spcify
+      #
+      # Examples:
+      #   Informer.new                    #=> logs to stdout with all levels being
+      #                                       shown.
+      #   Informer.new($stderr)           #=> same, but to stderr
+      #   Informer.new("foo.log")         #=> same, but logs to the file foo.log
+      #                                       (or creates it if it doesn't exist yet)
+      #   Informer.new($stdout, [:info])  #=> show only #info messages to stdout.
+
+      def initialize(out = $stdout, log_levels = [:debug, :error, :info, :warn])
+        @colorize = false
+
+        @out =
+          case out
+          when STDOUT, :stdout, 'stdout'
+            $stdout
+          when STDERR, :stderr, 'stderr'
+            $stderr
+          when IO
+            out
+          else
+            if out.respond_to?(:puts)
               out
             else
-              if out.respond_to?(:puts)
-                out
-              else
-                File.open(out.to_s, 'ab+')
-              end
+              File.open(out.to_s, 'ab+')
             end
-
-          if @out.respond_to?(:tty?) and class_trait[:colorize]
-            @colorize = @out.tty?
           end
 
-          @log_levels = log_levels
+        if @out.respond_to?(:tty?) and class_trait[:colorize]
+          @colorize = @out.tty?
         end
 
-        # Close the file we log to if it isn't closed already.
-
-        def shutdown
-          if @out.respond_to?(:close)
-            Log.debug("close, #{@out.inspect}")
-            @out.close
-          end
-        end
+        @log_levels = log_levels
+      end
 
-        # Integration to Logging.
+      # Close the file we log to if it isn't closed already.
 
-        def log tag, *messages
-          return if closed? || !@log_levels.include?(tag)
-          messages.flatten!
+      def shutdown
+        if @out.respond_to?(:close)
+          Log.debug("close, #{@out.inspect}")
+          @out.close
+        end
+      end
 
-          prefix = tag.to_s.upcase.ljust(5)
+      # Integration to Logging.
 
-          if @colorize
-            color = COLORS[tag] ||= :white
-            prefix.replace prefix.send(color)
-          end
+      def log tag, *messages
+        return if closed? || !@log_levels.include?(tag)
+        messages.flatten!
 
-          messages.each do |message|
-            @out.puts(log_interpolate(prefix, message))
-          end
+        prefix = tag.to_s.upcase.ljust(5)
 
-          @out.flush if @out.respond_to?(:flush)
+        if @colorize
+          color = COLORS[tag] ||= :white
+          prefix.replace prefix.send(color)
         end
 
-        # Takes the prefix (tag), text and timestamp and applies it to
-        # the :format trait.
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
 
-        def log_interpolate prefix, text, time = timestamp
-          message = class_trait[:format].dup
+        @out.flush if @out.respond_to?(:flush)
+      end
 
-          vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
-          vars.each{|from, to| message.gsub!(from, to) }
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
 
-          message
-        end
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
 
-        # This uses Global.inform_timestamp or a date in the format of
-        #   %Y-%m-%d %H:%M:%S
-        #   # => "2007-01-19 21:09:32"
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
 
-        def timestamp
-          mask = class_trait[:timestamp]
-          Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
-        end
+        message
+      end
 
-        # is @out closed?
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
 
-        def closed?
-          @out.respond_to?(:closed?) and @out.closed?
-        end
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
       end
 
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) and @out.closed?
+      end
     end
+
   end
 end

data/lib/ramaze/log/knotify.rb

@@ -2,29 +2,27 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Logging
-    module Logger
+  module Logger
 
-      # Informer for the Knotify notfication system used on KDE.
-      # Doesn't need any special libraries.
+    # Informer for the Knotify notfication system used on KDE.
+    # Doesn't need any special libraries.
 
-      class Knotify
-        include Logging
+    class Knotify
+      include Logging
 
-        trait :present => 16
+      trait :present => 16
 
-        # Please see for more information on the API used here:
-        # http://lukeplant.me.uk/articles.php?id=3
+      # Please see for more information on the API used here:
+      # http://lukeplant.me.uk/articles.php?id=3
 
-        def log(tag, *messages)
-          present = class_trait[:present]
-          tag = tag.to_s.capitalize
-          messages.flatten.each do |message|
-            system(%{dcop knotify default notify Ramaze "#{tag}" "#{message}" '' '' #{present} 0})
-          end
+      def log(tag, *messages)
+        present = class_trait[:present]
+        tag = tag.to_s.capitalize
+        messages.flatten.each do |message|
+          system(%{dcop knotify default notify Ramaze "#{tag}" "#{message}" '' '' #{present} 0})
         end
       end
-
     end
+
   end
 end

data/lib/ramaze/log/logger.rb

@@ -4,25 +4,23 @@
 require 'logger'
 
 module Ramaze
-  module Logging
-    module Logger
+  module Logger
 
-      # Informer for the Stdlib Logger
+    # Informer for the Stdlib Logger
 
-      class Logger < ::Logger
+    class Logger < ::Logger
 
-        # integration to Logging
+      # integration to Logging
 
-        def log(tag, *args)
-          __send__(tag, args.join("\n"))
-        end
-
-        # Stub for compatibility
-        def dev(*args)
-          debug(*args)
-        end
+      def log(tag, *args)
+        __send__(tag, args.join("\n"))
       end
 
+      # Stub for compatibility
+      def dev(*args)
+        debug(*args)
+      end
     end
+
   end
 end

data/lib/ramaze/log/logging.rb

@@ -2,90 +2,88 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Logging
 
-    # This module provides a basic skeleton for your own loggers to be compatible.
-    # The minimal usage is like this:
-    #
-    #   class MyLogger
-    #     include Logging
-    #
-    #     def log(tag, *args)
-    #       p tag => args
-    #     end
-    #   end
-
-    module Logging
-
-      # Takes the tag (:warn|:debug|:error|:info) and the name of a method to be
-      # called upon elements of msgs that don't respond to :to_str
-      # Goes on and sends the tag and transformed messages each to the #log method.
-      # If you include this module you have to define #log or it will raise.
-
-      def tag_log(tag, meth, *msgs)
-        msgs.each do |msg|
-          string = (msg.respond_to?(:to_str) ? msg : msg.send(meth))
-          log(tag, string)
-        end
-      end
+  # This module provides a basic skeleton for your own loggers to be compatible.
+  # The minimal usage is like this:
+  #
+  #   class MyLogger
+  #     include Logging
+  #
+  #     def log(tag, *args)
+  #       p tag => args
+  #     end
+  #   end
 
-      # Converts everything given to strings and passes them on with :info
+  module Logging
 
-      def info(*objects)
-        tag_log(:info, :to_s, *objects)
+    # Takes the tag (:warn|:debug|:error|:info) and the name of a method to be
+    # called upon elements of msgs that don't respond to :to_str
+    # Goes on and sends the tag and transformed messages each to the #log method.
+    # If you include this module you have to define #log or it will raise.
+
+    def tag_log(tag, meth, *msgs)
+      msgs.each do |msg|
+        string = (msg.respond_to?(:to_str) ? msg : msg.send(meth))
+        log(tag, string)
       end
+    end
 
-      # Converts everything given to strings and passes them on with :warn
+    # Converts everything given to strings and passes them on with :info
 
-      def warn(*objects)
-        tag_log(:warn, :to_s, *objects)
-      end
+    def info(*objects)
+      tag_log(:info, :to_s, *objects)
+    end
 
-      # inspects objects if they are no strings. Tag is :debug
+    # Converts everything given to strings and passes them on with :warn
 
-      def debug(*objects)
-        tag_log(:debug, :inspect, *objects)
-      end
+    def warn(*objects)
+      tag_log(:warn, :to_s, *objects)
+    end
 
-      # inspects objects if they are no strings. Tag is :dev
+    # inspects objects if they are no strings. Tag is :debug
 
-      def dev(*objects)
-        tag_log(:dev, :inspect, *objects)
-      end
+    def debug(*objects)
+      tag_log(:debug, :inspect, *objects)
+    end
 
-      alias << debug
+    # inspects objects if they are no strings. Tag is :dev
 
-      # Takes either an Exception or just a String, formats backtraces to be a bit
-      # more readable and passes all of this on to tag_log :error
+    def dev(*objects)
+      tag_log(:dev, :inspect, *objects)
+    end
 
-      def error(ex)
-        if ex.respond_to?(:exception)
-          message = [ex.backtrace].flatten[0..Global.backtrace_size]
-          message.map{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
-          message.unshift(ex.inspect)
-        else
-          message = ex.to_s
-        end
-        tag_log(:error, :to_s, *message)
-      end
+    alias << debug
 
-      # raises
+    # Takes either an Exception or just a String, formats backtraces to be a bit
+    # more readable and passes all of this on to tag_log :error
 
-      def log(*args)
-        raise "#log should be implemented by an instance including this module (#{self})"
+    def error(ex)
+      if ex.respond_to?(:exception)
+        message = [ex.backtrace].flatten[0..Global.backtrace_size]
+        message.map{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
+        message.unshift(ex.inspect)
+      else
+        message = ex.to_s
       end
+      tag_log(:error, :to_s, *message)
+    end
 
-      # nothing
+    # raises
 
-      def shutdown
-      end
+    def log(*args)
+      raise "#log should be implemented by an instance including this module (#{self})"
+    end
 
-      # stub for WEBrick
+    # nothing
 
-      def debug?
-        false
-      end
+    def shutdown
     end
 
+    # stub for WEBrick
+
+    def debug?
+      false
+    end
   end
+
 end