lita 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b75112b772520840f9fa41dd68bd92950b4e6714
+  data.tar.gz: 567d841b587ec14f27a958a27081c384ca0a2c3f
+SHA512:
+  metadata.gz: 5fc9e89ef72af2fd35c8b859baa2c67fec936cfc4faf899bf413ae4f5bf2abda4b2bcb1087b83228f7fdd73008743b2f3e5f99fddfc8a81b709a9e21ebbb8946
+  data.tar.gz: 0ec04ae916a4adfdce35b6f9761a7a8634bdf3e511921ba8486e82081c73fb4da0f6848bb0accaa94d3cd1eee443bb2618c5d9976dedfc84d533caa221cf9f3e

data/.gitignore

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

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,77 @@
+# Lita
+
+[![Build Status](https://travis-ci.org/jimmycuadra/lita.png)](https://travis-ci.org/jimmycuadra/lita)
+[![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** is a chat bot written in Ruby with persistent storage provided by [Redis](http://redis.io/). It can connect to any chat service (given that there is an [adapter](#adapters) available for it) and can have new behavior added via [handlers](#handlers). The plugin system is managed with regular RubyGems and [Bundler](http://gembundler.com/).
+
+Automate your business and have fun with your very own robot companion.
+
+## Dependencies
+
+* Ruby 2.0
+* Redis
+
+## Installation
+
+First, install the gem with `gem install lita`. This gives you access to the `lita` commmand. Run `lita help` to list available tasks.
+
+Generate a new Lita instance by running `lita new NAME`. This will create a new directory called NAME (defaults to "lita") with a Gemfile and Lita configuration file.
+
+## Usage
+
+To start your Lita instance, simply run `bundle exec lita`. This will load up all the plugins (adapters and handlers) declared in your Gemfile, load any configuration you've defined (more on that later) and start the bot.
+
+## Adapters
+
+The core Lita gem by itself doesn't do much. To make real use of it, you'll want to install an adapter gem to allow Lita to connect to the chat service of your choice. Find the gem for the service you want to use on [the list of adapters](https://github.com/jimmycuadra/lita/wiki/Adapters), then add it to your Gemfile. For example:
+
+``` ruby
+gem "lita-hipchat"
+```
+
+Adapters will likely require some configuration to be able to connect. See the documentation for the adapter for details.
+
+Without installing an adapter, you can use the default shell adapter to chat with Lita in your terminal. Lita doesn't respond to any messages by default, however, so you'll want to add some new behavior to Lita via handlers.
+
+## Handlers
+
+Handlers are gems that add new behavior to Lita. They are responsible for listening for incoming messages and responding to them appropriately. Find the handler gems you want for your bot on [the list of handlers](https://github.com/jimmycuadra/lita/wiki/Handlers), then add them to your Gemfile. For example:
+
+``` ruby
+gem "lita-karma"
+```
+
+## Configuration
+
+To configure Lita, edit the file `lita_config.rb` generated by the `lita new` command. This is just a plain Ruby file that will be evaluated when the bot is starting up. A Lita config file looks something like this:
+
+``` ruby
+Lita.configure do |config|
+  config.robot.name = "Sir Bottington"
+  config.robot.adapter = :example_chat_service
+  config.adapter.username = "bottington"
+  config.adapter.password = "secret"
+  config.redis.host = "redis.example.com"
+  config.handlers.karma.rate_limit = 300
+  config.handlers.google_images.safe_search = false
+end
+```
+
+The main config objects are:
+
+* robot: General settings for Lita.
+  * name: The name the bot will use on the chat service.
+  * adapter: A symbol or string indicating the adapter to load.
+* adapter: Options for the chosen adapter. See the adapter's documentation.
+* redis: Options for the Redis connection. See the [Redis gem](https://github.com/redis/redis-rb) documentation.
+* handlers: Handlers may choose to expose a config object here with their own options. See the handler's documentation.
+
+## Acknowledgements
+
+Lita draws much inspiration from GitHub's fantastic [Hubot](http://hubot.github.com/).
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/lita

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+require "lita/cli"
+
+Lita::CLI.start

data/lib/lita.rb

@@ -0,0 +1,57 @@
+require "forwardable"
+require "set"
+require "shellwords"
+
+require "redis-namespace"
+
+module Lita
+  REDIS_NAMESPACE = "lita"
+
+  class << self
+    def adapters
+      @adapters ||= {}
+    end
+
+    def register_adapter(key, adapter)
+      adapters[key.to_sym] = adapter
+    end
+
+    def handlers
+      @handlers ||= Set.new
+    end
+
+    def register_handler(handler)
+      handlers << handler
+    end
+
+    def config
+      @config ||= Config.default_config
+    end
+
+    def configure
+      yield config
+    end
+
+    def redis
+      @redis ||= begin
+        redis = Redis.new(config.redis)
+        Redis::Namespace.new(REDIS_NAMESPACE, redis: redis)
+      end
+    end
+
+    def run
+      Config.load_user_config
+      Robot.new.run
+    end
+  end
+end
+
+require "lita/version"
+require "lita/errors"
+require "lita/config"
+require "lita/source"
+require "lita/message"
+require "lita/robot"
+require "lita/adapter"
+require "lita/adapters/shell"
+require "lita/handler"

data/lib/lita/adapter.rb

@@ -0,0 +1,40 @@
+module Lita
+  class Adapter
+    attr_reader :robot
+
+    class << self
+      attr_reader :required_configs
+
+      def require_config(*keys)
+        @required_configs ||= []
+        @required_configs.concat(keys.flatten.map(&:to_sym))
+      end
+
+      alias_method :require_configs, :require_config
+    end
+
+    def initialize(robot)
+      @robot = robot
+      ensure_required_configs
+    end
+
+    private
+
+    def ensure_required_configs
+      required_configs = self.class.required_configs
+      return if required_configs.nil?
+
+      missing_keys = []
+
+      required_configs.each do |key|
+        missing_keys << key unless Lita.config.adapter[key]
+      end
+
+      unless missing_keys.empty?
+        raise Lita::ConfigError.new(
+"The following keys are required on config.adapter: #{missing_keys.join(", ")}"
+        )
+      end
+    end
+  end
+end

data/lib/lita/adapters/shell.rb

@@ -0,0 +1,23 @@
+module Lita
+  module Adapters
+    class Shell < Adapter
+      def run
+        puts 'Type "exit" or "quit" to end the session.'
+        loop do
+          print "#{robot.name} > "
+          input = gets.chomp.strip
+          break if input == "exit" || input == "quit"
+          source = Source.new("Shell User")
+          message = Message.new(robot, input, source)
+          robot.receive(message)
+        end
+      end
+
+      def send_messages(target, *strings)
+        puts *strings
+      end
+    end
+
+    Lita.register_adapter(:shell, Shell)
+  end
+end

data/lib/lita/cli.rb

@@ -0,0 +1,24 @@
+require "thor"
+
+module Lita
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.expand_path("../../..", __FILE__)
+    end
+
+    default_task :start
+
+    desc "start", "Starts Lita"
+    def start
+      Bundler.require
+      Lita.run
+    end
+
+    desc "new NAME", "Generates a new Lita project (default name: lita)"
+    def new(name = "lita")
+      directory "skeleton", name
+    end
+  end
+end

data/lib/lita/config.rb

@@ -0,0 +1,41 @@
+module Lita
+  class Config < Hash
+    def self.default_config
+      new.tap do |c|
+        c.robot = new
+        c.robot.name = "Lita"
+        c.robot.adapter = :shell
+        c.redis = new
+        c.adapter = new
+        c.handlers = new
+      end
+    end
+
+    def self.load_user_config
+      config_path = File.expand_path("lita_config.rb", Dir.pwd)
+
+      begin
+        load(config_path)
+      rescue Exception
+        raise ConfigError
+      end if File.exist?(config_path)
+    end
+
+    def []=(key, value)
+      super(key.to_sym, value)
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def method_missing(name, *args)
+      name_string = name.to_s
+      if name_string.chomp!("=")
+        self[name_string] = args.first
+      else
+        self[name_string]
+      end
+    end
+  end
+end

data/lib/lita/errors.rb

@@ -0,0 +1,6 @@
+module Lita
+  class Error < StandardError; end
+
+  class UnknownAdapterError < Error; end
+  class ConfigError < Error; end
+end

data/lib/lita/handler.rb

@@ -0,0 +1,73 @@
+module Lita
+  class Handler
+    extend Forwardable
+
+    attr_reader :redis
+    private :redis
+
+    def_delegators :@message, :args, :command?, :scan
+
+    class Route < Struct.new(:pattern, :method_name, :command)
+      alias_method :command?, :command
+    end
+
+    class << self
+      def route(pattern, to: nil, command: false)
+        @routes ||= []
+        @routes << Route.new(pattern, to, command)
+      end
+
+      def dispatch(robot, message)
+        instance = new(robot, message)
+
+        @routes.each do |route|
+          if route_applies?(route, instance)
+            instance.public_send(
+              route.method_name,
+              matches_for_route(route, instance)
+            )
+          end
+        end
+      end
+
+      private
+
+      def route_applies?(route, instance)
+        if route.pattern === instance.message_body
+          if route.command?
+            return instance.command?
+          else
+            return true
+          end
+        end
+
+        false
+      end
+
+      def matches_for_route(route, instance)
+        instance.scan(route.pattern)
+      end
+    end
+
+    def initialize(robot, message)
+      @robot = robot
+      @message = message
+      @redis = Redis::Namespace.new(redis_namespace, redis: Lita.redis)
+    end
+
+    def reply(*strings)
+      @robot.send_messages(@message.source, *strings)
+    end
+
+    def message_body
+      @message.body
+    end
+
+    private
+
+    def redis_namespace
+      name = self.class.name.split("::").last.downcase
+      "handlers:#{name}"
+    end
+  end
+end

data/lib/lita/message.rb

@@ -0,0 +1,37 @@
+module Lita
+  class Message
+    extend Forwardable
+
+    attr_reader :body, :source
+    alias_method :message, :body
+
+    def_delegators :@body, :scan
+
+    def initialize(robot, body, source)
+      @robot = robot
+      @body = body
+      @source = source
+
+      @command = !!@body.sub!(/^\s*@?#{@robot.name}[:,]?\s*/, "")
+    end
+
+    def args
+      begin
+        command, *args = message.shellsplit
+      rescue ArgumentError
+        command, *args =
+          message.split(/\s+/).map(&:shellescape).join(" ").shellsplit
+      end
+
+      args
+    end
+
+    def command!
+      @command = true
+    end
+
+    def command?
+      @command
+    end
+  end
+end

data/lib/lita/robot.rb

@@ -0,0 +1,36 @@
+module Lita
+  class Robot
+    attr_reader :name
+
+    def initialize
+      @name = Lita.config.robot.name
+      load_adapter
+    end
+
+    def receive(message)
+      Lita.handlers.each { |handler| handler.dispatch(self, message) }
+    end
+
+    def run
+      @adapter.run
+    end
+
+    def send_messages(target, *strings)
+      @adapter.send_messages(target, strings.flatten)
+    end
+    alias_method :send_message, :send_messages
+
+    private
+
+    def load_adapter
+      adapter_name = Lita.config.robot.adapter
+      adapter_class = Lita.adapters[adapter_name.to_sym]
+
+      unless adapter_class
+        raise UnknownAdapterError.new("Unknown adapter: :#{adapter_name}")
+      end
+
+      @adapter = adapter_class.new(self)
+    end
+  end
+end

data/lib/lita/rspec.rb

@@ -0,0 +1,51 @@
+module Lita
+  module RSpec
+    def self.included(base)
+      base.class_eval do
+        let(:robot) { Robot.new }
+
+        before do
+          allow(Lita).to receive(:handlers).and_return([described_class])
+          stub_const("Lita::REDIS_NAMESPACE", "lita.test")
+          keys = Lita.redis.keys("*")
+          Lita.redis.del(keys) unless keys.empty?
+        end
+      end
+    end
+
+    def send_test_message(body)
+      source = Source.new("Test User")
+      message = Message.new(robot, body, source)
+      robot.receive(message)
+    end
+
+    def routes(message)
+      RouteMatcher.new(self, message)
+    end
+
+    def does_not_route(message)
+      RouteMatcher.new(self, message, invert: true)
+    end
+    alias_method :doesnt_route, :does_not_route
+  end
+
+  class RouteMatcher
+    def initialize(context, message_body, invert: false)
+      @context = context
+      @message_body = message_body
+      @method = invert ? :not_to : :to
+    end
+
+    def to(route)
+      @context.expect_any_instance_of(
+        @context.described_class
+      ).public_send(@method, @context.receive(route))
+
+      @context.send_test_message(@message_body)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Lita::RSpec, lita_handler: true
+end

data/lib/lita/source.rb

@@ -0,0 +1,10 @@
+module Lita
+  class Source
+    attr_reader :user, :room
+
+    def initialize(user, room = nil)
+      @user = user
+      @room = room
+    end
+  end
+end

data/lib/lita/version.rb

@@ -0,0 +1,3 @@
+module Lita
+  VERSION = "0.0.1"
+end

data/lita.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lita/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "lita"
+  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.homepage      = "https://github.com/jimmycuadra/lita"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "bundler", "~> 1.3"
+  spec.add_runtime_dependency "redis-namespace", "~> 1.3.0"
+  spec.add_runtime_dependency "thor", "~> 0.18.1"
+
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 2.14.0rc1"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "coveralls"
+end

data/skeleton/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "lita"
+
+# Uncomment to use the HipChat adapter
+# gem "lita-hipchat"
+
+# Uncomment to use the IRC adapter
+# gem "lita-irc"

data/skeleton/lita_config.rb

@@ -0,0 +1,20 @@
+Lita.configure do |config|
+  # The name your robot will use.
+  config.robot.name = "Lita"
+
+  # The adapter you want to connect with. Make sure you've added the
+  # appropriate gem to the Gemfile.
+  config.robot.adapter = :shell
+
+  ## Example: Set options for the chosen adapter.
+  # config.adapter.username = "myname"
+  # config.adapter.password = "secret"
+
+  ## Example: Set options for the Redis connection.
+  # config.redis.host = "127.0.0.1"
+  # config.redis.port = 1234
+
+  ## Example: Set configuration for any loaded handlers. See the handler's
+  ## documentation for options.
+  # config.handlers.some_handler.some_config_key = "value"
+end

data/spec/lita/adapter_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Lita::Adapter do
+  let(:robot) { double("Robot") }
+
+  subject { described_class.new(robot) }
+
+  it "stores a Robot" do
+    expect(subject.robot).to eql(robot)
+  end
+
+  describe ".require_config" do
+    let(:adapter_class) do
+      Class.new(described_class) do
+        require_config :foo
+        require_configs :bar, :baz
+        require_configs ["blah", :bleh]
+      end
+    end
+
+    subject { adapter_class.new(robot) }
+
+    it "ensures that config keys are present on initialization" do
+      expect do
+        subject
+      end.to raise_error(Lita::ConfigError, /foo, bar, baz, blah, bleh/)
+    end
+  end
+end

data/spec/lita/adapters/shell_spec.rb

@@ -0,0 +1,27 @@
+describe Lita::Adapters::Shell do
+  let(:robot) do
+    robot = double("Robot")
+    allow(robot).to receive(:name).and_return("Lita")
+    robot
+  end
+
+  subject { described_class.new(robot) }
+
+  describe "#run" do
+    before { allow(subject).to receive(:puts) }
+
+    it "passes input to the Robot and breaks on an exit message" do
+      expect(subject).to receive(:print).with("#{robot.name} > ").twice
+      allow(subject).to receive(:gets).and_return("foo", "exit")
+      expect(robot).to receive(:receive).with(an_instance_of(Lita::Message))
+      subject.run
+    end
+  end
+
+  describe "#send_message" do
+    it "prints its input" do
+      expect(subject).to receive(:puts).with("bar")
+      subject.send_messages(double("target"), "bar")
+    end
+  end
+end

data/spec/lita/config_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Lita::Config do
+  let(:value) { double("arbitrary config key's value") }
+
+  it "allows hash-style access with symbols or strings" do
+    subject[:foo] = value
+    expect(subject[:foo]).to eql(value)
+    expect(subject["foo"]).to eql(value)
+  end
+
+  it "allows struct-style access" do
+    subject.foo = value
+    expect(subject.foo).to eql(value)
+  end
+
+  describe ".default_config" do
+    it "has predefined values for certain keys" do
+      expect(described_class.default_config.robot.name).to eq("Lita")
+      expect(described_class.default_config.robot.adapter).to eq(:shell)
+    end
+  end
+
+  describe ".load_user_config" do
+    it "loads and evals lita_config.rb" do
+      allow(File).to receive(:exist?).and_return(true)
+      allow(described_class).to receive(:load) do
+        Lita.configure { |config| config.robot.name = "Not Lita" }
+      end
+      described_class.load_user_config
+      expect(Lita.config.robot.name).to eq("Not Lita")
+    end
+
+    it "doesn't attempt to load lita_config.rb if it doesn't exist" do
+      expect(described_class).not_to receive(:load)
+      described_class.load_user_config
+    end
+
+    it "raises an exception if lita_config.rb raises an exception" do
+      allow(File).to receive(:exist?).and_return(true)
+      allow(described_class).to receive(:load) { Lita.non_existent_method }
+      expect do
+        described_class.load_user_config
+      end.to raise_error(Lita::ConfigError)
+    end
+  end
+end

data/spec/lita/handler_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe Lita::Handler do
+  let(:robot) do
+    robot = double("Robot")
+    allow(robot).to receive(:name).and_return("Lita")
+    robot
+  end
+
+  let(:message) do
+    message = double("Message")
+    allow(message).to receive(:scan).and_return(matches)
+    allow(message).to receive(:command?).and_return(false)
+    allow(message).to receive(:source).and_return(source)
+    message
+  end
+
+  let(:matches) { double("MatchData") }
+
+  let(:source) { double("Source") }
+
+  let(:handler_class) do
+    Class.new(described_class) do
+      route(/\w{3}/, to: :foo)
+      route(/\w{4}/, to: :blah, command: true)
+
+      def foo(matches)
+      end
+
+      def blah(matches)
+      end
+
+      def self.name
+        "Lita::Handlers::Test"
+      end
+    end
+  end
+
+  subject { described_class.new(robot, message) }
+
+  describe ".dispatch" do
+    it "routes a matching message to the supplied method" do
+      allow(message).to receive(:body).and_return("bar")
+      expect_any_instance_of(handler_class).to receive(:foo)
+      handler_class.dispatch(robot, message)
+    end
+
+    it "routes a matching message even if addressed to the Robot" do
+      allow(message).to receive(:body).and_return("#{robot.name}: bar")
+      allow(message).to receive(:command?).and_return(true)
+      expect_any_instance_of(handler_class).to receive(:foo)
+      handler_class.dispatch(robot, message)
+    end
+
+    it "routes a command message to the supplied method" do
+      allow(message).to receive(:body).and_return("#{robot.name}: bar")
+      allow(message).to receive(:command?).and_return(true)
+      expect_any_instance_of(handler_class).to receive(:blah)
+      handler_class.dispatch(robot, message)
+    end
+
+    it "requires command routes to be addressed to the Robot" do
+      allow(message).to receive(:body).and_return("blah")
+      expect_any_instance_of(handler_class).not_to receive(:blah)
+      handler_class.dispatch(robot, message)
+    end
+
+    it "doesn't route messages that don't match anything" do
+      allow(message).to receive(:body).and_return("yo")
+      expect_any_instance_of(handler_class).not_to receive(:foo)
+      expect_any_instance_of(handler_class).not_to receive(:blah)
+      handler_class.dispatch(robot, message)
+    end
+  end
+
+  describe "#args" do
+    it "delegates to Message" do
+      expect(message).to receive(:args)
+      subject.args
+    end
+  end
+
+  describe "#command?" do
+    it "delegates to Message" do
+      expect(message).to receive(:command?)
+      subject.command?
+    end
+  end
+
+  describe "#message_body" do
+    it "delegates to Message" do
+      expect(message).to receive(:body)
+      subject.message_body
+    end
+  end
+
+  describe "#reply" do
+    it "calls Robot#send_message with the messages to send" do
+      expect(robot).to receive(:send_messages).with(source, "foo", "bar")
+      subject.reply("foo", "bar")
+    end
+  end
+
+  describe "#scan" do
+    it "delegates to Message" do
+      expect(message).to receive(:scan)
+      subject.scan
+    end
+  end
+end

data/spec/lita/message_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Lita::Message do
+  let(:robot) do
+    robot = double("Robot")
+    allow(robot).to receive(:name).and_return("Lita")
+    robot
+  end
+
+  subject do
+    described_class.new(robot, "Hello", "Carl")
+  end
+
+  it "has a body" do
+    expect(subject.body).to eq("Hello")
+  end
+
+  it "aliases #body with #message" do
+    expect(subject.message).to eq("Hello")
+  end
+
+  it "has a source" do
+    expect(subject.source).to eq("Carl")
+  end
+
+  describe "#args" do
+    it "returns an array of the 2nd through nth word in the message" do
+      subject = described_class.new(robot, "args foo bar", "Carl")
+      expect(subject.args).to eq(["foo", "bar"])
+    end
+
+    it "escapes messages that have mismatched quotes" do
+      subject = described_class.new(robot, "args it's working", "Carl")
+      expect(subject.args).to eq(["it's", "working"])
+    end
+  end
+
+  describe "#command!" do
+    it "marks a message as a command" do
+      subject.command!
+      expect(subject).to be_a_command
+    end
+  end
+
+  describe "#command?" do
+    it "is true when the message is addressed to the Robot" do
+      subject = described_class.new(robot, "#{robot.name}: hello", "Carl")
+      expect(subject).to be_a_command
+    end
+
+    it "is false when the message is not addressed to the Robot" do
+      expect(subject).not_to be_a_command
+    end
+  end
+
+  describe "#scan" do
+    it "delegates to #body" do
+      expect(subject.body).to receive(:scan)
+      subject.scan
+    end
+  end
+end

data/spec/lita/robot_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Lita::Robot do
+  it "raises an exception if the specified adapter can't be found" do
+    adapter_registry = double("adapter_registry")
+    allow(Lita).to receive(:adapters).and_return(adapter_registry)
+    allow(adapter_registry).to receive(:[]).and_return(nil)
+    expect { subject }.to raise_error(Lita::UnknownAdapterError)
+  end
+
+  describe "#receive" do
+    let(:handler1) { double("Handler 1") }
+    let(:handler2) { double("Handler 2") }
+
+    it "dispatches messages to every registered handler" do
+      allow(Lita).to receive(:handlers).and_return([handler1, handler2])
+      expect(handler1).to receive(:dispatch).with(subject, "foo")
+      expect(handler2).to receive(:dispatch).with(subject, "foo")
+      subject.receive("foo")
+    end
+  end
+
+  describe "#run" do
+    it "starts the adapter" do
+      expect_any_instance_of(Lita::Adapters::Shell).to receive(:run)
+      subject.run
+    end
+  end
+
+  describe "#send_message" do
+    let(:message) { double("Message") }
+
+    it "delegates to the adapter" do
+      expect_any_instance_of(
+        Lita::Adapters::Shell
+      ).to receive(:send_messages).with(
+        message, ["foo", "bar"]
+      )
+      subject.send_messages(message, "foo", "bar")
+    end
+  end
+end

data/spec/lita/rspec_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+handler_class = Class.new(Lita::Handler) do
+  route(/\w{3}/, to: :foo)
+  route(/\w{4}/, to: :blah, command: true)
+
+  def foo(matches)
+  end
+
+  def blah(matches)
+  end
+
+  def self.name
+    "Lita::Handlers::Test"
+  end
+end
+
+describe handler_class, lita_handler: true do
+  it { routes("foo").to(:foo) }
+  it { routes("#{robot.name}: blah").to(:blah) }
+  it { doesnt_route("blah").to(:blah) }
+  it { does_not_route("blah").to(:blah) }
+end

data/spec/lita/source_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Lita::Source do
+  it "has a user" do
+    subject = described_class.new("Carl")
+    expect(subject.user).to eq("Carl")
+  end
+
+  it "has a room" do
+    subject = described_class.new("Carl", "#litabot")
+    expect(subject.room).to eq("#litabot")
+  end
+end

data/spec/lita_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Lita do
+  it "memoizes a hash of Adapters" do
+    adapter_class = double("Adapter")
+    described_class.register_adapter(:foo, adapter_class)
+    expect(described_class.adapters[:foo]).to eql(adapter_class)
+    expect(described_class.adapters).to eql(described_class.adapters)
+  end
+
+  it "memoizes a set of Handlers" do
+    handler_class = double("Handler")
+    described_class.register_handler(handler_class)
+    described_class.register_handler(handler_class)
+    expect(described_class.handlers.to_a).to eq([handler_class])
+    expect(described_class.handlers).to eql(described_class.handlers)
+  end
+
+  it "memoizes a Config" do
+    expect(described_class.config).to be_a(Lita::Config)
+    expect(described_class.config).to eql(described_class.config)
+  end
+
+  describe ".configure" do
+    it "yields the Config object" do
+      described_class.configure { |c| c.robot.name = "Not Lita" }
+      expect(described_class.config.robot.name).to eq("Not Lita")
+    end
+  end
+
+  describe ".redis" do
+    it "memoizes a Redis::Namespace" do
+      expect(described_class.redis.namespace).to eq(
+        described_class::REDIS_NAMESPACE
+      )
+      expect(described_class.redis).to eql(described_class.redis)
+    end
+  end
+
+  describe ".run" do
+    it "laods the user config" do
+      expect(Lita::Config).to receive(:load_user_config)
+      allow_any_instance_of(Lita::Robot).to receive(:run)
+      described_class.run
+    end
+
+    it "runs a new Robot" do
+      expect_any_instance_of(Lita::Robot).to receive(:run)
+      described_class.run
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "simplecov"
+require "coveralls"
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
+
+require "lita"
+require "lita/rspec"

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: lita
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jimmy Cuadra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.0rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.0rc1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A multi-service chat bot with extendable behavior.
+email:
+- jimmy@jimmycuadra.com
+executables:
+- lita
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/lita
+- lib/lita.rb
+- lib/lita/adapter.rb
+- lib/lita/adapters/shell.rb
+- lib/lita/cli.rb
+- lib/lita/config.rb
+- lib/lita/errors.rb
+- lib/lita/handler.rb
+- lib/lita/message.rb
+- lib/lita/robot.rb
+- lib/lita/rspec.rb
+- lib/lita/source.rb
+- lib/lita/version.rb
+- lita.gemspec
+- skeleton/Gemfile
+- skeleton/lita_config.rb
+- spec/lita/adapter_spec.rb
+- spec/lita/adapters/shell_spec.rb
+- spec/lita/config_spec.rb
+- spec/lita/handler_spec.rb
+- spec/lita/message_spec.rb
+- spec/lita/robot_spec.rb
+- spec/lita/rspec_spec.rb
+- spec/lita/source_spec.rb
+- spec/lita_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jimmycuadra/lita
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A multi-service chat bot with extendable behavior.
+test_files:
+- spec/lita/adapter_spec.rb
+- spec/lita/adapters/shell_spec.rb
+- spec/lita/config_spec.rb
+- spec/lita/handler_spec.rb
+- spec/lita/message_spec.rb
+- spec/lita/robot_spec.rb
+- spec/lita/rspec_spec.rb
+- spec/lita/source_spec.rb
+- spec/lita_spec.rb
+- spec/spec_helper.rb
+has_rdoc: