cinch 0.3.5 → 1.0.0

data/lib/cinch/irc/message.rb

@@ -1,135 +0,0 @@
-module Cinch
-  module IRC
-    
-    # == Description
-    # IRC::Message provies a nicely encapsulated IRC message object. Used directly by 
-    # IRC::Parser#parse and sent to any plugin or listener defined. 
-    #
-    # TODO: Add more documentation
-    # 
-    # == See Also
-    # * Cinch::IRC::Parser#parse
-    #
-    # == Author
-    # * Lee Jarvis - ljjarvis@gmail.com
-    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_accessor :symbol
-      
-      # The raw string passed to ::new
-      attr_reader :raw
-
-      # Hash with message attributes
-      attr_reader :data
-
-      # Message text
-      attr_accessor :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
-
-      # Alter an attribute
-      def alter(var, val)
-        if @data.key?(var)
-          @data[var] = val
-        end
-      end
-
-      # Check if our message was sent privately
-      def private?
-        !@data[:channel]
-      end
-
-      # Check if our message was sent publicly (in a channel)
-      def public?
-        !private?
-      end
-
-      # Reply to a channel or user, probably the most commonly used helper
-      # method
-      def reply(text)
-        recipient = data[:channel] || data[:nick]
-        @irc.privmsg(recipient, text)
-      end
-
-      # Same as reply but prefixes the users nickname
-      def answer(text)
-        return unless data[:channel]
-        @irc.privmsg(data[:channel], "#{data[:nick]}: #{text}")
-      end
-
-      # Send a CTCP reply
-      def ctcp_reply(text)
-        recipient = data[:channel] || data[:nick]
-        @irc.notice(recipient, "\001#{@data[:ctcp_action]} #{text}\001")
-      end
-
-      # The deadly /me action
-      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

@@ -1,141 +0,0 @@
-module Cinch
-  module IRC
-
-    # == Description
-    # Parse incoming IRC lines and extract data, returning a nicely
-    # encapsulated Cinch::IRC::Message
-    #
-    # == Example
-    #  require 'cinch/irc/parser'
-    #
-    #  message = Cinch::IRC::Parser.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!
-    #
-    # == Author
-    # * Lee Jarvis - ljjarvis@gmail.com
-    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)
-        @patterns[key.to_sym] = pattern
-      end
-
-      # Remove a pattern
-      def remove_pattern(key)
-        @patterns.delete(key.to_sym)
-      end
-
-      # Helper for our patterns Hash
-      def pattern(key)
-        @patterns[key.to_sym]
-      end
-
-      # Check if a pattern exists
-      def has_pattern?(key)
-        @patterns.key?(key.to_sym)
-      end
-
-      # Set up some default patterns used directly by this class
-      def setup_patterns
-        add_pattern :letter, /[a-zA-Z]/
-        add_pattern :word, /\w+/
-        add_pattern :upper, /[A-Z]+/
-        add_pattern :lower, /[a-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 :ctcp, /\001(\S+)(?:\s([^\x00\r\n\001]+))?\001$/
-
-        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(raw)
-        raise ArgumentError, raw unless raw && 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)
-          nick, user, host = userhost
-          m.add(:nick, nick)
-          m.add(:user, user)
-          m.add(:host, host)
-
-          unless m.params.empty?
-            m.add(:recipient, m.params.first)
-            m.add(:channel, m.recipient) if valid_channel?(m.recipient)
-          end
-        end
-
-        # Parse CTCP response
-        if m.symbol == :privmsg && data = m.text.match(pattern(:ctcp))
-          m.symbol = :ctcp
-          m.text = data[2]
-          m.add(:ctcp_action, data[1])
-        end
-
-        m # Return our IRC::Message
-      end
-
-      # 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

@@ -1,329 +0,0 @@
-module Cinch
-  module IRC
-
-    # == Description
-    # This class has been directly taken 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
-    #
-    # == Author
-    # * Lee Jarvis - ljjarvis@gmail.com 
-    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
-
-      # How long to wait before aborting a connection
-      attr_accessor :timeout
-
-      # Maximum attempts to retry failed connection
-      attr_accessor :attempts
-
-      # 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, ssl=false)
-        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, ssl=false)
-        @server = server
-        @port = port
-        @ssl = ssl
-
-        @socket = nil
-        @connected = false
-        @timeout = 5
-        @attempts = 5
-
-        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(server=nil, port=nil, ssl=false)
-        @server = server if server
-        @port = port if port
-        @ssl = ssl if ssl
-  
-        Timeout.timeout(@timeout) do
-          socket = TCPSocket.new(@server, @port)
-
-          if @ssl
-            require 'openssl'
-
-            ssl = OpenSSL::SSL::SSLContext.new
-            ssl.verify_mode = OpenSSL::SSL::VERIFY_NONE
-            @socket = OpenSSL::SSL::SSLSocket.new(socket, ssl)
-            @socket.sync = true
-            @socket.connect
-          else
-            @socket = socket
-          end
-        end
-      rescue Timeout::Error
-        if @attempts == 0
-          puts "Maximum attempts reached. Aborting .."
-          exit 1
-        else
-          puts "Connection timed out. Retrying #{@attempts} more time#{'s' unless @attempts == 1} .."
-          @attempts -= 1
-          connect(server, port)
-        end
-      rescue Interrupt
-        puts "\nAborting connection .."
-        exit
-      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_optional("JOIN #{channel}", password)
-      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
-