lita-standups 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82008368e3b720587006e5591b4bacb7f23d7aa4
+  data.tar.gz: 04a147d56cfba2c231ff58014fd5be92b5ff5bda
+SHA512:
+  metadata.gz: eff194daa8fc8f234492b4449d0923d541a5c55fa75fd07d239d15d1a93cce3bf7dd6192ada5454387267822ae1db2b7d7b16e043dd947d5764d22ec37562e79
+  data.tar.gz: 3d307792f13acc18a50dc76c83069173cb1ccdfc10b72dba422cfe48f31186290cac7fb16c339e7618a5f796ef1a241efe1969add2d85b5beda5812172a45499

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format=documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,51 @@
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.3
+
+
+Style/Encoding:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Style/Documentation:
+  Enabled: false
+
+Style/AndOr:
+  EnforcedStyle: conditionals
+
+Style/EmptyLinesAroundClassBody:
+  EnforcedStyle: empty_lines
+
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  []
+    '%i': []
+    '%q': ()
+    '%Q': ()
+    '%r': '{}'
+    '%s': []
+    '%w': []
+    '%W': []
+    '%x': ()
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Style/GuardClause:
+  MinBodyLength: 1
+
+Metrics/LineLength:
+  Max: 120

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.3.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server
+notifications:
+  email: false

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,37 @@
+guard :bundler do
+  require 'guard/bundler'
+  require 'guard/bundler/verify'
+  helper = Guard::Bundler::Verify.new
+
+  files = ['Gemfile']
+  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+
+  # Assume files are symlinked from somewhere
+  files.each { |file| watch(helper.real_path(file)) }
+end
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Cristian Bica
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# lita-standups
+
+[![Build Status](https://travis-ci.org/cristianbica/lita-standups.png?branch=master)](https://travis-ci.org/cristianbica/lita-standups)
+[![Coverage Status](https://coveralls.io/repos/github/cristianbica/lita-standups/badge.svg?branch=master)](https://coveralls.io/github/cristianbica/lita-standups?branch=master)
+
+
+lita-standups is a [Lita](http://lita.io) plugin which allows you to run standups with your team.
+
+## Installation
+
+Add lita-standups to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-standups"
+```
+
+## Usage
+
+```
+list standups - list configured standups
+create standup - create a standup
+show standup STANDUP_ID - shows details of a standup
+delete standup STANDUP_ID - deletes a standup
+schedule standup STANDUP_ID - schedule a standup
+unschedule standup SCHEDULE_ID - unschedule a standup
+list standups schedules - shows scheduled standups
+show standup schedule SCHEDULE_ID - shows a scheduled standup
+run standup STANDUP_ID with USERS - runs a standup now (users space/eparated)
+list standup sessions - list all standups sessions
+show standup session SESSION_ID - show a standups session details
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/cristianbica/lita-standups/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+

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/standups.rb

@@ -0,0 +1,155 @@
+module Lita
+  module Handlers
+    class Standups < Handler
+
+      route(/^list standups$/, :list_standups,
+            command: true,
+            help: { 'list standups' => 'list configured standups' })
+
+      route(/^create standup$/, :create_standup,
+            command: true,
+            help: { 'create standup' => 'create a standup' })
+
+      route(/^show standup (\w+)$/, :show_standup,
+            command: true,
+            help: { 'show standup STANDUP_ID' => 'shows details of a standup' })
+
+      route(/^delete standup (\w+)$/, :delete_standup,
+            command: true,
+            help: { 'delete standup STANDUP_ID' => 'deletes a standup' })
+
+      route(/^schedule standup (\w+)$/, :create_standups_schedule,
+            command: true,
+            help: { 'schedule standup STANDUP_ID' => 'schedule a standup' })
+
+      route(/^unschedule standup (\w+)$/, :delete_standups_schedule,
+            command: true,
+            help: { 'unschedule standup SCHEDULE_ID' => 'unschedule a standup' })
+
+      route(/^list standups schedules$/, :show_standups_schedule,
+            command: true,
+            help: { 'list standups schedules' => 'shows scheduled standups' })
+
+      route(/^show standup schedule (\w+)$/, :show_standup_schedule,
+            command: true,
+            help: { 'show standup schedule SCHEDULE_ID' => 'shows a scheduled standup' })
+
+      route(/^run standup (.+) with (.*)$/, :run_standup,
+            command: true,
+            help: { 'run standup STANDUP_ID with USERS' => 'runs a standup now (users space/comma separated)' })
+
+      route(/^list standup sessions$/, :list_standup_sessions,
+            command: true,
+            help: { 'list standup sessions' => 'list all standups sessions' })
+
+      route(/^show standup session (\w+)$/, :show_standup_session,
+            command: true,
+            help: { 'show standup session SESSION_ID' => 'show a standups session details' })
+
+      def list_standups(request)
+        standups = Models::Standup.all.to_a
+        message = "Standups found: #{standups.size}."
+        message << " Here they are: \n" if standups.size>0
+        message << standups.map(&:summary).join("\n")
+        request.reply message
+      end
+
+      def create_standup(request)
+        start_wizard Wizards::CreateStandup, request.message
+      end
+
+      def show_standup(request)
+        standup = Models::Standup[request.matches[0][0]]
+        if standup
+          request.reply "Here are the details of your standup: \n>>>\n#{standup.description}"
+        else
+          request.reply "I couldn't find a standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def delete_standup(request)
+        standup = Models::Standup[request.matches[0][0]]
+        if standup
+          standup.delete
+          request.reply "Standup with ID #{standup.id} has been deleted"
+        else
+          request.reply "I couldn't find a standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def create_standups_schedule(request)
+        standup = Models::Standup[request.matches[0][0]]
+        if standup
+          start_wizard Wizards::ScheduleStandup, request.message, 'standup_id' => standup.id
+        else
+          request.reply "I couldn't find a standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def show_standups_schedule(request)
+        schedules = Models::StandupSchedule.all.to_a
+        message = "Scheduled standups found: #{schedules.size}."
+        message << " Here they are: \n" if schedules.size>0
+        message << schedules.map(&:summary).join("\n")
+        request.reply message
+      end
+
+      def delete_standups_schedule(request)
+        schedule = Models::StandupSchedule[request.matches[0][0]]
+        if schedule
+          robot.unschedule_standup(schedule)
+          schedule.delete
+          request.reply "Schedule with ID #{schedule.id} has been deleted"
+        else
+          request.reply "I couldn't find a scheduled standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def show_standup_schedule(request)
+        schedule = Models::StandupSchedule[request.matches[0][0]]
+        if schedule
+          request.reply "Here are the details: \n>>>\n#{schedule.description}"
+        else
+          request.reply "I couldn't find a scheduled standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def run_standup(request)
+        standup = Models::Standup[request.matches[0][0]]
+        recipients = request.matches[0][1].to_s.gsub("@", "").split(/[\s,\n]/m).map(&:strip).map(&:presence).compact
+        if standup
+          request.reply "I'll run the standup shortly and post the results here. Thanks"
+          robot.run_standup standup.id, recipients, request.message.source.room
+        else
+          request.reply "I couldn't find a standup with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def list_standup_sessions(request)
+        sessions = Models::StandupSession.all.to_a
+        message = "Sessions found: #{sessions.size}."
+        message << " Here they are: \n" if sessions.size>0
+        message << sessions.map(&:summary).join("\n")
+        request.reply message
+      end
+
+      def show_standup_session(request)
+        session = Models::StandupSession[request.matches[0][0]]
+        if session
+          message = "Here are the standup session details: \n #{session.description}\n"
+          message << "\n*Responses:*\n"
+          message << session.report_message
+          request.reply message
+        else
+          request.reply "I couldn't find a standup session with ID=#{request.matches[0][0]}"
+        end
+      end
+
+      def self.const_missing(name)
+        Lita::Standups.const_defined?(name) ? Lita::Standups.const_get(name) : super
+      end
+
+      Lita.register_handler(self)
+    end
+  end
+end

data/lib/lita/standups/manager.rb

@@ -0,0 +1,86 @@
+module Lita
+  module Standups
+    class Manager
+
+      EXPIRATION_TIME = 3600
+
+      def self.run(robot:, standup_id:, recipients:, room:)
+        session = Models::StandupSession.create(
+          standup_id: standup_id,
+          recipients: recipients,
+          room: room
+        )
+        new(robot: robot, session: session).run
+      end
+
+      def self.run_schedule(robot:, schedule_id:)
+        schedule = Models::StandupSchedule[schedule_id]
+        session = Models::StandupSession.create(
+          standup_id: schedule.standup_id,
+          standup_schedule_id: schedule.id,
+          recipients: schedule.recipients,
+          room: schedule.channel
+        )
+        new(robot: robot, session: session).run
+      end
+
+      def self.abort_expired_standups(robot:)
+        Lita::Standups::Models::StandupResponse.find(status: "pending").union(status: "running").each do |response|
+          next unless Time.current - response.created_at > EXPIRATION_TIME
+          response.expired!
+          response.save
+          Lita::Wizard.cancel_wizard(response.user.id)
+          target = Lita::Source.new(user: response.user, room: nil, private_message: true)
+          robot.send_message target, "Expired. See you next time!"
+        end
+      end
+
+      def self.complete_finished_standups(robot:)
+        Lita::Standups::Models::StandupSession.find(status: "completed", results_sent: false).each do |session|
+          new(robot: robot, session: session).post_results
+        end
+      end
+
+      attr_accessor :robot, :session
+
+      def initialize(robot:, session:)
+        @robot = robot
+        @session = session
+      end
+
+      def standup
+        session.standup
+      end
+
+      def room
+        @room ||= Lita::Source.new(user: nil, room: session.room)
+      end
+
+      def run
+        session.running!
+        session.save
+        session.recipients.each { |recipient| ask_questions(recipient) }
+      end
+
+      def ask_questions(recipient)
+        user = Lita::User.fuzzy_find(recipient)
+        response = Models::StandupResponse.create(
+          standup_session_id: session.id,
+          user_id: user.id
+        )
+        dummy_source = Lita::Source.new(user: user, room: nil, private_message: true)
+        dummy_message = Lita::Message.new(robot, '', dummy_source)
+        Wizards::RunStandup.start robot, dummy_message, 'response_id' => response.id
+      end
+
+      def post_results
+        return if session.results_sent
+        message = "The standup '#{standup.name}' has finished. Here's what everyone posted:\n\n#{session.report_message}"
+        robot.send_message room, message
+        session.results_sent = true
+        session.save
+      end
+
+    end
+  end
+end

data/lib/lita/standups/mixins/robot.rb

@@ -0,0 +1,70 @@
+module Lita
+  module Standups
+    module Mixins
+      module Robot
+        def initialize(*args)
+          @scheduler = Rufus::Scheduler.new if scheduler_enabled?
+          super
+        end
+
+        # :nocov:
+        def scheduler
+          @scheduler
+        end
+        # :nocov:
+
+        def scheduler_enabled?
+          ENV['TEST'].nil?
+        end
+
+        def schedule_standups
+          return unless scheduler_enabled?
+          scheduler.jobs.each(&:unschedule)
+          scheduler.cron '* * * * *', tags: [:standup_schedules, :abort_expired] do |job|
+            Lita::Standups::Manager.abort_expired_standups(robot: self)
+          end
+          scheduler.cron '* * * * *', tags: [:standup_schedules, :complete_finished] do |job|
+            Lita::Standups::Manager.complete_finished_standups(robot: self)
+          end
+          Models::StandupSchedule.all.each do |standup_schedule|
+            schedule_standup(standup_schedule)
+          end
+        end
+
+        def schedule_standup(standup_schedule)
+          return unless scheduler_enabled?
+          scheduler.cron standup_schedule.cron_line, schedule_id: standup_schedule.id,
+            tags: [:standup_schedules, "standup_schedule_#{standup_schedule.id}"] do |job|
+            Lita::Standups::Manager.run_schedule(robot: self, schedule_id: job.opts[:schedule_id])
+          end
+        end
+
+        def unschedule_standup(standup_schedule)
+          return unless scheduler_enabled?
+          scheduler.jobs(tags: [:standup_schedules, "standup_schedule_#{standup_schedule.id}"]).each(&:unschedule)
+        end
+
+        def run_standup(standup_id, recipients, room_id)
+          if scheduler_enabled?
+            scheduler.in "5s", tags: [:standup_schedules, :run_standup] do |job|
+              Lita::Standups::Manager.run(robot: self, standup_id: standup_id, recipients: recipients, room: room_id)
+            end
+          else
+            Lita::Standups::Manager.run(robot: self, standup_id: standup_id, recipients: recipients, room: room_id)
+          end
+        end
+
+        # :nocov:
+        def run
+          schedule_standups
+          super
+        end
+        # :nocov:
+      end
+    end
+  end
+
+  class Robot
+    prepend ::Lita::Standups::Mixins::Robot
+  end
+end

data/lib/lita/standups/models/standup.rb

@@ -0,0 +1,31 @@
+module Lita
+  module Standups
+    module Models
+      class Standup < Ohm::Model
+
+        include Ohm::Callbacks
+        include Ohm::Timestamps
+        include Ohm::DataTypes
+
+        attribute :name
+        attribute :questions, Type::Array
+
+        collection :schedules, StandupSchedule, :standup
+
+        def summary
+          "#{name} (ID: #{id}) - #{questions.size} question(s)"
+        end
+
+        def description
+          [
+            "ID: #{id}",
+            "Name: #{name}",
+            "Questions:",
+            questions.join("\n")
+          ].join("\n")
+        end
+
+      end
+    end
+  end
+end

data/lib/lita/standups/models/standup_response.rb

@@ -0,0 +1,72 @@
+module Lita
+  module Standups
+    module Models
+      class StandupResponse < Ohm::Model
+
+        include Ohm::Callbacks
+        include Ohm::Timestamps
+        include Ohm::DataTypes
+
+        attribute :status
+        attribute :user_id
+        attribute :answers, Type::Array
+
+        reference :standup_session, StandupSession
+
+        index :status
+        index :user_id
+
+        def user
+          @user ||= Lita::User.fuzzy_find(user_id)
+        end
+
+        def standup
+          standup_session.standup
+        end
+
+        def questions
+          standup.questions
+        end
+
+        def before_create
+          self.status ||= 'pending'
+        end
+
+        def after_save
+          standup_session.update_status if finished?
+        end
+
+        %w(pending running completed aborted expired).each do |status_name|
+          define_method("#{status_name}?") do
+            status == status_name
+          end
+          define_method("#{status_name}!") do
+            self.status = status_name
+          end
+        end
+
+        def finished?
+          completed? || aborted? || expired?
+        end
+
+        def report_message
+          message = "#{user.name} (a.k.a @#{user.mention_name})\n"
+          if answers.is_a?(Array)
+            questions.map.with_index do |question, index|
+              if answers[index]
+                message << "> *#{question}*\n"
+                answers[index].split("\n").each do |line|
+                  message << "> #{line}\n"
+                end
+              end
+              message << "> \n" if index < questions.count - 1
+            end
+          else
+            message << "> *Expired*\n"
+          end
+          message
+        end
+      end
+    end
+  end
+end

data/lib/lita/standups/models/standup_schedule.rb

@@ -0,0 +1,54 @@
+module Lita
+  module Standups
+    module Models
+      class StandupSchedule < Ohm::Model
+
+        include Ohm::Callbacks
+        include Ohm::Timestamps
+        include Ohm::DataTypes
+
+        attribute :repeat
+        attribute :day_of_week
+        attribute :time, Type::Time
+        attribute :recipients, Type::Array
+        attribute :channel
+
+        reference :standup, Standup
+
+        def cron_line
+          [
+            time.min,
+            time.hour,
+            "*",
+            "*",
+            (weekly? ? day_of_week_index : "*")
+          ].join(" ")
+        end
+
+        def day_of_week_index
+          %w(sunday monday tuesday wednesday thursday friday saturday).index(day_of_week)
+        end
+
+        def summary
+          day_text = weekly? ? " on #{day_of_week}" : ""
+          "ID: #{id} - running standup #{standup.name} (ID: #{standup.id}) #{repeat}#{day_text} at #{time.strftime("%H:%M")}"
+        end
+
+        def description
+          [
+            "ID: #{id}",
+            "Standup: #{standup.name} (ID: #{standup.id})",
+            "Recipients: #{recipients.join(", ")}",
+            "Running #{repeat} " + (weekly? ? "on #{day_of_week} " : "") + "at #{time.strftime("%H:%M")}",
+            "Sending the result on #{channel}"
+          ].join("\n")
+        end
+
+        def weekly?
+          repeat == "weekly"
+        end
+
+      end
+    end
+  end
+end