Ticket #93: topic.2.rb

# Author: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
# Add a bunch of topic manipulation features

class TopicPlugin < Plugin
  def initialize
    super
    @addtopic = /(?:topic(?:append|add)|(?:append|add)topic)/
    @prependtopic = /(?:topicprepend|prependtopic)/
    @addtopicat = /(?:(?:addtopic|topicadd)at)/
    @deltopic = /(?:deltopic|topicdel)/
    @separator = "|" # default separator
  end

  def help(plugin, topic="")
    case plugin
    when "topic"
      case topic
      when "add"
        return "#{topic} <text> => add <text> at the end the topic"
      when "prepend"
        return "#{topic} <text> => add <text> at the beginning of the topic"
      when "addat"
        return "#{topic} <num> <text> => add <text> at position <num> of the topic"
      when "del"
        return "#{topic} <num> => remove section <num> from the topic"
      when "set"
        return "settopic <text> => sets the topic to <text>"
      when "separator"
        return "separator [<text>] => get or set the topic section separator"
      when "learntopic"
        return "learntopic => remembers the topic for later"
      when "resumetopic"
        return "resumetopic => resets the topic to the latest remembered one"
      when "settopic"
        return "settopic <text> => sets the topic to <text>"
      else
        return "topic commands: addtopic, prependtopic, addtopicat, deltopic, learntopic, resumetopic, settopic"
      end
    when "learntopic"
      return "learntopic => remembers the topic for later"
    when "resumetopic"
      return "resumetopic => resets the topic to the latest remembered one"
    when "settopic"
      return "settopic <text> => sets the topic to <text>"
    end
  end

  def handletopic(m, param)
    return unless m.kind_of?(PrivMessage) && m.public?
    cmd = param[:command]
    txt = param[:text].join(" ")
    case cmd
    when /a(dd|ppend)/
      topicappend(m, txt)
    when 'prepend'
      topicprepend(m, txt)
    when 'addat'
      if txt =~ /\s*(-?\d+)\s+(.*)\s*/
        num = $1.to_i - 1
        num += 1 if num < 0
        txt = $2
        topicaddat(m, num, txt)
      end
    when /del(ete)?/
      if txt =~ /\s*(-?\d+)\s*/
        num=$1.to_i - 1
        num += 1 if num < 0
        topicdel(m, num)
      end
    when /set/
      do_topicset(m, txt)
    when /sep(arator)?/
      do_topicsep(m, txt)
    else
      m.reply 'unknown command'
    end
  end

  def listen(m)
    return unless m.kind_of?(PrivMessage) && m.public? && m.address? && !m.action?
    command = m.message.dup
    if m.address? || command.gsub!(/^!/, "")
      case command
      when /^#{@addtopic}\s+(.*)\s*/
        txt=$1
        if @bot.auth.allow?("topic", m.source, m.replyto)
          topicappend(m, txt)
        end
      when /^#{@prependtopic}\s+(.*)\s*/
        txt=$1
        if @bot.auth.allow?("topic", m.source, m.replyto)
          topicprepend(m, txt)
        end
      when /^#{@addtopicat}\s+(-?\d+)\s+(.*)\s*/
        num=$1.to_i - 1
        num += 1 if num < 0
        txt=$2
        if @bot.auth.allow?("topic", m.source, m.replyto)
          topicaddat(m, num, txt)
        end
      when /^#{@deltopic}\s+(-?\d+)\s*/
        num=$1.to_i - 1
        num += 1 if num < 0
        if @bot.auth.allow?("topic", m.source, m.replyto)
          topicdel(m, num)
        end
      end
    end
  end

  def topicsep(m, param)
    do_topicsep(m, param[:text].join(" "))
  end

  def do_topicsep(m, txt)
    ch = m.channel.downcase
    if txt
      sep = txt.strip
      if sep != ""
        setsep(ch, sep)
      end
    end
    m.reply "Topic separator set to #{getsep(ch)}"
  end

  def setsep(ch, sep)
    if @registry.has_key?(ch)
      data = @registry[ch]
    else
      data = Hash.new
    end
    data[:separator] = sep
    @registry[ch] = data
  end

  def getsep(ch)
    if @registry.has_key?(ch)
      if @registry[ch].has_key?(:separator)
        return @registry[ch][:separator]
      end
    end
    return @separator
  end

  def topicaddat(m, num, txt)
    channel = m.channel.downcase
    sep = getsep(channel)
    topic = @bot.channels[m.channel].topic.to_s
    topicarray = topic.split(/\s+#{sep}\s*/)
    topicarray.insert(num, txt)
    newtopic = topicarray.join(" #{sep} ")
    @bot.topic channel, newtopic
  end

  def topicappend(m, txt)
    topicaddat(m, -1, txt)
  end

  def topicprepend(m, txt)
    topicaddat(m, 0, txt)
  end

  def topicdel(m, num)
    channel = m.channel.downcase
    sep = getsep(channel)
    topic = @bot.channels[m.channel].topic.to_s
    topicarray = topic.split(/\s+#{sep}\s*/)
    topicarray.delete_at(num)
    newtopic = topicarray.join(" #{sep} ")
    @bot.topic channel, newtopic
  end

  def learntopic(m, param)
    return if !@bot.auth.allow?("learntopic", m.source, m.replyto)
    channel = m.channel.downcase
    topic = @bot.channels[m.channel].topic.to_s
    if @registry.has_key?(channel)
      data = @registry[channel]
    else
      data = Hash.new
    end
    data[:topic] = topic
    @registry[channel] = data
    m.okay
  end

  def resumetopic(m, param)
    return if !@bot.auth.allow?("resumetopic", m.source, m.replyto)
    channel = m.channel.downcase
    if @registry.has_key?(channel) && @registry[channel].has_key?(:topic)
      topic = @registry[channel][:topic]
      @bot.topic channel, topic
    else
      @bot.say channel, "I don't remember any topic for this channel"
    end
  end

  def topicset(m, param)
    do_topicset(m, param[:text].join(" "))
  end

  def do_topicset(m, text)
    return if !@bot.auth.allow?("topic", m.source, m.replyto)
    channel = m.channel.downcase
    @bot.topic channel, text
  end

end
plugin = TopicPlugin.new
plugin.map 'topic :command *text', :action => 'handletopic'
plugin.map 'settopic *text', :action => 'topicset'
plugin.map 'topicset *text', :action => 'topicset'
plugin.map 'topicsep *text', :action => 'topicsep'
plugin.map 'resumetopic'
plugin.map 'learntopic'