waylon-core 0.1.1 → 0.1.4

data/lib/waylon/sense.rb

@@ -20,17 +20,16 @@ module Waylon
 
     # The connection between Senses and Skills happens here, via a Route and a Hash of details
     # @param route [Route] route The matching Route from the SkillRegistry
-    # @param request_id [String] The ID (from the messaging platform) of the request
-    # @param body [String] Message content for the Skill
+    # @param request [String] The request message (or its ID) from the messaging platform
     # @api private
-    def self.enqueue(route, request_id, body)
+    def self.enqueue(route, request)
       details = {
         "sense" => self,
-        "message" => request_id,
-        "tokens" => route.tokens(body.strip)
+        "request" => request,
+        "route" => route.name
       }
 
-      Resque.enqueue route.destination, route.action, details
+      Resque.enqueue route.destination, details
     end
 
     # Provides a simple mechanism for referencing the Group subclass provided by this Sense

data/lib/waylon/sense_registry.rb

@@ -5,6 +5,8 @@ module Waylon
   class SenseRegistry
     include Singleton
 
+    attr_reader :senses
+
     # A convenience wrapper around the singleton instance #register method
     # @param (see #register)
     # @return (see #register)

data/lib/waylon/services/ping.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Services
+    # A Ping Service for monitoring
+    class Ping < Sinatra::Base
+      configure do
+        set :protection, except: :http_origin
+        set :logging, ::Waylon::Logger
+      end
+
+      before do
+        content_type "application/json"
+        halt 403 unless request.get? || request.options?
+      end
+
+      after do
+        headers "Access-Control-Allow-Methods" => %w[OPTIONS GET] if request.options?
+      end
+
+      get "/" do
+        { status: :ok }.to_json
+      end
+
+      options "/" do
+        halt 200
+      end
+    end
+  end
+end

data/lib/waylon/skill.rb

@@ -5,7 +5,7 @@ module Waylon
   class Skill
     include BaseComponent
 
-    attr_reader :sense, :tokens, :request
+    attr_reader :sense, :tokens, :request, :route
 
     # Config namespace for config keys
     # @return [String] The namespace for config keys
@@ -14,32 +14,31 @@ module Waylon
     end
 
     # Resque uses this to execute the Skill. Just defers to the `action` subclass method
-    # @param action [Symbol,String] The method on the Skill subclass to call
     # @param details [Hash] Input details about the message for running a Skill action
-    def self.perform(action, details)
-      new(details["sense"], details["tokens"], details["message"], details["meta"])
-        .send(action.to_sym)
+    def self.perform(details)
+      skill = new(details["sense"], details["route"], details["request"], details["meta"])
+      skill.send(skill.route.action.to_sym)
     end
 
     # Redis/Resque queue name
     # @api private
     # @return [Symbol]
     def self.queue
-      :senses
+      :skills
     end
 
     # Adds skills to the SkillRegistry
     # @param condition [Condition,Regexp] The condition that determines if this route applies
     # @param action [Symbol,String] The method on the Skill subclass to call
     # @param allowed_groups [Symbol,Array<Symbol>] The group or list of groups allowed to use this
-    # @param help [String] A description of how to use the skill
-    def self.route(condition, action, allowed_groups: :everyone, help: nil, name: nil)
+    # @param help [String,Hash] A description of how to use the skill
+    def self.route(condition, action, allowed_groups: :everyone, help: nil, name: nil, mention_only: true)
       name ||= "#{to_s.split("::").last.downcase}##{action}"
       real_cond = case condition
                   when Condition
                     condition
                   when Regexp
-                    Conditions::Regex.new(condition, action, allowed_groups, help)
+                    Conditions::Regex.new(condition, action, allowed_groups, help, mention_only)
                   else
                     log("Unknown condition for route for #{name}##{action}", :warn)
                     nil
@@ -48,13 +47,13 @@ module Waylon
     end
 
     # @param sense [Class,String] Class (or Class name) of the source Sense
-    # @param tokens [Array<String>] Tokenized message content for use in the Skill
-    # @param request [String,Integer] Reference to the request from the Sense provider (usually an ID)
+    # @param request [String,Integer] Reference to the request from the Sense provider (usually ID or message itself)
     # @param meta [Hash] Optional meta data that can be passed along from a Sense for use in Skills
-    def initialize(sense, tokens, request, meta)
+    def initialize(sense, route, request, meta)
       @sense   = sense.is_a?(Class) ? sense : Module.const_get(sense)
-      @tokens  = tokens || []
+      @route   = SkillRegistry.find_by_name(route)
       @request = request
+      @tokens  = @route.tokens(message.body) || []
       @meta    = meta
     end
 
@@ -62,7 +61,6 @@ module Waylon
     # @return [String]
     def acknowledgement
       responses = [
-        "I'll get back to you in just a sec.",
         "You got it!",
         "As you wish.",
         "Certainly!",
@@ -73,11 +71,10 @@ module Waylon
         "Of course!",
         "I'd be delighted!",
         "Right away!",
-        "Gladly",
+        "Gladly!",
         "All right.",
         "I'm all over it.",
         "I'm on it!",
-        "Let me see what I can do.",
         "Will do!"
       ]
       responses.sample
@@ -97,7 +94,8 @@ module Waylon
         sense: @sense,
         message: @request,
         tokens: @tokens,
-        meta: @meta
+        meta: @meta,
+        route: route.name
       }
     end
 
@@ -111,7 +109,11 @@ module Waylon
     # Provides a wrapped message for responding to the received Sense
     # @return [Waylon::Message]
     def message
-      sense.message_class.new(request)
+      sense.message_from_request(request)
+    end
+
+    def named_tokens
+      @named_tokens ||= @route.named_tokens(message.body) || {}
     end
 
     # Defers to the Sense to react to a message
@@ -124,9 +126,40 @@ module Waylon
     end
 
     # Defers to the Sense to determine how to reply to a message
-    # @param [String] text The reply text
-    def reply(text)
-      sense.reply(request, text)
+    # @param text [String] The reply text
+    def reply(text, private: false)
+      if private && sense.supports?(:private_messages)
+        sense.private_reply(request, text)
+      else
+        log("Unable to send private message for Sense #{sense.name}, replying instead", :debug) if private
+        sense.reply(request, text)
+      end
+    end
+
+    # Defers to the Sense to determine how to reply to a message with rich content
+    # @param blocks [String] The reply blocks
+    def reply_with_blocks(blocks, private: false)
+      unless sense.supports?(:blocks)
+        log("Unable to use blocks with Sense #{sense.name}")
+        return false
+      end
+      if private
+        sense.private_reply_with_blocks(request, blocks)
+      else
+        log("Unable to send private message for Sense #{sense.name}, replying instead", :debug) if private
+        sense.reply_with_blocks(request, blocks)
+      end
+    end
+
+    # Defers to the Sense to do threaded replies if it can, otherwise it falls back to normal replies
+    # @param text [String] The reply text
+    def threaded_reply(text)
+      if sense.supports?(:threads)
+        sense.threaded_reply(request, text)
+      else
+        log("Unable to reply in theads for Sense #{sense.name}, replying instead", :debug)
+        sense.reply(request, text)
+      end
     end
   end
 end

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,60 @@
+# 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"
+        if Resque.redis.connected?
+          response << "*Queue Monitoring:*"
+          response << "  - Failed jobs: #{Resque::Failure.count}"
+        end
+
+        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,173 @@
+# 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
+        if db.adapter.instance_of?(Moneta::Adapters::Redis)
+          db.adapter.backend.keys("groups.*")
+        else
+          groups = []
+          db.each_key { |key| groups << key if key.start_with?("groups.") }
+          groups
+        end
+      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