lita-slack-standup 0.1.0

data/README.md

@@ -0,0 +1,35 @@
+# lita-standup
+
+ - lita-standup is a gem for Lita (https://www.lita.io/), a chat bot written in ruby.
+ - It handles standup meetings on slack (the sentences are in french for now).
+
+## Installation
+
+Add lita-standup to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-standup"
+```
+
+## Configuration
+
+In your lita configuration file (lita_config.rb), add the lines :
+``` ruby
+Lita.congifure do |config|
+  ## standup
+  config.handlers.standup.channel = ENV['STANDUP_CHANNEL']
+end
+```
+
+And set the environment variable STANDUP_CHANNEL, with the name of the channel where you want to held the standup.
+
+## Usage
+
+!start standup : launches the standup, prints the standups already filled and asks for someone else to report
+!next standup : skips the current user and asks the next user to do his standup report
+!standup <some standup report> : saves your standup. If you do it before the start of the standup, you won't be asked to report. The bot will displays your standup in your stead
+!ignore <some user> : ignores an user for the standups
+!unignore <some user> : unignores an user
+!list ignore : list all ignored users
+
+The standup stops when everyone has done his report or has been skipped.

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-slack-standup.rb

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

data/lib/lita/handlers/slack_standup.rb

@@ -0,0 +1,166 @@
+module Lita
+  module Handlers
+    class SlackStandup < Handler
+      include SlackClient
+
+      config :channel
+
+      route(/^start\s*standup?/, :start_standup, command: true, help: {"start standup" => "Lance le standup." })
+
+      def start_standup(message=nil)
+        in_standup.value = 'true'
+        setup_redis_objects
+        send_message(config.channel, 'Hello <!channel> ! Le standup va commencer : )')
+        prewritten_standups_summary
+        next_standup
+      end
+
+      route(/^standup\s*(.*)$/, :standup, command: true, help: {"standup texte" => "Permet d'écrire son standup à l'avance ou pendant le tour d'un autre."})
+
+      def standup(message)
+        setup_redis_objects
+        save_standup message
+        message.reply("Ton standup est enregistré. Merci :)")
+      end
+
+      route(/^next\s*standup?/, :next_standup, command: true, help: {"next standup" => "Passe à l'utilisateur suivant et considère le standup précédent comme fait."})
+
+      def next_standup(message=nil)
+        if in_standup.value == 'true'
+          if standup_members.none? { |user, standup| standup.empty? }
+            end_standup
+          else
+            next_attendee = select_next_standup
+            send_message(config.channel,"Bonjour <@#{next_attendee}> ! C'est à ton tour de parler.") 
+            fill_standup(next_attendee)
+          end
+        else
+          send_message(config.channel,"La commande n'est pas disponible en dehors d'un standup.")
+        end
+      end
+
+      def reminder
+        standup_members.each do |user, standup|
+          send_message("@#{user}","Bonsoir <@#{user}> ! Tu peux donner ton standup pour demain. !standup 3615mavie") if standup.empty?
+        end
+      end
+
+      route(/^ignore\s*(.*)$/, :ignore, command: true, help: {"ignore nom" => "Retire un utilisateur de la liste des personnes ayant à faire le standup"})
+
+      def ignore(message)
+        user = message.matches[0][0].gsub('@','')
+        unless ignored_members.include? user
+          ignored_members << user
+          standup_members.delete(user)
+        end
+        message.reply("<@#{user}> est désormais ignoré jusqu'à nouvel ordre.")
+      end
+
+      route(/^unignore\s*(.*)$/, :unignore, command: true, help: {"unignore nom" => "Remet l'utilisateur dans la liste des personnes participant aux standups."})
+
+      def unignore(message)
+        user = message.matches[0][0].gsub('@','')
+        if ignored_members.include? user
+          ignored_members.delete(user)
+          standup_members[user] = ''
+        end
+        message.reply("<@#{user}> est à nouveau inclus dans les standups.")
+      end
+
+      route(/^list\s*ignore?/, :list_ignore, command: true, help: {"list ignore" => "Liste les utilisateurs ignorés."})
+
+      def list_ignore(message)
+        reply = "Utilisateurs ignorés : "
+        ignored_members.each do |user|
+          reply += "#{user}  "
+        end
+        message.reply(reply)
+      end
+
+      private 
+
+      def in_standup
+        @in_standup ||= Redis::Value.new('in_standup', redis, marshal: true)
+      end
+
+      def ignored_members
+        @ignored_members ||= Redis::List.new('ignored_members', redis)
+      end
+
+      def setup_redis_objects
+          update_ids_to_members if ids_to_members.empty?
+          update_standup_members if standup_members.empty?
+      end
+
+      def standup_members
+        @standup_members ||= Redis::HashKey.new('standup_members', redis, marshal: true)
+      end
+
+      def retrieve_channel
+        slack_client.channels_list['channels'].
+          find do |channel| 
+            "##{ channel['name'] }" == config.channel 
+          end
+      end
+
+      def fill_standup_members(members_list)
+        members_list.each do |user_id|
+          name = ids_to_members[user_id]
+          standup_members[name] = '' unless ignored_members.include?(name)
+        end
+      end
+
+      def update_standup_members
+        standup_members.clear
+        members_list = retrieve_channel['members']
+        fill_standup_members(members_list)
+      end
+
+      def ids_to_members
+        @ids_to_members ||= Redis::HashKey.new('ids_to_members', redis, marshal: true)
+      end
+
+      def update_ids_to_members
+        ids_to_members.clear
+        slack_client.users_list['members'].each do |user|
+          @ids_to_members[user['id']] = user['name']
+        end
+      end
+
+      def prewritten_standups_summary
+        standup_members.each do |user, standup|
+            display_standup(user, standup) unless standup.empty?
+        end
+      end
+
+      def display_standup(user, standup)
+        send_message(config.channel, "#{user} a déjà renseigné son standup : \n #{standup}")         
+      end
+
+      def save_standup(message)
+        member = message.user.mention_name
+        standup_report = message.matches[0][0]
+        standup_members[member] = standup_report
+      end
+
+      def fill_standup(member)
+        standup_members[member] = 'Standup fait en live.'
+      end
+
+      def select_next_standup
+        standup_members.select{ |key,value| value.empty? }.first.first
+      end
+
+
+      def end_standup
+        in_standup.value = 'false'
+
+        send_message(config.channel, "Et voilà ! C'est bon pour aujourd'hui. Merci tout le monde :parrot:")
+        update_standup_members
+        update_ids_to_members
+      end
+
+    end
+    Lita.register_handler(SlackStandup)
+  end
+end

data/lib/slack_client.rb

@@ -0,0 +1,17 @@
+require 'slack-ruby-client'
+
+module SlackClient
+  def slack_client
+    @slack_client ||= Slack::Web::Client.new
+  end
+
+  private
+
+  def send_message(channel, message)
+    slack_client.chat_postMessage(
+      channel: channel,
+      text: message,
+      as_user: true
+    )
+  end
+end

data/lita-slack-standup.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-slack-standup"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Sybil Deboin"]
+  spec.email         = ["sybil.deboin@gmail.com"]
+  spec.description   = "Standup feature for slack"
+  spec.summary       = ""
+  spec.homepage      = "https://github.com/blackbirdco/lita-slack-standup"
+  spec.license       = "GNU v3.0"
+  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_runtime_dependency "lita-slack"
+  spec.add_runtime_dependency "slack-ruby-client"
+  spec.add_runtime_dependency "redis-objects"
+
+  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 "webmock"
+  spec.add_development_dependency "vcr" 
+end

data/locales/en.yml

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

data/spec/lita/handlers/standup_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+describe Lita::Handlers::Standup, lita_handler: true do
+
+  let(:channel) { "#jambot-test" }
+  let(:robot_name) { "jambot-test" }
+  let(:sybil) { Lita::User.create(1000, name: "sybil") }
+  let(:zaratan) { Lita::User.create(1001, name: "zaratan") }
+
+  before(:all) do
+    Slack.configure do |config|
+      config.token = ENV['SLACK_LITA_TOKEN']
+    end
+    Lita.configure do |config|
+      config.handlers.standup.channel = '#jambot-test'
+    end
+  end
+
+  let(:registry) do
+    reg = Lita::Registry.new
+    reg.register_handler(Lita::Handlers::Standup)
+    reg.configure do |config|
+      config.robot.name = robot_name
+      config.robot.alias = "!"
+      config.robot.adapter = :slack
+      config.handlers.standup.channel = channel
+    end
+
+    reg
+  end
+
+  before do
+    standup = Lita::Handlers::Standup.new(robot)
+    standup.send(:standup_members).clear
+    standup.send(:ids_to_members).clear
+    standup.send(:ignored_members).clear 
+    ['jambot','slackbot','sybil_test'].each do |ignored_member|
+      standup.send(:ignored_members) << ignored_member
+    end
+  end
+
+  describe "when standup starts" do
+
+    subject do 
+      send_message("!start standup", as: sybil, from: channel)
+    end
+
+    it "starts standup", vcr: {cassette_name: 'start_standup'} do
+      [ "Hello <!channel> ! Le standup va commencer : )",
+        "Bonjour <@zaratan> ! C'est à ton tour de parler."
+      ].each do |text|
+        expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>text, :as_user=>true})
+      end 
+ 
+      subject 
+    end
+
+    it "annoys people only on working days" do
+      #standup test that it's called on weekday
+    end
+
+    context "with pre-filled reports" do
+      it "displays known reports", vcr: {cassette_name: 'standup_prefilled'} do
+        send_message("!standup My standup report for testing purposes", as: sybil, from: channel)
+
+	[ "Hello <!channel> ! Le standup va commencer : )",
+	  "sybil a déjà renseigné son standup : \n My standup report for testing purposes",
+	  "Bonjour <@zaratan> ! C'est à ton tour de parler."
+	].each do |text|
+	  expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>text, :as_user=>true})
+	end
+
+        subject
+      end
+      context "with all reports pre-filled", vcr: {cassette_name: 'standups_all_prefilled'} do
+        it "displays the standups and ends the meeting" do
+          send_message("!standup My standup report for testing purposes", as: sybil, from: channel)   
+          send_message("!standup My standup report for testing purposes", as: zaratan, from: channel)   
+
+ 	  [ "Hello <!channel> ! Le standup va commencer : )",
+	    "zaratan a déjà renseigné son standup : \n My standup report for testing purposes",
+	    "sybil a déjà renseigné son standup : \n My standup report for testing purposes",
+	    "Et voilà ! C'est bon pour aujourd'hui. Merci tout le monde :parrot:"
+	  ].each do |text|
+	    expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>text, :as_user=>true})       
+          end
+
+          subject
+        end
+      end
+    end
+  end
+
+  describe "!standup command", vcr: {cassette_name: 'standup'} do
+    subject do 
+      send_message("!standup My standup report for testing purposes", as: sybil, from: channel)
+    end
+
+    context "when the user reports" do
+      it "saves the report" do
+        subject
+        expect(replies.last).to eq("Ton standup est enregistré. Merci :)")
+      end
+    end
+  end
+
+  describe "!next standup command" do
+    subject do
+      send_message("!next standup", as: sybil, from: channel)
+    end
+
+    context "when its called oustide of standups", vcr: {cassette_name: 'next_standup_refused'} do
+      it "is not available" do
+        expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>"La commande n'est pas disponible en dehors d'un standup.", :as_user=>true})
+       
+        subject  
+      end
+    end
+
+    context "when it's called during standup", vcr: {cassette_name: 'next_standup'} do
+      it "asks the next user to report" do
+        send_message("!start standup", as: sybil, from: channel)
+ 
+        expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>"Bonjour <@sybil> ! C'est à ton tour de parler.", :as_user=>true})
+       
+        subject  
+      end
+    end
+  end
+
+  describe "!ignore user command", vcr: {cassette_name: 'ignore_user'} do
+
+    subject do 
+      send_message("!ignore sybil", as: sybil, from: channel)
+      send_message("!next standup", as: sybil, from: channel)
+    end
+
+    it "ignores an user" do
+      send_message("!start standup", as: sybil, from: channel)
+
+      expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>"Et voilà ! C'est bon pour aujourd'hui. Merci tout le monde :parrot:", :as_user=>true})
+
+      subject 
+      expect(replies.last).to eq("<@sybil> est désormais ignoré jusqu'à nouvel ordre.")
+    
+    end
+  end
+
+  describe "!unignore user command", vcr: {cassette_name: 'unignore_user'} do
+
+    subject do 
+      send_message("!unignore sybil", as: sybil, from: channel)
+      send_message("!next standup", as: sybil, from: channel)
+    end
+
+    it "unignores an user" do
+      send_message("!start standup", as: sybil, from: channel)
+      send_message("!ignore sybil", as: sybil, from: channel)
+
+      expect_any_instance_of(Slack::Web::Client).to receive(:chat_postMessage).with({:channel=>channel, :text=>"Bonjour <@sybil> ! C'est à ton tour de parler.", :as_user=>true})
+
+      subject 
+      expect(replies.last).to eq("<@sybil> est à nouveau inclus dans les standups.")
+    
+    end
+  end
+
+end