lita 4.4.3 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60f8a5c4baff97cb21c6bda0e37416b919747443
-  data.tar.gz: 2ecdd16eb4c246c566178a31f4cfc277e0794282
+  metadata.gz: b05600a1b35088abb38dbb5f4bf68e3f97f3758e
+  data.tar.gz: d67724a6e50664c074e71729ca0cda9a389fcaa6
 SHA512:
-  metadata.gz: 1f9d6e452648e187da436d3b9fbb248ff90243abc47ac671340df664f42b4c12c7d7fb832f169583cb485dd4adb44b554a79f4751f6ba011b6be6ed22fdc35d0
-  data.tar.gz: 55d2096400b2dca088b16b40f07ae0888ed30ec98ad9dc6e873c5a2b7a23132b7b16c8649a3b61c49a1a0a6c9009c830bc0e7b5ce6f7c589aeef37c0b105eb57
+  metadata.gz: 425041c5ed45f464f8374053f45f85ce0487cba75c6eb5c35e2ae54fbcb48891cae4fc21d5c8732da2984da626c639b1704cd72d74860892837e526241aed7a3
+  data.tar.gz: 38658b9c6a4bc97c54f79355b49c36e1cb4a6329077554320f4376ed4170d4db3e84763178d989bbb8b7a6999f44425c653a55a27b4f9e564915183b74bbfb71

data/.rubocop.yml

@@ -24,6 +24,8 @@ LineLength:
   Max: 100
 MethodLength:
   Enabled: false
+NestedMethodDefinition:
+  Enabled: false
 NonNilCheck:
   Enabled: false
 ParameterLists:

data/.travis.yml

@@ -1,9 +1,17 @@
 language: ruby
+sudo: false
 cache: bundler
 rvm:
   - 2.0
   - 2.1
   - 2.2
+  - jruby-9.0.0.0
+  - rbx-2
+matrix:
+  allow_failures:
+    - rvm: jruby-9.0.0.0
+    - rvm: rbx-2
+  fast_finish: true
 script: bundle exec rake
 before_install:
   - gem update --system
@@ -13,6 +21,7 @@ branches:
   except:
     - /^v[0-9]/
 notifications:
+  email: false
   webhooks:
     urls:
       - https://lita-freenode.herokuapp.com/travis

data/lib/lita/handler/chat_router.rb

@@ -9,7 +9,7 @@ module Lita
       end
 
       # A Struct representing a chat route defined by a handler.
-      class Route < Struct.new(
+      Route = Struct.new(
         :pattern,
         :callback,
         :command,
@@ -17,6 +17,8 @@ module Lita
         :help,
         :extensions
       )
+
+      class Route
         alias_method :command?, :command
       end
 
@@ -70,6 +72,13 @@ module Lita
         routes.map do |route|
           next unless route_applies?(route, message, robot)
           log_dispatch(route)
+          robot.trigger(
+            :message_dispatched,
+            handler: self,
+            route: route,
+            message: message,
+            robot: robot
+          )
           dispatch_to_route(route, robot, message)
           true
         end.any?

data/lib/lita/handler/common.rb

@@ -104,10 +104,34 @@ module Lita
         Lita.logger
       end
 
+      # Render an ERB template to a string, with any provided variables made available to the
+      # template.
+      # @param template_name [String] The name of the ERB template file.
+      # @param variables [Hash] An optional hash of variables to make available within the
+      #   template. Hash keys become instance variable names with the hash values as the instance
+      #   variables' values.
+      # @return [String] The rendered template.
+      # @since 4.2.0
       def render_template(template_name, variables = {})
         Template.from_file(file_for_template(template_name)).render(variables)
       end
 
+      # Renders an ERB template to a string, like {#render_template}, but also takes an array of
+      # modules with helper methods to be made available to the template.
+      # @param template_name [String] The name of the ERB template file.
+      # @param helpers [Array<Module>] An array of modules whose methods should be added to the
+      #   template evaluation context.
+      # @param variables [Hash] An optional hash of variables to make available within the
+      #   template. Hash keys become instance variable names with the hash values as the instance
+      #   variables' values.
+      # @return [String] The rendered template.
+      # @since 4.5.0
+      def render_template_with_helpers(template_name, helpers, variables = {})
+        template = Template.from_file(file_for_template(template_name))
+        helpers.each { |helper| template.add_helper(helper) }
+        template.render(variables)
+      end
+
       # @see .translate
       def translate(*args)
         self.class.translate(*args)

data/lib/lita/http_route.rb

@@ -1,17 +1,3 @@
-# Primary class from the +http_router+ gem.
-# @todo Remove this monkey patch as soon as a gem is released with this pull request merged:
-#   https://github.com/joshbuddy/http_router/pull/40
-class HttpRouter
-  # An individual HTTP route.
-  class Route
-    # Sets a name for the route. Monkey patched due to a bug.
-    def name=(name)
-      @name = name
-      router.named_routes[name] << self if router
-    end
-  end
-end
-
 module Lita
   # Handlers use this class to define HTTP routes for the built-in web
   # server.

data/lib/lita/message.rb

@@ -12,10 +12,20 @@ module Lita
     attr_reader :source
 
     # @!method user
-    # The user who sent the message.
-    # @return [Lita::User] The user.
-    # @see Lita::Source#user
-    def_delegators :source, :user
+    #   The user who sent the message.
+    #   @return [Lita::User] The user.
+    #   @see Lita::Source#user
+    # @!method room_object
+    #   The room where the message came from.
+    #   @return [Lita::Room] The room.
+    #   @see Lita::Source#room_object
+    #   @since 4.5.0
+    # @!method private_message?
+    #   Flag indicating that the message was sent to the robot privately.
+    #   @return [Boolean] The boolean flag.
+    #   @see Lita::Source#private_message?
+    #   @since 4.5.0
+    def_delegators :source, :user, :room_object, :private_message?
 
     # @param robot [Lita::Robot] The currently running robot.
     # @param body [String] The body of the message.
@@ -25,10 +35,15 @@ module Lita
       @body = body
       @source = source
 
-      name_pattern = Regexp.escape(@robot.mention_name)
-      name_pattern = "#{name_pattern}|#{Regexp.escape(@robot.alias)}" if @robot.alias
+      name_pattern = "@?#{Regexp.escape(@robot.mention_name)}[:,]?\\s+"
+      alias_pattern = "#{Regexp.escape(@robot.alias)}\\s*" if @robot.alias
+      command_regex = if alias_pattern
+        /^\s*(?:#{name_pattern}|#{alias_pattern})/i
+      else
+        /^\s*#{name_pattern}/i
+      end
 
-      @command = !!@body.sub!(/^\s*@?(?:#{name_pattern})[:,]?\s*/i, "")
+      @command = !!@body.sub!(command_regex, "")
     end
 
     # An array of arguments created by shellsplitting the message body, as if

data/lib/lita/middleware_registry.rb

@@ -4,7 +4,7 @@ module Lita
   # @api private
   class MiddlewareRegistry
     # A Rack middleware and its initialization arguments.
-    class MiddlewareWrapper < Struct.new(:middleware, :args, :block); end
+    MiddlewareWrapper = Struct.new(:middleware, :args, :block)
 
     extend Forwardable
 

data/lib/lita/rack_app.rb

@@ -42,6 +42,12 @@ module Lita
       router.call(env)
     end
 
+    # Overrides the default inspect implementation to make output less verbose and more readable.
+    def inspect
+      hex_address = (object_id << 1).to_s(16).rjust(14, "0")
+      "#<Lita::RackApp:0x#{hex_address}>"
+    end
+
     # Finds the first route that matches the request environment, if any. Does not trigger the
     # route.
     # @param env [Hash] A Rack environment.

data/lib/lita/response.rb

@@ -27,8 +27,16 @@ module Lita
     #   @see Lita::Message#reply_with_mention
     # @!method user
     #   @see Lita::Message#user
+    # @!method private_message?
+    #   @see Lita::Message#private_message?
+    #   @since 4.5.0
     def_delegators :message, :args, :reply, :reply_privately,
-      :reply_with_mention, :user, :command?
+      :reply_with_mention, :user, :private_message?, :command?
+
+    # @!method room
+    #   @see Lita::Message#room_object
+    #   @since 4.5.0
+    def_delegator :message, :room_object, :room
 
     # @param message [Lita::Message] The incoming message.
     # @param pattern [Regexp] The pattern the incoming message matched.

data/lib/lita/route_validator.rb

@@ -31,7 +31,15 @@ module Lita
       return unless command_satisfied?(route, message)
       return if from_self?(message, robot)
       return unless matches_pattern?(route, message)
-      return unless authorized?(robot, message.user, route.required_groups)
+      unless authorized?(robot, message.user, route.required_groups)
+        robot.trigger(
+          :route_authorization_failed,
+          message: message,
+          robot: robot,
+          route: route,
+        )
+        return
+      end
       return unless passes_route_hooks?(route, message, robot)
 
       true

data/lib/lita/rspec/handler.rb

@@ -10,6 +10,7 @@ module Lita
       include Matchers::ChatRouteMatcher
       include Matchers::HTTPRouteMatcher
       include Matchers::EventRouteMatcher
+      include Matchers::DeprecatedMethods
 
       class << self
         # Sets up the RSpec environment to easily test Lita handlers.
@@ -78,13 +79,10 @@ module Lita
       # Sends a message to the robot.
       # @param body [String] The message to send.
       # @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)
-        message = if as == user
-          Message.new(robot, body, source)
-        else
-          Message.new(robot, body, Source.new(user: as))
-        end
+      def send_message(body, as: user, from: nil)
+        message = Message.new(robot, body, Source.new(user: as, room: from))
 
         robot.receive(message)
       end
@@ -92,9 +90,10 @@ module Lita
       # Sends a "command" message to the robot.
       # @param body [String] The message to send.
       # @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)
-        send_message("#{robot.mention_name}: #{body}", as: as)
+      def send_command(body, as: user, from: nil)
+        send_message("#{robot.mention_name}: #{body}", as: as, from: from)
       end
 
       # Returns a Faraday connection hooked up to the currently running robot's Rack app.
@@ -109,138 +108,6 @@ module Lita
 
         Faraday::Connection.new { |c| c.adapter(:rack, robot.app) }
       end
-
-      # 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 [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
-      #   called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route+ instead.
-      def routes(message)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "routes",
-          new_method: "is_expected.to route",
-        )
-        Matchers::Deprecated.new(self, :route, true, message)
-      end
-
-      # Starts a chat routing test chain, asserting that a message should not
-      # trigger a route.
-      # @param message [String] The message that should not trigger the route.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
-      #   called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route+ instead.
-      def does_not_route(message)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "does_not_route",
-          new_method: "is_expected.not_to route",
-        )
-        Matchers::Deprecated.new(self, :route, false, message)
-      end
-      alias_method :doesnt_route, :does_not_route
-
-      # Starts a chat routing test chain, asserting that a "command" message
-      # should trigger a route.
-      # @param message [String] The message that should trigger the route.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
-      #   called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_command+ instead.
-      def routes_command(message)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "routes_command",
-          new_method: "is_expected.to route_command",
-        )
-        Matchers::Deprecated.new(self, :route_command, true, message)
-      end
-
-      # Starts a chat routing test chain, asserting that a "command" message
-      # should not trigger a route.
-      # @param message [String] The message that should not trigger the route.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should have +to+
-      #   called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_command+ instead.
-      def does_not_route_command(message)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "does_not_route_command",
-          new_method: "is_expected.not_to route_command",
-        )
-        Matchers::Deprecated.new(self, :route_command, false, message)
-      end
-      alias_method :doesnt_route_command, :does_not_route_command
-
-      # Starts an HTTP routing test chain, asserting that a request to the given
-      # path with the given HTTP request method will trigger a route.
-      # @param http_method [Symbol] The HTTP request method that should trigger
-      #   the route.
-      # @param path [String] The path URL component that should trigger the
-      #   route.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should
-      #   have +to+ called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_http+ instead.
-      def routes_http(http_method, path)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "routes_http",
-          new_method: "is_expected.to route_http",
-        )
-        Matchers::Deprecated.new(self, :route_http, true, http_method, path)
-      end
-
-      # Starts an HTTP routing test chain, asserting that a request to the given
-      # path with the given HTTP request method will not trigger a route.
-      # @param http_method [Symbol] The HTTP request method that should not
-      #   trigger the route.
-      # @param path [String] The path URL component that should not trigger the
-      #   route.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that should
-      #   have +to+ called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_http+ instead.
-      def does_not_route_http(http_method, path)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "does_not_route_http",
-          new_method: "is_expected.not_to route_http",
-        )
-        Matchers::Deprecated.new(self, :route_http, false, http_method, path)
-      end
-      alias_method :doesnt_route_http, :does_not_route_http
-
-      # Starts an event subscription test chain, asserting that an event should
-      # trigger the target method.
-      # @param event_name [String, Symbol] The name of the event that should
-      #   be triggered.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that
-      #   should have +to+ called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_event+ instead.
-      def routes_event(event_name)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "routes_event",
-          new_method: "is_expected.to route_event",
-        )
-        Matchers::Deprecated.new(self, :route_event, true, event_name)
-      end
-
-      # Starts an event subscription test chain, asserting that an event should
-      # not trigger the target method.
-      # @param event_name [String, Symbol] The name of the event that should
-      #   not be triggered.
-      # @return [Matchers::Deprecated] A {Matchers::Deprecated} that
-      #   should have +to+ called on it to complete the test.
-      # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_event+ instead.
-      def does_not_route_event(event_name)
-        STDERR.puts I18n.t(
-          "lita.rspec.matcher_deprecated",
-          old_method: "does_not_route_event",
-          new_method: "is_expected.not_to route_event",
-        )
-        Matchers::Deprecated.new(self, :route_event, false, event_name)
-      end
-      alias_method :doesnt_route_event, :does_not_route_event
     end
   end
 end

data/lib/lita/rspec/matchers/deprecated.rb

@@ -1,6 +1,140 @@
 module Lita
   module RSpec
     module Matchers
+      module DeprecatedMethods
+        # 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 [Deprecated] A {Deprecated} that should have +to+
+        #   called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route+ instead.
+        def routes(message)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "routes",
+            new_method: "is_expected.to route",
+          )
+          Deprecated.new(self, :route, true, message)
+        end
+
+        # Starts a chat routing test chain, asserting that a message should not
+        # trigger a route.
+        # @param message [String] The message that should not trigger the route.
+        # @return [Deprecated] A {Deprecated} that should have +to+
+        #   called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route+ instead.
+        def does_not_route(message)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "does_not_route",
+            new_method: "is_expected.not_to route",
+          )
+          Deprecated.new(self, :route, false, message)
+        end
+        alias_method :doesnt_route, :does_not_route
+
+        # Starts a chat routing test chain, asserting that a "command" message
+        # should trigger a route.
+        # @param message [String] The message that should trigger the route.
+        # @return [Deprecated] A {Deprecated} that should have +to+
+        #   called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_command+ instead.
+        def routes_command(message)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "routes_command",
+            new_method: "is_expected.to route_command",
+          )
+          Deprecated.new(self, :route_command, true, message)
+        end
+
+        # Starts a chat routing test chain, asserting that a "command" message
+        # should not trigger a route.
+        # @param message [String] The message that should not trigger the route.
+        # @return [Deprecated] A {Deprecated} that should have +to+
+        #   called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_command+ instead.
+        def does_not_route_command(message)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "does_not_route_command",
+            new_method: "is_expected.not_to route_command",
+          )
+          Deprecated.new(self, :route_command, false, message)
+        end
+        alias_method :doesnt_route_command, :does_not_route_command
+
+        # Starts an HTTP routing test chain, asserting that a request to the given
+        # path with the given HTTP request method will trigger a route.
+        # @param http_method [Symbol] The HTTP request method that should trigger
+        #   the route.
+        # @param path [String] The path URL component that should trigger the
+        #   route.
+        # @return [Deprecated] A {Deprecated} that should
+        #   have +to+ called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_http+ instead.
+        def routes_http(http_method, path)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "routes_http",
+            new_method: "is_expected.to route_http",
+          )
+          Deprecated.new(self, :route_http, true, http_method, path)
+        end
+
+        # Starts an HTTP routing test chain, asserting that a request to the given
+        # path with the given HTTP request method will not trigger a route.
+        # @param http_method [Symbol] The HTTP request method that should not
+        #   trigger the route.
+        # @param path [String] The path URL component that should not trigger the
+        #   route.
+        # @return [Deprecated] A {Deprecated} that should
+        #   have +to+ called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_http+ instead.
+        def does_not_route_http(http_method, path)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "does_not_route_http",
+            new_method: "is_expected.not_to route_http",
+          )
+          Deprecated.new(self, :route_http, false, http_method, path)
+        end
+        alias_method :doesnt_route_http, :does_not_route_http
+
+        # Starts an event subscription test chain, asserting that an event should
+        # trigger the target method.
+        # @param event_name [String, Symbol] The name of the event that should
+        #   be triggered.
+        # @return [Deprecated] A {Deprecated} that
+        #   should have +to+ called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.to route_event+ instead.
+        def routes_event(event_name)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "routes_event",
+            new_method: "is_expected.to route_event",
+          )
+          Deprecated.new(self, :route_event, true, event_name)
+        end
+
+        # Starts an event subscription test chain, asserting that an event should
+        # not trigger the target method.
+        # @param event_name [String, Symbol] The name of the event that should
+        #   not be triggered.
+        # @return [Deprecated] A {Deprecated} that
+        #   should have +to+ called on it to complete the test.
+        # @deprecated Will be removed in Lita 5.0. Use +is_expected.not_to route_event+ instead.
+        def does_not_route_event(event_name)
+          STDERR.puts I18n.t(
+            "lita.rspec.matcher_deprecated",
+            old_method: "does_not_route_event",
+            new_method: "is_expected.not_to route_event",
+          )
+          Deprecated.new(self, :route_event, false, event_name)
+        end
+        alias_method :doesnt_route_event, :does_not_route_event
+      end
+
       # Lita 3 versions of the routing  matchers.
       # @deprecated Will be removed in Lita 5.0. Use the +is_expected+ forms instead.
       class Deprecated

data/lib/lita/template.rb

@@ -24,6 +24,15 @@ module Lita
     # @param source [String] A string to use as the template's content.
     def initialize(source)
       @erb = ERB.new(source, $SAFE, "<>")
+      self.helpers = Set.new
+    end
+
+    # Add a module of helpers methods to be added to the template evalutation context.
+    # @param helper [Module] The module to extend onto the template evalutation context.
+    # @return [void]
+    # @since 4.5.0
+    def add_helper(helper)
+      helpers << helper
     end
 
     # Render the template with the provided variables.
@@ -36,10 +45,14 @@ module Lita
 
     private
 
+    attr_accessor :helpers
+
     # Create an empty object to use as the ERB context and set any provided variables in it.
     def context_binding(variables)
       context = TemplateEvaluationContext.new
 
+      helpers.each { |helper| context.extend(helper) }
+
       variables.each do |k, v|
         context.instance_variable_set("@#{k}", v)
       end

data/lib/lita/version.rb

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

data/lita.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "bundler", ">= 1.3"
   spec.add_runtime_dependency "faraday", ">= 0.8.7"
-  spec.add_runtime_dependency "http_router", ">= 0.11.1"
+  spec.add_runtime_dependency "http_router", ">= 0.11.2"
   spec.add_runtime_dependency "ice_nine", ">= 0.11.0"
   spec.add_runtime_dependency "i18n", ">= 0.6.9"
   spec.add_runtime_dependency "multi_json", ">= 1.7.7"
@@ -38,5 +38,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 "rubocop", "~> 0.28.0"
+  spec.add_development_dependency "rubocop", "~> 0.33.0"
 end

data/spec/lita/handler/chat_router_spec.rb

@@ -81,6 +81,12 @@ describe handler, lita_handler: true do
       expect(replies).to be_empty
     end
 
+    it "triggers a :route_authorization_failed event when a user is not authorized" do
+      allow(robot).to receive(:trigger)
+      expect(robot).to receive(:trigger).with(:route_authorization_failed, anything)
+      send_message("admin")
+    end
+
     it "ignores messages from itself" do
       allow(user).to receive(:name).and_return(robot.name)
       send_message("message")
@@ -104,6 +110,11 @@ describe handler, lita_handler: true do
       end
     end
 
+    it "triggers a message_dispatched event" do
+      expect(robot).to receive(:trigger).with(:message_dispatched, anything)
+      send_message("message")
+    end
+
     it "raises exceptions in test mode" do
       expect { send_message("error") }.to raise_error(RuntimeError)
     end
@@ -181,8 +192,8 @@ describe handler, lita_handler: true do
 
   context "with another handler registered" do
     before do
-      registry.register_handler(:test_2)  do
-        route(/three/)  { |response| response.reply "got three" }
+      registry.register_handler(:test_2) do
+        route(/three/) { |response| response.reply "got three" }
       end
     end
 

data/spec/lita/handler/common_spec.rb

@@ -80,7 +80,7 @@ describe Lita::Handler::Common, lita: true do
 
     it "raises an exception if the handler doesn't have a name to derive the namespace from" do
       handler = Class.new { include Lita::Handler::Common }
-      expect { handler.namespace }.to raise_error
+      expect { handler.namespace }.to raise_error(RuntimeError, /must set a namespace/)
     end
   end
 
@@ -198,6 +198,29 @@ describe Lita::Handler::Common, lita: true do
     end
   end
 
+  describe "#render_template_with_helpers" do
+    before do
+      handler.template_root(File.expand_path(File.join("..", "..", "..", "templates"), __FILE__))
+    end
+
+    it "extends custom helpers into the template evaluation context" do
+      helpers = Module.new do
+        def reverse_name(first, last)
+          "#{last}, #{first}"
+        end
+      end
+
+      result = subject.render_template_with_helpers(
+        "helpers",
+        [helpers],
+        first: "Carl",
+        last: "Pug",
+      )
+
+      expect(result).to eq("Pug, Carl")
+    end
+  end
+
   describe "timer methods" do
     let(:queue) { Queue.new }
 

data/spec/lita/message_spec.rb

@@ -1,8 +1,10 @@
 require "spec_helper"
 
 describe Lita::Message do
+  let(:mention_name) { "LitaBot" }
+
   let(:robot) do
-    instance_double("Lita::Robot", name: "Lita", mention_name: "LitaBot", alias: ".")
+    instance_double("Lita::Robot", name: "Lita", mention_name: mention_name, alias: ".")
   end
 
   let(:source) { instance_double("Lita::Source") }
@@ -39,31 +41,66 @@ describe Lita::Message do
   end
 
   describe "#command?" do
-    it "is true when the message is addressed to the Robot" do
-      subject = described_class.new(
-        robot,
-        "#{robot.mention_name}: hello",
-        source
-      )
-      expect(subject).to be_a_command
+    context "when the message is addressed to the robot" do
+      subject { described_class.new(robot, "#{robot.mention_name}: hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
     end
 
-    it "is true when the Robot's name is capitalized differently" do
-      subject = described_class.new(
-        robot,
-        "#{robot.mention_name.upcase}: hello",
-        source
-      )
-      expect(subject).to be_a_command
+    context "when the message is addressed to the robot with different capitalization" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase}: hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
     end
 
-    it "is true when the Robot's alias is used" do
-      subject = described_class.new(
-        robot,
-        "#{robot.alias}hello",
-        source
-      )
-      expect(subject).to be_a_command
+    context "when the message is addressed to the robot with a comma" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase}, hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the robot with no trailing punctuation" do
+      subject { described_class.new(robot, "#{robot.mention_name.upcase} hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the bot via alias with no space after it" do
+      subject { described_class.new(robot, "#{robot.alias}hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message is addressed to the bot via alias with space after it" do
+      subject { described_class.new(robot, "#{robot.alias} hello", source) }
+
+      it "is true" do
+        expect(subject).to be_a_command
+      end
+    end
+
+    context "when the message incidentally starts with the mention name" do
+      let(:mention_name) { "sa" }
+
+      subject { described_class.new(robot, "salmon", source) }
+
+      it "is false" do
+        expect(subject).not_to be_a_command
+      end
+
+      it "does not affect the message body" do
+        expect(subject.body).to eq("salmon")
+      end
     end
 
     it "is false when the message is not addressed to the Robot" do
@@ -78,6 +115,20 @@ describe Lita::Message do
     end
   end
 
+  describe "#room_object" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:room_object)
+      subject.room_object
+    end
+  end
+
+  describe "#private_message?" do
+    it "delegates to #source" do
+      expect(subject.source).to receive(:private_message?)
+      subject.private_message?
+    end
+  end
+
   describe "#reply" do
     it "sends strings back to the source through the robot" do
       expect(robot).to receive(:send_messages).with(source, "foo", "bar")

data/spec/lita/response_spec.rb

@@ -36,4 +36,25 @@ describe Lita::Response do
       expect(subject.extensions[:foo]).to eq(:bar)
     end
   end
+
+  describe "#user" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:user)
+      subject.user
+    end
+  end
+
+  describe "#room" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:room_object)
+      subject.room
+    end
+  end
+
+  describe "#private_message?" do
+    it "delegates to #message" do
+      expect(subject.message).to receive(:private_message?)
+      subject.private_message?
+    end
+  end
 end

data/spec/lita/rspec_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 
 handler_class = Class.new(Lita::Handler) do
   route(/^message$/, :message)
+  route(/^channel$/, :channel)
   route(/^command$/, :command, command: true)
   route("restricted", :restricted, restrict_to: :some_group)
   route("admins only", :admins_only, restrict_to: :admins)
@@ -14,6 +15,15 @@ handler_class = Class.new(Lita::Handler) do
     response.reply(response.user.name)
   end
 
+  def channel(response)
+    if (room = response.message.source.room_object)
+      response.reply(room.id)
+      response.reply(room.name)
+    else
+      response.reply("No room")
+    end
+  end
+
   def command(response)
     response.reply("a", "command")
   end
@@ -39,6 +49,12 @@ describe handler_class, lita_handler: true do
     it { is_expected.not_to route("message").to(:not_a_message) }
   end
 
+  describe "routing channels" do
+    it { is_expected.to route("channel") }
+    it { is_expected.to route("channel").to(:channel) }
+    it { is_expected.not_to route("channel").to(:not_a_channel) }
+  end
+
   describe "routing commands" do
     it { is_expected.to route_command("command") }
     it { is_expected.not_to route("command") }
@@ -94,6 +110,18 @@ describe handler_class, lita_handler: true do
     end
   end
 
+  describe "#channel" do
+    it "replies with channel id if sent from room" do
+      room = Lita::Room.create_or_update(1, name: "Room")
+      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 "#command" do
     it "replies with two strings" do
       send_command("command")

data/spec/lita/template_spec.rb

@@ -13,6 +13,23 @@ describe Lita::Template do
     end
   end
 
+  describe "#add_helper" do
+    subject { described_class.new("<%= reverse_name(@first, @last) %>") }
+    let(:helper) do
+      Module.new do
+        def reverse_name(first, last)
+          "#{last}, #{first}"
+        end
+      end
+    end
+
+    it "adds the helper to the evaluation context" do
+      subject.add_helper(helper)
+
+      expect(subject.render(first: "Carl", last: "Pug")).to eq("Pug, Carl")
+    end
+  end
+
   describe "#render" do
     context "with a static source template" do
       subject { described_class.new("Hello, Lita!") }

data/spec/lita_spec.rb

@@ -158,9 +158,9 @@ describe Lita do
 
     before do
       allow_any_instance_of(Lita::Robot).to receive(:run)
-      allow(Lita::ConfigurationValidator).to receive(:new).with(described_class).and_return(
-        validator
-       )
+      allow(
+        Lita::ConfigurationValidator
+      ).to receive(:new).with(described_class).and_return(validator)
     end
 
     after { described_class.reset }

data/spec/templates/helpers.erb

@@ -0,0 +1 @@
+<%= reverse_name(@first, @last) %>

data/templates/plugin/lib/lita/plugin_type/plugin.tt

@@ -1,16 +1,17 @@
 module Lita
   module <%= config[:constant_namespace] %>
     class <%= config[:constant_name] %><% unless config[:plugin_type] == "extension" %> < <%= config[:plugin_type].capitalize %><% end %>
-    end
+      # insert <%= config[:plugin_type] %> code here
 
-    <%- if config[:plugin_type] == "adapter" -%>
-    Lita.register_adapter(:<%= config[:name] %>, <%= config[:constant_name] %>)
-    <%- elsif config[:plugin_type] == "handler" -%>
-    Lita.register_handler(<%= config[:constant_name] %>)
-    <%- else -%>
-    # If your extension needs to register with a Lita hook, uncomment the
-    # following line and change the hook name to the appropriate value:
-    # Lita.register_hook(:hook_name, <%= config[:constant_name] %>)
-    <%- end -%>
+      <%- if config[:plugin_type] == "adapter" -%>
+      Lita.register_adapter(:<%= config[:name] %>, self)
+      <%- elsif config[:plugin_type] == "handler" -%>
+      Lita.register_handler(self)
+      <%- else -%>
+      # If your extension needs to register with a Lita hook, uncomment the
+      # following line and change the hook name to the appropriate value:
+      # Lita.register_hook(:hook_name, self)
+      <%- end -%>
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita
 version: !ruby/object:Gem::Version
-  version: 4.4.3
+  version: 4.5.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-12 00:00:00.000000000 Z
+date: 2015-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.1
+        version: 0.11.2
 - !ruby/object:Gem::Dependency
   name: ice_nine
   requirement: !ruby/object:Gem::Requirement
@@ -254,14 +254,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.0
+        version: 0.33.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.28.0
+        version: 0.33.0
 description: ChatOps for Ruby.
 email:
 - jimmy@jimmycuadra.com
@@ -368,6 +368,7 @@ files:
 - spec/spec_helper.rb
 - spec/templates/basic.erb
 - spec/templates/basic.irc.erb
+- spec/templates/helpers.erb
 - spec/templates/interpolated.erb
 - templates/locales/en.yml
 - templates/plugin/Gemfile
@@ -404,7 +405,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: ChatOps framework for Ruby. Lita is a robot companion for your chat room.
@@ -446,5 +447,5 @@ test_files:
 - spec/spec_helper.rb
 - spec/templates/basic.erb
 - spec/templates/basic.irc.erb
+- spec/templates/helpers.erb
 - spec/templates/interpolated.erb
-has_rdoc: