zetabot 0.0.1

data/lib/Zeta/plugins/gif.rb

@@ -0,0 +1,73 @@
+require 'open-uri'
+require 'nokogiri'
+require 'json'
+
+module Plugins
+  class Gif
+    include Cinch::Plugin
+    include Cinch::Helpers
+    enable_acl
+
+    # Author: blahed (https://github.com/blahed/gifbot)
+    self.plugin_name = 'GIF'
+    self.help = '?randomgif | ?rgif | ?gifme <query>'
+
+    def initialize(*args)
+      super
+      @imgurray = []
+      @last_update = Time
+    end
+
+    match 'randomgif', method: :imgif
+    match 'rgif', method: :imgif
+    match 'imgif', method: :imgif
+    def imgif(msg)
+      msg.reply "IMGUR↦ #{imgur}"
+    end
+
+    match /gifme (.+)/, method: :gifme
+    def gifme(msg,query)
+      msg.reply "GB↦ #{search(query)}"
+    end
+
+    private
+
+    def search(query)
+      url = URI.encode "http://www.gifbin.com/search/#{query}/"
+      doc = Nokogiri::HTML( open(url) )
+      e = doc.css('.thumbs li').length
+      return "No Results Found" if e == 0
+      result = doc.css('.thumbs li')[rand(e)].css('a img').attribute('src').text.gsub(/tn_/, '')
+      "http://www.gifbin.com#{result}"
+    end
+
+    def gifbin
+      url = URI.encode 'http://www.gifbin.com/random'
+      doc = Nokogiri.HTML(open url)
+      doc.css('div#gifcontainer a img').attribute('src').text
+    end
+
+    def imgur
+      # Cache results for 1 hour
+      if @imgurray.empty? || @last_update >= (Time.now + 3600)
+        url = URI.encode('http://reddit.com/r/gifs.json')
+        doc = JSON.load(open(url))
+
+        doc['data']['children'].each_with_index do |post, index|
+          if doc['data']['children'][index]['data']['url'].to_s =~ /imgur/
+            @imgurray << doc['data']['children'][index]['data']['url'].to_s
+          end
+        end
+        @last_update = Time.now
+        @imgurray.sample
+      else
+        @imgurray.sample
+      end
+
+    end
+
+  end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Gif

data/lib/Zeta/plugins/help.rb

@@ -0,0 +1,32 @@
+module Plugins
+  class BotHelp
+    include Cinch::Plugin
+    include Cinch::Helpers
+    enable_acl
+
+    set(
+        plugin_name: "BotHelp",
+        help: "Need help?.\nUsage: `?help`\nUsage: `?help [plugin]` `?help plugins`",
+    )
+    match /help (.+)$/i, method: :execute_help
+
+    def execute_help(m, name)
+      list = {}
+      @bot.plugins.each { |p| list[p.class.plugin_name.downcase] = {name: p.class.plugin_name, help: p.class.help} };
+      return m.user.notice("Help for \"#{name}\" could not be found.") unless list.has_key?(name.downcase)
+      m.user.notice("Help for #{Format(:bold, list[name.downcase][:name])}:\n#{list[name.downcase][:help]}")
+    end
+
+    match 'help', method: :execute_list
+    def execute_list(m)
+
+      list = []
+      @bot.plugins.each {|p| list << p.class.plugin_name };
+      m.user.notice("All #{list.size} currently loaded plugins for #{@bot.nick}:\n#{list.to_sentence}.\nTo view help for a plugin, use `!help <plugin name>`.")
+    end
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::BotHelp

data/lib/Zeta/plugins/libsecure.rb

@@ -0,0 +1,34 @@
+require 'uri'
+require 'net/http'
+require 'ostruct'
+require 'discourse_api'
+require 'action_view'
+
+module Plugins
+  class Libsecure
+    include Cinch::Plugin
+    include Cinch::Helpers
+    include ActionView::Helpers::DateHelper
+
+    enable_acl(:nobody)
+
+    self.plugin_name = 'DarkScience #libsecure'
+    self.help = '?latest'
+
+    match 'latest', method: :fetch_latest
+
+    def fetch_latest(m)
+      return unless m.channel == '#libsecure' || m.channel == '#bots'
+
+      client = DiscourseApi::Client.new('https://libsecure.so', Config.secrets[:libsecure], Config.secrets[:libsecure_user] )
+      parser = client.latest_topics.sort_by { |hash| hash['last_posted_at'] }
+      data = parser.last
+
+      m.reply "Latest → #{data['title']} -- https://libsecure.so/t/#{data['id']}"
+    end
+
+  end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Libsecure

data/lib/Zeta/plugins/macros.rb

@@ -0,0 +1,124 @@
+# coding: utf-8
+require 'yaml'
+
+module Plugins
+  class Macros
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl(:nobody, false)
+
+    attr_reader :macros
+
+    set plugin_name: "Macros", help: "Macro's are prefixed by a <dot> example .dnf",
+        react_on: :channel
+
+    def initialize *args
+      super
+      # @macros = YAML::load_file($root_path + '/locales/macros.yml')
+      @macros = load_locale 'macros'
+    end
+
+    match /reload/, method: :execute_reloadmacros, react_on: :private
+    def execute_reloadmacros m
+      return unless check_user(m, :admin)
+      # return unless check_channel(m)
+      begin
+        # @macros = YAML::load_file($root_path + '/locales/macros.yml')
+        @macros = load_locale 'macros'
+        m.user.notice "Macros have been reloaded."
+      rescue
+        m.user.notice "Reloading macros has failed: #{$!}"
+      end
+    end
+
+    match /m (\w+)(?: (.+))?/, method: :execute_macro, group: :macro
+    def execute_macro m, macro, arguments
+      return unless @macros.has_key?(macro)
+      parse(arguments.to_s.rstrip, @macros[macro], m.channel, m.user)
+
+
+      # Guide to writing macros:
+      # - A macro can be a string, hash, or array
+      # - They can be embedded within each other (as lines, etc.)
+      # To have options for a macro (either globally or within embedded macros:)
+      # => macroname:
+      # =>   type: (string) ['random'] (optional)
+      # =>   sent_as: (string) ['reply','action'] (optional)
+      # =>   sleep: (numeric) a number that represents how many seconds the bot will wait for each line
+      # =>   lines: (array, string, hash) an object that represents the individual lines.
+
+      # Guide to writing macros v3 templates:
+      # transform/(default text)[template]
+      # transform/ (optional):
+      #   cap (all uppercase)
+      #   lc (all lowercase)
+      # (default text) (optional):
+      #   Can be anything that you want. May want to watch usage of brackets &c.
+      # [template] (required):
+      #   Can be one of these tags:
+      #   * in (input/argument, will default to the default text if available, otherwise it will choose a random nick.)
+      #   * channel (the current channel that the command is run in.)
+      #   * bot (The bot's nick)
+      #   * self (the originating user's nick)
+    end
+
+    private
+
+    # @param [String,NilClass] input The arguments for the command.
+    # @param [String,Hash,Array] macro The macro object.
+    # @param [Channel] channel The target channel.
+    # @param [Users] user The user that activated the macro.
+    # @param [Hash] params The (optional) parameters for controlling the macro as set in the external resource.
+    # @option params [String,NilClass] 'type' The type of output. Can be either nil, or "random"
+    # @option params [String] 'sent_as' The method of sending the line. Can be either 'reply' or 'action'
+    # @option params [Numeric,NilClass] 'sleep' How long does the bot wait to send the line?
+    def parse(input, macro, channel, user, params={})
+      params = { 'type' => nil, 'sent_as' => 'reply', 'sleep' => nil }.merge params
+
+      if macro.respond_to? :has_key?
+        lines = macro['lines']
+        params = params.merge macro.reject {|k,_| k.eql? 'lines' }
+        lines = lines.sample if params['type'].eql?('random') && lines.respond_to?(:each)
+        parse(input, lines, channel, user, params)
+      elsif macro.respond_to? :each
+        macro.each {|line| parse(input, line, channel, user, params) }
+      else
+        sleep params['sleep'] if params['sleep']
+        case params['sent_as']
+        when 'action' then channel.action replace_tokens(input, macro.to_s, channel, user)
+        else
+          channel.send replace_tokens(input, macro.to_s, channel, user)
+        end
+      end
+    end
+
+    # @see #parse (sans params)
+    def replace_tokens(input, macro, channel, user)
+      tokens = macro.scan(/((?:(\w+)\/)?(?:\((.+?)\))?(?:\[(\w+)\]))/)
+      tokens.each_with_object(macro.dup) {|(token,transform,default,template), memo|
+        result = case template
+        when 'in' then input || default || channel.users.keys.sample.nick
+        when 'bot' then @bot.nick
+        when 'channel' then channel.name
+        when 'self' then user.nick
+        else token
+        end
+
+        result = case transform
+        when 'cap' then result.upcase
+        when 'lc' then result.downcase
+        else result
+        end
+
+        memo.sub!(token, result)
+      }
+    end
+
+
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Macros

data/lib/Zeta/plugins/movie.rb

@@ -0,0 +1,67 @@
+module Plugins
+  class Movie
+    include Cinch::Plugin
+    include Cinch::Helpers
+
+    enable_acl
+
+    set(
+     plugin_name: 'Movie',
+     help: 'Movie Plots \nUsage: `?movie <name of movie>`;',
+     react_on: :channel
+    )
+
+    match /movie (.*)/, method: :find_movie
+    def find_movie(m, movie)
+      data = query_movie(movie)
+      if data && data.response == 'True'
+        m.reply "Movie ⊥ #{data.title} (#{data.year}) <#{data.rated}> #{data.plot.to_s.strip[0..800]} [www.imdb.com/title/#{data.imdbid}/]"
+      elsif data && data.response == 'False'
+        m.reply data.error
+      else
+        m.reply 'Unable to find movie!'
+      end
+    end
+
+    private
+    def query_movie(m)
+      year = m[/:\d+/].gsub(/:/, '') if m[/:\d+/]
+      movie = URI.encode(m.gsub(/:\d+/, ''))
+      data = JSON.parse(
+          # RestClient.get("http://www.omdbapi.com/?t=#{movie}&y=#{year}")
+          open("http://www.omdbapi.com/?t=#{movie}&y=#{year}").read
+      )
+      OpenStruct.new(
+          title:       data['Title'],
+          year:        data['Year'],
+          rated:       data['Rated'],
+          released:    data['Released'],
+          runtime:     data['Runtime'],
+          genre:       data['Genre'],
+          director:    data['Director'],
+          writer:      data['Writer'],
+          actors:      data['Actors'],
+          plot:        data['Plot'],
+          language:    data['Language'],
+          country:     data['Country'],
+          awards:      data['Awards'],
+          poster:      data['Poster'],
+          metascore:   data['Metascore'],
+          imdbrating:  data['imdbRating'],
+          imdbvotes:   data['imdbVotes'],
+          imdbid:      data['imdbID'],
+          type:        data['Type'],
+          response:    data['Response'],
+          error:       data['Error']
+      )
+    rescue
+      nil
+    end
+
+
+  end
+end
+
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Movie

data/lib/Zeta/plugins/pdfinfo.rb

@@ -0,0 +1,69 @@
+require 'faraday'
+require 'open-uri'
+require 'action_view'
+require 'pdf-reader'
+require 'humanize-bytes'
+
+module Plugins
+  class PDFinfo
+    include Cinch::Plugin
+    include Cinch::Helpers
+    include ActionView::Helpers::DateHelper
+
+    enable_acl(:nobody, false)
+
+    self.plugin_name = 'PDF Information'
+    self.help = 'This plugin will check a url for a pdf link and fetch metadata from it'
+
+
+    # Default list of URL regexps to ignore.
+    DEFAULT_ALLOWED = [/\.pdf$/i].freeze
+    FILE_SIZE_LIMIT = 4000000
+
+
+    match %r{(https?://.*?)(?:\s|$|,|\.\s|\.$)}, :use_prefix => false
+
+    def execute(msg, url)
+
+      allowedlist = DEFAULT_ALLOWED.dup
+      allowedlist.concat(config[:blacklist]) if config[:blacklist]
+
+      return unless allowedlist.any? { |entry| url =~ entry }
+      debug "URL matched: #{url}"
+
+      # Grab header and check filesize
+      # one line to make request
+      head = Faraday.head url
+
+      # example with headers
+      file_size = head.headers['Content-Length']
+      humanize_size = Humanize::Byte.new(file_size.to_i).to_k.to_s.to_i.round(2)
+      if file_size.to_i > FILE_SIZE_LIMIT
+        return msg.reply("PDF → Unable to parse. file too big #{humanize_size}kb")
+      end
+
+
+      # Get file and parse metadata
+      open(url, "rb") do |io|
+        reader = PDF::Reader.new(io)
+        creator = reader.info[:Creator] || 'Anon'
+        producer = reader.info[:Producer] || 'Anon'
+        creation = reader.info[:CreationDate] || 'now'
+        modification = reader.info[:ModDate] || 'now'
+        title = reader.info[:Title] || nil
+        display = title ? title : "Title: None <> Creator: #{creator} <> Producer: #{producer} <> Creation: #{creation}"
+        msg.reply "PDF (#{humanize_size}kb) → #{display}"
+      end
+
+
+    rescue => e
+      error "#{e.class.name}: #{e.message}"
+    end
+
+
+  end
+
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::PDFinfo

data/lib/Zeta/plugins/rainbow.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+class String # moved from lib\obj_ext\string.rb
+  def irc_colorize
+    self.gsub(/!\[(.*?)\]/) { $1.tr('boruic', 2.chr + 15.chr + 18.chr + 31.chr + 29.chr + 3.chr) }
+    #Note to self, tr and gsub is your friend!
+    #Thanks to j416 on #ruby@freenode!
+  end
+end
+
+
+module Plugins
+  class Rainbow
+    include Cinch::Plugin
+    include Cinch::Helpers
+    enable_acl
+
+    set plugin_name: "Rainbow", help: "Rainbowificates your text.\nUsage: `?rainbow [text]`.\nUsage: `?eyerape [text]`.", suffix: /$/
+
+    def rainbowification(s)
+      s.gsub(/\x03([0-9]{2}(,[0-9]{2})?)?/, "") # Because total function abuse.
+      colour = %w{04 07 08 09 10 06 13}
+      i = Random.new.rand(0..colour.size-1);
+      new_string = ""
+      s.each_char { |c|
+        new_string << "\x03#{colour[i]}#{c}";
+        i = i < colour.size-1 ? i.next : 0;
+      }
+      new_string
+    end
+
+    def eyerapeification(s)
+      sd = s.dup
+      sd.gsub(/\x03([0-9]{2}(,[0-9]{2})?)?/, "") # Because total function abuse.
+      colour = %w{04 07 08 09 10 06 13}
+      offset = Random.new.rand(0..colour.size-1)
+      sd = "\x02" + sd.upcase.split(" ").map { |c|
+        offset = (offset < colour.size-1 ? offset.next : 0)
+        "\x03#{colour[offset]},#{colour[offset-4]}#{c.each_char.each_with_index.map { |char, index| index % 2 == 0 ? char : char.downcase }.join}"
+      }.join(" ")
+      #sd
+    end
+
+    match /rainbow (.+)/, method: :execute_rainbow
+
+    def execute_rainbow(m, string)
+      m.reply(rainbowification(string), false)
+    end
+
+
+
+    match /eyerape (.+)/, method: :execute_eyerape
+
+    def execute_eyerape(m, string)
+      m.reply(eyerapeification(string), false)
+    end
+
+
+  end
+end
+
+# AutoLoad
+Bot.config.plugins.plugins.push Plugins::Rainbow
+
+