potato 0.0.6

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/README.md

@@ -0,0 +1,18 @@
+Potato
+======
+    $ gem install potato
+
+THEN
+
+    $ potato [--port port] [--room room1 --room room2] [--debug] [--max-users N]
+
+OR
+
+    #!/usr/bin/env ruby
+    require 'potato'
+    
+    Potato::Server.start(ARGV)
+
+THEN
+
+Connect your IRC client to localhost on port 6667 (or whatever other port you chose). Potato will give you instructions once connected. Happy potatoing!

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/potato

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "potato"
+
+Potato::Server.start(ARGV)

data/lib/potato.rb

@@ -0,0 +1,39 @@
+require "socket"
+require "ostruct"
+require "optparse"
+require "timeout"
+require "iconv"
+require "cgi"
+require "open-uri"
+require "net/http"
+
+$stdout.sync = true
+
+# A dAmn <=> IRC server.
+module Potato
+  # Used for making file requiring work properly
+  # @api private
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  
+  autoload :Server,   "#{ROOT}/potato/irc/server.rb"
+  
+  # IRC namespace
+  module IRC
+    require             "#{ROOT}/potato/irc/events.rb"
+    autoload :Client,   "#{ROOT}/potato/irc/client.rb"
+    autoload :Packet,   "#{ROOT}/potato/irc/packet.rb"
+    autoload :User,     "#{ROOT}/potato/irc/user.rb"
+  end
+  
+  # dAmn namespace
+  module DAmn
+    require             "#{ROOT}/potato/damn/events.rb"
+    autoload :Client,   "#{ROOT}/potato/damn/client.rb"
+    autoload :Packet,   "#{ROOT}/potato/damn/packet.rb"
+    autoload :Token,    "#{ROOT}/potato/damn/token.rb"
+  end
+end
+
+Dir["#{Potato::ROOT}/potato/helpers/*.rb"].each do |f|
+  require f
+end

data/lib/potato/damn/client.rb

@@ -0,0 +1,139 @@
+# Hack to manage reads on dAmn sockets in the select() loop
+class DamnSocket < TCPSocket; end
+
+module Potato
+  module DAmn
+    # Represents a connection to the dAmn server.
+    class Client
+      include Events
+      
+      # This instance's socket connection to the dAmn server.
+      # @return [DamnSocket]
+      attr_reader :server
+      
+      # An associative privclass level list.
+      # @return [Hash<String, Integer>]
+      attr_reader :privclasses
+      
+      # Instance variable hack to prevent unwanted NAMES listing to the IRC client
+      # @return [Boolean]
+      attr_accessor :whoising
+      
+      # @param [IRC::Client] user a reference to the irc client object that owns this dAmn client
+      def initialize user
+        @user = user
+        @privclasses = {}
+        @whoising = false
+      end
+      
+      # Handshake and login.
+      # @param [String] user username to login with
+      # @param [String] token authtoken to login with
+      # @see DAmn::Token
+      # @return [void]
+      def connect_with user, token
+        send_packet "dAmnClient", "0.3", :agent => "potato 0.1"
+        send_packet "login", user, :pk => token
+      end
+      
+      # Attempt to retrieve user information.
+      # @param [String] user user to investigate
+      # @return [void]
+      def whois user
+        send_packet "get", "login:#{user}", :p => "info"
+      end
+      
+      # Attempt to join a room.
+      # @param [String] room room to join
+      # @return [void]
+      def join room
+        send_packet "join", "chat:#{room.sub("#", "")}"
+      end
+      
+      # Attempt to part a room.
+      # @param [String] room room to part
+      # @return [void]
+      def part room
+        send_packet "part", "chat:#{room.sub("#", "")}"
+      end
+      
+      # Attempt to say something in a room.
+      # @param [String] room room to speak in
+      # @param [String] line line to speak
+      # @return [void]
+      def say room, line
+        send_packet "send", "chat:#{room.sub("#", "")}", :body => packet("msg", "main", :body => line)
+      end
+      
+      # Attempt to say an action in a room.
+      # @param [String] room room to action in
+      # @param [String] line line to say
+      # @return [void]
+      def action room, line
+        send_packet "send", "chat:#{room.sub("#", "")}", :body => packet("action", "main", :body => line)
+      end
+      
+      # Attempt to set the topic in a room.
+      # @param [String] room the room to set the topic of
+      # @param [String] topic the topic to set
+      # @return [void]
+      def topic room, topic
+        send_packet "set", "chat:#{room}", :p => "topic", :body => topic
+      end
+      
+      # Disconnect (attempt gracefully) from the server.
+      # @return [void]
+      def quit
+        send_packet "disconnect"
+        @server.close
+      end
+      
+      # Compose a dAmn packet.
+      # @param [String] pktname the packet command ("login", "join", etc.)
+      # @param [String] pktparam the packet parameter (usually a username or chatroom)
+      # @param [Hash] opts a key-value store of packet arguments
+      # @return [String]
+      def packet pktname, pktparam = nil, opts = {}
+        str = ""
+        str << pktname.to_s
+        if pktparam
+          str << " #{pktparam.to_s}"
+        end
+        opts.each{|k,v|
+          next if k == :body
+          str << "\n#{k}=#{v}"
+        }
+        if opts[:body]
+          str << "\n\n"
+          str << opts.delete(:body).to_s
+        end
+        str << "\n" unless pktname == "send"
+        str
+      end
+      
+      # Write out a packet to the server.
+      # @example Writes "login incluye\npk=my authtoken\n\0"
+      #   send_packet "login", "incluye",
+      #     :pk => "my authtoken"
+      # @example Writes "send chat:Botdom\n\nmsg main\n\nHello world!\n\0"
+      #   send_packet "send", "chat:Botdom",
+      #     :body => packet("msg", "main",
+      #       :body => "Hello world!")
+      # @see Client#packet
+      # @return [String]
+      def send_packet pktname, pktparam = nil, opts = {}
+        @server ||= DamnSocket.new "chat.deviantart.com", 3900
+        str = packet(pktname, pktparam, opts)
+        debug str
+        @server.write(str + "\0")
+        str
+      end
+      
+      # Debug one or more messages.
+      # @param [*String] strs any number of messages to print
+      def debug *strs
+        Server.debug *strs, :damn_out
+      end
+    end
+  end
+end

data/lib/potato/damn/events.rb

@@ -0,0 +1,82 @@
+module Potato
+  module DAmn
+    # @api private
+    # Manages packets received from dAmn
+    module Events
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_login pkt
+        @user.logged_in = true
+      end
+      
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_ping pkt
+        send_packet "pong"
+      end
+      
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_join pkt
+        @user.join(pkt.room)
+      end
+      
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_part pkt
+        @user.part(pkt.room)
+      end
+      
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_property pkt
+        if pkt.param =~ /login:/ && @whoising
+          @user.whois(pkt.param.sub("login:", ""), pkt)
+          @whoising = false
+        else
+          case pkt.args[:p]
+          when "topic"
+            @user.topic(pkt.room, pkt.body.decode_entities, pkt.args[:by], pkt.args[:ts])
+          when "members"
+            @user.names(pkt.room, pkt.subpkts)
+          when "privclasses"
+            @privclasses[pkt.room] = Hash[pkt.body.split(/\n/).map{|x|[x.split(":")[1], x.split(":")[0].to_i]}]
+          end
+        end
+      end
+      
+      # @param [DAmn::Packet] pkt
+      # @return [void]
+      def on_recv pkt
+        case pkt.subpkts[0].cmd
+        when "action", "msg"
+          @user.send(pkt.subpkts[0].cmd.to_sym,
+            pkt.room,
+            pkt.subpkts[0].args[:from],
+            pkt.body) unless pkt.body.to_tags.strip == @user.config.last_line.strip
+        when "join", "part"
+          @server.write("get login:#{pkt.subpkts[0].param}\np=info\n\0")
+          @user.send((pkt.subpkts[0].cmd + "s").to_sym,
+            pkt.subpkts[0].param, pkt.room,
+            Packet.new(@server.readline("\0")).subpkts.count{|x|x.cmd == "ns" && x.param == "chat:#{pkt.room}"},
+            begin; pkt.subpkts[1].cmd.gsub(/\w+=/, ""); rescue; nil; end,
+            begin; pkt.subpkts[1].args[:r]; rescue; nil; end)
+        when "kicked"
+          @user.kick(pkt.room, pkt.subpkts[0].param, pkt.subpkts[0].args[:by], pkt.subpkts[0].body)
+        when "admin"
+          case pkt.subpkts[0].param
+          when "create", "update"
+            @user.send("#{pkt.subpkts[0].param}_privclass".to_sym,
+              pkt.room, *pkt.subpkts[0].args.values_at(:name, :privs, :by))
+          when "rename"
+            @user.rename_privclass(pkt.room, *pkt.subpkts[0].args.values_at(:prev, :name, :by))
+          when "remove"
+            @user.remove_privclass(pkt.room, *pkt.subpkts[0].args.values_at(:name, :by))
+          end
+        when "privchg"
+          @user.move_user(pkt.room, pkt.subpkts[0].param, pkt.subpkts[0].args[:pc], pkt.subpkts[0].args[:by])
+        end
+      end
+    end
+  end
+end

data/lib/potato/damn/packet.rb

@@ -0,0 +1,112 @@
+module Potato
+  module DAmn
+    # Parser for dAmn packets.
+    class Packet
+      # Matches packets that should contain a body.
+      BODIED = [
+        /^recv p?chat:(.*?)\n\nmsg main/,
+        /^recv p?chat:(.*?)\n\naction main/,
+        /^property p?chat:(.*?)\np=(topic|title|privclasses)/,
+        /^recv p?chat:(.*?)\n\nkicked/,
+        /^recv p?chat:(.*?)\n\nadmin show/,
+        /^recv p?chat:(.*?)\n\nadmin privclass/,
+        /^kicked/
+      ]
+      # All existing tablumps.
+      TABLUMPS = (%w[&b &/b &i &/i &u &/u &s &/s &sup
+        &/sup &sub &/sub &code &/code &br
+        &ul &/ul &ol &/ol &li &/li &bcode
+        &/bcode &/a &/acro &/abbr &p &/p].map{|lump| lump + "\t" } +
+        [/&emote\t([^\t]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t/,
+        /&a\t([^\t]+)\t([^\t]*)\t/,
+        /&link\t([^\t]+)\t&\t/,
+        /&link\t([^\t]+)\t([^\t]+)\t&\t/,
+        /&dev\t[^\t]\t([^\t]+)\t/,
+        /&avatar\t([^\t]+)\t[0-9]+\t/,
+        /&thumb\t([0-9]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t([^\t]+)\t/,
+        /&img\t([^\t]+)\t([^\t]*)\t([^\t]*)\t/,
+        /&iframe\t([^\t]+)\t([0-9%]*)\t([0-9%]*)\t&\/iframe\t/,
+        /&acro\t([^\t]+)\t/,
+        /&abbr\t([^\t]+)\t/,
+        /^.+?<abbr title="(.+?)"><\/abbr>:/]).
+        zip(["\x02", "\x0F", "\x16", "\x0F", "\x1F", "\x0F", "<s>", "</s>",
+             "<sup>", "</sup>", "<sub>", "</sub>", "<code>", "</code>", "<br>",
+             "<ul>", "</ul>", "<ol>", "</ol>", "<li>", "</li>", "", "", "</a>",
+             "</acronym>", "", "<p>", "</p>", '\1', '<a href="\1" title="\2">',
+             '\1', '\1 (\2)', ':dev\1:', ':icon\1:', ':thumb\1:',
+             '<img src="\1" alt="\2" title="\3" />', '<iframe src="\1" width="\2" height="\3" />',
+             '<acronym title="\1">', '', '\1:', ''])
+
+      # @param [String] pkt the string received from the server to parse
+      # @raise [PacketNilException] if the string is nil, meaning that the server connection has been closed
+      def initialize pkt
+        TABLUMPS.each{|find, replace| pkt.gsub!(find, replace)}
+        @response = {:cmd => nil, :args => {}, :param => nil, :subpkts => [], :raw => pkt}
+        chunks = pkt.split(/\n\n/)
+        details = chunks.shift.split(/\n/)
+        @response[:cmd], @response[:param] = *details.shift.split(" ")
+        details.each{|dt|
+          key, value = *dt.split(/\W/, 2)
+          @response[:args][key.to_sym] = CGI.unescapeHTML(value)
+        }
+        body = BODIED.map{|x|!!(pkt =~ x)}.include?(true)
+        range = if body then chunks[0...-1] else chunks end
+        range.each{|c|
+          @response[:subpkts] << self.class.new(c)
+        }
+        if body && chunks[-1]
+          if pkt =~ /\n\n$/
+            @response[:subpkts] << self.class.new(chunks[-1])
+          else
+            @response[:body] = CGI.unescapeHTML(chunks[-1].chomp("\0").decode_entities)
+          end
+        end
+      end
+
+      # @return [String] the unformatted chat name
+      def room
+        if @response[:param] =~ /p?chat:/ then @response[:param].sub(/p?chat:/, "") else nil end
+      end
+
+      # @return [Boolean] whether the current packet has an error or not
+      def ok?
+        @response[:args][:e].nil? || @response[:args][:e] == "ok"
+      end
+
+      # @return [String] the current packet error
+      def error
+        @response[:args][:e]
+      end
+
+      # @yield [argument] iterates through each argument
+      def each &blk
+        @response[:args].each(&blk)
+      end
+
+      # @param [String] key the key to retrieve from the arguments
+      # @return [String] the packet argument
+      def [](key) @response[:args][key.to_sym] end
+
+      # @return [Packet] the first subpacket
+      def subpkt
+        @response[:subpkts][0]
+      end
+
+      # Lookup @response entries, struct-style.
+      def method_missing(m, *args, &blk) @response[m] end
+      
+      # Generates a human-readable representation of this packet
+      # @return [String]
+      def inspect
+        str = "#<Potato::DAmn::Packet '#{@response[:cmd]} #{@response[:param]}'"
+        str << ", args={#{@response[:args].map{|k,v|
+          "#{k}: #{v}"
+        }.join(", ")}}" if @response[:args].size > 0
+        str << ", body='#{@response[:body].rstrip}'" if @response[:body]
+        str << ", subpackets=#{@response[:subpkts]}" if @response[:subpkts].size > 0
+        str << ">"
+        str
+      end
+    end
+  end
+end

data/lib/potato/damn/token.rb

@@ -0,0 +1,53 @@
+module Potato
+  module DAmn
+    # Interface to grab dAmn authtokens.
+    module Token
+      extend self
+      
+      # Converts a hash to a URL query string.
+      # @param [Hash<String, String>] hash
+      # @return [String]
+      def safe_qstring hash
+        hash.map do |a,b|
+          a + "=" + b.to_s.gsub(/([^A-Za-z0-9\-])/) do
+            '%' + $1.unpack("U*")[0].to_s(16)
+          end
+        end.join("&")
+      end
+      
+      # Gets an authtoken.
+      # @param [String] username
+      # @param [String] password
+      # @return [String, nil]
+      def get username, password
+        uri = URI.parse("https://www.deviantart.com/users/login")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        cookies = nil
+        begin
+          http.start do
+            data = Token.safe_qstring({"username" => username, "password" => password, "remember_me" => 1})
+            http.request_post(uri.path,data) do |res|
+              uri = URI.parse("http://chat.deviantart.com/chat/Botdom")
+              Net::HTTP.new(uri.host, uri.port).start do |ht|
+                request = Net::HTTP::Get.new(uri.path)
+                request["cookie"] = res["Set-Cookie"].scan(/[a-z_]+=[^ ]{20,}/).join(";")
+                ht.request(request) do |req|
+                  if req.body.empty?
+                    return nil
+                  else
+                    return req.body.scan(/[0-9a-f]{32}/)[0]
+                  end
+                end
+              end
+            end
+          end
+        rescue Errno::ECONNRESET
+          warn "Connection reset by peer when attempting to retrieve authtoken."
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/potato/helpers/string.rb

@@ -0,0 +1,28 @@
+module Potato
+  # Mixin module for helper methods we want to add to classes.
+  module Helpers
+    # Helpers for String.
+    module String
+      # Convert numeric and hexadecimal HTML entities to Unicode codepoints.
+      # @return [String]
+      def decode_entities
+        gsub(/&#(\d+);/){[$1.to_i].pack("U*")}.gsub(/&#x([0-9a-fA-F]+);/u){[$1.to_i(16)].pack("U*")}
+      end
+      
+      # Convert Unicode codepoints to numeric HTML entities.
+      # @return [String]
+      def encode_entities
+        gsub(/([^ a-zA-Z0-9_.\-'",;!@#\$%^&\*\(\)\{\}\?\/\\<>=\+:])/u){"&##{$1.unpack("U*")[0]};"}
+      end
+      
+      # Convert IRC formatting to tags.
+      # @see Potato::DAmn::Client
+      # @return [String]
+      def to_tags
+        gsub(/\x02(.*?)\x0F/u, '<b>\1</b>').gsub(/\x16(.*?)\x0F/u, '<i>\1</i>').gsub(/\x1F(.*?)\x0F/u, '<u>\1</u>')
+      end
+    end
+  end
+end
+
+class String; include Potato::Helpers::String; end

data/lib/potato/irc/client.rb

@@ -0,0 +1,370 @@
+module Potato
+  module IRC
+    # A single client that intends to use dAmn.
+    class Client
+      include Events
+      
+      # The connection to the IRC user associated with this instance.
+      # @return [TCPSocket]
+      attr_reader :socket
+      
+      # The dAmn connection associated with this instance.
+      # @return [DAmn::Client]
+      attr_reader :client
+      
+      # Configuration value store
+      # @return [OpenStruct]
+      attr_reader :config
+      
+      # Have we logged in?
+      # @return [Boolean]
+      attr_accessor :logged_in
+      
+      def initialize sock
+        @config = OpenStruct.new({:last_line => ""})
+        @socket = sock
+        @client = Potato::DAmn::Client.new(self)
+        @logged_in = false
+        @users = {}
+      end
+      
+      # Triggered when a user first connects.
+      # @return [void]
+      def welcome!
+        send_packet :cmd => "localhost", :args => ["001", @config.nick],
+          :content => "Welcome to potato #{@config.nick}!#{@config.nick}@chat.deviantart.com"
+        send_packet :cmd => "localhost", :args => ["002", @config.nick],
+          :content => "Your host is localhost, running version potato0.1"
+        send_packet :cmd => "localhost", :args => ["004", @config.nick,
+            "iowghraAsORTVSxNCWqBzvdHtGp lvhopsmntikrRcaqOALQbSeIKVfMCuzNTGj"]
+        send_packet :cmd => "localhost", :args => ["005", @config.nick,
+          %w[UHNAMES NAMESX SAFELIST HCN MAXCHANNELS=20 CHANLIMIT=#:20 MAXLIST=b:60,e:60,I:60
+            NICKLEN=20 CHANNELLEN=100 TOPICLEN=8192 KICKLEN=8192 AWAYLEN=8192 MAXTARGETS=20]].flatten,
+            :content => "are supported by this server"
+        send_packet :cmd => "localhost", :args => ["005", @config.nick,
+          %w[MODES=12 CHANTYPES=# PREFIX=(qaohv)~&@%+ NETWORK=dAmn ELIST=MNUCT STATUSMSG=~&@%+]].flatten,
+          :content => "are supported by this server"
+        send_packet :cmd => @config.nick, :args => ["MODE", @config.nick], :content => "+i"
+        greeting = <<-EOG
+Welcome to dAmn, #{@config.nick}!
+To connect you need to give me some information.
+Type /pass yourpassword to authenticate.
+        EOG
+        greeting.split(/\n/).each do |g|
+          send_packet :colon => false, :cmd => "NOTICE", :args => %w[AUTH], :content => "*** #{g}"
+        end
+      end
+      
+      # Returns an IRC hostname.
+      # @param [String] user user to generate a hostname for
+      # @return [String]
+      def host_for user
+        "%s!%s@chat.deviantart.com" % [user, user]
+      end
+      
+      # Rejects one or more join requests if the user isn't logged in.
+      # @param [Array<String>] chans channels to notify for
+      # @return [void]
+      def cannot_join *chans
+        chans.each do |chan|
+          send_packet :cmd => "localhost", :args => [473, @config.nick, chan],
+            :content => "Not authenticated"
+        end
+      end
+      
+      # Notify that you have joined a room
+      # @param [String] room the joined room
+      # @return [void]
+      def join room
+        send_packet :cmd => @config.host, :args => "JOIN", :content => "##{room}"
+      end
+      
+      # Notify that you have parted a room
+      # @param [String] room the parted room
+      # @return [void]
+      def part room
+        send_packet :cmd => @config.host, :args => "PART", :content => "##{room}"
+      end
+      
+      # Notify that another user has joined a room
+      # @param [String] user the user that has joined
+      # @param [String] room the room that the user has joined
+      # @param [Integer] conns the number of connections the user has in which they are joined to this channel
+      # @param [String] privclass the name of the privclass in which the user can be found
+      # @return [void]
+      def joins user, room, conns, privclass, reason
+        if conns < 2
+          @users[room] << User.new(user, privclass, sym(@client.privclasses[room][privclass]), 
+            @client.privclasses[room][privclass])
+          send_packet :cmd => host_for(user), :args => "JOIN", :content => "##{room}"
+          send_packet :cmd => "localhost", :args =>
+            ["MODE", "##{room}", "+#{sym_to_level(sym(@client.privclasses[room][privclass]))}", user]
+        else
+          chan_notice(room, "#{user} has joined again (now joined #{conns} times)")
+        end
+      end
+      
+      # Notify that a user has parted a room
+      # @param [String] user the user that has parted
+      # @param [String] room the room that the user has parted
+      # @param [Integer] conns the number of connections the user has in which they are joined to this channel
+      # @param [String] privclass
+      # @return [void]
+      def parts user, room, conns, privclass, reason
+        if conns < 1
+          @users[room].delete_if{|x|x.username == user}
+          send_packet :cmd => host_for(user), :args => ["PART", "##{room}"], :content => reason
+        else
+          chan_notice(room, "#{user} has parted (now joined #{conns} time#{"s" unless conns == 1})")
+        end
+      end
+      
+      # A /names list for the current room.
+      # @param [String] room the room to query
+      # @param [Array<DAmn::Packet>] packets
+      # @return [void]
+      def names room, packets
+        @users[room] = packets.map{|x|User.new(x.param, x.args[:pc], sym(@client.privclasses[room][x.args[:pc]]),
+            @client.privclasses[room][x.args[:pc]])}
+        send_packet :cmd => "localhost", :args => [353, @config.nick, "=", "##{room}"],
+          :content => @users[room].reject{|k|k.username == @config.nick}.map{|k|k.symbol + k.username}.join(" ")
+        send_packet :cmd => "localhost", :args => [366, @config.nick, "##{room}"],
+          :content => "End of /NAMES list."
+        me_mode = sym_to_level(sym(@client.privclasses[room][packets.find{|x|x.param == @config.nick}.args[:pc]]))
+        unless me_mode.empty?
+          send_packet :cmd => "localhost", :args => 
+            ["MODE", "##{room}", "+#{me_mode}", @config.nick]
+        end
+      end
+      
+      # A /whois query for a user.
+      # @param [String] name the queried user
+      # @param [DAmn::Packet] packet
+      # @return [void]
+      def whois name, packet
+        send_packet :cmd => "localhost", :args => [311, @config.nick, name, name, "chat.deviantart.com", "*"],
+          :content => packet.subpkts[0].args[:realname]
+        send_packet :cmd => "localhost", :args => [307, @config.nick, name],
+          :content => "is a registered nick"
+        send_packet :cmd => "localhost", :args => [319, @config.nick, name],
+          :content => packet.subpkts.select{|pk|pk.cmd == "ns"}.map{|x|x.param.sub("chat:", "#")}.uniq.join(" ")
+        send_packet :cmd => "localhost", :args => [312, @config.nick, name, "localhost"],
+          :content => "potato"
+        send_packet :cmd => "localhost", :args => [317, @config.nick, name,
+          packet.subpkts.find{|pk|pk.cmd == "conn"}[:idle],
+          (Time.now - packet.subpkts.find{|pk|pk.cmd == "conn"}[:online].to_i).to_i],
+          :content => "seconds idle, signon time"
+        send_packet :cmd => "localhost", :args => [318, @config.nick, name],
+          :content => "End of /WHOIS list."
+      end
+      
+      # Convert a privclass level to a ~&@%+ symbol
+      # @param [#to_i] level the privclass level
+      # @return [String]
+      def sym level
+        case level.to_i
+        when 0..30
+          ""
+        when 31..70
+          "+"
+        when 71..80
+          "%"
+        when 81..98
+          "@"
+        when 99
+          "~"
+        end
+      end
+      
+      # Convert a ~&@%+ symbol to a mode qaohv
+      # @param [String] sym the symbol to convert
+      # @return [String]
+      def sym_to_level sym
+        case sym
+        when ""
+          ""
+        when "~"
+          "q"
+        when "@"
+          "o"
+        when "+"
+          "v"
+        when "%"
+          "h"
+        end
+      end
+      
+      # Notify that the topic has been set in the current room
+      # @param [String] room the room in which the topic has been set
+      # @param [String] topic the topic set
+      # @param [String] by the user who set the topic
+      # @param [String] time the time in seconds (since epoch) at which the topic was set
+      # @return [void]
+      def topic room, topic, by, time
+        send_packet :cmd => "localhost", :args => [332, @config.nick, "##{room}"],
+          :content => topic
+        send_packet :cmd => "localhost", :args => [333, @config.nick, "##{room}", by, time]
+      end
+      
+      # Display a message from a user in a room.
+      # @param [String] room the receiving room
+      # @param [String] user the sayer of the line
+      # @param [String] line the line said
+      # @return [void]
+      def msg room, user, line
+        line.gsub("<br>", "\n").split(/\n/).each do |l|
+          send_packet :cmd => host_for(user), :args => ["PRIVMSG", "##{room}"],
+            :content => l
+        end
+      end
+      
+      # Display an action from a user in a room.
+      # @param [String] room the receiving room
+      # @param [String] user the perpetrator of the action
+      # @param [String] line the action perpetrated
+      # @return [void]
+      def action room, user, line
+        line.gsub("<br>", "\n").split(/\n/).each do |l|
+          send_packet :cmd => host_for(user), :args => ["PRIVMSG", "##{room}"],
+            :content => "\x01ACTION #{l}\x01"
+        end
+      end
+      
+      # Notify that a user has been kicked from a room.
+      # @param [String] room the room from which somebody has been kicked
+      # @param [String] user the kickee
+      # @param [String] by the kicker
+      # @param [String] line the reason for kicking
+      # @return [void]
+      def kick room, user, by, line
+        send_packet :cmd => host_for(by), :args => ["KICK", "##{room}", user], :content => line || by
+      end
+      
+      # Notify that a privclass has been created in a room.
+      # @param [String] room the room in which has been added the privclass
+      # @param [String] privclass the name of the created privclass
+      # @param [String] privs the privileges of the created privclass
+      # @param [String] by the creator of the privclass
+      # @return [void]
+      def create_privclass room, privclass, privs, by
+        chan_notice room, "Privilege class \x16#{privclass}\x0F has been created by #{by} with {#{privs.split(" ").map{|x|x.split("=").join(": ")}.join(", ")}}"
+      end
+      
+      # Notify that a privclass has been updated in a room.
+      # @param [String] room the room in which has been updated the privclass
+      # @param [String] privclass the name of the updated privclass
+      # @param [String] privs the privileges of the created privclass
+      # @param [String] by the updator of the privclass
+      # @return [void]
+      def update_privclass room, privclass, privs, by
+        chan_notice room, "Privilege class \x16#{privclass}\x0F has been updated by #{by} with {#{privs.split(" ").map{|x|x.split("=").join(": ")}.join(", ")}}"
+        users = @users[room].select{|x|x.privclass == privclass}
+        mode = ""
+        count = 0
+        unless users[0].symbol == sym(@client.privclasses[room][privclass])
+          unless users[0].symbol.empty?
+            mode << "-#{sym_to_level(users[0].symbol) * users.size}"
+            count += 1
+          end
+          unless sym(@client.privclasses[room][privclass]).empty?
+            mode << "+#{sym_to_level(sym(@client.privclasses[room][privclass])) * users.size}"
+            count += 1
+          end
+          send_packet :cmd => "localhost", :args =>
+            ["MODE", "##{room}", mode, *(users.map(&:username) * count)]
+          users.each do |user|
+            user.symbol = sym(@client.privclasses[room][privclass])
+            user.privclass = privclass
+            user.level = @client.privclasses[room][privclass]
+          end
+        end
+      end
+      
+      # Notify that a privclass has been renamed in a room.
+      # @param [String] room the room in which has been renamed the privclass
+      # @param [String] prev the previous name of the privclass
+      # @param [String] priv the new name of the privclass
+      # @param [String] by the renamer of the privclass
+      # @return [void]
+      def rename_privclass room, prev, priv, by
+        chan_notice room, "Privclass \x16#{prev}\x0F has been renamed to \x16#{priv}\x0F by #{by}"
+      end
+      
+      # Notify that a privclass has been removed from a room.
+      # @param [String] room the room from which the privclass has been removed
+      # @param [String] privclass the name of the removed privclass
+      # @param [String] by the remover of the privclass
+      # @return [void]
+      def remove_privclass room, privclass, by
+        chan_notice room, "Privclass \x16#{privclass}\x0F has been removed by #{by}"
+      end
+      
+      # Notify that a user has been moved from one privclass to another.
+      # @param [String] room the room in which the user has been moved
+      # @param [String] user the name of the moved user
+      # @param [String] privclass the privclass to which the user has been moved
+      # @param [String] by the mover of the user
+      # @return [void]
+      def move_user room, user, privclass, by
+        chan_notice room, "#{user} has been moved to \x16#{privclass}\x0F by #{by}"
+        us = @users[room].find{|x|x.username == user}
+        mode = ""
+        count = 0
+        unless us.symbol == sym(@client.privclasses[room][privclass])
+          unless us.symbol.empty?
+            mode << "-#{sym_to_level(us.symbol)}"
+            count += 1
+          end
+          unless sym(@client.privclasses[room][privclass]).empty?
+            mode << "+#{sym_to_level(sym(@client.privclasses[room][privclass]))}"
+            count += 1
+          end
+          send_packet :cmd => "localhost", :args =>
+            ["MODE", "##{room}", mode, *([us.username] * count)]
+          us.symbol = sym(@client.privclasses[room][privclass])
+          us.privclass = privclass
+          us.level = @client.privclasses[room][privclass]
+        end
+      end
+      
+      # Sends you an auth notice (in the server window)
+      # @param [String] line the line to display
+      # @return [void]
+      def notice line
+        send_packet :colon => false, :cmd => "NOTICE", :args => "AUTH", :content => "*** #{line}"
+      end
+      
+      # Sends you a channel notice
+      # @param [String] room the room to notice
+      # @param [String] line the line to display
+      # @return [void]
+      def chan_notice room, line
+        send_packet :cmd => "localhost", :args => ["NOTICE", "##{room}"], :content => line
+      end
+      
+      # Compiles a packet and sends it to the server
+      # @param [Hash] opts a list of options
+      # @option opts [String] :cmd
+      # @option opts [Array] :args
+      # @option opts [String, nil] :content
+      # @option opts [Boolean] :colon whether to put a colon in front or not
+      # @see IRC::Packet
+      # @return [void]
+      def send_packet opts = {}
+        opts = ({:colon => true, :cmd => "", :args => [], :content => nil}).merge(opts)
+        str = opts[:colon] ? ":" : ""
+        str << opts[:cmd] << " " << Array(opts[:args]).join(" ")
+        str << " :#{opts[:content]}" if opts[:content]
+        @socket.write(str + "\r\n")
+        debug str
+      end
+      
+      # Sends debug messages
+      # @param [Array] strs all messages to send
+      # @return [void]
+      def debug *strs
+        Server.debug *strs, :irc_out
+      end
+    end
+  end
+end

data/lib/potato/irc/events.rb

@@ -0,0 +1,138 @@
+module Potato
+  module IRC
+    # Module for handling lines sent from an IRC client.
+    # @api private
+    module Events
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_nick pkt
+        @config.nick = pkt.args[0]
+        @config.host = host_for(pkt.args[0])
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_user pkt
+        welcome!
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_mode pkt
+        if pkt.args[0] =~ /#/
+          if pkt.args[1] == "b"
+            send_packet :cmd => "localhost", :args => [368, @config.nick, pkt.args[0]],
+              :content => "End of Channel Ban List"
+          else
+            send_packet :cmd => "localhost", :args => [324, @config.nick, pkt.args[0], "+"]
+            send_packet :cmd => "localhost", :args => [329, @config.nick, pkt.args[0], Time.now.to_i]
+          end
+        end
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_who pkt
+        users = @users[pkt.args[0].sub("#", "")].map(&:first)
+        users.uniq.each do |user|
+          send_packet :cmd => "localhost", :args => [352, @config.nick, pkt.args[0], user,
+            host_for(user), "localhost", user], :content => "0 #{user}"
+        end
+        send_packet :cmd => "localhost", :args => [315, @config.nick, pkt.args[0]],
+          :content => "End of /WHO list."
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_whois pkt
+        @client.whoising = true
+        @client.whois(pkt.args[0])
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_ping pkt
+        @socket.write("PONG #{pkt.args[0]}\r\n")
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_join pkt
+        rooms = pkt.args[0].include?(",") ? pkt.args[0].split(",") : pkt.args
+        unless @logged_in
+          cannot_join(*rooms)
+        else
+          rooms.each do |room|
+            @client.join(room)
+          end
+        end
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_pass pkt
+        notice "Attempting to retrieve authtoken."
+        begin
+          tok = Timeout::timeout(12) {
+            Potato::DAmn::Token.get(@config.nick, pkt.args[0])
+          }
+        rescue Timeout::Error
+          notice "dAmn server is down. Try again later."
+          @client.quit
+          @socket.close
+          return
+        end
+        if tok.nil?
+          notice "Unable to retrieve an authtoken (server didn't respond)."
+          @client.quit
+          @socket.close
+          return
+        elsif tok.empty?
+          notice "Wrong password or username. (no authtoken retrieved)"
+        else
+          notice "You have successfully logged in."
+          @logged_in = true
+          @config.token = tok
+          @client.connect_with(@config.nick, @config.token)
+          unless Server.opts.rooms.empty?
+            Server.opts.rooms.each do |room|
+              @client.join(room)
+            end
+          end
+        end
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_part pkt
+        @client.part(pkt.room)
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_privmsg pkt
+        pkt.args.each do |room|
+          if pkt.content =~ /\x01ACTION/
+            @client.action(room, pkt.content.gsub(/\x01(ACTION|\x00)?\s*/, "").encode_entities)
+          else
+            @client.say(room, pkt.content.encode_entities)
+          end
+        end
+        @config.last_line = pkt.content.gsub(/\x01(ACTION|\x00)?\s*/, "")
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_topic pkt
+        @client.topic(pkt.room, pkt.content)
+      end
+      
+      # @param [IRC::Packet] pkt
+      # @return [void]
+      def on_quit pkt
+        @client.quit
+        @socket.close
+      end
+    end
+  end
+end

data/lib/potato/irc/packet.rb

@@ -0,0 +1,41 @@
+module Potato
+  module IRC
+    # A line from an IRC client.
+    class Packet
+      # The first word of the packet, usually all-caps.
+      # @return [String]
+      attr_reader :cmd
+      
+      # Any words in the packet that aren't part of the content.
+      # @return [Array<String>]
+      attr_reader :args
+      
+      # Content of the packet (after a colon).
+      # @return [String, nil]
+      attr_reader :content
+      
+      # The actual packet string.
+      # @return [String]
+      attr_reader :raw
+      
+      def initialize str
+        str = str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
+        @raw = str
+        if str.include?(" :")
+          @cmd, *@args, @content = str.split(" ", str[0...str.index(" :")+1].count(" ") + 1)
+          @content.slice!(0)
+        else
+          @cmd, *@args = str.split(" ")
+        end
+        @cmd.upcase!
+        @content = @args.pop(@args.size - 1).join(" ") if @cmd == "PRIVMSG" && @content.nil?
+      end
+      
+      # The first argument whose first character is an octothorpe (#), or nil if none is found.
+      # @return [String]
+      def room
+        @args.find{|a|a =~ /^#/}[1..-1]
+      end
+    end
+  end
+end

data/lib/potato/irc/server.rb

@@ -0,0 +1,115 @@
+module Potato
+  # An IRC server.
+  module Server
+    extend self
+
+    # A list of the current connections (IRC-dAmn clients)
+    # @return [Hash<IO, IRC::Client>]
+    attr_reader :connections
+
+    # Command-line options.
+    # @return [Hash]
+    attr_reader :opts
+
+    # Write color-coded debug information if debug is enabled.
+    def debug(*items, type)
+      color = {:damn => 33, :irc => 35, :damn_out => 32, :irc_out => 34, :sys => 31}[type || :sys]
+      colon = (type == :damn_out || type == :irc_out) ? ">>" : "<<"
+      if @opts.debug
+        items.each do |line|
+          line.split("\n").each do |l|
+            puts "\e[#{color}m#{colon}\e[0m #{l}"
+          end
+        end
+      end
+    end
+
+    # Start the server and listen for connections.
+    # @param [Hash] opts command-line options
+    # @return [void]
+    def start opts
+      @connections = {}
+      @opts = self.parse_opts(opts)
+      @server = TCPServer.new(@opts.port)
+
+      loop do
+        begin
+          action = IO.select([@server, @connections.keys, @connections.values.map{|x|x.client.server}].flatten.compact, nil, nil)[0][0]
+        rescue IOError
+          @connections.delete_if { |k,v| v.client.server.closed? || k.closed? }
+          retry
+        rescue Interrupt
+          puts "\033[2DCaught interrupt (^C), exiting."
+          exit
+        end
+        if action == @server
+          if @connections.size <= @opts.max || @opts.max < 0
+            @connections[cl = @server.accept] = IRC::Client.new(cl)
+            debug "Accepted client #{cl}"
+          else
+            debug "Client #{cl = @server.accept} requested connection, but user limit (#{@opts.max}) has been reached"
+            cl.close
+          end
+        else
+          if DamnSocket === action
+            begin
+              pkt = DAmn::Packet.new(Iconv.conv("UTF-8", "LATIN1", action.readline("\0").chomp("\0")))
+            rescue Errno::ECONNRESET, EOFError => e
+              @connections.values.each do |cl|
+                cl.notice "Lost connection to dAmn (#{e.class})."
+                cl.socket.close
+              end
+              @connections = {}
+            end
+            debug pkt.raw, :damn
+            client = @connections.values.find{|x|x.client.server == action}.client
+            client.send("on_#{pkt.cmd}".to_sym, pkt) if client.respond_to?("on_#{pkt.cmd}".to_sym)
+          else
+            if action.eof?
+              @connections.delete(action)
+              debug "Client #{action} disconnected"
+            else
+              client = @connections[action]
+              pkt = IRC::Packet.new(action.readline("\r\n").chomp("\r\n"))
+              debug pkt.raw, :irc
+              client.send("on_#{pkt.cmd.downcase}".to_sym, pkt) if client.respond_to?("on_#{pkt.cmd.downcase}".to_sym)
+            end
+          end
+        end
+      end
+    end
+
+    # Parses command-line options into <code>@opts</code>.
+    # @return [Hash]
+    def parse_opts(args)
+      options = OpenStruct.new
+      options.rooms = []
+      options.port = 6667
+      options.debug = false
+      options.max = -1
+
+      o = OptionParser.new do |opts|
+        opts.banner = "Usage: potato [options]"
+
+        opts.on("-p", "--port PORT", Integer, "Specify port number (default 6667)") do |v|
+          options.port = v
+        end
+
+        opts.on("-r", "--room ROOM", "Add a room to the autojoin list") do |v|
+          options.rooms << v
+        end
+
+        opts.on("--debug", "Turn debug mode on or off (prints color-coded messages to stdout)") do |v|
+          options.debug = v
+        end
+
+        opts.on("--max-users N", Integer, "Set the maximum number of users that may connect to this server (default unlimited)") do |v|
+          options.max = v
+        end
+      end
+
+      o.parse!(args)
+      options
+    end
+  end
+end

data/lib/potato/irc/user.rb

@@ -0,0 +1,10 @@
+module Potato
+  module IRC
+    # Storage for a user's privilege level. Room-specific.
+    # @attr [String] username
+    # @attr [String] privclass
+    # @attr [String] symbol
+    # @attr [Integer] level
+    User = Struct.new(:username, :privclass, :symbol, :level)
+  end
+end

data/lib/potato/version.rb

@@ -0,0 +1,4 @@
+module Potato
+  # Current version of Potato.
+  VERSION = "0.0.6"
+end

data/potato.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "potato/version"
+
+Gem::Specification.new do |s|
+  s.name        = "potato"
+  s.version     = Potato::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joel Taylor"]
+  s.email       = ["holla@joeldt.net"]
+  s.homepage    = ""
+  s.summary     = %q{A dAmn <=> IRC proxy.}
+  s.description = %q{Potato is an IRC server that communicates with the deviantART Message Network and allows you to treat it like a regular IRC server, with support for user modes, kicks/bans, /whois-ing, etc.}
+
+  s.rubyforge_project = "potato"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: potato
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- Joel Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-22 00:00:00.000000000 -04:00
+default_executable: 
+dependencies: []
+description: Potato is an IRC server that communicates with the deviantART Message
+  Network and allows you to treat it like a regular IRC server, with support for user
+  modes, kicks/bans, /whois-ing, etc.
+email:
+- holla@joeldt.net
+executables:
+- potato
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- README.md
+- Rakefile
+- bin/potato
+- lib/potato.rb
+- lib/potato/damn/client.rb
+- lib/potato/damn/events.rb
+- lib/potato/damn/packet.rb
+- lib/potato/damn/token.rb
+- lib/potato/helpers/string.rb
+- lib/potato/irc/client.rb
+- lib/potato/irc/events.rb
+- lib/potato/irc/packet.rb
+- lib/potato/irc/server.rb
+- lib/potato/irc/user.rb
+- lib/potato/version.rb
+- potato.gemspec
+has_rdoc: true
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: potato
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A dAmn <=> IRC proxy.
+test_files: []