ruggby 0.3.0

data/lib/ruggby/action/mark.rb

@@ -0,0 +1,27 @@
+module RuGGby
+
+  module Action
+
+    # Send a "mark" message
+    # If we don't download GG friends list, we need to send a mark anyway
+    class Mark < Base
+
+      def initialize(client)
+        @client = client
+        @block  = client.actions[:mark]
+      end
+
+      # Send a mark packet
+      def run!
+        @client.logger.debug('RuGGby::Action::Mark')
+
+        mark = Packet::Outgoing::Mark.new
+        @client.socket.write(mark)
+        @block.call if @block
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/action/new_message.rb

@@ -0,0 +1,28 @@
+module RuGGby
+
+  module Action
+
+    # Action invoken when new message occures
+    class NewMessage < Base
+
+      attr_reader :uin, :message
+
+      def initialize(client, data)
+        @client     = client
+        @block      = client.actions[:new_message]
+        @uin        = data[0]
+        @created_at = Time.at(data[2])
+        @message    = StringEncoder.complex(data[4])
+      end
+
+      def run!
+        @client.logger.debug('RuGGby::Action::NewMessage')
+
+        @block.call(@uin, @created_at, @message) if @block
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/action/ping.rb

@@ -0,0 +1,40 @@
+module RuGGby
+
+  module Action
+
+    # Ping action
+    # In order to maintaine a TCP connection with GG server, we need to send
+    # a ping from time to time.
+    # This is done in a background thread (don't need to worry about it
+    # just ignite it and forget ;) )
+    class Ping < Base
+
+      SLEEP_TIME = 180
+
+      def initialize(client)
+        @client = client
+        @block  = client.actions[:ping]
+      end
+
+      def run!
+        @client.loops[:ping] = Thread.new do
+          begin
+            loop do
+              @client.logger.info('RuGGby::Action::Ping')
+              ping = Packet::Outgoing::Ping.new
+              @client.socket.write(ping)
+              sleep SLEEP_TIME
+              @block.call if @block
+            end
+          rescue => e
+            @client.logger.fatal("RuGGby::Action::Ping #{e}")
+            raise e
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/action/read.rb

@@ -0,0 +1,49 @@
+module RuGGby
+
+  module Action
+
+    # Action reading from socket - will check every SLEEP_TIME if there is a
+    # data in TCPSocket
+    class Read < Base
+
+      SLEEP_TIME = 0.2
+
+      def initialize(client)
+        @client = client
+        @block  = client.actions[:read]
+      end
+
+      # Start a thread that reads data and if there is any data - try to create
+      # an appropriate packet and if successful will create a thread that
+      # handles an callback
+      def run!
+        @client.loops[:read] = Thread.new do
+          @client.logger.debug('RuGGby::Action::Read')
+          begin
+            loop do
+              sleep SLEEP_TIME
+
+              if el = RuGGby::Packet::Factory.new(@client.socket).build
+                @client.logger.info("RuGGby::Action::Read - type: #{el.class::TYPE}")
+
+                case RuGGby::Converter.action(el.class::TYPE)
+                  when :new_message then
+                    action = RuGGby::Action::NewMessage.new(@client, el.data)
+                    Threader.run(@client, action)
+                end
+
+                @block.call(el) if @block
+              end
+            end
+          rescue => e
+            @client.logger.fatal("RuGGby::Action::Read #{e}")
+            raise e
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ruggby/callback.rb

@@ -0,0 +1,22 @@
+module RuGGby
+
+  # Defines methods that we can use to define an actions to events
+  module Callback
+
+    # What should we do when we receive a new message
+    # You'll get passed 3 parameters to a block:
+    # uin        => user GG number
+    # created_at => Time.at when message was sent
+    # message    => String containing a received message
+    def on_new_message(&block)
+      self.actions[:new_message] = block
+    end
+
+    # Method invoked when we change our status or description on GG
+    def on_change_status(&block)
+      self.actions[:change_status] = block
+    end
+
+  end
+
+end

data/lib/ruggby/client.rb

@@ -0,0 +1,95 @@
+module RuGGby
+
+  # The main GG bot class used to control our GG bot
+  class Client
+
+    include Callback
+
+    class << self
+      attr_accessor :logger
+      attr_accessor :log_level
+    end
+
+    @logger    ||= RuGGby::Logger
+    @log_level ||= :debug
+
+    attr_reader :socket, :password
+    attr_writer :logged
+    attr_accessor :loops, :actions, :threads, :reconnect, :status, 
+      :description, :login, :logger
+
+    def initialize()
+      @loops   = {}
+      @actions = {}
+      @threads = []
+      @logged  = false
+      @logger  = self.class.logger.new(self.class.log_level)
+
+      @logger.debug('RuGGby::Client initialized')
+    end
+
+    def login!(gg_nr, password, params = {})
+      @logger.debug('RuGGby::Client login in')
+
+      @login       = gg_nr
+      @password    = password
+      @status      = params[:status] || :available
+      @description = params[:description]
+
+      if logged?
+        @logger.info('RuGGby::Client already logged')
+        return true
+      end
+
+      @logger.debug('RuGGby::Client creating socket')
+
+      @socket = Socket.new(@login)
+
+      begin
+        RuGGby::Action::Login.new(self).run!
+      rescue => e
+        @logger.info("RuGGby::Client login failed")
+        @logger.error("RuGGby::Client #{e}")
+
+        @logged = false
+      end
+
+      if logged?
+        RuGGby::Action::Mark.new(self).run!
+        RuGGby::Action::Ping.new(self).run!
+        RuGGby::Action::Read.new(self).run!
+      end
+      
+      @logged
+    end
+
+    def logged?
+      @logged
+    end
+
+    def logout!
+      @logger.debug('RuGGby::Client logout')
+
+      @threads.each { |t| t.exit    }
+      @loops.each   { |k, v| v.exit }
+      @socket.close
+      @logged = false
+    end
+
+    def change_status(status, description = '')
+      RuGGby::Action::ChangeStatus.new(self, status, description).run!
+    end
+
+    def message(uin, message)
+      @logger.debug('RuGGby::Client message')
+
+      RuGGby::Action::CreateMessage.new(self, uin, message).run!
+    end
+
+    def wait
+      @loops[:ping].join
+    end
+
+  end
+
+end

data/lib/ruggby/converter.rb

@@ -0,0 +1,57 @@
+module RuGGby
+
+  # Module used to convert messages from GG format (INT, Chars) to a ruby symbols
+  module Converter
+
+    # Available actions
+    ACTION = {
+      Packet::Incoming::Message::TYPE => :new_message
+    }
+
+    # Available statuses (sent by GG server)
+    STATUS = {
+      0x02 => :available,
+      0x04 => :available,
+      0x03 => :busy,
+      0x05 => :busy,
+      0x14 => :invisible,
+      0x16 => :invisible,
+      0x01 => :not_available,
+      0x15 => :not_available
+    }
+
+    # Statuses that we can use
+    TO_STATUS = {
+      :available     => 0x02,
+      :busy          => 0x03,
+      :invisible     => 0x14,
+      :not_available => 0x01
+    }
+
+    # Statuses that are available but we also need to provide a description
+    TO_STATUS_DESCRIPTION = {
+      :available     => 0x04,
+      :busy          => 0x05,
+      :invisible     => 0x16,
+      :not_available => 0x15
+    }
+
+    def self.status(status)
+      if status.is_a?(Symbol) || status.is_a?(String)
+        TO_STATUS[status.to_sym]
+      else
+        STATUS[status]
+      end
+    end
+
+    def self.status_description(status)
+      TO_STATUS_DESCRIPTION[status]
+    end
+
+    def self.action(action)
+      ACTION[action]
+    end
+
+  end
+
+end

data/lib/ruggby/logger.rb

@@ -0,0 +1,67 @@
+module RuGGby
+
+  class Logger
+
+    DEBUG   = 0
+    INFO    = 1
+    ERROR   = 2
+    FATAL   = 3
+
+    LEVEL_MAP = {
+      :debug => DEBUG,
+      :info  => INFO,
+      :error => ERROR,
+      :fatal => FATAL
+    }
+
+    # Available log levels
+    # => debug
+    # => error
+    # => fatal
+    def initialize(level)
+      @level = LEVEL_MAP[level]
+    end
+
+    # Returns +true+ iff the current level allows for the printing of
+    # +DEBUG+ messages.
+    def debug?; @level <= DEBUG; end
+
+    # Returns +true+ iff the current level allows for the printing of
+    # +INFO+ messages.
+    def info?; @level <= INFO; end
+
+    # Returns +true+ iff the current level allows for the printing of
+    # +ERROR+ messages.
+    def error?; @level <= ERROR; end
+
+    # Returns +true+ iff the current level allows for the printing of
+    # +FATAL+ messages.
+    def fatal?; @level <= FATAL; end
+
+    def debug(msg)
+      handle_message(msg, :debug)
+    end
+
+    def info(msg)
+      handle_message(msg, :info)
+    end
+
+    def error(msg)
+      handle_message(msg, :error)
+    end
+
+    def fatal(msg)
+      handle_message(msg, :fatal)
+    end
+
+    private
+
+    def handle_message(msg, level)
+      if self.send(:"#{level}?")
+        printf "%-6s %s\n", level.upcase.to_s+':', msg
+      end
+    end
+
+  end
+
+end

data/lib/ruggby/packet/factory.rb

@@ -0,0 +1,39 @@
+module RuGGby
+
+  module Packet
+
+    # Will build a certain incoming packet based on a message header
+    class Factory
+
+      # I => unsigned int, native endian
+      HEADER_PACK_PATTERN = 'II'
+      HEADER_SIZE = 8
+
+      attr_reader :type, :length, :data
+
+      def initialize(socket)
+        unpacked = socket.read(HEADER_SIZE).unpack HEADER_PACK_PATTERN
+        @type, @length = unpacked
+        @data = socket.read(@length)
+      end
+
+      def build
+        case @type
+          when Packet::Incoming::Welcome::TYPE then
+            Incoming::Welcome.new(@data)
+          when Packet::Incoming::LoginStatus::TYPE then
+            Packet::Incoming::LoginStatus.new(true)
+          when Packet::Incoming::Message::TYPE then
+            Packet::Incoming::Message.new(@data)
+          when nil
+            Packet::Incoming::LoginStatus.new(false)
+          else
+            nil
+        end
+      end
+
+    end
+
+  end
+  
+end

data/lib/ruggby/packet/incoming/base.rb

@@ -0,0 +1,31 @@
+module RuGGby
+
+  module Packet
+
+    module Incoming
+
+      # Base class for all the incoming packets
+      # Unpacks the data accorging to the pattern method
+      class Base
+
+        class NotImplemented < Exception; end
+
+        attr_reader :data
+
+        def initialize(data)
+          @data = data.unpack(pattern)
+        end
+
+        private
+
+        def pattern
+          raise NotImplemented
+        end
+
+      end
+
+    end
+
+  end
+
+end