beerbot 0.1.5 → 0.2.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6483fc83799ee9b532e10c4f96a1c7d1b7eb0a29
-  data.tar.gz: 9564a54aa28c251d87b09f72222f63284b7f5d35
+  metadata.gz: 87f292c599a9b6b747cf3946ba5693c3eac5e6fc
+  data.tar.gz: 0a3a0612f3cedbb8c52508dba7cf67af4f5cae6f
 SHA512:
-  metadata.gz: d857137c3322faabef1fc1da6a9155c0acd4c185a18de60cb87d57404ba67896b48137bd72de91ea2d157224da0cbefce57aa880465ada41f5c59ce30ddb24ef
-  data.tar.gz: 452fca254f50a355a141dab0c4ea7d758c85debde316eb8023e257424913e52f4f85b3e7e12afe06e26756169db693961285eb40e05076ae300b351506961780
+  metadata.gz: e3d16c56405388a6183dc99057dc1953c18f3df825e295ca07f4c851ddff2d3103449f89d8e56ad9a12b56fa7c3f67a0f3d53cb1ce90f088e29e5fa74107eb66
+  data.tar.gz: 4b629d26bd44bd7a0a9e1590f07ed74f41323b3575a9415db57518a28d7c8c24d9f91a7f1163ec83bb5e7ec5a31a4715b16f23b7f172c65896c152281040cb6f

data/bin/{run-irc.rb → beerbot-run-irc.rb}

@@ -7,6 +7,11 @@
 # enclosed with this project in the file LICENSE.  If not
 # see <http://www.gnu.org/licenses/>.
 
+# If you're running this WITHOUT the gem, you probably want to do
+# something like this (in beerbot's root directory):
+#
+#   ruby -Ilib bin/beerbot-run-irb.rb path/to/conf.json
+
 raise "Needs ruby 2" if /^1/===RUBY_VERSION
 require_relative '../lib/RunIRC'
 
@@ -17,8 +22,9 @@ if ARGV.size == 0 then
 end
 
 conffile = ARGV[0]
-BeerBot::Config.load JSON.load(File.read(conffile))
-BeerBot::Config.validate!
+config = BeerBot::Config.new
+config.load JSON.load(File.read(conffile))
+config.validate!
 
-$runirc = BeerBot::RunIRC.new BeerBot::Config
+$runirc = BeerBot::RunIRC.new(config)
 $runirc.start

data/lib/RunIRC.rb

@@ -9,7 +9,7 @@ require 'set'
 require 'rubygems'
 require 'pry'
 require 'json'
-require_relative 'BeerBot'
+require_relative 'beerbot'
 
 # Run the irc bot.
 #
@@ -23,15 +23,15 @@ module BeerBot; end
 class BeerBot::RunIRC
 
   Utils         = BeerBot::Utils
-  IRCWorld      = BeerBot::Utils::IRCWorld
   InOut         = BeerBot::Utils::InOut
   IRCConnection = BeerBot::IRCConnection
   IRC           = BeerBot::Protocol::IRC
   Bot           = BeerBot::Bot
+  BotMsg        = BeerBot::BotMsg
   Dispatcher    = BeerBot::Dispatchers::Dispatcher
   Scheduler     = BeerBot::Scheduler
 
-  attr_accessor :config,:bot,:scheduler,:dispatcher,:world,:conn,:postq,:parse,:more
+  attr_accessor :config,:bot,:scheduler,:dispatcher,:conn,:postq,:parse,:more
 
   # Initialize all parts of the system here.
   #
@@ -41,27 +41,27 @@ class BeerBot::RunIRC
 
   def initialize config
 
+    @echo = true
     @path = File.expand_path(File.dirname(__FILE__)+'/..')
     @module_path = config['moduledir']
     @config = config
 
     # Create the bot.
-    @bot = Bot.new(@module_path,config['modules'])
-
-    # Create a world associated with this irc connection.
-    # (lists channels and users we know about)
-    @world = IRCWorld.new(config['nick'])
+    @bot = Bot.new
+    @bot.load!(config['modules'],@module_path)
+    config.bot = @bot
 
     # Dispatcher which receives messages and interacts with the bot.
     @dispatcher = Dispatcher.new(
       @bot,
       config['nick'],
       prefix:config['cmd_prefix'],
-      world:@world
+      config:config
     )
 
     # Set up scheduler (this doesn't start it yet)...
     @scheduler = Scheduler.instance(config['timezone'])
+    config.scheduler = @scheduler
 
     # Create but don't open the irc connection.
     @conn = IRCConnection.new(
@@ -85,12 +85,32 @@ class BeerBot::RunIRC
     # which also need to be dispatched.
 
     @scheduler_thread = InOut.new(inq:@scheduler.queue,outq:@conn.writeq) {|cron_job|
-      puts "<< scheduler #{cron_job.inspect}"
-      puts "<< scheduler #{@scheduler.time}"
+      puts "<< scheduler #{cron_job.inspect}" if @echo
+      puts "<< scheduler #{@scheduler.time}" if @echo
       IRC.to_irc(cron_job.run)
     }
     @scheduler_thread.start!
 
+    # Active messaging queue.
+    #
+    # 'config' will be injected into bot modules.
+    # config.out should be a queue that we can dequeue.
+
+    @active_thread = InOut.new(inq:@config.out,outq:@conn.writeq) {|replies|
+      puts "<< active #{replies}" if @echo
+      # TODO: almost identical logic in the dispatcher class (in
+      # @dispatcher_thread).
+      case replies
+      when String # assume protocol string eg irc
+        replies
+      when Hash,Array,Proc
+        IRC.to_irc(BotMsg.to_a(replies))
+      else
+        []
+      end
+    }
+    @active_thread.start!
+
     # Set up a repl in a separate thread.
     # 
     # In pry, you can then do:
@@ -102,6 +122,9 @@ class BeerBot::RunIRC
       binding.pry
     }
 
+    @bot.init(@config)
+    @bot.update_config(@config)
+
     # Do stuff once we've identified with the irc server...
     # 
     # Join channels.
@@ -118,6 +141,15 @@ class BeerBot::RunIRC
     }
   end
 
+  # Toggle whether inputs and outputs show on the repl screen.
+  #
+  # Call this from the pry repl.
+
+  def echo
+    @echo = !@echo
+    @conn.echo = @echo
+  end
+
   # Start the connection.
 
   def start
@@ -142,14 +174,10 @@ class BeerBot::RunIRC
     @conn.writeq.enq(IRC.join(chan))
   end
 
-  # Reload @bot using module list 'modules'.
-  #
-  # You could use
+  # Convenience method to leave a channel.
 
-  def reload! modules=[]
-    @config['modules'] = modules
-    @bot = Bot.new(@module_path,modules)
-    @dispatcher.bot = @bot
+  def leave chan
+    @conn.writeq.enq(IRC.leave(chan))
   end
 
 end

data/lib/beerbot.rb

@@ -0,0 +1,17 @@
+require 'CronR' # For scheduler
+
+require_relative 'beerbot/00.utils/utils'
+require_relative 'beerbot/00.utils/InOut'
+require_relative 'beerbot/01.connect/IRCConnection'
+require_relative 'beerbot/01.bot/botmsg'
+require_relative 'beerbot/01.bot/BotModule'
+require_relative 'beerbot/01.bot/Bot'
+require_relative 'beerbot/02.protocols/irc'
+require_relative 'beerbot/06.dispatchers/dispatcher'
+require_relative 'beerbot/70.scheduler/scheduler'
+require_relative 'beerbot/Config'
+
+module BeerBot
+  module Modules
+  end
+end

data/lib/beerbot/00.utils/utils.rb

@@ -0,0 +1,34 @@
+# 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
+
+    # Return a parser that takes string msg and extracts a specified
+    # prefix at beginning.
+    #
+    # The prefix might be a nick or a command prefix.
+    #
+    # Use this to get commands issued to the bot through a channel.
+    #
+    # TODO: make sure this returns msg without the prefix, or nil
+    # otherwise.
+
+    def self.make_prefix_parser prefix
+      rx = Regexp.new("^#{prefix}\\W?(.*)",'i')
+      lambda {|msg|
+        if m = rx.match(msg) then
+          m[1].strip
+        end
+      }
+    end
+
+  end
+
+end

data/lib/{BeerBot → beerbot}/01.bot/Bot.rb

@@ -16,17 +16,41 @@ module BeerBot
 
     attr_accessor :module_path,:module_names
 
-    def initialize module_path,module_names
+    def initialize
       super()
-      @module_path = module_path
-      @module_names = module_names
-      self.load!
     end
 
-    def load!
+    # Call all init methods on bot modules that have them.
+    # 
+    # Should only be called once.
+
+    def init config
+      self.valid_modules.each {|botmodule|
+        if botmodule[:mod].respond_to?(:init) then
+          botmodule[:mod].init(config)
+        end
+      }
+    end
+
+    # Call #config on all valid bot modules.
+
+    def update_config config
+      self.valid_modules.each {|botmodule|
+        if botmodule[:mod].respond_to?(:config) then
+          botmodule[:mod].config(config)
+        end
+      }
+    end
+
+    # Purge existing modules from this array and load modules with
+    # names in module_names in module_path on disk into memory.
+
+    def load! module_names,module_path
+      @module_path = module_path
+      @module_names = module_names
       self.reject!{true} unless self.empty?  # ick :)
-      Dir.chdir(@module_path) {
-        @module_names.each {|name|
+      Dir.chdir(module_path) {
+        module_names.each {|name|
           initfile = "#{name}/init.rb"
           modname = "::BeerBot::Modules::#{name}"
           mod = nil
@@ -88,12 +112,16 @@ module BeerBot
     def run meth,*args,**kargs
       self.valid_modules.inject([]) {|arr,bot_module|
         name,mod = bot_module.values_at(:name,:mod)
-        next arr unless mod.respond_to?(meth)
-        botmsg = mod.send(meth,*args,**kargs)
+        unless mod.respond_to?(meth) then
+          next arr
+        end
+        reply = mod.send(meth,*args,**kargs)
+        suppress,botmsg = BotMsg.to_reply_format(reply)
         if botmsg then
-          #arr << [name,botmsg]
-          arr += BotMsg.to_a(botmsg)
-          break arr # TODO allow multi-module response?
+          arr += botmsg
+        end
+        if suppress then
+          break arr
         else
           arr
         end
@@ -102,26 +130,26 @@ module BeerBot
 
     # Process messages addressed directly to the bot.
 
-    def cmd msg,from:nil,to:nil,me:false,world:nil
+    def cmd msg,from:nil,to:nil,me:false,config:nil
       if @cmd then
-        @cmd.call(msg,from:from,to:to,world:world,me:me)
+        @cmd.call(msg,from:from,to:to,config:config,me:me)
       else
-        self.run(:cmd,msg,from:from,to:to,world:world,me:me)
+        self.run(:cmd,msg,from:from,to:to,config:config,me:me)
       end
     end
 
     # Process messages the bot overhears.
 
-    def hear msg,from:nil,to:nil,me:false,world:nil
+    def hear msg,from:nil,to:nil,me:false,config:nil
       if @hear then
-        @hear.call(msg,from:from,to:to,me:me,world:world)
+        @hear.call(msg,from:from,to:to,me:me,config:config)
       else
-        self.run(:hear,msg,from:from,to:to,me:me,world:world)
+        self.run(:hear,msg,from:from,to:to,me:me,config:config)
       end
     end
 
-    def action action,from:nil,to:nil,me:false,world:nil
-      self.run(:action,action,from:from,to:to,me:me,world:world)
+    def action action,from:nil,to:nil,me:false,config:nil
+      self.run(:action,action,from:from,to:to,me:me,config:config)
     end
 
     # Handle events other than being messaged.
@@ -135,7 +163,7 @@ module BeerBot
       self.run(:event,event,**kargs)
     end
 
-    def help arr,from:nil,to:nil,world:nil,me:false
+    def help arr,from:nil,to:nil,config:nil,me:false
       m = []
       modname,*topics = arr
 

data/lib/{BeerBot → beerbot}/01.bot/botmsg.rb

@@ -99,6 +99,57 @@ module BeerBot
           botmsg
         end
       end
+
+      # Transform all replies from bot modules to ARRAY FORMAT.
+      #
+      # A module may reply in either format. But we convert it here. The
+      # single return format is the simplest, which is why we have 2
+      # formats.
+      # 
+      # ARRAY FORMAT
+      # 
+      #   [<bool>,<reply>]
+      # 
+      # where bool  = true  => "use <reply> and keep going"
+      #             = false => "use <reply> but stop here"
+      # where reply = whatever the bot returns.
+      # NOTE: any other type of array will assumed to be in
+      # single return form...
+      #
+      # SINGLE RETURN FORMAT
+      # 
+      # This form assumes you return one thing, either nil/false or a
+      # botmsg. Returning nil/false won't suppress subsequent modules
+      # from being evaluated.
+      #
+      # Note, that "whatever the bot returns" will need to be one of the
+      # valid forms of a botmsg for it to get sent out.
+
+      def self.to_reply_format thing
+        case thing
+        when Array
+          bool,botmsg = thing
+          case bool
+          when TrueClass,FalseClass
+            # Assume array format:
+            [bool,self.to_a(botmsg)]
+          else
+            # Assume single return format...
+            # Array of any sort is truthy, so suppress.
+            [true,self.to_a(thing)]
+          end
+        else
+          # Asume single return format...
+          # 
+          # Look at truthiness of thing to determine whether to suppress
+          # further responses (true) or continue (false).
+          if thing then
+            [true,self.to_a(thing)]
+          else
+            [false,self.to_a(thing)]
+          end
+        end
+      end
       
     end
     

data/lib/{BeerBot → beerbot}/01.connect/IRCConnection.rb

@@ -21,8 +21,10 @@ module BeerBot
     # Queue containing received messages from the server.
     attr_accessor :queue,:writeq,:readyq
     attr_accessor :connection,:server,:port,:nick,:thread
+    attr_accessor :echo
 
     def initialize server:nil,port:6667,nick:'beerbot'
+      @echo = true
       @server = server
       @port = port
       @nick = nick
@@ -33,6 +35,7 @@ module BeerBot
       # to the irc server isn't ready yet:
       @readyq = Queue.new
       @ready = false
+      @ready_blocks = []
       @ready_mutex = Mutex.new
       @write_mutex = Mutex.new
 
@@ -44,9 +47,13 @@ module BeerBot
 
     def ready!
       @ready_mutex.synchronize {
+        unless @ready_blocks.empty? then
+          @ready_blocks.each{|b| @readyq.enq(b)}
+        end
         @ready = true
         while @readyq.size > 0
           block = @readyq.deq
+          @ready_blocks.push(block)
           block.call
         end
       }
@@ -70,30 +77,43 @@ module BeerBot
     # It should respond to whatever is called on @connection
     # eg open,gets,write.
     # Use for testing this class.
+    #
+    # May throw errors.
+    # - @connection.eof? can throw things like ECONNRESET etc
 
     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)
+        loop do
+          begin
+            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}")
+            while not @connection.eof? do
+              str = @connection.gets()
+              puts "<< #{str}" if @echo
+              case str
+              when /^PING (.*)$/
+                self.write "PONG #{$1}"
+              when / 001 / # ready
+                self.ready!
+              else
+                self.queue.enq(str)
+              end
+            end
+          rescue => e
+            puts "Connection whoops: #{e}"
           end
+          @ready = false
+          puts "Sleeping #{10} then try again..."
+          sleep 10
         end
       }
+        
       @write_thread = Thread.new {
         loop do
           thing = @writeq.deq
@@ -115,7 +135,7 @@ module BeerBot
       case message
       when String
         message = message.chomp + "\r\n"
-        puts ">> #{message}"
+        puts ">> #{message}" if @echo
         @write_mutex.synchronize {
           @connection.print(message)
         }