lita 2.7.2 → 3.0.0

data/lib/lita/message.rb

@@ -26,10 +26,7 @@ module Lita
       @source = source
 
       name_pattern = Regexp.escape(@robot.mention_name)
-
-      if @robot.alias
-        name_pattern = "#{name_pattern}|#{Regexp.escape(@robot.alias)}"
-      end
+      name_pattern = "#{name_pattern}|#{Regexp.escape(@robot.alias)}" if @robot.alias
 
       @command = !!@body.sub!(/^\s*@?(?:#{name_pattern})[:,]?\s*/i, "")
     end
@@ -39,9 +36,9 @@ module Lita
     # @return [Array<String>] The array of arguments.
     def args
       begin
-        command, *args = body.shellsplit
+        _command, *args = body.shellsplit
       rescue ArgumentError
-        command, *args =
+        _command, *args =
           body.split(/\s+/).map(&:shellescape).join(" ").shellsplit
       end
 

data/lib/lita/rack_app.rb

@@ -1,114 +1,36 @@
 module Lita
   # A +Rack+ application to serve routes registered by handlers.
   class RackApp
-    # The character that separates the pieces of a URL's path component.
-    PATH_SEPARATOR = "/"
-
-    # A +Struct+ representing a route's destination handler and method name.
-    RouteMapping = Struct.new(:handler, :method_name)
-
-    # All registered paths. Used to respond to HEAD requests.
-    # @return [Array<String>] The array of paths.
-    attr_reader :all_paths
-
     # The currently running robot.
     # @return [Lita::Robot] The robot.
     attr_reader :robot
 
-    # A hash mapping HTTP request methods and paths to handlers and methods.
-    # @return [Hash] The mapping.
-    attr_reader :routes
+    # An +HttpRouter+ used for dispatch.
+    # @return [HttpRouter] The router.
+    attr_reader :router
 
     # @param robot [Lita::Robot] The currently running robot.
     def initialize(robot)
       @robot = robot
-      @routes = Hash.new { |h, k| h[k] = {} }
+      @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)
-      request = Rack::Request.new(env)
-      mapping = get_mapping(request)
-
-      if mapping
-        serve(mapping, request)
-      elsif request.head? && all_paths.include?(request.path)
-        Lita.logger.info "HTTP HEAD #{request.path} was a 204."
-        [204, {}, []]
-      else
-        Lita.logger.info <<-LOG.chomp
-HTTP #{request.request_method} #{request.path} was a 404.
-LOG
-        [404, {}, ["Route not found."]]
-      end
-    end
-
-    # Creates a +Rack+ application from the compiled routes.
-    # @return [Rack::Builder] The +Rack+ application.
-    def to_app
-      app = Rack::Builder.new
-      app.run(self)
-      app
+      env["lita.robot"] = robot
+      router.call(env)
     end
 
     private
 
-    # Collect all registered paths. Used for responding to HEAD requests.
-    def collect_paths
-      @all_paths = routes.values.map { |hash| hash.keys.first }.uniq
-    end
-
-    # Registers routes in the route mapping for each handler's defined routes.
+    # Registers routes in the router for each handler's defined routes.
     def compile
       Lita.handlers.each do |handler|
-        handler.http_routes.each { |route| register_route(handler, route) }
-      end
-      collect_paths
-    end
-
-    def get_mapping(request)
-      routes[request.request_method][request.path]
-    end
-
-    # Registers a route.
-    def register_route(handler, route)
-      cleaned_path = clean_path(route.path)
-
-      if @routes[route.http_method][cleaned_path]
-        Lita.logger.fatal <<-ERR.chomp
-#{handler.name} attempted to register an HTTP route that was already \
-registered: #{route.http_method} "#{cleaned_path}"
-ERR
-        abort
+        handler.http_routes.each { |route| router.add_route(route) }
       end
-
-      Lita.logger.debug <<-LOG.chomp
-Registering HTTP route: #{route.http_method} #{cleaned_path} to \
-#{handler}##{route.method_name}.
-LOG
-      @routes[route.http_method][cleaned_path] = RouteMapping.new(
-        handler,
-        route.method_name
-      )
-    end
-
-    def serve(mapping, request)
-      Lita.logger.info <<-LOG.chomp
-Routing HTTP #{request.request_method} #{request.path} to \
-#{mapping.handler}##{mapping.method_name}.
-LOG
-      response = Rack::Response.new
-      instance = mapping.handler.new(robot)
-      instance.public_send(mapping.method_name, request, response)
-      response.finish
-    end
-
-    # Ensures that paths begin with one slash and do not end with one.
-    def clean_path(path)
-      path.strip!
-      path.chop! while path.end_with?(PATH_SEPARATOR)
-      path = path[1..-1] while path.start_with?(PATH_SEPARATOR)
-      "/#{path}"
     end
   end
 end

data/lib/lita/response.rb

@@ -23,20 +23,10 @@ module Lita
     def_delegators :message, :args, :reply, :reply_privately, :user, :command?
 
     # @param message [Lita::Message] The incoming message.
-    # @param matches [Regexp] The pattern the incoming message matched.
-    def initialize(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-
-      self.message = args[0]
-      self.pattern = args[1]
-
-      if options[:matches]
-        Lita.logger.warn <<-WARNING.chomp
-Passing a "matches" option to Response's constructor is deprecated. \
-Use Response.new(message, pattern) instead.
-        WARNING
-        @matches = options[:matches]
-      end
+    # @param pattern [Regexp] The pattern the incoming message matched.
+    def initialize(message, pattern)
+      self.message = message
+      self.pattern = pattern
     end
 
     # An array of matches from scanning the message against the route pattern.
@@ -48,7 +38,7 @@ Use Response.new(message, pattern) instead.
     # A +MatchData+ object from running the pattern against the message body.
     # @return [MatchData] The +MatchData+.
     def match_data
-      @match_data ||= pattern.match(message.body) if pattern
+      @match_data ||= pattern.match(message.body)
     end
   end
 end

data/lib/lita/robot.rb

@@ -26,7 +26,7 @@ module Lita
       @name = Lita.config.robot.name
       @mention_name = Lita.config.robot.mention_name || @name
       @alias = Lita.config.robot.alias
-      @app = RackApp.new(self).to_app
+      @app = RackApp.new(self)
       load_adapter
       trigger(:loaded)
     end
@@ -49,6 +49,22 @@ module Lita
       shut_down
     end
 
+    # Makes the robot join a room with the specified ID.
+    # @param room_id [String] The ID of the room.
+    # @return [void]
+    # @since 3.0.0
+    def join(room_id)
+      @adapter.join(room_id)
+    end
+
+    # Makes the robot part from the room with the specified ID.
+    # @param room_id [String] The ID of the room.
+    # @return [void]
+    # @since 3.0.0
+    def part(room_id)
+      @adapter.part(room_id)
+    end
+
     # Sends one or more messages to a user or room.
     # @param target [Lita::Source] The user or room to send to. If the Source
     #   has a room, it will choose the room. Otherwise, it will send to the
@@ -74,7 +90,7 @@ module Lita
     # @return [void]
     def shut_down
       trigger(:shut_down_started)
-      @server.stop if @server
+      @server.stop(true) if @server
       @server_thread.join if @server_thread
       @adapter.shut_down
       trigger(:shut_down_complete)
@@ -100,7 +116,7 @@ module Lita
       adapter_class = Lita.adapters[adapter_name.to_sym]
 
       unless adapter_class
-        Lita.logger.fatal("Unknown adapter: :#{adapter_name}.")
+        Lita.logger.fatal I18n.t("lita.robot.unknown_adapter", adapter: adapter_name)
         abort
       end
 
@@ -109,14 +125,14 @@ module Lita
 
     # Starts the web server.
     def run_app
+      http_config = Lita.config.http
+
       @server_thread = Thread.new do
-        @server = Thin::Server.new(
-          app,
-          Lita.config.http.port.to_i,
-          signals: false
-        )
-        @server.silent = true unless Lita.config.http.debug
-        @server.start
+        @server = Puma::Server.new(app)
+        @server.add_tcp_listener(http_config.host, http_config.port.to_i)
+        @server.min_threads = http_config.min_threads
+        @server.max_threads = http_config.max_threads
+        @server.run
       end
 
       @server_thread.abort_on_exception = true

data/lib/lita/rspec.rb

@@ -3,15 +3,13 @@ begin
   require "rspec/expectations"
   require "rspec/mocks"
 rescue LoadError
-  abort "Lita::RSpec requires both RSpec::Mocks and RSpec::Expectations."
+  abort I18n.t("lita.rspec.full_suite_required")
 end
 
-major, minor, patch, *pre = RSpec::Mocks::Version::STRING.split(/\./)
-if major == "2" && minor.to_i < 14
-  abort "RSpec::Mocks 2.14 or greater is required to use Lita::RSpec."
-end
+major, minor, _patch, *_pre = RSpec::Mocks::Version::STRING.split(/\./)
+abort I18n.t("lita.rspec.mocks_expect_syntax_required") if major == "2" && minor.to_i < 14
 
-require "lita/rspec/handler"
+require_relative "rspec/handler"
 
 module Lita
   # Extras for +RSpec+ that facilitate the testing of Lita code.
@@ -32,14 +30,14 @@ module Lita
           end
         end
 
-        set_up_redis(base)
+        prepare_redis(base)
       end
 
       private
 
       # Set up Redis to use the test namespace and clear out before each
       # example.
-      def set_up_redis(base)
+      def prepare_redis(base)
         base.class_eval do
           before do
             stub_const("Lita::REDIS_NAMESPACE", "lita.test")

data/lib/lita/rspec/handler.rb

@@ -1,3 +1,7 @@
+require_relative "matchers/route_matcher"
+require_relative "matchers/http_route_matcher"
+require_relative "matchers/event_subscription_matcher"
+
 module Lita
   module RSpec
     # Extras for +RSpec+ to facilitate testing Lita handlers.
@@ -9,29 +13,23 @@ module Lita
             include Lita::RSpec
           end
 
-          set_up_let_blocks(base)
-          set_up_subject(base)
-          set_up_before_block(base)
+          prepare_handlers(base)
+          prepare_let_blocks(base)
+          prepare_subject(base)
+          prepare_robot(base)
         end
 
         private
 
-        # Stub Lita.handlers and Lita::Robot#send_messages.
-        def set_up_before_block(base)
+        # Stub Lita.handlers.
+        def prepare_handlers(base)
           base.class_eval do
-            before do
-              allow(Lita).to receive(:handlers).and_return([described_class])
-              [:send_messages, :send_message].each do |message|
-                allow(robot).to receive(message) do |target, *strings|
-                  replies.concat(strings)
-                end
-              end
-            end
+            before { allow(Lita).to receive(:handlers).and_return([described_class]) }
           end
         end
 
         # Create common test objects.
-        def set_up_let_blocks(base)
+        def prepare_let_blocks(base)
           base.class_eval do
             let(:robot) { Robot.new }
             let(:source) { Source.new(user: user) }
@@ -40,10 +38,24 @@ module Lita
           end
         end
 
+        # Stub Lita::Robot#send_messages.
+        def prepare_robot(base)
+          base.class_eval do
+            before do
+              [:send_messages, :send_message].each do |message|
+                allow(robot).to receive(message) do |target, *strings|
+                  replies.concat(strings)
+                end
+              end
+            end
+          end
+        end
+
         # Set up a working test subject.
-        def set_up_subject(base)
+        def prepare_subject(base)
           base.class_eval do
             subject { described_class.new(robot) }
+            before { allow(described_class).to receive(:new).and_return(subject) }
           end
         end
       end
@@ -73,42 +85,38 @@ module Lita
       # 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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
-      #   it to complete the test.
+      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      #   called on it to complete the test.
       def routes(message)
-        RouteMatcher.new(self, message)
+        Matchers::RouteMatcher.new(self, 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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
-      #   it to complete the test.
+      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      #   called on it to complete the test.
       def does_not_route(message)
-        RouteMatcher.new(self, message, invert: true)
+        Matchers::RouteMatcher.new(self, message, expectation: false)
       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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
-      #   it to complete the test.
+      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      #   called on it to complete the test.
       def routes_command(message)
-        RouteMatcher.new(self, "#{robot.mention_name}: #{message}")
+        Matchers::RouteMatcher.new(self, "#{robot.mention_name}: #{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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
-      #   it to complete the test.
+      # @return [Matchers::RouteMatcher] A {Matchers::RouteMatcher} that should have +to+
+      #   called on it to complete the test.
       def does_not_route_command(message)
-        RouteMatcher.new(
-          self,
-          "#{robot.mention_name}: #{message}",
-          invert: true
-        )
+        Matchers::RouteMatcher.new(self, "#{robot.mention_name}: #{message}", expectation: false)
       end
       alias_method :doesnt_route_command, :does_not_route_command
 
@@ -118,10 +126,10 @@ module Lita
       #   the route.
       # @param path [String] The path URL component that should trigger the
       #   route.
-      # @return [HTTPRouteMatcher] An {HTTPRouteMatcher} that should have +to+
-      #   called on it to complete the test.
+      # @return [Matchers::HTTPRouteMatcher] A {Matchers::HTTPRouteMatcher} that should
+      #   have +to+ called on it to complete the test.
       def routes_http(http_method, path)
-        HTTPRouteMatcher.new(self, http_method, path)
+        Matchers::HTTPRouteMatcher.new(self, http_method, path)
       end
 
       # Starts an HTTP routing test chain, asserting that a request to the given
@@ -130,10 +138,10 @@ module Lita
       #   trigger the route.
       # @param path [String] The path URL component that should not trigger the
       #   route.
-      # @return [HTTPRouteMatcher] An {HTTPRouteMatcher} that should have +to+
-      #   called on it to complete the test.
+      # @return [Matchers::HTTPRouteMatcher] A {Matchers::HTTPRouteMatcher} that should
+      #   have +to+ called on it to complete the test.
       def does_not_route_http(http_method, path)
-        HTTPRouteMatcher.new(self, http_method, path, invert: true)
+        Matchers::HTTPRouteMatcher.new(self, http_method, path, expectation: false)
       end
       alias_method :doesnt_route_http, :does_not_route_http
 
@@ -141,102 +149,22 @@ module Lita
       # trigger the target method.
       # @param event_name [String, Symbol] The name of the event that should
       #   be triggered.
-      # @return [EventSubscriptionMatcher] An {EventSubscriptionMatcher} that
+      # @return [Matchers::EventSubscriptionMatcher] A {Matchers::EventSubscriptionMatcher} that
       #   should have +to+ called on it to complete the test.
       def routes_event(event_name)
-        EventSubscriptionMatcher.new(self, event_name)
+        Matchers::EventSubscriptionMatcher.new(self, 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 [EventSubscriptionMatcher] An {EventSubscriptionMatcher} that
+      # @return [Matchers::EventSubscriptionMatcher] A {Matchers::EventSubscriptionMatcher} that
       #   should have +to+ called on it to complete the test.
       def does_not_route_event(event_name)
-        EventSubscriptionMatcher.new(self, event_name, invert: true)
+        Matchers::EventSubscriptionMatcher.new(self, event_name, expectation: false)
       end
       alias_method :doesnt_route_event, :does_not_route_event
     end
-
-    # Used to complete a chat routing test chain.
-    class RouteMatcher
-      def initialize(context, message_body, invert: false)
-        @context = context
-        @message_body = message_body
-        @method = invert ? :not_to : :to
-      end
-
-      # Sets an expectation that a route will or will not be triggered, then
-      # sends the message originally provided.
-      # @param route [Symbol] The name of the method that should or should not
-      #   be triggered.
-      # @return [void]
-      def to(route)
-        m = @method
-        b = @message_body
-
-        @context.instance_eval do
-          allow(Authorization).to receive(:user_in_group?).and_return(true)
-          expect_any_instance_of(described_class).public_send(m, receive(route))
-          send_message(b)
-        end
-      end
-    end
-
-    # Used to complete an HTTP routing test chain.
-    class HTTPRouteMatcher
-      def initialize(context, http_method, path, invert: false)
-        @context = context
-        @http_method = http_method
-        @path = path
-        @method = invert ? :not_to : :to
-      end
-
-      # Sets an expectation that an HTTP route will or will not be triggered,
-      #   then makes an HTTP request against the app with the HTTP request
-      #   method and path originally provided.
-      # @param route [Symbol] The name of the method that should or should not
-      #   be triggered.
-      # @return [void]
-      def to(route)
-        m = @method
-        h = @http_method
-        p = @path
-
-        @context.instance_eval do
-          expect_any_instance_of(described_class).public_send(m, receive(route))
-          env = Rack::MockRequest.env_for(p, method: h)
-          robot.app.call(env)
-        end
-      end
-    end
-
-    # Used to complete an event subscription test chain.
-    class EventSubscriptionMatcher
-      def initialize(context, event_name, invert: false)
-        @context = context
-        @event_name = event_name
-        @method = invert ? :not_to : :to
-      end
-
-      # Sets an expectation that a handler method will or will not be called in
-      # response to a triggered event, then triggers the event.
-      # @param target_method_name [String, Symbol] The name of the method that
-      #   should or should not be triggered.
-      # @return [void]
-      def to(target_method_name)
-        e = @event_name
-        m = @method
-
-        @context.instance_eval do
-          expect_any_instance_of(described_class).public_send(
-            m,
-            receive(target_method_name)
-          )
-          robot.trigger(e)
-        end
-      end
-    end
   end
 end