lita 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b317185fd4bf51c66e01de3aef18547d27d154ef
-  data.tar.gz: 0ee25a799c8b033fb82e0e58fe3654ebaf974eea
+  metadata.gz: 68d6c55cacef1663c210df90ff03f764bca2c3b3
+  data.tar.gz: 4696fa739de19bb0a0245fd855666fe6a5622f31
 SHA512:
-  metadata.gz: 23c70beb7798a316f725225c17a0b75f8e0fdd2d104e9d9f4c611ae6c423300810adb1c1a9805629287a0db1d27b60071779bd4bf7ecebfbef302a3fde3623f3
-  data.tar.gz: 0498b930d44e0057058a25df985b8117d97de953f76ed89c414c7902482f889db1333b4376665aab01409f60fbcc55ae6fb3159594432cbfac0944b4bd8c9168
+  metadata.gz: 7701c02aa161e08559b50e1133ea1227cc79d53f4278a772ef274b090fceb9a9bad22a317263f067adfe036a336fc6d3ba6d0a546b014387e12f49cf46d52ec7
+  data.tar.gz: b4b212cee5587adaf06f0ad8944715b9653a678f041e18d71258bbc4d52864f5cf575c3fb010161325153a42d6bde5271f722202383c5a3ca48b035e2685d204

data/.rubocop.yml

@@ -18,10 +18,14 @@ LineLength:
   Max: 100
 MethodLength:
   Enabled: false
+RegexpLiteral:
+  Enabled: false
 RescueException:
   Enabled: false
 SignalException:
   Enabled: false
+SpecialGlobalVars:
+  Enabled: false
 StringLiterals:
   EnforcedStyle: double_quotes
 TrailingComma:

data/README.md

@@ -5,8 +5,6 @@
 [![Code Climate](https://codeclimate.com/github/jimmycuadra/lita.png)](https://codeclimate.com/github/jimmycuadra/lita)
 [![Coverage Status](https://coveralls.io/repos/jimmycuadra/lita/badge.png)](https://coveralls.io/r/jimmycuadra/lita)
 
-![Lita](http://f.cl.ly/items/0c271a2P3k2V180B1R0X/lita.jpg)
-
 **Lita** is a chat bot written in [Ruby](https://www.ruby-lang.org/) with persistent storage provided by [Redis](http://redis.io/). It uses a plugin system to connect to different chat services and to provide new behavior. The plugin system uses the familiar tools of the Ruby ecosystem: [RubyGems](https://rubygems.org/) and [Bundler](http://gembundler.com/).
 
 Automate your business and have fun with your very own robot companion.

data/lib/lita.rb

@@ -26,27 +26,6 @@ module Lita
       @adapters ||= {}
     end
 
-    # Adds an adapter to the global registry under the provided key.
-    # @param key [String, Symbol] The key that identifies the adapter.
-    # @param adapter [Lita::Adapter] The adapter class.
-    # @return [void]
-    def register_adapter(key, adapter)
-      adapters[key.to_sym] = adapter
-    end
-
-    # The global registry of handlers.
-    # @return [Set] The set of handlers.
-    def handlers
-      @handlers ||= Set.new
-    end
-
-    # Adds a handler to the global registry.
-    # @param handler [Lita::Handler] The handler class.
-    # @return [void]
-    def register_handler(handler)
-      handlers << handler
-    end
-
     # The global configuration object. Provides user settings for the robot.
     # @return [Lita::Config] The Lita configuration object.
     def config
@@ -61,11 +40,17 @@ module Lita
       yield config
     end
 
-    # Clears the global configuration object. The next call to {Lita.config}
-    # will create a fresh config object.
-    # @return [void]
-    def clear_config
-      @config = nil
+    # The global registry of handlers.
+    # @return [Set] The set of handlers.
+    def handlers
+      @handlers ||= Set.new
+    end
+
+    # The global registry of hook handler objects.
+    # @return [Hash] A hash mapping hook names to sets of objects that handle them.
+    # @since 3.2.0
+    def hooks
+      @hooks ||= Hash.new { |h, k| h[k] = Set.new }
     end
 
     # The global Logger object.
@@ -83,10 +68,72 @@ module Lita
       end
     end
 
+    # Adds an adapter to the global registry under the provided key.
+    # @param key [String, Symbol] The key that identifies the adapter.
+    # @param adapter [Lita::Adapter] The adapter class.
+    # @return [void]
+    def register_adapter(key, adapter)
+      adapters[key.to_sym] = adapter
+    end
+
+    # Adds a handler to the global registry.
+    # @param handler [Lita::Handler] The handler class.
+    # @return [void]
+    def register_handler(handler)
+      handlers << handler
+    end
+
+    # Adds a hook handler object to the global registry for the given hook.
+    # @return [void]
+    # @since 3.2.0
+    def register_hook(name, hook)
+      hooks[name.to_s.downcase.strip.to_sym] << hook
+    end
+
+    # Clears the global configuration object and the global adapter, handler, and hook registries.
+    # @return [void]
+    # @since 3.2.0
+    def reset
+      reset_adapters
+      reset_config
+      reset_handlers
+      reset_hooks
+    end
+
+    # Resets the global adapter registry, removing all registered adapters.
+    # @return [void]
+    # @since 3.2.0
+    def reset_adapters
+      @adapters = nil
+    end
+
+    # Resets the global configuration object. The next call to {Lita.config}
+    # will create a fresh config object.
+    # @return [void]
+    def reset_config
+      @config = nil
+    end
+    alias_method :clear_config, :reset_config
+
+    # Resets the global handler registry, removing all registered handlers.
+    # @return [void]
+    # @since 3.2.0
+    def reset_handlers
+      @handlers = nil
+    end
+
+    # Resets the global hooks registry, removing all registered hook handlers.
+    # @return [void]
+    # @since 3.2.0
+    def reset_hooks
+      @hooks = nil
+    end
+
     # Loads user configuration and starts the robot.
     # @param config_path [String] The path to the user configuration file.
     # @return [void]
     def run(config_path = nil)
+      hooks[:before_run].each { |hook| hook.call(config_path: config_path) }
       Config.load_user_config(config_path)
       Lita.config.finalize
       self.locale = Lita.config.robot.locale
@@ -112,6 +159,7 @@ require_relative "lita/robot"
 require_relative "lita/adapter"
 require_relative "lita/adapters/shell"
 require_relative "lita/handler"
+require_relative "lita/route_validator"
 require_relative "lita/handlers/authorization"
 require_relative "lita/handlers/help"
 require_relative "lita/handlers/info"

data/lib/lita/adapter.rb

@@ -89,7 +89,7 @@ module Lita
     # @return [void]
     # @abstract This should be implemented by the adapter.
     [:join, :part, :run, :send_messages, :set_topic, :shut_down].each do |method|
-      define_method(method) do |*args|
+      define_method(method) do
         Lita.logger.warn(I18n.t("lita.adapter.method_not_implemented", method: method))
       end
     end

data/lib/lita/adapters/shell.rb

@@ -20,7 +20,7 @@ module Lita
       #   shell environment.
       # @param strings [Array<String>] An array of strings to output.
       # @return [void]
-      def send_messages(target, strings)
+      def send_messages(_target, strings)
         strings = Array(strings)
         strings.reject! { |string| string.empty? }
         unless RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ || !$stdout.tty?

data/lib/lita/cli.rb

@@ -99,6 +99,14 @@ module Lita
       generate_templates(generate_config(name, "handler"))
     end
 
+    desc "extension NAME", "Generates a new Lita extension"
+    # Generates a new Lita extension.
+    # @param name [String] The name for the new extension.
+    # @return [void]
+    def extension(name)
+      generate_templates(generate_config(name, "extension"))
+    end
+
     desc "version", "Outputs the current version of Lita"
     # Outputs the current version of Lita.
     # @return [void]

data/lib/lita/handler.rb

@@ -17,7 +17,8 @@ module Lita
       :method_name,
       :command,
       :required_groups,
-      :help
+      :help,
+      :extensions
     )
       alias_method :command?, :command
     end
@@ -32,10 +33,19 @@ module Lita
       # @param restrict_to [Array<Symbol, String>, nil] A list of authorization
       #   groups the user must be in to trigger the route.
       # @param help [Hash] A map of example invocations to descriptions.
+      # @param extensions [Hash] Aribtrary additional data that can be used by Lita extensions.
       # @return [void]
-      def route(pattern, method, command: false, restrict_to: nil, help: {})
-        groups = restrict_to.nil? ? nil : Array(restrict_to)
-        routes << Route.new(pattern, method, command, groups, help)
+      def route(pattern, method, **options)
+        options = default_route_options.merge(options)
+        options[:restrict_to] = options[:restrict_to].nil? ? nil : Array(options[:restrict_to])
+        routes << Route.new(
+          pattern,
+          method,
+          options.delete(:command),
+          options.delete(:restrict_to),
+          options.delete(:help),
+          options
+        )
       end
 
       # A list of chat routes defined by the handler.
@@ -57,10 +67,9 @@ module Lita
           log_dispatch(route)
 
           begin
-            new(robot).public_send(
-              route.method_name,
-              Response.new(message, route.pattern)
-            )
+            response = Response.new(message, route.pattern)
+            Lita.hooks[:trigger_route].each { |hook| hook.call(response: response, route: route) }
+            new(robot).public_send(route.method_name, response)
           rescue Exception => e
             log_dispatch_error(e)
             raise e if rspec_loaded?
@@ -133,6 +142,14 @@ module Lita
 
       private
 
+      def default_route_options
+        {
+          command: false,
+          restrict_to: nil,
+          help: {}
+        }
+      end
+
       # A hash of arrays used to store event subscriptions registered with {on}.
       def event_subscriptions
         @event_subscriptions ||= Hash.new { |h, k| h[k] = [] }
@@ -140,19 +157,7 @@ module Lita
 
       # Determines whether or not an incoming messages should trigger a route.
       def route_applies?(route, message, robot)
-        # Message must be a command if the route requires a command
-        return if route.command? && !message.command?
-
-        # Messages from self should be ignored to prevent infinite loops
-        return if message.user.name == robot.name
-
-        # Message must match the pattern
-        return unless route.pattern === message.body
-
-        # User must be in auth group if route is restricted
-        return unless authorized?(message.user, route.required_groups)
-
-        true
+        RouteValidator.new(route, message, robot).call
       end
 
       # Checks if RSpec is loaded. If so, assume we are testing and let handler
@@ -161,13 +166,6 @@ module Lita
         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 I18n.t(
@@ -206,6 +204,13 @@ module Lita
       Thread.new { Timer.new(interval: interval, &block).start }
     end
 
+    # The handler's config object.
+    # @return [Lita::Config] The handler's config object.
+    # @since 3.2.0
+    def config
+      Lita.config.handlers[self.class.namespace]
+    end
+
     # Invokes the given block repeatedly, waiting the given number of seconds between each
     # invocation.
     # @param interval [Integer] The number of seconds to wait before each invocation of the block.
@@ -227,6 +232,13 @@ module Lita
       Faraday::Connection.new(nil, options, &block)
     end
 
+    # The Lita logger.
+    # @return [Lita::Logger] The Lita logger.
+    # @since 3.2.0
+    def log
+      Lita.logger
+    end
+
     # @see .translate
     def translate(*args)
       self.class.translate(*args)

data/lib/lita/handlers/authorization.rb

@@ -88,7 +88,7 @@ module Lita
 
       def valid_group?(response, identifier)
         unless identifier && @group
-          response.reply "#{t('format')}: #{robot.name} auth add USER GROUP"
+          response.reply "#{t("format")}: #{robot.name} auth add USER GROUP"
           return
         end
 

data/lib/lita/handlers/info.rb

@@ -21,7 +21,7 @@ module Lita
       # @param request [Rack::Request] The HTTP request.
       # @param response [Rack::Response] The HTTP response.
       # @return [void]
-      def web(request, response)
+      def web(_request, response)
         response.headers["Content-Type"] = "application/json"
         json = MultiJson.dump(
           lita_version: Lita::VERSION,

data/lib/lita/logger.rb

@@ -9,7 +9,7 @@ module Lita
       def get_logger(level)
         logger = ::Logger.new(STDERR)
         logger.level = get_level_constant(level)
-        logger.formatter = proc do |severity, datetime, progname, msg|
+        logger.formatter = proc do |severity, datetime, _progname, msg|
           "[#{datetime.utc}] #{severity}: #{msg}\n"
         end
         logger

data/lib/lita/response.rb

@@ -8,6 +8,11 @@ module Lita
     # @return [Lita::Message] The message.
     attr_accessor :message
 
+    # A hash of arbitrary data that can be populated by Lita extensions.
+    # @return [Hash] The extensions data.
+    # @since 3.2.0
+    attr_accessor :extensions
+
     # The pattern the incoming message matched.
     # @return [Regexp] The pattern.
     attr_accessor :pattern
@@ -29,6 +34,7 @@ module Lita
     # @param pattern [Regexp] The pattern the incoming message matched.
     def initialize(message, pattern)
       self.message = message
+      self.extensions = {}
       self.pattern = pattern
     end
 

data/lib/lita/route_validator.rb

@@ -0,0 +1,63 @@
+module Lita
+  # Determines if an incoming message should trigger a route.
+  # @api private
+  class RouteValidator
+    # The incoming message.
+    attr_reader :message
+
+    # The currently running robot.
+    attr_reader :robot
+
+    # The route being checked.
+    attr_reader :route
+
+    def initialize(route, message, robot)
+      @route = route
+      @message = message
+      @robot = robot
+    end
+
+    # Returns a boolean indicating whether or not the route should be triggered.
+    # @return [Boolean] Whether or not the route should be triggered.
+    def call
+      return unless passes_route_hooks?(route, message, robot)
+      return unless command_satisfied?(route, message)
+      return if from_self?(message, robot)
+      return unless matches_pattern?(route, message)
+      return unless authorized?(message.user, route.required_groups)
+
+      true
+    end
+
+    private
+
+    # Message must be a command if the route requires a command
+    def command_satisfied?(route, message)
+      !route.command? || message.command?
+    end
+
+    # Messages from self should be ignored to prevent infinite loops
+    def from_self?(message, robot)
+      message.user.name == robot.name
+    end
+
+    # Message must match the pattern
+    def matches_pattern?(route, message)
+      route.pattern === message.body
+    end
+
+    # Allow custom route hooks to reject the route
+    def passes_route_hooks?(route, message, robot)
+      Lita.hooks[:validate_route].all? do |hook|
+        hook.call(route: route, message: message, robot: robot)
+      end
+    end
+
+    # User must be in auth group if route is restricted.
+    def authorized?(user, required_groups)
+      required_groups.nil? || required_groups.any? do |group|
+        Authorization.user_in_group?(user, group)
+      end
+    end
+  end
+end

data/lib/lita/rspec/handler.rb

@@ -43,7 +43,7 @@ module Lita
           base.class_eval do
             before do
               [:send_messages, :send_message].each do |message|
-                allow(robot).to receive(message) do |target, *strings|
+                allow(robot).to receive(message) do |_target, *strings|
                   replies.concat(strings)
                 end
               end

data/lib/lita/util.rb

@@ -22,7 +22,7 @@ module Lita
         word = camel_cased_word.to_s.dup
         word.gsub!("::", "/")
         word.gsub!(/(?:([A-Za-z\d])|^)(#{ACRONYM_REGEX})(?=\b|[^a-z])/) do
-          "#{Regexp.last_match[1]}#{Regexp.last_match[1] && '_'}#{Regexp.last_match[2].downcase}"
+          "#{Regexp.last_match[1]}#{Regexp.last_match[1] && "_"}#{Regexp.last_match[2].downcase}"
         end
         word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
         word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')

data/lib/lita/version.rb

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

data/lita.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Lita::VERSION
   spec.authors       = ["Jimmy Cuadra"]
   spec.email         = ["jimmy@jimmycuadra.com"]
-  spec.description   = %q{A multi-service chat bot with extendable behavior.}
-  spec.summary       = %q{A multi-service chat bot with extendable behavior.}
+  spec.description   = %q(A multi-service chat bot with extendable behavior.)
+  spec.summary       = %q(A multi-service chat bot with extendable behavior.)
   spec.homepage      = "https://github.com/jimmycuadra/lita"
   spec.license       = "MIT"
 
@@ -36,5 +36,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"
+  spec.add_development_dependency "rubocop", "~> 0.21.0"
 end

data/spec/lita/handler_spec.rb

@@ -12,38 +12,70 @@ describe Lita::Handler, lita: true do
 
   let(:queue) { Queue.new }
 
+  let(:guard_hook) do
+    Class.new do
+      def self.call(payload)
+        if payload[:route].extensions[:guard]
+          payload[:message].body.include?("code word")
+        else
+          true
+        end
+      end
+    end
+  end
+
+  let(:response_hook) do
+    Class.new do
+      def self.call(payload)
+        payload[:response].extensions[:data] = payload[:route].extensions[:data]
+      end
+    end
+  end
+
   let(:handler_class) do
     Class.new(described_class) do
       route(/\w{3}/, :foo)
       route(/\w{4}/, :blah, command: true)
       route(/secret/, :secret, restrict_to: :admins)
       route(/danger/, :danger)
+      route(/guard/, :guard, guard: true)
+      route(/trigger route hook/, :trigger_route_hook, data: :foo)
 
       on :connected, :greet
       on :some_hook, :test_payload
 
-      def foo(response)
+      def self.default_config(config)
+        config.foo = "bar"
       end
 
-      def blah(response)
+      def foo(_response)
       end
 
-      def secret(response)
+      def blah(_response)
       end
 
-      def danger(response)
+      def secret(_response)
+      end
+
+      def danger(_response)
         raise "The developer of this handler's got a bug in their code!"
       end
 
+      def guard(_response)
+      end
+
+      def trigger_route_hook(_response)
+      end
+
       def greet(payload)
         robot.send_message("Hi, #{payload[:name]}! Lita has started!")
       end
 
-      def after_test(response, queue)
-        after(2) { |timer| queue.push("Waited 2 seconds!") }
+      def after_test(_response, queue)
+        after(2) { queue.push("Waited 2 seconds!") }
       end
 
-      def every_test(response, queue)
+      def every_test(_response, queue)
         array = [1, 2, 3]
 
         every(2) do |timer|
@@ -138,6 +170,36 @@ describe Lita::Handler, lita: true do
       allow(message).to receive(:body).and_return("#{robot.name}: danger")
       expect { handler_class.dispatch(robot, message) }.to raise_error
     end
+
+    context "with a custom validate_route hook" do
+      before { Lita.register_hook(:validate_route, guard_hook) }
+      after { Lita.reset_hooks }
+
+      it "matches if the hook returns true" do
+        allow(message).to receive(:body).and_return("guard code word")
+        expect_any_instance_of(handler_class).to receive(:guard)
+        handler_class.dispatch(robot, message)
+      end
+
+      it "does not match if the hook returns false" do
+        allow(message).to receive(:body).and_return("guard")
+        expect_any_instance_of(handler_class).not_to receive(:guard)
+        handler_class.dispatch(robot, message)
+      end
+    end
+
+    context "with a custom trigger_route hook" do
+      before { Lita.register_hook(:trigger_route, response_hook) }
+      after { Lita.reset_hooks }
+
+      it "adds data to the response's extensions" do
+        allow(message).to receive(:body).and_return("trigger route hook")
+        allow_any_instance_of(handler_class).to receive(:trigger_route_hook) do |_robot, response|
+          expect(response.extensions[:data]).to eq(:foo)
+        end
+        handler_class.dispatch(robot, message)
+      end
+    end
   end
 
   describe ".namespace" do
@@ -171,6 +233,19 @@ describe Lita::Handler, lita: true do
     end
   end
 
+  describe "#config" do
+    before { Lita.register_handler(handler_class) }
+    subject { handler_class.new(robot) }
+
+    it "returns a Lita config" do
+      expect(subject.config).to be_a(Lita::Config)
+    end
+
+    it "contains the handler's config settings" do
+      expect(subject.config.foo).to eq("bar")
+    end
+  end
+
   describe "#http" do
     it "returns a Faraday connection" do
       expect(subject.http).to be_a(Faraday::Connection)
@@ -194,6 +269,12 @@ describe Lita::Handler, lita: true do
     end
   end
 
+  describe "#log" do
+    it "returns the Lita logger" do
+      expect(subject.log).to eq(Lita.logger)
+    end
+  end
+
   describe "timer methods" do
     let(:response) { instance_double("Lita::Response") }
 

data/spec/lita/rack_app_spec.rb

@@ -10,7 +10,7 @@ describe Lita::RackApp do
       http.get ":var/otherwise/identical/path", :constraint, var: /\d+/
       http.get ":var/otherwise/identical/path", :no_constraint
 
-      def web(request, response)
+      def web(_request, response)
         response.write("it worked")
       end
 
@@ -24,11 +24,11 @@ describe Lita::RackApp do
         response.write(segments.join("/"))
       end
 
-      def constraint(request, response)
+      def constraint(_request, response)
         response.write("constraint")
       end
 
-      def no_constraint(request, response)
+      def no_constraint(_request, response)
         response.write("no constraint")
       end
 

data/spec/lita/response_spec.rb

@@ -28,4 +28,12 @@ describe Lita::Response do
       subject.match_data
     end
   end
+
+  describe "#extensions" do
+    it "can be populated with arbitrary data" do
+      subject.extensions[:foo] = :bar
+
+      expect(subject.extensions[:foo]).to eq(:bar)
+    end
+  end
 end

data/spec/lita/rspec_spec.rb

@@ -17,13 +17,13 @@ handler_class = Class.new(Lita::Handler) do
     response.reply "bongo", "wongo"
   end
 
-  def restricted(response)
+  def restricted(_response)
   end
 
-  def web(request, response)
+  def web(_request, _response)
   end
 
-  def greet(payload)
+  def greet(_payload)
   end
 
   def self.name

data/spec/lita_spec.rb

@@ -1,11 +1,20 @@
 require "spec_helper"
 
 describe Lita do
+  before { described_class.register_adapter(:shell, Lita::Adapters::Shell) }
+
   it "memoizes a Config" do
     expect(described_class.config).to be_a(Lita::Config)
     expect(described_class.config).to eql(described_class.config)
   end
 
+  it "keeps track of registered hooks" do
+    hook = double("hook")
+    described_class.register_hook("Foo ", hook)
+    described_class.register_hook(:foO, hook)
+    expect(described_class.hooks[:foo]).to eq(Set.new([hook]))
+  end
+
   describe ".configure" do
     it "yields the Config object" do
       described_class.configure { |c| c.robot.name = "Not Lita" }
@@ -57,12 +66,48 @@ describe Lita do
     end
   end
 
+  describe ".reset" do
+    it "clears the config" do
+      described_class.config.robot.name = "Foo"
+      described_class.reset
+      expect(described_class.config.robot.name).to eq("Lita")
+    end
+
+    it "clears adapters" do
+      described_class.register_adapter(:foo, double)
+      described_class.reset
+      expect(described_class.adapters).to be_empty
+    end
+
+    it "clears handlers" do
+      described_class.register_handler(double)
+      described_class.reset
+      expect(described_class.handlers).to be_empty
+    end
+
+    it "clears hooks" do
+      described_class.register_hook(:foo, double)
+      described_class.reset
+      expect(described_class.hooks).to be_empty
+    end
+  end
+
   describe ".run" do
-    before { Lita.config }
+    let(:hook) { double("Hook") }
+
+    before do
+      allow_any_instance_of(Lita::Robot).to receive(:run)
+    end
 
     it "runs a new Robot" do
       expect_any_instance_of(Lita::Robot).to receive(:run)
       described_class.run
     end
+
+    it "calls before_run hooks" do
+      described_class.register_hook(:before_run, hook)
+      expect(hook).to receive(:call).with(config_path: "path/to/config")
+      described_class.run("path/to/config")
+    end
   end
 end

data/spec/spec_helper.rb

@@ -14,8 +14,8 @@ require "lita/rspec"
 RSpec.configure do |config|
   config.mock_with :rspec do |mocks_config|
     mocks_config.verify_doubled_constant_names = true
-    # Enable config option this when a new rspec-mocks beta including this patch is released:
-    # https://github.com/rspec/rspec-mocks/pull/466
+    # Enable config option when a new rspec-mocks beta including this patch is released:
+    # https://github.com/rspec/rspec-mocks/pull/615
     #
     # mocks_config.verify_partial_doubles = true
   end

data/templates/plugin/README.tt

@@ -4,16 +4,26 @@ TODO: Add a description of the plugin.
 
 ## Installation
 
+<%- if config[:plugin_type] == "extension" -%>
+Add <%= config[:gem_name] %> to your Lita plugin's gemspec:
+
+``` ruby
+spec.add_runtime_dependency "<%= config[:gem_name] %>"
+```
+<%- else -%>
 Add <%= config[:gem_name] %> to your Lita instance's Gemfile:
 
 ``` ruby
 gem "<%= config[:gem_name] %>"
 ```
+<%- end -%>
 
+<%- unless config[:plugin_type] == "extension" %>
 ## Configuration
 
 TODO: Describe any configuration attributes the plugin exposes.
 
+<%- end -%>
 ## Usage
 
 TODO: Describe the plugin's features and how to use them.

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

@@ -1,12 +1,16 @@
 module Lita
   module <%= config[:constant_namespace] %>
-    class <%= config[:constant_name] %> < <%= config[:plugin_type].capitalize %>
+    class <%= config[:constant_name] %><% unless config[:plugin_type] == "extension" %> < <%= config[:plugin_type].capitalize %><% end %>
     end
 
     <%- if config[:plugin_type] == "adapter" -%>
     Lita.register_adapter(:<%= config[:name] %>, <%= config[:constant_name] %>)
-    <%- else -%>
+    <%- 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 -%>
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Jimmy Cuadra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-11 00:00:00.000000000 Z
+date: 2014-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -224,16 +224,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.21.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.21.0
 description: A multi-service chat bot with extendable behavior.
 email:
 - jimmy@jimmycuadra.com
@@ -270,6 +270,7 @@ files:
 - lib/lita/rack_app.rb
 - lib/lita/response.rb
 - lib/lita/robot.rb
+- lib/lita/route_validator.rb
 - lib/lita/rspec.rb
 - lib/lita/rspec/handler.rb
 - lib/lita/rspec/matchers/event_subscription_matcher.rb