cinch 1.0.2 → 1.1.0

data/lib/cinch/logger/formatted_logger.rb

@@ -27,15 +27,14 @@ module Cinch
       # (see Logger::Logger#log)
       def log(messages, kind = :generic)
         @mutex.synchronize do
-          messages = [messages].flatten.map {|s| s.chomp}
-          # message = message.to_s.chomp # don't want to tinker with the original string
-
-          messages.each do |message|
+          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 + message
+              message << prefix + msg
             else
-              pre, msg = message.split(" :", 2)
+              pre, msg = msg.split(" :", 2)
               pre_parts = pre.split(" ")
 
               if kind == :incoming
@@ -53,10 +52,10 @@ module Cinch
                 pre_parts[0] = colorize(pre_parts[0], :bold)
               end
 
-              message = prefix + pre_parts.join(" ")
+              message << prefix + pre_parts.join(" ")
               message << colorize(" :#{msg}", :yellow) if msg
             end
-            @output.puts message.encode
+            @output.puts message.encode("locale", {:invalid => :replace, :undef => :replace})
           end
         end
       end
@@ -66,6 +65,7 @@ module Cinch
       # @param [Array<Symbol>] codes array of colors to apply
       # @return [String] colorized string
       def colorize(text, *codes)
+        return text unless @output.tty?
         COLORS.values_at(*codes).join + text + COLORS[:reset]
       end
 

data/lib/cinch/logger/zcbot_logger.rb

@@ -0,0 +1,37 @@
+require "cinch/logger/logger"
+module Cinch
+  module 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
+      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)
+      end
+    end
+  end
+end

data/lib/cinch/mask.rb

@@ -11,13 +11,27 @@ module Cinch
     def initialize(mask)
       @mask = mask
       @nick, @user, @host = mask.match(/(.+)!(.+)@(.+)/)[1..-1]
-      @regexp = Regexp.new(Regexp.escape(mask).gsub("\\*", ".*"))
+      @regexp = Regexp.new("^" + Regexp.escape(mask).gsub("\\*", ".*") + "$")
     end
 
+    # @return [Boolean]
+    def ==(other)
+      other.respond_to?(:mask) && other.mask == @mask
+    end
+
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(self.class) && self == other
+    end
+
+    def hash
+      @mask.hash
+    end
+
+    # @param [User] user
     # @return [Boolean]
     def match(user)
-      mask = "%s!%s@%s" % [nick, user, host]
-      return mask =~ @regexp
+      return user.mask =~ @regexp
 
       # TODO support CIDR (freenode)
     end

data/lib/cinch/message.rb

@@ -10,7 +10,8 @@ module Cinch
     # @return [Array<String>]
     attr_accessor :params
     attr_reader :events
-
+    # @return [Bot]
+    attr_reader :bot
     def initialize(msg, bot)
       @raw = msg
       @bot = bot
@@ -50,7 +51,7 @@ module Cinch
       host = @prefix[/@(\S+)$/, 1]
 
       return nil if nick.nil?
-      @user ||= User.find_ensured(user, nick, host, @bot)
+      @user ||= @bot.user_manager.find_ensured(user, nick, host)
     end
 
     # @return [String, nil]
@@ -91,14 +92,14 @@ module Cinch
       @channel ||= begin
                      case command
                      when "INVITE", RPL_CHANNELMODEIS.to_s, RPL_BANLIST.to_s
-                       Channel.find_ensured(params[1], @bot)
+                       @bot.channel_manager.find_ensured(params[1])
                      when RPL_NAMEREPLY.to_s
-                       Channel.find_ensured(params[2], @bot)
+                       @bot.channel_manager.find_ensured(params[2])
                      else
                        if params.first.start_with?("#")
-                         Channel.find_ensured(params.first, @bot)
+                         @bot.channel_manager.find_ensured(params.first)
                        elsif numeric_reply? and params[1].start_with?("#")
-                         Channel.find_ensured(params[1], @bot)
+                         @bot.channel_manager.find_ensured(params[1])
                        end
                      end
                    end
@@ -121,6 +122,7 @@ module Cinch
       $1
     end
 
+    # @return [Array<String>, nil]
     def ctcp_args
       return unless ctcp?
       ctcp_message.split(" ")[1..-1]
@@ -172,7 +174,12 @@ module Cinch
     # @return [void]
     def ctcp_reply(answer)
       return unless ctcp?
-      @bot.raw "NOTICE #{user.nick} :\001#{ctcp_command} #{answer}\001"
+      user.notice "\001#{ctcp_command} #{answer}\001"
+    end
+
+    # @return [String]
+    def to_s
+      "#<Cinch::Message @raw=#{raw.chomp.inspect} @params=#{@params.inspect} channel=#{channel.inspect} user=#{user.inspect}>"
     end
 
     private

data/lib/cinch/message_queue.rb

@@ -51,11 +51,15 @@ module Cinch
 
         message = @queue.pop.to_s.chomp
 
-        @log << Time.now
-        @bot.logger.log(message, :outgoing) if @bot.config.verbose
+        begin
+          @socket.writeline Cinch.encode_outgoing(message, @bot.config.encoding) + "\r\n"
+          @log << Time.now
+          @bot.logger.log(message, :outgoing) if @bot.config.verbose
 
-        @time_since_last_send = Time.now
-        @socket.print message.encode(@bot.config.encoding, {:invalid => :replace, :undef => :replace}) + "\r\n"
+          @time_since_last_send = Time.now
+        rescue IOError
+          @bot.debug "Could not send message (connectivity problems): #{message}"
+        end
       end
     end
   end

data/lib/cinch/mode_parser.rb

@@ -0,0 +1,56 @@
+module Cinch
+  # @api private
+  module ModeParser
+    def self.parse_modes(modes, params, param_modes = {})
+      if modes.size == 0
+        raise InvalidModeString, 'Empty mode string'
+      end
+
+      if modes[0] !~ /[+-]/
+        raise InvalidModeString, "Malformed modes string: %s" % modes
+      end
+
+      changes = []
+
+      direction = nil
+      count = -1
+
+      modes.each_char do |ch|
+        if ch =~ /[+-]/
+          if count == 0
+            raise InvalidModeString, 'Empty mode sequence: %s' % modes
+          end
+
+          direction = case ch
+                      when "+"
+                        :add
+                      when "-"
+                        :remove
+                      end
+          count = 0
+        else
+          param = nil
+          if param_modes[direction].include?(ch)
+            if params.size > 0
+              param = params.shift
+            else
+              raise InvalidModeString, 'Not enough parameters: %s' % ch.inspect
+            end
+          end
+          changes << [direction, ch, param]
+          count += 1
+        end
+      end
+
+      if params.size > 0
+        raise InvalidModeString, 'Too many parameters: %s %s' % [modes, params].inspect
+      end
+
+      if count == 0
+        raise InvalidModeString, 'Empty mode sequence: %r' % modes
+      end
+
+      return changes
+    end
+  end
+end

data/lib/cinch/pattern.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  # @api private
+  class Pattern
+    # @param [String, Regexp, NilClass, Proc, #to_s] obj The object to
+    #   convert to a regexp
+    # @return [Regexp, nil]
+    def self.obj_to_r(obj)
+      case obj
+      when Regexp, NilClass
+        return obj
+      else
+        return Regexp.new(Regexp.escape(obj.to_s))
+      end
+    end
+
+    def self.resolve_proc(obj, msg = nil)
+      if obj.is_a?(Proc)
+        return resolve_proc(obj.call(msg), msg)
+      else
+        return obj
+      end
+    end
+
+    attr_reader :prefix
+    attr_reader :suffix
+    attr_reader :pattern
+    def initialize(prefix, pattern, suffix)
+      @prefix, @pattern, @suffix = prefix, pattern, suffix
+    end
+
+    def to_r(msg = nil)
+      prefix  = Pattern.obj_to_r(Pattern.resolve_proc(@prefix, msg))
+      suffix  = Pattern.obj_to_r(Pattern.resolve_proc(@suffix, msg))
+      pattern = Pattern.resolve_proc(@pattern, msg)
+
+      case pattern
+      when Regexp, NilClass
+        /#{prefix}#{pattern}#{suffix}/
+      else
+        /^#{prefix}#{Pattern.obj_to_r(pattern)}#{suffix}$/
+      end
+    end
+  end
+end

data/lib/cinch/plugin.rb

@@ -3,8 +3,14 @@ module Cinch
     include Helpers
 
     module ClassMethods
-      Pattern = Struct.new(:pattern, :use_prefix, :method)
+      # @api private
+      Match = Struct.new(:pattern, :use_prefix, :use_suffix, :method)
+      # @api private
       Listener = Struct.new(:event, :method)
+      # @api private
+      Timer = Struct.new(:interval, :method, :threaded, :registered)
+      # @api private
+      Hook = Struct.new(:type, :for, :method)
 
       # Set a match pattern.
       #
@@ -15,9 +21,9 @@ module Cinch
       #   pattern.
       # @return [void]
       def match(pattern, options = {})
-        options = {:use_prefix => true, :method => :execute}.merge(options)
-        @__cinch_patterns ||= []
-        @__cinch_patterns << Pattern.new(pattern, options[:use_prefix], options[:method])
+        options = {:use_prefix => true, :use_suffix => true, :method => :execute}.merge(options)
+        @__cinch_matches ||= []
+        @__cinch_matches << Match.new(pattern, options[:use_prefix], options[:use_suffix], options[:method])
       end
 
       # Events to listen to.
@@ -53,8 +59,8 @@ module Cinch
         (@__cinch_ctcps ||= []) << command.to_s.upcase
       end
 
-      # Define a help message which will be returned on "<prefix>help
-      # <pluginname>".
+      # Define a help message which will be returned on "&lt;prefix&gt;help
+      # &lt;pluginname&gt;".
       #
       # @param [String] message
       # @return [void]
@@ -66,10 +72,22 @@ module Cinch
       #
       # @param [String] prefix
       # @return [void]
-      def prefix(prefix)
-        @__cinch_prefix = prefix
+      def prefix(prefix = nil, &block)
+        raise ArgumentError if prefix.nil? && block.nil?
+        @__cinch_prefix = prefix || block
       end
 
+      # Set the plugin suffix.
+      #
+      # @param [String] suffix
+      # @return [void]
+      def suffix(suffix = nil, &block)
+        raise ArgumentError if suffix.nil? && block.nil?
+        @__cinch_suffix = suffix || block
+      end
+
+
+
       # Set which kind of messages to react on (i.e. call {#execute})
       #
       # @param [Symbol<:message, :channel, :private>] target React to all,
@@ -87,12 +105,63 @@ module Cinch
         @__cinch_name = name
       end
 
+      # @example
+      #   timer 5, method: :some_method
+      #   def some_method
+      #     Channel("#cinch-bots").send(Time.now.to_s)
+      #   end
+      # @param [Number] interval Interval in seconds
+      # @option options [Symbol] :method (:timer) Method to call
+      # @option options [Boolean] :threaded (true) Call method in a thread?
+      # @return [void]
+      def timer(interval, options = {})
+        options = {:method => :timer, :threaded => true}.merge(options)
+        @__cinch_timers ||= []
+        @__cinch_timers << Timer.new(interval, options[:method], options[:threaded], false)
+      end
+
+      # Defines a hook which will be run before or after a handler is
+      # executed, depending on the value of `type`.
+      #
+      # @param [Symbol<:pre, :post>] type Run the hook before or after
+      #   a handler?
+      # @option options [Array<:match, :listen_to, :ctcp>] :for ([:match, :listen_to, :ctcp])
+      #   Which kinds of events to run the hook for.
+      # @option options [Symbol] :method (true) The method to execute.
+      # @return [void]
+      def hook(type, options = {})
+        options = {:for => [:match, :listen_to, :ctcp], :method => :hook}.merge(options)
+        __hooks(type) << Hook.new(type, options[:for], options[:method])
+      end
+
       # @return [String]
       # @api private
       def __plugin_name
         @__cinch_name || self.name.split("::").last.downcase
       end
 
+      # @return [Hash]
+      # @api private
+      def __hooks(type = nil, events = nil)
+        @__cinch_hooks ||= Hash.new{|h,k| h[k] = []}
+
+        if type.nil?
+          hooks = @__cinch_hooks
+        else
+          hooks = @__cinch_hooks[type]
+        end
+
+        if events.nil?
+          return hooks
+        else
+          events = [*events]
+          if hooks.is_a?(Hash)
+            hooks = hooks.map { |k, v| v }
+          end
+          return hooks.select { |hook| (events & hook.for).size > 0 }
+        end
+      end
+
       # @return [void]
       # @api private
       def __register_with_bot(bot, instance)
@@ -100,36 +169,30 @@ module Cinch
 
         (@__cinch_listeners || []).each do |listener|
           bot.debug "[plugin] #{plugin_name}: Registering listener for type `#{listener.event}`"
-          bot.on(listener.event, [], instance) do |message, plugin|
-            plugin.__send__(listener.method, message) if plugin.respond_to?(listener.method)
+          bot.on(listener.event, [], instance) do |message, plugin, *args|
+            if plugin.respond_to?(listener.method)
+              plugin.class.__hooks(:pre, :listen_to).each {|hook| plugin.__send__(hook.method, message)}
+              plugin.__send__(listener.method, message, *args)
+              plugin.class.__hooks(:post, :listen_to).each {|hook| plugin.__send__(hook.method, message)}
+            end
           end
         end
 
-        if (@__cinch_patterns ||= []).empty?
-          @__cinch_patterns << Pattern.new(plugin_name, true, nil)
+        if (@__cinch_matches ||= []).empty?
+          @__cinch_matches << Match.new(plugin_name, true, true, :execute)
         end
 
         prefix = @__cinch_prefix || bot.config.plugins.prefix
-        if prefix.is_a?(String)
-          prefix = Regexp.escape(prefix)
-        end
-        @__cinch_patterns.each do |pattern|
-          pattern_to_register = nil
-
-          if pattern.use_prefix && prefix
-            case pattern.pattern
-            when Regexp
-              pattern_to_register = /^#{prefix}#{pattern.pattern}/
-            when String
-              pattern_to_register = prefix + pattern.pattern
-            end
-          else
-            pattern_to_register = pattern.pattern
-          end
+        suffix = @__cinch_suffix || bot.config.plugins.suffix
+
+        @__cinch_matches.each do |pattern|
+          _prefix = pattern.use_prefix ? prefix : nil
+          _suffix = pattern.use_suffix ? suffix : nil
 
+          pattern_to_register = Pattern.new(_prefix, pattern.pattern, _suffix)
           react_on = @__cinch_react_on || :message
 
-          bot.debug "[plugin] #{plugin_name}: Registering executor with pattern `#{pattern_to_register}`, reacting on `#{react_on}`"
+          bot.debug "[plugin] #{plugin_name}: Registering executor with pattern `#{pattern_to_register.inspect}`, reacting on `#{react_on}`"
 
           bot.on(react_on, pattern_to_register, instance, pattern) do |message, plugin, pattern, *args|
             if plugin.respond_to?(pattern.method)
@@ -140,7 +203,9 @@ module Cinch
               elsif arity == 0
                 args = []
               end
+              plugin.class.__hooks(:pre, :match).each {|hook| plugin.__send__(hook.method, message)}
               method.call(message, *args)
+              plugin.class.__hooks(:post, :match).each {|hook| plugin.__send__(hook.method, message)}
             end
           end
         end
@@ -148,13 +213,46 @@ module Cinch
         (@__cinch_ctcps || []).each do |ctcp|
           bot.debug "[plugin] #{plugin_name}: Registering CTCP `#{ctcp}`"
           bot.on(:ctcp, ctcp, instance, ctcp) do |message, plugin, ctcp, *args|
+            plugin.class.__hooks(:pre, :ctcp).each {|hook| plugin.__send__(hook.method, message)}
             plugin.__send__("ctcp_#{ctcp.downcase}", message, *args)
+            plugin.class.__hooks(:post, :ctcp).each {|hook| plugin.__send__(hook.method, message)}
+          end
+        end
+
+        (@__cinch_timers || []).each do |timer|
+          bot.debug "[plugin] #{__plugin_name}: Registering timer with interval `#{timer.interval}` for method `#{timer.method}`"
+          bot.on :connect do
+            next if timer.registered
+            timer.registered = true
+            Thread.new do
+              bot.debug "registering timer..."
+              loop do
+                sleep timer.interval
+                if instance.respond_to?(timer.method)
+                  l = lambda {
+                    begin
+                      instance.__send__(timer.method)
+                    rescue => e
+                      bot.logger.log_exception(e)
+                    end
+                  }
+
+                  if timer.threaded
+                    Thread.new do
+                      l.call
+                    end
+                  else
+                    l.call
+                  end
+                end
+              end
+            end
           end
         end
 
         if @__cinch_help_message
           bot.debug "[plugin] #{plugin_name}: Registering help message"
-          bot.on(:message, /#{prefix}help #{Regexp.escape(plugin_name)}/, @__cinch_help_message) do |message, help_message|
+          bot.on(:message, "#{prefix}help #{plugin_name}", @__cinch_help_message) do |message, help_message|
             message.reply(help_message)
           end
         end
@@ -169,10 +267,7 @@ module Cinch
       self.class.__register_with_bot(bot, self)
     end
 
-    # @param (see Bot#synchronize)
-    # @yield
-    # @return (see Bot#synchronize)
-    # @see Bot#synchronize
+    # (see Bot#synchronize)
     def synchronize(*args, &block)
       @bot.synchronize(*args, &block)
     end