ircinch 2.4.0

data/lib/cinch/log_filter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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/formatted_logger.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../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..].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,26 @@
+# frozen_string_literal: true
+
+require_relative "../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.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Cinch
+  # This is the base logger class from which all loggers have to
+  # inherit.
+  #
+  # @version 2.0.0
+  class Logger
+    # @private
+    LEVEL_ORDER = [: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)
+      LEVEL_ORDER.index(level) >= LEVEL_ORDER.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_list.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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

data/lib/cinch/mask.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Cinch
+  # This class represents masks, which are primarily used for bans.
+  class Mask
+    # @return [String]
+    attr_reader :nick
+    # @return [String]
+    attr_reader :user
+    # @return [String]
+    attr_reader :host
+    # @return [String]
+    attr_reader :mask
+
+    # @version 1.1.2
+    # @param [String] mask
+    def initialize(mask)
+      @mask = mask
+      @nick, @user, @host = mask.match(/(.+)!(.+)@(.+)/)[1..]
+      @regexp = Regexp.new("^" + Regexp.escape(mask).gsub("\\*", ".*").gsub("\\?", ".?") + "$")
+    end
+
+    # @return [Boolean]
+    # @since 1.1.0
+    def ==(other)
+      other.respond_to?(:mask) && other.mask == @mask
+    end
+
+    # @return [Boolean]
+    # @since 1.1.0
+    def eql?(other)
+      other.is_a?(self.class) && self == other
+    end
+
+    # @return [Fixnum]
+    def hash
+      @mask.hash
+    end
+
+    # @param [Mask, String, #mask] target
+    # @return [Boolean]
+    # @version 1.1.2
+    def match(target)
+      self.class.from(target).mask =~ @regexp
+
+      # TODO support CIDR (freenode)
+    end
+    alias_method :=~, :match
+
+    # @return [String]
+    def to_s
+      @mask.dup
+    end
+
+    # @param [String, #mask] target
+    # @return [target] if already a Mask
+    # @return [Mask]
+    # @version 2.0.0
+    def self.from(target)
+      return target if target.is_a?(self)
+
+      if target.respond_to?(:mask)
+        target.mask
+      else
+        Mask.new(target.to_s)
+      end
+    end
+  end
+end