vetinari 0.0.1

data/lib/vetinari/irc.rb

@@ -0,0 +1,42 @@
+module Vetinari
+  module IRC
+    def register
+      raw "PASS #{@config.password}" if @config.password
+      raw "NICK #{@config.nick}"
+      raw "USER #{@config.username} * * :#{@config.real_name}"
+    end
+
+    def rename(nick)
+      raw "NICK :#{nick}"
+    end
+
+    def away(message = nil)
+      if message
+        raw "AWAY :#{message}"
+      else
+        raw "AWAY"
+      end
+    end
+
+    def back
+      away
+    end
+
+    def quit(message = nil)
+      @quitted = true
+
+      if message
+        raw "QUIT :#{message}"
+      else
+        raw 'QUIT'
+      end
+    end
+
+    def join(channel_name, key = nil)
+      unless @channels.has_channel?(channel_name)
+        channel = Channel.new(channel_name, @actor)
+        channel.join key
+      end
+    end
+  end
+end

data/lib/vetinari/isupport.rb

@@ -0,0 +1,175 @@
+module Vetinari
+  class ISupport < Hash
+    def initialize
+      super
+
+      # Defaults:
+      self['CASEMAPPING'] = 'rfc1459'
+      self['CHANLIMIT'] = {}
+      self['CHANMODES'] = {
+        'A' => ['b'],
+        'B' => ['k'],
+        'C' => ['l'],
+        'D' => %w(i m n p s t r)
+      }
+      self['CHANNELLEN'] = 200
+      self['CHANTYPES'] = ['#', '&']
+      self['EXCEPTS'] = false
+      self['IDCHAN'] = {}
+      self['INVEX'] = false
+      self['KICKLEN'] = Float::INFINITY
+      self['MAXLIST'] = {}
+      self['MODES'] = 3
+      self['NETWORK'] = ''
+      self['NICKLEN'] = Float::INFINITY
+      self['PREFIX'] = {'o' => '@', 'v' => '+'}
+      self['SAFELIST'] = false
+      self['STATUSMSG'] = false
+      self['STD'] = false
+      self['TARGMAX'] = {}
+      self['TOPICLEN'] = Float::INFINITY
+    end
+
+    def parse(message)
+      patterns = message.split(' ')
+      patterns.delete_at(0)
+      patterns.each do |pattern|
+        return self if pattern.start_with?(':')
+        key = pattern.scan(/\w+/).first
+        method_name = "set_#{key.downcase}"
+        begin
+          if respond_to?(method_name, true)
+            send method_name, pattern
+          else
+            set_different key, pattern
+          end
+        rescue
+        end
+      end
+    end
+
+    private
+
+    def set_casemapping(pattern)
+      self['CASEMAPPING'] = pattern.split('=')[1]
+    end
+
+    def set_chanlimit(pattern)
+      value = pattern.split('=')[1]
+      value.split(',').each do |prefixes_and_limit|
+        prefixes, limit = prefixes_and_limit.split(':')
+        limit = limit.nil? ? Float::INFINITY : limit.to_i
+        prefixes.split('').each do |prefix|
+          self['CHANLIMIT'][prefix] = limit
+        end
+      end
+    end
+
+    def set_chanmodes(pattern)
+      value = pattern.split('=')[1]
+      modes_per_type = value.split(',').map { |modes| modes.split('') }
+      ('A'..'D').each_with_index do |type, index|
+        self['CHANMODES'][type] = modes_per_type[index]
+      end
+    end
+
+    def set_channellen(pattern)
+      self['CHANNELLEN'] = pattern.split('=')[1].to_i
+    end
+
+    def set_chantypes(pattern)
+      self['CHANTYPES'] = pattern.split('=')[1].split('')
+    end
+
+    def set_excepts(pattern)
+      mode_char = pattern.split('=')[1]
+      self['EXCEPTS'] = mode_char.nil? ? true : mode_char
+    end
+
+    def set_idchan(pattern)
+      value = pattern.split('=')[1]
+      value.split(',').each do |prefix_and_number|
+        prefix, number = prefix_and_number.split(':')
+        self['IDCHAN'][prefix] = number.to_i
+      end
+    end
+
+    def set_invex(pattern)
+      mode_char = pattern.split('=')[1]
+      self['INVEX'] = mode_char.nil? ? true : mode_char
+    end
+
+    def set_kicklen(pattern)
+      self['KICKLEN'] = pattern.split('=')[1].to_i
+    end
+
+    def set_maxlist(pattern)
+      value = pattern.split('=')[1]
+      value.split(',').each do |prefixes_and_maximum|
+        prefixes, maximum = prefixes_and_maximum.split(':')
+        prefixes.split('').each do |prefix|
+          self['MAXLIST'][prefix] = maximum.to_i
+        end
+      end
+    end
+
+    def set_modes(pattern)
+      mode_char = pattern.split('=')[1]
+      self['MODES'] = mode_char.nil? ? Float::INFINITY : mode_char.to_i
+    end
+
+    def set_network(pattern)
+      self['NETWORK'] = pattern.split('=')[1]
+    end
+
+    def set_nicklen(pattern)
+      self['NICKLEN'] = pattern.split('=')[1].to_i
+    end
+
+    def set_prefix(pattern)
+      modes, prefixes = pattern.scan(/\((.+)\)(.+)/).flatten
+      modes = modes.split('')
+      prefixes = prefixes.split('')
+      modes.zip(prefixes).each do |pair|
+        self['PREFIX'][pair.first] = pair.last
+      end
+    end
+
+    def set_safelist(pattern)
+      self['SAFELIST'] = true
+    end
+
+    def set_statusmsg(pattern)
+      self['STATUSMSG'] = pattern.split('=')[1].split('')
+    end
+
+    def set_std(pattern)
+      self['STD'] = pattern.split('=')[1].split(',')
+    end
+
+    def set_targmax(pattern)
+      targets = pattern.split('=')[1].split(',')
+      targets.each do |target_with_maximum|
+        target, maximum = target_with_maximum.split(':')
+        maximum = maximum.nil? ? Float::INFINITY : maximum.to_i
+        self['TARGMAX'][target] = maximum
+      end
+    end
+
+    def set_topiclen(pattern)
+      self['TOPICLEN'] = pattern.split('=')[1].to_i
+    end
+
+    def set_different(key, pattern)
+      if pattern.include? '='
+        if pattern.include? ','
+          self[key] = pattern.split('=')[1].split(',')
+        else
+          self[key] = pattern.split('=')[1]
+        end
+      else
+        self[key] = true
+      end
+    end
+  end
+end

data/lib/vetinari/logging/logger.rb

@@ -0,0 +1,13 @@
+module Vetinari
+  module Logging
+    class Logger < ::Logger
+      def initialize(*args)
+        super(*args)
+        
+        self.formatter = proc do |severity, datetime, progname, msg|
+          "#{severity} #{datetime.strftime('%Y-%m-%d %H:%M:%S')} #{msg}\n"
+        end
+      end
+    end
+  end
+end

data/lib/vetinari/logging/logger_list.rb

@@ -0,0 +1,19 @@
+module Vetinari
+  module Logging
+    class LoggerList < Array
+      %w(debug info warn error fatal unknown).each do |method_name|
+        define_method(method_name) do |*args, &block|
+          each do |logger|
+            logger.send(method_name, *args, &block)
+          end
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        each do |logger|
+          logger.send(method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/vetinari/logging/null_logger.rb

@@ -0,0 +1,9 @@
+module Vetinari
+  module Logging
+    class NullLogger
+      %w(debug info warn error fatal unknown method_missing).each do |method_name|
+        define_method(method_name) { |*args, &block| }
+      end
+    end
+  end
+end

data/lib/vetinari/message_parser.rb

@@ -0,0 +1,35 @@
+module Vetinari
+  module MessageParser
+    def parse(message, chantypes)
+      chantypes = chantypes.map { |c| Regexp.escape(c) }.join('|')
+
+      case message
+        # :kornbluth.freenode.net 001 Vetinari5824 :Welcome to the freenode Internet Relay Chat Network Vetinari5824
+      when /^(?:\:\S+ )?(\d\d\d) /
+        number = $1.to_i
+        {:type => number, :params => $'}
+      when /^:(\S+)!(\S+)@(\S+) PRIVMSG ((?:#{chantypes})\S+) :/
+        {:type => :channel, :nick => $1, :user => $2, :host => $3, :channel => $4, :message => $'}
+      when /^:(\S+)!(\S+)@(\S+) PRIVMSG \S+ :/
+        {:type => :query, :nick => $1, :user => $2, :host => $3, :message => $'}
+      when /^:(\S+)!(\S+)@(\S+) JOIN :*(\S+)$/
+        {:type => :join, :nick => $1, :user => $2, :host => $3, :channel => $4}
+      when /^:(\S+)!(\S+)@(\S+) PART (\S+)/
+        {:type => :part, :nick => $1, :user => $2, :host => $3, :channel => $4, :message => $'.sub(/ :/, '')}
+      when /^:(\S+)!(\S+)@(\S+) QUIT/
+        {:type => :quit, :nick => $1, :user => $2, :host => $3, :message => $'.sub(/ :/, '')}
+      when /^:(\S+)!(\S+)@(\S+) MODE ((?:#{chantypes})\S+) ([+-]\S+)/
+        {:type => :channel_mode, :nick => $1, :user => $2, :host => $3, :channel => $4, :modes => $5, :params => $'.lstrip}
+      when /^:(\S+)!(\S+)@(\S+) NICK :/
+        {:type => :nickchange, :nick => $1, :user => $2, :host => $3, :new_nick => $'}
+      when /^:(\S+)!(\S+)@(\S+) KICK (\S+) (\S+) :/
+        {:type => :kick, :nick => $1, :user => $2, :host => $3, :channel => $4, :kickee => $5, :message => $'}
+      when /^:(\S+)!(\S+)@(\S+) TOPIC (\S+) :/
+        {:type => :topic, :nick => $1, :user => $2, :host => $3, :channel => $4, :topic => $'}
+      else
+        {}
+      end
+    end
+    module_function :parse
+  end
+end

data/lib/vetinari/mode_parser.rb

@@ -0,0 +1,46 @@
+module Vetinari
+  module ModeParser
+    def parse(modes, params, isupport)
+      modes = modes.split(//)
+      direction = modes.shift.to_sym
+      unless [:'+', :'-'].include?(direction)
+        raise(ArgumentError, "Direction for modes argument not given. +/- needed, got: #{direction}.")
+      end
+      params = params.split(/ /) if params.is_a?(String)
+      mode_changes = []
+
+      modes.each do |mode|
+        if needs_a_param?(mode, direction, isupport)
+          param = params.shift
+
+          if param
+            mode_change = {
+              :direction => direction,
+              :mode => mode,
+              :param => param
+            }
+            mode_changes << mode_change
+          end
+        else
+          mode_change = {
+            :direction => direction,
+            :mode => mode
+          }
+          mode_changes << mode_change
+        end
+      end
+
+      mode_changes
+    end
+    module_function :parse
+
+    def needs_a_param?(mode, direction, isupport)
+      modes = isupport['CHANMODES']['A'] +
+        isupport['CHANMODES']['B'] +
+        isupport['PREFIX'].keys
+      modes.concat(isupport['CHANMODES']['C']) if direction == :'+'
+      modes.include?(mode)
+    end
+    module_function :needs_a_param?
+  end
+end

data/lib/vetinari/user.rb

@@ -0,0 +1,104 @@
+module Vetinari
+  # TODO: Actor?
+  class User
+    attr_reader :nick, :user, :host, :online, :observed
+    
+    def initialize(nick, bot)
+      @bot = bot
+
+      @nick = nick
+      @user = nil
+      @host = nil
+      
+      @online   = nil
+      @observed = false
+
+      @channels = Set.new
+      @channels_with_modes = {}
+    end
+
+    # Updates the properties of an user.
+    # def whois
+    #   connected do
+    #     fiber = Fiber.current
+    #     callbacks = {}
+
+    #     # User is online.
+    #     callbacks[311] = @thaum.on(311) do |event_data|
+    #       nick = event_data[:params].split(' ')[1]
+    #       if nick.downcase == @nick.downcase
+    #         @online = true
+    #         # TODO: Add properties.
+    #       end
+    #     end
+
+    #     # User is not online.
+    #     callbacks[401] = @thaum.on(401) do |event_data|
+    #       nick = event_data[:params].split(' ')[1]
+    #       if nick.downcase == @nick.downcase
+    #         @online = false
+    #         fiber.resume
+    #       end
+    #     end
+
+    #     # End of WHOIS.
+    #     callbacks[318] = @thaum.on(318) do |event_data|
+    #       nick = event_data[:params].split(' ')[1]
+    #       if nick.downcase == @nick.downcase
+    #         fiber.resume
+    #       end
+    #     end
+
+    #     raw "WHOIS #{@nick}"
+    #     Fiber.yield
+
+    #     callbacks.each do |type, callback|
+    #       @thaum.callbacks[type].delete(callback)
+    #     end
+    #   end
+
+    #   self
+    # end
+
+    def online?
+      if @bot.users[@nick]
+        @online = true
+      else
+        # TODO
+        # whois if @online.nil?
+        # @online
+      end
+    end
+
+    def bot?
+      self == @bot.user
+    end
+
+    def dcc_send(filepath, filename = nil)
+      if @bot.server_manager
+        if File.exist?(filepath)
+          filename = File.basename(filepath) unless filename
+          @bot.server_manager.add_offering(self, filepath, filename)
+        else
+          raise "File '#{filepath}' does not exist."
+        end
+      else
+        raise 'DCC not available: Missing external IP or ports'
+      end
+    end
+
+    # TODO: ping, version, time methods?
+
+    def message(message)
+      @bot.raw "PRIVMSG #{@nick} :#{message}"
+    end
+
+    def notice(message)
+      @bot.raw "NOTICE #{@nick} :#{message}"
+    end
+
+    def inspect
+      "#<User nick=#{@nick}>"
+    end
+  end
+end

data/lib/vetinari/user_container.rb

@@ -0,0 +1,52 @@
+module Vetinari
+  # The UserList class holds information about users a Thaum is able to see
+  # in channels.
+  class UserContainer
+    include Celluloid
+
+    attr_reader :users
+
+    exclusive
+
+    def initialize
+      @users = Set.new
+    end
+
+    def add(user)
+      @users << user
+    end
+
+    # TODO
+    def remove(user)
+      @users.delete(user)
+    end
+
+    # Find a User given the nick.
+    def [](user_or_nick)
+      case user_or_nick
+      when User
+        user_or_nick if @users.include?(user_or_nick)
+      when String
+        @users.find do |u|
+          u.nick.downcase == user_or_nick.downcase
+        end
+      end
+    end
+
+    def has_user?(user)
+      self[user] ? true : false
+    end
+
+    def clear
+      @users.clear
+    end
+
+    # Removes all users from the UserContainer that don't share channels with
+    # the Bot.
+    def kill_zombie_users(users)
+      (@users - users).each do |user|
+        @users.delete(user) unless user.bot?
+      end
+    end
+  end
+end

data/lib/vetinari/version.rb

@@ -0,0 +1,3 @@
+module Vetinari
+  VERSION = Gem::Version.new('0.0.1')
+end

data/lib/vetinari.rb

@@ -0,0 +1,38 @@
+require 'ipaddr'
+require 'logger'
+require 'ostruct'
+require 'thread'
+
+require 'celluloid/autostart'
+require 'celluloid/io'
+
+module Vetinari
+  require 'vetinari/irc'
+  require 'vetinari/bot'
+  require 'vetinari/callback'
+  require 'vetinari/callback_container'
+  require 'vetinari/channel'
+  require 'vetinari/channel_container'
+  require 'vetinari/configuration'
+  require 'vetinari/isupport'
+  require 'vetinari/message_parser'
+  require 'vetinari/mode_parser'
+  require 'vetinari/user'
+  require 'vetinari/user_container'
+  require 'vetinari/version'
+
+  module Dcc
+    require 'vetinari/dcc/server_manager'
+    require 'vetinari/dcc/server'
+
+    module Incoming
+      require 'vetinari/dcc/incoming/file'
+    end
+  end
+
+  module Logging
+    require 'vetinari/logging/logger'
+    require 'vetinari/logging/logger_list'
+    require 'vetinari/logging/null_logger'
+  end
+end

data/spec/callback_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Callback' do
+  subject { Vetinari::Bot.new { |c| c.verbose = false } }
+  let(:callbacks) { subject.callbacks.instance_variable_get('@callbacks') }
+
+  it 'is added correctly' do
+    expect(callbacks[:channel]).to have(1).callback
+    subject.on(:channel)
+    expect(callbacks[:channel]).to have(2).callbacks
+  end
+
+  it 'can be removed' do
+    cb = subject.on(:channel)
+    expect(callbacks[:channel]).to have(2).callback
+    cb.remove
+    expect(callbacks[:channel]).to have(1).callback
+  end
+end

data/spec/channel_management_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Channel Management' do
+  subject { Vetinari::Bot.new { |c| c.verbose = false } }
+
+  before(:each) do
+    subject.parse(':server 001 Vetinari :Welcome message')
+    subject.parse(':server 376 Vetinari :End of /MOTD command.')
+  end
+
+  it 'adds a channel to the channel_list when joining a channel' do
+    expect(subject.channels.channels).to be_empty
+    subject.parse(':Vetinari!foo@bar JOIN #mended_drum')
+    expect(subject.channels.channels).to have(1).channel
+    expect(subject.channels.channels.first.name).to eq('#mended_drum')
+  end
+
+  it 'removes a channel from the channel_list when leaving a channel' do
+    subject.parse(':Vetinari!foo@bar JOIN #mended_drum')
+    expect(subject.channels.channels).to have(1).channel
+    subject.parse(':Vetinari!foo@bar PART #mended_drum')
+    expect(subject.channels.channels).to be_empty
+  end
+
+  it 'removes a channel from the channel_list when being kicked from a channel' do
+    subject.parse(':Vetinari!foo@bar JOIN #mended_drum')
+    expect(subject.channels.channels).to have(1).channel
+    subject.parse(':TheLibrarian!foo@bar KICK #mended_drum Vetinari :No humans allowed!')
+    expect(subject.channels.channels).to be_empty
+  end
+
+  it 'removes all channels from the channel_list when quitting' do
+    subject.parse(':Vetinari!foo@bar JOIN #mended_drum')
+    subject.parse(':Vetinari!foo@bar JOIN #library')
+    expect(subject.channels.channels).to have(2).channels
+    subject.parse(':Vetinari!foo@bar QUIT :Bye mates!')
+    expect(subject.channels.channels).to be_empty
+  end
+end

data/spec/default_callbacks_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Vetinari::Bot do
+  subject { Vetinari::Bot.new { |c| c.verbose = false } }
+  let(:bare) { subject.bare_object }
+
+  before(:each) do
+    subject.parse(':server 001 Vetinari :Welcome message')
+    subject.parse(':server 376 Vetinari :End of /MOTD command.')
+  end
+
+  it 'PING PONGs (server)' do
+    bare.should_receive(:raw).with("PONG :server", false)
+    subject.parse("PING :server")
+  end
+
+  it 'PING PONGs (user)' do
+    time = Time.now.to_i
+    bare.should_receive(:raw).with("NOTICE nick :\001PING #{time}\001")
+    subject.parse(":nick!user@host PRIVMSG Vetinari :\001PING #{time}\001")
+  end
+
+  it 'responses to VERSION request' do
+    bare.should_receive(:raw).with("NOTICE nick :\001VERSION Vetinari #{Vetinari::VERSION} (https://github.com/tbuehlmann/vetinari)")
+    subject.parse(":nick!user@host PRIVMSG Vetinari :\001VERSION\001")
+  end
+
+  it 'responses to TIME request' do
+    bare.should_receive(:raw).with("NOTICE nick :\001TIME #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}\001")
+    subject.parse(":nick!user@host PRIVMSG Vetinari :\001TIME\001")
+  end
+
+  describe 'rejoin channel after kick' do
+    let(:channel) { subject.channels['#mended_drum'] }
+
+    before(:each) do
+      subject.config.rejoin_after_kick = true
+      subject.parse(':Vetinari!foo@bar JOIN #mended_drum')
+      subject.parse(':TheLibrarian!foo@bar JOIN #mended_drum')
+    end
+
+    it 'without a channel key' do
+      channel.should_receive(:join)
+      subject.parse(':TheLibrarian!foo@bar KICK #mended_drum Vetinari :foo')
+    end
+
+    it 'with a channel key' do
+      channel.should_receive(:join).with('thaum')
+      subject.parse(':Vetinari!foo@bar MODE #mended_drum +k thaum')
+      subject.parse(':TheLibrarian!foo@bar KICK #mended_drum Vetinari :foo')
+    end
+  end
+end