cinch 1.1.3 → 2.0.0.pre.1

data/lib/cinch/isupport.rb

@@ -1,4 +1,5 @@
 module Cinch
+  # This class exposes parsed ISUPPORT information of the IRC network.
   class ISupport < Hash
     @@mappings = {
       %w[PREFIX] => lambda {|v|
@@ -19,7 +20,7 @@ module Cinch
 
       %w[MODES MAXCHANNELS NICKLEN MAXBANS TOPICLEN
        KICKLEN CHANNELLEN CHIDLEN SILENCE AWAYLEN
-       MAXTARGETS WATCH] => lambda {|v| v.to_i},
+       MAXTARGETS WATCH MONITOR] => lambda {|v| v.to_i},
 
       %w[CHANLIMIT MAXLIST IDCHAN] => lambda {|v|
         h = {}
@@ -64,19 +65,20 @@ module Cinch
         "D"             => %w[i m n p s t r]
       }
       self["MODES"]       = 1
-      self["NICKLEN"]     = Infinity
-      self["MAXBANS"]     = Infinity
-      self["TOPICLEN"]    = Infinity
-      self["KICKLEN"]     = Infinity
-      self["CHANNELLEN"]  = Infinity
+      self["NICKLEN"]     = Float::INFINITY
+      self["MAXBANS"]     = Float::INFINITY
+      self["TOPICLEN"]    = Float::INFINITY
+      self["KICKLEN"]     = Float::INFINITY
+      self["CHANNELLEN"]  = Float::INFINITY
       self["CHIDLEN"]     = 5
-      self["AWAYLEN"]     = Infinity
+      self["AWAYLEN"]     = Float::INFINITY
       self["MAXTARGETS"]  = 1
-      self["MAXCHANNELS"] = Infinity # deprecated
-      self["CHANLIMIT"]   = {"#" => Infinity}
+      self["MAXCHANNELS"] = Float::INFINITY # deprecated
+      self["CHANLIMIT"]   = {"#" => Float::INFINITY}
       self["STATUSMSG"]   = ["@", "+"]
       self["CASEMAPPING"] = :rfc1459
       self["ELIST"]       = []
+      self["MONITOR"]     = 0
     end
 
     # @api private

data/lib/cinch/logger.rb

@@ -0,0 +1,168 @@
+module Cinch
+  # This is the base logger class from which all loggers have to
+  # inherit.
+  #
+  # @version 2.0.0
+  class Logger
+    # @private
+    LevelOrder = [:debug, :log, :info, :warn, :error, :fatal]
+
+    # @return [Array<:debug, :log, :info, :warn, :error, :fatal>]
+    #   The minimum level of events to log
+    attr_accessor :level
+
+    # @return [Mutex]
+    # @api private
+    attr_reader :mutex
+
+    # @return [IO]
+    # @api private
+    attr_reader :output
+
+    # @param [IO] output The I/O object to write log data to
+    def initialize(output)
+      @output = output
+      @mutex  = Mutex.new
+      @level  = :debug
+    end
+
+    # Logs a debugging message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @version 2.0.0
+    def debug(message)
+      log(message, :debug)
+    end
+
+    # Logs an error message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def error(message)
+      log(message, :error)
+    end
+
+    # Logs a fatal message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def fatal(message)
+      log(message, :fatal)
+    end
+
+    # Logs an info message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def info(message)
+      log(message, :info)
+    end
+
+    # Logs a warning message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def warn(message)
+      log(message, :warn)
+    end
+
+    # Logs an incoming IRC message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def incoming(message)
+      log(message, :incoming, :log)
+    end
+
+    # Logs an outgoing IRC message.
+    #
+    # @param [String] message
+    # @return [void]
+    # @since 2.0.0
+    def outgoing(message)
+      log(message, :outgoing, :log)
+    end
+
+    # Logs an exception.
+    #
+    # @param [Exception] e
+    # @return [void]
+    # @since 2.0.0
+    def exception(e)
+      log(e.message, :exception, :error)
+    end
+
+    # Logs a message.
+    #
+    # @param [String, Array] messages The message(s) to log
+    # @param [Symbol<:debug, :incoming, :outgoing, :info, :warn,
+    #   :exception, :error, :fatal>] event The kind of event that
+    #   triggered the message
+    # @param [Symbol<:debug, :info, :warn, :error, :fatal>] level The level of the message
+    # @return [void]
+    # @version 2.0.0
+    def log(messages, event = :debug, level = event)
+      return unless will_log?(level)
+      @mutex.synchronize do
+        Array(messages).each do |message|
+          message = format_general(message)
+          message = format_message(message, event)
+
+          next if message.nil?
+          @output.puts message.encode("locale", {:invalid => :replace, :undef => :replace})
+        end
+      end
+    end
+
+    # @param [Symbol<:debug, :info, :warn, :error, :fatal>] level
+    # @return [Boolean] Whether the currently set logging level will
+    #   allow the passed in level to be logged
+    # @since 2.0.0
+    def will_log?(level)
+      LevelOrder.index(level) >= LevelOrder.index(@level)
+    end
+
+    private
+    def format_message(message, level)
+      __send__ "format_#{level}", message
+    end
+
+    def format_general(message)
+      message
+    end
+
+    def format_debug(message)
+      message
+    end
+
+    def format_error(message)
+      message
+    end
+
+    def format_info(message)
+      message
+    end
+
+    def format_warn(message)
+      message
+    end
+
+    def format_incoming(message)
+      message
+    end
+
+    def format_outgoing(message)
+      message
+    end
+
+    def format_exception(message)
+      message
+    end
+  end
+end

data/lib/cinch/logger/formatted_logger.rb

@@ -1,63 +1,31 @@
-require "cinch/logger/logger"
+require "cinch/logger"
+
 module Cinch
-  module Logger
-    # A formatted logger that will colorize individual parts of IRC
-    # messages.
-    class FormattedLogger < Cinch::Logger::Logger
-      COLORS = {
+  class Logger
+    # @version 2.0.0
+    class FormattedLogger < Logger
+      # @private
+      Colors = {
         :reset => "\e[0m",
         :bold => "\e[1m",
         :red => "\e[31m",
         :green => "\e[32m",
         :yellow => "\e[33m",
         :blue => "\e[34m",
+        :black => "\e[30m",
+        :bg_white => "\e[47m",
       }
 
-      # @param [IO] output An IO to log to.
-      def initialize(output = STDERR)
-        @output = output
-        @mutex = Mutex.new
-      end
-
-      # (see Logger::Logger#debug)
-      def debug(messages)
-        log(messages, :debug)
+      # (see Logger#exception)
+      def exception(e)
+        lines = ["#{e.backtrace.first}: #{e.message} (#{e.class})"]
+        lines.concat e.backtrace[1..-1].map {|s| "\t" + s}
+        log(lines, :exception, :error)
       end
 
-      # (see Logger::Logger#log)
-      def log(messages, kind = :generic)
-        @mutex.synchronize do
-          messages = [messages].flatten.map {|s| s.to_s.chomp}
-          messages.each do |msg|
-            message = Time.now.strftime("[%Y/%m/%d %H:%M:%S.%L] ")
-            if kind == :debug
-              prefix = colorize("!! ", :yellow)
-              message << prefix + msg
-            else
-              pre, msg = msg.split(" :", 2)
-              pre_parts = pre.split(" ")
-
-              if kind == :incoming
-                prefix = colorize(">> ", :green)
-
-                if pre_parts.size == 1
-                  pre_parts[0] = colorize(pre_parts[0], :bold)
-                else
-                  pre_parts[0] = colorize(pre_parts[0], :blue)
-                  pre_parts[1] = colorize(pre_parts[1], :bold)
-                end
-
-              elsif kind == :outgoing
-                prefix = colorize("<< ", :red)
-                pre_parts[0] = colorize(pre_parts[0], :bold)
-              end
-
-              message << prefix + pre_parts.join(" ")
-              message << colorize(" :#{msg}", :yellow) if msg
-            end
-            @output.puts message.encode("locale", {:invalid => :replace, :undef => :replace})
-          end
-        end
+      private
+      def timestamp
+        Time.now.strftime("[%Y/%m/%d %H:%M:%S.%L]")
       end
 
       # @api private
@@ -66,14 +34,63 @@ module Cinch
       # @return [String] colorized string
       def colorize(text, *codes)
         return text unless @output.tty?
-        COLORS.values_at(*codes).join + text + COLORS[:reset]
+        codes = Colors.values_at(*codes).join
+        text = text.gsub(/#{Regexp.escape(Colors[:reset])}/, Colors[:reset] + codes)
+        codes + text + Colors[:reset]
       end
 
-      # (see Logger::Logger#log_exception)
-      def log_exception(e)
-        lines = ["#{e.backtrace.first}: #{e.message} (#{e.class})"]
-        lines.concat e.backtrace[1..-1].map {|s| "\t" + s}
-        debug(lines)
+      def format_general(message)
+        message.gsub(/[^[:print:][:space:]]/) do |m|
+          colorize(m.inspect[1..-2], :bg_white, :black)
+        end
+      end
+
+      def format_debug(message)
+        "%s %s %s" % [timestamp, colorize("!!", :yellow), message]
+      end
+
+      def format_warn(message)
+        format_debug(message)
+      end
+
+      def format_info(message)
+        "%s %s %s" % [timestamp, "II", message]
+      end
+
+      def format_incoming(message)
+        pre, msg = message.split(" :", 2)
+        pre_parts = pre.split(" ")
+
+        prefix = colorize(">>", :green)
+
+        if pre_parts.size == 1
+          pre_parts[0] = colorize(pre_parts[0], :bold)
+        else
+          pre_parts[0] = colorize(pre_parts[0], :blue)
+          pre_parts[1] = colorize(pre_parts[1], :bold)
+        end
+
+        "%s %s %s %s" % [timestamp,
+                          prefix,
+                          pre_parts.join(" "),
+                          msg ? colorize(":#{msg}", :yellow) : ""]
+      end
+
+      def format_outgoing(message)
+        pre, msg = message.split(" :", 2)
+        pre_parts = pre.split(" ")
+
+        prefix = colorize("<<", :red)
+        pre_parts[0] = colorize(pre_parts[0], :bold)
+
+        "%s %s %s %s" % [timestamp,
+                         prefix,
+                         pre_parts.join(" "),
+                         msg ? colorize(":#{msg}", :yellow) : ""]
+      end
+
+      def format_exception(message)
+        "%s %s %s" % [timestamp, colorize("!!", :red), message]
       end
     end
   end

data/lib/cinch/logger/zcbot_logger.rb

@@ -1,36 +1,21 @@
 require "cinch/logger/logger"
 module Cinch
-  module Logger
+  class Logger
     # This logger logs all incoming messages in the format of zcbot.
     # All other debug output (outgoing messages, exceptions, ...) will
     # silently be dropped. The sole purpose of this logger is to
     # produce logs parseable by pisg (with the zcbot formatter) to
     # create channel statistics..
-    class ZcbotLogger < Cinch::Logger::Logger
-      # @param [IO] output An IO to log to.
-      def initialize(output = STDERR)
-        @output = output
-        @mutex = Mutex.new
+    class ZcbotLogger < Cinch::Logger
+      # (see Logger#log)
+      def log(messages, event, level = event)
+        return if event != :incoming
+        super
       end
 
-      # (see Logger::Logger#debug)
-      def debug(messages)
-      end
-
-      # (see Logger::Logger#log)
-      def log(messages, kind = :generic)
-        return if kind != :incoming
-
-        @mutex.synchronize do
-          messages = [messages].flatten.map {|s| s.to_s.chomp}
-          messages.each do |msg|
-            @output.puts Time.now.strftime("%m/%d/%Y %H:%M:%S ") + msg.encode("locale", {:invalid => :replace, :undef => :replace})
-          end
-        end
-      end
-
-      # (see Logger::Logger#log_exception)
-      def log_exception(e)
+      private
+      def format_incoming(message)
+        Time.now.strftime("%m/%d/%Y %H:%M:%S ") + message
       end
     end
   end

data/lib/cinch/logger_list.rb

@@ -0,0 +1,62 @@
+module Cinch
+  # This class allows Cinch to use multiple loggers at once. A common
+  # use-case would be to log formatted messages to STDERR and a
+  # pisg-compatible log to a file.
+  #
+  # It inherits directly from Array, so adding new loggers is as easy
+  # as calling LoggerList#push.
+  #
+  # @attr_writer level
+  # @since 2.0.0
+  class LoggerList < Array
+    # (see Logger#level=)
+    def level=(level)
+      each {|l| l.level = level}
+    end
+
+    # (see Logger#log)
+    def log(messages, event = :debug, level = event)
+      each {|l| l.log(messages, event, level)}
+    end
+
+    # (see Logger#debug)
+    def debug(message)
+      each {|l| l.debug(message)}
+    end
+
+    # (see Logger#error)
+    def error(message)
+      each {|l| l.error(message)}
+    end
+
+    # (see Logger#error)
+    def fatal(message)
+      each {|l| l.fatal(message)}
+    end
+
+    # (see Logger#info)
+    def info(message)
+      each {|l| l.info(message)}
+    end
+
+    # (see Logger#warn)
+    def warn(message)
+      each {|l| l.warn(message)}
+    end
+
+    # (see Logger#incoming)
+    def incoming(message)
+      each {|l| l.incoming(message)}
+    end
+
+    # (see Logger#outgoing)
+    def outgoing(message)
+      each {|l| l.outgoing(message)}
+    end
+
+    # (see Logger#exception)
+    def exception(message)
+      each {|l| l.exception(message)}
+    end
+  end
+end