grinch 1.0.0

data/lib/cinch/isupport.rb

@@ -0,0 +1,98 @@
+module Cinch
+  # This class exposes parsed ISUPPORT information of the IRC network.
+  class ISupport < Hash
+    @@mappings = {
+      %w[PREFIX] => lambda {|v|
+        modes, prefixes = v.match(/^\((.+)\)(.+)$/)[1..2]
+        h = {}
+        modes.split("").each_with_index do |c, i|
+          h[c] = prefixes[i]
+        end
+        h
+      },
+
+      %w[CHANTYPES] => lambda {|v| v.split("")},
+      %w[CHANMODES] => lambda {|v|
+        h = {}
+        h["A"], h["B"], h["C"], h["D"] = v.split(",").map {|l| l.split("")}
+        h
+      },
+
+      %w[MODES MAXCHANNELS NICKLEN MAXBANS TOPICLEN
+       KICKLEN CHANNELLEN CHIDLEN SILENCE AWAYLEN
+       MAXTARGETS WATCH MONITOR] => lambda {|v| v.to_i},
+
+      %w[CHANLIMIT MAXLIST IDCHAN] => lambda {|v|
+        h = {}
+        v.split(",").each do |pair|
+          args, num = pair.split(":")
+          args.split("").each do |arg|
+            h[arg] = num.to_i
+          end
+        end
+        h
+      },
+
+      %w[TARGMAX] => lambda {|v|
+        h = {}
+        v.split(",").each do |pair|
+          name, value = pair.split(":")
+          h[name] = value.to_i
+        end
+        h
+      },
+
+      %w[NETWORK] => lambda {|v| v},
+      %w[STATUSMSG] => lambda {|v| v.split("")},
+      %w[CASEMAPPING] => lambda {|v| v.to_sym},
+      %w[ELIST] => lambda {|v| v.split("")},
+      # TODO STD
+    }
+
+    def initialize(*args)
+      super
+      # by setting most numeric values to "Infinity", we let the
+      # server truncate messages and lists while at the same time
+      # allowing the use of strictness=:strict for servers that don't
+      # support ISUPPORT (hopefully none, anyway)
+
+      self["PREFIX"]    =  {"o" => "@", "v" => "+"}
+      self["CHANTYPES"] =  ["#"]
+      self["CHANMODES"] =  {
+        "A"             => ["b"],
+        "B"             => ["k"],
+        "C"             => ["l"],
+        "D"             => %w[i m n p s t r]
+      }
+      self["MODES"]       = 1
+      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"]     = Float::INFINITY
+      self["MAXTARGETS"]  = 1
+      self["MAXCHANNELS"] = Float::INFINITY # deprecated
+      self["CHANLIMIT"]   = {"#" => Float::INFINITY}
+      self["STATUSMSG"]   = []
+      self["CASEMAPPING"] = :rfc1459
+      self["ELIST"]       = []
+      self["MONITOR"]     = 0
+    end
+
+    # @api private
+    # @return [void]
+    def parse(*options)
+      options.each do |option|
+        name, value = option.split("=")
+        if value
+          proc = @@mappings.find {|key, _| key.include?(name)}
+          self[name] = (proc && proc[1].call(value)) || value
+        else
+          self[name] = true
+        end
+      end
+    end
+  end
+end

data/lib/cinch/log_filter.rb

@@ -0,0 +1,21 @@
+module Cinch
+  # LogFilter describes an interface for filtering log messages before
+  # they're printed.
+  #
+  # @abstract
+  # @since 2.3.0
+  class LogFilter
+    # filter is called for each log message, except for exceptions. It
+    # returns a new string, which is the one that should be printed, or
+    # further filtered by other filters. Returning nil will drop the
+    # message.
+    #
+    # @param [String] message The message that is to be logged
+    # @param [:debug, :incoming, :outgoing, :info, :warn, :exception,
+    #   :error, :fatal] event The kind of message
+    # @return [String, nil] The modified message, as it should be
+    #   logged, or nil if the message shouldn't be logged at all
+    def filter(message, event)
+    end
+  end
+end

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, level: :debug)
+      @output = output
+      @mutex  = Mutex.new
+      @level  = level
+    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 [:debug, :incoming, :outgoing, :info, :warn,
+    #   :exception, :error, :fatal] event The kind of event that
+    #   triggered the message
+    # @param [: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 [: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

@@ -0,0 +1,97 @@
+require "cinch/logger"
+
+module Cinch
+  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",
+      }
+
+      # (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
+
+      private
+      def timestamp
+        Time.now.strftime("[%Y/%m/%d %H:%M:%S.%L]")
+      end
+
+      # @api private
+      # @param [String] text text to colorize
+      # @param [Array<Symbol>] codes array of colors to apply
+      # @return [String] colorized string
+      def colorize(text, *codes)
+        return text unless @output.tty?
+        codes = Colors.values_at(*codes).join
+        text = text.gsub(/#{Regexp.escape(Colors[:reset])}/, Colors[:reset] + codes)
+        codes + text + Colors[:reset]
+      end
+
+      def format_general(message)
+        message.gsub(/[^[:print:]]/) 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
+end

data/lib/cinch/logger/zcbot_logger.rb

@@ -0,0 +1,22 @@
+require "cinch/logger"
+module Cinch
+  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
+      # (see Logger#log)
+      def log(messages, event, level = event)
+        return if event != :incoming
+        super
+      end
+
+      private
+      def format_incoming(message)
+        Time.now.strftime("%m/%d/%Y %H:%M:%S ") + message
+      end
+    end
+  end
+end

data/lib/cinch/logger_list.rb

@@ -0,0 +1,85 @@
+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
+    # A list of log filters that will be applied before emitting a log
+    # message.
+    #
+    # @return [Array<LogFilter>]
+    # @since 2.3.0
+    attr_accessor :filters
+    def initialize(*args)
+      @filters = []
+      super
+    end
+
+    # (see Logger#level=)
+    def level=(level)
+      each {|l| l.level = level}
+    end
+
+    # (see Logger#log)
+    def log(messages, event = :debug, level = event)
+      messages = Array(messages).map {|m| filter(m, event)}.compact
+      each {|l| l.log(messages, event, level)}
+    end
+
+    # (see Logger#debug)
+    def debug(message)
+      (m = filter(message, :debug)) && each {|l| l.debug(m)}
+    end
+
+    # (see Logger#error)
+    def error(message)
+      (m = filter(message, :error)) && each {|l| l.error(m)}
+    end
+
+    # (see Logger#error)
+    def fatal(message)
+      (m = filter(message, :fatal)) && each {|l| l.fatal(m)}
+    end
+
+    # (see Logger#info)
+    def info(message)
+      (m = filter(message, :info)) && each {|l| l.info(m)}
+    end
+
+    # (see Logger#warn)
+    def warn(message)
+      (m = filter(message, :warn)) && each {|l| l.warn(m)}
+    end
+
+    # (see Logger#incoming)
+    def incoming(message)
+      (m = filter(message, :incoming)) && each {|l| l.incoming(m)}
+    end
+
+    # (see Logger#outgoing)
+    def outgoing(message)
+      (m = filter(message, :outgoing)) && each {|l| l.outgoing(m)}
+    end
+
+    # (see Logger#exception)
+    def exception(e)
+      each {|l| l.exception(e)}
+    end
+
+    private
+    def filter(m, ev)
+      @filters.each do |f|
+        m = f.filter(m, ev)
+        if m.nil?
+          break
+        end
+      end
+      m
+    end
+  end
+end