october 0.1.1

data/plugins/issues.rb

@@ -0,0 +1,161 @@
+require 'github_api'
+
+class Issues
+  include October::Plugin
+
+  self.prefix = /^!issues? /
+  register_help 'issue create title', 'create issue'
+  register_help 'issue create title | body', 'create issue with body'
+  register_help 'issue create title | milestone: 2', 'create issue for milestone'
+  register_help 'issue create title | assign: someone', 'create assigned issue'
+  register_help 'issue create title | assign: someone | body | milestone: 3', 'combined approach to create issue'
+  register_help 'issue convert number head => base', 'convert issue to pull request'
+  register_help 'pull head => base', 'creates a new pull request'
+
+  GIT = /[a-z0-9]{7}|[a-z0-9]{40}/
+  match /create (.+)$/, method: :create
+  match /convert (\d+) (.+?)\s*=>\s*(.+)$/, method: :convert
+  match /(?:issue\s+)?#(\d+)/, method: :issue, use_prefix: false
+  match /commit ([a-z0-9]{7}|[a-z0-9]{40})(?:[^a-z0-9]|$)/, method: :commit, use_prefix: false
+  match /pull (.+?)\s*=>\s*(.+)$/, method: :pull, use_prefix: false
+
+  def create(m, text)
+    issue = Retryable.do { api.issues.create(nil, nil, IssueParser.new(text).by(m.user.nick).to_hash) }
+    m.reply "created issue #{issue.number} - #{issue.html_url}"
+  rescue Github::Error::UnprocessableEntity => e
+    m.user.msg "Creation failed: "  + e.message
+  end
+
+  def pull(m, head, base)
+    pull = Retryable.do { api.pull_requests.create(nil, nil, :head => head, :base => base, :title => head) }
+    m.reply "Simba, there is a new pull request! #{pull.html_url}"
+  rescue Github::Error::UnprocessableEntity => e
+    m.user.msg "Creation failed: "  + e.message
+  end
+
+  def convert(m, number, head, base)
+    pull = Retryable.do { api.pull_requests.create nil, nil, :issue => number, :head => head, :base => base }
+    m.reply "Simba, there is a new pull request! #{pull.html_url}"
+  rescue Github::Error::UnprocessableEntity => e
+    m.user.msg "Converting failed: "  + e.message
+  end
+
+  def issue(m, number)
+    if issue = Retryable.do { api.issues.find(api.user, api.repo, number) }
+      m.reply "#{issue.html_url} - #{issue.title}"
+    end
+  rescue Github::Error::UnprocessableEntity => e
+    m.user.msg "Issue failed: "  + e.message
+  end
+
+  def commit(m, rev)
+    commit = Retryable.do { api.git_data.commit nil, nil, rev }
+    m.reply "https://github.com/#{api.user}/#{api.repo}/commit/#{commit.sha} by #{commit.author.name}"
+  rescue Github::Error::ResourceNotFound
+    m.user.msg "sorry, but commit #{rev} was not found"
+  end
+
+  def comment(m, number, message)
+    Retryable.do { api.issues.comments.create(api.user, api.repo, number, "body" => message)}
+  rescue Github::Error::ResourceNotFound
+    m.user.msg "sorry, but an error occurred while posting your comment"
+  end
+
+  # this method is used by the hudson plugin to figure out if a branch matches a pull request
+  def pull_request(m, branch_name)
+     pulls = Retryable.do { api.pull_requests.list(api.user, api.repo)}
+     pulls.detect do |pr|
+       full_pr = Retryable.do { api.pull_requests.find(api.user, api.repo, pr["number"]) }
+       return full_pr if full_pr["head"]["ref"] == branch_name
+     end
+     nil
+  rescue Github::Error::ResourceNotFound
+    m.user.msg "sorry, but an error occurred while fetching your pull request"
+  end
+
+  private
+
+  def config
+    self.class.config.symbolize_keys
+  end
+
+  def api
+    @api ||= Github.new config
+  end
+
+  class Retryable
+    attr_reader :attempts
+
+    def initialize(attempts = 2, &block)
+      @attempts = attempts
+      @block = block
+    end
+
+    def run!
+      attempts.times do |attempt|
+        value = @block.call(attempt + 1)
+        return value if value
+      end
+    end
+
+    def self.do &block
+      new(&block).run!
+    end
+  end
+
+  class IssueParser
+    def initialize(text)
+      @text = text
+    end
+
+    def tokens
+      @tokens ||= @text.split('|').map(&:strip)
+    end
+
+    def parse(name)
+      [tokens.find{ |t| t =~ /^#{name}:\s*(.+)$/ }, $1]
+    end
+
+    def attr(name)
+      parse(name).last
+    end
+
+    def token(name)
+      parse(name).first
+    end
+
+    def milestone
+      attr(:milestone)
+    end
+
+    def title
+      tokens.first
+    end
+
+    def by(user)
+      @user = user
+      self
+    end
+
+    def body
+      except = [token(:milestone), token(/assigne{2}?/), title]
+      tokens.find {|t| not except.include?(t) }
+    end
+
+    def assignee
+      attr(/assigne{2}?/)
+    end
+
+    def to_hash(user = @user)
+      text = body ? body.dup : ""
+      text += "\nrequested by: #{user}" if user
+      {
+        title: title,
+        body: text,
+        milestone: milestone,
+        assignee: assignee
+      }
+    end
+  end
+
+end

data/plugins/joke.rb

@@ -0,0 +1,32 @@
+gem 'typhoeus'
+gem 'json'
+
+class Joke
+  include October::Plugin
+  API_URL = "http://api.icndb.com/jokes/random?firstName=<first_name>&lastName=<last_name>"
+  HYDRA = Typhoeus::Hydra.new
+
+  match /joke(?: (\S+)(?: (\S+))?)?$/, method: :joke
+
+  register_help 'joke [first_name] [last_name]', 'Tells you a joke. Chuck Norris style!'
+  def joke(m, first_name = nil, last_name = nil)
+    first_name ||= m.user.nick
+
+    joke = request(first_name, last_name)
+    m.reply joke["value"]["joke"]
+  end
+
+
+  private
+
+  def request(first_name, last_name)
+    url = API_URL.dup
+    url.sub! "<first_name>", first_name.to_s
+    url.sub! "<last_name>", last_name.to_s
+
+    response = Typhoeus::Request.get(url)
+
+    JSON.parse(response.body)
+  end
+
+end

data/plugins/links.rb

@@ -0,0 +1,42 @@
+gem 'redis-objects'
+
+class Links
+  autoload :Link, 'links/link'
+
+  include October::Plugin
+
+  self.prefix = /^!links?(?:\s+)?/
+
+  match /add\s+(\S+)(?:\s+)?(.+)?$/, method: :add
+  match /rem(?:ove)?\s+(\d+)$/, method: :remove
+  match /list/, method: :list
+  match '', method: :list
+
+  register_help 'link[s] add uri [description]', 'add uri to database with optional description'
+  register_help 'link[s] [list]', 'list all saved links in this scope (channel of nick)'
+  register_help 'link[s] rem[ove] id', 'remove specific link'
+
+  def add m, url, desc = nil
+    link = Link.create url, scope(m), description: desc, user: m.user.nick
+    m.reply 'Link added'
+  end
+
+  def remove m, id
+    link = Link.find(id, scope(m))
+    if link and link.remove
+      m.reply "Link #{id} removed"
+    else
+      m.reply "Link #{id} not found"
+    end
+  end
+
+  def list m
+    links = Link.list scope(m)
+    m.reply links.map(&:to_list).join("\n")
+  end
+
+  private
+  def scope(message)
+    message.channel or message.user.nick or raise 'no scope'
+  end
+end

data/plugins/links/link.rb

@@ -0,0 +1,68 @@
+class Links
+  class Link
+    include Redis::Objects
+    value 'url'
+    hash_key 'metadata'
+
+    attr_reader :id, :scope
+
+    def initialize id, scope = nil
+      @id = id
+      @scope = scope.dup.freeze if scope
+    end
+    alias :meta :metadata
+
+    def description
+      meta[:description]
+    end
+
+    def user
+      meta[:user]
+    end
+
+    def to_list
+      %{#{id}) #{url} #{description} by #{user}}
+    end
+
+    def remove
+      $redis.srem(scope, id)
+    end
+
+    class << self
+
+      def find id, scope = nil
+        if scope = links(scope)
+          Link.new(id, scope) if $redis.sismember(scope, id)
+        else
+          Link.new(id)
+        end
+      end
+
+      def list scope
+        ids = $redis.smembers links(scope)
+        ids.map { |id| Link.find(id) }
+      end
+
+      def links(scope)
+        "links:#{scope}" if scope
+      end
+
+      def create(url, scope, metadata = {})
+        metadata.reverse_merge! :timestamp => Time.now
+        metadata.symbolize_keys!
+        metadata.select!{ |k,v| v.present? }
+
+
+        id = $redis.incr 'links'
+        link = Link.new(id)
+
+        link.url = url
+        link.metadata.bulk_set metadata
+        $redis.sadd links(scope), id
+        link
+      end
+
+
+     end
+  end
+end

data/plugins/service.rb

@@ -0,0 +1,11 @@
+class Service
+  include October::Plugin
+  register_help 'guys [msg]', 'focuses all users in channel'
+
+   match /guys(\s+.+?)?$/, method: :guys
+
+   def guys(m, msg)
+     users = m.channel.users.keys.reject{|u| u == bot }
+     m.reply [users.join(', '), msg].compact.join(':')
+   end
+end

data/plugins/update.rb

@@ -0,0 +1,79 @@
+class Update
+  include October::Plugin
+
+  match /selfupdate$/, method: :selfupdate
+  match /seppuku$/, method: :seppuku
+  match /spawn (.+)$/, method: :spawn
+  match /kill (-9 )?(.+)$/, method: :kill
+  match /running$/, method: :running
+  match /run (.+)$/, method: :run
+
+  $SPAWNS = []
+
+  def selfupdate(m)
+    m.user.msg "starting selfupdate..."
+    `git fetch origin`
+    `git reset --hard origin/master`
+    m.user.msg "installing gems..."
+    `bundle install`
+    m.user.msg "done!"
+
+    sleep(2)
+
+    seppuku(m)
+  end
+
+  def seppuku(m)
+    m.reply("bye... AGRG!! ahh...")
+    sleep(1)
+    exit(0)
+  end
+
+  def running(m)
+    m.reply "running processes: #{$SPAWNS.join(", ")}"
+  end
+
+  def kill(m, kill, pid)
+    pid = pid.to_i
+
+    signal = kill ? 'KILL' : 'TERM'
+    Process.kill(signal, pid)
+    m.reply "sent #{signal} to process #{pid}"
+  end
+
+  def run(m, command)
+    pid = nil
+    puts "current pid is #{Process.pid}"
+    IO.popen(command, err: [:child, :out]) do |io|
+      pid = io.pid
+      $SPAWNS.push pid
+      m.reply "process command #{command} with pid #{pid} started:"
+      t = Thread.new do
+        while row = io.gets
+          m.reply row.strip
+        end
+      end
+      unless t.join(10)
+        Process.kill('KILL', pid)
+        m.reply "process #{pid} killed beause of reading timeout (10s)"
+      else
+        m.reply "process #{pid} ended"
+      end
+    end
+    $SPAWNS.delete(pid)
+  end
+
+  def spawn(m, command)
+    pid = Process.spawn(command, :out => ['/dev/null'])
+
+    $SPAWNS.push pid
+    m.reply "spawned command '#{command}' with pid #{pid}"
+
+    Thread.new do
+      Process.wait(pid)
+      $SPAWNS.delete(pid)
+      m.reply "process #{pid} exited with status #{$?.exitstatus}"
+    end
+  end
+
+end

data/plugins/whisper.rb

@@ -0,0 +1,70 @@
+class Whisper
+  include October::Plugin
+
+  self.react_on = :private
+
+  self.prefix = ''
+
+  match /!whisper (.+)$/, method: :whisper
+  match /(.+)$/, method: :queue
+
+  listen_to :part, method: :close
+  listen_to :join, method: :flush
+
+  register_help 'whisper name', 'starts "whisper" mode, all messages will be sent to user when joins'
+
+  ACTIVE = Hash.new{ |hash, key| hash[key] = {} }
+  OPENED = {}
+
+  def whisper(m, nick)
+    synchronize(:whisper) do
+      ACTIVE[nick][m.user.nick] = [Time.now.to_s]
+      OPENED[m.user.nick] = nick
+      m.reply "Whisper mode started"
+    end
+  end
+
+  def queue(m, text)
+    return unless opened?(m.user)
+
+    synchronize(:whisper) do
+      nick  = m.user.nick
+      opened = OPENED[nick]
+      return if text == "!whisper #{opened}"
+
+      ACTIVE[opened][nick] << text
+      m.reply "Message enqueued"
+    end
+  end
+
+  def close(m)
+    return unless opened?(m.user)
+
+    synchronize(:whisper) do
+      OPENED.delete(m.user.nick)
+    end
+  end
+
+  def flush(m)
+    user = m.user
+    return unless ACTIVE.has_key?(user.nick)
+
+    synchronize(:whisper) do
+      queue = ACTIVE[m.user.nick]
+      queue.keys.each do |sender|
+        messages = queue.delete(sender)
+        user.msg "You have #{messages.size - 1} messages from #{sender}:"
+
+        while line = messages.shift
+          user.msg line
+        end
+      end
+    end
+  end
+
+  private
+  def opened?(user)
+    return unless user
+    OPENED.has_key?(user.nick)
+  end
+end