mos-eisley 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04aa61103f6ecc6125a9c6ee418ba29f83e21c60
+  data.tar.gz: 0afb292fddbfa032b38f59a4c3395bd3d19e26b3
+SHA512:
+  metadata.gz: 02396f7926f9c24e5c4985a75f377dc474cb496bc30dcb527cf84e3701f26f810e6a5a2d2fcec8b0bde4089f65404c0c0fea4cfd8a655154095aa5c70c0b2162
+  data.tar.gz: 99601b8d3ac02b31ec45d9673c3c85fdfe7733aaf579af4d9f696be0b913da1c526224610359ee86c57e097497c9cc4f41647db0b9176946f5f0f1b2e5e71877

data/README.md

@@ -0,0 +1,71 @@
+# mos-eisley
+
+```markdown
+[![Gem Version](https://badge.fury.io/rb/mos-eisley.svg)](http://badge.fury.io/rb/mos-eisley) [![Code Climate](https://codeclimate.com/github/kenjij/mos-eisley/badges/gpa.svg)](https://codeclimate.com/github/kenjij/mos-eisley) [![security](https://hakiri.io/github/kenjij/mos-eisley/master.svg)](https://hakiri.io/github/kenjij/mos-eisley/master)
+```
+
+Ruby server for running a Slackbot.
+
+## Requirements
+
+- [Ruby](https://www.ruby-lang.org/) >= 2.1
+
+Powered by [Sinatra](http://www.sinatrarb.com/).
+
+## Getting Started
+
+### Install
+
+```
+$ gem install mos-eisley
+```
+
+### Configure
+
+Create a configuration file following the example below.
+
+```ruby
+# Configure application logging
+MosEisley.logger = Logger.new(STDOUT)
+MosEisley.logger.level = Logger::DEBUG
+
+MosEisley::Config.setup do |c|
+  # User custom data
+  c.user = {my_data1: 'Something', my_data2: 'Somethingelse'}
+
+  # HTTP server (Sinatra) settings
+  c.dump_errors = true
+  c.logging = true
+
+  # Your handlers
+  c.handler_paths = [
+    'handlers'
+  ]
+
+  # Slack info
+  c.verification_tokens = [
+    'vErIf1c4t0k3n5'
+  ]
+  c.bot_access_token = 'xoxb-1234567890-b0t4cCe5sToK3N'
+end
+```
+
+### Use
+
+To see help:
+
+```
+$ mos-eisley -h
+Usage: mos-eisley [options] {start|stop}
+  -c, --config=<s>     Load config from file
+  -d, --daemonize      Run in the background
+  -l, --log=<s>        Log output to file
+  -P, --pid=<s>        Store PID to file
+  -p, --port=<i>       Use port (default: 4567)
+```
+
+The minimum to start a server:
+
+```
+$ mos-eisley -c config.rb start
+```

data/bin/mos-eisley

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'kajiki'
+require 'mos-eisley'
+
+
+opts = Kajiki.preset_options(:server, {config: true})
+
+Kajiki.run(opts) do |cmd|
+  case cmd
+  when 'start'
+    MosEisley::Config.load_config(opts[:config]) if opts[:config]
+    MosEisley::Handler.autoload
+    require 'http-server/server'
+    MosEisley.logger.warn('Mos Eisley server starting...')
+    MosEisley::Server.run!({Host: opts[:address], Port: opts[:port]})
+  end
+end

data/lib/http-client/client.rb

@@ -0,0 +1,57 @@
+require 'eventmachine'
+require 'em-http'
+
+
+module MosEisley
+
+  class HTTPClient
+
+    def self.post_form(url:, params:, &block)
+      if EM.reactor_running?
+        MosEisley.logger.debug('POSTing form')
+        MosEisley::HTTPClient.request(url: url, body: params, &block)
+      else
+        MosEisley.logger.debug('Starting reactor...')
+        EM.run {
+          MosEisley.logger.debug('POSTing form')
+          MosEisley::HTTPClient.request(url: url, body: params, stop: true, &block)
+        }
+      end
+    end
+
+    def self.post_json(url:, params: nil, body: nil, &block)
+      head = {'Content-Type' => 'application/json'}
+      body = S3PO.json_with_object(params) if params
+      if EM.reactor_running?
+        MosEisley.logger.debug('POSTing JSON')
+        MosEisley::HTTPClient.request(url: url, body: body, head: head, &block)
+      else
+        MosEisley.logger.debug('Starting reactor...')
+        EM.run {
+          MosEisley.logger.debug('POSTing JSON')
+          MosEisley::HTTPClient.request(url: url, body: body, head: head, stop: true, &block)
+        }
+      end
+    end
+
+    def self.request(url:, head: nil, body:, stop: false, &block)
+      http = EM::HttpRequest.new(url).post(body: body)
+      http.errback {
+        MosEisley.logger.error('HTTP error')
+        if stop
+          EM.stop
+          MosEisley.logger.debug('Stopped reactor.')
+        end
+      }
+      http.callback {
+        block.call(http) if block_given?
+        if stop
+          EM.stop
+          MosEisley.logger.debug('Stopped reactor.')
+        end
+      }
+    end
+
+  end
+
+end

data/lib/http-client/webapi.rb

@@ -0,0 +1,44 @@
+module MosEisley
+
+  class WebAPI
+
+    BaseURL = 'https://slack.com/api/'
+
+    def self.auth_test
+      MosEisley.logger.debug('auth_test')
+      m = 'auth.test'
+      url = BaseURL + m
+      params = {token: MosEisley.config.bot_access_token}
+      MosEisley.logger.debug("#{url}\n#{params}")
+      HTTPClient.post_form(url: url, params: params) do |h|
+        MosEisley.config.meta.merge!(S3PO.parse_json(h.response))
+        MosEisley.logger.debug("meta data updated:\n#{MosEisley.config.meta}")
+      end
+    end
+
+    def self.post_message(msg)
+      m = 'chat.postMessage'
+      url = BaseURL + m
+      msg[:token] = MosEisley.config.bot_access_token
+      HTTPClient.post_form(url: url, params: msg) do |h|
+        MosEisley.logger.debug("chat.postMessage POSTed: #{h.response}")
+      end
+    end
+
+    def self.post_ephemeral(msg)
+      m = 'chat.postEphemeral'
+      url = BaseURL + m
+      msg[:token] = MosEisley.config.bot_access_token
+      HTTPClient.post_form(url: url, params: msg) do |h|
+        MosEisley.logger.debug("chat.postEphemeral POSTed: #{h.response}")
+      end
+    end
+
+    # def self.me_message()
+    #   m = 'chat.meMessage'
+    #   url = BaseURL + m
+    # end
+
+  end
+
+end

data/lib/http-server/helper.rb

@@ -0,0 +1,36 @@
+require 's3po/s3po'
+
+module MosEisley
+
+  module Helper
+
+    def logger
+      MosEisley.logger
+    end
+
+    def parse_command(params)
+      cmd = {}
+      params.each { |k, v| cmd[k.to_sym] = v }
+      return cmd
+    end
+
+    # Parse JSON to Hash with key symbolization by default
+    def parse_json(json)
+      MosEisley::S3PO.parse_json(json)
+    end
+
+    def valid_token?(token)
+      Config.shared.verification_tokens.include?(token)
+    end
+
+    # Convert object into JSON, optionally pretty-format
+    # @param obj [Object] any Ruby object
+    # @param opts [Hash] any JSON options
+    # @return [String] JSON string
+    def json_with_object(obj, pretty: true, opts: nil)
+      MosEisley::S3PO.json_with_object(obj, pretty: pretty, opts: opts)
+    end
+
+  end
+
+end

data/lib/http-server/server.rb

@@ -0,0 +1,118 @@
+require 'thin'
+require 'sinatra/base'
+require 'http-server/helper'
+
+module MosEisley
+
+  # The Sinatra server
+  class Server < Sinatra::Base
+
+    helpers Helper
+
+    configure do
+      set :environment, :production
+      c = Config.shared
+      # set :public_folder, c.public_folder if c.public_folder
+      # set :dump_errors, c.dump_errors
+      # set :logging, c.logging
+      enable :logging
+      MosEisley::WebAPI.auth_test
+    end
+
+    before do
+    end
+
+    # Interactive message buttons
+    # Receive POST form with payload containing JSON string; use "token" to verify
+    post '/action' do
+      logger.info('Incoming request received.')
+      logger.debug("Body size: #{request.content_length} bytes")
+      event = parse_json(params[:payload])
+      halt 400 if event.nil?
+      logger.debug("#{event}")
+      unless valid_token?(event[:token])
+        logger.debug("Invalid Slack Events token: #{event[:token]}")
+        halt 401
+      end
+      res = Handler.run(:action, S3PO.create_event(event, :action))
+      if res
+        json_with_object(res)
+      else
+        200
+      end
+    end
+
+    # Slash commands
+    # Receive POST form; use "token" to verify
+    # Respond within 3 sec directly; raw text or formatted
+    # OR, use response_url
+    post '/command' do
+      cmd = parse_command(params)
+      unless valid_token?(cmd[:token])
+        logger.debug("Invalid Slack Events token: #{cmd[:token]}")
+        halt 401
+      end
+      res = Handler.run(:command, cmd)
+      if res
+        json_with_object(res)
+      else
+        200
+      end
+    end
+
+    # Event API
+    # Receive POST JSON; use "token" to verify
+    post '/event' do
+      logger.info('Incoming request received.')
+      logger.debug("Body size: #{request.content_length} bytes")
+      request.body.rewind
+      event = parse_json(request.body.read)
+      halt 400 if event.nil?
+      logger.debug("#{event}")
+      
+      unless valid_token?(event[:token])
+        logger.debug("Invalid Slack Events token: #{event[:token]}")
+        halt 401
+      end
+      resp = {}
+      case event[:type]
+      when 'url_verification'
+        resp[:challenge] = event[:challenge]
+      when 'event_callback'
+        Handler.run(:event, S3PO.create_event(event[:event]))
+        resp[:text] = 'OK'
+      else
+        resp[:text] = "Unknown event type: #{event[:type]}"
+      end
+      logger.debug("#{resp}")
+      logger.debug("#{ME.config.meta}")
+      json_with_object(resp)
+    end
+
+    not_found do
+      logger.info('Invalid request.')
+      logger.debug("Request method and path: #{request.request_method} #{request.path}")
+      json_with_object({message: 'Huh, nothing here.'})
+    end
+
+    error 400 do
+      json_with_object({message: 'Um, I did not get that.'})
+    end
+
+    error 401 do
+      json_with_object({message: 'Oops, need a valid token.'})
+    end
+
+    error do
+      status 500
+      err = env['sinatra.error']
+      logger.error "#{err.class.name} - #{err}"
+      json_with_object({message: 'Yikes, internal error.'})
+    end
+
+    after do
+      content_type 'application/json'
+    end
+
+  end
+end

data/lib/mos-eisley/config.rb

@@ -0,0 +1,53 @@
+module MosEisley
+
+  def self.config
+    Config.shared
+  end
+
+  class Config
+
+    # Load Ruby config file
+    # @param path [String] config file
+    def self.load_config(path)
+      MosEisley.logger.debug("Loading config file: #{path}")
+      require File.expand_path(path)
+      MosEisley.logger.info('Config.load_config done.')
+    end
+
+    # Returns the shared instance
+    # @return [MosEisley::Config]
+    def self.shared
+      @shared_config ||= Config.new
+    end
+
+    # Call this from your config file
+    def self.setup
+      yield Config.shared
+      MosEisley.logger.debug('Config.setup block executed.')
+    end
+
+    attr_accessor :user
+    attr_accessor :handler_paths
+    attr_accessor :public_folder
+    attr_accessor :dump_errors
+    attr_accessor :logging
+
+    attr_reader :meta
+
+    attr_accessor :verification_tokens
+    attr_accessor :bot_access_token
+
+    def initialize
+      @handler_paths = []
+      @dump_errors = false
+      @logging = false
+
+      @meta = {}
+
+      @verification_tokens = []
+      @bot_access_token = ''
+    end
+
+  end
+
+end

data/lib/mos-eisley/handler.rb

@@ -0,0 +1,87 @@
+module MosEisley
+
+  def self.handlers
+    Handler.handlers
+  end
+
+  class Handler
+
+    # Load handlers from directories designated in config
+    def self.autoload
+      MosEisley.config.handler_paths.each { |path|
+        load_from_path(path)
+      }
+    end
+
+    # Load handlers from a directory
+    # @param path [String] directory name
+    def self.load_from_path(path)
+      Dir.chdir(path) {
+        Dir.foreach('.') { |f| load f unless File.directory?(f) }
+      }
+    end
+
+    # Call as often as necessary to add handlers; each call creates a MosEisley::Handler object
+    def self.add(type, &block)
+      @handlers ||= {
+        action: [],
+        command: [],
+        event: []
+      }
+      @handlers[type] << Handler.new(type, &block)
+      MosEisley.logger.debug("Added #{type} handler: #{@handlers[type].last}")
+    end
+
+    # @return [Hash<Symbol, Array>] containing all the handlers
+    def self.handlers
+      @handlers
+    end
+
+    # Run the handlers, typically called by the server
+    # @param event [Hash] from Slack Events API JSON data
+    def self.run(type, event)
+      logger = MosEisley.logger
+      logger.info("Running #{type} handlers...")
+      responses = []
+      @handlers[type].each { |h| responses << h.run(event) }
+      logger.info("Done running #{type} handlers.")
+      responses = [] if type == :event
+      merged_res = {}
+      responses.each do |r|
+        next unless r.class == Hash
+        [:response_type, :replace_original].each { |k| merged_res[k] = r[k] if r.has_key?(k) }
+        if r[:text]
+          if merged_res[:text]
+            merged_res[:text] += "\n#{r[:text]}"
+          else
+            merged_res[:text] = r[:text]
+          end
+        end
+        if r[:attachments]
+          merged_res[:attachments] ||= []
+          merged_res[:attachments] += r[:attachments]
+        end
+      end
+      return nil if merged_res.empty?
+      return merged_res
+    end
+
+    def initialize(type, &block)
+      @type = type
+      @block = block
+    end
+
+    def run(event)
+      logger = MosEisley.logger
+      logger.warn("No block to execute for #{@type} handler: #{self}") unless @block
+      logger.debug("Running #{@type} handler: #{self}")
+      @block.call(event)
+    rescue => e
+      logger.error(e.message)
+      logger.error(e.backtrace.join("\n"))
+      {text: "Woops, encountered an error."}
+    end
+
+  end
+
+end

data/lib/mos-eisley/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+
+module MosEisley
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.logger
+    @logger ||= NullLogger.new()
+  end
+
+  class NullLogger < Logger
+
+    def initialize(*args)
+    end
+
+    def add(*args, &block)
+    end
+
+  end
+
+end

data/lib/mos-eisley/version.rb

@@ -0,0 +1,5 @@
+module MosEisley
+
+  Version = '0.0.1'
+
+end

data/lib/mos-eisley.rb

@@ -0,0 +1,7 @@
+require 'mos-eisley/logger'
+require 'mos-eisley/config'
+require 'mos-eisley/handler'
+require 'http-client/client'
+require 'http-client/webapi'
+
+ME = MosEisley

data/lib/s3po/action.rb

@@ -0,0 +1,53 @@
+module MosEisley
+
+  module S3PO
+
+    class Action
+
+      attr_reader :event
+      attr_reader :original_message
+
+      def initialize(e)
+        @event = e
+        if e[:original_message]
+          @original_message = Message.new(e[:original_message])
+        end
+      end
+
+      def action
+        event[:actions][0]
+      end
+
+      def callback_id
+        event[:callback_id]
+      end
+
+      def channel
+        event[:channel][:id]
+      end
+
+      def user
+        event[:user][:id]
+      end
+
+      def message_ts
+        event[:message_ts]
+      end
+
+      def attachment_id
+        event[:attachment_id].to_i
+      end
+
+      def response_url
+        event[:response_url]
+      end
+
+      def message_age
+        Time.now.to_i - message_ts.to_i
+      end
+
+    end
+
+  end
+
+end

data/lib/s3po/generic.rb

@@ -0,0 +1,17 @@
+module MosEisley
+
+  module S3PO
+
+    class GenericEvent
+
+      attr_reader :event
+
+      def initialize(e)
+        @event = e
+      end
+
+    end
+
+  end
+
+end

data/lib/s3po/message.rb

@@ -0,0 +1,111 @@
+module MosEisley
+
+  module S3PO
+
+    class Message
+
+      attr_reader :event
+
+      def initialize(e)
+        @event = e
+      end
+
+      def message_type
+        return nil if event[:channel].nil?
+        t = :na
+        case event[:channel][0]
+        when 'C'
+          t = :channel
+        when 'D'
+          t = :im
+        when 'G'
+          t = :group
+        end
+        return t
+      end
+
+      def simple_message?
+        event[:subtype].nil?
+      end
+
+      def for_me?
+        # check user is not myself
+        myid = MosEisley.config.meta[:user_id]
+        return false if event[:user] == myid
+        return true if message_type == :im && simple_message?
+        return true if (event[:text] =~ /^<@#{myid}[|>]/) && simple_message?
+        return false
+      end
+
+      def text
+        event[:text]
+      end
+
+      def text=(t)
+        event[:text] = t
+      end
+
+      def attachments
+        event[:attachments]
+      end
+
+      def attachments=(a)
+        event[:attachments] = a
+      end
+
+      def user
+        event[:user]
+      end
+
+      def ts
+        event[:ts]
+      end
+
+      def channel
+        event[:channel]
+      end
+
+      def thread_ts
+        event[:thread_ts]
+      end
+
+      def arguments
+        return nil unless simple_message?
+        t = event[:text]
+        t = t.sub(/^<@#{MosEisley.config.meta[:user_id]}[|]?[^>]*>/, '') if for_me?
+        t.split
+      end
+
+      def postable_object
+        obj = @event.dup
+        return obj unless obj[:attachments]
+        obj[:attachments] = S3PO.json_with_object(obj[:attachments])
+        return obj
+      end
+
+      def reply(t = nil)
+        s = {
+          channel: channel,
+          as_user: true,
+          attachments: []
+        }
+        s[:text] = "<@#{user}> " unless message_type == :im
+        if thread_ts
+          s[:thread_ts] = thread_ts
+        elsif t
+          s[:thread_ts] = t
+        end
+        Message.new(s)
+      end
+
+      def reply_in_thread
+        t = thread_ts
+        t ||= ts
+        reply(t)
+      end
+
+    end
+
+  end
+
+end

data/lib/s3po/s3po.rb

@@ -0,0 +1,68 @@
+require 'json'
+require 'time'
+require 's3po/generic'
+require 's3po/action'
+require 's3po/message'
+
+module MosEisley
+
+  module S3PO
+
+    def self.parse_json(json)
+      return JSON.parse(json, {symbolize_names: true})
+    rescue => e
+      MosEisley.logger.warn("JSON parse error: #{e}")
+      return nil
+    end
+
+    # Convert object into JSON, optionally pretty-format
+    # @param obj [Object] any Ruby object
+    # @param opts [Hash] any JSON options
+    # @return [String] JSON string
+    def self.json_with_object(obj, pretty: false, opts: nil)
+      return '{}' if obj.nil?
+      if pretty
+        opts = {
+          indent: '  ',
+          space: ' ',
+          object_nl: "\n",
+          array_nl: "\n"
+        }
+      end
+      JSON.fast_generate(MosEisley::S3PO.format_json_value(obj), opts)
+    end
+
+    # Return Ruby object/value to JSON standard format
+    # @param val [Object]
+    # @return [Object]
+    def self.format_json_value(val)
+      s3po = MosEisley::S3PO
+      case val
+      when Array
+        val.map { |v| s3po.format_json_value(v) }
+      when Hash
+        val.reduce({}) { |h, (k, v)| h.merge({k => s3po.format_json_value(v)}) }
+      when String
+        val.encode!('UTF-8', {invalid: :replace, undef: :replace})
+      when Time
+        val.utc.iso8601
+      else
+        val
+      end
+    end
+
+    def self.create_event(e, type = nil)
+      type = e[:type] if e[:type]
+      case type
+      when 'message'
+        return Message.new(e)
+      when :action
+        return Action.new(e)
+      else
+        return GenericEvent.new(e)
+      end
+    end
+
+  end
+
+end

data/mos-eisley.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'mos-eisley/version'
+
+
+Gem::Specification.new do |s|
+  s.name          = 'mos-eisley'
+  s.version       = MosEisley::Version
+  s.authors       = ['Ken J.']
+  s.email         = ['kenjij@gmail.com']
+  s.summary       = %q{A Ruby based multi-purpose Slack app server}
+  s.description   = %q{A Ruby based HTTP server for accepting Slack actions, commands, events.}
+  s.homepage      = 'https://github.com/kenjij/mos-eisley'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 2.1'
+  s.add_runtime_dependency 'kajiki', '~> 1.1'
+  s.add_runtime_dependency 'thin', '~> 1.7'
+  s.add_runtime_dependency 'sinatra', '~> 2.0'
+  s.add_runtime_dependency 'em-http-request', '~> 1.1'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: mos-eisley
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ken J.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kajiki
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: A Ruby based HTTP server for accepting Slack actions, commands, events.
+email:
+- kenjij@gmail.com
+executables:
+- mos-eisley
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/mos-eisley
+- lib/http-client/client.rb
+- lib/http-client/webapi.rb
+- lib/http-server/helper.rb
+- lib/http-server/server.rb
+- lib/mos-eisley.rb
+- lib/mos-eisley/config.rb
+- lib/mos-eisley/handler.rb
+- lib/mos-eisley/logger.rb
+- lib/mos-eisley/version.rb
+- lib/s3po/action.rb
+- lib/s3po/generic.rb
+- lib/s3po/message.rb
+- lib/s3po/s3po.rb
+- mos-eisley.gemspec
+homepage: https://github.com/kenjij/mos-eisley
+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.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A Ruby based multi-purpose Slack app server
+test_files: []