percy 0.0.6 → 1.0.0

data/README.md

@@ -1,4 +1,4 @@
-# Percy 0.0.6
+# Percy 1.0.0
 
 ## Configuring and starting the bot
 
@@ -9,29 +9,31 @@
     require 'rubygems'
     require 'percy'
     
-    bot = Percy.new
-    
-    bot.configure do |c|
-      c.server = 'chat.eu.freenode.net'
-      c.port = 6667
-      c.nick = 'Percyguy'
-      c.verbose = true
-      c.logging = true
+    Percy.configure do |c|
+      c.server             = 'chat.eu.freenode.net'
+      c.port               = 6667
+      # c.password         = 'password'
+      c.nick               = 'Percyguy'
+      c.username           = 'Percyguy'
+      c.verbose            = true
+      c.logging            = true
+      c.reconnect          = true
+      c.reconnect_interval = 30
     end
     
-    bot.connect
+    Percy.connect
 
 Start it with `ruby mybot.rb`.
 
 ## Handling Events
 ### Connect
-    bot.on :connect do
+    Percy.on :connect do
       # ...
     end
 No variables.
 
 ### Channel message
-    bot.on :channel, /^foo!/ do |env|
+    Percy.on :channel, /^foo!/ do |env|
       # ...
     end
 Variables:
@@ -43,7 +45,7 @@ env[:channel]<br />
 env[:message]</tt>
 
 ### Query message
-    bot.on :query, /^bar!/ do |env|
+    Percy.on :query, /^bar!/ do |env|
       # ...
     end
 Variables:
@@ -54,7 +56,7 @@ env[:host]<br />
 env[:message]</tt>
 
 ### Join
-    bot.on :join do |env|
+    Percy.on :join do |env|
       # ...
     end
 Variables:
@@ -65,7 +67,7 @@ env[:host]<br />
 env[:channel]</tt>
 
 ### Part
-    bot.on :part do |env|
+    Percy.on :part do |env|
       # ...
     end
 Variables:
@@ -77,7 +79,7 @@ env[:channel]<br />
 env[:message]</tt>
 
 ### Quit
-    bot.on :quit do |env|
+    Percy.on :quit do |env|
       # ...
     end
 Variables:
@@ -88,7 +90,7 @@ env[:host]<br />
 env[:message]</tt>
 
 ### Nickchange
-    bot.on :nickchange do |env|
+    Percy.on :nickchange do |env|
       # ...
     end
 Variables:
@@ -99,7 +101,7 @@ env[:host]<br />
 env[:new_nick]</tt>
 
 ### Kick
-    bot.on :kick do |env|
+    Percy.on :kick do |env|
       # ...
     end
 Variables:
@@ -111,58 +113,58 @@ env[:channel]<br />
 env[:victim]<br />
 env[:reason]</tt>
 
-## Availabe Methods
+## Availabe Class Methods
 
-`raw(msg)`
+`Percy.raw(msg)`
 
 Sends a raw message to the server.
 
-`message(recipient, msg)`
+`Percy.message(recipient, msg)`
 
 Sends a message to a channel or an user.
 
-`notice(recipient, msg)`
+`Percy.notice(recipient, msg)`
 
 Sends a notice to an user.
 
-`action(recipient, msg)`
+`Percy.action(recipient, msg)`
 
 Performs an action (/me ...).
 
-`mode(recipient, option)`
+`Percy.mode(recipient, option)`
 
 Sets a mode for a channel or an user.
 
-`channellimit(channel)`
+`Percy.channellimit(channel)`
 
 Returns the channel limit of a channel (as integer if set, else (not set/timeout) false).
 
-`kick(channel, user, reason)`
+`Percy.kick(channel, user, reason)`
 
 Kicks an user from a channel with a specific reason.
 
-`topic(channel, topic)`
+`Percy.topic(channel, topic)`
 
 Sets the topic for a channel.
 
-`join(channel, password = nil)`
+`Percy.join(channel, password = nil)`
 
 Joins a channel.
 
-`part(channel, msg)`
+`Percy.part(channel, msg)`
 
 Parts a channel with a message.
 
-`quit(msg = nil)`
+`Percy.quit(msg = nil)`
 
 Quits from the server with a message.
 
-`users_on(channel)`
+`Percy.users_on(channel)`
 
 Returns an array of users from a channel (mode in front like: ['@percy', 'Peter_Parker', '+The_Librarian']) or false if timeout.
 
 
-`is_online(nick)`
+`Percy.is_online(nick)`
 
 Returns a nickname as string if online, else false (not online/timeout)
 

data/VERSION

@@ -1 +1 @@
-0.0.6
+1.0.0

data/lib/percy.rb

@@ -1,43 +1,73 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
+require 'rubygems'
+require 'eventmachine'
 require 'percylogger'
-require 'socket'
 require 'timeout'
 require 'thread'
 
 Thread.abort_on_exception = true
 
-class Percy
-  VERSION = 'Percy 0.0.6 (http://github.com/tbuehlmann/percy)'
+class Connection < EventMachine::Connection
+  include EventMachine::Protocols::LineText2
   
-  Config = Struct.new(:server, :port, :password, :nick, :username, :verbose, :logging)
+  def connection_completed
+    Percy.raw "NICK #{Percy.config.nick}"
+    Percy.raw "USER #{Percy.config.nick} 0 * :#{Percy.config.username}"
+    Percy.raw "PASS #{Percy.config.password}" if Percy.config.password
+  end
   
-  def initialize
-    @config = Config.new("localhost", 6667, nil, 'Percy', 'Percy', true, false)
-    
-    # helper variables for getting server return values
-    @observers = 0
-    @temp_socket = []
-    
-    # user methods
-    @on_channel    = []
-    @on_query      = []
-    @on_connect    = []
-    @on_join       = []
-    @on_part       = []
-    @on_quit       = []
-    @on_nickchange = []
-    @on_kick       = []
-    
-    # observer synchronizer
-    @mutex = Mutex.new
-    
-    # running variable (provisional solution for rejoining at netsplit)
-    @running = true
+  def unbind
+    Percy.connected = false
+    Percy.traffic_logger.info('-- Percy disconnected') if Percy.traffic_logger
+    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Percy disconnected"
+    if Percy.config.reconnect
+      Percy.traffic_logger.info("-- Reconnecting in #{Percy.config.reconnect_interval} seconds") if Percy.traffic_logger
+      puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Reconnecting in #{Percy.config.reconnect_interval} seconds"
+      
+      EventMachine::add_timer(Percy.config.reconnect_interval) do
+        reconnect Percy.config.server, Percy.config.port
+      end
+    end
+  end
+  
+  def receive_line(line)
+    Percy.parse line
+  end
+end
+
+class Percy
+  class << self
+    attr_reader :config
+    attr_accessor :traffic_logger, :connected
   end
   
-  # configure block
-  def configure(&block)
+  VERSION = 'Percy 1.0.0 (http://github.com/tbuehlmann/percy)'
+  
+  Config = Struct.new(:server, :port, :password, :nick, :username, :verbose, :logging, :reconnect, :reconnect_interval)
+  
+  @config = Config.new("localhost", 6667, nil, 'Percy', 'Percy', true, false, false, 30)
+  
+  # helper variables for getting server return values
+  @observers = 0
+  @temp_socket = []
+  
+  @connected = false
+  
+  # user methods
+  @on_channel    = []
+  @on_query      = []
+  @on_connect    = []
+  @on_join       = []
+  @on_part       = []
+  @on_quit       = []
+  @on_nickchange = []
+  @on_kick       = []
+  
+  # observer synchronizer
+  @mutex_observer = Mutex.new
+  
+  def self.configure(&block)
     block.call(@config)
     
     # logger
@@ -45,32 +75,84 @@ class Percy
     @error_logger = PercyLogger.new("#{PERCY_ROOT}/logs/error.log") if @config.logging
   end
   
-  # raw irc messages
-  def raw(msg)
-    @socket.puts "#{msg}\r\n"
-    @traffic_logger.info(">> #{msg}") if @traffic_logger
-    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} >> #{msg}" if @config.verbose
+  # raw IRC messages
+  def self.raw(message)
+    @connection.send_data "#{message}\r\n"
+    @traffic_logger.info(">> #{message}") if @traffic_logg
+    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} >> #{message}" if @config.verbose
   end
   
   # send a message
-  def message(recipient, msg)
-    raw "PRIVMSG #{recipient} :#{msg}"
+  def self.message(recipient, message)
+    self.raw "PRIVMSG #{recipient} :#{message}"
   end
   
   # send a notice
-  def notice(recipient, msg)
-    raw "NOTICE #{recipient} :#{msg}"
+  def self.notice(recipient, message)
+    self.raw "NOTICE #{recipient} :#{message}"
   end
   
   # set a mode
-  def mode(recipient, option)
-    raw "MODE #{recipient} #{option}"
+  def self.mode(recipient, option)
+    self.raw "MODE #{recipient} #{option}"
+  end
+  
+  # kick a user
+  def self.kick(channel, user, reason)
+    if reason
+      self.raw "KICK #{channel} #{user} :#{reason}"
+    else
+      self.raw "KICK #{channel} #{user}"
+    end
+  end
+  
+  # perform an action
+  def self.action(recipient, message)
+    self.raw "PRIVMSG #{recipient} :\001ACTION #{message}\001"
+  end
+  
+  # set a topic
+  def self.topic(channel, topic)
+    self.raw "TOPIC #{channel} :#{topic}"
+  end
+  
+  # joining a channel
+  def self.join(channel, password = nil)
+    if password
+      self.raw "JOIN #{channel} #{password}"
+    else
+      self.raw "JOIN #{channel}"
+    end
+  end
+  
+  # parting a channel
+  def self.part(channel, message)
+    if msg
+      self.raw "PART #{channel} :#{message}"
+    else
+      self.raw 'PART'
+    end
+  end
+  
+  # quitting
+  def self.quit(message = nil)
+    if message
+      self.raw "QUIT :#{message}"
+    else
+      self.raw 'QUIT'
+    end
+    
+    @config.reconnect = false # so Percy does not reconnect after the socket has been closed
+  end
+  
+  def self.nick
+    @config.nick
   end
   
   # returns all users on a specific channel
-  def users_on(channel)
-    add_observer
-    raw "NAMES #{channel}"
+  def self.users_on(channel)
+    self.add_observer
+    self.raw "NAMES #{channel}"
     
     begin
       Timeout::timeout(10) do # try 10 seconds to retrieve the users of <channel>
@@ -92,14 +174,14 @@ class Percy
     rescue Timeout::Error
       return false
     ensure
-      remove_observer
+      self.remove_observer
     end
   end
   
   # get the channel limit of a channel
-  def channel_limit(channel)
-    add_observer
-    raw "MODE #{channel}"
+  def self.channel_limit(channel)
+    self.add_observer
+    self.raw "MODE #{channel}"
     
     begin
       Timeout::timeout(10) do # try 10 seconds to retrieve l mode of <channel>
@@ -121,14 +203,14 @@ class Percy
     rescue Timeout::Error
       return false
     ensure
-      remove_observer
+      self.remove_observer
     end
   end
   
   # check whether an user is online
-  def is_online(nick)
-    add_observer
-    raw "WHOIS #{nick}"
+  def self.is_online(nick)
+    self.add_observer
+    self.raw "WHOIS #{nick}"
     
     begin
       Timeout::timeout(10) do
@@ -152,60 +234,12 @@ class Percy
     rescue Timeout::Error
       return false
     ensure
-      remove_observer
-    end
-  end
-  
-  # kick a user
-  def kick(channel, user, reason)
-    if reason
-      raw "KICK #{channel} #{user} :#{reason}"
-    else
-      raw "KICK #{channel} #{user}"
-    end
-  end
-  
-  # perform an action
-  def action(recipient, msg)
-    raw "PRIVMSG #{recipient} :\001ACTION #{msg}\001"
-  end
-  
-  # set a topic
-  def topic(channel, topic)
-    raw "TOPIC #{channel} :#{topic}"
-  end
-  
-  # joining a channel
-  def join(channel, password = nil)
-    if password
-      raw "JOIN #{channel} #{password}"
-    else
-      raw "JOIN #{channel}"
+      self.remove_observer
     end
   end
   
-  # parting a channel
-  def part(channel, msg)
-    if msg
-      raw "PART #{channel} :#{msg}"
-    else
-      raw 'PART'
-    end
-  end
-  
-  # quitting
-  def quit(msg = nil)
-    if msg
-      raw "QUIT :#{msg}"
-    else
-      raw 'QUIT'
-    end
-    
-    @running = false # so Percy does not reconnect after the socket has been closed
-  end
-  
   # on method
-  def on(type = :channel, match = //, &block)
+  def self.on(type = :channel, match = //, &block)
     case type
       when :channel
         @on_channel << {:match => match, :proc => block}
@@ -227,22 +261,22 @@ class Percy
   end
   
   # add observer
-  def add_observer
-    @mutex.synchronize do
+  def self.add_observer
+    @mutex_observer.synchronize do
       @observers += 1
     end
   end
   
   # remove observer
-  def remove_observer
-    @mutex.synchronize do
+  def self.remove_observer
+    @mutex_observer.synchronize do
       @observers -= 1 # remove observer
       @temp_socket = [] if @observers == 0 # clear @temp_socket if no observers are active
     end
   end
   
-  # parses incoming traffic
-  def parse(type, env = nil)
+  # parses incoming traffic (types)
+  def self.parse_type(type, env = nil)
     case type
     when :connect
       @on_connect.each do |block|
@@ -284,17 +318,17 @@ class Percy
     when :query
       # version respones
       if env[:message] == "\001VERSION\001"
-        notice env[:nick], "\001VERSION #{VERSION}\001"
+        self.notice env[:nick], "\001VERSION #{VERSION}\001"
       end
       
       # time response
       if env[:message] == "\001TIME\001"
-        notice env[:nick], "\001TIME #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}\001"
+        self.notice env[:nick], "\001TIME #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}\001"
       end
       
       # ping response
       if env[:message] =~ /\001PING (\d+)\001/
-        notice env[:nick], "\001PING #{$1}\001"
+        self.notice env[:nick], "\001PING #{$1}\001"
       end
       
       @on_query.each do |method|
@@ -396,77 +430,52 @@ class Percy
     end
   end
   
-  def nick
-    @config.nick
+  # connect!
+  def self.connect
+    @traffic_logger.info('-- Starting Percy') if @traffic_logger
+    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Starting Percy"
+    
+    EventMachine::run do
+      @connection = EventMachine::connect(@config.server, @config.port, Connection)
+    end
   end
   
-  # connect!
-  def connect
-    begin
-      while @running
-        @traffic_logger.info('-- Starting Percy') if @traffic_logger
-        puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Starting Percy"
-        
-        
-        @socket = TCPSocket.open(@config.server, @config.port)
-        raw "PASS #{@config.password}" if @config.password
-        raw "NICK #{@config.nick}"
-        raw "USER #{@config.nick} 0 * :#{@config.username}"
-        
-        while line = @socket.gets
-          @traffic_logger.info("<< #{line.chomp}") if @traffic_logger
-          puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} << #{line.chomp}" if @config.verbose
-          
-          case line.chomp
-          when /^PING \S+$/
-            raw line.chomp.gsub('PING', 'PONG')
-          
-          when /^:\S+ 376|422/
-            parse(:connect)
-          
-          when /^:(\S+)!(\S+)@(\S+) PRIVMSG #(\S+) :/
-            parse(:channel, :nick => $1, :user => $2, :host => $3, :channel => "##{$4}", :message => $')
-          
-          when /^:(\S+)!(\S+)@(\S+) PRIVMSG \S+ :/
-            parse(:query, :nick => $1, :user => $2, :host => $3, :message => $')
-          
-          when /^:(\S+)!(\S+)@(\S+) JOIN :*(\S+)$/
-            parse(:join, :nick => $1, :user => $2, :host => $3, :channel => $4)
-          
-          when /^:(\S+)!(\S+)@(\S+) PART (\S+)/
-            parse(:part, :nick => $1, :user => $2, :host => $3, :channel => $4, :message => $'.sub(' :', ''))
-          
-          when /^:(\S+)!(\S+)@(\S+) QUIT/
-            parse(:quit, :nick => $1, :user => $2, :host => $3, :message => $'.sub(' :', ''))
-          
-          when /^:(\S+)!(\S+)@(\S+) NICK :/
-            parse(:nickchange, :nick => $1, :user => $2, :host => $3, :new_nick => $')
-          
-          when /^:(\S+)!(\S+)@(\S+) KICK (\S+) (\S+) :/
-            parse(:kick, :nick => $1, :user => $2, :host => $3, :channel => $4, :victim => $5, :reason => $')
-          end
-          
-          if @observers > 0
-            @temp_socket << line.chomp
-          end
-        end
-        
-        @traffic_logger.info('-- Percy disconnected') if @traffic_logger
-        puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Percy disconnected"
-        @connected = false
-      end
-    rescue => e
-      @error_logger.error(e.message)
-      e.backtrace.each do |line|
-        @error_logger.error(line)
-      end
-      
-      @traffic_logger.info('-- Percy disconnected') if @traffic_logger
-      puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} -- Percy disconnected"
-      @connected = false
-    ensure
-      @traffic_logger.file.close if @traffic_logger
-      @error_logger.file.close if @error_logger
+  # parsing incoming traffic
+  def self.parse(message)
+    @traffic_logger.info("<< #{message.chomp}") if @traffic_logger
+    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} << #{message.chomp}" if @config.verbose
+    
+    case message.chomp
+    when /^PING \S+$/
+      self.raw message.chomp.gsub('PING', 'PONG')
+    
+    when /^:\S+ 376|422/
+      self.parse_type(:connect)
+    
+    when /^:(\S+)!(\S+)@(\S+) PRIVMSG #(\S+) :/
+      self.parse_type(:channel, :nick => $1, :user => $2, :host => $3, :channel => "##{$4}", :message => $')
+    
+    when /^:(\S+)!(\S+)@(\S+) PRIVMSG \S+ :/
+      self.parse_type(:query, :nick => $1, :user => $2, :host => $3, :message => $')
+    
+    when /^:(\S+)!(\S+)@(\S+) JOIN :*(\S+)$/
+      self.parse_type(:join, :nick => $1, :user => $2, :host => $3, :channel => $4)
+    
+    when /^:(\S+)!(\S+)@(\S+) PART (\S+)/
+      self.parse_type(:part, :nick => $1, :user => $2, :host => $3, :channel => $4, :message => $'.sub(' :', ''))
+    
+    when /^:(\S+)!(\S+)@(\S+) QUIT/
+      self.parse_type(:quit, :nick => $1, :user => $2, :host => $3, :message => $'.sub(' :', ''))
+    
+    when /^:(\S+)!(\S+)@(\S+) NICK :/
+      self.parse_type(:nickchange, :nick => $1, :user => $2, :host => $3, :new_nick => $')
+    
+    when /^:(\S+)!(\S+)@(\S+) KICK (\S+) (\S+) :/
+      self.parse_type(:kick, :nick => $1, :user => $2, :host => $3, :channel => $4, :victim => $5, :reason => $')
+    end
+    
+    if @observers > 0
+      @temp_socket << message.chomp
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: percy
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - "Tobias B\xC3\xBChlmann"
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 +01:00
+date: 2009-12-21 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.10
+    version: 
 description: Percy is an IRC bot framework inspired by isaac with various changes.
 email: tobias.buehlmann@gmx.de
 executables: []