lita 2.7.2 → 3.0.0

data/lib/lita/daemon.rb

@@ -19,19 +19,14 @@ module Lita
       Process.daemon(true)
       File.open(@pid_path, "w") { |f| f.write(Process.pid) }
       set_up_logs
-      at_exit { FileUtils.rm(@pid_path) if File.exist?(@pid_path) }
+      at_exit { FileUtils.rm(@pid_path) if File.exists?(@pid_path) }
     end
 
     private
 
     # Abort if Lita is already running.
     def ensure_not_running
-      if File.exist?(@pid_path)
-        abort <<-FATAL.chomp
-PID file exists at #{@pid_path}. Lita may already be running. \
-Kill the existing process or remove the PID file and then start Lita.
-FATAL
-      end
+      abort I18n.t("lita.daemon.pid_exists", path: @pid_path) if File.exists?(@pid_path)
     end
 
     # Call the appropriate method depending on kill mode.
@@ -45,18 +40,26 @@ FATAL
 
     # Try to kill an existing process.
     def kill_existing_process
-      pid = File.read(@pid_path).strip.to_i
+      pid = File.read(@pid_path).to_s.strip.to_i
       Process.kill("TERM", pid)
     rescue Errno::ESRCH, RangeError, Errno::EPERM
-      abort "Failed to kill existing Lita process #{pid}."
+      abort I18n.t("lita.daemon.kill_failure", pid: pid)
     end
 
     # Redirect the standard streams to a log file.
     def set_up_logs
       log_file = File.new(@log_path, "a")
-      $stdout.reopen(log_file)
-      $stderr.reopen(log_file)
-      $stderr.sync = $stdout.sync = true
+      stdout.reopen(log_file)
+      stderr.reopen(log_file)
+      stderr.sync = stdout.sync = true
+    end
+
+    def stdout
+      $stdout
+    end
+
+    def stderr
+      $stderr
     end
   end
 end

data/lib/lita/handler.rb

@@ -91,7 +91,7 @@ module Lita
         if name
           Util.underscore(name.split("::").last)
         else
-          raise "Handlers that are anonymous classes must define self.name."
+          raise I18n.t("lita.handler.name_required")
         end
       end
 
@@ -108,6 +108,17 @@ module Lita
         event_subscriptions[normalize_event(event_name)] << method_name
       end
 
+      # Returns the translation for a key, automatically namespaced to the handler.
+      # @param key [String] The key of the translation.
+      # @param hash [Hash] An optional hash of values to be interpolated in the string.
+      # @return [String] The translated string.
+      # @since 3.0.0
+      def translate(key, hash = {})
+        I18n.translate("lita.handlers.#{namespace}.#{key}", hash)
+      end
+
+      alias_method :t, :translate
+
       # Triggers an event, invoking methods previously registered with {on} and
       # passing them a payload hash with any arbitrary data.
       # @param robot [Lita::Robot] The currently running robot instance.
@@ -159,17 +170,20 @@ module Lita
 
       # Logs the dispatch of message.
       def log_dispatch(route)
-        Lita.logger.debug <<-LOG.chomp
-Dispatching message to #{self}##{route.method_name}.
-LOG
+        Lita.logger.debug I18n.t(
+          "lita.handler.dispatch",
+          handler: name,
+          method: route.method_name
+        )
       end
 
       def log_dispatch_error(e)
-        Lita.logger.error <<-ERROR.chomp
-#{name} crashed. The exception was:
-#{e.message}
-#{e.backtrace.join("\n")}
-ERROR
+        Lita.logger.error I18n.t(
+          "lita.handler.exception",
+          handler: name,
+          message: e.message,
+          backtrace: e.backtrace.join("\n")
+        )
       end
 
       def normalize_event(event_name)
@@ -183,6 +197,25 @@ ERROR
       @redis = Redis::Namespace.new(redis_namespace, redis: Lita.redis)
     end
 
+    # Invokes the given block after the given number of seconds.
+    # @param interval [Integer] The number of seconds to wait before invoking the block.
+    # @yieldparam timer [Lita::Timer] The current {Lita::Timer} instance.
+    # @since 3.0.0
+    def after(interval, &block)
+      Timer.new(interval: interval, &block).start
+    end
+
+    # Invokes the given block repeatedly, waiting the given number of seconds between each
+    # invocation.
+    # @param interval [Integer] The number of seconds to wait before each invocation of the block.
+    # @yieldparam timer [Lita::Timer] The current {Lita::Timer} instance.
+    # @note The block should call {Lita::Timer#stop} at a terminating condition to avoid infinite
+    #   recursion.
+    # @since 3.0.0
+    def every(interval, &block)
+      Timer.new(interval: interval, recurring: true, &block).start
+    end
+
     # Creates a new +Faraday::Connection+ for making HTTP requests.
     # @param options [Hash] A set of options passed on to Faraday.
     # @yield [builder] A Faraday builder object for adding middleware.
@@ -192,6 +225,13 @@ ERROR
       Faraday::Connection.new(nil, options, &block)
     end
 
+    # @see .translate
+    def translate(*args)
+      self.class.translate(*args)
+    end
+
+    alias_method :t, :translate
+
     private
 
     # Default options for new Faraday connections. Sets the user agent to the

data/lib/lita/handlers/authorization.rb

@@ -1,4 +1,5 @@
 module Lita
+  # A namespace to hold all subclasses of {Handler}.
   module Handlers
     # Provides a chat interface for administering authorization groups.
     class Authorization < Handler
@@ -7,28 +8,17 @@ module Lita
         :add,
         command: true,
         restrict_to: :admins,
-        help: {
-        "auth add USER GROUP" => <<-HELP.chomp
-Add USER to authorization group GROUP. Requires admin privileges.
-HELP
-        }
+        help: { t("help.add_key") => t("help.add_value") }
       )
       route(
         /^auth\s+remove/,
         :remove,
         command: true,
         restrict_to: :admins,
-        help: {
-        "auth remove USER GROUP" => <<-HELP.chomp
-Remove USER from authorization group GROUP. Requires admin privileges.
-HELP
-        }
+        help: { t("help.remove_key") => t("help.remove_value") }
       )
       route(/^auth\s+list/, :list, command: true, restrict_to: :admins, help: {
-        "auth list [GROUP]" => <<-HELP.chomp
-List authorization groups and the users in them. If GROUP is supplied, only \
-lists that group.
-HELP
+        t("help.list_key") => t("help.list_value")
       })
 
       # Adds a user to an authorization group.
@@ -38,9 +28,9 @@ HELP
         return unless valid_message?(response)
 
         if Lita::Authorization.add_user_to_group(response.user, @user, @group)
-          response.reply "#{@user.name} was added to #{@group}."
+          response.reply t("user_added", user: @user.name, group: @group)
         else
-          response.reply "#{@user.name} was already in #{@group}."
+          response.reply t("user_already_in", user: @user.name, group: @group)
         end
       end
 
@@ -50,14 +40,13 @@ HELP
       def remove(response)
         return unless valid_message?(response)
 
-        if Lita::Authorization.remove_user_from_group(
-          response.user,
-          @user,
-          @group
-        )
-          response.reply "#{@user.name} was removed from #{@group}."
+        if Lita::Authorization.remove_user_from_group(response.user, @user, @group)
+          response.reply t("user_removed",
+            user: @user.name,
+            group: @group
+          )
         else
-          response.reply "#{@user.name} was not in #{@group}."
+          response.reply t("user_not_in", user: @user.name, group: @group)
         end
       end
 
@@ -67,15 +56,9 @@ HELP
       # @return [void]
       def list(response)
         requested_group = response.args[1]
-        output = get_groups_list(requested_group)
+        output = get_groups_list(response.args[1])
         if output.empty?
-          if requested_group
-            response.reply(
-              "There is no authorization group named #{requested_group}."
-            )
-          else
-            response.reply("There are no authorization groups yet.")
-          end
+          response.reply(empty_state_for_list(requested_group))
         else
           response.reply(output.join("\n"))
         end
@@ -83,6 +66,14 @@ HELP
 
       private
 
+      def empty_state_for_list(requested_group)
+        if requested_group
+          t("empty_state_group", group: requested_group)
+        else
+          t("empty_state")
+        end
+      end
+
       def get_groups_list(requested_group)
         groups_with_users = Lita::Authorization.groups_with_users
         if requested_group
@@ -95,34 +86,43 @@ HELP
         end
       end
 
-      # Validates that incoming messages have the right format and a valid user.
-      # Also assigns the user and group to instance variables for the main
-      # methods to use later.
-      def valid_message?(response)
-        command, identifier, @group = response.args
-
+      def valid_group?(response, identifier)
         unless identifier && @group
-          response.reply "Format: #{robot.name} auth add USER GROUP"
+          response.reply "#{t('format')}: #{robot.name} auth add USER GROUP"
           return
         end
 
         if @group.downcase.strip == "admins"
-          response.reply "Administrators can only be managed via Lita config."
+          response.reply t("admin_management")
           return
         end
 
-        @user = User.find_by_id(identifier)
-        @user = User.find_by_name(identifier) unless @user
+        true
+      end
 
-        unless @user
-          response.reply <<-REPLY.chomp
-No user was found with the identifier "#{identifier}".
-REPLY
-          return
-        end
+      # Validates that incoming messages have the right format and a valid user.
+      # Also assigns the user and group to instance variables for the main
+      # methods to use later.
+      def valid_message?(response)
+        _command, identifier, @group = response.args
+
+        return unless valid_group?(response, identifier)
+
+        return unless valid_user?(response, identifier)
 
         true
       end
+
+      def valid_user?(response, identifier)
+        @user = User.fuzzy_find(identifier)
+
+        if @user
+          true
+        else
+          response.reply t("no_user_found", identifier: identifier)
+          return
+        end
+      end
     end
 
     Lita.register_handler(Authorization)

data/lib/lita/handlers/help.rb

@@ -1,14 +1,11 @@
 module Lita
+  # A namespace to hold all subclasses of {Handler}.
   module Handlers
     # Provides online help about Lita commands for users.
     class Help < Handler
       route(/^help\s*(.+)?/, :help, command: true, help: {
-        "help" => %{
-Lists help information for terms and command the robot will respond to.
-}.gsub(/\n/, ""),
-        "help COMMAND" => %{
-Lists help information for terms or commands that begin with COMMAND.
-}.gsub(/\n/, "")
+        "help" => t("help.help_value"),
+        t("help.help_command_key") => t("help.help_command_value")
       })
 
       # Outputs help information about Lita commands.
@@ -31,19 +28,15 @@ Lists help information for terms or commands that begin with COMMAND.
 
       # Creates an array of help info for all registered routes.
       def build_help(response)
-        output = []
-
-        Lita.handlers.each do |handler|
-          handler.routes.each do |route|
-            route.help.each do |command, description|
-              next unless authorized?(response.user, route.required_groups)
-              command = "#{name}: #{command}" if route.command?
-              output << "#{command} - #{description}"
+        Lita.handlers.map do |handler|
+          handler.routes.map do |route|
+            route.help.map do |command, description|
+              if authorized?(response.user, route.required_groups)
+                help_command(route, command, description)
+              end
             end
           end
-        end
-
-        output
+        end.flatten.compact
       end
 
       # Filters the help output by an optional command.
@@ -57,6 +50,12 @@ Lists help information for terms or commands that begin with COMMAND.
         end
       end
 
+      # Formats an individual command's help message.
+      def help_command(route, command, description)
+        command = "#{name}: #{command}" if route.command?
+        "#{command} - #{description}"
+      end
+
       # The way the bot should be addressed in order to trigger a command.
       def name
         Lita.config.robot.mention_name || Lita.config.robot.name

data/lib/lita/handlers/info.rb

@@ -0,0 +1,38 @@
+module Lita
+  # A namespace to hold all subclasses of {Handler}.
+  module Handlers
+    # Provides information about the currently running robot.
+    class Info < Handler
+      route(/^info$/i, :chat, command: true, help: {
+        "info" => t("help.info_value")
+      })
+
+      http.get "/lita/info", :web
+
+      # Replies with the current version of the Lita.
+      # @param response [Lita::Response] The response object.
+      # @return [void]
+      # @since 3.0.0
+      def chat(response)
+        response.reply "Lita #{Lita::VERSION} - http://www.lita.io/"
+      end
+
+      # Returns JSON with basic information about the robot.
+      # @param request [Rack::Request] The HTTP request.
+      # @param response [Rack::Response] The HTTP response.
+      # @return [void]
+      def web(request, response)
+        response.headers["Content-Type"] = "application/json"
+        json = MultiJson.dump(
+          lita_version: Lita::VERSION,
+          adapter: Lita.config.robot.adapter,
+          robot_name: robot.name,
+          robot_mention_name: robot.mention_name
+        )
+        response.write(json)
+      end
+    end
+
+    Lita.register_handler(Info)
+  end
+end

data/lib/lita/handlers/room.rb

@@ -0,0 +1,32 @@
+module Lita
+  # A namespace to hold all subclasses of {Handler}.
+  module Handlers
+    # Allows administrators to make Lita join and part from rooms.
+    # @since 3.0.0
+    class Room < Handler
+      route(/^join\s+(.+)$/i, :join, command: true, restrict_to: :admins, help: {
+        t("help.join_key") => t("help.join_value")
+      })
+
+      route(/^part\s+(.+)$/i, :part, command: true, restrict_to: :admins, help: {
+        t("help.part_key") => t("help.part_value")
+      })
+
+      # Joins the room with the specified ID.
+      # @param response [Lita::Response] The response object.
+      # @return [void]
+      def join(response)
+        robot.join(response.args[0])
+      end
+
+      # Parts from the room with the specified ID.
+      # @param response [Lita::Response] The response object.
+      # @return [void]
+      def part(response)
+        robot.part(response.args[0])
+      end
+    end
+
+    Lita.register_handler(Room)
+  end
+end

data/lib/lita/http_route.rb

@@ -2,22 +2,17 @@ module Lita
   # Handlers use this class to define HTTP routes for the built-in web
   # server.
   class HTTPRoute
+    # An +HttpRouter::Route+ class used for dispatch.
+    # @since 3.0.0
+    ExtendedRoute = Class.new(HttpRouter::Route) do
+      include HttpRouter::RouteHelper
+      include HttpRouter::GenerationHelper
+    end
+
     # The handler registering the route.
     # @return [Lita::Handler] The handler.
     attr_reader :handler_class
 
-    # The HTTP method for the route (GET, POST, etc.).
-    # @return [String] The HTTP method.
-    attr_reader :http_method
-
-    # The name of the instance method in the handler to call for the route.
-    # @return [Symbol, String] The method name.
-    attr_reader :method_name
-
-    # The URL path component that will trigger the route.
-    # @return [String] The path.
-    attr_reader :path
-
     # @param handler_class [Lita::Handler] The handler registering the route.
     def initialize(handler_class)
       @handler_class = handler_class
@@ -35,12 +30,13 @@ module Lita
       #     the handler to call for the route.
       #   @return [void]
       def define_http_method(http_method)
-        define_method(http_method) do |path, method_name|
-          route(http_method.to_s.upcase, path, method_name)
+        define_method(http_method) do |path, method_name, options = {}|
+          create_route(http_method.to_s.upcase, path, method_name, options)
         end
       end
     end
 
+    define_http_method :head
     define_http_method :get
     define_http_method :post
     define_http_method :put
@@ -53,12 +49,27 @@ module Lita
     private
 
     # Creates a new HTTP route.
-    def route(http_method, path, method_name)
-      @http_method = http_method
-      @path = path
-      @method_name = method_name
+    def create_route(http_method, path, method_name, options)
+      route = ExtendedRoute.new
+      route.path = path
+      route.add_match_with(options)
+      route.add_request_method(http_method)
+      route.add_request_method("HEAD") if http_method == "GET"
+
+      route.to do |env|
+        request = Rack::Request.new(env)
+        response = Rack::Response.new
+
+        if request.head?
+          response.status = 204
+        else
+          handler_class.new(env["lita.robot"]).public_send(method_name, request, response)
+        end
+
+        response.finish
+      end
 
-      handler_class.http_routes << self
+      handler_class.http_routes << route
     end
   end
 end