lita 2.7.2 → 3.0.0

data/Rakefile

@@ -1,8 +1,8 @@
 require "bundler/gem_tasks"
-require "cane/rake_task"
 require "rspec/core/rake_task"
+require "rubocop/rake_task"
 
-Cane::RakeTask.new
 RSpec::Core::RakeTask.new
+Rubocop::RakeTask.new
 
-task default: [:spec, :cane]
+task default: [:spec, :rubocop]

data/lib/lita.rb

@@ -3,12 +3,15 @@ require "logger"
 require "rbconfig"
 require "set"
 require "shellwords"
+require "thread"
 
+require "http_router"
+require "ice_nine"
 require "faraday"
 require "multi_json"
+require "puma"
 require "rack"
 require "redis-namespace"
-require "thin"
 
 # The main namespace for Lita. Provides a global registry of adapters and
 # handlers, as well as global configuration, logger, and Redis store.
@@ -85,26 +88,31 @@ module Lita
     # @return [void]
     def run(config_path = nil)
       Config.load_user_config(config_path)
+      Lita.config.finalize
+      self.locale = Lita.config.robot.locale
       Robot.new.run
     end
   end
 end
 
-require "lita/version"
-require "lita/config"
-require "lita/util"
-require "lita/logger"
-require "lita/user"
-require "lita/source"
-require "lita/authorization"
-require "lita/message"
-require "lita/response"
-require "lita/http_route"
-require "lita/rack_app"
-require "lita/robot"
-require "lita/adapter"
-require "lita/adapters/shell"
-require "lita/handler"
-require "lita/handlers/authorization"
-require "lita/handlers/help"
-require "lita/handlers/web"
+require_relative "lita/version"
+require_relative "lita/common"
+require_relative "lita/config"
+require_relative "lita/util"
+require_relative "lita/logger"
+require_relative "lita/user"
+require_relative "lita/source"
+require_relative "lita/authorization"
+require_relative "lita/message"
+require_relative "lita/response"
+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/handlers/authorization"
+require_relative "lita/handlers/help"
+require_relative "lita/handlers/info"
+require_relative "lita/handlers/room"

data/lib/lita/adapter.rb

@@ -10,6 +10,18 @@ module Lita
       # @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
+      end
+
       # Defines configuration keys that are requried for the adapter to boot.
       # @param keys [String, Symbol] The required keys.
       # @return [void]
@@ -19,6 +31,16 @@ module Lita
       end
 
       alias_method :require_configs, :require_config
+
+      # Returns the translation for a key, automatically namespaced to the adapter.
+      # @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.
+      def translate(key, hash = {})
+        I18n.translate("lita.adapters.#{namespace}.#{key}", hash)
+      end
+
+      alias_method :t, :translate
     end
 
     # @param robot [Lita::Robot] The currently running robot.
@@ -27,6 +49,20 @@ module Lita
       ensure_required_configs
     end
 
+    # @!method join
+    # Joins the room with the specified ID.
+    # @param room_id [String] The ID of the room.
+    # @return [void]
+    # @abstract This should be implemented by the adapter.
+    # @since 3.0.0
+
+    # @!method part
+    # Parts from the room with the specified ID.
+    # @param room_id [String] The ID of the room.
+    # @return [void]
+    # @abstract This should be implemented by the adapter.
+    # @since 3.0.0
+
     # @!method run
     # The main loop. Should connect to the chat service, listen for incoming
     # messages, create {Lita::Message} objects from them, and dispatch them to
@@ -52,12 +88,19 @@ module Lita
     # Performs any clean up necessary when disconnecting from the chat service.
     # @return [void]
     # @abstract This should be implemented by the adapter.
-    [:run, :send_messages, :set_topic, :shut_down].each do |method|
+    [:join, :part, :run, :send_messages, :set_topic, :shut_down].each do |method|
       define_method(method) do |*args|
-        Lita.logger.warn("This adapter has not implemented ##{method}.")
+        Lita.logger.warn(I18n.t("lita.adapter.method_not_implemented", method: method))
       end
     end
 
+    # @see .translate
+    def translate(*args)
+      self.class.translate(*args)
+    end
+
+    alias_method :t, :translate
+
     private
 
     # Logs a fatal message and aborts if a required config key is not set.
@@ -72,9 +115,7 @@ module Lita
       end
 
       unless missing_keys.empty?
-        Lita.logger.fatal(
-"The following keys are required on config.adapter: #{missing_keys.join(", ")}"
-        )
+        Lita.logger.fatal(I18n.t("lita.adapter.missing_configs", configs: missing_keys.join(", ")))
         abort
       end
     end

data/lib/lita/adapters/shell.rb

@@ -1,4 +1,5 @@
 module Lita
+  # A namespace to hold all subclasses of {Adapter}.
   module Adapters
     # An adapter that runs Lita in a UNIX shell.
     class Shell < Adapter
@@ -7,21 +8,11 @@ module Lita
       # @return [void]
       def run
         user = User.create(1, name: "Shell User")
-        source = Source.new(user: user)
-        puts 'Type "exit" or "quit" to end the session.'
+        @source = Source.new(user: user)
+        puts t("startup_message")
         robot.trigger(:connected)
 
-        loop do
-          print "#{robot.name} > "
-          input = $stdin.gets
-          if input.nil?
-            puts
-            break
-          end
-          input = input.chomp.strip
-          break if input == "exit" || input == "quit"
-          robot.receive(build_message(input, source))
-        end
+        run_loop
       end
 
       # Outputs outgoing messages to the shell.
@@ -51,6 +42,20 @@ module Lita
         message.command! if Lita.config.adapter.private_chat
         message
       end
+
+      def run_loop
+        loop do
+          print "#{robot.name} > "
+          input = $stdin.gets
+          if input.nil?
+            puts
+            break
+          end
+          input = input.chomp.strip
+          break if input == "exit" || input == "quit"
+          robot.receive(build_message(input, @source))
+        end
+      end
     end
 
     Lita.register_adapter(:shell, Shell)

data/lib/lita/authorization.rb

@@ -52,7 +52,7 @@ module Lita
       # 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.inject({}) do |list, group|
+        groups.reduce({}) do |list, group|
           list[group] = redis.smembers(group).map do |user_id|
             User.find_by_id(user_id)
           end

data/lib/lita/cli.rb

@@ -1,15 +1,29 @@
 require "thor"
 
-require "lita/daemon"
-require "lita/version"
+require_relative "common"
+require_relative "daemon"
+require_relative "version"
 
 module Lita
   # The command line interface for Lita.
   class CLI < Thor
     include Thor::Actions
 
+    # The root file path for the templates directory.
+    # @note This is a magic method required by Thor for file operations.
+    # @return [String] The path.
     def self.source_root
-      File.expand_path("../../../templates", __FILE__)
+      Lita.template_root
+    end
+
+    # Returns the full destination file path for the given file, using the supplied +default_path+
+    # as the base if run as root, otherwise falling back to the user's home directory.
+    # @param file_name [String] The name of the file.
+    # @param default_path [String] The base of the file path to use when run as root.
+    # @return [String] The full file path.
+    def self.file_path_for(file_name, default_path)
+      base_path = Process.euid == 0 ? default_path : ENV["HOME"]
+      File.join(base_path, file_name)
     end
 
     default_task :start
@@ -28,29 +42,25 @@ module Lita
     option :log_file,
       aliases: "-l",
       banner: "PATH",
-      default: Process.euid == 0 ?
-        "/var/log/lita.log" : File.expand_path("lita.log", ENV["HOME"]),
+      default: file_path_for("lita.log", "/var/log"),
       desc: "Path where the log file should be written when daemonized"
     option :pid_file,
       aliases: "-p",
       banner: "PATH",
-      default: Process.euid == 0 ?
-        "/var/run/lita.pid" : File.expand_path("lita.pid", ENV["HOME"]),
+      default: file_path_for("lita.pid", "/var/run"),
       desc: "Path where the PID file should be written when daemonized"
     option :kill,
       aliases: "-k",
       default: false,
       desc: "Kill existing Lita processes when starting the daemon",
       type: :boolean
+    # Starts Lita.
+    # @return [void]
     def start
       begin
         Bundler.require
       rescue Bundler::GemfileNotFound
-        no_gemfile_warning = <<-WARN.chomp
-The default command "start" must be run inside a Lita project. Try running \
-`lita new` to generate a new Lita project or `lita help` to see all commands.
-WARN
-        say no_gemfile_warning, :red
+        say I18n.t("lita.cli.no_gemfile_warning"), :red
         abort
       end
 
@@ -66,21 +76,32 @@ WARN
     end
 
     desc "new NAME", "Generates a new Lita project (default name: lita)"
+    # Generates a new Lita project.
+    # @param name [String] The directory name for the new project.
+    # @return [void]
     def new(name = "lita")
       directory "robot", name
     end
 
     desc "adapter NAME", "Generates a new Lita adapter"
+    # Generates a new Lita adapter.
+    # @param name [String] The name for the new adapter.
+    # @return [void]
     def adapter(name)
       generate_templates(generate_config(name, "adapter"))
     end
 
     desc "handler NAME", "Generates a new Lita handler"
+    # Generates a new Lita handler.
+    # @param name [String] The name for the new handler.
+    # @return [void]
     def handler(name)
       generate_templates(generate_config(name, "handler"))
     end
 
     desc "version", "Outputs the current version of Lita"
+    # Outputs the current version of Lita.
+    # @return [void]
     def version
       puts VERSION
     end
@@ -139,11 +160,8 @@ WARN
         "#{target}/spec/lita/#{namespace}/#{name}_spec.rb",
         config
       )
-      template(
-        "plugin/spec/spec_helper.tt",
-        "#{target}/spec/spec_helper.rb",
-        config
-      )
+      template("plugin/spec/spec_helper.tt", "#{target}/spec/spec_helper.rb", config)
+      template("plugin/locales/en.yml.tt", "#{target}/locales/en.yml", config)
       copy_file("plugin/Gemfile", "#{target}/Gemfile")
       template("plugin/gemspec.tt", "#{target}/#{gem_name}.gemspec", config)
       copy_file("plugin/gitignore", "#{target}/.gitignore")
@@ -161,13 +179,9 @@ WARN
     end
 
     def optional_content
-      coveralls_question = <<-Q.chomp
-Do you want to generate code coverage information with SimpleCov \
-and Coveralls.io?
-Q
       {
-        travis: yes?("Do you want to test your plugin on Travis CI?"),
-        coveralls: yes?(coveralls_question)
+        travis: yes?(I18n.t("lita.cli.travis_question")),
+        coveralls: yes?(I18n.t("lita.cli.coveralls_question"))
       }
     end
   end

data/lib/lita/common.rb

@@ -0,0 +1,35 @@
+require "i18n"
+require "i18n/backend/fallbacks"
+
+module Lita
+  class << self
+    # Adds one or more paths to the I18n load path and reloads I18n.
+    # @param paths [String, Array<String>] The path(s) to add.
+    # @return [void]
+    # @since 3.0.0
+    def load_locales(paths)
+      I18n.load_path.concat(Array(paths))
+      I18n.reload!
+    end
+
+    # Sets I18n.locale, normalizing the provided locale name.
+    # @param new_locale [Symbol, String] The code of the locale to use.
+    # @return [void]
+    # @since 3.0.0
+    def locale=(new_locale)
+      I18n.locale = new_locale.to_s.tr("_", "-")
+    end
+
+    # The absolute path to Lita's templates directory.
+    # @return [String] The path.
+    # @since 3.0.0
+    def template_root
+      File.expand_path("../../../templates", __FILE__)
+    end
+  end
+end
+
+I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
+Lita.load_locales(Dir[File.join(Lita.template_root, "locales", "*.yml")])
+I18n.enforce_available_locales = false
+Lita.locale = ENV["LANG"] unless ENV["LANG"].nil?

data/lib/lita/config.rb

@@ -6,15 +6,9 @@ module Lita
       # @return [Lita::Config] The default configuration.
       def default_config
         new.tap do |c|
-          c.robot = new
-          c.robot.name = "Lita"
-          c.robot.adapter = :shell
-          c.robot.log_level = :info
-          c.robot.admins = nil
+          load_robot_configs(c)
           c.redis = new
-          c.http = new
-          c.http.port = 8080
-          c.http.debug = false
+          load_http_configs(c)
           c.adapter = new
           c.handlers = new
           load_handler_configs(c)
@@ -30,11 +24,11 @@ module Lita
         begin
           load(config_path)
         rescue Exception => e
-          Lita.logger.fatal <<-MSG
-Lita configuration file could not be processed. The exception was:
-#{e.message}
-#{e.backtrace.join("\n")}
-MSG
+          Lita.logger.fatal I18n.t(
+            "lita.config.exception",
+            message: e.message,
+            backtrace: e.backtrace.join("\n")
+          )
           abort
         end if File.exist?(config_path)
       end
@@ -50,6 +44,25 @@ MSG
           handler.default_config(handler_config)
         end
       end
+
+      # Adds and populates a Config object for the built-in web server.
+      def load_http_configs(config)
+        config.http = new
+        config.http.host = "0.0.0.0"
+        config.http.port = 8080
+        config.http.min_threads = 0
+        config.http.max_threads = 16
+      end
+
+      # Adds and populates a Config object for the Robot.
+      def load_robot_configs(config)
+        config.robot = new
+        config.robot.name = "Lita"
+        config.robot.adapter = :shell
+        config.robot.locale = I18n.locale
+        config.robot.log_level = :info
+        config.robot.admins = nil
+      end
     end
 
     # Sets a config key.
@@ -67,6 +80,13 @@ MSG
       super(key.to_sym)
     end
 
+    # Deeply freezes the object to prevent any further mutation.
+    # @return [void]
+    # @since 3.0.0
+    def finalize
+      IceNine.deep_freeze!(self)
+    end
+
     # Allows keys to be read and written with struct-like syntax.
     def method_missing(name, *args)
       name_string = name.to_s