lita 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b61601772ee2c0a0822f137d838dd8f2b2aed2b
-  data.tar.gz: a035716200ec7451d45e4b9cc6bf633200718a30
+  metadata.gz: ffbba6c703174e7a6984339b41e1b6b3ce01e617
+  data.tar.gz: 5d30f8db3d352fd2dacf9e3fb752d434ab6230d4
 SHA512:
-  metadata.gz: 0088d680d6ded0dbeabfc979401010675d6e5d2b296dfdd66e06cadcfcf760d2db22ba480f9830a7d8eb05d3b81f1773bbe7ec8c6d20e4bb0820699eff90c195
-  data.tar.gz: 7225377452adbde322b4a9a1a62d2abb30721dee7b719b62e9d41c62ede19116b0979942374bfb195ea8eb2ebdec8efcbbe6ab1ba360927c17b42f065526775f
+  metadata.gz: e5d699a894adf21dd032822f4b3e03b1271e4f49d1330abe1cef0a99d4af9f710aa2934277474ae6a72700b16fc48abee34777f6ca9bec34fc19a7fb6c421009
+  data.tar.gz: 62e5a1586f950a4385d40c0cab802d7e9eef5dd07900657ef8640dc59ad9c4a9a3972b402c327f6cff2c83be9ad933ce2f4adc7ef4a5699093fb3b9ffcb2870d

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
   - 2.0.0
-script: bundle exec rspec
+script: bundle exec rake
 before_install:
   - gem update --system

data/README.md

@@ -258,7 +258,7 @@ module Lita
     class Echo < Handler
       route /^echo\s+(.+)/, :echo, help: { "echo FOO" => "Echoes back FOO." }
 
-      def echo(matches)
+      def echo(response)
         response.reply(response.matches)
       end
     end

data/Rakefile

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

data/lib/lita.rb

@@ -100,7 +100,7 @@ require "lita/authorization"
 require "lita/message"
 require "lita/response"
 require "lita/http_route"
-require "lita/rack_app_builder"
+require "lita/rack_app"
 require "lita/robot"
 require "lita/adapter"
 require "lita/adapters/shell"

data/lib/lita/adapters/shell.rb

@@ -14,9 +14,7 @@ module Lita
           print "#{robot.name} > "
           input = $stdin.gets.chomp.strip
           break if input == "exit" || input == "quit"
-          message = Message.new(robot, input, source)
-          message.command! if Lita.config.adapter.private_chat
-          robot.receive(message)
+          robot.receive(build_message(robot, input, source))
         end
       end
 
@@ -34,6 +32,14 @@ module Lita
       def shut_down
         puts
       end
+
+      private
+
+      def build_message(robot, input, source)
+        message = Message.new(robot, input, source)
+        message.command! if Lita.config.adapter.private_chat
+        message
+      end
     end
 
     Lita.register_adapter(:shell, Shell)

data/lib/lita/authorization.rb

@@ -31,7 +31,9 @@ module Lita
       # @param group [Symbol, String] The name of the group.
       # @return [Boolean] Whether or not the user is in the group.
       def user_in_group?(user, group)
-        redis.sismember(normalize_group(group), user.id)
+        group = normalize_group(group)
+        return user_is_admin?(user) if group == "admins"
+        redis.sismember(group, user.id)
       end
 
       # Checks if a user is an administrator.

data/lib/lita/config.rb

@@ -5,7 +5,7 @@ module Lita
       # Initializes a new Config object with the default settings.
       # @return [Lita::Config] The default configuration.
       def default_config
-        config = new.tap do |c|
+        new.tap do |c|
           c.robot = new
           c.robot.name = "Lita"
           c.robot.adapter = :shell
@@ -17,9 +17,8 @@ module Lita
           c.http.debug = false
           c.adapter = new
           c.handlers = new
+          load_handler_configs(c)
         end
-        load_handler_configs(config)
-        config
       end
 
       # Loads configuration from a user configuration file.

data/lib/lita/handler.rb

@@ -51,24 +51,17 @@ module Lita
       # @param message [Lita::Message] The incoming message.
       # @return [void]
       def dispatch(robot, message)
-        routes.each do |route|
-          if route_applies?(route, message, robot)
-            Lita.logger.debug <<-LOG.chomp
-Dispatching message to #{self}##{route.method_name}.
-LOG
-            begin
-              new(robot).public_send(route.method_name, Response.new(
-                message,
-                matches: message.match(route.pattern)
-              ))
-            rescue Exception => e
-              Lita.logger.error <<-ERROR.chomp
-#{name} crashed. The exception was:
-#{e.message}
-#{e.backtrace.join("\n")}
-ERROR
-              raise e if rspec_loaded?
-            end
+        routes.select { |r| route_applies?(r, message, robot) }.each do |route|
+          log_dispatch(route)
+
+          begin
+            new(robot).public_send(
+              route.method_name,
+              build_response(message, route)
+            )
+          rescue Exception => e
+            log_dispatch_error(e)
+            raise e if rspec_loaded?
           end
         end
       end
@@ -102,6 +95,11 @@ ERROR
 
       private
 
+      # Builds a response object for an incoming message.
+      def build_response(message, route)
+        Response.new(message, matches: message.match(route.pattern))
+      end
+
       # Determines whether or not an incoming messages should trigger a route.
       def route_applies?(route, message, robot)
         # Message must match the pattern
@@ -114,9 +112,7 @@ ERROR
         return if message.user.name == robot.name
 
         # User must be in auth group if route is restricted
-        return if route.required_groups && route.required_groups.none? do |group|
-          Authorization.user_in_group?(message.user, group)
-        end
+        return unless authorized?(message.user, route.required_groups)
 
         true
       end
@@ -126,6 +122,28 @@ ERROR
       def rspec_loaded?
         defined?(::RSpec)
       end
+
+      # 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|
+          Authorization.user_in_group?(user, group)
+        end
+      end
+
+      # Logs the dispatch of message.
+      def log_dispatch(route)
+        Lita.logger.debug <<-LOG.chomp
+Dispatching message to #{self}##{route.method_name}.
+LOG
+      end
+
+      def log_dispatch_error(e)
+        Lita.logger.error <<-ERROR.chomp
+#{name} crashed. The exception was:
+#{e.message}
+#{e.backtrace.join("\n")}
+ERROR
+      end
     end
 
     # @param robot [Lita::Robot] The currently running robot.

data/lib/lita/handlers/authorization.rb

@@ -2,16 +2,32 @@ module Lita
   module Handlers
     # Provides a chat interface for administering authorization groups.
     class Authorization < Handler
-      route(/^auth\s+add/, :add, command: true, help: {
-        "auth add USER GROUP" => "Add USER to authorization group GROUP. Requires admin privileges."
-      })
-      route(/^auth\s+remove/, :remove, command: true, help: {
-        "auth remove USER GROUP" => "Remove USER from authorization group GROUP. Requires admin privileges."
-      })
-      route(/^auth\s+list/, :list, command: true, help: {
-        "auth list [GROUP]" => <<-HELP
+      route(
+        /^auth\s+add/,
+        :add,
+        command: true,
+        restrict_to: :admins,
+        help: {
+        "auth add USER GROUP" => <<-HELP.chomp
+Add USER to authorization group GROUP. Requires admin privileges.
+HELP
+        }
+      )
+      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
+        }
+      )
+      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."
+lists that group.
 HELP
       })
 
@@ -21,10 +37,7 @@ HELP
       def add(response)
         return unless valid_message?(response)
 
-        case Lita::Authorization.add_user_to_group(response.user, @user, @group)
-        when :unauthorized
-          response.reply "Only administrators can add users to groups."
-        when true
+        if Lita::Authorization.add_user_to_group(response.user, @user, @group)
           response.reply "#{@user.name} was added to #{@group}."
         else
           response.reply "#{@user.name} was already in #{@group}."
@@ -37,14 +50,11 @@ HELP
       def remove(response)
         return unless valid_message?(response)
 
-        case Lita::Authorization.remove_user_from_group(
+        if Lita::Authorization.remove_user_from_group(
           response.user,
           @user,
           @group
         )
-        when :unauthorized
-          response.reply "Only administrators can remove users from groups."
-        when true
           response.reply "#{@user.name} was removed from #{@group}."
         else
           response.reply "#{@user.name} was not in #{@group}."
@@ -96,6 +106,11 @@ HELP
           return
         end
 
+        if @group.downcase.strip == "admins"
+          response.reply "Administrators can only be managed via Lita config."
+          return
+        end
+
         @user = User.find_by_id(identifier)
         @user = User.find_by_name(identifier) unless @user
 

data/lib/lita/handlers/help.rb

@@ -3,35 +3,60 @@ module Lita
     # 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.",
-        "help COMMAND" => "Lists help information for terms or commands that begin with COMMAND."
+        "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/, "")
       })
 
       # Outputs help information about Lita commands.
       # @param response [Lita::Response] The response object.
       # @return [void]
       def help(response)
+        output = build_help(response)
+        output = filter_help(output, response)
+        response.reply 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|
+          Lita::Authorization.user_in_group?(user, group)
+        end
+      end
+
+      # 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}"
             end
           end
         end
 
+        output
+      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 }
+          output.select { |line| /(?:@?#{name}[:,]?)?#{filter}/i === line }
+        else
+          output
         end
-
-        response.reply output.join("\n")
       end
 
-      private
-
       # 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/{rack_app_builder.rb → rack_app.rb}

@@ -1,6 +1,6 @@
 module Lita
-  # Creates a +Rack+ application from all the routes registered by handlers.
-  class RackAppBuilder
+  # 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 = "/"
 
@@ -26,44 +26,33 @@ module Lita
       compile
     end
 
+    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(app_proc)
+      app.run(self)
       app
     end
 
     private
 
-    # The proc that serves as the +Rack+ application.
-    def app_proc
-      -> (env) do
-        request = Rack::Request.new(env)
-
-        mapping = routes[request.request_method][request.path]
-
-        if mapping
-          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
-        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
-    end
-
     # Collect all registered paths. Used for responding to HEAD requests.
     def collect_paths
       @all_paths = routes.values.map { |hash| hash.keys.first }.uniq
@@ -77,6 +66,10 @@ LOG
       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)
@@ -99,6 +92,17 @@ LOG
       )
     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!

data/lib/lita/robot.rb

@@ -20,7 +20,7 @@ module Lita
     def initialize
       @name = Lita.config.robot.name
       @mention_name = Lita.config.robot.mention_name || @name
-      @app = RackAppBuilder.new(self).to_app
+      @app = RackApp.new(self).to_app
       load_adapter
     end
 

data/lib/lita/rspec.rb

@@ -16,20 +16,36 @@ require "lita/rspec/handler"
 module Lita
   # Extras for +RSpec+ that facilitate the testing of Lita code.
   module RSpec
-    # Causes all interaction with Redis to use a test-specific namespace. Clears
-    # Redis before each example. Stubs the logger to prevent log messages from
-    # cluttering test output. Clears Lita's global configuration.
-    # @param base [Object] The class including the module.
-    # @return [void]
-    def self.included(base)
-      base.class_eval do
-        before do
-          stub_const("Lita::REDIS_NAMESPACE", "lita.test")
-          keys = Lita.redis.keys("*")
-          Lita.redis.del(keys) unless keys.empty?
-          logger = double("Logger").as_null_object
-          allow(Lita).to receive(:logger).and_return(logger)
-          Lita.clear_config
+    class << self
+      # Causes all interaction with Redis to use a test-specific namespace.
+      # Clears Redis before each example. Stubs the logger to prevent log
+      # messages from cluttering test output. Clears Lita's global
+      # configuration.
+      # @param base [Object] The class including the module.
+      # @return [void]
+      def included(base)
+        base.class_eval do
+          before do
+            logger = double("Logger").as_null_object
+            allow(Lita).to receive(:logger).and_return(logger)
+            Lita.clear_config
+          end
+        end
+
+        set_up_redis(base)
+      end
+
+      private
+
+      # Set up Redis to use the test namespace and clear out before each
+      # example.
+      def set_up_redis(base)
+        base.class_eval do
+          before do
+            stub_const("Lita::REDIS_NAMESPACE", "lita.test")
+            keys = Lita.redis.keys("*")
+            Lita.redis.del(keys) unless keys.empty?
+          end
         end
       end
     end

data/lib/lita/rspec/handler.rb

@@ -2,28 +2,50 @@ module Lita
   module RSpec
     # Extras for +RSpec+ to facilitate testing Lita handlers.
     module Handler
-      # Sets up the RSpec environment to easily test Lita handlers.
-      def self.included(base)
-        base.class_eval do
-          include Lita::RSpec
-
-          let(:robot) { Robot.new }
-          let(:source) { Source.new(user) }
-          let(:user) { User.create("1", name: "Test User") }
-          let(:replies) { [] }
-
-          subject { described_class.new(robot) }
-
-          before do
-            allow(Lita).to receive(:handlers).and_return([described_class])
-            allow(robot).to receive(:send_messages) do |target, *strings|
-              replies.concat(strings)
-            end
-            allow(robot).to receive(:send_message) do |target, *strings|
-              replies.concat(strings)
+      class << self
+        # Sets up the RSpec environment to easily test Lita handlers.
+        def included(base)
+          base.class_eval do
+            include Lita::RSpec
+          end
+
+          set_up_let_blocks(base)
+          set_up_subject(base)
+          set_up_before_block(base)
+        end
+
+        private
+
+        # Stub Lita.handlers and Lita::Robot#send_messages.
+        def set_up_before_block(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
           end
         end
+
+        # Create common test objects.
+        def set_up_let_blocks(base)
+          base.class_eval do
+            let(:robot) { Robot.new }
+            let(:source) { Source.new(user) }
+            let(:user) { User.create("1", name: "Test User") }
+            let(:replies) { [] }
+          end
+        end
+
+        # Set up a working test subject.
+        def set_up_subject(base)
+          base.class_eval do
+            subject { described_class.new(robot) }
+          end
+        end
       end
 
       # Sends a message to the robot.
@@ -48,8 +70,8 @@ module Lita
         send_message("#{robot.mention_name}: #{body}", as: as)
       end
 
-      # Starts a chat routing test chain, asserting that a message should trigger
-      # a route.
+      # 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.
@@ -82,7 +104,11 @@ module Lita
       # @return [RouteMatcher] A {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)
+        RouteMatcher.new(
+          self,
+          "#{robot.mention_name}: #{message}",
+          invert: true
+        )
       end
       alias_method :doesnt_route_command, :does_not_route_command
 

data/lib/lita/version.rb

@@ -1,4 +1,4 @@
 module Lita
   # The current version of Lita.
-  VERSION = "2.2.0"
+  VERSION = "2.2.1"
 end

data/lita.gemspec

@@ -33,4 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "cane"
 end

data/spec/lita/authorization_spec.rb

@@ -61,6 +61,11 @@ describe Lita::Authorization, lita: true do
     it "returns false if the user is in the group" do
       expect(described_class.user_in_group?(user, "employees")).to be_false
     end
+
+    it "delegates to .user_is_admin? if the group is admins" do
+      expect(described_class).to receive(:user_is_admin?)
+      described_class.user_in_group?(user, "admins")
+    end
   end
 
   describe ".user_is_admin?" do

data/spec/lita/handlers/authorization_spec.rb

@@ -40,13 +40,9 @@ describe Lita::Handlers::Authorization, lita_handler: true do
       expect(replies.last).to eq("#{target_user.name} was already in bar.")
     end
 
-    it "replies with a warning if the requesting user is not an admin" do
-      allow(Lita::User).to receive(:find_by_id).and_return(target_user)
-      allow(Lita::Authorization).to receive(:user_is_admin?).with(
-        user
-      ).and_return(false)
-      send_command("auth add foo bar")
-      expect(replies.last).to match(/Only administrators can add/)
+    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
 
@@ -67,12 +63,9 @@ describe Lita::Handlers::Authorization, lita_handler: true do
       expect(replies.last).to eq("#{target_user.name} was not in bar.")
     end
 
-    it "replies with a warning if the requesting user is not an admin" do
-      allow(Lita::Authorization).to receive(:user_is_admin?).with(
-        user
-      ).and_return(false)
-      send_command("auth remove foo bar")
-      expect(replies.last).to match(/Only administrators can remove/)
+    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
 

data/spec/lita/handlers/help_spec.rb

@@ -5,6 +5,13 @@ describe Lita::Handlers::Help, lita_handler: true do
   it { routes_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(
@@ -17,5 +24,14 @@ describe Lita::Handlers::Help, lita_handler: true do
       expect(replies.last).to match(/help COMMAND - Lists/)
       expect(replies.last).not_to match(/help - Lists/)
     end
+
+    it "doesn't show help for commands the user doesn't have access to" do
+      allow(Lita).to receive(:handlers).and_return([
+        described_class,
+        secret_handler_class
+      ])
+      send_command("help")
+      expect(replies.last).not_to include("secret")
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-31 00:00:00.000000000 Z
+date: 2013-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -178,6 +178,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  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 multi-service chat bot with extendable behavior.
 email:
 - jimmy@jimmycuadra.com
@@ -207,7 +221,7 @@ files:
 - lib/lita/http_route.rb
 - lib/lita/logger.rb
 - lib/lita/message.rb
-- lib/lita/rack_app_builder.rb
+- lib/lita/rack_app.rb
 - lib/lita/response.rb
 - lib/lita/robot.rb
 - lib/lita/rspec.rb