waylon-core 0.1.0

data/lib/waylon/config.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Waylon
+  # The global configuration
+  class Config
+    include Singleton
+    extend Forwardable
+
+    attr_accessor :schema
+
+    delegate delete: :@config
+
+    # Stores schema metadata about config items
+    # @api private
+    # @param key [String] The config key to define a schema for
+    # @param required [Boolean] Is this key required on startup?
+    # @param type [Class] The class type for the stored value
+    # @param default [Object] The optional default value
+    # @return [Boolean] Was the schema update successful?
+    def add_schema(key, default: nil, required: false, type: String)
+      @schema ||= {}
+      @schema[key] = { default: default, required: required, type: type }
+      true
+    end
+
+    # A list of emails specified via the CONF_GLOBAL_ADMINS environment variable
+    # @return [Array<String>] a list of emails
+    def admins
+      admin_emails = self["global.admins"]
+      admin_emails ? admin_emails.split(",") : []
+    end
+
+    # Load in the config from env variables
+    # @return [Boolean] Was the configuration loaded?
+    def load_env
+      @schema ||= {}
+      self["global.log.level"] = ENV.fetch("LOG_LEVEL", "info")
+      self["global.redis.host"] = ENV.fetch("REDIS_HOST", "redis")
+      self["global.redis.port"] = ENV.fetch("REDIS_PORT", "6379")
+      ENV.keys.grep(/CONF_/).each do |env_key|
+        conf_key = env_key.downcase.split("_")[1..].join(".")
+        ::Waylon::Logger.log("Attempting to set #{conf_key} from #{env_key}", :debug)
+        self[conf_key] = ENV[env_key]
+      end
+      true
+    end
+
+    # Provides the redis host used for most of Waylon's brain
+    # @return [String] The redis host
+    def redis_host
+      self["global.redis.host"]
+    end
+
+    # Provides the redis port used for most of Waylon's brain
+    # @return [String] The redis host
+    def redis_port
+      self["global.redis.port"]
+    end
+
+    # Clear the configuration
+    # @return [Boolean] Was the configuration reset?
+    def reset
+      @config = {}
+      true
+    end
+
+    # Check if a given key is explicitly set (not including defaults)
+    # @param key [String] The key to check
+    # @return [Boolean] Is the key set?
+    def key?(key)
+      @config ||= {}
+      @config.key?(key)
+    end
+
+    alias set? key?
+
+    # Check if a given key is has _any_ value (default or otherwise)
+    # @param key [String] The key to look for
+    # @return [Boolean] Does the key have a value?
+    def value?(key)
+      @config ||= {}
+      !self[key].nil?
+    end
+
+    # Set the value for a key
+    # @param key [String] The key to use for storing the value
+    # @param [Object] value The value for the key
+    def []=(key, value)
+      if (@schema[key] && validate_config(@schema[key], value)) || key.start_with?("global.")
+        @config ||= {}
+        @config[key] = value
+      elsif @schema[key]
+        ::Waylon::Logger.log("Ignoring invalid config value for key: #{key}", :warn)
+      else
+        ::Waylon::Logger.log("Ignoring unknown config key: #{key}", :warn)
+      end
+    end
+
+    # Retrieve the value for the given key
+    # @param key [String] The key to lookup
+    # @return [String,nil] The requested value
+    def [](key)
+      @config ||= {}
+      if @config.key?(key)
+        @config[key].dup
+      elsif @schema.key?(key) && @schema[key][:default]
+        @schema[key][:default].dup
+      end
+    end
+
+    # Is the state of the config valid?
+    # @return [Boolean]
+    def valid?
+      missing = @schema.select { |_k, v| v[:required] }.reject { |k, _v| @config[k] }
+      missing.each do |key, _value|
+        ::Waylon::Logger.log("Missing config: #{key}", :debug)
+      end
+      missing.empty?
+    end
+
+    # Checks if a value aligns with a schema
+    # @param schema [Hash] The schema definition for this value
+    # @param value The value to compare to the schema
+    # @return [Boolean]
+    def validate_config(schema, value)
+      type = schema[:type]
+      if type == :boolean
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      else
+        value.is_a?(type)
+      end
+    end
+  end
+end

data/lib/waylon/core.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Standard Library dependencies
+require "base64"
+require "digest"
+require "English"
+require "fileutils"
+require "forwardable"
+require "logger"
+require "yaml"
+require "singleton"
+require "ostruct"
+require "timeout"
+require "resolv"
+require "set"
+
+# External dependencies
+require "addressable/uri"
+require "faraday"
+require "i18n"
+require "json"
+require "moneta"
+require "resque"
+
+# Internal requirements
+require "waylon/version"
+require "waylon/config"
+require "waylon/generic_exception"
+require "waylon/exceptions/not_implemented_error"
+require "waylon/exceptions/validation_error"
+require "waylon/group"
+require "waylon/logger"
+require "waylon/base_component"
+require "waylon/condition"
+require "waylon/message"
+require "waylon/route"
+require "waylon/sense_registry"
+require "waylon/sense"
+require "waylon/skill_registry"
+require "waylon/skill"
+require "waylon/user"
+require "waylon/conditions/default"
+require "waylon/conditions/permission_denied"
+require "waylon/conditions/regex"
+require "waylon/routes/default"
+require "waylon/routes/permission_denied"

data/lib/waylon/exceptions/not_implemented_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Exceptions
+    # Exception class used to signify a feature that hasn't been implemented
+    class NotImplementedError < GenericException
+    end
+  end
+end

data/lib/waylon/exceptions/validation_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Exceptions
+    # Exception class used to signify invalid input
+    class ValidationError < GenericException
+    end
+  end
+end

data/lib/waylon/generic_exception.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Waylon
+  # A generic exception super class
+  class GenericException < StandardError
+  end
+end

data/lib/waylon/group.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Waylon
+  # The basic, built-in Group class. Relies on Redis for storage and is managed directly by Waylon.
+  # @note This class can be subclassed for external authentication mechanisms per Sense
+  class Group
+    attr_reader :name
+
+    # @param name [String,Symbol] The name of the group
+    def initialize(name)
+      @name = name.to_sym
+    end
+
+    # Add a user to the group
+    # @param user [User] User to add
+    # @return [Boolean]
+    def add(user)
+      return false if include?(user)
+
+      users = members
+      users << user.email.downcase
+      storage.store(key, users)
+      true
+    end
+
+    # Remove a user from the group
+    # @param user [User] User to remove
+    # @return [Boolean]
+    def remove(user)
+      return false unless include?(user)
+
+      users = members
+      users.delete(user)
+      storage.store(key, users)
+      true
+    end
+
+    # Waylon Users in this group
+    # @return [Array<User>] The members of this Group
+    def members
+      # all actions on Group funnel through here, so always make sure the key exists first
+      storage.store(key, []) unless storage.key?(key)
+
+      storage.load(key).sort.uniq
+    end
+
+    alias to_a members
+
+    # Checks if a user a member
+    # @param user [User] User to look for
+    # @return [Boolean]
+    def include?(user)
+      members.include?(user.email.downcase)
+    end
+
+    private
+
+    # Provides access to the top-level storage singleton
+    # @return [Waylon::Storage]
+    def storage
+      Waylon::Storage
+    end
+
+    # A quick way to find the config/storage key for this Group
+    # @return [String]
+    def key
+      "groups.#{name}"
+    end
+  end
+end

data/lib/waylon/logger.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Waylon
+  # A simple way to abstract logging
+  module Logger
+    # The log level as defined in the global Config singleton
+    # @return [String] The current log level
+    def self.level
+      Config.instance["global.log.level"]
+    end
+
+    # Abstraction for sending logs to the logger at some level
+    # @param [Symbol] level The log level this message corresponds to
+    # @param [String] message The message to log at this specified level
+    def self.log(message, level = :info)
+      logger.send(level, message)
+    end
+
+    # Provides an easy way to access the underlying logger
+    # @return [Logger] The Logger instance
+    def self.logger
+      return @logger if @logger
+
+      @logger = ::Logger.new($stderr)
+      @logger.level = level
+      @logger.progname = "Waylon"
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        json_data = JSON.dump(
+          ts: datetime,
+          severity: severity.ljust(5).to_s,
+          progname: progname,
+          pid: Process.pid,
+          message: msg,
+          v: Waylon::Core::VERSION
+        )
+        "#{json_data}\n"
+      end
+      @logger
+    end
+  end
+end

data/lib/waylon/message.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Waylon
+  # Abstract Message module
+  # @abstract
+  module Message
+    # Message author (meant to be overwritten by mixing classes)
+    def author
+      nil
+    end
+
+    # Message channel (meant to be overwritten by mixing classes)
+    def channel
+      nil
+    end
+  end
+end

data/lib/waylon/route.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Waylon
+  # A Route is a way of connecting a Sense to the right Skill, allowing for things like
+  # permissions, prioritization, and scopes.
+  class Route
+    extend Forwardable
+
+    attr_reader :name, :destination, :condition, :priority
+
+    # @param name [String] The name of this route (for use in logging and exceptions)
+    # @param destination [Class] The Skill subclass to send matching requests to
+    # @param condition [Condition] The Condition used to see if this Route matches a request
+    # @param priority [Integer] The priority value (for resolving conflicts). Highest value wins.
+    def initialize(name:, destination:, condition:, priority: 10)
+      validate_name(name)
+      validate_destination(destination)
+      validate_condition(condition)
+      validate_priority(priority)
+      @name = name
+      @destination = destination
+      @condition = condition
+      @priority = priority
+    end
+
+    delegate %i[action help matches? permits? tokens] => :@condition
+
+    private
+
+    # Validates the Condition
+    # @param condition [Condition]
+    # @raise [Exceptions::ValidationError]
+    # @return [Boolean]
+    def validate_condition(condition)
+      raise Exceptions::ValidationError, "Route condition must be a Condition" unless condition.is_a?(Condition)
+
+      true
+    end
+
+    # Validates the destination
+    # @param destination [Class]
+    # @raise [Exceptions::ValidationError]
+    # @return [Boolean]
+    def validate_destination(destination)
+      unless destination.ancestors.include?(Skill)
+        raise Exceptions::ValidationError, "Route destination must be a Skill"
+      end
+
+      true
+    end
+
+    # Validates the Route name
+    # @param name [String]
+    # @raise [Exceptions::ValidationError]
+    # @return [Boolean]
+    def validate_name(name)
+      raise Exceptions::ValidationError, "Route name must be a String" unless name.is_a?(String)
+      raise Exceptions::ValidationError, "Route name must not be empty" if name.empty?
+
+      true
+    end
+
+    # Validates the priority
+    # @param priority [Integer]
+    # @raise [Exceptions::ValidationError]
+    # @return [Boolean]
+    def validate_priority(priority)
+      raise Exceptions::ValidationError, "Route priority must be between 0 and 99" unless (0..99).include?(priority)
+    end
+  end
+end

data/lib/waylon/routes/default.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Routes
+    # The default route for unrouted messages
+    class Default < Route
+      def initialize(
+        name: "default_route",
+        destination: Skills::Default,
+        condition: Conditions::Default.new,
+        priority: 0
+      )
+        super
+      end
+    end
+  end
+end

data/lib/waylon/routes/permission_denied.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Waylon
+  module Routes
+    # This route is used when a route exists but the current user doesn't have permission
+    class PermissionDenied < Route
+      def initialize(
+        name: "permission_denied",
+        destination: Skills::Default,
+        condition: Conditions::PermissionDenied.new,
+        priority: 99
+      )
+        super
+      end
+    end
+  end
+end

data/lib/waylon/rspec/matchers/route_matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Waylon
+  module RSpec
+    module Matchers
+      # RSpec matchers for Routes defined in Skills
+      module RouteMatcher
+        extend ::RSpec::Matchers::DSL
+
+        # Validates that the provided message is routable
+        matcher :route do |body|
+          match do
+            message = chatroom.post_message(body, from: testuser)
+
+            if defined?(@group)
+              # Add the test user to the group
+              Group.new(@group.to_s).add(testuser)
+            end
+
+            found_route = SkillRegistry.instance.route(message)
+
+            if defined?(@method_name)
+              # Verify that the route sends to the appropriate place
+              found_route &&
+                found_route.destination == described_class &&
+                found_route.action == @method_name.to_sym
+            else
+              found_route && found_route.destination == described_class
+            end
+          end
+
+          chain :as_member_of do |group|
+            @group = group
+          end
+
+          chain :to do |method_name|
+            @method_name = method_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/waylon/rspec/skill.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "waylon/rspec/matchers/route_matcher"
+
+module Waylon
+  module RSpec
+    # Extras for RSpec to facilitate testing Waylon Skills
+    module Skill
+      include Matchers::RouteMatcher
+
+      class << self
+        # Sets up the RSpec environment
+        def included(base)
+          base.send(:include, Waylon::RSpec)
+
+          init_let_blocks(base)
+          init_subject(base)
+        end
+
+        private
+
+        # Create common test objects.
+        def init_let_blocks(base)
+          base.class_eval do
+            let(:bot) { TestUser.new(0) }
+            let(:testuser) { TestUser.new(1) }
+            let(:chatroom) { TestChannel.new(0) }
+            let(:adminuser) do
+              @adminuser ||= TestUser.find_or_create(name: "Charles Montgomery Burns", handle: "monty")
+              Group.new("admins").add(@adminuser)
+              @adminuser
+            end
+          end
+        end
+
+        # Set up a working test subject.
+        def init_subject(base)
+          base.class_eval do
+            subject { described_class }
+          end
+        end
+      end
+
+      # An array of strings that have been sent by the bot during throughout a test
+      # @return [Array<String>] The replies.
+      def replies
+        TestSense.sent_messages
+      end
+
+      # Sends a message to the bot
+      # @param body [String] The message to send
+      # @param from [TestUser] The user sending the message
+      # @param channel [TestChannel] Where the message is received
+      # @param privately [Boolean] Is the message a DM
+      # @return [void]
+      def send_message(body, from: testuser, channel: nil, privately: false)
+        msg_details = { person_id: from.id, text: body, created_at: Time.now }
+        if privately
+          msg_details[:type] = :private
+          msg_details[:receiver_id] = robot.id
+        else
+          msg_details[:type] = :channel
+          msg_details[:channel_id] = channel ? channel.id : chatroom.id
+        end
+
+        TestSense.process(msg_details)
+        TestWorker.handle(TestSense.fake_queue)
+      end
+    end
+  end
+end

data/lib/waylon/rspec/test_channel.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Waylon
+  module RSpec
+    # The TestChannel
+    class TestChannel
+      attr_reader :id
+
+      # Simple way to list all TestChannels
+      # @return [Array<TestChannel>]
+      def self.all
+        TestSense.channel_list.each_index.map { |id| new(id) }
+      end
+
+      # Always provides a TestChannel, either by finding an existing or creating a new one
+      # @return [TestChannel]
+      def self.find_or_create(name)
+        existing_channel = find_by_name(name)
+        if existing_channel
+          existing_channel
+        else
+          channel_details = { name: name, created_at: Time.now }
+          TestSense.channel_list << channel_details
+          new(TestSense.channel_list.size - 1)
+        end
+      end
+
+      # Looks up an existing TestChannel by name
+      # @return [TestChannel,nil]
+      def self.find_by_name(name)
+        channel_id = TestSense.channel_list.index { |channel| channel[:name] == name }
+        channel_id ? new(channel_id) : nil
+      end
+
+      # @param channel_id [Integer] The Channel ID for the new TestChannel
+      # @param details [Hash] Details (namely 'name' and 'created_at') for the new TestChannel
+      def initialize(channel_id, details = {})
+        @id = channel_id.to_i
+        @details = details
+      end
+
+      # Easy access to when the TestChannel was created
+      # @return [Time]
+      def created_at
+        details[:created_at]
+      end
+
+      # The name of the TestChannel
+      # @return [String]
+      def name
+        details[:name]
+      end
+
+      # Send a TestMessage to a TestChannel
+      # @param content [String,Message] The Message to send
+      # @return [Message] The sent Message object
+      def post_message(content, from: TestUser.whoami)
+        msg = if content.is_a?(Message)
+                content.text
+              else
+                content
+              end
+        msg_details = {
+          user_id: from.id,
+          text: msg,
+          type: :channel,
+          channel_id: id,
+          created_at: Time.now
+        }
+        TestSense.message_list << msg_details
+        TestMessage.new(TestSense.message_list.size - 1)
+      end
+
+      # Lazily provides the details for a TestUser
+      # @api private
+      # @return [Hash] details for this instance
+      def details
+        @details = TestSense.room_list[id] if @details.empty?
+        @details.dup
+      end
+    end
+  end
+end