rita 0.1.0 → 5.0.0.alpha.1

data/lib/lita/message.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "shellwords"
+
+module Lita
+  # Represents an incoming chat message.
+  class Message
+    extend Forwardable
+
+    # The body of the message.
+    # @return [String] The message body.
+    attr_reader :body
+
+    # The source of the message, which is a user and optional room.
+    # @return [Source] The message source.
+    attr_reader :source
+
+    # A hash of arbitrary data that can be populated by Lita adapters and extensions.
+    # @return [Hash] The extension data.
+    # @since 4.7.0
+    attr_reader :extensions
+
+    # @!method user
+    #   The user who sent the message.
+    #   @return [User] The user.
+    #   @see Source#user
+    # @!method room_object
+    #   The room where the message came from.
+    #   @return [Room] The room.
+    #   @see Source#room_object
+    #   @since 4.5.0
+    # @!method private_message?
+    #   Flag indicating that the message was sent to the robot privately.
+    #   @return [Boolean] The boolean flag.
+    #   @see Source#private_message?
+    #   @since 4.5.0
+    def_delegators :source, :user, :room_object, :private_message?
+
+    # @param robot [Robot] The currently running robot.
+    # @param body [String] The body of the message.
+    # @param source [Source] The source of the message.
+    def initialize(robot, body, source)
+      @robot = robot
+      @body = body
+      @source = source
+      @extensions = {}
+
+      name_pattern = "@?#{Regexp.escape(@robot.mention_name)}[:,]?\\s+"
+      alias_pattern = "#{Regexp.escape(@robot.alias)}\\s*" if @robot.alias
+      command_regex = if alias_pattern
+        /\A\s*(?:#{name_pattern}|#{alias_pattern})/i
+      else
+        /\A\s*#{name_pattern}/i
+      end
+
+      @body = @body.sub(command_regex) do
+        @command = true
+
+        ""
+      end
+    end
+
+    # An array of arguments created by shellsplitting the message body, as if
+    # it were a shell command.
+    # @return [Array<String>] The array of arguments.
+    def args
+      begin
+        _command, *args = body.shellsplit
+      rescue ArgumentError
+        _command, *args =
+          body.split(/\s+/).map(&:shellescape).join(" ").shellsplit
+      end
+
+      args
+    end
+
+    # Marks the message as a command, meaning it was directed at the robot
+    # specifically.
+    # @return [void]
+    def command!
+      @command = true
+    end
+
+    # A boolean representing whether or not the message was a command.
+    # @return [Boolean] +true+ if the message was a command, +false+ if not.
+    def command?
+      @command
+    end
+
+    # An array of matches against the message body for the given {::Regexp}.
+    # @param pattern [Regexp] A pattern to match.
+    # @return [Array<String>, Array<Array<String>>] An array of matches.
+    def match(pattern)
+      body.scan(pattern)
+    end
+
+    # Replies by sending the given strings back to the source of the message.
+    # @param strings [String, Array<String>] The strings to send back.
+    # @return [void]
+    def reply(*strings)
+      @robot.send_messages(source, *strings)
+    end
+
+    # Replies by sending the given strings back to the user who sent the
+    # message directly, even if the message was sent in a room.
+    # @param strings [String, Array<String>] The strings to send back.
+    # @return [void]
+    def reply_privately(*strings)
+      private_source = source.clone
+      private_source.private_message!
+      @robot.send_messages(private_source, *strings)
+    end
+
+    # Replies by sending the given strings back to the source of the message.
+    # Each message is prefixed with the user's mention name.
+    # @param strings [String, Array<String>] The strings to send back.
+    # @return [void]
+    # @since 3.1.0
+    def reply_with_mention(*strings)
+      @robot.send_messages_with_mention(source, *strings)
+    end
+  end
+end

data/lib/lita/middleware_registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Lita
+  # Stores Rack middleware for later use in a +Rack::Builder+.
+  # @since 4.0.2
+  # @api private
+  class MiddlewareRegistry
+    # A Rack middleware and its initialization arguments.
+    MiddlewareWrapper = Struct.new(:middleware, :args, :block)
+
+    extend Forwardable
+
+    def_delegators :@registry, :each, :empty?
+
+    def initialize
+      @registry = []
+    end
+
+    # Adds a Rack middleware with no initialization arguments.
+    # @param middleware [#call] A Rack middleware.
+    # @return [void]
+    def push(middleware)
+      @registry << MiddlewareWrapper.new(middleware, [], nil)
+    end
+    alias << push
+
+    # Adds a Rack middleware with initialization argumens. Uses the same interface as
+    # +Rack::Builder#use+.
+    # @param middleware [#call] A Rack middleware.
+    # @param args [Array] Arbitrary initialization arguments for the middleware.
+    # @yield An optional block to be passed to the constructor of the middleware.
+    # @return [void]
+    def use(middleware, *args, &block)
+      @registry << MiddlewareWrapper.new(middleware, args, block)
+    end
+  end
+end

data/lib/lita/namespace.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "i18n"
+
+require_relative "util"
+
+module Lita
+  # A mixin for setting and getting a plugin's namespace.
+  # @since 4.0.0
+  module Namespace
+    # Gets (and optionally sets) the namespace for a plugin. The namespace is generated from the
+    # class's name by default.
+    # @param value [String] If provided, sets the namespace of the plugin to the value.
+    # @return [String] The namespace.
+    # @raise [RuntimeError] If the plugin is an anonymous class, does not define +self.name+, and
+    #   has not set a namespace manually.
+    def namespace(value = nil)
+      @namespace = value.to_s if value
+
+      string_name = defined?(@namespace) ? @namespace : name
+
+      if string_name
+        Util.underscore(string_name.split("::").last)
+      else
+        raise I18n.t("lita.plugin.name_required")
+      end
+    end
+  end
+end

data/lib/lita/plugin_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+require_relative "handler"
+
+module Lita
+  # Constructs a Lita plugin from a block.
+  # @since 4.0.0
+  # @api private
+  class PluginBuilder
+    # @param namespace [String, Symbol] The Redis namespace to use for the plugin.
+    # @yield The class body of the plugin.
+    def initialize(namespace, &block)
+      @namespace = namespace.to_s
+      @block = block
+    end
+
+    # Constructs an {Adapter} from the provided block.
+    # @return [Adapter]
+    def build_adapter
+      adapter = create_plugin(Adapter)
+      adapter.class_exec(&@block)
+      adapter
+    end
+
+    # Constructs a {Handler} from the provided block.
+    # @return [Handler]
+    def build_handler
+      handler = create_plugin(Handler)
+      handler.class_exec(&@block)
+      handler
+    end
+
+    private
+
+    # Creates a class of the relevant plugin type and sets its namespace.
+    def create_plugin(plugin_type)
+      plugin = Class.new(plugin_type)
+      plugin.namespace(@namespace)
+      plugin
+    end
+  end
+end

data/lib/lita/rack_app.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "uri"
+
+require "http_router"
+require "rack"
+
+# The http_router gem still uses URI.escape which has been removed from Ruby 3.0.
+unless URI.respond_to?(:escape)
+  def URI.escape(*args)
+    CGI.escape(*args)
+  end
+end
+
+# The http_router gem still uses URI.unescape which has been removed from Ruby 3.0.
+unless URI.respond_to?(:unescape)
+  def URI.unescape(*args)
+    CGI.unescape(*args)
+  end
+end
+
+module Lita
+  # A +Rack+ application to serve HTTP routes registered by handlers.
+  # @api private
+  class RackApp
+    # The currently running robot.
+    # @return [Robot] The robot.
+    attr_reader :robot
+
+    # An +HttpRouter+ used for dispatch.
+    # @return [HttpRouter] The router.
+    attr_reader :router
+
+    # Constructs a {RackApp} inside a +Rack::Builder+, including any configured middleware.
+    # @param robot [Robot] The currently running robot.
+    # @return [RackApp, Class] The Rack application.
+    def self.build(robot)
+      builder = Rack::Builder.new
+      builder.run(new(robot))
+
+      robot.config.http.middleware.each do |wrapper|
+        if wrapper.block
+          builder.use(wrapper.middleware, *wrapper.args, &wrapper.block)
+        else
+          builder.use(wrapper.middleware, *wrapper.args)
+        end
+      end
+
+      builder.to_app
+    end
+
+    # @param robot [Robot] The currently running robot.
+    def initialize(robot)
+      @robot = robot
+      @router = HttpRouter.new
+      compile
+    end
+
+    # Entry point for Lita's HTTP routes. Invokes the Rack application.
+    # @param env [Hash] A Rack environment.
+    # @return [void]
+    def call(env)
+      env["lita.robot"] = robot
+      router.call(env)
+    end
+
+    # Overrides the default inspect implementation to make output less verbose and more readable.
+    def inspect
+      hex_address = (object_id << 1).to_s(16).rjust(14, "0")
+      "#<Lita::RackApp:0x#{hex_address}>"
+    end
+
+    # Finds the first route that matches the request environment, if any. Does not trigger the
+    # route.
+    # @param env [Hash] A Rack environment.
+    # @return [Array] An array of the name of the first matching route.
+    # @since 4.0.0
+    def recognize(env)
+      env["lita.robot"] = robot
+      recognized_routes_for(env).map { |match| match.route.name }
+    end
+
+    private
+
+    # Registers routes in the router for each handler's defined routes.
+    def compile
+      robot.handlers.each do |handler|
+        next unless handler.respond_to?(:http_routes)
+
+        handler.http_routes.each { |route| router.add_route(route) }
+      end
+    end
+
+    # Returns an array containing the first recongnized route, if any.
+    def recognized_routes_for(env)
+      Array(router.recognize(env).first)
+    end
+  end
+end

data/lib/lita/registry.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "i18n"
+require "redis-namespace"
+
+require_relative "../lita"
+require_relative "default_configuration"
+require_relative "plugin_builder"
+
+module Lita
+  # An object to hold various types of data including configuration and plugins.
+  # @since 4.0.0
+  class Registry
+    # Allows a registry to be added to another object.
+    module Mixins
+      # The primary configuration object. Provides user settings for the robot.
+      # @return [Configuration] The configuration object.
+      def config
+        @config ||= DefaultConfiguration.new(self).build
+      end
+
+      # Yields the configuration object. Called by the user in a +lita_config.rb+ file.
+      # @yieldparam [Configuration] config The configuration object.
+      # @return [void]
+      def configure
+        yield config
+      end
+
+      # A registry of adapters.
+      # @return [Hash] A map of adapter keys to adapter classes.
+      def adapters
+        @adapters ||= {}
+      end
+
+      # A registry of handlers.
+      # @return [Set] The set of handlers.
+      def handlers
+        @handlers ||= Set.new
+      end
+
+      # A registry of hook handler objects.
+      # @return [Hash] A hash mapping hook names to sets of objects that handle them.
+      # @since 3.2.0
+      def hooks
+        @hooks ||= Hash.new { |h, k| h[k] = Set.new }
+      end
+
+      # The root Redis object.
+      # @return [Redis::Namespace] The root Redis object.
+      def redis
+        @redis ||= begin
+          redis = Redis.new(config.redis)
+          Redis::Namespace.new(config.robot.redis_namespace, redis: redis).tap(&:ping)
+        end
+      rescue Redis::BaseError => e
+        if Lita.test_mode?
+          raise RedisError, I18n.t("lita.redis.test_mode_exception", message: e.message)
+        else
+          Lita.logger.fatal I18n.t(
+            "lita.redis.exception",
+            message: e.message,
+            backtrace: e.backtrace.join("\n")
+          )
+          exit(false)
+        end
+      end
+
+      # @overload register_adapter(key, adapter)
+      #   Adds an adapter to the registry under the provided key.
+      #   @param key [String, Symbol] The key that identifies the adapter.
+      #   @param adapter [Class] The adapter class.
+      #   @return [void]
+      # @overload register_adapter(key)
+      #   Adds an adapter to the registry under the provided key.
+      #   @param key [String, Symbol] The key that identifies the adapter.
+      #   @yield The body of the adapter class.
+      #   @return [void]
+      #   @since 4.0.0
+      def register_adapter(key, adapter = nil, &block)
+        adapter = PluginBuilder.new(key, &block).build_adapter if block
+
+        unless adapter.is_a?(Class)
+          raise ArgumentError, I18n.t("lita.core.register_adapter.block_or_class_required")
+        end
+
+        adapters[key.to_sym] = adapter
+      end
+
+      # @overload register_handler(handler)
+      #   Adds a handler to the registry.
+      #   @param handler [Handler] The handler class.
+      #   @return [void]
+      # @overload register_handler(key)
+      #   Adds a handler to the registry.
+      #   @param key [String] The namespace of the handler.
+      #   @yield The body of the handler class.
+      #   @return [void]
+      #   @since 4.0.0
+      def register_handler(handler_or_key, &block)
+        if block
+          handler = PluginBuilder.new(handler_or_key, &block).build_handler
+        else
+          handler = handler_or_key
+
+          unless handler.is_a?(Class)
+            raise ArgumentError, I18n.t("lita.core.register_handler.block_or_class_required")
+          end
+        end
+
+        handlers << handler
+      end
+
+      # Adds a hook handler object to the registry for the given hook.
+      # @return [void]
+      # @since 3.2.0
+      def register_hook(name, hook)
+        hooks[name.to_s.downcase.strip.to_sym] << hook
+      end
+
+      # Clears the configuration object and the adapter, handler, and hook registries.
+      # @return [void]
+      # @since 3.2.0
+      def reset
+        reset_adapters
+        reset_config
+        reset_handlers
+        reset_hooks
+      end
+
+      # Resets the adapter registry, removing all registered adapters.
+      # @return [void]
+      # @since 3.2.0
+      def reset_adapters
+        @adapters = nil
+      end
+
+      # Resets the configuration object. The next call to {#config}
+      # will create a fresh config object.
+      # @return [void]
+      def reset_config
+        @config = nil
+      end
+      alias clear_config reset_config
+
+      # Resets the handler registry, removing all registered handlers.
+      # @return [void]
+      # @since 3.2.0
+      def reset_handlers
+        @handlers = nil
+      end
+
+      # Resets the hooks registry, removing all registered hook handlers.
+      # @return [void]
+      # @since 3.2.0
+      def reset_hooks
+        @hooks = nil
+      end
+    end
+
+    include Mixins
+  end
+end

data/lib/lita/response.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Lita
+  # A wrapper object that provides the primary interface for handlers to
+  # respond to incoming chat messages.
+  class Response
+    extend Forwardable
+
+    # The incoming message.
+    # @return [Message] The message.
+    attr_accessor :message
+
+    # A hash of arbitrary data that can be populated by Lita extensions.
+    # @return [Hash] The extensions data.
+    # @since 3.2.0
+    attr_accessor :extensions
+
+    # The pattern the incoming message matched.
+    # @return [Regexp] The pattern.
+    attr_accessor :pattern
+
+    # @!method args
+    #   @see Message#args
+    # @!method reply(*strings)
+    #   @see Message#reply
+    # @!method reply_privately(*strings)
+    #   @see Message#reply_privately
+    # @!method reply_with_mention(*strings)
+    #   @see Message#reply_with_mention
+    # @!method user
+    #   @see Message#user
+    # @!method private_message?
+    #   @see Message#private_message?
+    #   @since 4.5.0
+    def_delegators :message, :args, :reply, :reply_privately,
+      :reply_with_mention, :user, :private_message?, :command?
+
+    # @!method room
+    #   @see Message#room_object
+    #   @since 4.5.0
+    def_delegator :message, :room_object, :room
+
+    # @param message [Message] The incoming message.
+    # @param pattern [Regexp] The pattern the incoming message matched.
+    def initialize(message, pattern)
+      self.message = message
+      self.extensions = {}
+      self.pattern = pattern
+    end
+
+    # An array of matches from scanning the message against the route pattern.
+    # @return [Array<String>, Array<Array<String>>] The array of matches.
+    def matches
+      @matches ||= message.match(pattern)
+    end
+
+    # A +MatchData+ object from running the pattern against the message body.
+    # @return [MatchData] The +MatchData+.
+    def match_data
+      @match_data ||= pattern.match(message.body)
+    end
+  end
+end