cinch 0.1

data/lib/cinch/irc/message.rb

@@ -0,0 +1,121 @@
+module Cinch
+  module IRC
+    
+    # == Author
+    # * Lee Jarvis - ljjarvis@gmail.com
+    #
+    # == Description
+    # IRC::Message is a nicely encapsulated IRC message object. Used directly by 
+    # IRC::Parser#parse_servermessage and sent to every plugin defined. It does
+    # not do any parsing of itself, that's all down to the parser
+    #
+    # == See
+    # * Cinch::IRC::Parser#parse_servermessage
+    #
+    # TODO: Add more documentation
+    class Message
+
+      # Message prefix
+      attr_reader :prefix
+
+      # Message command (PRIVMSG, JOIN, KICK, etc)
+      attr_reader :command
+
+      # Message params
+      attr_reader :params
+
+      # Message symbol (lowercase command, ie. :privmsg, :join, :kick)
+      attr_reader :symbol
+      
+      # The raw string passed to ::new
+      attr_reader :raw
+
+      # Hash with message attributes
+      attr_reader :data
+
+      # Message text
+      attr_reader :text
+
+      # Arguments parsed from a rule
+      attr_accessor :args
+
+      # The IRC::Socket object (or nil)
+      attr_accessor :irc
+
+      # Invoked directly from IRC::Parser#parse_servermessage
+      def initialize(raw, prefix, command, params)
+        @raw = raw
+        @prefix = prefix
+        @command = command
+        @params = params
+        @text = params.last unless params.empty?
+
+        @symbol = command.downcase.to_sym
+        @data = {}
+        @args = {}
+        @irc = nil
+      end
+
+      # Access attribute
+      def [](var)
+        @data[var.to_sym]
+      end
+
+      # Add a new attribute (stored in @data)
+      def add(var, val)
+        @data[var.to_sym] = val
+      end
+      alias []= add
+
+      # Remove an attribute
+      def delete(var)
+        var = var.to_sym
+        return unless @data.key?(var)
+        @data.delete(var)
+      end
+
+      # Check if our message was sent privately
+      def private?
+        !@data[:channel]
+      end
+
+      # Add the nick/user/host attributes
+      def apply_user(nick, user, host)
+        @data[:nick] = nick
+        @data[:user] = user
+        @data[:host] = host
+      end
+
+      def reply(text)
+        recipient = data[:channel] || data[:nick]
+        @irc.privmsg(recipient, text)
+      end
+
+      def answer(text)
+        return unless data[:channel]
+        @irc.privmsg(data[:channel], "#{data[:nick]}: #{text}")
+      end
+
+      def action(text)
+        reply("\001ACTION #{text}\001")
+      end
+
+      # The raw IRC message
+      def to_s
+        raw
+      end
+
+      # Catch methods and check if they exist as keys in
+      # the attribute hash
+      def method_missing(meth, *args, &blk) # :nodoc:
+        if @data.key?(meth)
+          @data[meth]
+        else
+          nil
+        end
+      end
+
+    end
+  end
+end
+

data/lib/cinch/irc/parser.rb

@@ -0,0 +1,125 @@
+module Cinch
+  module IRC
+
+    # == Author
+    # * Lee Jarvis - ljjarvis@gmail.com
+    #
+    # == Description
+    # Parse incoming IRC lines and extract data, returning a nicely
+    # encapsulated Cinch::IRC::Message
+    #
+    # == Example
+    #  require 'cinch/irc/parser'
+    #  include Cinch::IRC::Parser
+    #
+    #  message = parse(":foo!bar@myhost.com PRIVMSG #mychan :ding dong!")
+    #
+    #  message.class #=> Cinch::IRC::Message
+    #  message.command #=> PRIVMSG
+    #  message.nick #=> foo
+    #  message.channel #=> #mychan
+    #  message.text #=> ding dong!
+    class Parser
+
+      # A hash holding all of our patterns
+      attr_reader :patterns
+
+      def initialize
+        @patterns = {}
+        setup_patterns
+      end
+
+      # Add a new pattern
+      def add_pattern(key, pattern)
+        raise ArgumentError, "Pattern is not a regular expression" unless pattern.is_a?(Regexp)
+        @patterns[key.to_sym] = pattern
+      end
+
+      # Remove a pattern
+      def remove_pattern(key)
+        key = key.to_sym
+        @patterns.delete(key) if @patterns.key?(key)
+      end
+
+      # Helper for our patterns Hash
+      def pattern(key)
+        @patterns[key]
+      end
+
+      # Set up some default patterns used directly by this class
+      def setup_patterns
+        add_pattern :letter, /[a-zA-Z]/
+          add_pattern :hex, /[\dA-Fa-f]/
+
+          add_pattern :ip4addr, /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+          add_pattern :ip6addr, /[\dA-Fa-f](?::[\dA-Fa-f]){7}|0:0:0:0:0:(?:0|[Ff]{4}):#{pattern(:ip4addr)}/
+          add_pattern :hostaddr, /#{pattern(:ip4addr)}|#{pattern(:ip6addr)}/
+          add_pattern :shortname, /[A-Za-z0-9][A-Za-z0-9-]*/
+          add_pattern :hostname, /#{pattern(:shortname)}(?:\.#{pattern(:shortname)})*/
+          add_pattern :host, /#{pattern(:hostname)}|#{pattern(:hostaddr)}/
+
+          add_pattern :user, /[^\x00\x10\x0D\x20@]+/
+          add_pattern :nick, /[A-Za-z\[\]\\`_^{|}][A-Za-z\d\[\]\\`_^{|}-]{0,19}/
+
+          add_pattern :userhost, /(#{pattern(:nick)})(?:(?:!(#{pattern(:user)}))?@(#{pattern(:host)}))?/
+
+          add_pattern :channel, /(?:[#+&]|![A-Z\d]{5})[^\x00\x07\x10\x0D\x20,:]/
+
+          # Server message parsing patterns
+          add_pattern :prefix, /(?:(\S+)\x20)?/
+          add_pattern :command, /([A-Za-z]+|\d{3})/
+          add_pattern :middle, /[^\x00\x20\r\n:][^\x00\x20\r\n]*/
+          add_pattern :trailing, /[^\x00\r\n]*/
+          add_pattern :params, /(?:((?:#{pattern(:middle)}){0,14}(?::?#{pattern(:trailing)})?))/
+          add_pattern :message, /\A#{pattern(:prefix)}#{pattern(:command)}#{pattern(:params)}\Z/
+
+          add_pattern :params_scan, /(?!:)([^\x00\x20\r\n:]+)|:([^\x00\r\n]*)/
+      end
+      private :setup_patterns
+
+      # Parse the incoming raw IRC string and return
+      # a nicely formatted IRC::Message
+      def parse_servermessage(raw)
+        raise ArgumentError, raw unless matches = raw.match(pattern(:message))
+
+        prefix, command, parameters = matches.captures
+
+        params = []
+        parameters.scan(pattern(:params_scan)) {|a, c| params << (a || c) }
+
+        m = IRC::Message.new(raw, prefix, command, params)
+
+        if prefix && userhost = parse_userhost(prefix)
+          m.apply_user(*userhost)
+
+          unless m.params.empty?
+            m[:recipient] = m.params.first
+            m[:channel] = m[:recipient] if valid_channel?(m[:recipient])
+          end
+        end
+
+        m # Return our IRC::Message
+      end
+      alias :parse :parse_servermessage
+
+      # Parse the prefix returned from the server
+      # and return an Array of [nick, user, host] or 
+      # nil if no match is found
+      def parse_userhost(prefix)
+        if matches = prefix.match(pattern(:userhost))
+          matches.captures
+        else
+          nil
+        end
+      end
+      alias :extract_userhost :parse_userhost
+
+      # Check if a string is a valid channel
+      def valid_channel?(str)
+        !str.match(pattern(:channel)).nil?
+      end
+
+    end
+  end
+end
+

data/lib/cinch/irc/socket.rb

@@ -0,0 +1,291 @@
+module Cinch
+  module IRC
+    # == Author
+    # * Lee Jarvis - ljjarvis@gmail.com
+    #
+    # == Description
+    # This class has been directly take from the irc-socket library. Original documentation
+    # for this class can be found {here}[http://rdoc.injekt.net/irc-socket].
+    #
+    # IRCSocket is an IRC wrapper around a TCPSocket. It implements all of the major 
+    # commands laid out in {RFC 2812}[http://irchelp.org/irchelp/rfc/rfc2812.txt].
+    # All these commands are available as instance methods of an IRCSocket Object.
+    #
+    # == Example
+    #  irc = IRCSocket.new('irc.freenode.org')
+    #  irc.connect
+    #
+    #  if irc.connected?
+    #    irc.nick "HulkHogan"
+    #    irc.user "Hulk", 0, "*", "I am Hulk Hogan"
+    #
+    #    while line = irc.read
+    #         
+    #      # Join a channel after MOTD
+    #      if line.split[1] == '376'
+    #        irc.join "#mychannel"
+    #      end
+    #
+    #      puts "Received: #{line}"
+    #    end
+    #  end
+    #
+    # === Block Form
+    #  IRCSocket.new('irc.freenode.org') do |irc|
+    #    irc.nick "SpongeBob"
+    #    irc.user "Spongey", 0, "*", "Square Pants"
+    #
+    #    puts irc.read
+    #  end
+    class Socket
+
+      # The server our socket is connected to
+      attr_reader :server
+
+      # The port our socket is connected on
+      attr_reader :port
+
+      # The TCPSocket instance
+      attr_reader :socket
+
+      # Creates a new IRCSocket and automatically connects
+      #
+      # === Example
+      #  irc = IRCSocket.open('irc.freenode.org')
+      #
+      #  while data = irc.read
+      #    puts data
+      #  end
+      def self.open(server, port=6667)
+        irc = new(server, port)
+        irc.connect
+        irc
+      end
+      
+      # Create a new IRCSocket to connect to +server+ on +port+. Defaults to port 6667.
+      # If an optional code block is given, it will be passed an instance of the IRCSocket.
+      # NOTE: Using the block form does not mean the socket will send the applicable QUIT
+      # command to leave the IRC server. You must send this yourself.
+      def initialize(server, port=6667)
+        @server = server
+        @port = port
+
+        @socket = nil
+        @connected = false
+
+        if block_given?
+          connect
+          yield self      
+        end
+      end
+      
+      # Check if our socket is alive and connected to an IRC server
+      def connected?
+        @connected
+      end
+      alias connected connected?
+      
+      # Connect to an IRC server, returns true on a successful connection, or
+      # raises otherwise
+      def connect
+        @socket = TCPSocket.new(server, port)
+      rescue Interrupt
+        raise
+      rescue Exception
+        raise
+      else
+        @connected = true
+      end
+
+      # Read the next line in from the server. If no arguments are passed
+      # the line will have the CRLF chomp'ed. Returns nil if no data could be read
+      def read(chompstr="\r\n")
+        if data = @socket.gets("\r\n")
+          data.chomp!(chompstr) if chompstr
+          data
+        else
+          nil
+        end
+      rescue IOError
+        nil
+      end
+
+      # Write to our Socket and append CRLF
+      def write(data)
+        @socket.write(data + "\r\n")
+      rescue IOError
+        raise
+      end
+
+      # Sugar for #write
+      def raw(*args) # :nodoc:
+        args.last.insert(0, ':') unless args.last.nil?
+        write args.join(' ').strip
+      end
+
+      # More sugar
+      def write_optional(command, *optional) # :nodoc:
+        command = "#{command} #{optional.join(' ')}" if optional
+        write(command.strip)
+      end
+      private :raw, :write_optional
+
+      # Send PASS command
+      def pass(password)
+        write("PASS #{password}")
+      end
+
+      # Send NICK command
+      def nick(nickname)
+        write("NICK #{nickname}")
+      end
+
+      # Send USER command 
+      def user(user, mode, unused, realname)
+        write("USER #{user} #{mode} #{unused} :#{realname}")
+      end
+
+      # Send OPER command
+      def oper(name, password)
+        write("OPER #{name} #{password}")
+      end
+
+      # Send the MODE command.
+      # Should probably implement a better way of doing this
+      def mode(channel, *modes)
+        write("MODE #{channel} #{modes.join(' ')}")
+      end
+
+      # Send QUIT command
+      def quit(message=nil)
+        raw("QUIT", message)
+      end
+
+      # Send JOIN command - Join a channel with given password
+      def join(channel, password=nil)
+        write("JOIN #{channel}")
+      end
+
+      # Send PART command
+      def part(channel, message=nil)
+        raw("PART", channel, message)
+      end
+
+      # Send TOPIC command
+      def topic(channel, topic=nil)
+        raw("TOPIC", channel, topic)
+      end
+
+      # Send NAMES command
+      def names(*channels)
+        write("NAMES #{channels.join(',') unless channels.empty?}")
+      end
+
+      # Send LIST command
+      def list(*channels)
+        write("LIST #{channels.join(',') unless channels.empty?}")
+      end
+
+      # Send INVITE command
+      def invite(nickname, channel)
+        write("INVITE #{nickname} #{channel}")
+      end
+
+      # Send KICK command
+      def kick(channel, user, comment=nil)
+        raw("KICK", channel, user, comment)
+      end
+
+      # Send PRIVMSG command
+      def privmsg(target, message)
+        write("PRIVMSG #{target} :#{message}")
+      end
+
+      # Send NOTICE command
+      def notice(target, message)
+        write("NOTICE #{target} :#{message}")
+      end
+
+      # Send MOTD command
+      def motd(target=nil)
+        write_optional("MOTD", target)
+      end
+
+      # Send VERSION command
+      def version(target=nil)
+        write_optional("VERSION", target)
+      end
+
+      # Send STATS command
+      def stats(*params)
+        write_optional("STATS", params)
+      end
+
+      # Send TIME command
+      def time(target=nil)
+        write_optional("TIME", target)
+      end
+
+      # Send INFO command
+      def info(target=nil)
+        write_optional("INFO", target)
+      end
+
+      # Send SQUERY command
+      def squery(target, message)
+        write("SQUERY #{target} :#{message}")
+      end
+
+      # Send WHO command
+      def who(*params)
+        write_optional("WHO", params)
+      end
+
+      # Send WHOIS command
+      def whois(*params)
+        write_optional("WHOIS", params)
+      end
+
+      # Send WHOWAS command
+      def whowas(*params)
+        write_optional("WHOWAS", params)
+      end
+
+      # Send KILL command
+      def kill(user, message)
+        write("KILL #{user} :#{message}")
+      end
+
+      # Send PING command
+      def ping(server)
+        write("PING #{server}")
+      end
+
+      # Send PONG command
+      def pong(server)
+        write("PONG #{server}")
+      end
+
+      # Send AWAY command
+      def away(message=nil)
+        raw("AWAY", message)
+      end
+
+      # Send USERS command
+      def users(target=nil)
+        write_optional("USERS", target)
+      end
+
+      # Send USERHOST command
+      def userhost(*users)
+        write("USERHOST #{users.join(' ')}")
+      end
+
+      # Close our socket instance
+      def close
+        @socket.close if connected?
+      end
+    end
+  end
+end
+