warchat 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in warchat.gemspec
+gemspec

data/Rakefile

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

data/lib/warchat/byte_string.rb

@@ -0,0 +1,8 @@
+module Warchat
+  class ByteString < String
+  
+    def to_s
+      self
+    end
+  end
+end

data/lib/warchat/chat/chat_response.rb

@@ -0,0 +1,20 @@
+module Warchat  module Chat
+    module ChatResponse
+      def presence?
+        chat_type == 'wow_presence'
+      end
+
+      def ack?
+        chat_type == 'message_ack'
+      end
+
+      def message? 
+        chat_type == 'wow_message'
+      end
+
+      def chat_type
+        self['chatType']
+      end
+    end
+  end
+end

data/lib/warchat/chat/client.rb

@@ -0,0 +1,98 @@
+module Warchat
+  module Chat
+    class Warchat::Chat::Client
+      attr_accessor :on_message,:on_presence,:on_logout,:on_fail,:on_establish
+      attr_accessor :on_message_afk,:on_message_dnd,:on_message_guild_chat,:on_message_motd,:on_message_officer_chat,:on_message_whisper,:on_chat_logout
+      attr_accessor :character_name,:character_realm
+      
+      attr_reader :session
+
+      def initialize
+        @session = Warchat::Network::Session.new
+
+        [:receive,:establish,:error].each do |m| 
+          session.send("on_#{m}=".to_sym, method("session_#{m}".to_sym)) 
+        end
+      end
+      
+      def start username, password
+        self.session.start(username,password)
+      end
+
+      def session_error response
+        on_fail.andand.call(response["body"]) if response.target == "/chat-login"
+      end
+
+      def session_establish response
+        puts 'Session Established'
+        on_establish.andand.call(response)
+      end
+
+      def session_receive response
+        send(response.target.gsub('/','').underscore.to_sym,response)
+      end
+      
+      def login
+        request = Warchat::Network::Request.new("/chat-login",:options=>{:mature_filter=>'false'},:n=>character_name,:r=>character_realm)
+        session.send_request(request)
+        @timer = Warchat::Timer.new(120,&method(:keep_alive))
+      end
+
+      def logout
+        request = Warchat::Network::Request.new('/chat-logout',:chatSessionId=>@chat_session_id)
+      end
+
+      def chat_logout response
+        puts 'Logged out of chat'
+        @timer.andand.stop
+        on_chat_logout.andand.call response
+        session.close
+      end
+
+      def chat_login response
+        puts "Logged into chat"
+        @chat_session_id = response["chatSessionId"]
+      end
+
+      def chat response
+        response.extend(ChatResponse)
+        if response.ack?
+          puts("chat ack")
+        elsif response.message?
+          message = Message.new(response)
+          on_message.andand.call(message)
+          send("on_message_#{message.type}".to_sym).andand.call(message)
+        elsif response.presence?
+          puts
+          on_presence.andand.call(Presence.new(response))
+        else
+          puts "unhandled chat type: #{response.chat_type}"
+        end
+      end
+
+      def close
+        request = Warchat::Network::Request.new("/chat-logout",:chatSessionId=>@chat_session_id)
+        session.send_request(request)
+      end
+
+      def keep_alive
+        puts "Sending 'keep-alive'"
+
+        request = Warchat::Network::Request("/ah-mail")
+        request["r"] = realm
+        request["cn"] = name
+        session.send_request(request)
+      end
+
+      def message(msg, chat_type = Message.CHAT_MSG_TYPE_GUILD_CHAT)
+        request = Warchat::Network::Request.new("/chat-guild",:type=>chat_type,:body=>msg,:chatSessionId=>@chat_session_id)
+        session.send_request(request)
+      end
+
+      def whisper(msg, char_id)
+        request = Warchat::Network::Request.new("/chat-whisper",:to=>char_id,:body=>msg,:chatSessionId=>@chat_session_id)
+        session.send_request(request)
+      end
+    end
+  end
+end

data/lib/warchat/chat/message.rb

@@ -0,0 +1,35 @@
+module Warchat
+  module Chat
+    class Message
+      CHAT_ID_TYPE_CHARACTER = "character"
+      CHAT_ID_TYPE_GUILD = "guild"
+      CHAT_ID_TYPE_GUILD_MEMBER = "guild_member"
+
+      CHAT_MSG_TYPE_AFK = "afk"
+      CHAT_MSG_TYPE_DND = "dnd"
+      CHAT_MSG_TYPE_GUILD_CHAT = "guild_chat"
+      CHAT_MSG_TYPE_GUILD_MOTD = "motd"
+      CHAT_MSG_TYPE_OFFICER_CHAT = "officer_chat"
+      CHAT_MSG_TYPE_WHISPER = "whisper"
+
+      attr_reader :type,:body,:from_type,:character_id,:from
+
+      def initialize response
+        @type = response["messageType"]
+        @body = response['body']
+        @from = response["from"]
+        @from_type = from["chatIdType"]
+
+        @character_id = from["characterId"]
+      end
+
+      def character_name
+        @character_id.andand.split(':')[-2]
+      end
+
+      def realm_id
+        @character_id.andand.split(':').last
+      end
+    end
+  end
+end

data/lib/warchat/chat/presence.rb

@@ -0,0 +1,22 @@
+module Warchat
+  module Chat
+    class Presence    
+      attr_reader :name,:character
+
+      def initialize response
+        @type = response["presenceType"];
+        @character = response["character"];
+        @name = character["n"];
+      end
+
+      def offline?
+        @type.andand.include? 'offline'
+      end
+
+      def type 
+        return 'unknown' unless @type
+        @type.split('_')[1..-1].join '_'
+      end
+    end
+  end
+end

data/lib/warchat/network/binary_reader.rb

@@ -0,0 +1,46 @@
+module Warchat
+  module Network
+    class BinaryReader
+      def initialize socket
+        @socket = socket
+      end
+
+      TYPES = [:hash,:array,:int_32,:string,:string,:boolean,:int_64]
+      def parse_next *args  
+        send TYPES[byte.unpack('C').first-1]
+      end
+      
+      def substream l
+        @socket.read l
+      end
+
+      def byte
+        substream 1
+      end
+
+      def string
+        substream(int_32)
+      end
+
+      def array
+        (1..(int_32)).map &method(:parse_next)
+      end
+
+      def hash
+        Hash[*(1..(int_32)).map do
+          [string,parse_next] 
+        end.flatten(1)]
+      end
+
+      {16=>'n',32=>'N',64=>'L_'}.each do |size,directive| 
+        define_method "int_#{size}".to_sym do 
+          substream(size/8).unpack(directive).first
+        end 
+      end
+
+      def boolean
+        byte == "\001"
+      end
+    end
+  end
+end

data/lib/warchat/network/binary_writer.rb

@@ -0,0 +1,86 @@
+module Warchat
+  module Network
+    class BinaryWriter
+
+      attr_reader :stream
+
+      def initialize stream
+        @stream = stream
+      end
+
+      def write obj
+        m = (obj.class.ancestors.map do |c| 
+          "write_#{File.basename c.name.underscore}".to_sym 
+        end.find(&method(:respond_to?)) or :write_string)
+        send(m,obj)
+      end
+
+      def write_string obj
+        byte 5
+        string obj.to_s
+      end
+
+      def write_integer obj
+        if obj < 2**32
+          byte 3
+          int_32 obj
+        else
+          byte 7
+          int_64 obj 
+        end
+      end
+
+      def write_hash obj
+        byte 1
+        int_32 obj.size
+        obj.each do |k,v|
+          string(k.to_s)
+          write(v)
+        end
+      end
+
+      def write_array obj
+        byte 2
+        int_32 obj.size
+        obj.each do |v|
+          write(v)
+        end
+      end
+
+      def write_byte_string obj
+        byte 4
+        int_32 obj.length
+        bytes obj
+      end
+
+      def write_bool obj
+        byte 6
+        byte(obj ? 1 : 0)
+      end
+      alias_method :write_true_class,:write_bool
+      alias_method :write_false_class,:write_bool
+
+
+      {16=>'n',32=>'N',64=>'L_'}.each do |size,directive|
+        define_method "int_#{size}".to_sym do |obj| 
+          @stream.print [obj].pack(directive)
+        end 
+      end
+
+      def string obj
+        obj = obj.to_s
+        int_32 obj.length
+        @stream.print obj
+      end
+
+      def byte obj
+        obj = (obj.is_a? Integer and [obj].pack('C') or obj.to_s[0..0])
+        @stream.print obj
+      end
+
+      def bytes obj
+        @stream.print obj.to_s
+      end
+    end  
+  end
+end

data/lib/warchat/network/connection.rb

@@ -0,0 +1,85 @@
+require 'socket'
+require 'thread'
+
+module Warchat
+  module Network
+    class Connection
+
+      attr_accessor :host,:port,:on_send,:on_receive,:on_close
+
+      def initialize *args
+        options = args.pop if args.last.is_a? Hash
+
+        self.host = (args.shift or "m.us.wowarmory.com")
+        self.port = (args.shift or 8780)
+        @closed = true
+        @queue = []
+        @mutex = Mutex.new
+      end
+
+      def start
+        close
+
+        @closed = false;
+        @socket = TCPSocket.open(host,port)
+        @socket.sync = false
+        @request_thread = Thread.new &method(:handle_requests)
+        @response_thread = Thread.new &method(:handle_responses)
+        @request_thread['name'] = 'Request Thead'
+        @response_thread['name'] = 'Response Thread'
+      end
+
+      def close reason = ""
+        return if is_closed?
+
+        on_close.andand.call(reason)
+        
+        @mutex.synchronize do 
+          @closed = true
+          @socket.close
+        end     
+      end
+
+      def is_closed? 
+        @closed or @socket.nil?
+      end
+
+      def send_request request
+        @mutex.synchronize do
+          @queue << request
+        end
+      end
+
+      def handle_responses
+        until is_closed?
+          response = Response.new(@socket)
+          on_receive.andand.call(response) unless is_closed?
+          sleep 0.01
+        end
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace unless e.is_a? IOError
+      end
+
+      def handle_requests
+        until is_closed?
+          @mutex.synchronize do
+            until @queue.empty?
+              
+              request = @queue.shift
+              unless is_closed?
+                request.stream @socket
+                @socket.flush
+                on_send.andand.call(request) 
+              end
+            end
+          end
+          sleep 0.01
+        end
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+      end
+    end
+  end
+end

data/lib/warchat/network/request.rb

@@ -0,0 +1,60 @@
+module Warchat
+  module Network
+    class Request < Hash
+      class StringSocket
+        def initialize
+          @stream = ""
+        end
+        
+        def print obj
+          @stream << obj.to_s
+        end
+        
+        def length
+          @stream.length
+        end
+        
+        def value
+          @stream
+        end
+      end
+      attr_reader :id,:target
+
+      def initialize target,*args
+        @target = target
+        @@request_count ||= -1
+        @@request_count += 1
+        @id = @@request_count
+        merge! args.shift if args.first.is_a? Hash
+        super *args
+      end
+
+      def stream socket
+        writer = BinaryWriter.new socket
+        writer.string(target)
+        writer.int_32(@id)
+        each do |k,v|
+          if [Hash,Array,Warchat::ByteString].none? &v.method(:is_a?)
+            writer.byte 5
+            writer.string k
+            writer.string v.to_s
+          else
+            writer.byte 4
+            writer.string k
+            tmp_socket = StringSocket.new
+            tmp = BinaryWriter.new(tmp_socket)
+            tmp.write v
+            writer.int_32(tmp_socket.length)        
+            writer.bytes(tmp_socket.value)
+          end
+          writer.byte 0xFF
+        end
+        writer.byte 0xFF
+      end
+      
+      def inspect
+        "<#{self.class.name} id:#{id.inspect} target:#{target.inspect} #{super}>"
+      end
+    end  
+  end
+end

data/lib/warchat/network/response.rb

@@ -0,0 +1,25 @@
+module Warchat
+  module Network
+    class Response < Hash
+      attr_accessor :length,:status,:target,:id
+      def initialize socket,*args
+        super *args
+        reader = BinaryReader.new socket
+        self.length = reader.int_32
+        self.status = reader.int_16
+        self.target = reader.string
+        self.id = reader.int_32
+
+        merge! reader.parse_next
+      end
+
+      def ok?
+        status == 200
+      end
+      
+      def inspect
+        "<#{self.class.name} id:#{id.inspect} target:#{target.inspect} status:#{status.inspect} #{super}>"
+      end
+    end
+  end
+end

data/lib/warchat/network/session.rb

@@ -0,0 +1,85 @@
+module Warchat
+  module Network
+    class Session
+
+      attr_accessor :on_close,:on_receive,:on_establish,:on_error
+
+
+      def initialize
+        @connection = Warchat::Network::Connection.new
+
+        @connection.on_close = method(:connection_close)
+        @connection.on_receive = method(:connection_receive)
+      end
+
+      def start account_name, password
+        @account_name = account_name
+        @password = password
+
+        @connection.start
+
+        @srp = Warchat::Srp::Client.new
+
+        send_request Request.new('/authenticate1',
+          :screenRes => "PHONE_HIGH",
+          :device => "iPhone",
+          :deviceSystemVersion => "4.2.1",
+          :deviceModel => "iPhone3,1",
+          :appV => "3.0.0",
+          :deviceTime => Time.now.to_i,
+          :deviceTimeZoneId => "America/New_York",
+          :clientA => @srp.a_bytes,
+          :appId => "Armory",
+          :deviceId => '50862581c5dc46072050d51886cbae3149b3473c',
+          :emailAddress => account_name,
+          :deviceTimeZone => "-14400000",
+          :locale => "en_US"
+        )
+      end
+      
+      def established? 
+        @established
+      end
+
+      def close reason=''
+        @connection.andand.close reason
+      end
+      
+      def send_request request
+        @connection.andand.send_request(request)
+      end
+
+      def stage_1 response
+        proof = @srp.auth1_proof(response["user"], @password[0..15].upcase, response["salt"], response["B"])
+        puts("sending client proof: 0x#{@srp.unpack_int(proof).to_s(16)} length: #{proof.length}")
+        send_request(Request.new("/authenticate2",:clientProof=>proof))
+      end
+
+      def stage_2 response
+        puts("sending client proof2")
+        send_request(Request.new("/authenticate2",:clientProof=>Warchat::ByteString.new("\000")))
+      end
+      
+      def stage_3 response
+        @established = true 
+        on_establish.andand.call(response)
+      end
+
+      def connection_receive response
+        puts response.inspect
+        m = "stage_#{response['stage']}".to_sym
+        if response.ok?
+          respond_to? m and send(m,response) or on_receive.andand.call(response)
+        else
+          error = response["body"]
+          puts("error: " + error)
+          close(error) if respond_to? m
+        end      
+      end
+
+      def connection_close reason
+        on_close.andand.call(reason)
+      end
+    end
+  end
+end

data/lib/warchat/srp/client.rb

@@ -0,0 +1,138 @@
+require 'digest'
+require 'openssl'
+
+module Warchat
+  module Srp
+    class Client
+      G = 2
+
+      MODULUS_SIZE = 128
+      MODULUS = 0x86a7f6deeb306ce519770fe37d556f29944132554ded0bd68205e27f3231fef5a10108238a3150c59caf7b0b6478691c13a6acf5e1b5adafd4a943d4a21a142b800e8a55f8bfbac700eb77a7235ee5a609e350ea9fc19f10d921c2fa832e4461b7125d38d254a0be873dfc27858acb3f8b9f258461e4373bc3a6c2a9634324ab
+
+      SALT_SIZE = 32
+      HASH_SIZE = 32
+      SESSION_KEY_SIZE = HASH_SIZE * 2
+
+      attr_reader :b,:b_bytes
+
+      def modpow(a, n, m) 
+        r = 1
+        while true
+          r = r * a % m if n[0] == 1
+          n >>= 1
+          return r if n == 0
+          a = a * a % m
+        end
+      end
+
+      def pack_int int
+        Warchat::ByteString.new [int.to_s(16).reverse].pack('h*')
+      end
+      
+      def unpack_int str
+        str.unpack('h*').first.reverse.hex
+      end
+      
+      def digest_int s
+        unpack_int(Digest::SHA2.digest(s))
+      end
+      
+      def adjust_size str,length
+        str[0..(length-1)].ljust(length,"\000")
+      end
+
+      def random_crypt
+        unpack_int(OpenSSL::Random.random_bytes(MODULUS_SIZE*2)) % MODULUS
+      end
+      
+      def hN_xor_hG
+        # xor H(N) and H(G)
+        return @hN_xor_hG if @hN_xor_hG
+        hN = Digest::SHA2.digest(pack_int(MODULUS))
+        hG = Digest::SHA2.digest(pack_int(G))
+        
+        @hN_xor_hG = "\000" * HASH_SIZE
+        
+        HASH_SIZE.times do |i| @hN_xor_hG[i] = (hN[i] ^ hG[i]) end
+          
+        @hN_xor_hG
+      end
+
+      def a
+        @a ||= random_crypt
+      end
+
+      def a_bytes 
+        @a_bytes ||= adjust_size(pack_int(modpow(G,a,MODULUS)),MODULUS_SIZE)
+      end
+
+      def k
+        @k ||= digest_int(pack_int(MODULUS)+pack_int(G))
+      end
+
+      def u 
+        # H(A | B)
+        @u ||= digest_int(a_bytes+b_bytes)
+      end
+
+      def x
+        # H(salt | H(userHash | : | sessionPassword))
+        @x ||= digest_int(@salt+Digest::SHA2.digest(@user+":"+@password))
+      end
+
+      def s
+        # (B - k * G^x) ^ (a + u * x)
+        return modpow(b - k * modpow(G, x, MODULUS), a + u * x, MODULUS)
+      end
+
+      def s_bytes
+        @s_bytes ||= adjust_size(pack_int(s),(MODULUS_SIZE))
+      end
+
+
+      def auth1_proof user, password, salt, b_bytes
+        @b = unpack_int b_bytes
+        @b_bytes = adjust_size(b_bytes,MODULUS_SIZE)
+        @salt = adjust_size(salt,SALT_SIZE)
+        @user = user
+        @password = password
+
+        # hash this to generate client proof, H(H(N) xor H(G) | H(userHash) | salt | A | B | K)
+        Warchat::ByteString.new Digest::SHA2.digest(hN_xor_hG+Digest::SHA2.digest(@user)+salt+a_bytes+@b_bytes+session_key)
+      end
+
+      def session_key
+        return @session_key if @session_key
+        @session_key = "\000" * SESSION_KEY_SIZE
+
+        l = s_bytes.length
+        offset = (l.odd? and 1 or 0)
+        l -= offset
+
+        l = [l/2,MODULUS_SIZE].min
+
+        temp = ''
+        l.times do |i|
+          temp << s_bytes[i*2+offset]
+        end
+
+        hash = Digest::SHA2.digest(temp)
+        HASH_SIZE.times do |i|
+          @session_key[i*2] = hash[i]
+        end
+
+        temp = ''
+        l.times do |i|
+          temp << s_bytes[i*2+offset+1]
+        end
+
+        hash = Digest::SHA2.digest(temp)
+        HASH_SIZE.times do |i|
+          @session_key[i*2+1] = hash[i]
+        end
+
+        @session_key
+      end
+    end
+  end
+end

data/lib/warchat/timer.rb

@@ -0,0 +1,45 @@
+require 'monitor'
+
+module Warchat  class Timer
+    def initialize(interval, &handler)
+      
+      raise ArgumentError, "Illegal interval" if interval < 0
+      @interval = interval
+      extend MonitorMixin
+      @run = true
+      @th = Thread.new do
+        while run?
+          do_sleep and handler.call rescue nil
+        end
+      end
+      @th['name'] = 'Timer'
+    end
+
+    def stop
+      synchronize do
+        @run = false
+      end
+      sleeping? and @th.kill or @th.join 
+    end
+
+    private
+    
+    def sleeping?
+      synchronize do @sleeping end
+    end
+    
+    def do_sleep
+      synchronize do @sleeping = true end
+      sleep(@interval)
+      synchronize do @sleeping = false end
+    rescue
+      nil
+    end
+
+    def run?
+      synchronize do
+        @run
+      end
+    end
+  end
+end

data/lib/warchat/version.rb

@@ -0,0 +1,3 @@
+module Warchat  
+  VERSION = "0.0.1"
+end

data/lib/warchat.rb

@@ -0,0 +1,7 @@
+require 'active_support/inflector'
+require 'andand'
+
+module Warchat  
+end
+
+[['*.rb'],['network','*.rb'],['srp','*.rb'],['chat','*.rb']].each do |p| Dir.glob(File.join(File.expand_path('../wow_chat',__FILE__)),*p)).each &method(:require) end

data/warchat.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "warchat/version"
+
+Gem::Specification.new do |s|
+  s.name        = "warchat"
+  s.version     = Warchat::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Zachary Gavin"]
+  s.email       = ["zgavin@gmail.com"]
+  s.homepage    = "http://www.github.com/zgavin/warchat"
+  s.summary     = %q{A simple interface to World of Warcraft Remote Guild Chat based off Eike Siewertsen's C# implementation}
+  s.description = %q{A simple interface to World of Warcraft Remote Guild Chat in Ruby.  Supports whispers, guild chat, officer chat, and presence notifications.  Many thanks to Eike Siewertsen (https://github.com/fry) for his work deciphering the protocol.  }
+
+  s.rubyforge_project = "warchat"
+  
+  s.add_dependency('activesupport','>= 3.0.0')
+  s.add_dependency('andand')
+  
+  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,115 @@
+--- !ruby/object:Gem::Specification 
+name: warchat
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Zachary Gavin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: andand
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: "A simple interface to World of Warcraft Remote Guild Chat in Ruby.  Supports whispers, guild chat, officer chat, and presence notifications.  Many thanks to Eike Siewertsen (https://github.com/fry) for his work deciphering the protocol.  "
+email: 
+- zgavin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/warchat.rb
+- lib/warchat/byte_string.rb
+- lib/warchat/chat/chat_response.rb
+- lib/warchat/chat/client.rb
+- lib/warchat/chat/message.rb
+- lib/warchat/chat/presence.rb
+- lib/warchat/network/binary_reader.rb
+- lib/warchat/network/binary_writer.rb
+- lib/warchat/network/connection.rb
+- lib/warchat/network/request.rb
+- lib/warchat/network/response.rb
+- lib/warchat/network/session.rb
+- lib/warchat/srp/client.rb
+- lib/warchat/timer.rb
+- lib/warchat/version.rb
+- warchat.gemspec
+has_rdoc: true
+homepage: http://www.github.com/zgavin/warchat
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: warchat
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: A simple interface to World of Warcraft Remote Guild Chat based off Eike Siewertsen's C# implementation
+test_files: []
+