lita 3.3.1 → 4.0.0.rc1

data/lib/lita/robot.rb

@@ -4,10 +4,17 @@ module Lita
   # registered handlers. Can send outgoing chat messages and set the topic
   # of chat rooms.
   class Robot
+    extend Forwardable
+
     # A +Rack+ application used for the built-in web server.
     # @return [Rack::Builder] The +Rack+ app.
     attr_reader :app
 
+    # The {Authorization} object for the currently running robot.
+    # @return [Lita::Authorization] The authorization object.
+    # @since 4.0.0
+    attr_reader :auth
+
     # The name the robot will look for in incoming messages to determine if it's
     # being addressed.
     # @return [String] The mention name.
@@ -22,12 +29,21 @@ module Lita
     # @return [String] The robot's name.
     attr_reader :name
 
-    def initialize
-      @name = Lita.config.robot.name
-      @mention_name = Lita.config.robot.mention_name || @name
-      @alias = Lita.config.robot.alias
-      @app = RackApp.new(self)
-      load_adapter
+    # The {Registry} for the currently running robot.
+    # @return [Lita::Registry] The registry.
+    # @since 4.0.0
+    attr_reader :registry
+
+    def_delegators :registry, :config, :adapters, :handlers, :hooks
+
+    # @param registry [Lita::Registry] The registry for the robot's configuration and plugins.
+    def initialize(registry = Lita)
+      @registry = registry
+      @name = config.robot.name
+      @mention_name = config.robot.mention_name || @name
+      @alias = config.robot.alias
+      @app = RackApp.build(self)
+      @auth = Authorization.new(config)
       trigger(:loaded)
     end
 
@@ -36,7 +52,13 @@ module Lita
     # @param message [Lita::Message] The incoming message.
     # @return [void]
     def receive(message)
-      Lita.handlers.each { |handler| handler.dispatch(self, message) }
+      matched = handlers.map do |handler|
+        next unless handler.respond_to?(:dispatch)
+
+        handler.dispatch(self, message)
+      end.any?
+
+      trigger(:unhandled_message, message: message) unless matched
     end
 
     # Starts the robot, booting the web server and delegating to the adapter to
@@ -44,7 +66,7 @@ module Lita
     # @return [void]
     def run
       run_app
-      @adapter.run
+      adapter.run
     rescue Interrupt
       shut_down
     end
@@ -54,7 +76,7 @@ module Lita
     # @return [void]
     # @since 3.0.0
     def join(room_id)
-      @adapter.join(room_id)
+      adapter.join(room_id)
     end
 
     # Makes the robot part from the room with the specified ID.
@@ -62,7 +84,7 @@ module Lita
     # @return [void]
     # @since 3.0.0
     def part(room_id)
-      @adapter.part(room_id)
+      adapter.part(room_id)
     end
 
     # Sends one or more messages to a user or room.
@@ -72,7 +94,7 @@ module Lita
     # @param strings [String, Array<String>] One or more strings to send.
     # @return [void]
     def send_messages(target, *strings)
-      @adapter.send_messages(target, strings.flatten)
+      adapter.send_messages(target, strings.flatten)
     end
     alias_method :send_message, :send_messages
 
@@ -89,7 +111,7 @@ module Lita
 
       mention_name = target.user.mention_name
       prefixed_strings = strings.map do |s|
-        "#{@adapter.mention_format(mention_name).strip} #{s}"
+        "#{adapter.mention_format(mention_name).strip} #{s}"
       end
 
       send_messages(target, *prefixed_strings)
@@ -101,7 +123,7 @@ module Lita
     # @param topic [String] The new topic message to set.
     # @return [void]
     def set_topic(target, topic)
-      @adapter.set_topic(target, topic)
+      adapter.set_topic(target, topic)
     end
 
     # Gracefully shuts the robot down, stopping the web server and delegating
@@ -112,7 +134,7 @@ module Lita
       trigger(:shut_down_started)
       @server.stop(true) if @server
       @server_thread.join if @server_thread
-      @adapter.shut_down
+      adapter.shut_down
       trigger(:shut_down_complete)
     end
 
@@ -123,33 +145,49 @@ module Lita
     # @param payload [Hash] An optional hash of arbitrary data.
     # @return [void]
     def trigger(event_name, payload = {})
-      Lita.handlers.each do |handler|
+      handlers.each do |handler|
+        next unless handler.respond_to?(:trigger)
+
         handler.trigger(self, event_name, payload)
       end
     end
 
     private
 
+    # Loads and caches the adapter on first access.
+    def adapter
+      @adapter ||= load_adapter
+    end
+
     # Loads the selected adapter.
     def load_adapter
-      adapter_name = Lita.config.robot.adapter
-      adapter_class = Lita.adapters[adapter_name.to_sym]
+      adapter_name = config.robot.adapter
+      adapter_class = adapters[adapter_name.to_sym]
 
       unless adapter_class
         Lita.logger.fatal I18n.t("lita.robot.unknown_adapter", adapter: adapter_name)
         abort
       end
 
-      @adapter = adapter_class.new(self)
+      adapter_class.new(self)
     end
 
     # Starts the web server.
     def run_app
-      http_config = Lita.config.http
+      http_config = config.http
 
       @server_thread = Thread.new do
         @server = Puma::Server.new(app)
-        @server.add_tcp_listener(http_config.host, http_config.port.to_i)
+        begin
+          @server.add_tcp_listener(http_config.host, http_config.port.to_i)
+        rescue Errno::EADDRINUSE, Errno::EACCES => e
+            Lita.logger.fatal I18n.t(
+              "lita.http.exception",
+              message: e.message,
+              backtrace: e.backtrace.join("\n")
+            )
+            abort
+        end
         @server.min_threads = http_config.min_threads
         @server.max_threads = http_config.max_threads
         @server.run

data/lib/lita/route_validator.rb

@@ -14,6 +14,10 @@ module Lita
     # The route being checked.
     attr_reader :route
 
+    # @param handler [Lita::Handler] The handler the route belongs to.
+    # @param route [Lita::Handler::ChatRouter::Route] The route being validated.
+    # @param message [Lita::Message] The incoming message.
+    # @param robot [Lita::Robot] The currently running robot.
     def initialize(handler, route, message, robot)
       @handler = handler
       @route = route
@@ -27,7 +31,7 @@ module Lita
       return unless command_satisfied?(route, message)
       return if from_self?(message, robot)
       return unless matches_pattern?(route, message)
-      return unless authorized?(message.user, route.required_groups)
+      return unless authorized?(robot, message.user, route.required_groups)
       return unless passes_route_hooks?(route, message, robot)
 
       true
@@ -52,15 +56,19 @@ module Lita
 
     # Allow custom route hooks to reject the route
     def passes_route_hooks?(route, message, robot)
-      Lita.hooks[:validate_route].all? do |hook|
+      robot.hooks[:validate_route].all? do |hook|
         hook.call(handler: handler, route: route, message: message, robot: robot)
       end
     end
 
     # User must be in auth group if route is restricted.
-    def authorized?(user, required_groups)
+    def authorized?(robot, user, required_groups)
       required_groups.nil? || required_groups.any? do |group|
-        Authorization.user_in_group?(user, group)
+        if Lita.version_3_compatibility_mode?
+          Lita::Authorization.user_in_group?(user, group)
+        else
+          robot.auth.user_in_group?(user, group)
+        end
       end
     end
   end

data/lib/lita/rspec.rb

@@ -9,6 +9,7 @@ end
 major, *_unused = RSpec::Core::Version::STRING.split(/\./)
 abort I18n.t("lita.rspec.version_3_required") if major.to_i < 3
 
+require_relative "../lita"
 require_relative "rspec/handler"
 
 module Lita
@@ -23,26 +24,21 @@ module Lita
       # @return [void]
       def included(base)
         base.class_eval do
-          before do
-            logger = double("Logger").as_null_object
-            allow(Lita).to receive(:logger).and_return(logger)
-            Lita.clear_config
+          let(:registry) do
+            if Lita.version_3_compatibility_mode?
+              Lita
+            else
+              Registry.new
+            end
           end
-        end
 
-        prepare_redis(base)
-      end
-
-      private
-
-      # Set up Redis to use the test namespace and clear out before each
-      # example.
-      def prepare_redis(base)
-        base.class_eval do
           before do
+            logger = double("Logger").as_null_object
+            allow(Lita).to receive(:logger).and_return(logger)
             stub_const("Lita::REDIS_NAMESPACE", "lita.test")
             keys = Lita.redis.keys("*")
             Lita.redis.del(keys) unless keys.empty?
+            registry.clear_config if Lita.version_3_compatibility_mode?
           end
         end
       end
@@ -50,7 +46,20 @@ module Lita
   end
 end
 
+Lita.test_mode = true
+Lita.version_3_compatibility_mode = true
+
 RSpec.configure do |config|
   config.include Lita::RSpec, lita: true
   config.include Lita::RSpec::Handler, lita_handler: true
+
+  config.before(:suite) do
+    if Lita.version_3_compatibility_mode?
+      if RSpec.configuration.color_enabled?
+        warn "\e[31m" + I18n.t("lita.rspec.lita_3_compatibility_mode") + "\e[0m"
+      else
+        warn I18n.t("lita.rspec.lita_3_compatibility_mode")
+      end
+    end
+  end
 end

data/lib/lita/rspec/handler.rb

@@ -1,17 +1,20 @@
-require_relative "matchers/route_matcher"
+require_relative "matchers/chat_route_matcher"
 require_relative "matchers/http_route_matcher"
-require_relative "matchers/event_subscription_matcher"
+require_relative "matchers/event_route_matcher"
+require_relative "matchers/deprecated"
 
 module Lita
   module RSpec
     # Extras for +RSpec+ to facilitate testing Lita handlers.
     module Handler
+      include Matchers::ChatRouteMatcher
+      include Matchers::HTTPRouteMatcher
+      include Matchers::EventRouteMatcher
+
       class << self
         # Sets up the RSpec environment to easily test Lita handlers.
         def included(base)
-          base.class_eval do
-            include Lita::RSpec
-          end
+          base.send(:include, Lita::RSpec)
 
           prepare_handlers(base)
           prepare_let_blocks(base)
@@ -24,14 +27,20 @@ module Lita
         # Stub Lita.handlers.
         def prepare_handlers(base)
           base.class_eval do
-            before { allow(Lita).to receive(:handlers).and_return([described_class]) }
+            before do
+              if Lita.version_3_compatibility_mode?
+                allow(Lita).to receive(:handlers).and_return(Set.new([described_class]))
+              else
+                registry.register_handler(described_class)
+              end
+            end
           end
         end
 
         # Create common test objects.
         def prepare_let_blocks(base)
           base.class_eval do
-            let(:robot) { Robot.new }
+            let(:robot) { Robot.new(registry) }
             let(:source) { Source.new(user: user) }
             let(:user) { User.create("1", name: "Test User") }
             let(:replies) { [] }
@@ -82,41 +91,78 @@ module Lita
         send_message("#{robot.mention_name}: #{body}", as: as)
       end
 
+      # Returns a Faraday connection hooked up to the currently running robot's Rack app.
+      # @return [Faraday::Connection] The connection.
+      # @since 4.0.0
+      def http
+        begin
+          require "rack/test"
+        rescue LoadError
+          raise LoadError, I18n.t("lita.rspec.rack_test_required")
+        end unless Rack.const_defined?(:Test)
+
+        Faraday::Connection.new { |c| c.adapter(:rack, robot.app) }
+      end
+
       # Starts a chat routing test chain, asserting that a message should
       # trigger a route.
       # @param message [String] The message that should trigger the route.
-      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
       #   called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route+ instead.
       def routes(message)
-        Matchers::RouteMatcher.new(self, message)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "routes",
+          new_method: "is_expected.to route",
+        )
+        Matchers::Deprecated.new(self, :route, true, message)
       end
 
       # Starts a chat routing test chain, asserting that a message should not
       # trigger a route.
       # @param message [String] The message that should not trigger the route.
-      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
       #   called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route+ instead.
       def does_not_route(message)
-        Matchers::RouteMatcher.new(self, message, expectation: false)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "does_not_route",
+          new_method: "is_expected.not_to route",
+        )
+        Matchers::Deprecated.new(self, :route, false, message)
       end
       alias_method :doesnt_route, :does_not_route
 
       # Starts a chat routing test chain, asserting that a "command" message
       # should trigger a route.
       # @param message [String] The message that should trigger the route.
-      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
       #   called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_command+ instead.
       def routes_command(message)
-        Matchers::RouteMatcher.new(self, "#{robot.mention_name}: #{message}")
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "routes_command",
+          new_method: "is_expected.to route_command",
+        )
+        Matchers::Deprecated.new(self, :route_command, true, message)
       end
 
       # Starts a chat routing test chain, asserting that a "command" message
       # should not trigger a route.
       # @param message [String] The message that should not trigger the route.
-      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
       #   called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_command+ instead.
       def does_not_route_command(message)
-        Matchers::RouteMatcher.new(self, "#{robot.mention_name}: #{message}", expectation: false)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "does_not_route_command",
+          new_method: "is_expected.not_to route_command",
+        )
+        Matchers::Deprecated.new(self, :route_command, false, message)
       end
       alias_method :doesnt_route_command, :does_not_route_command
 
@@ -126,10 +172,16 @@ module Lita
       #   the route.
       # @param path [String] The path URL component that should trigger the
       #   route.
-      # @return [Matchers::HTTPRouteMatcher] A {Matchers::HTTPRouteMatcher} that should
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should
       #   have +to+ called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_http+ instead.
       def routes_http(http_method, path)
-        Matchers::HTTPRouteMatcher.new(self, http_method, path)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "routes_http",
+          new_method: "is_expected.to route_http",
+        )
+        Matchers::Deprecated.new(self, :route_http, true, http_method, path)
       end
 
       # Starts an HTTP routing test chain, asserting that a request to the given
@@ -138,10 +190,16 @@ module Lita
       #   trigger the route.
       # @param path [String] The path URL component that should not trigger the
       #   route.
-      # @return [Matchers::HTTPRouteMatcher] A {Matchers::HTTPRouteMatcher} that should
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should
       #   have +to+ called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_http+ instead.
       def does_not_route_http(http_method, path)
-        Matchers::HTTPRouteMatcher.new(self, http_method, path, expectation: false)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "does_not_route_http",
+          new_method: "is_expected.not_to route_http",
+        )
+        Matchers::Deprecated.new(self, :route_http, false, http_method, path)
       end
       alias_method :doesnt_route_http, :does_not_route_http
 
@@ -149,20 +207,32 @@ module Lita
       # trigger the target method.
       # @param event_name [String, Symbol] The name of the event that should
       #   be triggered.
-      # @return [Matchers::EventSubscriptionMatcher] A {Matchers::EventSubscriptionMatcher} that
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that
       #   should have +to+ called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_event+ instead.
       def routes_event(event_name)
-        Matchers::EventSubscriptionMatcher.new(self, event_name)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "routes_event",
+          new_method: "is_expected.to route_event",
+        )
+        Matchers::Deprecated.new(self, :route_event, true, event_name)
       end
 
       # Starts an event subscription test chain, asserting that an event should
       # not trigger the target method.
       # @param event_name [String, Symbol] The name of the event that should
       #   not be triggered.
-      # @return [Matchers::EventSubscriptionMatcher] A {Matchers::EventSubscriptionMatcher} that
+      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that
       #   should have +to+ called on it to complete the test.
+      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_event+ instead.
       def does_not_route_event(event_name)
-        Matchers::EventSubscriptionMatcher.new(self, event_name, expectation: false)
+        STDERR.puts I18n.t(
+          "lita.rspec.matcher_deprecated",
+          old_method: "does_not_route_event",
+          new_method: "is_expected.not_to route_event",
+        )
+        Matchers::Deprecated.new(self, :route_event, false, event_name)
       end
       alias_method :doesnt_route_event, :does_not_route_event
     end