waylon-core 0.1.0

data/lib/waylon/rspec/test_message.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Waylon
+  module RSpec
+    # A test Message class
+    class TestMessage
+      include Waylon::Message
+
+      attr_reader :id
+
+      # Simple way to list all TestMessages
+      # @return [Array<TestMessage>]
+      def self.all
+        TestSense.message_list.each_index.map { |id| new(id) }
+      end
+
+      # @param message_id [Integer] The Message ID for the new TestMessage
+      # @param details [Hash] Details hash for the new TestMessage
+      def initialize(message_id, details = {})
+        @id = message_id.to_i
+        @details = details
+      end
+
+      # Provides the user that authored the message
+      # @return [TestUser]
+      def author
+        TestUser.new(details[:user_id])
+      end
+
+      # Easy access to when the TestMessage was created
+      # @return [Time]
+      def created_at
+        details[:created_at]
+      end
+
+      # Is this a private message?
+      # @return [Boolean]
+      def private_message?
+        details[:type] == :private
+      end
+
+      # The TestChannel where this TestMessage lives
+      # @return [TestChannel]
+      def channel
+        TestChannel.new(details[:channel_id])
+      end
+
+      # The Message content
+      # @return [String]
+      def text
+        details[:text]
+      end
+
+      # Lazily provides the details for TestMessages
+      # @api private
+      # @return [Hash] The details for this TestMessage instance
+      def details
+        @details = TestSense.message_list[id] if @details.empty?
+        @details.dup
+      end
+    end
+  end
+end

data/lib/waylon/rspec/test_sense.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "waylon/rspec/matchers/route_matcher"
+
+module Waylon
+  module RSpec
+    # Extras for RSpec to facilitate testing Waylon Skills
+    class TestSense < Sense
+      features :reactions
+
+      def self.add_user_from_details(details)
+        user_id = user_list.size
+        user = user_class.new(user_id, details)
+        user_list << user
+        user
+      end
+
+      # The list of TestChannel IDs for this TestSense
+      # @return [Array<Integer>]
+      def self.channel_list
+        @channel_list ||= []
+      end
+
+      # Overrides the Sense.enqueue class method to avoid Resque
+      def self.enqueue(route, request_id, body)
+        details = {
+          "sense" => self,
+          "message" => request_id,
+          "tokens" => route.tokens(body.strip)
+        }
+
+        fake_queue.push [route.destination, route.action, details]
+      end
+
+      # Allows access to the fake version of Resque
+      # @return [Queue]
+      def self.fake_queue
+        @fake_queue ||= Queue.new
+      end
+
+      # Ensures we're using the TestMessage class for Messages
+      # @return [Class]
+      def self.message_class
+        RSpec::TestMessage
+      end
+
+      # The list of message details that were sent through this Sense
+      # @return [Array<Hash>]
+      def self.message_list
+        @message_list ||= []
+      end
+
+      # Receives incoming message details and places work on a queue to be performed by a Skill
+      # @param message_details [Hash] The details necessary for creating a TestMessage
+      # @return [void]
+      def self.process(message_details)
+        message_list << message_details
+        message_id = message_list.size - 1
+        msg = message_class.new(message_id)
+        route = SkillRegistry.instance.route(msg) || SkillRegistry.instance.default_route
+        enqueue(route, msg.id, msg.text)
+      end
+
+      # Emulates reactions by sending a message with the reaction type
+      # @param request [Integer] A reference (message ID) of the initial request
+      # @param type [Symbol,String] The type of reaction to send
+      # @return [void]
+      def self.react(request, type)
+        msg = message_class.new(request)
+        msg.channel.post_message(":#{type}:")
+      end
+
+      # Provides all message text sent _to_ Waylon
+      # @return [Array<String>]
+      def self.received_messages
+        message_list.reject { |m| m[:user_id] == TestUser.whoami.id }.map { |m| m[:text] }
+      end
+
+      # Posts a reply to the channel
+      # @param request [Integer] A reference (message ID) of the initial request
+      # @param text [String] The message content to send in response to the request
+      # @return [void]
+      def self.reply(request, text)
+        msg = message_class.new(request)
+        msg.channel.post_message(text)
+      end
+
+      # Provides all message text sent _by_ Waylon
+      # @return [Array<String>]
+      def self.sent_messages
+        message_list.select { |m| m[:user_id] == TestUser.whoami.id }.map { |m| m[:text] }
+      end
+
+      # Ensures we're using the TestUser class for Users
+      # @return [Class]
+      def self.user_class
+        RSpec::TestUser
+      end
+
+      # The list of Users for this TestSense
+      # @return [Array<User>]
+      def self.user_list
+        @user_list ||= []
+      end
+
+      # Automatically informs Waylon about this Sense
+      SenseRegistry.register(:test, self)
+    end
+  end
+end

data/lib/waylon/rspec/test_server.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "rspec/expectations"
+require "rspec/mocks"
+
+major, *_unused = RSpec::Core::Version::STRING.split(/\./)
+abort "RSpec 3 or greater required" if major.to_i < 3
+
+require "waylon/core"
+require "waylon/skills/default"
+require "waylon/rspec/skill"
+require "waylon/rspec/test_channel"
+require "waylon/rspec/test_message"
+require "waylon/rspec/test_sense"
+require "waylon/rspec/test_user"
+require "waylon/rspec/test_worker"
+
+config = Waylon::Config.instance
+config.load_env
+
+Waylon::Cache = Moneta.new(:Cookie)
+Waylon::Storage = Moneta.new(:LRUHash)
+Waylon::Logger.log("Found Global Admins: #{config.admins}")
+
+Waylon::RSpec::TestUser.find_or_create(
+  name: "Waylon Smithers",
+  email: "waylon.smithers@example.com"
+)
+
+# This is the user for test chats
+if ENV["USER_EMAIL"]
+  Waylon::RSpec::TestUser.find_or_create(
+    name: "Home Simpson",
+    email: ENV["USER_EMAIL"]
+  )
+else
+  Waylon::RSpec::TestUser.find_or_create(name: "Homer Simpson")
+end
+
+Waylon::RSpec::TestChannel.find_or_create("random")
+
+# Load demo skills here
+require "waylon/skills/fun"
+
+# Handle demo chat REPL
+def adminuser
+  @adminuser ||= Waylon::RSpec::TestUser.find_or_create(name: "Charles Montgomery Burns", handle: "monty")
+  Waylon::Group.new("admins").add(@adminuser)
+  @adminuser
+end
+
+def chatroom
+  @chatroom ||= Waylon::RSpec::TestChannel.new(0)
+end
+
+def handle_exit_input
+  if @admin_enabled
+    puts "Switching back to a normal user."
+    @admin_enabled = false
+  else
+    puts "Talk to you later!"
+    exit
+  end
+end
+
+def msg_details(body, from, privately)
+  details = {
+    user_id: from.id,
+    text: body,
+    created_at: Time.now
+  }
+  if privately
+    details[:type] = :private
+    details[:receiver_id] = robot.id
+  else
+    details[:type] = :channel
+    details[:channel_id] = channel ? channel.id : chatroom.id
+  end
+  details
+end
+
+def robot
+  @robot ||= Waylon::RSpec::TestUser.new(0)
+end
+
+def testuser
+  @testuser ||= Waylon::RSpec::TestUser.new(1)
+end
+
+def this_user
+  @admin_enabled ? adminuser : testuser
+end
+
+def handle_input(body, from: this_user, privately: true)
+  if %w[bye exit leave quit].include?(body)
+    handle_exit_input
+  elsif ["su", "su -", "su admin", "su - admin"].include?(body)
+    puts 'Admin enabled! Use "exit" to go back to a normal user.'
+    @admin_enabled = true
+  else
+    message_count = Waylon::RSpec::TestSense.sent_messages.size
+
+    Waylon::RSpec::TestSense.process(msg_details(body, from, privately))
+    Waylon::RSpec::TestWorker.handle(Waylon::RSpec::TestSense.fake_queue)
+    result = Waylon::RSpec::TestSense.sent_messages[message_count..].join("\n")
+    puts("(@#{Waylon::RSpec::TestUser.whoami.handle}) >> #{result}")
+  end
+end
+
+# A lambda for a test chat server
+repl = lambda do |prompt|
+  print prompt
+  handle_input($stdin.gets.chomp!)
+end
+
+loop do
+  @admin_enabled ||= false
+  repl["(@#{this_user.handle}) << "]
+end

data/lib/waylon/rspec/test_user.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Waylon
+  module RSpec
+    # Extras for RSpec to facilitate testing Waylon (by creating fake Users)
+    class TestUser
+      include Waylon::User
+
+      attr_reader :id
+
+      # Looks up a User by their email
+      # @param email [String] The User's email
+      # @return [User,nil] The found User
+      def self.find_by_email(email)
+        TestSense.user_list.find { |user| user.email == email }
+      end
+
+      # Looks up a User by their IM handle
+      # @param handle [String] The User's handle
+      # @return [User,nil] The found User
+      def self.find_by_handle(handle)
+        TestSense.user_list.find { |user| user.handle == handle }
+      end
+
+      # Looks up a User by their full name
+      # @param name [String] The User's name
+      # @return [User,nil] The found User
+      def self.find_by_name(name)
+        TestSense.user_list.find { |user| user.display_name == name }
+      end
+
+      # Looks up existing or creates a new User based on their full name, email, or handle
+      # @param name [String] The full name of the User
+      # @param email [String] The User's email
+      # @param handle [String] The User's handle
+      # @return [User,Boolean]
+      # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+      def self.find_or_create(name: nil, email: nil, handle: nil)
+        return false unless name || email || handle # have to provide _something_
+
+        existing_user = find_by_email(email) || find_by_handle(handle) || find_by_name(name)
+        if existing_user
+          existing_user
+        else
+          this_name = name || random_name # if no name was provided, make one up
+          details = {
+            email: email || email_from_name(this_name),
+            handle: handle || handle_from_name(this_name),
+            name: this_name,
+            status: :online
+          }
+          # Need to give up if we've generated a duplicate
+          if find_by_email(details[:email]) || find_by_handle(details[:handle]) || find_by_name(details[:name])
+            return false
+          end
+
+          TestSense.add_user_from_details(details)
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+
+      # Provides a random human-sounding full name for test users
+      # @return [String]
+      def self.random_name
+        first_names = %w[
+          Abraham Al Alex Barbara Barry Bob Brenda Chloe Chuck Daniel Dave Eliza Felicia Frank
+          Francis Glen Graham Greg Hal Jackie Jacob Jessica Jonathan Julie Maria Marcia Nikhil
+          Olivia Patrick Paul Reggie Robby Roger Sam Saul Sean Tim Todd Tristan Xavier Zack
+        ]
+        last_names = %w[
+          Adams Andrews Bailey Brooks Brown Bush Cervantes Chen Collins Crooks Dean Franz Harris
+          Jackson Jimenez Jones Jordan Laflor Lopez Gonzalez McDowell Miller Ng Odinson Reed
+          Roberts Rodriguez Sanders Schmidt Scott Smith Stewart Taylor Tesla Torres Turner
+          Walker Ward Warner White Williams Wilson Wong Young Zeta Zimmerman
+        ]
+
+        "#{first_names.sample} #{last_names.sample}"
+      end
+
+      # Gives back the TestUser for the bot
+      # @return [TestUser] Waylon's User instance
+      def self.whoami
+        find_by_email("waylon.smithers@example.com")
+      end
+
+      # @param user_id [Integer] The ID of the user in the TestSense's user list
+      # @param details [Hash] Optional User details (can be looked up later)
+      def initialize(user_id, details = {})
+        @id = user_id.to_i
+        @details = details
+      end
+
+      # The User's full name (:user from the details Hash)
+      # @return [String]
+      def display_name
+        details[:name]
+      end
+
+      # The User's email address
+      # @return [String]
+      def email
+        details[:email]
+      end
+
+      # Sends a direct TestMessage to a User
+      # @param content [String] The message content to send
+      # @return [TestMessage]
+      def private_message(content)
+        msg = {
+          user_id: self.class.whoami.id,
+          receiver_id: id,
+          text: content,
+          type: :private,
+          created_at: Time.now
+        }
+        TestSense.message_list << msg
+        TestMessage.new(TestSense.message_list.size - 1)
+      end
+
+      # The User's handle
+      # @return [String]
+      def handle
+        details[:handle]
+      end
+
+      # The User's current status
+      # @return [Symbol]
+      def status
+        details[:status]
+      end
+
+      # Is the User valid?
+      # @return [Boolean]
+      def valid?
+        true
+      end
+
+      # Lazily provides the details for a TestUser
+      # @api private
+      # @return [Hash] Details for this instance
+      def details
+        @details = TestSense.user_list[id].details if @details.empty?
+        @details.dup
+      end
+
+      # Creates an email address based on the name provided
+      # @api private
+      # @return [String] A generated email address
+      def self.email_from_name(name)
+        if ENV["USER_EMAIL"] && name == "homer.simpson"
+          ENV["USER_EMAIL"]
+        else
+          "#{name.downcase.gsub(/[\s_-]/, ".")}@example.com"
+        end
+      end
+
+      # Creates a handle from a name
+      # @api private
+      # @return [String] A generated user handle
+      def self.handle_from_name(name)
+        name.downcase.split(/[\s_-]/).first
+      end
+    end
+  end
+end

data/lib/waylon/rspec/test_worker.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Waylon
+  module RSpec
+    # A TestWorker to run queued Skills
+    class TestWorker
+      # Instructs the worker to grab an item off the Queue and run it
+      # @param queue [Queue] The queue that contains work to be done
+      def self.handle(queue)
+        skill, action, details = queue.pop
+        skill.perform(action, details)
+      end
+    end
+  end
+end

data/lib/waylon/rspec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "rspec/expectations"
+require "rspec/mocks"
+
+major, *_unused = RSpec::Core::Version::STRING.split(/\./)
+abort "RSpec 3 or greater required" if major.to_i < 3
+
+require "moneta"
+require "set"
+
+require "waylon/core"
+require "waylon/skills/default"
+require "waylon/rspec/skill"
+require "waylon/rspec/test_channel"
+require "waylon/rspec/test_message"
+require "waylon/rspec/test_sense"
+require "waylon/rspec/test_user"
+require "waylon/rspec/test_worker"
+
+module Waylon
+  # RSpec stuff that allows specialized Waylon testing
+  module RSpec
+    class << self
+      # @param base [Object] The class including the module.
+      # @return [void]
+      def included(base)
+        base.class_eval do
+          before do
+            config = Waylon::Config.instance
+            config.load_env
+            Waylon::Cache.clear
+            Waylon::Storage.clear
+
+            Waylon::RSpec::TestChannel.find_or_create("random")
+            Waylon::RSpec::TestUser.find_or_create(
+              name: "Waylon Smithers",
+              email: "waylon.smithers@example.com"
+            )
+            Waylon::RSpec::TestUser.find_or_create(name: "Homer Simpson")
+          end
+        end
+      end
+    end
+  end
+end
+
+Waylon::Cache = Moneta.new(:Cookie)
+Waylon::Storage = Moneta.new(:Cookie)

data/lib/waylon/sense.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Waylon
+  # Base class for Senses (Usually messaging providers like Slack)
+  class Sense
+    include BaseComponent
+
+    # Almost always meant to be overridden, this is how the Sense wraps text in a code block
+    # @param text [String] The string to codify
+    # @return [String] Properly wrapped content
+    def self.codify(text)
+      "```\n#{text}```"
+    end
+
+    # Config namespace for config keys
+    # @return [String] The namespace for config keys
+    def self.config_namespace
+      "senses.#{component_namespace}"
+    end
+
+    # 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
+    # @api private
+    def self.enqueue(route, request_id, body)
+      details = {
+        "sense" => self,
+        "message" => request_id,
+        "tokens" => route.tokens(body.strip)
+      }
+
+      Resque.enqueue route.destination, route.action, details
+    end
+
+    # Provides a simple mechanism for referencing the Group subclass provided by this Sense
+    # @return [Class] A Group subclass
+    def self.group_class
+      Group
+    end
+
+    # "At-mention" a User via the Sense. This is usually overridden on Sense subclasses.
+    # @param user [Waylon::User] The User to mention
+    # @return [String]
+    def self.mention(user)
+      "@#{user.handle}"
+    end
+
+    # Provides a simple mechanism for referencing the Message subclass provided by this Sense
+    # @return [Class] A Message subclass
+    def self.message_class
+      Message
+    end
+
+    # Called by Resque to actually use this BaseComponent. Hands off to run() method
+    # @param content [Hash] The payload hash for use in processing the message
+    def self.perform(content)
+      run(content)
+    end
+
+    # Redis/Resque queue name
+    # @api private
+    # @return [Symbol]
+    def self.queue
+      :senses
+    end
+
+    # Provides a simple mechanism for referencing the User subclass provided by this Sense
+    # @return [Class] A User subclass
+    def self.user_class
+      User
+    end
+  end
+end

data/lib/waylon/sense_registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Waylon
+  # Registry of Sense subclasses known to Waylon
+  class SenseRegistry
+    include Singleton
+
+    # A convenience wrapper around the singleton instance #register method
+    # @param (see #register)
+    # @return (see #register)
+    def self.register(name, class_name)
+      instance.register(name, class_name)
+    end
+
+    # Add the provided Sense class to the registry under `name`
+    # @param name [String] The name of the Sense in the registry
+    # @param class_name [Class] The Sense subclass to add
+    # @return [Class] The Sense subclass
+    def register(name, class_name)
+      @senses ||= {}
+      @senses[name.to_s] = class_name
+    end
+
+    # Provides a Hash version of this registry
+    # @return [Hash]
+    def to_hash
+      (@senses || {}).dup
+    end
+  end
+end