vetinari 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0000606629bd97c6e36412292b86220a9279472b
+  data.tar.gz: 5cb4790367bb5037fa4aecd97c6058a88ba56f39
+SHA512:
+  metadata.gz: a40248f184e7ee83ce0f6b8e12e806d5c71cf9b6f258f53c3dc774070bdf77ce02ced8ea274d241bf8adbab732cb3779b7b480dbdcc2a1080e7c98e219e21d85
+  data.tar.gz: 8989e04679431ca77300fb6195901a4c355e1a7047ec314b62cb14f8629afc011fecccb3d185eb0345dac6aaa9dda891129cc9b2bff39aaeb535e666b4ad696d

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tobias Bühlmann
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Vetinari
+Vetinari is a Domain Specific Language for writing IRC Bots using the [Celluloid::IO](https://github.com/celluloid/celluloid-io "Celluloid::IO") library.
+
+## Requirements
+- Ruby >= 1.9.2
+- Celluloid::IO ~> 0.14
+
+## Wiki
+Detailed information about using Vetinari can be found in the [Project Wiki](https://github.com/tbuehlmann/vetinari/wiki).
+
+## Quick Setup
+
+### Installation
+```sh
+$ gem install vetinari
+```
+
+### Usage
+```ruby
+require 'vetinari'
+
+bot = Vetinari::Bot.new do |config|
+  config.server = 'chat.freenode.org'
+  config.port   = 6667
+  config.nick   = 'Vetinari'
+end
+
+bot.on(:connect) do
+  bot.join '#vetinari'
+end
+
+bot.on(:channel, /foo/) do |env|
+  env[:channel].message('bar')
+end
+
+bot.connect
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+Copyright (c) 2013 Tobias Bühlmann
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/examples/echo_bot.rb

@@ -0,0 +1,24 @@
+lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir
+
+require 'vetinari'
+
+echo_bot = Vetinari::Bot.new do |config|
+  config.server = 'chat.freenode.org'
+  config.port   = 6667
+  config.nick   = "Vetinari#{rand(10_000)}"
+end
+
+echo_bot.on :connect do
+  echo_bot.join '#vetinari'
+end
+
+echo_bot.on :channel, /\Aquit!\z/ do |env|
+  echo_bot.quit
+end
+
+echo_bot.on :channel, //, 1 do |env|
+  env[:channel].message(env[:message])
+end
+
+echo_bot.connect

data/lib/vetinari/bot.rb

@@ -0,0 +1,358 @@
+module Vetinari
+  class Bot
+    include Celluloid::IO, IRC
+
+    attr_reader :config, :users, :user, :channels, :server_manager, :callbacks
+
+    def initialize(&block)
+      @actor     = Actor.current
+      @config    = Configuration.new(&block)
+      @callbacks = CallbackContainer.new(Actor.current)
+      @users     = UserContainer.new
+      @channels  = ChannelContainer.new
+      @socket    = nil
+      @connected = false
+      @user      = nil
+
+      setup_channel_and_user_tracking
+      setup_default_callbacks
+      setup_dcc
+    end
+
+    def on(event, pattern = //, worker = 0, &block)
+      @callbacks.add(event, pattern, worker, block)
+    end
+
+    exclusive :on
+    execute_block_on_receiver :on
+
+    def connect
+      @config.loggers.info '-- Starting Vetinari'
+      @socket = TCPSocket.open(@config.server, @config.port)
+      # port, ip = Socket.unpack_sockaddr_in(@socket.to_io.getpeername)
+      # @config.internal_port = port
+      # @config.internal_ip   = ip
+      register
+
+      while message = @socket.gets do
+        parse message
+      end
+
+      disconnected
+    end
+
+    def raw(message, logging = true)
+      if @socket
+        @socket.puts("#{message}\r\n")
+        @config.loggers.info ">> #{message}" if logging
+        message
+      end
+    end
+
+    def connected?
+      @connected ? true : false
+    end
+
+    def inspect
+      nick = @user.nick rescue @config.nick
+      "#<Bot nick=#{nick}>"
+    end
+
+    def parse(message)
+      message.chomp!
+
+      if message =~ /^PING \S+$/
+        if @config.hide_ping_pongs
+          raw message.sub(/PING/, 'PONG'), false
+        else
+          @config.loggers.info "<< #{message}"
+          raw message.sub(/PING/, 'PONG')
+        end
+      else
+        @config.loggers.info "<< #{message}"
+        env = MessageParser.parse(message, @config.isupport['CHANTYPES'])
+        @callbacks.call(env)
+      end
+    end
+
+    private
+
+    def disconnected
+      @connected = false
+      @config.loggers.info '-- Vetinari disconnected'
+
+      unless @quitted
+        if @config.reconnect
+          @quitted = nil
+          puts "-- Reconnecting in #{@config.reconnect_interval} seconds."
+          after(@config.reconnect_interval) { connect }
+        end
+      end
+    end
+
+    def setup_dcc
+      if @config.dcc.external_ip && @config.dcc.ports.any?
+        @server_manager = Dcc::ServerManager.new(Actor.current)
+      end
+    end
+
+    def setup_default_callbacks
+      [376, 422].each do |raw_numeric|
+        on raw_numeric do |env|
+          unless @connected
+            @connected = true
+            @callbacks.call({:type => :connect})
+          end
+        end
+      end
+
+      on 005 do |env|
+        @config.isupport.parse(env[:params])
+      end
+
+      # User ping request.
+      on :query, /^\001PING \d+\001$/ do |env|
+        time = env[:message].scan(/\d+/)[0]
+        env[:user].notice("\001PING #{time}\001")
+      end
+
+      on :query, /^\001VERSION\001$/ do |env|
+        env[:user].notice("\001VERSION Vetinari #{Vetinari::VERSION} (https://github.com/tbuehlmann/vetinari)")
+      end
+
+      on :query, /^\001TIME\001$/ do |env|
+        env[:user].notice("\001TIME #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}\001")
+      end
+    end
+
+    def setup_channel_and_user_tracking
+      # Add the bot user to the user container when connected.
+      on 001 do |env|
+        nick = env[:params].split(/ /).first
+        @user = User.new(nick, @actor) # TODO
+        @users.add(@user)
+      end
+
+      on :join do |env|
+        joined_user = {
+          :nick => env.delete(:nick),
+          :user => env.delete(:user),
+          :host => env.delete(:host)
+        }
+        channel = env.delete(:channel)
+
+        # TODO: Update existing users with user/host information.
+
+        user = @users[joined_user[:nick]]
+
+        if user
+          if user.bot?
+            channel = Channel.new(channel, @actor)
+            channel.get_mode
+            @channels.add(channel)
+          else
+            channel = @channels[channel]
+          end
+        else
+          channel = @channels[channel]
+          user = User.new(joined_user[:nick], self)
+          @users.add(user)
+        end
+
+        channel.add_user(user, [])
+        env[:channel] = channel
+        env[:user] = user
+      end
+
+      on 353 do |env|
+        channel_name = env[:params].split(/ /)[2]
+        channel = @channels[channel_name]
+        nicks_with_prefixes = env[:params].scan(/:(.*)/)[0][0].split(/ /)
+        nicks, prefixes = [], []
+        channel_prefixes = @config.isupport['PREFIX'].values.map do |p|
+          Regexp.escape(p)
+        end.join('|')
+
+        nicks_with_prefixes.each do |nick_with_prefixes|
+          nick = nick_with_prefixes.gsub(/#{channel_prefixes}/, '')
+          prefixes = nick_with_prefixes.scan(/#{channel_prefixes}/)
+          
+          unless user = @users[nick]
+            user = User.new(nick, @actor)
+            @users.add(user)
+          end
+
+          channel.add_user(user, prefixes)
+        end
+      end
+
+      on :part do |env|
+        nick    = env.delete(:nick)
+        user    = env.delete(:user)
+        host    = env.delete(:host)
+
+        # TODO: Update existing users with user/host information.
+
+        user = @users[nick]
+        channel = @channels[env.delete(:channel)]
+
+        if user.bot?
+          # Remove the channel from the channel_list.
+          @channels.remove(channel)
+
+          # Remove all users from the user_list that do not share channels
+          # with the Thaum.
+          all_known_users = @channels.channels.flat_map(&:users)
+          @users.kill_zombie_users(all_known_users)
+        else
+          channel.remove_user(user)
+          remove_user = @channels.channels.none? do |_channel|
+            _channel.has_user?(user)
+          end
+
+          @users.remove(user) if remove_user
+        end
+
+        env[:channel] = channel
+        env[:user] = user
+      end
+
+      on :kick do |env|
+        nick = env.delete(:nick)
+        user = env.delete(:user)
+        host = env.delete(:host)
+
+        # TODO: Update existing users with user/host information.
+
+        channel = @channels[env.delete(:channel)]
+        kicker = @users[nick]
+        kickee = @users[env.delete(:kickee)]
+
+        channel.remove_user(kickee)
+
+        if kickee.bot?
+          # Remove the channel from the channel_list.
+          @channels.remove(channel)
+
+          # Remove all users from the user_list that do not share channels
+          # with the Thaum.
+          all_known_users = @channels.channels.map(&:users).flatten
+          @users.kill_zombie_users(all_known_users)
+        else
+          remove_user = @channels.channels.none? do |_channel|
+            _channel.has_user?(kickee)
+          end
+
+          @users.remove(kickee) if remove_user
+        end
+
+        env[:kicker]  = kicker
+        env[:kickee]  = kickee
+        env[:channel] = channel
+      end
+
+      # If @config.rejoin_after_kick is set to `true`, let
+      # the Thaum rejoin a channel after being kicked.
+      on :kick do |env|
+        if @config.rejoin_after_kick && env[:kickee].bot?
+          key = env[:channel].modes['k']
+          env[:channel].join(key)
+        end
+      end
+
+      on :quit do |env|
+        nick = env.delete(:nick)
+        user = env.delete(:user)
+        host = env.delete(:host)
+
+        # TODO: Update existing users with user/host information.
+
+        user = @users[nick]
+
+        if user.bot?
+          channels = @channels.clear
+          @users.clear
+        else
+          channels = @channels.remove_user(user)
+          @users.remove(user)
+        end
+
+        env[:user] = user
+        env[:channels] = channels
+      end
+
+      on :disconnect do
+        @channels.clear
+        @users.clear
+      end
+
+      on :channel do |env|
+        nick    = env[:nick]
+        user    = env[:user]
+        host    = env[:host]
+
+        # TODO: Update existing users with user/host information.
+
+        env[:channel] = @channels[env[:channel]]
+        env[:user] = @users[nick]
+      end
+
+      on :query do |env|
+        nick    = env[:nick]
+        user    = env[:user]
+        host    = env[:host]
+        # TODO: Update existing users with user/host information.
+
+        env[:user] = @users[nick] || User.new(nick, @actor)
+      end
+
+      on :query, /\A\001DCC SEND \"?\S+\"? \d+ \d+ \d+\001\z/ do |env|
+        results = env[:message].scan(/\A\001DCC SEND \"?(\S+)\"? (\d+) (\d+) (\d+)\001\z/)
+        filename, ip, port, filesize = results.first
+        filename = filename.delete("/\\")
+        ip       = IPAddr.new(ip.to_i, Socket::AF_INET)
+        port     = Integer(port)
+        filesize = Integer(filesize)
+        file     = Dcc::Incoming::File.new(env[:user], filename, ip, port, filesize, @actor)
+        @callbacks.call(env.merge(:type => :dcc, :file => file))
+      end
+
+      on :channel_mode do |env|
+        # TODO: Update existing users with user/host information.
+        # nick = env[:nick]
+        # user = env[:user]
+        # host = env[:host]
+
+        nick    = env.delete(:nick)
+        params  = env.delete(:params)
+        modes   = env.delete(:modes)
+
+        channel = @channels[env.delete(:channel)]
+        env[:channel] = channel
+        env[:user]    = @users[nick]
+        env[:channel_modes] = ModeParser.parse(modes, params, @config.isupport)
+
+        env[:channel_modes].each do |mode|
+          channel.set_mode(mode, @config.isupport)
+        end
+      end
+
+      # Response to MODE command, giving back the channel modes.
+      on 324 do |env|
+        split = env[:params].split(/ /)
+        channel_name = split[1]
+        channel = @channels[channel_name]
+
+        if channel
+          modes = split[2]
+          params = split[3..-1]
+          mode_changes = ModeParser.parse(modes, params, @config.isupport)
+
+          mode_changes.each do |mode_change|
+            channel.set_mode(mode_change, @config.isupport)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vetinari/callback.rb

@@ -0,0 +1,48 @@
+module Vetinari
+  class Callback
+    include Celluloid
+
+    attr_reader :event
+    attr_writer :container
+
+    def initialize(event, pattern, proc, container, uuid)
+      @event = event
+      @pattern = pattern
+      @proc = proc
+      @container = container
+      @uuid = uuid
+    end
+
+    def call(env)
+      begin
+        @proc.call(env) if matching?(env)
+      rescue => e
+        loggers = @container.bot.config.loggers
+        loggers.error "-- #{e.class}: #{e.message}"
+        e.backtrace.each { |line| loggers.error("-- #{line}") }
+      end
+    end
+
+    def remove
+      @container.remove(@event, @uuid)
+    end
+
+    def inspect
+      event   = @event.inspect
+      pattern = @pattern.inspect
+      uuid    = @uuid.inspect
+      "#<Callback event=#{event} pattern=#{pattern} uuid=#{uuid}>"
+    end
+
+    private
+
+    def matching?(env)
+      case @event
+      when :channel, :query
+        env[:message] =~ @pattern
+      else
+        true
+      end
+    end
+  end
+end

data/lib/vetinari/callback_container.rb

@@ -0,0 +1,85 @@
+module Vetinari
+  class CallbackContainer
+    attr_reader :bot
+
+    def initialize(bot)
+      @bot = bot
+      @callbacks = Hash.new { |hash, key| hash[key] = {} }
+      @mutex = Mutex.new
+    end
+    
+    def add(event, pattern, worker, proc)
+      uuid = Celluloid.uuid
+      args = [event, pattern, proc, self, uuid]
+      worker = Integer(worker)
+
+      case
+      when worker == 1
+        callback = Callback.new(*args)
+        synchronicity = :async
+      when worker > 1
+        callback = Callback.pool(:size => worker, :args => args)
+        synchronicity = :async
+      else
+        callback = Callback.new(*args)
+        synchronicity = :sync
+      end
+
+      @mutex.synchronize do
+        @callbacks[callback.event][uuid] = {
+          :callback      => callback,
+          :synchronicity => synchronicity
+        }
+      end
+
+      callback
+    end
+
+    def remove(event, uuid)
+      @mutex.synchronize do
+        if @callbacks.key?(event)
+          hash = @callbacks[event].delete(uuid)
+
+          if hash
+            # https://github.com/celluloid/celluloid/issues/197
+            # callback.soft_terminate
+
+            # #terminate is broken for Pools:
+            # https://github.com/celluloid/celluloid/pull/207
+            #
+            # So, don't terminate for now.
+            # hash[:callback].terminate
+            return true
+          end
+        end
+      end
+
+      false
+    end
+
+    def call(env)
+      callbacks = nil
+
+      @mutex.synchronize do
+        if @callbacks.key?(env[:type])
+          callbacks = @callbacks[env[:type]].values.dup
+        end
+      end
+
+      if callbacks
+        callbacks.each do |hash|
+          case hash[:synchronicity]
+          when :sync
+            hash[:callback].call(env)
+          when :async
+            hash[:callback].async.call(env)
+          end
+        end
+      end
+    end
+
+    def inspect
+      "#<CallbackContainer bot=#{@bot.inspect}>"
+    end
+  end
+end