gitall 1.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 023bf7ff2db1c44f15f8f8f66d02356ee0d5d88c53a4e4b1b78a374873041e7a
+  data.tar.gz: c0f0f44647496761ff884cb2380ea5891d27ad41ee9f8c5c3bcfab55e6912ff4
+SHA512:
+  metadata.gz: f385058ddb774533779b5efb63a53ca3ca46094575fabf15ca43444d7a8fa93806c481059bd394a5eeb61eadbde2947396a3e54e2aa6906d5156e612a4ce9c87
+  data.tar.gz: d3a6e33ff86b316dc41042f809731624a5777c537a2dd22d28b6252d2cb39f6ccd6095aaf2f965e02bfd465142debc4ed88bf255fd9f1291a6140d9b0e47d8e6

data/bin/gitall

@@ -0,0 +1,58 @@
+#! /usr/bin/env ruby
+
+require './bot_version.rb'
+require 'sinatra/base'
+require 'json'
+require 'cinch'
+require 'cinch/plugins/basic_ctcp'
+require 'cinch/plugins/identify'
+require 'ostruct'
+require 'recursive-open-struct'
+require 'yaml'
+require 'unirest'
+require 'base64'
+require 'active_support/all'
+Thread.abort_on_exception = true
+
+# @note Load the plugins
+require 'gitallchancontrol.rb'
+require './lib/admin.rb'
+require './lib/logger.rb'
+require './lib/eval.rb'
+
+# @note Load the parsers
+require 'gitall/parsers/gitlab'
+require 'gitall/parsers/github.rb'
+
+# Cinch
+
+$cfg = YAML.load_file(`echo ~/.gitall-rc.yml`.chomp!)
+$bots = Hash.new
+$threads = Array.new
+
+# For the sake of this example, we'll create an ORM-like model and give it an
+# authenticate method, that checks if a given password matches.
+class User < Struct.new :nickname, :password, :type
+  def authenticate(pass)
+    password == pass
+  end
+end
+
+# Simulate a database.
+$users = []
+@users = YAML.load_file(`echo ~/.gitall-rc.yml`.chomp!)['users']
+@users.each do |user, hash|
+  password = hash['password']
+  role = hash['role']
+  $users << User.new(user, password, role)
+end
+
+
+$bots.each do |key, bot|
+  puts "Starting IRC connection for #{key}..."
+  $threads << Thread.new { bot.start }
+end
+$threads << Thread.new {
+  WebHook.run! if __FILE__ == $PROGRAM_NAME
+}
+$threads.each(&:join)

data/lib/gitall/gitall.rb

@@ -0,0 +1,200 @@
+require 'recursive_open_struct'
+require 'json'
+
+require 'parsers/github'
+require 'parsers/gitlab'
+
+require 'plugins/admin'
+require 'plugins/chancontrol'
+require 'plugins/git'
+require 'plugins/eval'
+
+module GitAll
+  CFG = File.open(Pathname(Dir.home).join('gitall-rc.yml'), 'r').read
+  USERS = CFG['users']
+  PROJECTS = CFG['projects']
+  # Houses all the gitall bots and their data
+
+  class Users
+    attr :users
+    @users = []
+
+    class User < Struct.new :nickname, :password, :type
+      def authenticate(pass)
+        password == pass
+      end
+    end
+
+    USERS.each do |user, hash|
+      password = hash['password']
+      role = hash['role']
+      @users << User.new(user, password, role)
+    end
+  end
+  class Bots
+    attr :bots, :config
+
+    @bots = {}
+    @config = GitAll::CFG
+
+
+
+    def add_bots
+      @config['networks'].each do |name, ncfg|
+        bot = Cinch::Bot.new do
+          configure do |c|
+            c.server = ncfg.fetch('server')
+            c.port = ncfg.fetch('port')
+            c.nick = ncfg.fetch('nickname')
+            c.user = ncfg.fetch('username')
+            c.realname = ncfg.fetch('realname')
+            c.plugins.prefix = Regexp.new(ncfg.fetch('prefix'))
+            c.plugins.plugins << Cinch::Plugins::Identify
+            identify_with = ncfg.fetch('identify-with')
+            case identify_with
+            when 'nickserv'
+              begin
+                c.plugins.options[Cinch::Plugins::Identify] = {
+                    :username => ncfg.fetch('sasl-username'),
+                    :password => ncfg.fetch('sasl-password'),
+                    :type     => :nickserv,
+                }
+              rescue KeyError
+# ignored
+              end
+            when 'sasl'
+              begin
+                c.sasl.username = ncfg.fetch('sasl-username')
+                c.sasl.password = ncfg.fetch('sasl-password')
+              rescue KeyError
+# ignored
+              end
+            when 'cert'
+              begin
+                c.ssl.client_cert = ncfg.fetch('certfp')
+              rescue KeyError
+                # ignored
+              end
+            when 'none'
+              # Don't identify
+            else
+              # noop
+            end
+            c.channels = ncfg.fetch('channels')
+            c.ssl.use = ncfg.fetch('ssl')
+            c.ssl.verify = ncfg.fetch('sslverify')
+            c.messages_per_second = ncfg.fetch('mps')
+            # Global configuration. This means that all plugins / matchers that
+            # implement authentication make use of the :login strategy, with a user
+            # level of :users.
+            c.authentication          = Cinch::Configuration::Authentication.new
+            c.authentication.strategy = :login
+            c.authentication.level    = :users
+            # The UserLogin plugin will call this lambda when a user runs !register.
+            #c.authentication.registration = lambda { |nickname, password|
+              # If you were using an ORM, you'd do something like
+              # `User.create(:nickname => nickname, :password => password)` here.
+            #  return false if Users.users.one? { |user| user.nickname == nickname }
+            #  Users.users << User.new(nickname, password, 'user')
+            #}
+            # The UserLogin plugin will call this lambda when a user runs !login. Note:
+            # the class it returns must respond to #authenticate with 1 argument (the
+            # password the user tries to login with).
+            c.authentication.fetch_user = lambda { |nickname|
+              # If you were using an ORM, you'd probably do something like
+              # `User.first(:nickname => nickname)` here.
+              Users.users.find { |user| user.nickname == nickname } }
+            # The Authentication mixin will call these lambdas to check if a user is
+            # allowed to run a command.
+            c.authentication.users  = lambda { |user| user.type == 'user' }
+            c.authentication.admins = lambda { |user| user.type == 'admin' }
+            c.plugins.plugins << Cinch::Plugins::UserLogin
+            c.plugins.plugins << Cinch::Plugins::BasicCTCP
+            c.plugins.options[Cinch::Plugins::BasicCTCP][:replies] = {
+                version: Version::Bot.version,
+                source:  'https://gitlab.com/gitall/gitall'
+            }
+            c.plugins.plugins << ChanControl
+            c.plugins.options[ChanControl][:authentication_level] = :admins
+            c.plugins.plugins << Admin
+            c.plugins.options[Admin][:authentication_level] = :admins
+            c.plugins.plugins << Eval
+            c.plugins.options[Eval][:authentication_level] = :admins
+            c.plugins.plugins << Cinch::Plugins::UserList
+            c.plugins.options[Cinch::Plugins::UserList][:authentication_level] = :admins
+          end
+        end
+        bot.loggers.clear
+        bot.loggers << GitLogger.new(name, File.open("log/gitall-#{name}.log", 'a'))
+        bot.loggers << GitLogger.new(name, STDOUT)
+        bot.loggers.level = :debug
+        self.bots[name] = bot
+      end
+    end
+  end
+  class WebHook < Sinatra::Base
+    set :port, 8008
+    set :bind, '127.0.0.1'
+    set :environment, 'production'
+    set :threaded, true
+    post '/hook/?' do
+      request.body.rewind
+      payload = request.body.read
+      json = JSON.load(payload)
+      j = RecursiveOpenStruct.new(json)
+      repo = ''
+      if request.env.key? 'HTTP_X_GITLAB_TOKEN'
+        repo = j.project.path_with_namespace
+        resp = GitLabParser.parse json
+        phash = PROJECTS[repo]
+        if phash['token'] == request.env['HTTP_X_GITLAB_TOKEN']
+          channels = phash['channels']
+          channels.each do |channet|
+            channel = channet.split(',')[0]
+            net = channet.split(',')[1]
+            resp.each do |n|
+              Bots.bots[net].Channel(channel).send("#{n}")
+            end
+          end
+        end
+      elsif request.env.key? 'HTTP_X_HUB_SIGNATURE'
+        if !j.repository.full_name.nil?
+          repo = j.repository.full_name
+        elsif !j.organization.login.nil?
+          repo = j.organization.login
+        else
+        end
+        # phash includes orgs and repos
+        phash = PROJECTS[repo.to_sym]
+        token = phash['token']
+        sent_token = request.env['HTTP_X_HUB_SIGNATURE']
+        signature = "sha1=#{OpenSSL::HMAC.hexdigest('sha1', token, payload.strip).chomp}"
+        resp = GitHubParser.parse json, request.env['HTTP_X_GITHUB_EVENT']
+        if signature.to_s == sent_token.to_s
+          channels = phash['channels'.to_sym]
+          channels.each {
+              |channet|
+            channel = channet.split(',')[0]
+            network = channet.split(',')[1]
+            resp.each {
+                |n|
+              GitAll::Bots.bots[network].Channel(channel).send("#{n}")
+            }
+          }
+        end
+
+      elsif request.env.key?('HTTP_X_GOGS_EVENT')
+
+      elsif request.env.key?('HTTP_X_EVENT_KEY')
+        # BitBucket's Webhooks
+        # Requires HTTPS and does not
+        # implement a secret unless set into
+        # the url.
+        status 404
+        body 'bitbucket not implemented'
+      else
+        [404, "I can't help with that"]
+      end
+    end
+  end
+end

data/lib/gitall/logger.rb

@@ -0,0 +1,21 @@
+# lib/logger.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+require 'cinch'
+
+class GitLogger < Cinch::Logger::FormattedLogger
+  def initialize(network, *args)
+    @network = network
+    super(*args)
+  end
+
+  def format_general(message)
+    message.gsub!(/[^[:print:][:space:]]/) do |m|
+      colorize(m.inspect[1..-2], :bg_white, :black)
+    end
+    "[#{@network}] #{message}"
+  end
+end

data/lib/gitall/parsers/bitbucket.rb

@@ -0,0 +1,13 @@
+# lib/bitbucket.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+class BitBucketParser
+  # @param [Object] json json object
+  # @param [Object] event the github event
+  def self.parse(json, event)
+    ec, e = event.split(':')
+  end
+end

data/lib/gitall/parsers/github.rb

@@ -0,0 +1,191 @@
+# lib/github.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+# GitHub Event Parsing
+# noinspection RubyUnusedLocalVariable
+require 'cinch'
+class GitHubParser
+  # @param [Object] json json object
+  # @param [Object] event the github event
+  def self.parse(json, event)
+    j = RecursiveOpenStruct.new(json)
+    response = []
+    case event
+      when 'ping'
+        zen = j.zen
+        id = j.hook_id
+        response << "Hook #{id} [PING] '#{zen}'"
+      when 'issue_comment'
+      when 'member'
+      when 'membership'
+      when 'milestone'
+      when 'label'
+#        "action":"created",
+#  			"label":{
+#    		"url":"https://api.github.com/repos/baxterandthehackers/public-repo/labels/blocked",
+#    		"name":"blocked",
+#    		"color":"ff0000"
+#  		},
+        action = j.action
+        l = j.label
+        repo = j.repository.full_name
+        user = j.sender.login
+        lurl = l.url
+        lname = l.name
+        case action
+          when 'created', 'deleted'
+            response << "[#{repo}] #{user} #{action} label #{lname} <#{lurl}>"
+          when 'edited'
+            old = l.changes.name.from
+            new = lname
+            if old != new
+              response << "[#{repo}] #{user} #{action} Old: #{old} New: #{new}"
+            end
+        end
+      when 'team'
+      when 'team_add'
+      when 'fork'
+        f = RecursiveOpenStruct.new(j.forkee)
+        user = j.sender.login
+        fork = f.full_name
+        repo = j.repository.full_name
+        response << "[#{repo}] #{user} forked the repository to #{fork}"
+      when 'pull_request'
+        p = RecursiveOpenStruct.new(j.pull_request)
+        action = j.action
+        case action
+          when 'opened'
+          when 'closed'
+        end
+      when 'pull_request_review'
+        action = j.action
+        case action
+          when 'created'
+          when 'deleted'
+        end
+      when 'pull_request_review_comment'
+        c = RecursiveOpenStruct.new(j.comment)
+        action = j.action
+        case action
+          when 'created'
+          when 'deleted'
+          when 'edited'
+        end
+      when 'commit_comment'
+      when 'gollum'
+        p = j.pages
+        action = j.action
+      when 'create'
+      when 'delete'
+      when 'organization'
+        action = j.action
+        case action
+          when 'member_add'
+          when 'member_del'
+        end
+      when 'repository'
+        r = RecursiveOpenStruct.new(j.repository)
+        action = j.action
+        repo = r.full_name
+        user = j.sender.login
+        case action
+          when 'created'
+            response << "#{user} created repository #{repo}"
+          when 'deleted'
+            # XXX: Only triggers on Organization webhooks
+            response << "#{user} deleted #{r.full_name}"
+        end
+      when 'release'
+        r = RecursiveOpenStruct.new(j.release)
+        tag = r.tag_name
+        action = j.action
+        repo = j.repository.full_name
+        case action
+          when 'published'
+            response << "[#{repo}] released #{tag}!"
+          else
+            response << "[#{repo}] #{action} something!"
+            response << "**\u000304This is a fallback for when new actions are added to the 'ReleaseEvent'**"
+            response << 'Please submit an issue at https://github.com/IotaSpencer/gitall'
+            response << ' or join #gitall on the freenode or ElectroCode IRC networks.'
+        end
+      when 'watch'
+        # XXX: possibly add user's profile url if option set
+        response << "[#{repo}] #{user} starred the repository!"
+      when 'issue'
+        repo = j.repository.full_name
+        url = shorten(j.issue.url)
+        action = j.action
+        id = j.issue.number
+        title = j.issue.title
+        user = j.issue.user.name
+        # assigned", "unassigned", "labeled", "unlabeled", "opened", "edited",
+        # "milestoned", "demilestoned", "closed", or "reopened".
+        case action
+          when 'assigned'
+            # do stuff ...
+          when 'unassigned'
+            # do stuff ...
+          when 'labeled'
+            label = j.label.name
+            response << "[#{repo}] #{user} added #{label}"
+          when 'unlabeled'
+            # do stuff ...
+          when 'milestoned'
+            response << "[#{repo}] #{user} milestoned issue ##{id} "
+          when 'demilestoned'
+            # do stuff ...
+          when 'reopened'
+            response << "[#{repo}] #{user} reopened ##{id}"
+
+          when 'opened'
+            response << "[#{repo}] #{user} opened an issue ##{id} - #{title} <#{url}>"
+          when 'closed'
+            response << "[#{repo}] #{user} closed issue ##{id} - #{title} <#{url}>"
+          when 'edited'
+            response << "[#{repo}] #{user} edited issue ##{id} - #{title} <#{url}>"
+        end
+      when 'push'
+        repo = j.repository.full_name
+        branch = j.ref.split('/')[-1]
+        commits = j.commits
+        added = 0
+        removed = 0
+        modified = 0
+        commits.each do |h|
+          added += h['added'].length
+          removed += h['removed'].length
+          modified += h['modified'].length
+        end
+        pusher = j.pusher.name
+        commit_count = commits.length
+        compare_url = shorten(j.compare)
+        response << "[#{repo}] #{pusher} pushed #{commit_count} commit(s) [+#{added}/-#{removed}/±#{modified}] to [#{branch}] <#{compare_url}>"
+        if commits.length > 3
+          coms = commits[0..2]
+          coms.each do |n|
+            id = n.dig('id')
+            id = id[0...7]
+            msg = n.dig('message').lines[0].chomp
+            author = n.dig 'committer', 'name'
+            response << "#{author} — #{msg} [#{id}]"
+          end
+          response << "and #{commits.length - 3} commits..."
+        else
+          commits.each do |n|
+            id = n.dig('id')
+            id = id[0...7]
+            msg = n.dig('message').lines[0].chomp
+            author = n.dig 'committer', 'name'
+            response << "#{author} — #{msg} [#{id}]"
+          end
+        end
+      else
+        'format not implemented'
+    end
+    response
+  end
+end

data/lib/gitall/parsers/gitlab.rb

@@ -0,0 +1,103 @@
+# lib/gitlab.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+# GitLab Event Parsing
+class GitLabParser
+  def GitLabParser.parse(json)
+    j = RecursiveOpenStruct.new(json)
+    response = []
+    kind = j.object_kind
+    case kind
+    when 'note'
+      repo = j.project.path_with_namespace
+      ntype = j.object_attributes.noteable_type
+      case ntype
+      when 'MergeRequest'
+        mr_note  = j.object_attributes.note
+        mr_url   = shorten(j.object_attributes.url)
+        mr_title = j.merge_request.title
+        mr_id    = j.merge_request.iid
+        mr_user  = j.user.name
+        response << "[#{repo}] #{mr_user} commented on Merge Request ##{mr_id} \u2014 #{mr_note}"
+        response << "'#{mr_title}' => #{mr_url}"
+      when 'Commit'
+        c_note    = j.object_attributes.note
+        c_sha     = j.commit.id[0...7]
+        c_url     = shorten(j.object_attributes.url)
+        c_user    = j.user.name
+        response << "[#{repo}] #{c_user} commented on commit (#{c_sha}) \u2014 #{c_note} <#{c_url}>"
+      when 'Issue'
+        i_id    = j.issue.iid
+        i_url   = shorten(j.object_attributes.url)
+        i_msg   = j.object_attributes.note
+        i_title = j.issue.title
+        i_user  = j.user.name
+        response << "[#{repo}] #{i_user} commented on Issue ##{i_id} (#{i_title}) \u2014 #{i_msg} <#{i_url}>"
+        else
+          # type code here
+      end
+    when 'issue'
+      i_repo   = j.project.path_with_namespace
+      i_user   = j.user.name
+      i_un     = j.user.username
+      i_id     = j.object_attributes.iid
+      i_title  = j.object_attributes.title
+      i_action = j.object_attributes.action
+      i_url    = shorten(j.object_attributes.url)
+      response << "[#{i_repo}] #{i_user}(#{i_un}) #{i_action} issue ##{i_id} - #{i_title} <#{i_url}>"
+    when 'merge_request'
+      mr_name      = j.user.name
+      mr_user      = j.user.username
+      mr_url       = shorten(j.url)
+      mr_spath     = j.object_attributes.source.path_with_namespace
+      mr_sbranch   = j.object_attributes.source_branch
+      mr_tpath     = j.object_attributes.target.path_with_namespace
+      mr_tbranch   = j.object_attributes.target_branch
+      mr_lcmessage = j.object_attributes.last_commit.message
+      mr_lcsha     = j.object_attributes.last_commit.id[0...7]
+      response << "#{mr_name}(#{mr_user}) opened a merge request. #{mr_spath}[#{mr_sbranch}] ~> #{mr_tpath}[#{mr_tbranch}]"
+      response << "[#{mr_lcsha}] \u2014 #{mr_lcmessage} <#{mr_url}>"
+    when 'push' # comes to
+      # shove
+      branch = j.ref.split('/')[-1]
+      commits = j.commits
+      added = 0
+      removed = 0
+      modified = 0
+      commits.each do |h|
+        added    += h['added'].length
+        removed  += h['removed'].length
+        modified += h['modified'].length
+      end
+      owner = j.project.namespace
+      project = j.project.name
+      pusher = j.user_name
+      commit_count = j.total_commits_count
+      repo_url = shorten(j.project.web_url)
+      response << "[#{owner}/#{project}] #{pusher} pushed #{commit_count} commit(s) [+#{added}/-#{removed}/±#{modified}] to [#{branch}] at <#{repo_url}>"
+      if commits.length > 3
+        coms = commits[0..2]
+        coms.each do |n|
+          id = n['id']
+          msg = n['message'].lines[0]
+          author = n['author']['name']
+          response << "#{author} — #{msg.chomp!} [#{id[0...7]}]"
+        end
+        response << "and #{commits.from(3).length} commits..."
+      else
+        commits.each do |n|
+          id = n['id'][0...7]
+          msg = n['message'].lines[0]
+          author = n['author']['name']
+          response << "#{author} — #{msg.chomp!} [#{id}]"
+        end
+      end
+      else
+        # type code here
+    end
+    return response
+  end
+end

data/lib/gitall/plugins/admin.rb

@@ -0,0 +1,78 @@
+# lib/admin.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+require 'cinch'
+require 'cinch/extensions/authentication'
+require 'yaml'
+require 'recursive-open-struct'
+
+# @class Admin Plugin
+class Admin
+  include Cinch::Plugin
+  include Cinch::Extensions::Authentication
+  match /quit$/, method: :do_Quit, group: :quit
+  match /quit (.+)$/, method: :do_Quit, group: :quit
+
+  match /join$/, method: :do_Join, group: :join
+  match /join (.+)/, method: :do_Join, group: :join
+
+  match /announce$/, method: :do_Announce, group: :announce
+  match /announce (.+)$/, method: :do_Announce, group: :announce
+  match /global$/, method: :do_Announce, group: :announce
+  match /global (.+)$/, method: :do_Announce, group: :announce
+
+  def do_Announce(m, msg = nil)
+    return unless authenticated? m
+    if msg.nil?
+      command = m.command
+      m.reply "Syntax: !#{command} Message to announce..."
+    else
+      $bots.each do |net, bot|
+        info("Announcing to #{net}")
+        debug("Announcing '#{msg}'")
+        bot.channels.each do |c|
+          Channel(c).send("[GLOBAL - #{m.user}@#{m.bot.irc.isupport.fetch('NETWORK')}] #{msg}",
+                          notice=false)
+        end
+      end
+    end
+  end
+
+  def do_Quit(m, msg = nil)
+    return unless authenticated? m
+    if msg.nil?
+      $bots.each do |net, bot|
+        info("Exiting from #{net}")
+        bot.quit('QUIT received!')
+      end
+    else
+      $bots.each do |net, bot|
+        info("Exiting from #{net}")
+        bot.quit(msg)
+      end
+    end
+    $threads.each(&:exit)
+  end
+  def do_Join(m, channels = nil)
+  	return unless authenticated? m
+  	if channels.nil?
+  	  m.reply 'Syntax: join #channel[,#channel2,#channel3]'
+  	else
+  	  chans = channels.split(',')
+  	  chans.each do |chan|
+  	    Channel(chan).join
+  	  end
+   	end
+  end
+  def do_Part(m, channels = nil, reasons = nil)
+    return unless authenticated? m
+    if channels.nil? && reasons.nil?
+      m.reply 'Syntax: part #channel1[,#channel2,#channel3] [reason1[,reason2,reason3]]'
+    else
+      m.reply 'Not implemented yet'
+    end
+  end
+end

data/lib/gitall/plugins/chancontrol.rb

@@ -0,0 +1,127 @@
+# lib/chancontrol.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+require 'cinch'
+require 'cinch/extensions/authentication'
+require 'yaml'
+require 'recursive-open-struct'
+require 'strgen'
+# @note ChanControl Plugin
+
+class ChanControl
+  include Cinch::Plugin
+  include Cinch::Extensions::Authentication
+
+  # Write to the config
+  # @param [Hash] msg the data to write
+  def toFile(msg)
+    data = msg
+    File.open(`echo ~/.gitall-rc.yml`.chomp, 'w') {|f| f.write(data.to_yaml) }
+  end
+
+  # Load the config
+  # @return [Hash] load the current config
+  def deFile
+    begin
+      parsed = YAML.load(File.open(`echo ~/.gitall-rc.yml`.chomp, 'r'))
+    rescue ArgumentError => e
+      puts "Could not parse YAML: #{e.message}"
+    end
+    parsed
+  end
+
+  match /padd$/, method: :padd, group: :padd
+  match /padd (\S+) (\S+) (\S+) (\S+)/, method: :padd, group: :padd
+
+  match /list$/, method: :listchans, group: :listchans
+  match /list (\S+)/, method: :listchans, group: :listchans
+
+  match /token$/, method: :getToken, group: :token
+  match /token ([0-9]+)/, method: :getToken, group: :token
+
+  # @param [Message]
+  # @param [String] namespace the Repository to watch
+  # @param [String] host the Git Service Website
+  # @param [String] token Secret Token @seealso {ChanControl#getToken}
+  # @param [ChannelList] channels | separated list of channels in the format
+  # of #channel,net
+  def padd(m, namespace = nil, host = nil, token = nil, channels = nil)
+    if namespace.nil?
+      m.reply 'Syntax: padd {OWNER/PROJECT} {github, gitlab, bitbucket}
+                XXXXXXTOKEN #channel,network[|#channel2,network|#channel3,network2]'
+      m.reply 'GitALL works best when using owner/repo webhooks, organization hooks have not been tested.'
+    else
+      return unless authenticated? m
+      config = deFile
+      if config[:projects].has_key? namespace
+        m.user.send("#{m.user.nick}: #{namespace} already exists in the
+config.")
+      else
+        config[:projects][namespace] = {
+          host: host,
+          token: token,
+          channels: channels.split('|')
+        }
+        toFile(config)
+        project = deFile().dig(:projects, namespace)
+        m.user.send("Inputted: #{project}")
+      end
+      # @param [String] host
+      def cap_host(host)
+        case host.downcase
+          when 'github'
+            'GitHub.com'
+          when 'gitlab'
+            'GitLab.com'
+          when 'bitbucket'
+            'BitBucket.org'
+        end
+      end
+      m.user.send("Remember to add the webhook to #{cap_host(host)} if you
+haven't already.")
+      info("Project added: #{project}")
+    end
+  end
+
+  # @param [Message] m message object
+  # @param [Integer] length token length
+  # @return [String] Token
+  def getToken(m, length = nil)
+    token = Strgen.generate do |c|
+      if length.nil?
+        c.length = 30
+      else
+        if length.to_i > 100
+          c.length = 100
+          m.reply 'Truncating to 100 characters due to spam concerns'
+        else
+          c.length = length
+        end
+      end
+      c.alpha   = true
+      c.numbers = true
+      c.repeat  = false
+      c.symbols = false
+      c.exclude = %w[1 i I l L 0 o O]
+    end
+    m.user.send "Token: #{token}"
+  end
+
+  # @param [Channel] channel name of channel
+  # @note Ensures that the channel is joined or known of
+  # @returns Boolean true/false
+
+  def self.joined(channel)
+    Channel(channel) ? true : false
+  end
+  # @param [Object] m Object
+
+  def listchans(m, project = nil)
+    return unless authenticated? m
+    project_hash = deFile['projects'][project]
+    m.reply "Name: #{project} Host: #{project_hash['host'.to_sym]} Channels: #{project_hash['channels'.to_sym].join(" \xB7 ")}"
+  end
+end

data/lib/gitall/plugins/eval.rb

@@ -0,0 +1,17 @@
+require 'cinch'
+class Eval
+  include Cinch::Plugin
+  include Cinch::Extensions::Authentication
+
+  match /eval$/, method: :do_eval, group: :doeval
+  match /eval (.*)/, method: :do_eval, group: :doeval
+
+  def do_eval(m, string = nil)
+    if string.nil?
+      m.reply "Syntax: !eval [CODE...]"
+    else
+      return unless authenticated? m
+      m.reply(eval(string))
+    end
+  end
+end

data/lib/gitall/plugins/git.rb

@@ -0,0 +1,28 @@
+# lib/git.rb
+# Ken Spencer <ken@electrocode.net>
+#
+# This module is part of GitAll and is released under the
+# MIT license: http://opensource.org/licenses/MIT
+
+require 'cinch'
+require 'cinch/extensions/authentication'
+require 'unirest'
+class ChanControl 
+  include Cinch::Plugin
+  include Cinch::Extensions::Authentication
+
+  match /(\s+)\:(\S)\/(\S+)\#(\S)/, :method => :getIssue
+
+  def getIssue(m, host, user, repo, issue)
+    case host
+    when 'gl'
+      m.reply("https://gitlab.com/#{user}/#{repo}/issues/#{issue}")
+    when 'gh'
+      m.reply("https://github.com/#{user}/#{repo}/issue/#{issue}")
+    when 'bb'
+      m.reply("https://bitbucket.org/#{user}/#{repo}/issue/#{issue}")
+    else
+      m.user.notice("I don't know that git-service host")
+    end
+  end
+end

data/lib/gitall/version.rb

@@ -0,0 +1,3 @@
+module GitAll
+  VERSION = '1.1.5'
+end

data/lib/views/_403.erb

@@ -0,0 +1 @@
+Invalid / Missing 'Secret' or 'Token'

metadata

@@ -0,0 +1,224 @@
+--- !ruby/object:Gem::Specification
+name: gitall
+version: !ruby/object:Gem::Version
+  version: 1.1.5
+platform: ruby
+authors:
+- Ken Spencer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cinch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.4
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A git based webhook receiver for GitHub, GitLab, and Gogs
+email:
+- me@iotaspencer.me
+executables:
+- gitall
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gitall
+- lib/cli/app.rb
+- lib/gitall/gitall.rb
+- lib/gitall/logger.rb
+- lib/gitall/parsers/bitbucket.rb
+- lib/gitall/parsers/github.rb
+- lib/gitall/parsers/gitlab.rb
+- lib/gitall/plugins/admin.rb
+- lib/gitall/plugins/chancontrol.rb
+- lib/gitall/plugins/eval.rb
+- lib/gitall/plugins/git.rb
+- lib/gitall/version.rb
+- lib/views/_403.erb
+homepage: https://gitlab.com/gitall/gitall
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Git Based Webservices Webhook Receiver
+test_files: []