201 lines
5.1 KiB
Ruby
201 lines
5.1 KiB
Ruby
require 'cinch'
|
|
require 'uri'
|
|
require 'open-uri'
|
|
require_relative '../classes/Util.rb'
|
|
require_relative '../classes/Markov.rb'
|
|
class Markovian
|
|
include Cinch::Plugin
|
|
include Hooks::ACLHook
|
|
include Util::PluginHelper
|
|
set :prefix, /^:/
|
|
@clist = %w{markov}
|
|
@@commands["markov"] = ":markov <length> <seed>- generates a markov chain of <length> words, starting with optional word <seed>"
|
|
@@commands["chainsaw"] = ":chainsaw <url> - grabs the text at <url> and chainsaws it to death!!!"
|
|
match /markov$/, method: :markov
|
|
match /markov (\d+)$/, method: :markov
|
|
match /markov (\d+) ([\w ]+)$/, method: :markov
|
|
match /chainsaw (.+)/, method: :chainsaw
|
|
listen_to :channel
|
|
|
|
def listen(m)
|
|
return if m.message.match /^:/
|
|
text = m.message
|
|
user = m.user.nick
|
|
if(!(["sayok","g1mp","van","durnkb0t", "[0]"].include? user))
|
|
process(text,user)
|
|
end
|
|
end
|
|
|
|
def process(text,user=nil)
|
|
#puts "Markovian\n\t#{user}: #{text}"
|
|
mkv = Markovin8or.new(2)
|
|
db = Util::Util.instance.getCollection("markov","ngrams")
|
|
|
|
re = /[^a-z0-9' ]/i
|
|
[
|
|
[URI.regexp, ''],
|
|
[re, ''],
|
|
[/\s+/, ' '],
|
|
[/\b[^\sai5h]\b/i, ''],
|
|
].each { |args| text = text.gsub *args }
|
|
puts "text: #{text}"
|
|
chains = mkv.chain(text)
|
|
mkvs = mkv.mongoize
|
|
mkvs.each { |hash|
|
|
#next if hash["head"] == nil
|
|
#hash["user"] = user
|
|
#hash["server"] = Util::Util.instance.hton("#{m.bot.config.server}:#{m.bot.config.port}")
|
|
#p hash
|
|
if(db.find({head: hash["head"]}).count > 0)
|
|
#puts "#{hash["head"]} found"
|
|
hash["tails"].each { |tail|
|
|
if(tail != nil)
|
|
db.update_one(
|
|
{head: hash["head"]},
|
|
{'$push' =>
|
|
{ tails: tail
|
|
}
|
|
}
|
|
)
|
|
end
|
|
}
|
|
else
|
|
#puts "#{hash["head"]} not found (#{hash["tails"].inspect})"
|
|
val = db.insert_one(hash)
|
|
end
|
|
#p val
|
|
if(val)
|
|
#puts "success :: #{hash}"
|
|
else
|
|
#puts "failure :: #{hash}"
|
|
end
|
|
}
|
|
end
|
|
|
|
def markov(m,length=nil,seed=nil)
|
|
out = start(m,seed,length == nil ? length : length.to_i)
|
|
puts "markov out:\n\t#{out}"
|
|
m.reply(out)
|
|
|
|
end
|
|
def chainsaw(m, url)
|
|
#uri = URI.parse url rescue nil
|
|
begin
|
|
uri=URI(url)
|
|
rescue URI::InvalidURIError
|
|
e = Util::Util.instance.getExcuse()
|
|
m.reply("#{m.user.nick}: #{e} [that clearly wasn't a url brah]")
|
|
return 0
|
|
end
|
|
if(uri.nil?)
|
|
e = Util::Util.instance.getExcuse()
|
|
m.reply("#{m.user.nick}: #{e} (that URL you provided was SUS AF bruh)")
|
|
return 0
|
|
end
|
|
content = ""
|
|
open(url) do |f|
|
|
content = f.read
|
|
content.gsub!(%r{</?[^>]+?>}, '')
|
|
end
|
|
e = Util::Util.instance.getSuccess()
|
|
m.reply("#{m.user.nick}: chainsaw engaged on #{url} ...")
|
|
begin
|
|
process(content)
|
|
ensure
|
|
m.reply("#{m.user.nick}: #{e} (CHAINSAW SUCCESSFUL!)")
|
|
end
|
|
|
|
end
|
|
def getRandomRow(seed = nil)
|
|
db = Util::Util.instance.getCollection("markov","ngrams")
|
|
ret = nil
|
|
while ret.nil?
|
|
if(seed == nil)
|
|
cnt = db.find().count()
|
|
ret = db.find().limit(-1).skip(rand(cnt)).to_a
|
|
else
|
|
ret = getRow(seed)
|
|
end
|
|
end
|
|
puts "ret is: " + ret.inspect
|
|
return ret
|
|
end
|
|
|
|
def start(m, seed=nil, words=nil)
|
|
db = Util::Util.instance.getCollection("markov","ngrams")
|
|
res = ""
|
|
if(words == nil)
|
|
words = (4+rand(24).to_i)
|
|
end
|
|
words = words > 256 ? 256 : words
|
|
#puts "begin markov chainsaw"
|
|
#puts "start.count: #{words}, start.seed: #{seed}"
|
|
if seed != nil
|
|
seed.strip!
|
|
else
|
|
tmp = getRandomRow().shift
|
|
puts "tmp = " + tmp.inspect
|
|
seed = tmp["head"]
|
|
end
|
|
out = ""
|
|
if(seed.match(/ /))
|
|
a = seed.split(/ /)
|
|
seed = a.pop
|
|
out = a.join(" ") << " "
|
|
end
|
|
|
|
i = 0
|
|
head = ""
|
|
tails = []
|
|
tail=""
|
|
sentences = []
|
|
sentence=[]
|
|
while i < words
|
|
#puts i
|
|
addP = false
|
|
loop do
|
|
row = getRandomRow(seed)
|
|
if(row.kind_of?(Array))
|
|
row = row.shift
|
|
end
|
|
#puts "new row #{row.inspect}"
|
|
head = row["head"]
|
|
tails = row["tails"]
|
|
tail = tails[rand(tails.count())]
|
|
test = row.nil? or !row.key?("head") or row["head"].nil? or row["head"] == "" or tails.nil? or tail.nil?
|
|
#puts "new row: #{row.inspect}"
|
|
#puts "test: #{test.inspect}"
|
|
if test
|
|
puts "ADDD THAT PPPP"
|
|
addP = true
|
|
else
|
|
break
|
|
end
|
|
# puts "heaheahea"
|
|
end
|
|
#next if n == nil
|
|
#puts "\t#{head} -> #{n}"
|
|
sentence.push(head)
|
|
out += "#{head} "
|
|
seed = tail
|
|
#puts "\trow: "
|
|
#p row
|
|
#puts "out: #{out}"
|
|
if addP
|
|
sentences.push(sentence)
|
|
sentence = []
|
|
end
|
|
i+=1
|
|
end
|
|
if sentence.count
|
|
sentences.push(sentence)
|
|
end
|
|
return sentences.map { |e| e.join " " }.join(". ")
|
|
end
|
|
def getRow(head)
|
|
db = Util::Util.instance.getCollection("markov","ngrams")
|
|
res = db.find({'head' => head}).to_a
|
|
return res[0]
|
|
end
|
|
end
|