zetabot 0.0.1

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zeta"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here
+mkdir -p ~/.zeta/cache
+
+end
+Dir.mkdir( File.join(Dir.home, ".zeta"), 0700)
+Dir.mkdir(File.join(Dir.home, ".zeta", 'cache'), 0700)

data/bin/zeta

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'Zeta'
+require 'daemons'
+
+# Deamonize this process
+# Daemons.daemonize
+
+# Start Zeta
+Bot.start

data/bin/zeta-setup

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+Puts 'Setting up ZetaBot'
+puts 'Checking if .zeta is in your home directory'
+unless Dir.exists? File.join(Dir.home, '.zeta')
+  puts 'Creating .zeta/'
+  Dir.mkdir( File.join(Dir.home, ".zeta"), 0700)
+  puts 'Creating .zeta/cache/'
+  Dir.mkdir(File.join(Dir.home, ".zeta", 'cache'), 0700)
+  puts 'Creating .zeta/db/'
+  Dir.mkdir(File.join(Dir.home, ".zeta", 'db'), 0700)
+  puts 'Creating .zeta/log/'
+  Dir.mkdir(File.join(Dir.home, ".zeta", 'log'), 0700)
+end

data/lib/Zeta.rb

@@ -0,0 +1,13 @@
+module Zeta; end
+
+require 'Zeta/version'
+require 'Zeta/cache'
+require 'Zeta/config'
+require 'Zeta/access'
+require 'Zeta/blacklist'
+require 'Zeta/cinch'
+require 'Zeta/models'
+require 'Zeta/admin'
+require 'Zeta/locale'
+require 'Zeta/plugins'
+require 'Zeta/log'

data/lib/Zeta/access.rb

@@ -0,0 +1,84 @@
+module Cinch
+  module Plugin
+
+    module ClassMethods
+      def enable_acl(lvl= :nobody, secure_chan=false)
+        hook(:pre, :for => [:match], :method => lambda { |m| check?(m,lvl,secure_chan) })
+      end
+    end
+
+    def check?(m, lvl, secure_chan)
+      # Make sure we are actually getting a channel object
+      if m.class == Cinch::Channel
+        channel = m
+      elsif m.class == Cinch::Message
+        channel = m.channel
+      else
+        return false
+      end
+
+      # Get User
+      if m.class == Cinch::User
+        user = m
+      elsif m.class == Cinch::Message
+        user = m.user
+      else
+        return false
+      end
+
+      # Oper Overide
+      if Config.oper_overide
+        return true if user.oper
+      end
+
+      # Check Channel status
+      return false if Blacklist.channels.include? channel.to_s
+
+      # Check Ignore status
+      return false if Blacklist.users.include? user.to_s
+
+      # Only check if user has permission in the secure channel
+      channel = Channel(Config.secure_channel.to_s) if secure_chan
+
+      # Authorization method
+      if Config.secure_mode == 'channel'
+        # Check lvl privilege
+        case lvl
+          when :O, :oper
+            return true if user.oper
+            false
+          when :q, :owner # Owner
+            return true if channel.owners.include? user
+            false
+          when :a, :admin # Admin
+            return true if channel.admins.include? user
+            false
+          when :o, :op # Op
+            return true if channel.ops.include? user
+            false
+          when :h, :halfop # Half-Op
+            return true if channel.half_ops.include? user
+            false
+          when :v, :voice # Voice
+            return true if channel.voiced.include? user
+            false
+          when :nobody
+            return true
+          else
+            return false
+        end
+      elsif Config.secure_mode == 'identify'
+        # TODO
+        # Require you to identify with bot before usage
+      elsif Config.secure_mode == 'hostmask'
+        # TODO
+        # Require hostmask
+      end
+    end
+
+    def log2chan(msg, level=:notice)
+      Channel(Config.log_channel.to_s).send "[#{level.to_s}] #{msg}"
+    end
+
+  end
+end

data/lib/Zeta/admin.rb

@@ -0,0 +1,10 @@
+module Admin; end
+require 'Zeta/admin/channels'
+require 'Zeta/admin/eval'
+require 'Zeta/admin/fifo'
+require 'Zeta/admin/oper'
+require 'Zeta/admin/plugins'
+require 'Zeta/admin/users'
+require 'Zeta/admin/autojoin'
+require 'Zeta/admin/ignore'
+require 'Zeta/admin/bot'

data/lib/Zeta/admin/autojoin.rb

@@ -0,0 +1,25 @@
+module Admin
+  class Autojoin
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    # Listeners
+    listen_to :invite, method: :invited
+
+    # Methods
+    def invited(m)
+      puts "triggered"
+      if Config.options.dig :join_on_invite
+        return false if Blacklist.users.include? m.user.nick.to_s
+        return false if Blacklist.channels.include? m.channel.to_s
+
+        log2chan("#{m.user.nick} has requested me join #{m.channel}", :notice)
+
+        Channel(m.channel).join
+      end
+    end
+  end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Autojoin

data/lib/Zeta/admin/bot.rb

@@ -0,0 +1,43 @@
+module Admin
+  class Bot
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:oper)
+
+    set(
+        plugin_name: "BotAdmin",
+        help: "Bot administrator-only private commands.\nUsage: `~nick [channel]`;",
+    )
+
+    # Regex
+    match /set nick (.+)/, method: :nick
+    match /set mode (.+)/, method: :mode
+    match /die(?: (.+))?/, method: :quit, group: :quit
+
+    # Methods
+    def nick(m, nick)
+      bot.nick = nick
+      synchronize(:nickchange) do
+        @bot.handlers.dispatch :admin, m, "My nick got changed from #{@bot.last_nick} to #{@bot.nick} by #{m.user.nick}", m.target
+      end
+    end
+
+    def mode(m, nick)
+      bot.modes = m
+    end
+
+    def quit(m, msg=nil)
+      msg ||= m.user.nick
+      @bot.handlers.dispatch :admin, m, "I am being shut down NOW!#{" - Reason: " + msg unless msg.nil?}", m.target
+      sleep 2
+      bot.quit(msg)
+    end
+
+
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Bot

data/lib/Zeta/admin/channels.rb

@@ -0,0 +1,36 @@
+module Admin
+  class Channels
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:operator, true)
+
+    set(
+        plugin_name: 'ChannelAdmin',
+        help: "Bot administrator-only private commands.\nUsage: `?join [channel]`; `?part [channel] <reason>`; `?quit [reason]`;",
+    )
+
+    # Regex
+    match /join (.+)/, method: :join
+    match /part(?: (\S+))?(?: (.+))?/, method: :part, group: :part
+
+    def join(m, channel)
+      channel.split(", ").each {|ch|
+        Channel(ch).join
+        @bot.handlers.dispatch :admin, m, "Attempt to join #{ch.split[0]} by #{m.user.nick}...", m.target
+      }
+    end
+
+    def part(m, channel=nil, msg=nil)
+      channel ||= m.channel.name
+      msg ||= m.user.nick
+      Channel(channel).part(msg) if channel
+      @bot.handlers.dispatch :admin, m, "Parted #{channel}#{" - #{msg}" unless msg.nil?}", m.target
+    end
+
+  end
+
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Channels

data/lib/Zeta/admin/eval.rb

@@ -0,0 +1,43 @@
+module Admin
+  class Eval
+    include Cinch::Plugin
+
+    enable_acl(:oper)
+
+    set(
+        plugin_name: "Bot_Eval",
+        help:        "Bot administrator-only private commands.\nUsage: `?er <code>`;",
+    )
+
+    # Regex
+    match /e (.+)/, method: :boteval
+    match /eval (.+)/, method: :boteval
+    match /ereturn (.+)/, method: :botevalreturn
+    match /er (.+)/, method: :botevalreturn
+    match /evalmsg (.+)/, method: :botevalmsg
+    match /em (.+)/, method: :botevalmsg
+
+    def boteval(m, s)
+      eval(s)
+    rescue => e
+      m.user.send "eval error: %s\n- %s (%s)" % [s, e.message, e.class.name]
+    end
+
+    def botevalreturn(m, s)
+      return m.reply eval(s)
+    rescue => e
+      m.user.send "eval error: %s\n- %s (%s)" % [s, e.message, e.class.name]
+    end
+
+    def botevalmsg(m, s)
+      return m.user.msg eval(s)
+    rescue => e
+      m.user.send "eval error: %s\n- %s (%s)" % [s, e.message, e.class.name]
+    end
+
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Eval

data/lib/Zeta/admin/fifo.rb

@@ -0,0 +1,45 @@
+unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  require 'mkfifo'
+end
+
+# Named pipe plugin for Cinch.
+module Admin
+  class Fifo
+    include Cinch::Plugin
+    listen_to :connect, :method => :open_fifo
+    listen_to :disconnect, :method => :close_fifo
+
+    def open_fifo(m)
+      # Sometimes FiFo is left open on crash, remove old fifo
+      if File.exists?(File.join(Dir.home, '.zeta', 'zeta.io'))
+        File.delete(File.join(Dir.home, '.zeta', 'zeta.io'))
+      end
+
+      File.mkfifo(File.join(Dir.home, '.zeta', 'zeta.io') || raise(ArgumentError, "No FIFO path given!"))
+      File.chmod(0660, File.join(Dir.home, '.zeta', 'zeta.io'))
+
+      File.open(File.join(Dir.home, '.zeta', 'zeta.io'), "r+") do |fifo|
+        bot.info "Opened named pipe (FIFO) at #{File.join(Dir.home, '.zeta', 'zeta.io')}"
+
+        fifo.each_line do |line|
+          msg = line.strip
+          bot.debug "Got message from the FIFO: #{msg}"
+          bot.irc.send msg
+        end
+      end
+
+    end
+
+    def close_fifo(msg)
+      File.delete(File.join(Dir.home, '.zeta', 'zeta.io'))
+      bot.info "Deleted named pipe #{File.join(Dir.home, '.zeta', 'zeta.io')}"
+    end
+
+  end
+end
+
+
+# AutoLoad if Not Jruby
+unless defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+  Bot.config.plugins.plugins.push Admin::Fifo
+end

data/lib/Zeta/admin/ignore.rb

@@ -0,0 +1,112 @@
+module Admin
+  class Ignore
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:operator, true)
+
+    set(
+        plugin_name: "BotAdmin",
+        help:        "Bot administrator-only private commands.\nUsage: `~nick [channel]`;",
+    )
+
+    # Regex
+    match /ignore (.+)/, method: :ignore_user
+    match /unignore (.+)/, method: :unignore_user
+
+    match /disable (.+)/, method: :disable_channel
+    match /enable (.+)/, method: :enable_channel
+    match 'disable', method: :disable_channel
+    match 'enable', method: :enable_channel
+
+    match 'ignorelist', method: :ignore_list
+
+    match 'sync', method: :sync
+
+    def finalize
+      save_blacklist()
+    end
+
+    # Methods
+    def ignore_user(m, nickname)
+      nickname.rstrip!
+      return m.reply("You can't ignore yourself") if m.user.nick == nickname
+      u = User(nickname)
+      if m.channel.users.member?(u)
+        if Blacklist.users.include? u
+          m.reply("#{nickname} is already being ignored")
+        else
+          Blacklist.users << u.to_s
+          m.action_reply "is now ignoring #{nickname}"
+        end
+      else
+        m.reply "#{nickname} isn't currently in channel"
+      end
+      save_blacklist()
+    end
+
+    def unignore_user(m, nickname)
+      nickname.rstrip!
+      u = User(nickname)
+      if Blacklist.users.include?(u.to_s)
+        Blacklist.users.delete(u.to_s)
+        m.action_reply "is no longer ignoring #{nickname}"
+      else
+        m.reply "#{nickname} isn't on the ignore list"
+      end
+      save_blacklist()
+    end
+
+    def disable_channel(m, channel=nil)
+      if channel
+        if Blacklist.channels.include?(channel.to_s)
+          m.reply('Channel is currently disabled')
+        else
+          Blacklist.channels << channel.to_s
+          m.action_reply "has disabled #{channel} buffer"
+        end
+      else
+        if Blacklist.channels.include?(m.channel.to_s)
+          m.reply('Channel is currently disabled')
+        else
+          Blacklist.channels << m.channel.to_s.to_s
+          m.action_reply "has disabled #{m.channel.to_s} buffer"
+        end
+      end
+      save_blacklist()
+    end
+
+    def enable_channel(m, channel=nil)
+      if channel
+        if Blacklist.channels.include?(channel.to_s)
+          Blacklist.channels.delete(channel.to_s)
+          m.action_reply "has enabled #{channel} buffer"
+        else
+          m.reply('Channel is currently enabled')
+        end
+      else
+        if Blacklist.channels.include?(m.channel.to_s)
+          Blacklist.channels.delete(m.channel.to_s)
+          m.action_reply "has enabled #{m.channel.to_s} buffer"
+        else
+          m.reply('Channel is currently enabled')
+        end
+      end
+      save_blacklist()
+    end
+
+    def ignore_list(m)
+      m.reply "Currently ignored users are: #{Blacklist.users.join(', ')}"
+    end
+
+    def sync(m)
+      save_blacklist()
+      m.action_reply 'is now synced!'
+    end
+
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Admin::Ignore