beerbot 0.1.0

data/lib/BeerBot/00.utils/world/IRCWorld.rb

@@ -0,0 +1,47 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+require_relative 'World'
+
+module BeerBot
+
+  module Utils
+
+    # The chief specialisation of IRCWorld is to handle user names which
+    # are sometimes prepended with characters like '@'.
+    #
+    # TODO: are there any more?
+
+    class IRCWorld < World
+      def remove_op nick
+        nick.sub(/^@/,'')
+      end
+
+      def user nick
+        nick = self.remove_op(nick)
+        super
+      end
+
+      def nick oldnick,nick
+        oldnick = self.remove_op(oldnick)
+        nick = self.remove_op(nick)
+        super
+      end
+
+      def part nick,channel
+        nick = self.remove_op(nick)
+        super
+      end
+      
+      def join nick,channel
+        nick = self.remove_op(nick)
+        super
+      end
+    end
+
+  end
+end

data/lib/BeerBot/00.utils/world/World.rb

@@ -0,0 +1,84 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+module BeerBot
+
+  module Utils
+
+    # There should be one world per connection instance tracking
+    # the channels joined and users on those channels.
+
+    class World < Hash
+
+      def initialize nick
+        self[:nick] = nick
+
+        # An index/lookup for channels we know about.
+        self[:channels] = Hash.new {|h,k| h[k] = {users:Set.new}}
+
+        # An index/lookup for users we know about.
+        self[:users] = Hash.new {|h,k| h[k] = {channels:Set.new}}
+
+      end
+
+      # Fetch a user.
+      def user user
+        if self[:users].has_key?(user) then
+          self[:users][user]
+        else
+        end
+      end
+
+      # Fetch a channel.
+      def channel channel
+        if self[:channels].has_key?(channel) then
+          self[:channels][channel]
+        else
+        end
+      end
+
+      # Someone joins channel.
+      def join nick,channel
+        self[:channels][channel][:users].add(nick)
+        self[:users][nick][:channels].add(channel)
+        self
+      end
+
+      # Someone leaves channel.
+      def part nick,channel
+        self[:channels][channel][:users].delete(nick)
+        self[:users][nick][:channels].delete(channel)
+        self
+      end
+
+      # Someone changes nick.
+      def nick oldnick,nick
+        self[:channels].each_pair{|name,chan|
+          if chan.member?(oldnick) then
+            chan.delete(oldnick)
+            chan.add(nick)
+          end
+        }
+        self[:users][nick] = self[:users][oldnick]
+        self[:users].delete(oldnick)
+        # If it's us, update our nick:
+        if self[:nick] == oldnick then
+          self[:nick] = nick
+        end
+        self
+      end
+
+      # TODO: User quits altogether.
+      def quit user
+      end
+
+    end
+
+  end
+
+end
+

data/lib/BeerBot/01.connect/Connection.rb

@@ -0,0 +1,23 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2013,2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+module BeerBot
+  class Connection
+    attr_accessor :queue
+    def initialize
+      @queue = Queue.new
+    end
+    def open
+    end
+    def close
+    end
+    def write str
+    end
+    def ready? &block
+    end
+  end
+end

data/lib/BeerBot/01.connect/IRCConnection.rb

@@ -0,0 +1,133 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2013,2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+require 'socket'
+require 'set'
+require_relative 'Connection'
+
+module BeerBot
+
+  # An instance of IRCConnection represents a specific connection to
+  # an irc server (for a given user/bot).
+  #
+  # We also do some low-level bookkeeping, like returning pong and
+  # looking for welcome message.
+
+  class IRCConnection < Connection
+
+    # Queue containing received messages from the server.
+    attr_accessor :queue,:writeq,:readyq
+    attr_accessor :connection,:server,:port,:nick,:thread
+
+    def initialize server:nil,port:6667,nick:'beerbot'
+      @server = server
+      @port = port
+      @nick = nick
+      @queue = Queue.new   # received messages
+      @writeq = Queue.new  # messages to send out
+
+      # This queue is only used at start up when the connection
+      # to the irc server isn't ready yet:
+      @readyq = Queue.new
+      @ready = false
+      @ready_mutex = Mutex.new
+      @write_mutex = Mutex.new
+
+    end
+
+    # Flag the connection as ready.
+    #
+    # Any blocks passed to ready? will now be executed.
+
+    def ready!
+      @ready_mutex.synchronize {
+        @ready = true
+        while @readyq.size > 0
+          block = @readyq.deq
+          block.call
+        end
+      }
+    end
+
+    def ready? &block
+      return @ready unless block_given?
+      @ready_mutex.synchronize {
+        if @ready then
+          block.call
+        else
+          @readyq.enq(block)
+        end
+      }
+    end
+
+    # Open and maintain the connection with an irc server.
+    #
+    # If you pass in a connection object it will be used instead of
+    # opening a tcp socket.
+    # It should respond to whatever is called on @connection
+    # eg open,gets,write.
+    # Use for testing this class.
+
+    def open connection=nil
+      if connection then
+        @connection = connection
+        @connection.open(self.server, self.port)
+      else
+        @connection = TCPSocket.open(self.server, self.port)
+      end
+      self.write("USER #{@nick} #{@nick} #{@nick} :#{@nick}")
+      self.write("NICK #{@nick}")
+      @thread = Thread.new {
+        while not @connection.eof? do
+          str = @connection.gets()
+          puts "<< #{str}"
+          case str
+          when /^PING (.*)$/
+            self.write "PONG #{$1}"
+          when / 001 / # ready
+            self.ready!
+          else
+            self.queue.enq(str)
+          end
+        end
+      }
+      @write_thread = Thread.new {
+        loop do
+          thing = @writeq.deq
+          self.write thing
+        end
+      }
+
+      @thread
+    end
+
+    def close
+    end
+
+    # Write out to the socket.
+    #
+    # Chomps message and then adds "\r\n".
+
+    def write message
+      case message
+      when String
+        message = message.chomp + "\r\n"
+        puts ">> #{message}"
+        @write_mutex.synchronize {
+          @connection.print(message)
+        }
+      when Array
+        message.each{|m| self.write(m) }
+      when NilClass
+      else
+        puts "IRCConnection: can't process #{message}"
+      end
+    end
+
+  end
+
+end

data/lib/BeerBot/01.protocols/botmsg.rb

@@ -0,0 +1,59 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2013,2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+module BeerBot
+
+  module Protocol
+
+    module BotMsg
+
+      # Convert botmsg to an array of one or more botmsg hashes.
+      #
+      # Proc's are executed to retrieve an array or hash.
+      #
+      # Array => Array
+      # Hash  => [Hash]
+      # Proc  => [Hash]
+
+      def self.to_a botmsg
+        case botmsg
+        when Hash
+          return [botmsg]
+        when Array
+          return botmsg
+        when Proc
+          return self.to_a(botmsg.call)
+        else
+          return []
+        end
+      end
+
+      # Convert botmsg to an action if it starts with '*'.
+
+      def self.actionify botmsg
+        case botmsg
+        when Hash
+          case botmsg[:msg]
+          when /^\*\s*/
+            botmsg[:action] = botmsg[:msg].sub(/^\*\s*/,'')
+            botmsg[:msg] = nil
+          end
+          botmsg
+        when Array
+          botmsg.map {|b|
+            self.actionify(b)
+          }
+        else
+          botmsg
+        end
+      end
+      
+    end
+
+    
+  end
+end

data/lib/BeerBot/01.protocols/irc.rb

@@ -0,0 +1,250 @@
+# The files in this directory are part of BeerBot, a a ruby irc bot library.
+# Copyright (C) 2013,2014 Daniel Bush
+# This program is distributed under the terms of the GNU
+# General Public License.  A copy of the license should be
+# enclosed with this project in the file LICENSE.  If not
+# see <http://www.gnu.org/licenses/>.
+
+module BeerBot
+
+  module Protocol
+
+    module IRC
+
+      # In coming IRC messages are parsed into hashes with several
+      # additional methods.
+
+      class IRCMessage < Hash
+
+        # This regexp captures the basic pattern used for prefixed and
+        # unprefixed irc commands sent by the server to a client.
+        # 
+        # See: http://tools.ietf.org/html/rfc1459.html sec 2.3.1
+
+        CMD = Regexp.new(
+          # nick!~user@host:
+          '^(:(?<prefix>[^:\s]+(@\S+)?)\s+)?'+
+          # eg 'PRIVMSG' , 3-digit code:
+          '(?<command>[^:\s]+)'+
+          # Bit after the command (one or more words):
+          '(\s+(?<params>[^:\s]+(\s+[^:\s]+)*))?\s*'+
+          # Bit after second ':' the msg in PRIVMSG
+          '\s:\s*(?<trailing>.*)$'
+          )
+
+        def initialize raw
+
+          @valid = false
+          @has_prefix = false
+          @user_prefix = false # message came from nick
+          self[:prefix] = {}
+          self[:command] = :unknown
+          self[:raw] = raw
+          self[:params] = []
+          self[:trailing] = nil
+
+          if m = CMD.match(raw) then
+            @valid = true
+            if m[:prefix] then
+              @has_prefix = true
+              nick,host = m[:prefix].split('!')
+              if host then
+                @user_prefix = true
+                user,host = host.split('@')
+                self[:prefix][:nick] = nick
+                self[:prefix][:user] = user
+                self[:prefix][:host] = host
+              else
+                # It aint a user prefix, so just bung it in host for the
+                # moment.
+                self[:prefix][:host] = nick
+              end
+            end
+
+            self[:command] = m[:command].strip
+            params = if m[:params] then m[:params].strip else "" end
+            self[:params] = params.split(/\s+/)
+            self[:trailing]= m[:trailing].strip
+          end
+
+        end
+
+        # We couldn't parse the command if not valid.
+
+        def valid?
+          @valid
+        end
+
+        # Is a prefixed irc string sent by server.
+
+        def prefix?
+          @has_prefix
+        end
+
+        # Is prefixed and the prefix is nick!~user@host .
+
+        def user_prefix?
+          @user_prefix
+        end
+
+        # Check that syms exist in the hash otherwise return the missing
+        # sym.  
+
+        def check *syms
+          result = true
+          syms.each{|sym|
+            case sym
+            when :prefix,:nick,:user,:host
+              return :prefix unless self[:prefix]
+              case sym
+              when :prefix
+              else
+                return sym unless self[:prefix][sym]
+              end
+            else
+              return sym unless self[sym]
+            end
+          }
+          result
+        end
+
+      end
+
+      # Parse raw irc string and then yield for various events. 
+      # 
+      # The lambda receives an incoming irc string, tries to parse
+      # it and act on it.
+      # The lambda should return nil or a botmsg hash.
+      # Note that connection readiness and PONG protocol are handled by
+      # the irc connection, not here.
+
+      def self.parse str,&block
+
+        m = IRCMessage.new(str)
+        #puts "[parse] #{m}"
+        result = []
+
+        case m[:command]
+
+        when 'NICK'  # change of nick
+          case s=m.check(:prefix,:nick,:trailing)
+          when Symbol
+            puts "* NICK expected #{s}"
+            return nil
+          end
+          old = m[:prefix][:nick]
+          nick = m[:trailing]
+          result = [:nick,old,nick]
+
+        when 'PART' # someone leaves channel
+          case s=m.check(:prefix,:nick,:params)
+          when Symbol
+            puts "* PART expected #{s}"
+            return nil
+          end
+          channel = m[:params][0]
+          nick = m[:prefix][:nick]
+          result = [:part,nick,channel]
+
+        when 'JOIN' # someone joins channel
+          case s=m.check(:prefix,:nick,:trailing)
+          when Symbol
+            puts "* JOIN expected #{s}"
+            return nil
+          end
+          channel = m[:trailing]
+          nick = m[:prefix][:nick]
+          result = [:join,nick,channel]
+
+        when '353'  # channel user list when we join the channel
+          case s=m.check(:params,:trailing)
+          when Symbol
+            puts "* 353 expected #{s}"
+            return nil
+          end
+          channel = m[:params][2]
+          users = m[:trailing].split(/\s+/)
+          result = [:chanlist,channel,users]
+          #puts "[parse/353] #{result}"
+
+        when '366'  # end of 353
+          result = [:chanlistend]
+
+        when 'PRIVMSG'
+          case s=m.check(:prefix,:nick,:params,:trailing)
+          when Symbol
+            #puts "* PRIVMSG expected #{s}"
+            return nil
+          end
+
+          msg  = m[:trailing].strip
+          from = m[:prefix][:nick].strip
+          to   = m[:params][0].strip unless m[:params].empty?
+          result = [:privmsg,from,to,msg]
+
+        else # command we don't handle
+          result = [:default,m]
+        end
+
+        if block_given? then
+          yield result
+        else
+          result
+        end
+      end
+
+      # Return irc-conformat string from a botmsg hash.
+      #
+      # Generates nil if it can't handle 'botmsg'.
+
+      def self.to_irc botmsg
+        case botmsg
+        when Hash
+          to = botmsg[:to]
+          return nil unless to
+          if botmsg[:action] then
+            self.action(to,botmsg[:action])
+          elsif botmsg[:msg] then
+            self.msg(to,botmsg[:msg])
+          else
+            nil
+          end
+        when Array
+          botmsg.map{|reply|
+            self.to_irc reply
+          }
+        when Proc
+          #p botmsg.call
+          self.to_irc(botmsg.call)
+        else
+          nil
+        end
+
+      end
+
+
+      # Send PRIVMSG to channel or nick.
+
+      def self.msg to,str
+        "PRIVMSG #{to} :#{str}"
+      end
+      class << self
+        alias_method :privmsg,:msg
+      end
+
+      # Send a /me-style action to channel or nick.
+
+      def self.action to,str
+        "PRIVMSG #{to} :\u0001#{'ACTION'} #{str}\u0001"
+      end
+
+      # Join a channel
+
+      def self.join chan
+        "JOIN #{chan}"
+      end
+
+    end
+  end
+
+end