rita 0.1.0 → 5.0.0.alpha.1

data/lib/lita.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+require "i18n"
+require "i18n/backend/fallbacks"
+require "redis-namespace"
+
+require_relative "lita/configuration_builder"
+require_relative "lita/configuration_validator"
+require_relative "lita/errors"
+require_relative "lita/logger"
+require_relative "lita/registry"
+require_relative "lita/robot"
+
+# The main namespace for Lita. Provides a global registry of adapters and
+# handlers, as well as global configuration, logger, and Redis store.
+module Lita
+  class << self
+    include Registry::Mixins
+
+    # 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_reader :test_mode
+    alias test_mode? test_mode
+
+    # Sets both I18n.default_locale and I18n.locale to the provided locale, if any.
+    # @api private
+    # @since 5.0.0
+    def configure_i18n(new_locale)
+      unless new_locale.nil?
+        self.default_locale = new_locale
+        self.locale = new_locale
+      end
+    end
+
+    # Lita's global +Logger+.
+    #
+    # The log level is initially set according to the environment variable +LITA_LOG+, defaulting to
+    # +info+ if the variable is not set. Once the user configuration is loaded, the log level will
+    # be reset to whatever is specified in the configuration file.
+    # @return [::Logger] A +Logger+ object.
+    def logger
+      @logger ||= Logger.get_logger(
+        ENV["LITA_LOG"],
+        io: test_mode? ? StringIO.new : $stderr,
+      )
+    end
+
+    # 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.
+    #
+    # Note that setting this only affects the current thread. Since handler
+    # methods are dispatched in new threads, changing the locale globally will
+    # require calling this method at the start of every handler method.
+    # Alternatively, use {Lita#default_locale=} which will affect all threads.
+    # @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
+
+    # Sets +I18n.default_locale+, normalizing the provided locale name.
+    #
+    # This is preferred over {Lita#locale=} as it affects all threads.
+    # @param new_locale [Symbol, String] The code of the locale to use.
+    # @return [void]
+    # @since 4.8.0
+    def default_locale=(new_locale)
+      I18n.default_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", __dir__)
+    end
+
+    # Loads user configuration.
+    # @param config_path [String] The path to the user configuration file.
+    # @return [void]
+    def load_config(config_path = nil)
+      hooks[:before_run].each { |hook| hook.call(config_path: config_path) }
+      ConfigurationBuilder.load_user_config(config_path)
+      ConfigurationBuilder.freeze_config(config)
+      recreate_logger # Pick up value of `config.robot.log_level` and `config.robot.log_formatter`.
+      ConfigurationValidator.new(self).call
+      hooks[:config_finalized].each { |hook| hook.call(config_path: config_path) }
+
+      if config.robot.default_locale || config.robot.locale
+        logger.warn I18n.t("lita.config.locale_deprecated")
+        self.default_locale = config.robot.default_locale if config.robot.default_locale
+        self.locale = config.robot.locale if config.robot.locale
+      end
+    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)
+      load_config(config_path)
+      Robot.new.run
+    end
+
+    # Turns test mode on or off.
+    # @param mode [Boolean] Whether or not test mode should be enabled.
+    # @return [void]
+    # @see #test_mode
+    def test_mode=(mode)
+      @test_mode = mode
+      # Reset the logger because its IO stream is determined by test mode.
+      recreate_logger
+    end
+
+    # A special mode to ensure that tests written for Lita 3 plugins continue to work. Has no effect
+    # in Lita 5+.
+    # @return [Boolean] Whether or not version 3 compatibility mode is active.
+    # @since 4.0.0
+    # @deprecated Will be removed in Lita 6.0.
+    def version_3_compatibility_mode(_value = nil)
+      warn I18n.t("lita.rspec.lita_3_compatibility_mode")
+      false
+    end
+    alias version_3_compatibility_mode? version_3_compatibility_mode
+    alias version_3_compatibility_mode= version_3_compatibility_mode
+
+    private
+
+    # Recreate the logger, specifying the configured log level and output stream. Should be called
+    # manually after user configuration has been loaded and whenever test mode is changed. This is
+    # necessary because {#logger} does not access the config so as not to accidentally build the
+    # {DefaultConfiguration} before all plugins have been loaded and registered.
+    def recreate_logger
+      @logger = Logger.get_logger(
+        config.robot.log_level,
+        formatter: config.robot.log_formatter,
+        io: test_mode? ? StringIO.new : $stderr,
+      )
+    end
+  end
+end
+
+I18n::Backend::Simple.include(I18n::Backend::Fallbacks)
+I18n.enforce_available_locales = false
+Lita.load_locales(Dir[File.join(Lita.template_root, "locales", "*.yml")])
+Lita.configure_i18n(ENV["LC_ALL"] || ENV["LC_MESSAGES"] || ENV["LANG"])
+
+require_relative "lita/adapters/shell"
+require_relative "lita/adapters/test"
+
+require_relative "lita/handlers/authorization"
+require_relative "lita/handlers/help"
+require_relative "lita/handlers/info"
+require_relative "lita/handlers/room"
+require_relative "lita/handlers/users"

data/rita.gemspec

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lita/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rita"
+  spec.version       = Lita::VERSION
+  spec.authors       = ["Jimmy Cuadra"]
+  spec.email         = ["jimmy@jimmycuadra.com"]
+  spec.description   = "ChatOps for Ruby."
+  spec.summary       = "ChatOps framework for Ruby. Rita is a robot companion for your chat room."
+  spec.homepage      = "https://github.com/ritaio/rita"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/ritaio/rita/issues",
+    "changelog_uri"     => "https://github.com/ritaio/rita/releases",
+    # "documentation_uri" => "https://docs.lita.io/",
+    # "homepage_uri"      => "https://www.lita.io/",
+    # "mailing_list_uri"  => "https://groups.google.com/group/litaio",
+    "source_code_uri"   => "https://github.com/ritaio/rita",
+  }
+
+  spec.add_runtime_dependency "bundler", "~> 2.2.3"
+  spec.add_runtime_dependency "faraday", "~> 1.6.0"
+  spec.add_runtime_dependency "http_router", "~> 0.11.2"
+  spec.add_runtime_dependency "i18n", "~> 1.8.10"
+  spec.add_runtime_dependency "ice_nine", "~> 0.11.2"
+  spec.add_runtime_dependency "puma", "~> 5.4.0"
+  spec.add_runtime_dependency "rack", "~> 2.2.3"
+  spec.add_runtime_dependency "rb-readline", "~> 0.5.5"
+  spec.add_runtime_dependency "redis-namespace", "~> 1.8.1"
+  spec.add_runtime_dependency "thor", "~> 1.1.0"
+
+  spec.add_development_dependency "pry-byebug", "~> 3.9.0"
+  spec.add_development_dependency "rack-test", "~> 1.1.0"
+  spec.add_development_dependency "rake", "~> 13.0.3"
+  spec.add_development_dependency "rspec", "~> 3.10.0"
+  spec.add_development_dependency "rubocop", "~> 1.17.0"
+  spec.add_development_dependency "simplecov", "~> 0.21.2"
+end

data/spec/lita/adapter_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Adapter, lita: true do
+  let(:robot) { Lita::Robot.new(registry) }
+
+  let(:required_methods) { described_class::REQUIRED_METHODS }
+
+  subject { described_class.new(robot) }
+
+  it "stores a Robot" do
+    expect(subject.robot).to eql(robot)
+  end
+
+  it "logs a warning if a required method has not been implemented" do
+    expect(robot.logger).to receive(:warn).exactly(required_methods.size).times
+    required_methods.each do |method|
+      subject.public_send(method)
+    end
+  end
+
+  describe "#config" do
+    let(:adapter) do
+      Class.new(described_class) do
+        namespace "test"
+
+        config :foo, default: :bar
+      end
+    end
+
+    let(:robot) { Lita::Robot.new(registry) }
+
+    before { registry.register_adapter(:test, adapter) }
+
+    subject { adapter.new(robot) }
+
+    it "provides access to the adapter's configuration object" do
+      expect(subject.config.foo).to eq(:bar)
+    end
+  end
+
+  describe "#log" do
+    it "returns the robot's logger" do
+      expect(subject.log).to eq(robot.logger)
+    end
+  end
+
+  describe "#mention_format" do
+    it "formats the provided name for mentioning the user" do
+      expect(subject.mention_format("carl")).to eq("carl:")
+    end
+  end
+end

data/spec/lita/adapters/shell_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Adapters::Shell, lita: true do
+  let(:robot) do
+    instance_double(
+      "Lita::Robot",
+      name: "Lita",
+      mention_name: "LitaBot",
+      alias: "/",
+      config: registry.config
+    )
+  end
+
+  subject { described_class.new(robot) }
+
+  describe "#roster" do
+    let(:room) { instance_double("Lita::Room") }
+
+    it "returns the shell user" do
+      expect(subject.roster(room).first.name).to eq("Shell User")
+    end
+  end
+
+  describe "#run" do
+    let(:user) { Lita::User.create(1, name: "Shell User") }
+
+    before do
+      registry.register_adapter(:shell, described_class)
+      allow(subject).to receive(:puts)
+      allow(Readline).to receive(:readline).and_return("foo", "exit")
+      allow(robot).to receive(:trigger)
+      allow(robot).to receive(:receive)
+      allow(Lita::User).to receive(:create).and_return(user)
+    end
+
+    it "passes input to the Robot and breaks on an exit message" do
+      expect(Readline).to receive(:readline).with("#{robot.name} > ", true).twice
+      expect(robot).to receive(:receive).with(an_instance_of(Lita::Message))
+      subject.run
+    end
+
+    it "marks messages as commands if config.adapters.shell.private_chat is true" do
+      registry.config.adapters.shell.private_chat = true
+      expect_any_instance_of(Lita::Message).to receive(:command!)
+      subject.run
+    end
+
+    it "sets the room to 'shell' if config.adapters.shell.private_chat is false" do
+      registry.config.adapters.shell.private_chat = false
+      expect(Lita::Source).to receive(:new).with(user: user, room: "shell")
+      subject.run
+    end
+
+    it "sets the room to nil if config.adapters.shell.private_chat is true" do
+      registry.config.adapters.shell.private_chat = true
+      expect(Lita::Source).to receive(:new).with(user: user, room: nil)
+      subject.run
+    end
+
+    it "triggers a connected event" do
+      expect(robot).to receive(:trigger).with(:connected)
+      subject.run
+    end
+
+    it "exits cleanly when EOF is received" do
+      allow(Readline).to receive(:readline).and_return(nil)
+      subject.run
+    end
+
+    it "removes empty input from readline history" do
+      allow(Readline).to receive(:readline).and_return("", "exit")
+      expect(Readline::HISTORY).to receive(:pop)
+      subject.run
+    end
+  end
+
+  describe "#send_message" do
+    it "prints its input" do
+      expect(subject).to receive(:puts) do |messages|
+        expect(messages.first).to include("bar")
+      end
+      subject.send_messages(instance_double("Lita::Source"), "bar")
+    end
+
+    it "doesn't output empty messages" do
+      expect(subject).to receive(:puts).with([])
+      subject.send_messages(instance_double("Lita::Source"), "")
+    end
+  end
+
+  describe "#shut_down" do
+    it "outputs a blank line" do
+      expect(subject).to receive(:puts)
+      subject.shut_down
+    end
+  end
+end

data/spec/lita/authorization_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Lita::Authorization, lita: true do
+  let(:requesting_user) { instance_double("Lita::User", id: "1") }
+  let(:robot) { Lita::Robot.new(registry) }
+  let(:user) { instance_double("Lita::User", id: "2") }
+
+  subject { described_class.new(robot) }
+
+  before do
+    registry.config.robot.admins = ["1"]
+  end
+
+  describe "#add_user_to_group" do
+    it "adds users to an auth group" do
+      subject.add_user_to_group(requesting_user, user, "employees")
+      expect(subject.user_in_group?(user, "employees")).to be true
+    end
+
+    it "can only be called by admins" do
+      registry.config.robot.admins = nil
+      result = subject.add_user_to_group(
+        requesting_user,
+        user,
+        "employees"
+      )
+      expect(result).to eq(:unauthorized)
+      expect(subject.user_in_group?(user, "employees")).to be false
+    end
+
+    it "normalizes the group name" do
+      subject.add_user_to_group(requesting_user, user, "eMPLoYeeS")
+      expect(subject.user_in_group?(user, "  EmplOyEEs  ")).to be true
+    end
+  end
+
+  describe "#remove_user_from_group" do
+    it "removes users from an auth group" do
+      subject.add_user_to_group(requesting_user, user, "employees")
+      subject.remove_user_from_group(requesting_user, user, "employees")
+      expect(subject.user_in_group?(user, "employees")).to be false
+    end
+
+    it "can only be called by admins" do
+      subject.add_user_to_group(requesting_user, user, "employees")
+      registry.config.robot.admins = nil
+      result = subject.remove_user_from_group(
+        requesting_user,
+        user,
+        "employees"
+      )
+      expect(result).to eq(:unauthorized)
+      expect(subject.user_in_group?(user, "employees")).to be true
+    end
+
+    it "normalizes the group name" do
+      subject.add_user_to_group(requesting_user, user, "eMPLoYeeS")
+      subject.remove_user_from_group(requesting_user, user, "EmployeeS")
+      expect(subject.user_in_group?(user, "  EmplOyEEs  ")).to be false
+    end
+  end
+
+  describe "#user_in_group?" do
+    it "returns false if the user is in the group" do
+      expect(subject.user_in_group?(user, "employees")).to be false
+    end
+
+    it "delegates to .user_is_admin? if the group is admins" do
+      expect(subject).to receive(:user_is_admin?)
+      subject.user_in_group?(user, "admins")
+    end
+  end
+
+  describe "#user_is_admin?" do
+    it "returns true if the user's ID is in the config" do
+      expect(subject.user_is_admin?(requesting_user)).to be true
+    end
+
+    it "returns false if the user's ID is not in the config" do
+      registry.config.robot.admins = nil
+      expect(subject.user_is_admin?(user)).to be false
+    end
+  end
+
+  describe "#groups" do
+    before do
+      %i[foo bar baz].each do |group|
+        subject.add_user_to_group(requesting_user, user, group)
+      end
+    end
+
+    it "returns a list of all authorization groups" do
+      expect(subject.groups).to match_array(%i[foo bar baz])
+    end
+  end
+
+  describe "#groups_with_users" do
+    before do
+      %i[foo bar baz].each do |group|
+        subject.add_user_to_group(requesting_user, user, group)
+        subject.add_user_to_group(
+          requesting_user,
+          requesting_user,
+          group
+        )
+      end
+      allow(Lita::User).to receive(:find_by_id).with("1").and_return(requesting_user)
+      allow(Lita::User).to receive(:find_by_id).with("2").and_return(user)
+    end
+
+    it "returns a hash of all authorization groups and their members" do
+      groups = %i[foo bar baz]
+      groups_with_users = subject.groups_with_users
+      expect(groups_with_users.keys).to match_array(groups)
+      groups.each do |group|
+        expect(groups_with_users[group]).to match_array([user, requesting_user])
+      end
+    end
+  end
+end