cinch 0.3.5 → 1.0.0

data/lib/cinch/exceptions.rb

@@ -0,0 +1,25 @@
+module Cinch
+  module Exceptions
+    # Generic error. Superclass for all Cinch-specific errors.
+    class Generic < ::StandardError
+    end
+
+    class ArgumentTooLong < Generic
+    end
+
+    # Error that is raised when a topic is too long to be set.
+    class TopicTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a nick is too long to be used.
+    class NickTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a kick reason is too long.
+    class KickReasonTooLong < ArgumentTooLong
+    end
+
+    class UnsupportedFeature < Generic
+    end
+  end
+end

data/lib/cinch/helpers.rb

@@ -0,0 +1,21 @@
+module Cinch
+  module Helpers
+    # Helper method for turning a String into a {Channel} object.
+    #
+    # @param (see Bot#Channel)
+    # @return (see Bot#Channel)
+    # @example (see Bot#Channel)
+    def Channel(*args)
+      @bot.Channel(*args)
+    end
+
+    # Helper method for turning a String into an {User} object.
+    #
+    # @param (see Bot#User)
+    # @return (see Bot#User)
+    # @example (see Bot#User)
+    def User(*args)
+      @bot.User(*args)
+    end
+  end
+end

data/lib/cinch/irc.rb

@@ -1,45 +1,351 @@
-lib = File.dirname(__FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+module Cinch
+  class IRC
+    # @return [ISupport]
+    attr_reader :isupport
+    def initialize(bot, config)
+      @bot, @config = bot, config
+      @isupport = ISupport.new
+    end
 
-require 'socket'
-require 'timeout'
+    # Establish a connection.
+    #
+    # @return [void]
+    def connect
+      @registration = []
 
-require 'irc/parser'
-require 'irc/message'
-require 'irc/socket'
+      @whois_updates = Hash.new {|h, k| h[k] = {}}
+      @in_lists      = Set.new
 
-module Cinch
+      tcp_socket = TCPSocket.open(@config.server, @config.port)
+
+      if @config.ssl
+        require 'openssl'
+
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        @bot.logger.debug "Using SSL with #{@config.server}:#{@config.port}"
+
+        @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+        @socket.sync = true
+        @socket.connect
+      else
+        @socket = tcp_socket
+      end
+      @socket.set_encoding(@bot.config.encoding || Encoding.default_external,
+                           Encoding.default_internal,
+                           {:invalid => :replace, :undef => :replace})
+
+      @queue = MessageQueue.new(@socket, @bot)
+      message "PASS #{@config.password}" if @config.password
+      message "NICK #{@config.nick}"
+      message "USER #{@config.nick} 0 * :#{@config.realname}"
+
+      Thread.new do
+        begin
+          while line = @socket.gets
+            begin
+              parse line
+            rescue => e
+              @bot.logger.log_exception(e)
+            end
+          end
+        rescue => e
+          @bot.logger.log_exception(e)
+        end
+
+        @bot.dispatch(:disconnect)
+      end
+      begin
+        @queue.process!
+      rescue => e
+        @bot.logger.log_exception(e)
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def parse(input)
+      @bot.logger.log(input, :incoming) if @bot.config.verbose
+      msg          = Message.new(input, @bot)
+      events       = []
+
+      if ("001".."004").include? msg.command
+        @registration << msg.command
+        if registered?
+          events << :connect
+        end
+      elsif ["PRIVMSG", "NOTICE"].include?(msg.command)
+        events << :ctcp if msg.ctcp?
+        if msg.channel?
+          events << :channel
+        else
+          events << :private
+        end
+
+        if msg.command == "PRIVMSG"
+          events << :message
+        else
+          events << :notice
+        end
+      else
+        meth = "on_#{msg.command.downcase}"
+        __send__(meth, msg) if respond_to?(meth, true)
+
+        if msg.error?
+          events << :error
+        else
+          events << msg.command.downcase.to_sym
+        end
+      end
+
+      msg.instance_variable_set(:@events, events)
+      events.each do |event|
+        @bot.dispatch(event, msg)
+      end
+    end
+
+    # @return [Boolean] true if we successfully registered yet
+    def registered?
+      (("001".."004").to_a - @registration).empty?
+    end
+
+    # Send a message.
+    # @return [void]
+    def message(msg)
+      @queue.queue(msg)
+    end
+
+    private
+    def on_join(msg)
+      if msg.user == @bot
+        @bot.channels << msg.channel
+        msg.channel.sync_modes
+      end
+      msg.channel.add_user(msg.user)
+    end
+
+    def on_kick(msg)
+      target = User.find_ensured(msg.params[1], @bot)
+      if target == @bot
+        @bot.channels.delete(msg.channel)
+      end
+      msg.channel.remove_user(target)
+    end
+
+    def on_kill(msg)
+      user = User.find_ensured(msg.params[1], @bot)
+      Channel.all.each do |channel|
+        channel.remove_user(user)
+      end
+      user.synced = false
+    end
+
+    def on_mode(msg)
+      msg.channel.sync_modes if msg.channel?
+    end
+
+    def on_nick(msg)
+      if msg.user == @bot
+        @bot.config.nick = msg.params.last
+      end
+
+      msg.user.instance_variable_set(:@nick, msg.params.last)
+    end
+
+    def on_part(msg)
+      msg.channel.remove_user(msg.user)
+      if msg.user == @bot
+        @bot.channels.delete(msg.channel)
+      end
+    end
+
+    def on_ping(msg)
+      message "PONG :#{msg.params.first}"
+    end
+
+    def on_topic(msg)
+      msg.channel.sync(:topic, msg.params[1])
+    end
+
+    def on_quit(msg)
+      Channel.all.each do |channel|
+        channel.remove_user(msg.user)
+      end
+      msg.user.synced = false
+    end
+
+    def on_005(msg)
+      # ISUPPORT
+      @isupport.parse(*msg.params[1..-2].map {|v| v.split(" ")}.flatten)
+    end
+
+    def on_311(msg)
+      # RPL_WHOISUSER
+      user = User.find_ensured(msg.params[1], @bot)
+      @whois_updates[user].merge!({
+                                    :user => msg.params[2],
+                                    :host => msg.params[3],
+                                    :realname => msg.params[5],
+                                  })
+    end
+
+    def on_317(msg)
+      # RPL_WHOISIDLE
+      user = User.find_ensured(msg.params[1], @bot)
+      @whois_updates[user].merge!({
+                                    :idle => msg.params[2].to_i,
+                                    :signed_on_at => Time.at(msg.params[3].to_i),
+                                  })
+    end
+
+    def on_318(msg)
+      # RPL_ENDOFWHOIS
+      user = User.find_ensured(msg.params[1], @bot)
+      user.instance_variable_set(:@in_whois, false)
+      if @whois_updates[user].empty? && !user.attr(:unknown?, true, true)
+        # for some reason, we did not receive user information. one
+        # reason is freenode throttling WHOIS
+        Thread.new do
+          sleep 2
+          user.whois
+        end
+      else
+        {
+          :authname => nil,
+          :idle => 0,
+          :secure? => false,
+        }.merge(@whois_updates[user]).each do |attr, value|
+          user.sync(attr, value, true)
+        end
+
+        user.sync(:unknown?, false, true)
+        user.instance_variable_set(:@synced, true)
+        @whois_updates.delete user
+      end
+    end
+
+    def on_319(msg)
+      # RPL_WHOISCHANNELS
+      user = User.find_ensured(msg.params[1], @bot)
+      channels = msg.params[2].scan(/#{@isupport["CHANTYPES"].join}[^ ]+/o).map {|c| Channel.find_ensured(c, @bot) }
+      user.sync(:channels, channels, true)
+    end
+
+    def on_324(msg)
+      # RPL_CHANNELMODEIS
+
+      modes = {}
+      arguments = msg.params[3..-1]
+      msg.params[2][1..-1].split("").each do |mode|
+        if (@isupport["CHANMODES"]["B"] + @isupport["CHANMODES"]["C"]).include?(mode)
+          modes[mode] = arguments.shift
+        else
+          modes[mode] = true
+        end
+      end
+
+      msg.channel.sync(:modes, modes, false)
+    end
+
+    def on_330(msg)
+      # RPL_WHOISACCOUNT
+      user = User.find_ensured(msg.params[1], @bot)
+      authname = msg.params[2]
+      @whois_updates[user].merge!({:authname => authname})
+    end
+
+    def on_331(msg)
+      # RPL_NOTOPIC
+      msg.channel.sync(:topic, "")
+    end
+
+    def on_332(msg)
+      # RPL_TOPIC
+      msg.channel.sync(:topic, msg.params[2])
+    end
+
+    def on_353(msg)
+      # RPL_NAMEREPLY
+      unless @in_lists.include?(:names)
+        msg.channel.clear_users
+      end
+      @in_lists << :names
+
+      msg.params[3].split(" ").each do |user|
+        if @isupport["PREFIX"].values.include?(user[0..0])
+          prefix = user[0..0]
+          nick   = user[1..-1]
+        else
+          nick   = user
+          prefix = nil
+        end
+        user = User.find_ensured(nick, @bot)
+        msg.channel.add_user(user, prefix)
+      end
+    end
+
+    def on_366(msg)
+      # RPL_ENDOFNAMES
+      @in_lists.delete :names
+      msg.channel.mark_as_synced(:users)
+    end
+
+    def on_367(msg)
+      # RPL_BANLIST
+      unless @in_lists.include?(:bans)
+        msg.channel.bans_unsynced.clear
+      end
+      @in_lists << :bans
+
+      mask = msg.params[2]
+      by   = User.find_ensured(msg.params[3].split("!").first, @bot)
+      at   = Time.at(msg.params[4].to_i)
+
+      ban = Ban.new(mask, by, at)
+      msg.channel.bans_unsynced << ban
+    end
+
+    def on_368(msg)
+      # RPL_ENDOFBANLIST
+      if @in_lists.include?(:bans)
+        @in_lists.delete :bans
+      else
+        # we never received a ban, yet an end of list => no bans
+        msg.channel.bans_unsynced.clear
+      end
+
+      msg.channel.mark_as_synced(:bans)
+    end
+
+    def on_396(msg)
+      # note: designed for freenode
+      User.find_ensured(msg.params[0], @bot).sync(:host, msg.params[1], true)
+    end
+
+    def on_401(msg)
+      # ERR_NOSUCHNICK
+      user = User.find_ensured(msg.params[1], @bot)
+      user.sync(:unknown?, true, true)
+    end
+
+    def on_402(msg)
+      # ERR_NOSUCHSERVER
+      if user = User.find(msg.params[1]) # not _ensured, we only want a user that already exists
+        user.sync(:unknown?, true, true)
+        @whois_updates.delete user
+        # TODO freenode specific, test on other IRCd
+      end
+    end
 
-  # == Description
-  # Cinch::IRC provides tools to interact with an IRC server, this
-  # includes reading/writing/parsing and building a message response.
-  #
-  # You can use these tools through Cinch or include them directly and use
-  # them on their own.
-  #
-  # Each class inside of this module can be used direcly as they contain
-  # no references to higher level classes inside Cinch
-  #
-  # == Example
-  #  require 'cinch/irc'
-  #  require 'pp'
-  #
-  #  parser = Cinch::IRC::Parser.new
-  #
-  #  Cinch::IRC::Socket.new('irc.2600.net') do |irc|
-  #    irc.nick "Cinch"
-  #    irc.user "Cinch", 0, '*', "Cinch IRC bot"
-  #
-  #    while line = irc.read
-  #      message = parser.parse(line)
-  #  
-  #      pp message
-  #    end
-  #  end
-  #
-  # == Author
-  # * Lee Jarvis - ljjarvis@gmail.com
-  module IRC
+    def on_433(msg)
+      # ERR_NICKNAMEINUSE
+      @bot.nick = msg.params[1] + "_"
+    end
 
+    def on_671(msg)
+      user = User.find_ensured(msg.params[1], @bot)
+      @whois_updates[user].merge!({:secure? => true})
+    end
   end
 end

data/lib/cinch/isupport.rb

@@ -0,0 +1,96 @@
+module Cinch
+  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] => 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"]     = Infinity
+      self["MAXBANS"]     = Infinity
+      self["TOPICLEN"]    = Infinity
+      self["KICKLEN"]     = Infinity
+      self["CHANNELLEN"]  = Infinity
+      self["CHIDLEN"]     = 5
+      self["AWAYLEN"]     = Infinity
+      self["MAXTARGETS"]  = 1
+      self["MAXCHANNELS"] = Infinity # deprecated
+      self["CHANLIMIT"]   = {"#" => Infinity}
+      self["STATUSMSG"]   = ["@", "+"]
+      self["CASEMAPPING"] = :rfc1459
+      self["ELIST"]       = []
+    end
+
+    # @api private
+    # @return [void]
+    def parse(*options)
+      options.each do |option|
+        name, value = option.split("=")
+        if value
+          proc = @@mappings.find {|key, value| key.include?(name)}
+          self[name] = (proc && proc[1].call(value)) || value
+        else
+          self[name] = true
+        end
+      end
+    end
+  end
+end