waylon-core 0.1.1 → 0.1.2

data/lib/waylon/skill_registry.rb

@@ -5,6 +5,8 @@ module Waylon
   class SkillRegistry
     include Singleton
 
+    attr_reader :routes
+
     # A wrapper around the singleton #register method
     # @param name [String] The name of the skill in the registry
     # @param class_name [Class] The class to associate with the name
@@ -14,8 +16,24 @@ module Waylon
       instance.register(name, class_name, condition)
     end
 
-    def default_route
-      Routes::Default.new
+    def self.find_by_name(name)
+      [
+        *instance.routes,
+        Routes::PermissionDenied.new,
+        Routes::BlackHole.new,
+        Routes::Default.new
+      ].find { |r| r.name == name.to_s }
+    end
+
+    def self.route(message)
+      instance.route(message)
+    end
+
+    # Provides the default route based on the received message.
+    # @param message [Waylon::Message] The received message
+    # @return [Waylon::Route]
+    def default_route(message)
+      message.to_bot? ? Routes::Default.new : Routes::BlackHole.new
     end
 
     # Gathers a Hash of help data for all routes a user is permitted to access
@@ -23,9 +41,13 @@ module Waylon
     # @return [Hash]
     def help(user)
       data = {}
-      @routes.select { |r| r.permits?(user) }.each do |permitted|
-        data[permitted.destination.config_namespace] ||= []
-        data[permitted.destination.config_namespace] << { name: permitted.name, help: permitted.help } if permitted.help
+      @routes.select { |r| r.permits?(user) && r.mention_only? }.each do |permitted|
+        data[permitted.destination.component_namespace] ||= []
+        data[permitted.destination.component_namespace] << if permitted.help
+                                                             { name: permitted.name, help: permitted.help }
+                                                           else
+                                                             { name: permitted.name }
+                                                           end
       end
 
       data.reject { |_k, v| v.empty? }
@@ -53,14 +75,25 @@ module Waylon
     # Given a message, find a suitable skill Route for it (sorted by priority, highest first)
     # @param message [Waylon::Message] A Message instance
     # @return [Hash]
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
     def route(message)
       route = nil
-      message_text = message.text.strip
+      message_text = message.body.strip
       @routes ||= []
-      @routes.sort_by(&:priority).reverse.each do |candidate_route|
-        if candidate_route.permits?(message.author) && candidate_route.matches?(message_text)
-          route = candidate_route
-        elsif candidate_route.matches?(message_text)
+      @routes.sort_by(&:priority).reverse.each do |this_route|
+        if this_route.permits?(message.author) &&
+           this_route.matches?(message_text) &&
+           (this_route.properly_mentions?(message) || message.private?)
+          route = this_route
+        elsif this_route.permits?(message.author) &&
+              this_route.matches?(message_text) &&
+              !this_route.properly_mentions?(message)
+          # Black hole these because they're not direct mentions
+          route = Routes::BlackHole.new
+        elsif this_route.matches?(message_text)
           route = Routes::PermissionDenied.new
         end
         if route
@@ -70,5 +103,9 @@ module Waylon
       end
       route
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
   end
 end

data/lib/waylon/skills/default.rb

@@ -20,6 +20,11 @@ module Waylon
         reply("#{prefix} #{responses.sample} #{help_postfix}")
       end
 
+      # This action ignores messages
+      def ignore
+        log("Ignoring black-holed message from #{message.author.email}")
+      end
+
       # A useful addition to message to tell the User how to get help
       # @return [String]
       def help_postfix

data/lib/waylon/skills/diagnostics.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Skills
+    # Built-in info routes
+    class Diagnostics < Skill
+      # Say hello to Waylon
+      route(
+        /^diagnostics|status$/i,
+        :status,
+        help: {
+          usage: "diagnostics|status",
+          description: "Retrieve this bot's current status"
+        }
+      )
+
+      # Provides info about Waylon's status
+      def status # rubocop:disable Metrics/AbcSize
+        response = []
+        response << "*Framework Version:* Waylon v#{Waylon::Core::VERSION}"
+        response << "*Sense plugins:*"
+        loaded_senses.each { |c| response << "  - #{c}" }
+        response << "*Skill plugins:*"
+        loaded_routes.each { |d| response << "  - #{d}" }
+        response << "*Redis:*"
+        state, read_time, write_time = test_redis
+        response << "  - *Test Result:* #{state ? "Success" : "Error"}"
+        response << "  - *Read time:* #{read_time}s"
+        response << "  - *Write time:* #{write_time}s"
+        response << "*Queue Monitoring:*"
+        response << "  - Failed jobs: #{Resque::Failure.count}"
+
+        reply response.join("\n")
+      end
+
+      def loaded_routes
+        SkillRegistry.instance.routes.map { |r| r.destination.name }.sort.uniq
+      end
+
+      def loaded_senses
+        SenseRegistry.instance.senses.map { |_s, c| c.name }.sort.uniq
+      end
+
+      def test_redis
+        test_key = ("a".."z").to_a.sample(10).join
+        test_value = (0..1000).to_a.sample(20).map(&:to_s).join
+        test_result = nil
+
+        write_time = Benchmark.realtime { db.store(test_key, test_value) }
+        read_time = Benchmark.realtime { test_result = db.load(test_key) }
+
+        db.delete(test_key)
+
+        [(test_value == test_result), read_time.round(6), write_time.round(6)]
+      end
+    end
+  end
+end

data/lib/waylon/skills/fun.rb

@@ -6,8 +6,9 @@ module Waylon
     class Fun < Skill
       # Say hello to Waylon
       route(
-        /^(hello|hi)$/i,
-        :hello
+        /^(hello|hi)([.!]+)?$/i,
+        :hello,
+        help: "hi|hello"
       )
 
       # Responds to "hello" in less boring ways
@@ -19,6 +20,8 @@ module Waylon
           "How can I be of service?"
         ]
 
+        react :wave
+
         reply responses.sample
       end
     end

data/lib/waylon/skills/groups.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Skills
+    # Built-in skills for managing groups
+    class Groups < Skill
+      route(
+        /^add (.+) to (.+)$/,
+        :add_to_group,
+        help: {
+          usage: "add USER[,USER] to GROUP",
+          description: "Add USER(s) to a GROUP"
+        },
+        allowed_groups: %i[admins group_admins]
+      )
+
+      route(
+        /^remove (.+) from (.+)$/,
+        :remove_from_group,
+        help: {
+          usage: "remove USER[,USER] from GROUP",
+          description: "Remove USER(s) from a GROUP"
+        },
+        allowed_groups: %i[admins group_admins]
+      )
+
+      route(
+        /^(describe|list|print|show) (all )?(groups|group memberships)$/,
+        :list_all_groups,
+        help: {
+          usage: "list all groups",
+          description: "List all groups and their members"
+        },
+        allowed_groups: %i[admins group_admins]
+      )
+
+      route(
+        /^cleanup groups$/,
+        :cleanup_groups,
+        help: {
+          usage: "cleanup groups",
+          description: "Remove empty groups"
+        },
+        allowed_groups: %i[admins group_admins]
+      )
+
+      route(
+        /^((list )?my )?groups$/,
+        :list_my_groups,
+        help: {
+          usage: "list my groups",
+          description: "List my group memberships"
+        }
+      )
+
+      def add_to_group # rubocop:disable Metrics/AbcSize
+        user_list = tokens.first
+        group_name = tokens.last
+
+        if group_name == "global admins"
+          reply "Sorry, I can't manipulate global admins this way..."
+          return
+        end
+
+        group = Group.new(group_name)
+
+        log "Adding #{user_list} to group #{group}"
+
+        failures = []
+        user_list.split(",").each do |this_user|
+          found = found_user(this_user)
+          failures << found unless group.add(found)
+        end
+
+        unless failures.empty?
+          text = failures.size > 1 ? "were already members" : "was already a member"
+          reply "Looks like [#{failures.map { |u| mention(u) }.join(", ")}] #{text} of #{group_name}"
+        end
+
+        reply("Done adding users to #{group_name}!")
+      end
+
+      def cleanup_groups
+        # perform a key scan in Redis for all group keys and find empty groups
+        group_keys = all_group_keys.select do |group|
+          name = group.split(".").last
+          Group.new(name).to_a.empty?
+        end
+
+        # delete the empty group keys
+        group_keys.each { |g| db.delete(g) }
+
+        group_names = group_keys.map { |g| g.split(".").last }
+
+        reply "I removed these empty groups: #{group_names.join(", ")}"
+      end
+
+      def remove_from_group # rubocop:disable Metrics/AbcSize
+        user_list = tokens.first
+        group_name = tokens.last
+
+        if group_name == "global admins"
+          reply "Sorry, I can't manipulate global admins this way..."
+          return
+        end
+
+        group = Group.new(group_name)
+
+        log "Removing #{user_list} from group '#{group_name}'", :debug
+
+        failures = []
+        user_list.split(",").each do |this_user|
+          found = found_user(this_user)
+          failures << found unless group.remove(found)
+        end
+
+        unless failures.empty?
+          text = failures.size > 1 ? "were members" : "was a member"
+          reply("I don't think [#{failures.map { |u| mention(u) }.join(", ")}] #{text} of #{group_name}")
+        end
+        reply("Done removing users from groups!")
+      end
+
+      def list_all_groups
+        groups = {}
+        groups["global admins"] = global_admins unless global_admins.empty?
+        all_group_keys.each do |group|
+          name = group.split(".").last
+          groups[name] = Group.new(name).members
+        end
+
+        reply(codify(groups.to_yaml))
+      end
+
+      def list_my_groups
+        groups = []
+        groups << "global admins" if global_admins.include?(message.author.email)
+        all_group_keys.each do |group|
+          name = group.split(".").last
+          groups << name if Group.new(name).include?(message.author)
+        end
+
+        reply(codify(groups.to_yaml))
+      end
+
+      private
+
+      def all_group_keys
+        db.adapter.backend.keys("groups.*")
+      end
+
+      def found_user(user_string)
+        if user_string =~ /^.+@.+/
+          # If provided an email
+          sense.user_class.find_by_email(user_string)
+        else
+          # Otherwise assume we're provided their user ID
+          sense.user_class.from_mention(user_string)
+        end
+      end
+
+      def global_admins
+        Config.instance.admins
+      end
+    end
+  end
+end

data/lib/waylon/skills/help.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Skills
+    # A Skill for providing help
+    class Help < Skill
+      # Ask for some help.
+      # Defaults to all things a user has access to, but allows specifying either a Skill name or a Skill and Route
+      route(
+        /^help(?<skill_clause>\s+(?<skill>\w+)(?<action_clause>#(?<action>\w+)|\s+(?<action>\w+))?)?$/i,
+        :help,
+        help: {
+          usage: "help [skill [action]]",
+          description: "Allows asking for help, either for all skills or for a particular skill or action"
+        }
+      )
+
+      # Responds to "help" requests
+      def help
+        skill = named_tokens[:skill]
+        action = named_tokens[:action]
+
+        react :book
+
+        immediate_responses = [
+          "I'll send you a DM to go over that with you.",
+          "I'll DM you the details.",
+          "Look for a private message with those details.",
+          "You should have a private message with that information shortly."
+        ]
+
+        # Only send this if you aren't already in a DM
+        threaded_reply "#{acknowledgement} #{immediate_responses.sample}" unless message.private?
+
+        if sense.supports?(:blocks)
+          reply_with_blocks(help_blocks(skill, action), private: true)
+        else
+          reply(help_text(skill, action), private: true)
+        end
+      end
+
+      def help_text(skill = nil, action = nil) # rubocop:disable Metrics/AbcSize
+        allowed_routes = SkillRegistry.instance.help(message.author)
+        resp = []
+        if skill
+          if action
+            resp << "## Help for #{skill}##{action}:"
+            this_route = allowed_routes[skill].find do |r|
+              r[:name].to_s == "#{skill}##{action}"
+            end
+            return "I couldn't find #{action} on #{skill}..." unless this_route
+
+            resp << build_help_text(this_route)
+          else
+            resp << "## Help for #{skill}:\n"
+            routes = allowed_routes[skill]
+            (routes || []).each { |r| resp << build_help_text(r) }
+          end
+        else
+          help_text_for_all(allowed_routes)
+        end
+      end
+
+      def help_blocks(skill = nil, action = nil) # rubocop:disable Metrics/AbcSize
+        allowed_routes = SkillRegistry.instance.help(message.author)
+        if skill
+          if action
+            this_route = allowed_routes[skill].find do |r|
+              r[:name].to_s == "#{skill}##{action}"
+            end
+
+            return not_found_block(skill, action) unless this_route
+
+            [build_header_block(skill, action), build_help_block(this_route)]
+          else
+            routes = allowed_routes[skill]
+            return not_found_block(skill, nil) unless routes
+
+            resp = [build_header_block(skill, nil)]
+            routes.each { |r| resp << build_help_block(r) }
+            resp
+          end
+        else
+          allowed_routes = SkillRegistry.instance.help(message.author)
+          help_blocks_for_all(allowed_routes)
+        end
+      end
+
+      def help_blocks_for_all(routes)
+        resp = [
+          { type: "header", text: { type: "plain_text", text: "All known actions:", emoji: true } }
+        ]
+
+        routes.each do |k, v|
+          resp += [
+            { type: "divider" },
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: "*Actions for '#{k}':*"
+              }
+            }
+          ]
+          v.each { |r| resp << build_help_block(r) }
+        end
+        resp
+      end
+
+      def help_text_for_all(routes)
+        resp = []
+        resp << "*All known actions:*\n"
+        routes.each do |k, v|
+          resp << "* *#{k}*:"
+          v.each do |r|
+            resp << build_help_text(r)
+          end
+          resp << " --- "
+        end
+        resp.join("\n")
+      end
+
+      def build_header_block(skill, action)
+        text = if action
+                 "Help for #{skill}##{action}:"
+               else
+                 "Help for #{skill}:"
+               end
+        { type: "header", text: { type: "plain_text", text: text, emoji: true } }
+      end
+
+      def build_help_block(this_route)
+        {
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: "  *#{this_route[:name]}*\n#{build_help_text(this_route)}"
+          }
+        }
+      end
+
+      def build_help_text(this_route)
+        route_help_text = []
+        case this_route[:help]
+        when String
+          route_help_text << "    *Usage:* #{this_route[:help]}"
+        when Hash
+          route_help_text << "    *Usage:* #{this_route.dig(:help, :usage)}"
+          if this_route.dig(:help, :description)
+            route_help_text << "\n    *Description:* #{this_route.dig(:help, :description)}"
+          end
+        end
+        route_help_text.join
+      end
+
+      def not_found_block(skill, action)
+        sentence = if action
+                     "I couldn't find any '#{action}' action on the '#{skill}' skill..."
+                   else
+                     "I couldn't find any routes related to a '#{skill}' skill..."
+                   end
+        [
+          {
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: sentence
+            }
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/waylon/user.rb

@@ -18,6 +18,11 @@ module Waylon
         raise NotImplementedError, "find_by_handle isn't implemented"
       end
 
+      # This should be overridden by subclasses to provide a mechanism for looking up Users based on mention strings
+      def from_mention(_mention_string)
+        raise NotImplementedError, "from_mention isn't implemented"
+      end
+
       # Provides a simple mechanism for referencing User subclass's Sense
       # @return [Class] A Sense subclass
       def sense

data/lib/waylon/version.rb

@@ -6,7 +6,7 @@ module Waylon
     VERSION = [
       0, # Major
       1, # Minor
-      1  # Patch
+      2  # Patch
     ].join(".")
   end
 end

data/lib/waylon/webhook.rb

@@ -21,7 +21,7 @@ module Waylon
     # @return [Class] The name of the corresponding Sense class
     def sense_class
       last = self.class.name.split("::").last
-      Module.const_get("Senses::#{last}")
+      Module.const_get("Waylon::Senses::#{last}")
     end
 
     # This must be implemented on every Webhook to provide a mechanism to ensure received payloads are legit
@@ -38,36 +38,35 @@ module Waylon
     end
 
     before do
-      content_type "application/json"
-
-      begin
-        unless request.get? || request.options?
-          request.body.rewind
-          @parsed_body = JSON.parse(request.body.read, symbolize_names: true)
-        end
-      rescue StandardError => e
-        halt(400, { error: "Request must be JSON: #{e.message}" }.to_json)
+      unless request.get? || request.options?
+        request.body.rewind
+        @parsed_body = JSON.parse(request.body.read, symbolize_names: true)
       end
+    rescue StandardError => e
+      content_type "application/json"
+      halt(400, { error: "Request must be JSON: #{e.message}" }.to_json)
     end
 
     after do
       request.options? && headers("Access-Control-Allow-Methods" => @allowed_types || %w[OPTIONS POST])
     end
 
-    post "/" do
-      begin
-        request.body.rewind
-        verify request.body.read, request.env
-        enqueue @parsed_body
-      rescue StandardError => e
-        halt(422, { error: "Unprocessable entity: #{e.message}" }.to_json)
-      end
-
-      { status: :ok }.to_json
-    end
-
-    options "/" do
-      halt 200
-    end
+    ## Example incoming webhook
+    #
+    # post "/" do
+    #   begin
+    #     request.body.rewind
+    #     verify request.body.read, request.env
+    #     enqueue @parsed_body
+    #   rescue StandardError => e
+    #     halt(422, { error: "Unprocessable entity: #{e.message}" }.to_json)
+    #   end
+    #
+    #   { status: :ok }.to_json
+    # end
+    #
+    # options "/" do
+    #   halt 200
+    # end
   end
 end

data/lib/waylon.rb

@@ -2,4 +2,7 @@
 
 require "waylon/core"
 require "waylon/skills/default"
+require "waylon/skills/diagnostics"
 require "waylon/skills/fun"
+require "waylon/skills/groups"
+require "waylon/skills/help"

data/waylon-core.gemspec

@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "puma", "~> 5.5"
   spec.add_dependency "resque", "~> 2.2"
 
-  spec.add_development_dependency "bundler", "~> 2.2"
+  spec.add_development_dependency "bundler", "~> 2.3"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.10"
   spec.add_development_dependency "rubocop", "~> 1.23"