lita 3.3.1 → 4.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3fb362ba4822b42cb6cd4a6b662d39fd23d94da
-  data.tar.gz: 98201ad5cf62ba5a964ce1ea80b93e298fad4b02
+  metadata.gz: 6aba9ae845dbe0d8fcbeedca12735d4cde375b44
+  data.tar.gz: 7afcedf903295c434f39390884c7f7fe8465c181
 SHA512:
-  metadata.gz: d4afd73a337dcf17183156546037c762d8e7c7d27870c55532f98d9228c83f4c11608352f1ccc71947e7ec072e9a6e523351eaf321a7a25f2540d432e34758ca
-  data.tar.gz: 3629b9e414f35a09444017aff288126ec737adc9d64695bf520497f7e59bbb43e757e56e3c40bde26f35caf40a260253404870fff3ad86c89263af0c51762eb9
+  metadata.gz: 174c6be0c949ee3fd83753348d65c862b6313b5f77164b6c6b928946524e1913adbd07c886f352ce9daedc19e8243a5016bb623e352701e8bfdc369ac1f9aa26
+  data.tar.gz: ce15b54ce11d9efcb90b6b6db82a246625d6b38154db75fdac127629ef1a60892e60e0a607d31d1853a539538d781285d89fbd22557ac1fef8d5dc67e623b823

data/.rubocop.yml

@@ -31,4 +31,4 @@ StringLiterals:
 TrailingComma:
   Enabled: false
 TrivialAccessors:
-  AllowPredicates: true
+  Enabled: false

data/.travis.yml

@@ -6,6 +6,9 @@ before_install:
   - gem update --system
 services:
   - redis-server
+branches:
+  except:
+    - /^v[0-9]/
 notifications:
   webhooks:
     urls:

data/lib/lita.rb

@@ -14,6 +14,8 @@ require "puma"
 require "rack"
 require "redis-namespace"
 
+require_relative "lita/registry"
+
 # The main namespace for Lita. Provides a global registry of adapters and
 # handlers, as well as global configuration, logger, and Redis store.
 module Lita
@@ -21,43 +23,24 @@ module Lita
   REDIS_NAMESPACE = "lita"
 
   class << self
-    # The global registry of adapters.
-    # @return [Hash] A map of adapter keys to adapter classes.
-    def adapters
-      @adapters ||= {}
-    end
+    include Registry::Mixins
 
-    # The global configuration object. Provides user settings for the robot.
-    # @return [Lita::Config] The Lita configuration object.
-    def config
-      @config ||= Config.default_config
-    end
+    # A special mode to ensure that tests written for Lita 3 plugins continue to work.
+    # @return [Boolean] Whether or not version 3 compatibility mode is active.
+    # @since 4.0.0
+    attr_accessor :version_3_compatibility_mode
+    alias_method :version_3_compatibility_mode?, :version_3_compatibility_mode
 
-    # Yields the global configuration object. Called by the user in a
-    # lita_config.rb file.
-    # @yieldparam [Lita::Configuration] config The global configuration object.
-    # @return [void]
-    def configure
-      yield config
-    end
-
-    # The global registry of handlers.
-    # @return [Set] The set of handlers.
-    def handlers
-      @handlers ||= Set.new
-    end
-
-    # The global 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
+    # A mode that makes minor changes to the Lita runtime to improve testability.
+    # @return [Boolean] Whether or not test mode is active.
+    # @since 4.0.0
+    attr_accessor :test_mode
+    alias_method :test_mode?, :test_mode
 
     # The global Logger object.
     # @return [::Logger] The global Logger object.
     def logger
-      @logger ||= Logger.get_logger(Lita.config.robot.log_level)
+      @logger ||= Logger.get_logger(config.robot.log_level)
     end
 
     # The root Redis object.
@@ -65,79 +48,30 @@ module Lita
     def redis
       @redis ||= begin
         redis = Redis.new(config.redis)
-        Redis::Namespace.new(REDIS_NAMESPACE, redis: redis)
+        Redis::Namespace.new(REDIS_NAMESPACE, redis: redis).tap do |client|
+          begin
+            client.ping
+          rescue Redis::BaseError => e
+            Lita.logger.fatal I18n.t(
+              "lita.redis.exception",
+              message: e.message,
+              backtrace: e.backtrace.join("\n")
+            )
+            abort
+          end
+        end
       end
     end
 
-    # Adds an adapter to the global registry under the provided key.
-    # @param key [String, Symbol] The key that identifies the adapter.
-    # @param adapter [Lita::Adapter] The adapter class.
-    # @return [void]
-    def register_adapter(key, adapter)
-      adapters[key.to_sym] = adapter
-    end
-
-    # Adds a handler to the global registry.
-    # @param handler [Lita::Handler] The handler class.
-    # @return [void]
-    def register_handler(handler)
-      handlers << handler
-    end
-
-    # Adds a hook handler object to the global 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 global configuration object and the global adapter, handler, and hook registries.
-    # @return [void]
-    # @since 3.2.0
-    def reset
-      reset_adapters
-      reset_config
-      reset_handlers
-      reset_hooks
-    end
-
-    # Resets the global adapter registry, removing all registered adapters.
-    # @return [void]
-    # @since 3.2.0
-    def reset_adapters
-      @adapters = nil
-    end
-
-    # Resets the global configuration object. The next call to {Lita.config}
-    # will create a fresh config object.
-    # @return [void]
-    def reset_config
-      @config = nil
-    end
-    alias_method :clear_config, :reset_config
-
-    # Resets the global handler registry, removing all registered handlers.
-    # @return [void]
-    # @since 3.2.0
-    def reset_handlers
-      @handlers = nil
-    end
-
-    # Resets the global hooks registry, removing all registered hook handlers.
-    # @return [void]
-    # @since 3.2.0
-    def reset_hooks
-      @hooks = nil
-    end
-
     # Loads user configuration and starts the robot.
     # @param config_path [String] The path to the user configuration file.
     # @return [void]
     def run(config_path = nil)
       hooks[:before_run].each { |hook| hook.call(config_path: config_path) }
-      Config.load_user_config(config_path)
-      Lita.config.finalize
-      self.locale = Lita.config.robot.locale
+      Configuration.load_user_config(config_path)
+      Configuration.freeze_config(config)
+      ConfigurationValidator.new(self).call
+      self.locale = config.robot.locale
       Robot.new.run
     end
   end
@@ -145,23 +79,37 @@ end
 
 require_relative "lita/version"
 require_relative "lita/common"
+require_relative "lita/errors"
 require_relative "lita/config"
+require_relative "lita/configuration"
+require_relative "lita/default_configuration"
+require_relative "lita/configuration_validator"
 require_relative "lita/util"
 require_relative "lita/logger"
+require_relative "lita/callback"
+require_relative "lita/configurable"
+require_relative "lita/namespace"
+require_relative "lita/handler/common"
+require_relative "lita/handler/chat_router"
+require_relative "lita/handler/http_router"
+require_relative "lita/handler/event_router"
+require_relative "lita/handler"
 require_relative "lita/user"
 require_relative "lita/source"
 require_relative "lita/authorization"
 require_relative "lita/message"
 require_relative "lita/response"
+require_relative "lita/http_callback"
 require_relative "lita/http_route"
 require_relative "lita/rack_app"
 require_relative "lita/timer"
 require_relative "lita/robot"
 require_relative "lita/adapter"
 require_relative "lita/adapters/shell"
-require_relative "lita/handler"
+require_relative "lita/builder"
 require_relative "lita/route_validator"
 require_relative "lita/handlers/authorization"
 require_relative "lita/handlers/help"
 require_relative "lita/handlers/info"
 require_relative "lita/handlers/room"
+require_relative "lita/handlers/deprecation_check"

data/lib/lita/adapter.rb

@@ -1,30 +1,27 @@
 module Lita
   # Adapters are the glue between Lita's API and a chat service.
   class Adapter
+    extend Namespace
+    extend Configurable
+
     # The instance of {Lita::Robot}.
     # @return [Lita::Robot]
     attr_reader :robot
 
     class << self
+      # @!attribute [r] required_configs
       # A list of configuration keys that are required for the adapter to boot.
       # @return [Array]
-      attr_reader :required_configs
-
-      # The namespace for the adapter, used for registry and for I18n. If the handler is an
-      # anonymous class, it must explicitly define +self.name+.
-      # @return [String] The adapter's namespace.
-      # @raise [RuntimeError] If +self.name+ is not defined.
-      def namespace
-        if name
-          Util.underscore(name.split("::").last)
-        else
-          raise I18n.t("lita.adapter.name_required")
-        end
+      # @deprecated Will be removed in Lita 5.0. Use {Lita::Adapter#configuration} instead.
+      def required_configs
+        Lita.logger.warn(I18n.t("lita.adapter.required_configs_deprecated"))
+        @required_configs
       end
 
       # Defines configuration keys that are requried for the adapter to boot.
       # @param keys [String, Symbol] The required keys.
       # @return [void]
+      # @deprecated Will be removed in Lita 5.0. Use {Lita::Adapter#config} instead.
       def require_config(*keys)
         @required_configs ||= []
         @required_configs.concat(keys.flatten.map(&:to_sym))
@@ -48,6 +45,13 @@ module Lita
       @robot = robot
       ensure_required_configs
     end
+    #
+    # The handler's config object.
+    # @return [Lita::Configuration] The adapter's configuration object.
+    # @since 4.0.0
+    def config
+      robot.config.adapters.public_send(self.class.namespace)
+    end
 
     # @!method join
     # Joins the room with the specified ID.
@@ -113,21 +117,38 @@ module Lita
 
     private
 
+    # Returns the object used for the adapter's config.
+    def adapter_config
+      if Lita.version_3_compatibility_mode?
+        Lita.config.adapter
+      else
+        robot.config.adapter
+      end
+    end
+
     # Logs a fatal message and aborts if a required config key is not set.
     def ensure_required_configs
-      required_configs = self.class.required_configs
       return if required_configs.nil?
 
-      missing_keys = []
+      Lita.logger.warn(I18n.t("lita.adapter.require_config_deprecated"))
 
-      required_configs.each do |key|
-        missing_keys << key unless Lita.config.adapter[key]
-      end
+      missing_keys = missing_config_keys
 
       unless missing_keys.empty?
         Lita.logger.fatal(I18n.t("lita.adapter.missing_configs", configs: missing_keys.join(", ")))
         abort
       end
     end
+
+    # Finds all missing config keys.
+    def missing_config_keys
+      required_configs.select do |key|
+        key unless adapter_config[key]
+      end
+    end
+
+    def required_configs
+      self.class.instance_variable_get(:@required_configs)
+    end
   end
 end

data/lib/lita/adapters/shell.rb

@@ -3,6 +3,8 @@ module Lita
   module Adapters
     # An adapter that runs Lita in a UNIX shell.
     class Shell < Adapter
+      config :private_chat, default: false
+
       # Creates a "Shell User" and then loops a prompt and input, passing the
       # incoming messages to the robot.
       # @return [void]
@@ -16,7 +18,7 @@ module Lita
       end
 
       # Outputs outgoing messages to the shell.
-      # @param target [Lita::Source] Unused, since there is only one user in the
+      # @param _target [Lita::Source] Unused, since there is only one user in the
       #   shell environment.
       # @param strings [Array<String>] An array of strings to output.
       # @return [void]
@@ -39,7 +41,7 @@ module Lita
 
       def build_message(input, source)
         message = Message.new(robot, input, source)
-        message.command! if Lita.config.adapter.private_chat
+        message.command! if robot.config.adapters.shell.private_chat
         message
       end
 
@@ -57,7 +59,7 @@ module Lita
         input = Readline.readline("#{robot.name} > ", true)
         # Input read via rb-readline will always be encoded as US-ASCII.
         # @see https://github.com/luislavena/rb-readline/blob/master/lib/readline.rb#L1
-        input.force_encoding(Encoding.default_external)
+        input.force_encoding(Encoding.default_external) if input
       end
 
       def run_loop

data/lib/lita/authorization.rb

@@ -1,76 +1,125 @@
 module Lita
   # Methods for querying and manipulating authorization groups.
-  module Authorization
-    class << self
-      # Adds a user to an authorization group.
-      # @param requesting_user [Lita::User] The user who sent the command.
-      # @param user [Lita::User] The user to add to the group.
-      # @param group [Symbol, String] The name of the group.
-      # @return [Symbol] :unauthorized if the requesting user is not authorized.
-      # @return [Boolean] true if the user was added. false if the user was
-      #   already in the group.
-      def add_user_to_group(requesting_user, user, group)
-        return :unauthorized unless user_is_admin?(requesting_user)
-        redis.sadd(normalize_group(group), user.id)
-      end
+  class Authorization
+    # @param config [Object] The finalized configuration object for the currently running robot.
+    def initialize(config)
+      @config = config
+    end
 
-      # Removes a user from an authorization group.
-      # @param requesting_user [Lita::User] The user who sent the command.
-      # @param user [Lita::User] The user to remove from the group.
-      # @param group [Symbol, String] The name of the group.
-      # @return [Symbol] :unauthorized if the requesting user is not authorized.
-      # @return [Boolean] true if the user was removed. false if the user was
-      #   not in the group.
-      def remove_user_from_group(requesting_user, user, group)
-        return :unauthorized unless user_is_admin?(requesting_user)
-        redis.srem(normalize_group(group), user.id)
-      end
+    # Adds a user to an authorization group.
+    # @param requesting_user [Lita::User] The user who sent the command.
+    # @param user [Lita::User] The user to add to the group.
+    # @param group [Symbol, String] The name of the group.
+    # @return [Symbol] :unauthorized if the requesting user is not authorized.
+    # @return [Boolean] true if the user was added. false if the user was
+    #   already in the group.
+    def add_user_to_group(requesting_user, user, group)
+      return :unauthorized unless user_is_admin?(requesting_user)
+      add_user_to_group!(user, group)
+    end
 
-      # Checks if a user is in an authorization group.
-      # @param user [Lita::User] The user.
-      # @param group [Symbol, String] The name of the group.
-      # @return [Boolean] Whether or not the user is in the group.
-      def user_in_group?(user, group)
-        group = normalize_group(group)
-        return user_is_admin?(user) if group == "admins"
-        redis.sismember(group, user.id)
-      end
+    # Adds a user to an authorization group without validating the permissions
+    # of the requesting user.
+    # @param user [Lita::User] The user to add to the group.
+    # @param group [Symbol, String] The name of the group.
+    # @return [Boolean] true if the user was added. false if the user was
+    #   already in the group.
+    # @since 4.0.0
+    def add_user_to_group!(user, group)
+      redis.sadd(normalize_group(group), user.id)
+    end
 
-      # Checks if a user is an administrator.
-      # @param user [Lita::User] The user.
-      # @return [Boolean] Whether or not the user is an administrator.
-      def user_is_admin?(user)
-        Array(Lita.config.robot.admins).include?(user.id)
-      end
+    # Removes a user from an authorization group.
+    # @param requesting_user [Lita::User] The user who sent the command.
+    # @param user [Lita::User] The user to remove from the group.
+    # @param group [Symbol, String] The name of the group.
+    # @return [Symbol] :unauthorized if the requesting user is not authorized.
+    # @return [Boolean] true if the user was removed. false if the user was
+    #   not in the group.
+    def remove_user_from_group(requesting_user, user, group)
+      return :unauthorized unless user_is_admin?(requesting_user)
+      remove_user_from_group!(user, group)
+    end
 
-      # Returns a list of all authorization groups.
-      # @return [Array<Symbol>] The names of all authorization groups.
-      def groups
-        redis.keys("*").map(&:to_sym)
-      end
+    # Removes a suer from an authorization group without validating the
+    # permissions of the requesting user.
+    # @param user [Lita::User] The user to remove from the group.
+    # @param group [Symbol, String] The name of the group.
+    # @return [Boolean] true if the user was removed. false if the user was
+    #   not in the group.
+    # @since 4.0.0
+    def remove_user_from_group!(user, group)
+      redis.srem(normalize_group(group), user.id)
+    end
 
-      # Returns a hash of authorization group names and the users in them.
-      # @return [Hash] A map of +Symbol+ group names to +Lita::User+ objects.
-      def groups_with_users
-        groups.reduce({}) do |list, group|
-          list[group] = redis.smembers(group).map do |user_id|
-            User.find_by_id(user_id)
-          end
-          list
+    # Checks if a user is in an authorization group.
+    # @param user [Lita::User] The user.
+    # @param group [Symbol, String] The name of the group.
+    # @return [Boolean] Whether or not the user is in the group.
+    def user_in_group?(user, group)
+      group = normalize_group(group)
+      return user_is_admin?(user) if group == "admins"
+      redis.sismember(group, user.id)
+    end
+
+    # Checks if a user is an administrator.
+    # @param user [Lita::User] The user.
+    # @return [Boolean] Whether or not the user is an administrator.
+    def user_is_admin?(user)
+      Array(@config.robot.admins).include?(user.id)
+    end
+
+    # Returns a list of all authorization groups.
+    # @return [Array<Symbol>] The names of all authorization groups.
+    def groups
+      redis.keys("*").map(&:to_sym)
+    end
+
+    # Returns a hash of authorization group names and the users in them.
+    # @return [Hash] A map of +Symbol+ group names to +Lita::User+ objects.
+    def groups_with_users
+      groups.reduce({}) do |list, group|
+        list[group] = redis.smembers(group).map do |user_id|
+          User.find_by_id(user_id)
         end
+        list
       end
+    end
 
-      private
+    private
 
-      # Ensures that group names are stored consistently in Redis.
-      def normalize_group(group)
-        group.to_s.downcase.strip
-      end
+    # Ensures that group names are stored consistently in Redis.
+    def normalize_group(group)
+      group.to_s.downcase.strip
+    end
 
-      # A Redis::Namespace for authorization data.
-      def redis
-        @redis ||= Redis::Namespace.new("auth", redis: Lita.redis)
+    # A Redis::Namespace for authorization data.
+    def redis
+      @redis ||= Redis::Namespace.new("auth", redis: Lita.redis)
+    end
+
+    class << self
+      class << self
+        private
+
+        # @!macro define_deprecated_class_method
+        #   @method $1(*args)
+        #   @see #$1
+        #   @deprecated Will be removed in Lita 5.0 Use #$1 instead.
+        def define_deprecated_class_method(deprecated_method)
+          define_method(deprecated_method) do |*args|
+            Lita.logger.warn(I18n.t("lita.auth.class_method_deprecated", method: deprecated_method))
+            new(Lita.config).public_send(deprecated_method, *args)
+          end
+        end
       end
+
+      define_deprecated_class_method :add_user_to_group
+      define_deprecated_class_method :remove_user_from_group
+      define_deprecated_class_method :user_in_group?
+      define_deprecated_class_method :user_is_admin?
+      define_deprecated_class_method :groups
+      define_deprecated_class_method :groups_with_users
     end
   end
 end