lita-default-handlers 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f1b1a5bfb8fdadbbdebe5527f1ee37c323eb3e3
+  data.tar.gz: 321c892420efece5552b903c567430b0d2f81c4b
+SHA512:
+  metadata.gz: e6aca24f50bb044d5ec3460cac57ab7f14d244b7c6b229759cff47232715df1c77c881fcb43bc6cf8003d19acf293e9cc2a922bf14e3a5423f08cb74e2a0d790
+  data.tar.gz: b49b1e936bd0e781b4d508dc2082457636ad7d28bf12c3d09009e71d126e3e1293718790aca59e1d7ec8a3ae421acf8cb9cace3a8ff0064317d3816da9dcd242

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "lita", path: "../lita"

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2015 Jimmy Cuadra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+# lita-default-handlers
+
+[![Gem Version](https://badge.fury.io/rb/lita-default-handlers.png)](http://badge.fury.io/rb/lita-default-handlers)
+
+Provides the default set of handlers that ship with Lita itself. The handlers are:
+
+* Authorization, for managing authorization groups
+* Help, for listing help strings for other handler routes
+* Info, for basic information about the running robot
+* Room, for making the robot join and part from rooms
+* Users, for finding a user's Lita user ID
+
+## Installation
+
+In Lita 5, this gem is a hard dependency of the lita gem itself, so it's not necessary to do anything to install it.
+
+In Lita 6:
+
+This gem must be included in the Lita project's Gemfile in order to be included, like any other plugin.
+New Lita projects created by `lita new` using Lita 5 or later will include the entry for it in the Gemfile automatically.
+To remove the default handlers, simply remove that line from the Gemfile.
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita-default-handlers.rb

@@ -0,0 +1,11 @@
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/handlers/authorization"
+require "lita/handlers/help"
+require "lita/handlers/info"
+require "lita/handlers/room"
+require "lita/handlers/users"

data/lib/lita/handlers/authorization.rb

@@ -0,0 +1,127 @@
+module Lita
+  # A namespace to hold all subclasses of {Handler}.
+  module Handlers
+    # Provides a chat interface for administering authorization groups.
+    class Authorization
+      extend Handler::ChatRouter
+
+      route(
+        /^auth\s+add/,
+        :add,
+        command: true,
+        restrict_to: :admins,
+        help: { t("help.add_key") => t("help.add_value") }
+      )
+      route(
+        /^auth\s+remove/,
+        :remove,
+        command: true,
+        restrict_to: :admins,
+        help: { t("help.remove_key") => t("help.remove_value") }
+      )
+      route(/^auth\s+list/, :list, command: true, restrict_to: :admins, help: {
+        t("help.list_key") => t("help.list_value")
+      })
+
+      # Adds a user to an authorization group.
+      # @param response [Response] The response object.
+      # @return [void]
+      def add(response)
+        toggle_membership(response, :add_user_to_group, "user_added", "user_already_in")
+      end
+
+      # Removes a user from an authorization group.
+      # @param response [Response] The response object.
+      # @return [void]
+      def remove(response)
+        toggle_membership(response, :remove_user_from_group, "user_removed", "user_not_in")
+      end
+
+      # Lists all authorization groups (or only the specified group) and the
+      # names of their members.
+      # @param response [Response] The response object.
+      # @return [void]
+      def list(response)
+        requested_group = response.args[1]
+        output = get_groups_list(response.args[1])
+        if output.empty?
+          response.reply(empty_state_for_list(requested_group))
+        else
+          response.reply(output.join("\n"))
+        end
+      end
+
+      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 = robot.auth.groups_with_users
+        if requested_group
+          requested_group = requested_group.downcase.strip.to_sym
+          groups_with_users.select! { |group, _| group == requested_group }
+        end
+        groups_with_users.map do |group, users|
+          user_names = users.map(&:name).join(", ")
+          "#{group}: #{user_names}"
+        end
+      end
+
+      def toggle_membership(response, method_name, success_key, failure_key)
+        return unless valid_message?(response)
+
+        if robot.auth.public_send(method_name, response.user, @user, @group)
+          response.reply t(success_key, user: @user.name, group: @group)
+        else
+          response.reply t(failure_key, user: @user.name, group: @group)
+        end
+      end
+
+      def valid_group?(response, identifier)
+        unless identifier && @group
+          response.reply "#{t('format')}: #{robot.name} auth add USER GROUP"
+          return
+        end
+
+        if @group.downcase.strip == "admins"
+          response.reply t("admin_management")
+          return
+        end
+
+        true
+      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)
+  end
+end

data/lib/lita/handlers/help.rb

@@ -0,0 +1,71 @@
+module Lita
+  # A namespace to hold all subclasses of {Handler}.
+  module Handlers
+    # Provides online help about Lita commands for users.
+    class Help
+      extend Handler::ChatRouter
+
+      route(/^help\s*(.+)?/, :help, command: true, help: {
+        "help" => t("help.help_value"),
+        t("help.help_command_key") => t("help.help_command_value")
+      })
+
+      # Outputs help information about Lita commands.
+      # @param response [Response] The response object.
+      # @return [void]
+      def help(response)
+        output = build_help(response)
+        output = filter_help(output, response)
+        response.reply_privately output.join("\n")
+      end
+
+      private
+
+      # Checks if the user is authorized to at least one of the given groups.
+      def authorized?(user, required_groups)
+        required_groups.nil? || required_groups.any? do |group|
+          robot.auth.user_in_group?(user, group)
+        end
+      end
+
+      # Creates an array of help info for all registered routes.
+      def build_help(response)
+        robot.handlers.map do |handler|
+          next unless handler.respond_to?(:routes)
+
+          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.flatten.compact
+      end
+
+      # Filters the help output by an optional command.
+      def filter_help(output, response)
+        filter = response.matches[0][0]
+
+        if filter
+          output.select { |line| /(?:@?#{name}[:,]?)?#{filter}/i === line }
+        else
+          output
+        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
+        robot.config.robot.mention_name || robot.config.robot.name
+      end
+    end
+
+    Lita.register_handler(Help)
+  end
+end

data/lib/lita/handlers/info.rb

@@ -0,0 +1,62 @@
+module Lita
+  # A namespace to hold all subclasses of {Handler}.
+  module Handlers
+    # Provides information about the currently running robot.
+    class Info
+      extend Handler::ChatRouter
+      extend Handler::HTTPRouter
+
+      route(/^info$/i, :chat, command: true, help: {
+        "info" => t("help.info_value")
+      })
+
+      http.get "/lita/info", :web
+
+      # Replies with the current version of Lita, the current version of Redis,
+      # and Redis memory usage.
+      # @param response [Response] The response object.
+      # @return [void]
+      # @since 3.0.0
+      def chat(response)
+        response.reply(
+          %(Lita #{Lita::VERSION} - https://www.lita.io/),
+          %(Redis #{redis_version} - Memory used: #{redis_memory_usage})
+        )
+      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(
+          adapter: robot.config.robot.adapter,
+          lita_version: Lita::VERSION,
+          redis_memory_usage: redis_memory_usage,
+          redis_version: redis_version,
+          robot_mention_name: robot.mention_name,
+          robot_name: robot.name
+        )
+        response.write(json)
+      end
+
+      # A hash of information about Redis.
+      def redis_info
+        @redis_info ||= redis.info
+      end
+
+      # The current version of Redis.
+      def redis_version
+        redis_info["redis_version"]
+      end
+
+      # The amount of memory Redis is using.
+      def redis_memory_usage
+        redis_info["used_memory_human"]
+      end
+    end
+
+    Lita.register_handler(Info)
+  end
+end

data/lib/lita/handlers/room.rb

@@ -0,0 +1,34 @@
+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
+      extend Handler::ChatRouter
+
+      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 [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 [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/handlers/users.rb

@@ -0,0 +1,35 @@
+module Lita
+  module Handlers
+    # Provides information on Lita users.
+    # @since 4.1.0
+    class Users
+      extend Handler::ChatRouter
+
+      route(/^users\s+find\s+(.+)/i, :find, command: true, help: {
+        t("help.find_key") => t("help.find_value")
+      })
+
+      # Outputs the name, ID, and mention name of a user matching the search query.
+      # @param response [Response] The response object.
+      # @return [void]
+      def find(response)
+        user = User.fuzzy_find(response.args[1])
+
+        if user
+          response.reply(formatted_user(user))
+        else
+          response.reply(t("find_empty_state"))
+        end
+      end
+
+      private
+
+      # Extract and label the relevant user information.
+      def formatted_user(user)
+        "#{user.name} (ID: #{user.id}, Mention name: #{user.mention_name})"
+      end
+    end
+
+    Lita.register_handler(Users)
+  end
+end

data/lita-default-handlers.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-default-handlers"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Jimmy Cuadra"]
+  spec.email         = ["jimmy@jimmycuadra.com"]
+  spec.description   = "A set of handlers included by default in Lita."
+  spec.summary       = "A set of handlers included by default in Lita."
+  spec.homepage      = "https://github.com/litaio/lita-default-handlers"
+  spec.license       = "MIT"
+  spec.metadata      = { "lita_plugin_type" => "handler" }
+
+  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.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

data/locales/en.yml

@@ -0,0 +1,41 @@
+en:
+  lita:
+    handlers:
+      authorization:
+        help:
+          add_key: auth add USER GROUP
+          add_value: Add USER to authorization group GROUP. Requires admin privileges.
+          remove_key: auth remove USER GROUP
+          remove_value: Remove USER from authorization group GROUP. Requires admin privileges.
+          list_key: "auth list [GROUP]"
+          list_value: >-
+            List authorization groups and the users in them. If GROUP is supplied,
+            only lists that group.
+        user_added: "%{user} was added to %{group}."
+        user_already_in: "%{user} was already in %{group}."
+        user_removed: "%{user} was removed from %{group}."
+        user_not_in: "%{user} was not in %{group}."
+        empty_state: There are no authorization groups yet.
+        empty_state_group: "There is no authorization group named %{group}."
+        format: "Format"
+        admin_management: Administrators can only be managed via Lita config.
+        no_user_found: 'No user was found with the identifier "%{identifier}".'
+      help:
+        help:
+          help_value: Lists help information for terms and command the robot will respond to.
+          help_command_key: help COMMAND
+          help_command_value: Lists help information for terms or commands that begin with COMMAND.
+      info:
+        help:
+          info_value: Replies with the current version of Lita.
+      room:
+        help:
+          join_key: join ROOM_ID
+          join_value: Makes the robot join the room with room ID ROOM_ID.
+          part_key: part ROOM_ID
+          part_value: Makes the robot part from the room with room ID ROOM_ID.
+      users:
+        find_empty_state: No matching users found.
+        help:
+          find_key: users find SEARCH_TERM
+          find_value: Find a Lita user by ID, name, or mention name.

data/spec/lita/handlers/authorization_spec.rb

@@ -0,0 +1,109 @@
+require "spec_helper"
+
+describe Lita::Handlers::Authorization, lita_handler: true do
+  before do
+    allow(robot.auth).to receive(:user_is_admin?).with(user).and_return(true)
+  end
+
+  let(:target_user) { instance_double("Lita::User", id: "1", name: "Carl") }
+
+  it { is_expected.to route_command("auth add foo bar").to(:add) }
+  it { is_expected.to route_command("auth add foo@bar.com baz").to(:add) }
+  it { is_expected.to route_command("auth remove foo bar").to(:remove) }
+  it { is_expected.to route_command("auth remove foo@bar.com baz").to(:remove) }
+  it { is_expected.to route_command("auth list").to(:list) }
+  it { is_expected.to route_command("auth list foo").to(:list) }
+
+  describe "#add" do
+    it "replies with the proper format if the require commands are missing" do
+      send_command("auth add foo")
+      expect(replies.last).to match(/^Format:/)
+    end
+
+    it "replies with a warning if target user is not known" do
+      send_command("auth add foo bar")
+      expect(replies.last).to match(/No user was found/)
+    end
+
+    it "replies with success if a valid user and group were supplied" do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+      expect(replies.last).to eq("#{target_user.name} was added to bar.")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+      send_command("auth add foo bar")
+      expect(replies.last).to eq("#{target_user.name} was already in bar.")
+    end
+
+    it 'replies with a warning if the group was "admins"' do
+      send_command("auth add foo admins")
+      expect(replies.last).to match(/Administrators can only be managed/)
+    end
+  end
+
+  describe "#remove" do
+    before do
+      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
+      send_command("auth add foo bar")
+    end
+
+    it "replies with success if a valid user and group were supplied" do
+      send_command("auth remove foo bar")
+      expect(replies.last).to eq("#{target_user.name} was removed from bar.")
+    end
+
+    it "replies with a warning if the user was already in the group" do
+      send_command("auth remove foo bar")
+      send_command("auth remove foo bar")
+      expect(replies.last).to eq("#{target_user.name} was not in bar.")
+    end
+
+    it 'replies with a warning if the group was "admins"' do
+      send_command("auth add foo admins")
+      expect(replies.last).to match(/Administrators can only be managed/)
+    end
+  end
+
+  describe "#list" do
+    context "when there are populated groups" do
+      let(:groups) { %i(foo bar) }
+      let(:user1) { Lita::User.create(3, name: "Bongo") }
+      let(:user2) { Lita::User.create(4, name: "Carl") }
+
+      before do
+        groups.each do |group|
+          subject.robot.auth.add_user_to_group(user, user1, group)
+          subject.robot.auth.add_user_to_group(user, user2, group)
+        end
+      end
+
+      it "lists all authorization groups and their members" do
+        send_command("auth list")
+        groups.each do |group|
+          expect(replies.last).to include(
+            "#{group}: #{user1.name}, #{user2.name}"
+          )
+        end
+      end
+
+      it "lists only the requested group" do
+        send_command("auth list foo")
+        expect(replies.last).to include("foo")
+        expect(replies.last).not_to include("bar")
+      end
+    end
+
+    it "replies that there are no groups" do
+      send_command("auth list")
+      expect(replies.last).to include("no authorization groups yet")
+    end
+
+    it "replies that the specified group doesn't exist" do
+      send_command("auth list nothing")
+      expect(replies.last).to include("no authorization group named nothing")
+    end
+  end
+end

data/spec/lita/handlers/help_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Lita::Handlers::Help, lita_handler: true do
+  it { is_expected.to route_command("help").to(:help) }
+  it { is_expected.to route_command("help foo").to(:help) }
+
+  describe "#help" do
+    let(:secret_handler_class) do
+      Class.new(Lita::Handler) do
+        route(/secret/, :secret, restrict_to: :the_nobodies, help: {
+          "secret" => "no one should ever see this help message"
+        })
+      end
+    end
+
+    it "sends help information for all commands" do
+      send_command("help")
+      expect(replies.last).to match(
+        /#{robot.mention_name}: help.+#{robot.mention_name}: help COMMAND/m
+      )
+    end
+
+    it "sends help information for commands starting with COMMAND" do
+      send_command("help help COMMAND")
+      expect(replies.last).to match(/help COMMAND - Lists/)
+      expect(replies.last).not_to match(/help - Lists/)
+    end
+
+    it "doesn't crash if a handler doesn't have routes" do
+      event_handler = Class.new do
+        extend Lita::Handler::EventRouter
+      end
+
+      registry.register_handler(event_handler)
+
+      expect { send_command("help") }.not_to raise_error
+    end
+
+    describe "restricted routes" do
+      let(:authorized_user) do
+        user = Lita::User.create(2, name: "Authorized User")
+        Lita::Authorization.new(robot).add_user_to_group!(user, :the_nobodies)
+        user
+      end
+
+      before { registry.register_handler(secret_handler_class) }
+
+      it "doesn't show help for commands the user doesn't have access to" do
+        send_command("help")
+        expect(replies.last).not_to include("secret")
+      end
+
+      it "shows help for restricted routes if the user has access" do
+        send_command("help", as: authorized_user)
+        expect(replies.last).to include("secret")
+      end
+    end
+  end
+end

data/spec/lita/handlers/info_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Lita::Handlers::Info, lita_handler: true do
+  it { is_expected.to route_command("info").to(:chat) }
+  it { is_expected.to route_http(:get, "/lita/info").to(:web) }
+
+  let(:request) { double("Rack::Request") }
+  let(:response) { Rack::Response.new }
+
+  describe "#chat" do
+    it "responds with the current version of Lita" do
+      send_command("info")
+      expect(replies.first).to include(Lita::VERSION)
+    end
+
+    it "responds with a link to the website" do
+      send_command("info")
+      expect(replies.first).to include("lita.io")
+    end
+
+    it "responds with the Redis version and memory usage" do
+      send_command("info")
+      expect(replies.last).to match(/Redis [\d\.]+ - Memory used: [\d\.]+[BKMG]/)
+    end
+  end
+
+  describe "#web" do
+    let(:json) { MultiJson.load(response.body.join) }
+
+    it "returns JSON" do
+      subject.web(request, response)
+      expect(response.headers["Content-Type"]).to eq("application/json")
+    end
+
+    it "includes the current version of Lita" do
+      subject.web(request, response)
+      expect(json).to include("lita_version" => Lita::VERSION)
+    end
+
+    it "includes the adapter being used" do
+      subject.web(request, response)
+      expect(json).to include("adapter" => registry.config.robot.adapter.to_s)
+    end
+
+    it "includes the robot's name" do
+      subject.web(request, response)
+      expect(json).to include("robot_name" => robot.name)
+    end
+
+    it "includes the robot's mention name" do
+      subject.web(request, response)
+      expect(json).to include("robot_mention_name" => robot.mention_name)
+    end
+
+    it "includes the Redis version" do
+      subject.web(request, response)
+      expect(json).to have_key("redis_version")
+    end
+
+    it "includes the Redis memory usage" do
+      subject.web(request, response)
+      expect(json).to have_key("redis_memory_usage")
+    end
+  end
+end

data/spec/lita/handlers/room_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Lita::Handlers::Room, lita_handler: true do
+  it { is_expected.to route_command("join #lita.io").to(:join) }
+  it { is_expected.to route_command("part #lita.io").to(:part) }
+
+  before { allow(robot.auth).to receive(:user_is_admin?).with(user).and_return(true) }
+
+  describe "#join" do
+    it "calls Robot#join with the provided ID" do
+      expect(robot).to receive(:join).with("#lita.io")
+      send_command("join #lita.io")
+    end
+  end
+
+  describe "#part" do
+    it "calls Robot#part with the provided ID" do
+      expect(robot).to receive(:part).with("#lita.io")
+      send_command("part #lita.io")
+    end
+  end
+end

data/spec/lita/handlers/users_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Lita::Handlers::Users, lita_handler: true do
+  it { is_expected.to route_command("users find carl").to(:find) }
+
+  describe "#find" do
+    it "finds users by ID" do
+      send_command("users find 1")
+
+      expect(replies.first).to eq("Test User (ID: 1, Mention name: Test User)")
+    end
+
+    it "finds users by name" do
+      send_command("users find 'Test User'")
+
+      expect(replies.first).to eq("Test User (ID: 1, Mention name: Test User)")
+    end
+
+    it "finds users by mention name" do
+      Lita::User.create(2, name: "Mr. Pug", mention_name: "carl")
+
+      send_command("users find carl")
+
+      expect(replies.first).to eq("Mr. Pug (ID: 2, Mention name: carl)")
+    end
+
+    it "replies with a message when no matches are found" do
+      send_command("users find nobody")
+
+      expect(replies.first).to eq("No matching users found.")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+])
+SimpleCov.start { add_filter "/spec/" }
+
+require "lita-default-handlers"
+require "lita/rspec"
+
+# A compatibility mode is provided for older plugins upgrading from Lita 3. Since this plugin
+# was generated with Lita 4, the compatibility mode should be left disabled.
+Lita.version_3_compatibility_mode = false

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: lita-default-handlers
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jimmy Cuadra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A set of handlers included by default in Lita.
+email:
+- jimmy@jimmycuadra.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/lita-default-handlers.rb
+- lib/lita/handlers/authorization.rb
+- lib/lita/handlers/help.rb
+- lib/lita/handlers/info.rb
+- lib/lita/handlers/room.rb
+- lib/lita/handlers/users.rb
+- lita-default-handlers.gemspec
+- locales/en.yml
+- spec/lita/handlers/authorization_spec.rb
+- spec/lita/handlers/help_spec.rb
+- spec/lita/handlers/info_spec.rb
+- spec/lita/handlers/room_spec.rb
+- spec/lita/handlers/users_spec.rb
+- spec/spec_helper.rb
+- templates/.gitkeep
+homepage: https://github.com/litaio/lita-default-handlers
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A set of handlers included by default in Lita.
+test_files:
+- spec/lita/handlers/authorization_spec.rb
+- spec/lita/handlers/help_spec.rb
+- spec/lita/handlers/info_spec.rb
+- spec/lita/handlers/room_spec.rb
+- spec/lita/handlers/users_spec.rb
+- spec/spec_helper.rb