tinyirc 0.1.0

data/lib/tinyirc/command.rb

@@ -0,0 +1,109 @@
+class TinyIRC::Command
+  class << self
+    attr_reader :log
+  end
+
+  @log = ParticleLog.new('commands', ParticleLog::INFO)
+
+  class Branch
+    attr_reader :cmd, :id, :definition, :handler, :last_uses
+    attr_accessor :cooldown, :description
+
+    def initialize(cmd, id, definition, handler)
+      @cmd         = cmd
+      @cooldown    = 0
+      @id          = id
+      @definition  = definition
+      @description = ''
+      @handler     = handler
+      @last_uses   = {}
+    end
+  end
+  
+  attr_reader :plugin, :name, :branches
+  
+  def initialize(plugin, name)
+    @plugin   = plugin
+    @name     = name
+    @branches = {}
+    TinyIRC::Command.log.info "commands += #{@plugin.name}/#{name}"
+  end
+
+  def branch(id, definition, &handler)
+    @branches[id] = Branch.new(self, id, ParticleCMD::Definition.from_string(@name, definition), handler)
+    TinyIRC::Command.log.info "#{@plugin.name}/#{@name} += #{id}: #{@branches[id].definition.command_signature(true)}"
+    @branches[id]
+  end
+
+  def handle_command(h, cmd_info)
+    pname = h[:cmd_info][:plugin]
+    pname = @plugin.name if pname == :any
+    cname = h[:cmd_info][:command]
+    bname = h[:cmd_info][:branch]
+    
+    def checkperm(h, fname)
+      h[:socket].has_perm(h[:host], fname)
+    end
+
+    def checkcd(h, branch)
+      return true if h[:socket].has_group(h[:host], 'admin')
+      unless branch.last_uses[h[:socket].name]
+        branch.last_uses[h[:socket].name] = {}
+        return true
+      end
+      current = Time.now.to_i
+      last = branch.last_uses[h[:socket].name][h[:nick]].to_i
+      diff = current - last
+      if diff >= branch.cooldown || diff < 0
+        branch.last_uses[h[:socket].name][h[:nick]] = current
+        true
+      else
+        false
+      end
+    end
+
+    if (bname != :any)
+      if @branches.include? bname
+        branch = @branches[bname]
+        res = branch.definition.match cmd_info
+        if res
+          bname = branch.id
+          fname = pname + '/' + cname + '/' + bname
+          unless checkperm(h, fname)
+            h.nreply "Sorry, but you cannot execute this command (#{fname})"
+            return :denied
+          end
+          unless checkcd(h, branch)
+            h.nreply "Sorry, but you cannot execute this command now (cooldown - #{branch.cooldown}s)"
+            return :cooldown
+          end
+          branch.handler.(h, res)
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+    else
+      @branches.each_pair do |id, branch|
+        res = branch.definition.match cmd_info
+        if res
+          bname = branch.id
+          fname = pname + '/' + cname + '/' + bname
+          unless checkperm(h, fname)
+            h.nreply "Sorry, but you cannot execute this command (#{fname})"
+            return :denied
+          end
+          unless checkcd(h, branch)
+            h.nreply "Sorry, but you cannot execute this command now (cooldown - #{branch.cooldown}s)"
+            return :cooldown
+          end
+          branch.handler.(h, res)
+          return true
+        end
+      end
+      false
+    end
+  end
+end

data/lib/tinyirc/event.rb

@@ -0,0 +1,12 @@
+module TinyIRC
+  def self.define_event_methods(h)
+    h.define_singleton_method :reply do |msg|
+      raise RuntimeError, ':reply action is not supported' unless self[:reply_to]
+      self[:socket].privmsg(self[:reply_to], msg)
+    end
+    h.define_singleton_method :nreply do |msg|
+      raise RuntimeError, ':nreply action is not supported' unless self[:nick]
+      self[:socket].notice(self[:nick], msg)
+    end
+  end
+end

data/lib/tinyirc/ircsocket.rb

@@ -0,0 +1,231 @@
+class TinyIRC::IRCSocket
+  attr_accessor :name, :host, :port, :nick, :user, :pass, :rnam, :autojoin, :prefix
+  attr_accessor :bot, :reconnects, :running, :last_write
+  attr_reader :mtx, :log, :sock, :queue, :usercache
+
+  def initialize(bot, name, opts)
+    @bot  = bot
+    @name = name
+    @host = opts['host'] || '127.0.0.1'
+    @port = opts['port'] || 6667
+    @nick = opts['nick'] || 'TinyBot'
+    @user = opts['user'] || @nick
+    @pass = opts['pass'] || nil
+    @rnam = opts['rnam'] || 'An IRC bot in Ruby'
+    @autojoin = opts['autojoin'] || []
+    @prefix = opts['prefix'] || bot.prefix || '!'
+    
+    @reconnects = 0
+    @running = false
+    @last_write = Time.now
+
+    @mtx = Mutex.new
+    @log = ParticleLog.new("!#{name}", ParticleLog::INFO)
+    @log.level_table[ParticleLog::IO] = 'IRC'
+    @log.important "Hello, #{name}!"
+  
+    @sock = nil
+    @queue = Queue.new
+    @usercache = TinyIRC::UserCache.new
+  end
+
+  def connect(reconnect=false)
+    @log.important 'Connecting...'
+    @mtx.synchronize do
+      begin
+        @sock = TCPSocket.new @host, @port
+        @running = true
+        @bot.handle_event type: :connect, socket: self
+        Thread.new do
+          authenticate
+        end
+      rescue => e
+        @log.error "#{e.class.name} - #{e.message}"
+        @bot.handle_event type: :disconnect, socket: self
+      end
+    end
+  end
+
+  def disconnect
+    @mtx.synchronize do
+      @running = false
+      sock.close
+    end
+  end
+
+  def authenticate
+    direct_write "PASS #{@pass}" if @pass
+    direct_write "NICK #{@nick}"
+    direct_write "USER #{@user} 0 * :#{@rnam}"
+  end
+
+  def direct_write(msg)
+    log.io "W> #{msg}"
+    @sock.write "#{msg}\r\n"
+  end
+
+  def write(msg)
+    @queue.push msg
+  end
+
+  def inspect
+    "#<TinyIRC::IRCSocket @name=#{@name.inspect}>"
+  end
+
+  def has_perm(host, name)
+    if (@bot.db.execute(
+      'SELECT EXISTS(SELECT 1 FROM groupinfo WHERE server=? AND host=? AND name="admin" LIMIT 1)',
+      [@name, host]
+    ).flatten[0] == 1)
+      return true
+    end
+
+    groups = @bot.db.execute("SELECT name FROM groupinfo WHERE server=? AND host=?", [@name, host])
+    groups = groups.flatten.to_set
+    groups << 'world'
+    
+    def where(gname)
+      s = gname.split('/', 2)
+      if s.length == 1
+        @bot.groups[gname]
+      elsif s.length == 2
+        return nil unless @bot.plugins.include? s[0]
+        @bot.plugins[s[0]].groups[gname]
+      else
+        nil
+      end
+
+    end
+
+    groups.each do |gname|
+      w = where(gname)
+      next unless w
+      w.perms.each do |perm|
+        if perm == TinyIRC::Permission.new(*TinyIRC::Permission.parse(name))
+          return true
+        end
+      end
+    end
+
+    false
+  end
+
+  def set_group(host, name)
+    res = @bot.db.execute(
+      'SELECT EXISTS(SELECT 1 FROM groupinfo WHERE server=? AND host=? AND name=? LIMIT 1)',
+      [@name, host, name]
+    ).flatten[0]
+    if res == 0
+      @bot.db.execute('INSERT INTO groupinfo (server, host, name) VALUES (?, ?, ?)', [@name, host, name])
+    end
+  end
+
+  def del_group(host, name)
+    @bot.db.execute('DELETE FROM groupinfo WHERE server=? AND host=? AND name=?', [@name, host, name])
+  end
+
+  def has_group(host, name)
+    if (@bot.db.execute(
+      'SELECT EXISTS(SELECT 1 FROM groupinfo WHERE server=? AND host=? AND name="admin" LIMIT 1)',
+      [@name, host]
+    ).flatten[0] == 0) then
+      @bot.db.execute(
+        'SELECT EXISTS(SELECT 1 FROM groupinfo WHERE server=? AND host=? AND name=? LIMIT 1)',
+        [@name, host, name]
+      ).flatten[0] == 1
+    else
+      true
+    end
+  end
+
+  def list_groups(host)
+    @bot.db.execute(
+      'SELECT name FROM groupinfo WHERE server=? AND host=?',
+      [@name, host]
+    ).flatten
+  end
+
+  def join(chan, key = nil)
+    if key
+      write "JOIN #{chan} #{key}"
+    else
+      write "JOIN #{chan}"
+    end
+  end
+
+  def part(chan, reason = 'Bye')
+    write "PART #{chan} :#{reason}"
+  end
+
+  def self.ssplit(string)
+    out = []
+    arr = string.split("\n\r")
+    arr.each do |i|
+      items = i.scan(/.{,399}/)
+      items.delete('')
+      items.each do |i2|
+        out << i2
+      end
+    end
+    out
+  end
+
+  def self.process_colors(string)
+    string
+      .gsub("%C%",     "%C?")
+      .gsub(",%",      ",?")
+      .gsub("%C",      "\x03")
+      .gsub("%B",      "\x02")
+      .gsub("%I",      "\x10")
+      .gsub("%U",      "\x1F")
+      .gsub("%N",      "\x0F")
+      .gsub("?WHITE",  "0")
+      .gsub("?BLACK",  "1")
+      .gsub("?BLUE",   "2")
+      .gsub("?GREEN",  "3")
+      .gsub("?RED",    "4")
+      .gsub("?BROWN",  "5")
+      .gsub("?PURPLE", "6")
+      .gsub("?ORANGE", "7")
+      .gsub("?YELLOW", "8")
+      .gsub("?LGREEN", "9")
+      .gsub("?CYAN"  , "10")
+      .gsub("?LCYAN",  "11")
+      .gsub("?LBLUE",  "12")
+      .gsub("?PINK",   "13")
+      .gsub("?GREY",   "14")
+      .gsub("?LGREY",  "15")
+  end
+
+  def privmsg(target, message)
+    self.class.ssplit(self.class.process_colors(message)).each do |m|
+      write("PRIVMSG #{target} :\u200B#{m}")
+    end
+  end
+
+  def notice(target, message)
+    self.class.ssplit(self.class.process_colors(message)).each do |m|
+      write("NOTICE #{target} :\u200B#{m}")
+    end
+  end
+
+  def ctcp(target, message)
+    write("PRIVMSG #{target} :\x01#{self.class.process_colors(message)}\x01")
+  end
+
+  def nctcp(target, message)
+    write("NOTICE #{target} :\x01#{self.class.process_colors(message)}\x01")
+  end
+
+  def mode(channel, params)
+    write("MODE #{channel} #{params}")
+  end
+
+  def kick(channel, target, reason = 'Bye!')
+    write("KICK #{channel} #{target} :#{reason}")
+  end
+
+  def remove(channel, target, reason = 'Bye!')
+    write("REMOVE #{channel} #{target} :#{reason}")
+  end
+end

data/lib/tinyirc/perms.rb

@@ -0,0 +1,45 @@
+class TinyIRC::Permission
+  attr_reader :plugin, :command, :branch
+  
+  def self.parse(pstr)
+    a = pstr.split('/', 3)
+    raise RuntimeError, "Invalid permission: #{pstr}" unless a[0] || !a[1] && a[2]
+    [a[0], a[1] || :all, a[2] || :all]
+  end
+
+  def initialize(plugin, command, branch)
+    @plugin  = plugin
+    @command = command
+    @branch  = branch
+  end
+
+  def ==(other)
+    @plugin == other.plugin && @command == other.command && @branch == other.branch
+  end
+
+  def to_s
+    "#{@plugin}/#{@command}/#{@branch}"
+  end
+end
+
+class TinyIRC::Group
+  class << self
+    attr_reader :log
+  end
+
+  @log = ParticleLog.new('groups', ParticleLog::INFO)
+
+  attr_reader :name, :perms
+
+  def initialize(name)
+    @name  = name
+    @perms = Set.new
+    TinyIRC::Group::log.write "groups += #{name}"
+  end
+
+  def perm(plugin, command, branch)
+    if @perms.add?(TinyIRC::Permission.new(plugin, command, branch))
+      TinyIRC::Group::log.write "#{@name} += #{plugin}/#{command}/#{branch}"
+    end
+  end
+end

data/lib/tinyirc/plugin.rb

@@ -0,0 +1,95 @@
+class TinyIRC::Plugin
+  attr_reader :commands, :event_handlers, :fullname, :groups, :loaded, :log, :name
+
+  def initialize(bot, name)
+    @loaded     = false
+    
+    @l_init     = lambda {}
+    @l_postinit = lambda {}
+    @l_config   = lambda {|cfg|}
+    
+    @bot      = bot
+    @fullname = name
+    @name     = File.basename(name)
+    
+    @commands       = {}
+    @event_handlers = {}
+    @groups         = {}
+
+    @log = ParticleLog.new('?' + @name, ParticleLog::INFO) 
+    @log.info 'Loading...'
+
+    lp = "./#{name}.rb"
+    ok = false
+    if File.exists? lp
+      instance_eval(File.read(lp), lp) 
+      ok = true
+    else
+      $LOAD_PATH.each do |f|
+        lp = File.join(f, name + '.rb')
+        if File.exists? lp
+          instance_eval(File.read(lp), lp)
+          ok = true
+        end
+      end
+    end
+
+    raise RuntimeError, "Cannot find the `#{name}` plugin" unless ok
+
+    _l_init
+  end
+
+  def init(&b) @l_init = b end
+  def _l_init()
+    @log.info 'Initializing...'
+    @l_init.()
+  end
+
+  def postinit(&b) @l_postinit = b end
+  def _l_postinit()
+    @log.info 'Post-Initializing...'
+    @l_postinit.()
+    @loaded = true
+    @log.important "Hello, bot!"
+  end
+    
+  def configure(&b) @l_config = b end
+  def _l_config(cfg)
+    @log.info 'Configuring...'
+    @l_config.(cfg)
+  end
+
+  def on(type, pattern, &block) 
+    pattern[:type] = type
+    pattern[:_block] = block
+    @event_handlers[type] = pattern
+  end
+
+  def on(type, **pattern, &handler)
+    @event_handlers[type] ||= []
+    @event_handlers[type] << {
+      pattern: pattern,
+      handler: handler
+    }
+  end
+
+  def cmd(name)
+    @commands[name] = TinyIRC::Command.new(self, name)
+    @commands[name]
+  end
+
+  def handle_command(h, cmd_info)
+    return false if h[:cmd_info][:plugin] != @name && h[:cmd_info][:plugin] != :any
+    x = if @commands.include? h[:cmd_info][:command]
+      @commands[h[:cmd_info][:command]].handle_command(h, cmd_info)
+    else
+      false
+    end
+  end
+
+  def group(name)
+    n = "#{@name}/#{name}"
+    @groups[n] = TinyIRC::Group.new n
+    @groups[n]
+  end
+end