lita-pubsub 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca7175e47eec1333171f11b8525d8c47b072fb87
+  data.tar.gz: 12acd3d976d766a796647c1329236c2acef28546
+SHA512:
+  metadata.gz: 5225391f61f94e2cf63ec77d292841b649153e67424d10948c8352bff9a228ed29db5edac8049e035b8f5acd7eb0c3c428f8fbe1ce7cc48152f8df6f03628313
+  data.tar.gz: ff11a64406a659ccf13d46d8d15b9e6e6ba206a1f557ab60c73fe903221edf3336b0374307ccf706d0f5da799332ce9e01a8797baef9ffd4490339f8f2b874de

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.byebug_history
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,124 @@
+# Lita PubSub
+
+PubSub notification system for [Lita](https://www.lita.io/), ported from [Hubot
+PubSub](https://github.com/spajus/hubot-pubsub).
+
+[![Build Status](https://travis-ci.org/spajus/lita-pubsub.png?branch=master)](https://travis-ci.org/spajus/lita-pubsub?branch=master)
+[![Coverage Status](https://coveralls.io/repos/github/spajus/lita-pubsub/badge.svg?branch=master)](https://coveralls.io/github/spajus/lita-pubsub?branch=master)
+
+## Possibilities
+
+`lita-pubsub` allows you to build a simple, yet powerful monitoring / notification system using your corporate chat. Simply subscribe events in appropriate chat rooms and publish info about these events via HTTP calls or from other Lita handlers when they happen.
+
+```
+              Lita PubSub Event Flow
+
++--------------+ +--------------+ +---------------+
+| Lita handler | | HTTP Request | | chat message  |<--+
++-------+------+ +-------+------+ +-------+-------+   |
+        |                |                |           |
+        |                v                |           |
+        |        +-------------+          |           |
+        +------->| lita-pubsub |<---------+           |
+                 +-------+-----+                      |
+                         |                            |
+                         v                            |
+                 +--------------+                     |
+             +---+     Lita     +---+                 |
+             |   +--------------+   |                 |
+             |                      |                 |
+             v                      v                 |
+       +---------------+  +---------------+           |
+       |  chatroom #1  |  |  chatroom #2  +-----------+
+       +---------------+  +---------------+
+```
+
+## How It Works
+
+```console
+$ bundle exec lita start
+Type "exit" or "quit" to end the session.
+Lita > lita help pubsub
+Lita: all subscriptions - pubsub: shows all subscriptions
+Lita: subscriptions - pubsub: shows current room subscriptions
+Lita: subscribers [of] EVENT - pubsub: shows rooms subscribed to EVENT
+Lita: subscribe EVENT - pubsub: subscribes room to event. subscribe to
+`unsubscribed.event` to debug missing events.
+Lita: unsubscribe EVENT - pubsub: subscribes current channel to event
+Lita: unsubscribe all events - pubsub: unsubscribes current channel from all
+events
+Lita: publish EVENT DATA - pubsub: publishes DATA to EVENT subscribers
+Lita > lita subscriptions
+Subscriptions for shell: []
+Lita > lita subscribe jenkins
+Subscribed shell to jenkins events
+# You would normally use HTTP API at lita:8080/publish for same result
+Lita > lita publish jenkins.build.fail Build #12141 failed!
+*jenkins.build.fail*: Build #12141 failed!
+Lita > lita publish nothing emptiness
+Lita > lita subscribe unsubscribed.event
+Subscribed shell to unsubscribed.event events
+Lita > lita publish nothing emptiness
+*unsubscribed.event*: nothing: emptiness
+Lita > lita subscribers of jenkins
+Subscribers of jenkins: ["shell"]
+```
+
+## Installation
+
+Add lita-pubsub to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-pubsub"
+```
+
+## Configuration
+
+```ruby
+
+# lita_config.rb
+
+Lita.configure do |config|
+  # optional password protection
+  config.handlers.pubsub.http_password = 's3cr3t'
+end
+```
+
+## Usage
+
+```
+lita subscribe <event>        # subscribes current room to event
+lita unsubscribe <event>      # unsubscribes current room from event
+lita unsubscribe all events   # unsubscribes current room from all events
+lita subscriptions            # show subscriptions of current room
+lita subscribers of <event>   # shows which rooms subscribe to event
+lita all subscriptions        # show all existing subscriptions
+lita publish <event> <data>   # triggers event
+```
+
+## HTTP Api
+
+```
+GET /publish?event=<event>&data=<text>[&password=<password>]
+```
+
+```
+POST /publish
+```
+
+ * Content-Type: `application/json`
+ * Body: `{ "password": "optional", "event": "event", "data": "text" }`
+
+## Event Namespaces
+
+Lita PubSub uses `.` as event namespace separator. I.e.: subscribing to `x.y`
+also subscribes to `x.y.*` events.
+
+## Handling unsubscribed events
+
+Do `lita subscribe unsubscribed.event` in a room where you want all unrouted
+events to get announced.
+
+## Warning
+
+HTTP password protection is trivial, and should not be used in public networks.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita/handlers/pubsub.rb

@@ -0,0 +1,199 @@
+module Lita
+  module Handlers
+    class Pubsub < Handler
+      config :http_password
+
+      http.get('/publish', :http_get)
+      http.post('/publish', :http_post)
+
+      route(
+        /^all subscriptions$/i,
+        :all_subscriptions,
+        command: true,
+        help: { 'all subscriptions' => 'pubsub: shows all subscriptions' }
+      )
+
+      route(
+        /^subscriptions$/i,
+        :subscriptions,
+        command: true,
+        help: { 'subscriptions' => 'pubsub: shows current room subscriptions' }
+      )
+
+      route(
+        /^subscribers (of )?([a-z0-9\-\.\:_]+)$/i,
+        :subscribers,
+        command: true,
+        help: { 'subscribers [of] EVENT' => 'pubsub: shows rooms subscribed to EVENT' }
+      )
+
+      route(
+        /^subscribe ([a-z0-9\-\.\:_]+)$/i,
+        :subscribe,
+        command: true,
+        help: { 'subscribe EVENT' => 'pubsub: subscribes room to event. subscribe to `unsubscribed.event` to debug missing events.' }
+      )
+
+      route(
+        /^unsubscribe ([a-z0-9\-\.\:_]+)$/i,
+        :unsubscribe,
+        command: true,
+        help: { 'unsubscribe EVENT' => 'pubsub: subscribes current channel to event' }
+      )
+
+      route(
+        /^unsubscribe all events$/i,
+        :unsubscribe_all,
+        command: true,
+        help: { 'unsubscribe all events' => 'pubsub: unsubscribes current channel from all events' }
+      )
+
+      route(
+        /^publish ([a-z0-9\-\.\:_]+) (.+)$/i,
+        :publish,
+        command: true,
+        help: { 'publish EVENT DATA' => 'pubsub: publishes DATA to EVENT subscribers' }
+      )
+
+      on(:publish) do |payload|
+        event = payload[:event]
+        rooms = find_subscriptions(event)
+        if rooms.any?
+          rooms.each do |room|
+            target = Source.new(room: room)
+            robot.send_message(target, format_message(event, payload[:data]))
+          end
+        else
+          if redis.smembers('pubsub.events.unsubscribed.event').any?
+            robot.trigger(
+              :publish,
+              event: 'unsubscribed.event',
+              data: "#{event}: #{payload[:data]}"
+            )
+          end
+        end
+      end
+
+      def http_get(request, response)
+        validate_http_password!(request.params['password'])
+        robot.trigger(
+          :publish,
+          event: request.params['event'],
+          data: request.params['data']
+        )
+        response.write('ok')
+      end
+
+      def http_post(request, response)
+        data = JSON.parse(request.body.read)
+        validate_http_password!(request.params['password'] || data['password'])
+        robot.trigger(
+          :publish,
+          event: data['event'],
+          data: data['data']
+        )
+        response.write('ok')
+      end
+
+      def all_subscriptions(response)
+        events = redis.smembers('pubsub.events').sort
+        subscriptions = events.map do |event|
+          "#{event} -> #{redis.smembers("pubsub.events.#{event}").sort}"
+        end
+        response.reply("All subscriptions:\n#{subscriptions.join("\n")}")
+      end
+
+      def subscriptions(response)
+        room = response.room
+        return response.reply('This command only works in a room') unless room
+        subscriptions = redis.smembers("pubsub.rooms.#{room.id}").sort
+        response.reply("Subscriptions for #{room.name}: #{subscriptions}")
+      end
+
+      def subscribers(response)
+        event = response.matches[0][1]
+        subscribers = find_subscriptions(event)
+        response.reply("Subscribers of #{event}: #{subscribers}")
+      end
+
+      def subscribe(response)
+        event = response.matches[0][0]
+        room = response.room
+        return response.reply('This command only works in a room') unless room
+        redis.sadd("pubsub.events", event)
+        redis.sadd("pubsub.rooms.#{room.id}", event)
+        redis.sadd("pubsub.events.#{event}", room.id)
+        response.reply("Subscribed #{room.name} to #{event} events")
+      end
+
+      def unsubscribe(response)
+        event = response.matches[0][0]
+        room = response.room
+        return response.reply('This command only works in a room') unless room
+        subscriptions = redis.smembers("pubsub.rooms.#{room.id}").sort
+        if subscriptions.include?(event)
+          redis.srem("pubsub.rooms.#{room.id}", event)
+          redis.srem("pubsub.events.#{event}", room.id)
+          subscribers = redis.smembers("pubsub.events.#{event}")
+          redis.srem("pubsub.events", event) if subscribers.empty?
+          response.reply("Unsubscribed #{room.name} from #{event} events")
+        else
+          response.reply(
+            "There is no #{event} subscription in #{room.name}.\n" \
+            "Current subscriptions: #{subscriptions}"
+          )
+        end
+      end
+
+      def unsubscribe_all(response)
+        room = response.room
+        return response.reply('This command only works in a room') unless room
+        subscriptions = redis.smembers("pubsub.rooms.#{room.id}").sort
+        subscriptions.each do |event|
+          redis.srem("pubsub.rooms.#{room.id}", event)
+          redis.srem("pubsub.events.#{event}", room.id)
+          subscribers = redis.smembers("pubsub.events.#{event}")
+          redis.srem("pubsub.events", event) if subscribers.empty?
+          response.reply("Unsubscribed #{room.name} from #{event} events")
+        end
+      end
+
+      def publish(response)
+        event, data = response.matches[0]
+        robot.trigger(:publish, event: event, data: data)
+      end
+
+      private
+
+      def format_message(event, data)
+        "*#{event}*: #{data}"
+      end
+
+      def find_subscriptions(event)
+        return [] if event.nil? || event.empty?
+        subscriptions = redis.smembers('pubsub.events').sort
+        if event.include?('.')
+          ev_parts = event.split('.')
+          matched = []
+          while ev_parts.any?
+            sub_ev = ev_parts.join('.')
+            if subscriptions.include?(sub_ev)
+              matched += redis.smembers("pubsub.events.#{sub_ev}").sort
+            end
+            ev_parts.pop
+          end
+          matched.sort.uniq
+        else
+          redis.smembers("pubsub.events.#{event}")
+        end
+      end
+
+      def validate_http_password!(password)
+        return if config.http_password.nil? || config.http_password.empty?
+        raise 'incorrect password!' if password != config.http_password
+      end
+
+      Lita.register_handler(self)
+    end
+  end
+end

data/lib/lita-pubsub.rb

@@ -0,0 +1,13 @@
+require 'json'
+require 'lita'
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require 'lita/handlers/pubsub'
+
+Lita::Handlers::Pubsub.template_root File.expand_path(
+  File.join('..', '..', 'templates'),
+ __FILE__
+)

data/lita-pubsub.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-pubsub"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Tomas Varaneckas"]
+  spec.email         = ["tomas.varaneckas@gmail.com"]
+  spec.description   = "PubSub notification system for Lita"
+  spec.summary       = "PubSub notification system for Lita"
+  spec.homepage      = "https://github.com/spajus/hubot-lita"
+  spec.license       = "MIT License"
+  spec.metadata      = { "lita_plugin_type" => "handler" }
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "lita", ">= 4.7"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

data/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  lita:
+    handlers:
+      pubsub:

data/spec/lita/handlers/pubsub_spec.rb

@@ -0,0 +1,153 @@
+require "spec_helper"
+
+describe Lita::Handlers::Pubsub, lita_handler: true do
+  let(:robot) { Lita::Robot.new(registry) }
+  subject { described_class.new(robot) }
+  let(:room) { Lita::Room.new('foos') }
+  let(:room2) { Lita::Room.new('bars') }
+
+  it 'subscribes current channel to event' do
+    send_message('lita subscribe foo', from: room)
+    send_message('lita subscriptions', from: room)
+    expect(replies.last).to eq('Subscriptions for foos: ["foo"]')
+  end
+
+  it 'unsubscribes current channel from event' do
+    send_message('lita subscribe foo', from: room)
+    send_message('lita subscriptions', from: room)
+    expect(replies.last).to eq('Subscriptions for foos: ["foo"]')
+
+    send_message('lita unsubscribe foo', from: room)
+    expect(replies.last).to eq("Unsubscribed foos from foo events")
+
+    send_message('lita subscriptions', from: room)
+    expect(replies.last).to eq('Subscriptions for foos: []')
+  end
+
+  it 'unsubscribes current channel from all events' do
+    send_message('lita subscribe foo', from: room)
+    send_message('lita subscribe bar', from: room)
+    send_message('lita subscribe baz', from: room)
+    send_message('lita unsubscribe all events', from: room)
+    expect(replies[-3]).to eq("Unsubscribed foos from bar events")
+    expect(replies[-2]).to eq("Unsubscribed foos from baz events")
+    expect(replies[-1]).to eq("Unsubscribed foos from foo events")
+
+    send_message('lita subscriptions', from: room)
+    expect(replies.last).to eq('Subscriptions for foos: []')
+  end
+
+  it 'shows room subscriptions' do
+    send_message('lita subscribe foo', from: room)
+    send_message('lita subscriptions', from: room)
+    expect(replies.last).to eq('Subscriptions for foos: ["foo"]')
+  end
+
+  it 'shows all subscriptions' do
+    send_message('lita subscribe foo', from: room)
+    send_message('lita subscribe bar', from: room)
+    send_message('lita subscribe bar', from: room2)
+    send_message('lita all subscriptions')
+    expect(replies.last).to eq("All subscriptions:\nbar -> [\"bars\", \"foos\"]\nfoo -> [\"foos\"]")
+  end
+
+  it 'shows subscribers of event' do
+    send_message("lita subscribe foo", from: room)
+    send_message("lita subscribe foo", from: room2)
+
+    send_message("lita subscribers foo")
+    expect(replies.last).to eq('Subscribers of foo: ["bars", "foos"]')
+
+    send_message("lita subscribers of foo")
+    expect(replies.last).to eq('Subscribers of foo: ["bars", "foos"]')
+  end
+
+  it 'publishes data to event subscribers' do
+    send_message("lita subscribe foo", from: room)
+    send_message("lita subscribe foo", from: room2)
+    send_message("lita publish foo bar de baz")
+    expect(replies[-1]).to eq('*foo*: bar de baz')
+    expect(replies[-2]).to eq('*foo*: bar de baz')
+  end
+
+  it 'publishes data to partial event subscribers' do
+    send_message("lita subscribe foo", from: room)
+    send_message("lita subscribe foo.bar", from: room2)
+    send_message("lita publish foo.bar i am foo.bar")
+    send_message("lita publish foo.baz i am foo.baz")
+    expect(replies.last(3).sort.uniq).to eq(
+      [
+        "*foo.bar*: i am foo.bar",
+        "*foo.baz*: i am foo.baz"
+      ]
+    )
+  end
+
+  it 'ignores unsubscribed events' do
+    send_message('lita publish foo bar de baz')
+    expect(replies).to be_empty
+  end
+
+  it 'publishes data to unsubscribed.event subscribers' do
+    send_message("lita subscribe unsubscribed.event", from: room)
+    send_message("lita publish foo bar de baz")
+    expect(replies.last).to eq('*unsubscribed.event*: foo: bar de baz')
+  end
+
+  it 'does not fail when unsubscribing unsubscribed event' do
+    send_message("lita unsubscribe bar", from: room)
+    expect(replies.last).to eq(
+      "There is no bar subscription in foos.\n" \
+      'Current subscriptions: []'
+    )
+  end
+
+  context 'http request' do
+    before { Lita.config.handlers.pubsub.http_password = 'secret' }
+
+    it 'receives events via http get' do
+      send_message("lita subscribe foo", from: room)
+      http.get('/publish?event=foo&data=bar%20baz&password=secret')
+      expect(replies.last).to eq('*foo*: bar baz')
+    end
+
+    it 'receives events via http post' do
+      send_message("lita subscribe foo", from: room)
+      http.post(
+        '/publish',
+        '{"event": "foo", "data":"bar baz", "password":"secret"}',
+        'Content-Type' => 'application/json'
+      )
+      expect(replies.last).to eq('*foo*: bar baz')
+    end
+
+    it 'receives events via http get when password is not set' do
+      send_message("lita subscribe foo", from: room)
+      Lita.config.handlers.pubsub.http_password = nil
+      http.get('/publish?event=foo&data=bar%20baz')
+      expect(replies.last).to eq('*foo*: bar baz')
+    end
+
+    it 'rejects http request without any password' do
+      expect {
+        http.get('/publish?event=foo&data=bar%20baz')
+      }.to raise_error('incorrect password!')
+    end
+
+    it 'rejects bad password via http get' do
+      expect {
+        http.get('/publish?event=foo&data=bar%20baz&password=haxor')
+      }.to raise_error('incorrect password!')
+    end
+
+    it 'rejects bad password via http post' do
+      expect {
+        http.post(
+          '/publish',
+          '{"event":"foo", "data":"bar baz", "password":"lol"}',
+          'Content-Type' => 'application/json'
+        )
+      }.to raise_error('incorrect password!')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'pry-byebug'
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+])
+SimpleCov.start { add_filter "/spec/" }
+
+require "lita-pubsub"
+require "lita/rspec"
+
+# A compatibility mode is provided for older plugins upgrading from Lita 3. Since this plugin
+# was generated with Lita 4, the compatibility mode should be left disabled.
+Lita.version_3_compatibility_mode = false

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: lita-pubsub
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomas Varaneckas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: PubSub notification system for Lita
+email:
+- tomas.varaneckas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/lita-pubsub.rb
+- lib/lita/handlers/pubsub.rb
+- lita-pubsub.gemspec
+- locales/en.yml
+- spec/lita/handlers/pubsub_spec.rb
+- spec/spec_helper.rb
+- templates/.gitkeep
+homepage: https://github.com/spajus/hubot-lita
+licenses:
+- MIT License
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: PubSub notification system for Lita
+test_files:
+- spec/lita/handlers/pubsub_spec.rb
+- spec/spec_helper.rb