percy 1.3.0 → 1.4.0

data/lib/percy.rb

@@ -1,556 +1,21 @@
-require 'rubygems'
 require 'pathname'
 $:.unshift Pathname.new(__FILE__).dirname.expand_path
-require 'eventmachine'
-require 'ostruct'
-require 'timeout'
-require 'thread'
-autoload :PercyLogger, 'percylogger'
-
+require 'percy/irc'
+require 'percy/formatting'
 Thread.abort_on_exception = true
 
-class Connection < EventMachine::Connection
-  include EventMachine::Protocols::LineText2
-  
-  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 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
-    else
-      EventMachine::stop_event_loop
-    end
-  end
-  
-  def receive_line(line)
-    Percy.parse line
-  end
-end
-
-class Percy
-  class << self
-    attr_reader :config
-    attr_accessor :traffic_logger, :connected
-  end
-  
-  VERSION = 'Percy 1.3.0 (http://github.com/tbuehlmann/percy)'
-  
-  @config = OpenStruct.new({:server             => 'localhost',
-                            :port               => 6667,
-                            :nick               => 'Percy',
-                            :username           => 'Percy',
-                            :verbose            => true,
-                            :logging            => false,
-                            :reconnect          => true,
-                            :reconnect_interval => 30})
-  
-  # helper variables for getting server return values
-  @observers = 0
-  @temp_socket = []
-  
-  @connected = false
-  
-  # user methods
-  @events = Hash.new []
-  @listened_types = [:connect, :channel, :query, :join, :part, :quit, :nickchange, :kick] # + 3-digit numbers
-  
-  # observer synchronizer
-  @mutex_observer = Mutex.new
-  
-  def self.configure(&block)
-    block.call(@config)
-    
-    # set the percy root directory
-    Object::const_set(:PERCY_ROOT, Pathname.new($0).dirname.expand_path)
-    
-    # logger
-    if @config.logging
-      @traffic_logger = PercyLogger.new(Pathname.new(PERCY_ROOT).join('logs'), 'traffic.log')
-      @error_logger   = PercyLogger.new(Pathname.new(PERCY_ROOT).join('logs'), 'error.log')
-    end
-  end
-  
-  # raw IRC messages
-  def self.raw(message)
-    @connection.send_data "#{message}\r\n"
-    @traffic_logger.info(">> #{message}") if @traffic_logger
-    puts "#{Time.now.strftime('%d.%m.%Y %H:%M:%S')} >> #{message}" if @config.verbose
-  end
-  
-  # send a message
-  def self.message(recipient, message)
-    self.raw "PRIVMSG #{recipient} :#{message}"
-  end
-  
-  # send a notice
-  def self.notice(recipient, message)
-    self.raw "NOTICE #{recipient} :#{message}"
-  end
-  
-  # set a mode
-  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
+module Percy
+  VERSION = 'Percy 1.4.0 (http://github.com/tbuehlmann/percy)'
   
-  def self.nick
-    @config.nick
-  end
-  
-  # returns all users on a specific channel as array: ['Foo', 'bar', 'The_Librarian']
-  def self.users_on(channel)
-    actual_length = self.add_observer
-    self.raw "NAMES #{channel}"
-    channel = Regexp.escape(channel)
-    
-    begin
-      Timeout::timeout(30) do # try 30 seconds to retrieve the users of <channel>
-        start = actual_length
-        ending = @temp_socket.length
-        users = []
-        
-        loop do
-          for line in start..ending do
-            case @temp_socket[line]
-            when /^:\S+ 353 .+ #{channel} :/i
-              users << $'.split(' ')
-            when /^:\S+ 366 .+ #{channel}/i
-              return users.flatten.uniq.map { |element| element.gsub(/[!@%+]/, '') } # removing all modes
-            end
-          end
-          
-          sleep 0.25
-          start = ending
-          ending = @temp_socket.length
-        end
-      end
-    rescue Timeout::Error
-      return []
-    ensure
-      self.remove_observer
-    end
-  end
-  
-  # returns all users on a specific channel as array (with status): ['@Foo', '+bar', 'The_Librarian', '!Frank']
-  def self.users_with_status_on(channel)
-    actual_length = self.add_observer
-    self.raw "NAMES #{channel}"
-    channel = Regexp.escape(channel)
-    
-    begin
-      Timeout::timeout(30) do # try 30 seconds to retrieve the users of <channel>
-        start = actual_length
-        ending = @temp_socket.length
-        users = []
-        
-        loop do
-          for line in start..ending do
-            case @temp_socket[line]
-            when /^:\S+ 353 .+ #{channel} :/i
-              users << $'.split(' ')
-            when /^:\S+ 366 .+ #{channel}/i
-              return users.flatten.uniq
-            end
-          end
-          
-          sleep 0.25
-          start = ending
-          ending = @temp_socket.length
-        end
-      end
-    rescue Timeout::Error
-      return []
-    ensure
-      self.remove_observer
-    end
-  end
-  
-  # get the channel limit of a channel
-  def self.channel_limit(channel)
-    actual_length = self.add_observer
-    self.raw "MODE #{channel}"
-    
-    begin
-      Timeout::timeout(10) do # try 10 seconds to retrieve l mode of <channel>
-        start = actual_length
-        ending = @temp_socket.length
-        channel = Regexp.escape(channel)
-        
-        loop do
-          for line in start..ending do
-            if @temp_socket[line] =~ /^:\S+ 324 \S+ #{channel} .*l.* (\d+)/
-              return $1.to_i
-            end
-          end
-          
-          sleep 0.25
-          start = ending
-          ending = @temp_socket.length
-        end
-      end
-    rescue Timeout::Error
-      return false
-    ensure
-      self.remove_observer
-    end
-  end
-  
-  # check whether an user is online
-  def self.is_online(nick)
-    actual_length = self.add_observer
-    self.raw "WHOIS #{nick}"
-    
-    begin
-      Timeout::timeout(10) do
-        start = actual_length
-        ending = @temp_socket.length
-        nick = Regexp.escape(nick)
-        
-        loop do
-          for line in start..ending do
-            if @temp_socket[line] =~ /^:\S+ 311 \S+ (#{nick}) /i
-              return $1
-            elsif @temp_socket[line] =~ /^:\S+ 401 \S+ #{nick} /i
-              return false
-            end
-          end
-          
-          sleep 0.25
-          start = ending
-          ending = @temp_socket.length
-        end
-      end
-    rescue Timeout::Error
-      return false
-    ensure
-      self.remove_observer
-    end
-  end
-  
-  # on method
-  def self.on(type = :channel, match = //, &block)
-    unless @listened_types.include?(type) || type =~ /^\d\d\d$/
-      raise ArgumentError, "#{type} is not a supported type"
-    end
-    
-    @events[type] = [] if @events[type].empty? # @events' default value is [], but it's not possible to add elements to it (weird!)
-    case type
-    when :channel || :query
-      @events[type] << {:match => match, :proc => block}
-    else
-      @events[type] << block
-    end
-  end
-  
-  # 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
-  
-  private
-  
-  # add observer
-  def self.add_observer
-    @mutex_observer.synchronize do
-      @observers += 1
-    end
-    
-    return @temp_socket.length - 1 # so the loop knows where to begin to search for patterns
-  end
-  
-  # remove observer
-  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 (types)
-  def self.parse_type(type, env = nil)
-    case type
-    when /^\d\d\d$/
-      if @events[type]
-        @events[type].each do |block|
-          Thread.new do
-            begin
-              block.call(env)
-            rescue => e
-              if @error_logger
-                @error_logger.error(e.message)
-                e.backtrace.each do |line|
-                  @error_logger.error(line)
-                end
-              end
-            end
-          end
-        end
-      end
-      
-      # :connect
-      if type =~ /^376|422$/
-        @events[:connect].each do |block|
-          Thread.new do
-            begin
-              unless @connected
-                @connected = true
-                block.call
-              end
-            rescue => e
-              if @error_logger
-                @error_logger.error(e.message)
-                e.backtrace.each do |line|
-                  @error_logger.error(line)
-                end
-              end
-            end
-          end
-        end
-      end
-    
-    when :channel
-      @events[type].each do |method|
-        if env[:message] =~ method[:match]
-          Thread.new do
-            begin
-              method[:proc].call(env)
-            rescue => e
-              if @error_logger
-                @error_logger.error(e.message)
-                e.backtrace.each do |line|
-                  @error_logger.error(line)
-                end
-              end
-            end
-          end
-        end
-      end
-    
-    when :query
-      # version respones
-      if env[:message] == "\001VERSION\001"
-        self.notice env[:nick], "\001VERSION #{VERSION}\001"
-      end
-      
-      # time response
-      if env[:message] == "\001TIME\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/
-        self.notice env[:nick], "\001PING #{$1}\001"
-      end
-      
-      @events[type].each do |method|
-        if env[:message] =~ method[:match]
-          Thread.new do
-            begin
-              method[:proc].call(env)
-            rescue => e
-              if @error_logger
-                @error_logger.error(e.message)
-                e.backtrace.each do |line|
-                  @error_logger.error(line)
-                end
-              end
-            end
-          end
-        end
-      end
-    
-    when :join
-      @events[type].each do |block|
-        Thread.new do
-          begin
-            block.call(env)
-          rescue => e
-            if @error_logger
-              @error_logger.error(e.message)
-              e.backtrace.each do |line|
-                @error_logger.error(line)
-              end
-            end
-          end
-        end
-      end
-    
-    when :part
-      @events[type].each do |block|
-        Thread.new do
-          begin
-            block.call(env)
-          rescue => e
-            if @error_logger
-              @error_logger.error(e.message)
-              e.backtrace.each do |line|
-                @error_logger.error(line)
-              end
-            end
-          end
-        end
-      end
-    
-    when :quit
-      @events[type].each do |block|
-        Thread.new do
-          begin
-            block.call(env)
-          rescue => e
-            if @error_logger
-              @error_logger.error(e.message)
-              e.backtrace.each do |line|
-                @error_logger.error(line)
-              end
-            end
-          end
-        end
-      end
-    
-    when :nickchange
-      @events[type].each do |block|
-        Thread.new do
-          begin
-            block.call(env)
-          rescue => e
-            if @error_logger
-              @error_logger.error(e.message)
-              e.backtrace.each do |line|
-                @error_logger.error(line)
-              end
-            end
-          end
-        end
-      end
-    
-    when :kick
-      @events[type].each do |block|
-        Thread.new do
-          begin
-            block.call(env)
-          rescue => e
-            if @error_logger
-              @error_logger.error(e.message)
-              e.backtrace.each do |line|
-                @error_logger.error(line)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-  
-  # 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+ (\d\d\d) /
-      self.parse_type($1, :params => $')
-    
-    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
+  # set the percy root directory
+  Object::const_set(:PERCY_ROOT, Pathname.new($0).dirname.expand_path)
 end
 
 def delegate(*methods)
   methods.each do |method|
    eval <<-EOS
       def #{method}(*args, &block)
-        Percy.send(#{method.inspect}, *args, &block)
+        Percy::IRC.send(#{method.inspect}, *args, &block)
       end
     EOS
   end

data/percy.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name = 'percy'
-  s.version = '1.3.0'
+  s.version = '1.4.0'
   s.summary = '(DSL, EventMachine) IRC Bot Framework inspired by isaac'
   s.description = 'Percy is an IRC Bot framework inspired by isaac with various changes.'
   s.homepage = 'http://github.com/tbuehlmann/percy'
-  s.date = '04.03.2010'
+  s.date = '10.03.2010'
   
   s.author = 'Tobias Bühlmann'
   s.email = 'tobias.buehlmann@gmx.de'
@@ -16,7 +16,10 @@ Gem::Specification.new do |s|
              'examples/github_blog.rb',
              'examples/is_online_checker.rb',
              'lib/percy.rb',
-             'lib/percylogger.rb',
+             'lib/percy/connection.rb',
+             'lib/percy/formatting.rb',
+             'lib/percy/irc.rb',
+             'lib/percy/percylogger.rb',
              'percy.gemspec']
   
   s.has_rdoc = false

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 3
+  - 4
   - 0
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - "Tobias B\xC3\xBChlmann"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 +01:00
+date: 2010-03-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,7 +46,10 @@ files:
 - examples/github_blog.rb
 - examples/is_online_checker.rb
 - lib/percy.rb
-- lib/percylogger.rb
+- lib/percy/connection.rb
+- lib/percy/formatting.rb
+- lib/percy/irc.rb
+- lib/percy/percylogger.rb
 - percy.gemspec
 has_rdoc: true
 homepage: http://github.com/tbuehlmann/percy

data/lib/percylogger.rb

@@ -1,71 +0,0 @@
-class PercyLogger
-  require 'pathname'
-  require 'thread'
-  autoload :FileUtils, 'fileutils'
-  
-  DEBUG   = 0
-  INFO    = 1
-  WARN    = 2
-  ERROR   = 3
-  FATAL   = 4
-  UNKNOWN = 5
-  LEVEL   = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL', 'UNKNOWN']
-  
-  attr_accessor :level, :time_format, :file
-  
-  def initialize(dirpath = Pathname.new($0).dirname.expand_path.join('logs'), filename = 'log.log', level = DEBUG, time_format = '%d.%m.%Y %H:%M:%S')
-    @dirpath = dirpath
-    @pathname = dirpath.join(filename)
-    @level = level
-    @time_format = time_format
-    @mutex = Mutex.new
-    
-    unless @pathname.exist?
-      unless @dirpath.directory?
-        FileUtils.mkdir_p @dirpath
-      end
-      
-      File.new(@pathname, 'w+')
-    end
-    
-    @file = File.open(@pathname, 'a+')
-    @file.sync = true
-  end
-  
-  def write(severity, message)
-    begin
-      if severity >= @level
-        @mutex.synchronize do
-          @file.puts "#{LEVEL[severity]} #{Time.now.strftime(@time_format)} #{message}"
-        end
-      end
-    rescue => e
-      puts e.message
-      puts e.backtrace.join('\n')
-    end
-  end
-  
-  def debug(message)
-    write DEBUG, message
-  end
-  
-  def info(message)
-    write INFO, message
-  end
-  
-  def warn(message)
-    write WARN, message
-  end
-  
-  def error(message)
-    write ERROR, message
-  end
-  
-  def fatal(message)
-    write FATAL, message
-  end
-  
-  def unknown(message)
-    write UNKNOWN, message
-  end
-end