lita 1.1.2 → 2.0.0

data/lib/lita/rspec.rb

@@ -1,67 +1,40 @@
+begin
+  require "rspec"
+rescue LoadError
+  abort "Lita::RSpec requires both RSpec::Mocks and RSpec::Expectations."
+end
+
+major, minor, patch, *pre = RSpec::Mocks::Version::STRING.split(/\./)
+if major == "2" && minor.to_i < 14
+  abort "RSpec::Mocks 2.14 or greater is required to use Lita::RSpec."
+end
+
+require "lita/rspec/handler"
+
 module Lita
+  # Extras for +RSpec+ that facilitate the testing of Lita code.
   module RSpec
+    # Causes all interaction with Redis to use a test-specific namespace. Clears
+    # Redis before each example. Stubs the logger to prevent log messages from
+    # cluttering test output. Clears Lita's global configuration.
+    # @param base [Object] The class including the module.
+    # @return [void]
     def self.included(base)
       base.class_eval do
-        let(:robot) { Robot.new }
-        let(:source) { Source.new(user) }
-        let(:user) { User.new("1", name: "Test User") }
-
         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?
-          allow(robot).to receive(:send_messages)
+          logger = double("Logger").as_null_object
+          allow(Lita).to receive(:logger).and_return(logger)
+          Lita.clear_config
         end
       end
     end
-
-    def expect_reply(*arguments, invert: false)
-      method = invert ? :not_to : :to
-      expect(robot).public_send(
-        method,
-        receive(:send_messages).with(source, *arguments)
-      )
-    end
-    alias_method :expect_replies, :expect_reply
-
-    def expect_no_reply(*arguments)
-      expect_reply(*arguments, invert: true)
-    end
-    alias_method :expect_no_replies, :expect_no_reply
-
-    def send_test_message(body)
-      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: true
+  config.include Lita::RSpec::Handler, lita_handler: true
 end

data/lib/lita/rspec/handler.rb

@@ -0,0 +1,168 @@
+module Lita
+  module RSpec
+    # Extras for +RSpec+ to facilitate testing Lita handlers.
+    module Handler
+      # Sets up the RSpec environment to easily test Lita handlers.
+      def self.included(base)
+        base.class_eval do
+          include Lita::RSpec
+
+          let(:robot) { Robot.new }
+          let(:source) { Source.new(user) }
+          let(:user) { User.create("1", name: "Test User") }
+          let(:replies) { [] }
+
+          subject { described_class.new(robot) }
+
+          before do
+            allow(Lita).to receive(:handlers).and_return([described_class])
+            allow(robot).to receive(:send_messages) do |target, *strings|
+              replies.concat(strings)
+            end
+            allow(robot).to receive(:send_message) do |target, *strings|
+              replies.concat(strings)
+            end
+          end
+        end
+      end
+
+      # Sends a message to the robot.
+      # @param body [String] The message to send.
+      # @param as [Lita::User] The user sending the message.
+      # @return [void]
+      def send_message(body, as: user)
+        message = if as == user
+          Message.new(robot, body, source)
+        else
+          Message.new(robot, body, Source.new(as))
+        end
+
+        robot.receive(message)
+      end
+
+      # Sends a "command" message to the robot.
+      # @param body [String] The message to send.
+      # @param as [Lita::User] The user sending the message.
+      # @return [void]
+      def send_command(body, as: user)
+        send_message("#{robot.mention_name}: #{body}", as: as)
+      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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
+      #   it to complete the test.
+      def routes(message)
+        RouteMatcher.new(self, 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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
+      #   it to complete the test.
+      def does_not_route(message)
+        RouteMatcher.new(self, message, invert: true)
+      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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
+      #   it to complete the test.
+      def routes_command(message)
+        RouteMatcher.new(self, "#{robot.mention_name}: #{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 [RouteMatcher] A {RouteMatcher} that should have +to+ called on
+      #   it to complete the test.
+      def does_not_route_command(message)
+        RouteMatcher.new(self, "#{robot.mention_name}: #{message}", invert: true)
+      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 [HTTPRouteMatcher] An {HTTPRouteMatcher} that should have +to+
+      #   called on it to complete the test.
+      def routes_http(http_method, path)
+        HTTPRouteMatcher.new(self, 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 [HTTPRouteMatcher] An {HTTPRouteMatcher} that should have +to+
+      #   called on it to complete the test.
+      def does_not_route_http(http_method, path)
+        HTTPRouteMatcher.new(self, http_method, path, invert: true)
+      end
+      alias_method :doesnt_route_http, :does_not_route_http
+    end
+
+    # Used to complete a chat routing test chain.
+    class RouteMatcher
+      def initialize(context, message_body, invert: false)
+        @context = context
+        @message_body = message_body
+        @method = invert ? :not_to : :to
+      end
+
+      # Sets an expectation that a route will or will not be triggered, then
+      # sends the message originally provided.
+      # @param route [Symbol] The name of the method that should or should not
+      #   be triggered.
+      # @return [void]
+      def to(route)
+        m = @method
+        b = @message_body
+
+        @context.instance_eval do
+          allow(Authorization).to receive(:user_in_group?).and_return(true)
+          expect_any_instance_of(described_class).public_send(m, receive(route))
+          send_message(b)
+        end
+      end
+    end
+
+    # Used to complete an HTTP routing test chain.
+    class HTTPRouteMatcher
+      def initialize(context, http_method, path, invert: false)
+        @context = context
+        @http_method = http_method
+        @path = path
+        @method = invert ? :not_to : :to
+      end
+
+      # Sets an expectation that an HTTP route will or will not be triggered,
+      #   then makes an HTTP request against the app with the HTTP request
+      #   method and path originally provided.
+      # @param route [Symbol] The name of the method that should or should not
+      #   be triggered.
+      # @return [void]
+      def to(route)
+        m = @method
+        h = @http_method
+        p = @path
+
+        @context.instance_eval do
+          expect_any_instance_of(described_class).public_send(m, receive(route))
+          env = Rack::MockRequest.env_for(p, method: h)
+          robot.app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/lita/source.rb

@@ -1,7 +1,25 @@
 module Lita
+  # A wrapper object representing the source of an incoming message (the user
+  # who sent it, and optionally the room they sent it from). If a room is set,
+  # the message is from a group chat room. If no room is set, the message is
+  # assumed to be a private message. Source objects are also used as "target"
+  # objects when sending an outgoing message or performing another operation
+  # on a user or a room.
   class Source
-    attr_reader :user, :room
 
+    # The room the message came from or should be sent to.
+    # @return [String] A string uniquely identifying the room.
+    attr_reader :room
+
+    # The user who sent the message or should receive the outgoing message.
+    # @return [Lita::User] The user.
+    attr_reader :user
+
+    # @param user [Lita::User] The user who sent the message or should receive
+    #   the outgoing message.
+    # @param room [String] A string uniquely identifying the room the user sent
+    #   the message from, or the room where a reply should go. The format of
+    #   this string will differ depending on the chat service.
     def initialize(user, room = nil)
       @user = user
       @room = room

data/lib/lita/user.rb

@@ -1,10 +1,19 @@
 module Lita
+  # A user in the chat service. Persisted in Redis.
   class User
     class << self
+      # The +Redis::Namespace+ for user persistence.
+      # @return [Redis::Namespace] The Redis connection.
       def redis
         @redis ||= Redis::Namespace.new("users", redis: Lita.redis)
       end
 
+      # Finds or creates a user. Attempts to find a user with the given ID. If
+      # none is found, creates a user with the provided ID and metadata.
+      # @param id [Integer, String] A unique identifier for the user.
+      # @param metadata [Hash] An optional hash of metadata about the user.
+      # @option metadata [String] name (id) The display name of the user.
+      # @return [Lita::User] The user.
       def create(id, metadata = {})
         user = find_by_id(id)
         unless user
@@ -15,25 +24,47 @@ module Lita
       end
       alias_method :find, :create
 
+      # Finds a user by ID.
+      # @param id [Integer, String] The user's unique ID.
+      # @return [Lita::User, nil] The user or +nil+ if no such user is known.
       def find_by_id(id)
         metadata = redis.hgetall("id:#{id}")
         return new(id, metadata) if metadata.key?("name")
       end
 
+      # Finds a user by display name.
+      # @param name [String] The user's name.
+      # @return [Lita::User, nil] The user or +nil+ if no such user is known.
       def find_by_name(name)
         id = redis.get("name:#{name}")
         find_by_id(id) if id
       end
     end
 
-    attr_reader :id, :name, :metadata
+    # The user's unique ID.
+    # @return [String] The user's ID.
+    attr_reader :id
 
+    # A hash of arbitrary metadata about the user.
+    # @return [Hash] The user's metadata.
+    attr_reader :metadata
+
+    # The user's name as displayed in the chat.
+    # @return [String] The user's name.
+    attr_reader :name
+
+    # @param id [Integer, String] The user's unique ID.
+    # @param metadata [Hash] Arbitrary user metadata.
+    # @option metadata [String] name (id) The user's display name.
     def initialize(id, metadata = {})
       @id = id.to_s
       @metadata = metadata
       @name = @metadata[:name] || @metadata["name"] || @id
     end
 
+    # Saves the user record to Redis, overwriting an previous data for the
+    # current ID and user name.
+    # @return [void]
     def save
       redis.pipelined do
         redis.hmset("id:#{id}", *metadata.to_a.flatten)
@@ -41,6 +72,10 @@ module Lita
       end
     end
 
+    # Compares the user against another user object to determine equality. Users
+    # are considered equal if they have the same ID and name.
+    # @param other (Lita::User) The user to compare against.
+    # @return [Boolean] True if users are equal, false otherwise.
     def ==(other)
       other.respond_to?(:id) && id == other.id &&
         other.respond_to?(:name) && name == other.name
@@ -48,6 +83,7 @@ module Lita
 
     private
 
+    # The Redis connection for user persistence.
     def redis
       self.class.redis
     end

data/lib/lita/util.rb

@@ -0,0 +1,26 @@
+module Lita
+  # Handy utilities used by other parts Lita classes.
+  module Util
+    # A regular expression for acronyms.
+    ACRONYM_REGEX = /(?=a)b/
+
+    class << self
+      # Transforms a camel-cased string into a snaked-cased string. Taken from
+      # +ActiveSupport.+
+      # @param camel_cased_word [String] The word to transform.
+      # @return [String] The transformed word.
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{ACRONYM_REGEX})(?=\b|[^a-z])/) do
+          "#{$1}#{$1 && '_'}#{$2.downcase}"
+        end
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+    end
+  end
+end

data/lib/lita/version.rb

@@ -1,3 +1,4 @@
 module Lita
-  VERSION = "1.1.2"
+  # The current version of Lita.
+  VERSION = "2.0.0"
 end

data/lita.gemspec

@@ -21,11 +21,16 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.0.0"
 
   spec.add_runtime_dependency "bundler", "~> 1.3"
+  spec.add_runtime_dependency "faraday", "~> 0.8.7"
+  spec.add_runtime_dependency "multi_json", "~> 1.7.7"
+  spec.add_runtime_dependency "rack", "~> 1.5.2"
   spec.add_runtime_dependency "redis-namespace", "~> 1.3.0"
+  spec.add_runtime_dependency "thin", "~> 1.5.1"
   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"
+  spec.add_development_dependency "pry"
 end

data/spec/lita/adapters/shell_spec.rb

@@ -4,20 +4,28 @@ describe Lita::Adapters::Shell do
   subject { described_class.new(robot) }
 
   describe "#run" do
-    before { allow(subject).to receive(:puts) }
+    before do
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+      allow($stdin).to receive(:gets).and_return("foo", "exit")
+      allow(robot).to receive(:receive)
+    end
 
     it "passes input to the Robot and breaks on an exit message" do
       expect(subject).to receive(:print).with("#{robot.name} > ").twice
-      allow($stdin).to receive(:gets).and_return("foo", "exit")
       expect(robot).to receive(:receive).with(an_instance_of(Lita::Message))
-      allow(Thread).to receive(:new) { |&block| block.call }
+      subject.run
+    end
+
+    it "marks messages as commands if config.adapter.private_chat is true" do
+      Lita.config.adapter.private_chat = true
+      expect_any_instance_of(Lita::Message).to receive(:command!)
       subject.run
     end
   end
 
   describe "#send_message" do
     it "prints its input" do
-      expect(subject).to receive(:puts)
       expect(subject).to receive(:puts).with("bar")
       subject.send_messages(double("target"), "bar")
     end