lita 4.5.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b05600a1b35088abb38dbb5f4bf68e3f97f3758e
-  data.tar.gz: d67724a6e50664c074e71729ca0cda9a389fcaa6
+  metadata.gz: 411c330d69cc62203d31374e506722511a8582aa
+  data.tar.gz: 36b57d4429140175ab4baa79a322dc13beac79c0
 SHA512:
-  metadata.gz: 425041c5ed45f464f8374053f45f85ce0487cba75c6eb5c35e2ae54fbcb48891cae4fc21d5c8732da2984da626c639b1704cd72d74860892837e526241aed7a3
-  data.tar.gz: 38658b9c6a4bc97c54f79355b49c36e1cb4a6329077554320f4376ed4170d4db3e84763178d989bbb8b7a6999f44425c653a55a27b4f9e564915183b74bbfb71
+  metadata.gz: 287c23415f235842e613290b117557624affe4e1357430e873128066f719d6a7d79fd1847a52a97c30b91d40d8a7a1cf6287c2044a05f619749d023bee55fd78
+  data.tar.gz: 4a44d63d33e8420f474a48ef63311f4f324f272da4dedf60399e86ee3f69b7a1c9f29d61adb092a18759e1b1341ede9fe31b57026666d1f118668e138fbe3b5e

data/lib/lita.rb

@@ -115,6 +115,7 @@ require_relative "lita/timer"
 require_relative "lita/robot"
 require_relative "lita/adapter"
 require_relative "lita/adapters/shell"
+require_relative "lita/adapters/test"
 require_relative "lita/plugin_builder"
 require_relative "lita/route_validator"
 require_relative "lita/handlers/authorization"

data/lib/lita/adapter.rb

@@ -4,6 +4,7 @@ module Lita
     # The names of methods that should be implemented by an adapter.
     # @since 4.4.0
     REQUIRED_METHODS = %i(
+      chat_service
       join
       part
       roster
@@ -65,6 +66,12 @@ module Lita
       robot.config.adapters.public_send(self.class.namespace)
     end
 
+    # @!method chat_service
+    # May return an object exposing chat-service-specific APIs.
+    # @return [Object, nil] The chat service API object, if any.
+    # @abstract This should be implemented by the adapter.
+    # @since 4.6.0
+
     # @!method join(room_id)
     # Joins the room with the specified ID.
     # @param room_id [String] The ID of the room.

data/lib/lita/adapters/test.rb

@@ -0,0 +1,43 @@
+module Lita
+  # A namespace to hold all subclasses of {Adapter}.
+  module Adapters
+    # An adapter for testing Lita and Lita plugins.
+    # @since 4.6.0
+    class Test < Adapter
+      # Adapter-specific methods exposed through {Robot}.
+      class ChatService
+        def initialize(sent_messages)
+          @sent_messages = sent_messages
+        end
+
+        # An array of recorded outgoing messages.
+        def sent_messages
+          @sent_messages.dup
+        end
+      end
+
+      def initialize(robot)
+        super
+
+        self.sent_messages = []
+      end
+
+      # Adapter-specific methods available via {Robot#chat_service}.
+      def chat_service
+        ChatService.new(sent_messages)
+      end
+
+      # Records outgoing messages.
+      def send_messages(_target, strings)
+        sent_messages.concat(strings)
+      end
+
+      private
+
+      # An array of recorded outgoing messages.
+      attr_accessor :sent_messages
+    end
+
+    Lita.register_adapter(:test, Test)
+  end
+end

data/lib/lita/handler/chat_router.rb

@@ -95,10 +95,8 @@ module Lita
         robot.hooks[:trigger_route].each { |hook| hook.call(response: response, route: route) }
         handler = new(robot)
         route.callback.call(handler, response)
-      rescue Exception => e
-        log_dispatch_error(e)
-        robot.config.robot.error_handler.call(e)
-        raise e if Lita.test_mode?
+      rescue => error
+        log_error(robot, error)
       end
 
       private
@@ -125,16 +123,6 @@ module Lita
           method: route.callback.method_name || "(block)"
         )
       end
-
-      # Logs an error encountered during dispatch.
-      def log_dispatch_error(e)
-        Lita.logger.error I18n.t(
-          "lita.handler.exception",
-          handler: name,
-          message: e.message,
-          backtrace: e.backtrace.join("\n")
-        )
-      end
     end
   end
 end

data/lib/lita/handler/common.rb

@@ -37,6 +37,18 @@ module Lita
         end
 
         alias_method :t, :translate
+
+        # Logs an error raised by a plugin.
+        def log_error(robot, error)
+          robot.config.robot.error_handler.call(error)
+          Lita.logger.error I18n.t(
+            "lita.handler.exception",
+            handler: name,
+            message: error.message,
+            backtrace: error.backtrace.join("\n")
+          )
+          raise error if Lita.test_mode?
+        end
       end
 
       # A Redis::Namespace scoped to the handler.

data/lib/lita/handler/event_router.rb

@@ -57,7 +57,11 @@ module Lita
       # @return [Boolean] Whether or not the event triggered any callbacks.
       def trigger(robot, event_name, payload = {})
         event_subscriptions_for(event_name).map do |callback|
-          callback.call(new(robot), payload)
+          begin
+            callback.call(new(robot), payload)
+          rescue => error
+            log_error(robot, error)
+          end
         end.any?
       end
 

data/lib/lita/robot.rb

@@ -36,13 +36,16 @@ module Lita
 
     def_delegators :registry, :config, :adapters, :handlers, :hooks
 
+    # @!method chat_service
+    #   @see Lita::Adapter#chat_service
+    #   @since 4.6.0
     # @!method mention_format(name)
     #   @see Lita::Adapter#mention_format
     #   @since 4.4.0
     # @!method roster(room)
     #   @see Lita::Adapter#roster
     #   @since 4.4.1
-    def_delegators :adapter, :mention_format, :roster
+    def_delegators :adapter, :chat_service, :mention_format, :roster
 
     # @param registry [Lita::Registry] The registry for the robot's configuration and plugins.
     def initialize(registry = Lita)

data/lib/lita/rspec/handler.rb

@@ -18,13 +18,27 @@ module Lita
           base.send(:include, Lita::RSpec)
 
           prepare_handlers(base)
+          prepare_adapter(base)
           prepare_let_blocks(base)
           prepare_subject(base)
-          prepare_robot(base)
         end
 
         private
 
+        # Stub Lita.adapters
+        def prepare_adapter(base)
+          base.class_eval do
+            before do
+              if Lita.version_3_compatibility_mode?
+                Lita.config.robot.adapter = :test
+              else
+                registry.register_adapter(:test, Lita::Adapters::Test)
+                registry.config.robot.adapter = :test
+              end
+            end
+          end
+        end
+
         # Stub Lita.handlers.
         def prepare_handlers(base)
           base.class_eval do
@@ -50,20 +64,7 @@ module Lita
             let(:robot) { Robot.new(registry) }
             let(:source) { Source.new(user: user) }
             let(:user) { User.create("1", name: "Test User") }
-            let(:replies) { [] }
-          end
-        end
-
-        # Stub Lita::Robot#send_messages.
-        def prepare_robot(base)
-          base.class_eval do
-            before do
-              [:send_messages, :send_message].each do |message|
-                allow(robot).to receive(message) do |_target, *strings|
-                  replies.concat(strings)
-                end
-              end
-            end
+            let(:replies) { robot.chat_service.sent_messages }
           end
         end
 
@@ -71,7 +72,6 @@ module Lita
         def prepare_subject(base)
           base.class_eval do
             subject { described_class.new(robot) }
-            before { allow(described_class).to receive(:new).and_return(subject) }
           end
         end
       end
@@ -81,8 +81,12 @@ module Lita
       # @param as [Lita::User] The user sending the message.
       # @param from [Lita::Room] The room where the message is received from.
       # @return [void]
-      def send_message(body, as: user, from: nil)
-        message = Message.new(robot, body, Source.new(user: as, room: from))
+      def send_message(body, as: user, from: nil, privately: false)
+        message = Message.new(
+          robot,
+          body,
+          Source.new(user: as, room: from, private_message: privately)
+        )
 
         robot.receive(message)
       end
@@ -92,8 +96,8 @@ module Lita
       # @param as [Lita::User] The user sending the message.
       # @param from [Lita::Room] The room where the message is received from.
       # @return [void]
-      def send_command(body, as: user, from: nil)
-        send_message("#{robot.mention_name}: #{body}", as: as, from: from)
+      def send_command(body, as: user, from: nil, privately: false)
+        send_message("#{robot.mention_name}: #{body}", as: as, from: from, privately: privately)
       end
 
       # Returns a Faraday connection hooked up to the currently running robot's Rack app.

data/lib/lita/version.rb

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

data/spec/lita/handler/event_router_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-describe Lita::Handler::EventRouter do
-  let(:robot) { instance_double("Lita::Robot", name: "Lita") }
+describe Lita::Handler::EventRouter, lita: true do
+  let(:robot) { Lita::Robot.new(registry) }
 
   subject do
     Class.new do
@@ -27,6 +27,16 @@ describe Lita::Handler::EventRouter do
 
       on(:multiple_callbacks) { robot.send_message("first callback") }
       on(:multiple_callbacks) { robot.send_message("second callback") }
+
+      on(:multiple_errors) do
+        robot.send_message("first error")
+        raise ArgumentError, "first"
+      end
+
+      on(:multiple_errors) do
+        robot.send_message("second error")
+        raise ArgumentError, "second"
+      end
     end
   end
 
@@ -61,5 +71,47 @@ describe Lita::Handler::EventRouter do
       subject.trigger(robot, "connected")
       subject.trigger(robot, " ConNected  ")
     end
+
+    context "not in test mode" do
+      around do |example|
+        test_mode = Lita.test_mode?
+        Lita.test_mode = false
+        begin
+          example.run
+        ensure
+          Lita.test_mode = test_mode
+        end
+      end
+
+      it "doesn't stop triggering callbacks after an exception is raised" do
+        expect(robot).to receive(:send_message).with("first error").once
+        expect(robot).to receive(:send_message).with("second error").once
+        subject.trigger(robot, :multiple_errors)
+      end
+
+      it "reports callback exceptions to the error handler" do
+        allow(robot).to receive(:send_message)
+        expect(registry.config.robot.error_handler).to receive(:call).twice
+        subject.trigger(robot, :multiple_errors)
+      end
+    end
+
+    context "in test mode" do
+      around do |example|
+        test_mode = Lita.test_mode?
+        Lita.test_mode = true
+        begin
+          example.run
+        ensure
+          Lita.test_mode = test_mode
+        end
+      end
+
+      it "re-raises callback exceptions immediately" do
+        allow(robot).to receive(:send_message)
+        expect(registry.config.robot.error_handler).to receive(:call).once
+        expect { subject.trigger(robot, :multiple_errors) }.to raise_error(ArgumentError, "first")
+      end
+    end
   end
 end

data/spec/lita/handlers/info_spec.rb

@@ -39,7 +39,7 @@ describe Lita::Handlers::Info, lita_handler: true do
 
     it "includes the adapter being used" do
       subject.web(request, response)
-      expect(json).to include("adapter" => Lita.config.robot.adapter.to_s)
+      expect(json).to include("adapter" => registry.config.robot.adapter.to_s)
     end
 
     it "includes the robot's name" do

data/spec/lita/robot_spec.rb

@@ -44,6 +44,10 @@ describe Lita::Robot, lita: true do
     subject.roster(instance_double("Lita::Room"))
   end
 
+  it "exposes Adapter#chat_service" do
+    expect { subject.chat_service }.not_to raise_error
+  end
+
   context "with registered handlers" do
     let(:handler1) { Class.new(Lita::Handler) { namespace :test } }
     let(:handler2) { Class.new(Lita::Handler) { namespace :test } }

data/spec/lita/rspec_spec.rb

@@ -3,6 +3,7 @@ require "spec_helper"
 handler_class = Class.new(Lita::Handler) do
   route(/^message$/, :message)
   route(/^channel$/, :channel)
+  route(/^private message$/, :private_message)
   route(/^command$/, :command, command: true)
   route("restricted", :restricted, restrict_to: :some_group)
   route("admins only", :admins_only, restrict_to: :admins)
@@ -24,6 +25,14 @@ handler_class = Class.new(Lita::Handler) do
     end
   end
 
+  def private_message(response)
+    if response.private_message?
+      response.reply("Private")
+    else
+      response.reply("Public")
+    end
+  end
+
   def command(response)
     response.reply("a", "command")
   end
@@ -116,12 +125,40 @@ describe handler_class, lita_handler: true do
       send_message("channel", from: room)
       expect(replies).to eq(%w(1 Room))
     end
+
     it "replies with no channel if not sent from room" do
       send_message("channel")
       expect(replies).to eq(["No room"])
     end
   end
 
+  describe "#private_message" do
+    let(:another_user) do
+      Lita::User.create(2, name: "Another User")
+    end
+
+    let(:room) do
+      Lita::Room.create_or_update(1, name: "Room")
+    end
+
+    it "replies with Private in response to a private message" do
+      send_message("private message", as: another_user, privately: true)
+      expect(source).to be_a_private_message
+      expect(replies.last).to eq("Private")
+    end
+
+    it "replies with Private in response to a private command" do
+      send_command("private message", as: another_user, privately: true)
+      expect(source).to be_a_private_message
+      expect(replies.last).to eq("Private")
+    end
+
+    it "replies with Public in response to a public message" do
+      send_message("private message", as: another_user, from: room)
+      expect(replies.last).to eq("Public")
+    end
+  end
+
   describe "#command" do
     it "replies with two strings" do
       send_command("command")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita
 version: !ruby/object:Gem::Version
-  version: 4.5.0
+  version: 4.6.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -282,6 +282,7 @@ files:
 - lib/lita.rb
 - lib/lita/adapter.rb
 - lib/lita/adapters/shell.rb
+- lib/lita/adapters/test.rb
 - lib/lita/authorization.rb
 - lib/lita/callback.rb
 - lib/lita/cli.rb
@@ -449,3 +450,4 @@ test_files:
 - spec/templates/basic.irc.erb
 - spec/templates/helpers.erb
 - spec/templates/interpolated.erb
+has_rdoc: