muzang-plugins 1.1.4 → 1.1.5

data/lib/muzang-plugins.rb

@@ -9,3 +9,5 @@ require 'muzang-plugins/muzang-nerdpursuit'
 require 'muzang-plugins/muzang-plusone'
 require 'muzang-plugins/muzang-reddit'
 require 'muzang-plugins/muzang-rubygems'
+require 'muzang-plugins/muzang-soupirc'
+require 'muzang-plugins/muzang-grep'

data/lib/muzang-plugins/muzang-eval.rb

@@ -1,51 +1,56 @@
-module Safe; end
-class << Safe
-   def safe(code, sandbox=nil)
-     error = nil
-
-     begin
-       $-w = nil
-       sandbox ||= Object.new.taint
-       yield(sandbox) if block_given?
-
-       $SAFE = 5
-       value = eval(code, sandbox.send(:binding))
-       result = Marshal.load(Marshal.dump(value))
-     rescue Exception => error
-       error = Marshal.load(Marshal.dump(error))
-     end
-
-     return result, error
-   end
-end
-
-def safe(*args, &block)
-  unless args.first =~ /EM|EventMachine/
-    Safe::safe(*args, &block)
-  end
-end
+module Muzang
+  module Plugins
+    module Safe; end
+    class << Safe
+       def safe(code, sandbox=nil)
+         error = nil
+
+         begin
+           $-w = nil
+           sandbox ||= Object.new.taint
+           yield(sandbox) if block_given?
+
+           $SAFE = 5
+           value = eval(code, sandbox.send(:binding))
+           result = Marshal.load(Marshal.dump(value))
+         rescue Exception => error
+           error = Marshal.load(Marshal.dump(error))
+         end
+
+         return result, error
+       end
+    end
 
-class Eval
-  include Muzang::Plugins::Helpers
+    class Eval
+      include Muzang::Plugins::Helpers
 
-  def initialize(bot)
-    @bot = bot
-  end
+      def initialize(bot)
+        @bot = bot
+      end
 
-  def call(connection, message)
-    on_channel(message) do
-      match(message, /^\% (.*)/) do |match|
-        operation = proc do
-          safe(match[1])
+      def call(connection, message)
+        on_channel(message) do
+          match(message, /^\% (.*)/) do |match|
+            operation = proc do
+              safe(match[1])
+            end
+            callback = proc do |tuple|
+              result, error = tuple
+              connection.msg(message.channel, "#{result}") if result
+              connection.msg(message.channel, "Error: #{error}") if error
+            end
+            EM.defer(operation, callback)
+          end
         end
-        callback = proc do |tuple|
-          result, error = tuple
-          connection.msg(message.channel, "#{result}") if result
-          connection.msg(message.channel, "Error: #{error}") if error
+      end
+
+      def safe(*args, &block)
+        unless args.first =~ /EM|EventMachine/
+          Safe::safe(*args, &block)
         end
-        EM.defer(operation, callback)
       end
     end
   end
 end
 
+

data/lib/muzang-plugins/muzang-google.rb

@@ -0,0 +1,24 @@
+module Muzang
+  module Plugins
+    class Google
+      include Muzang::Plugins::Helpers
+
+      def initialize(bot)
+        @bot = bot
+      end
+
+      def call(connection, message)
+        on_channel(message) do
+          message.message.match(/^(!|@)google (.*?)$/) do |m|
+            http = EventMachine::HttpRequest.new("http://ajax.googleapis.com/ajax/services/search/web").get :query => { :v => "1.0", :q => m[2] }
+            http.callback { 
+              results = JSON.parse(http.response)
+              result  = results["responseData"]["results"].first
+              connection.msg(message.channel, "#{result["url"]} | #{result["titleNoFormatting"]}")
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/muzang-plugins/muzang-grep.rb

@@ -0,0 +1,107 @@
+require 'sqlite3'
+require 'active_record'
+require 'muzang-plugins/muzang-grep/wrttn_in'
+
+module Muzang
+  module Plugins
+    class Grep
+      include Muzang::Plugins::Helpers
+
+      DATABASE_FILE = 'irclog.sqlite3'
+      DATABASE_CONFIG = {
+        :database => 'irclog.sqlite3',
+        :encoding => 'utf8',
+        :adapter => 'sqlite3'
+      }
+
+      class Message < ActiveRecord::Base
+        def self.like(channel, term)
+          find(:all, :conditions => ['channel LIKE ? AND content MATCH ?' , channel, term], :order => 'created_at DESC', :limit => 20)
+        end
+
+        def to_text
+          ["### #{user} @ #{created_at}:", "> #{content}", ''].join("\n")
+        end
+
+        class Migration < ActiveRecord::Migration
+          def self.up
+            execute(%q{
+      CREATE VIRTUAL TABLE messages USING fts4(
+        channel VARCHAR(255) NOT NULL,
+        user VARCHAR(255) NOT NULL,
+        content VARCHAR(2048) NOT NULL,
+        created_at DATETIME NOT NULL);
+      })
+          end
+
+          def self.down
+            drop_table :messages
+          end
+        end
+      end
+
+      def initialize(bot)
+        @bot = bot
+        open_database
+      end
+
+      def call(connection, message)
+        on_channel(message) do
+          match(message, /^[^~(Searched)]/) do
+            persist_message(message)
+          end
+          match(message, /^~ (.*)/) do |what|
+            search_for_term(connection, message, what[1])
+          end
+        end
+      rescue
+        puts $!
+        puts $!.backtrace
+        raise
+      end
+
+      def persist_message(message)
+        Message.create!(:channel => message.channel,
+                        :user => message.user,
+                        :content => message.message)
+      end
+
+      def search_for_term(connection, message, term)
+        results = Message.like(message.channel, term)
+        if results.size > 0
+          link = save_results(term, results)
+          connection.msg(message.channel, "Searched for '#{term}', found #{results.size} matches: #{link}")
+        else
+          connection.msg(message.channel, "Searched for '#{term}', nothing found")
+        end
+      end
+
+      private
+      def open_database
+        initialize_database unless database_exists?
+        open_existing_database
+      end
+
+      def database_exists?
+        File.exists?(DATABASE_FILE)
+      end
+
+      def initialize_database
+        ActiveRecord::Base.establish_connection(DATABASE_CONFIG)
+        Message::Migration.up
+        ActiveRecord::Base.connection.disconnect!
+      end
+
+      def open_existing_database
+        ActiveRecord::Base.establish_connection(DATABASE_CONFIG)
+      end
+
+      def save_results(term, results)
+        content = ["Searched for '#{term}', found #{results.size} matches", '']
+        content += results.map(&:to_text)
+        content = content.join("\n")
+        WrttnIn.create(content).public_url
+      end
+    end
+  end
+end

data/lib/muzang-plugins/muzang-grep/wrttn_in.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+
+class WrttnIn
+  attr_reader :public_url, :content
+
+  def self.create(content, markup = :markdown)
+    post_data = {
+      :content => content,
+      :parser => markup
+    }
+    response = Net::HTTP.post_form(URI.parse('http://wrttn.in/create'), post_data)
+    if response.kind_of?(Net::HTTPRedirection)
+      response_body = Net::HTTP.get(URI.join('http://wrttn.in', response['Location']))
+      if id = response_body.match(/<a href="\/(.*)" class="lab" target="_blank">public url<\/a>/)[1]
+        self.new(id, content)
+      else
+        raise "Couldn't parse the response"
+      end
+    else
+      raise "Couldn't create a post"
+    end
+  end
+
+  def initialize(id, content)
+    @public_url = "http://wrttn.in/#{id}"
+    @content = content
+  end
+end

data/lib/muzang-plugins/muzang-livereload.rb

@@ -1,17 +1,21 @@
-class LiveReload
-  include Muzang::Plugins::Helpers
+module Muzang
+  module Plugins
+    class LiveReload
+      include Muzang::Plugins::Helpers
 
-  def initialize(bot)
-    @bot = bot
-  end
+      def initialize(bot)
+        @bot = bot
+      end
 
-  def call(connection, message)
-    on_channel(message) do
-      match(message, /^!reload$/) do
-        @bot.plugins.each do |plugin, instance|
-          Kernel.load("muzang-plugins/muzang-#{plugin.to_s.downcase}.rb")
-          instance = plugin.new(@bot)
-          connection.msg(message.channel, "Reloading: #{plugin}")
+      def call(connection, message)
+        on_channel(message) do
+          match(message, /^!reload$/) do
+            @bot.plugins.each do |plugin, instance|
+              Kernel.load("muzang-plugins/muzang-#{plugin.to_s.split("::").last.downcase}.rb")
+              instance = plugin.new(@bot)
+              connection.msg(message.channel, "Reloading: #{plugin}")
+            end
+          end
         end
       end
     end

data/lib/muzang-plugins/muzang-meme.rb

@@ -3,99 +3,110 @@ require "json"
 require "memetron"
 require "soup-client"
 
-class Meme
-  include Muzang::Plugins::Helpers
+module Muzang
+  module Plugins
+    class Meme
+      include Muzang::Plugins::Helpers
 
-  MEMES = {
-    dos_equis:    { image_id: 2485,     generator: 74   },
-    y_u_no?:      { image_id: 166088,   generator: 2    },
-    bear_grylls:  { image_id: 89714,    generator: 92   },
-    fry:          { image_id: 84688,    generator: 305  },
-    orly:         { image_id: 117049,   generator: 920  },
-    all:          { image_id: 1121885,  generator: 6013 },
-    obama:        { image_id: 2154021,  generator: 372781 }
-  }
+      MEMES = {
+        dos_equis:    { image_id: 2485,     generator: 74   },
+        y_u_no?:      { image_id: 166088,   generator: 2    },
+        bear_grylls:  { image_id: 89714,    generator: 92   },
+        fry:          { image_id: 84688,    generator: 305  },
+        orly:         { image_id: 117049,   generator: 920  },
+        all:          { image_id: 1121885,  generator: 6013 },
+        obama:        { image_id: 2154021,  generator: 372781 }
+      }
 
-  def initialize(bot)
-    @bot      = bot
-    @matcher  = Memetron::Matcher.new
-    @soup     = File.open(ENV["HOME"] + "/.muzang/" + "soup").read.split(":") rescue nil
-  end
-
-  def call(connection, message)
-    message.message.match(/^meme$/) do
-      connection.msg("#{@bot.channels.first}", "Type 'meme [name of meme] \"Text0\" \"Text1\"'")
-      connection.msg("#{@bot.channels.first}", "Available memes: #{MEMES.keys.join(" ")}")
-    end
-    message.message.match(/^meme (.*?) "(.*?)"( "(.*?)")?$/) do |m|
-      if meme_ids = MEMES[m[1].to_sym]
-        @generator = meme_ids[:generator]
-        @image_id  = meme_ids[:image_id]
-      else
-        return nil
+      def initialize(bot)
+        @bot      = bot
+        @matcher  = Memetron::Matcher.new
+        @soup     = File.open(ENV["HOME"] + "/.muzang/" + "soup").read.split(":") rescue nil
       end
 
-      @text0 = m[2]
-      @text1 = m[4]
-      
-      create_instance(connection)
-    end
-  
-    on_channel(message) do
-      if meme = @matcher.match_and_parse(message.message)
-        @generator = MEMES[meme.first][:generator]
-        @image_id  = MEMES[meme.first][:image_id]
-
-        case meme.first
-          when :dos_equis
-            @text0 = "I don't always #{meme[1][0]}"
-            @text1 = "but when I do #{meme[1][1]}"
-          when :y_u_no?
-            @text0 = meme[1][0] + " Y U NO"
-            @text1 = meme[1][1]
-          when :bear_grylls
-            @text0 = meme[1][0]
-            @text1 = "better drink my own piss"
-          when :fry
-            @text0 = "not sure if #{meme[1][1]}"
-            @text1 = "or #{meme[1][2]}"
-          when :orly
-            @text0 = meme[1][0]
-            @text1 = "ORLY?"
-          when :all
-            @text0 = meme[1][0]
-            @text1 = "all the things!"
-          when :obama
-            @text0 = meme[1][0]
-            @text1 = "not bad"
-          else
-            @text0 = meme[1][0]
-            @text1 = meme[1][1]
+      def call(connection, message)
+        message.message.match(/^meme$/) do
+          connection.msg("#{@bot.channels.first}", "Type 'meme [name of meme] \"Text0\" \"Text1\"'")
+          connection.msg("#{@bot.channels.first}", "Available memes: #{MEMES.keys.join(" ")}")
         end
+        message.message.match(/^meme (.*?) "(.*?)"( "(.*?)")?$/) do |m|
+          if meme_ids = MEMES[m[1].to_sym]
+            @generator = meme_ids[:generator]
+            @image_id  = meme_ids[:image_id]
+          else
+            return nil
+          end
+
+          @text0 = m[2]
+          @text1 = m[4]
+          
           create_instance(connection)
         end
-    end 
-  end
+      
+        on_channel(message) do
+          if meme = @matcher.match_and_parse(message.message)
+            @generator = MEMES[meme.first][:generator]
+            @image_id  = MEMES[meme.first][:image_id]
+
+            case meme.first
+              when :dos_equis
+                @text0 = "I don't always #{meme[1][0]}"
+                @text1 = "but when I do #{meme[1][1]}"
+              when :y_u_no?
+                @text0 = meme[1][0] + "Y U NO"
+                @text1 = meme[1][1]
+              when :bear_grylls
+                @text0 = meme[1][0]
+                @text1 = "better drink my own piss"
+              when :fry
+                @text0 = "not sure if #{meme[1][1]}"
+                @text1 = "or #{meme[1][2]}"
+              when :orly
+                @text0 = meme[1][0]
+                @text1 = "ORLY?"
+              when :all
+                @text0 = meme[1][0]
+                @text1 = "all the things!"
+              when :obama
+                @text0 = meme[1][0]
+                @text1 = "not bad"
+              else
+                @text0 = meme[1][0]
+                @text1 = meme[1][1]
+            end
+              create_instance(connection)
+            end
+        end 
+      end
 
-  def create_instance(connection)
-    http = EventMachine::HttpRequest.new('http://version1.api.memegenerator.net/Instance_Create')
-           .get(:query => {:username => 'drug-bot',
-                           :password => 'drug-bot',
-                           :languageCode => 'en',
-                           :generatorID => @generator,
-                           :imageID => @image_id,
-                           :text0 => @text0,
-                           :text1 => @text1})
+      def create_instance(connection)
+        http = EventMachine::HttpRequest.new('http://version1.api.memegenerator.net/Instance_Create')
+               .get(:query => {:username => 'drug-bot',
+                               :password => 'drug-bot',
+                               :languageCode => 'en',
+                               :generatorID => @generator,
+                               :imageID => @image_id,
+                               :text0 => @text0,
+                               :text1 => @text1})
 
-    http.callback {
-      meme = JSON.parse(http.response)
-      url = "http://version1.api.memegenerator.net#{meme['result']['instanceImageUrl']}"
-      connection.msg("#{@bot.channels.first}", "Meme: #{url}")
-      if @soup
-        soup = Soup::Client.new(@soup.first, @soup.last.chomp)
-        soup.login
-        soup.new_image(url)
+        http.callback {
+          meme = JSON.parse(http.response)
+          instance = meme['result']['instanceImageUrl']
+
+          if instance.include?("images")
+            url = instance
+          else
+            url = "http://iversion1.api.memegenerator.net#{instance}"
+          end
+
+          connection.msg("#{@bot.channels.first}", "Meme: #{url}")
+          if @soup
+            soup = Soup::Client.new(@soup.first, @soup.last.chomp)
+            soup.login
+            soup.new_image(url)
+          end
+        }
       end
-    }
+    end
   end
 end