lita 0.0.1 → 1.0.0

data/lib/lita/handler.rb

@@ -2,19 +2,20 @@ module Lita
   class Handler
     extend Forwardable
 
-    attr_reader :redis
+    attr_reader :redis, :robot
     private :redis
 
-    def_delegators :@message, :args, :command?, :scan
+    def_delegators :@message, :args, :command?, :scan, :user
 
-    class Route < Struct.new(:pattern, :method_name, :command)
+    class Route < Struct.new(:pattern, :method_name, :command, :required_groups)
       alias_method :command?, :command
     end
 
     class << self
-      def route(pattern, to: nil, command: false)
+      def route(pattern, to: nil, command: false, restrict_to: nil)
         @routes ||= []
-        @routes << Route.new(pattern, to, command)
+        required_groups = restrict_to.nil? ? nil : Array(restrict_to)
+        @routes << Route.new(pattern, to, command, required_groups)
       end
 
       def dispatch(robot, message)
@@ -27,21 +28,24 @@ module Lita
               matches_for_route(route, instance)
             )
           end
-        end
+        end if defined?(@routes)
       end
 
       private
 
       def route_applies?(route, instance)
-        if route.pattern === instance.message_body
-          if route.command?
-            return instance.command?
-          else
-            return true
-          end
+        # Message must match the pattern
+        return unless route.pattern === instance.message_body
+
+        # Message must be a command if the route requires a command
+        return if route.command? && !instance.command?
+
+        # User must be in auth group if route is restricted
+        return if route.required_groups && route.required_groups.none? do |group|
+          Authorization.user_in_group?(instance.user, group)
         end
 
-        false
+        true
       end
 
       def matches_for_route(route, instance)

data/lib/lita/handlers/authorization.rb

@@ -0,0 +1,60 @@
+module Lita
+  module Handlers
+    class Authorization < Handler
+      route(/^auth\s+add/, to: :add, command: true)
+      route(/^auth\s+remove/, to: :remove, command: true)
+
+      def self.help
+        robot_name = Lita.config.robot.name
+
+        {
+          "#{robot_name}: auth add USER GROUP" => "Add USER to authorization group GROUP. Requires admin privileges.",
+          "#{robot_name}: auth remove USER GROUP" => "Remove USER from authorization group GROUP. Requires admin privileges."
+        }
+      end
+
+      def add(matches)
+        return unless valid_message?
+
+        if Lita::Authorization.add_user_to_group(@user, @group)
+          reply "#{@user.name} was added to #{@group}."
+        else
+          reply "#{@user.name} was already in #{@group}."
+        end
+      end
+
+      def remove(matches)
+        return unless valid_message?
+
+        if Lita::Authorization.remove_user_from_group(@user, @group)
+          reply "#{@user.name} was removed from #{@group}."
+        else
+          reply "#{@user.name} was not in #{@group}."
+        end
+      end
+
+      private
+
+      def valid_message?
+        command, identifier, @group = args
+
+        unless identifier && @group
+          reply "Format: #{robot.name} auth add USER GROUP"
+          return
+        end
+
+        @user = User.find_by_id(identifier)
+        @user = User.find_by_name(identifier) unless @user
+
+        unless @user
+          reply %{No user was found with the identifier "#{identifier}".}
+          return
+        end
+
+        true
+      end
+    end
+
+    Lita.register_handler(Authorization)
+  end
+end

data/lib/lita/handlers/help.rb

@@ -0,0 +1,40 @@
+module Lita
+  module Handlers
+    class Help < Handler
+      route(/^help\s*(.+)?/, to: :help, command: true)
+
+      def self.help
+        robot_name = Lita.config.robot.name
+
+        {
+          "#{robot_name}: help" => "Lists help information for terms and commands #{robot_name} will respond to.",
+          "#{robot_name}: help COMMAND" => "Lists help information for terms and commands starting with COMMAND."
+        }
+      end
+
+      def help(matches)
+        commands = {}
+
+        Lita.handlers.each do |handler|
+          commands.merge!(handler.help) if handler.respond_to?(:help)
+        end
+
+        filter = matches[0][0]
+        if filter
+          robot_name = Lita.config.robot.name
+          commands.select! do |key, value|
+            /^#{filter}/i === key.sub(/^\s*@?#{robot_name}[:,]?\s*/, "")
+          end
+        end
+
+        message = commands.map do |command, description|
+          "#{command} - #{description}"
+        end.join("\n")
+
+        reply message
+      end
+    end
+
+    Lita.register_handler(Help)
+  end
+end

data/lib/lita/message.rb

@@ -6,6 +6,7 @@ module Lita
     alias_method :message, :body
 
     def_delegators :@body, :scan
+    def_delegators :@source, :user
 
     def initialize(robot, body, source)
       @robot = robot

data/lib/lita/robot.rb

@@ -13,6 +13,8 @@ module Lita
 
     def run
       @adapter.run
+    rescue Interrupt
+      shut_down
     end
 
     def send_messages(target, *strings)
@@ -20,6 +22,14 @@ module Lita
     end
     alias_method :send_message, :send_messages
 
+    def set_topic(target, topic)
+      @adapter.set_topic(target, topic)
+    end
+
+    def shut_down
+      @adapter.shut_down
+    end
+
     private
 
     def load_adapter
@@ -27,7 +37,8 @@ module Lita
       adapter_class = Lita.adapters[adapter_name.to_sym]
 
       unless adapter_class
-        raise UnknownAdapterError.new("Unknown adapter: :#{adapter_name}")
+        Lita.logger.fatal("Unknown adapter: :#{adapter_name}.")
+        abort
       end
 
       @adapter = adapter_class.new(self)

data/lib/lita/rspec.rb

@@ -3,18 +3,34 @@ module Lita
     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)
         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)
-      source = Source.new("Test User")
       message = Message.new(robot, body, source)
       robot.receive(message)
     end
@@ -47,5 +63,5 @@ module Lita
 end
 
 RSpec.configure do |config|
-  config.include Lita::RSpec, lita_handler: true
+  config.include Lita::RSpec, lita: true
 end

data/lib/lita/user.rb

@@ -0,0 +1,54 @@
+module Lita
+  class User
+    class << self
+      def redis
+        @redis ||= Redis::Namespace.new("users", redis: Lita.redis)
+      end
+
+      def create(id, metadata = {})
+        user = find_by_id(id)
+        unless user
+          user = new(id, metadata)
+          user.save
+        end
+        user
+      end
+      alias_method :find, :create
+
+      def find_by_id(id)
+        metadata = redis.hgetall("id:#{id}")
+        return new(id, metadata) if metadata.key?("name")
+      end
+
+      def find_by_name(name)
+        id = redis.get("name:#{name}")
+        find_by_id(id) if id
+      end
+    end
+
+    attr_reader :id, :name, :metadata
+
+    def initialize(id, metadata = {})
+      @id = id.to_s
+      @metadata = metadata
+      @name = @metadata[:name] || @metadata["name"] || @id
+    end
+
+    def save
+      redis.pipelined do
+        redis.hmset("id:#{id}", *metadata.to_a.flatten)
+        redis.set("name:#{name}", id)
+      end
+    end
+
+    def ==(other)
+      id == other.id && name == other.name
+    end
+
+    private
+
+    def redis
+      self.class.redis
+    end
+  end
+end

data/lib/lita/version.rb

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

data/lita.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 2.0.0"
+
   spec.add_runtime_dependency "bundler", "~> 1.3"
   spec.add_runtime_dependency "redis-namespace", "~> 1.3.0"
   spec.add_runtime_dependency "thor", "~> 0.18.1"

data/skeleton/Gemfile

@@ -7,3 +7,8 @@ gem "lita"
 
 # Uncomment to use the IRC adapter
 # gem "lita-irc"
+
+# Add handlers to give Lita new functionality.
+# For example:
+# gem "lita-google-images"
+# gem "lita-karma"

data/skeleton/lita_config.rb

@@ -2,6 +2,16 @@ Lita.configure do |config|
   # The name your robot will use.
   config.robot.name = "Lita"
 
+  # The severity of messages to log. Options are:
+  # :debug, :info, :warn, :error, :fatal
+  # Messages at the selected level and above will be logged.
+  config.robot.log_level = :info
+
+  # An array of user IDs that are considered administrators. These users
+  # the ability to add and remove other users from authorization groups.
+  # What is considered a user ID will change depending on which adapter you use.
+  # config.robot.admins = ["1", "2"]
+
   # The adapter you want to connect with. Make sure you've added the
   # appropriate gem to the Gemfile.
   config.robot.adapter = :shell

data/spec/lita/adapter_spec.rb

@@ -3,12 +3,21 @@ require "spec_helper"
 describe Lita::Adapter do
   let(:robot) { double("Robot") }
 
+  let(:required_methods) { [:run, :send_messages, :set_topic, :shut_down] }
+
   subject { described_class.new(robot) }
 
   it "stores a Robot" do
     expect(subject.robot).to eql(robot)
   end
 
+  it "logs a warning if a required method has not been implemented" do
+    expect(Lita.logger).to receive(:warn).exactly(required_methods.size).times
+    required_methods.each do |method|
+      subject.public_send(method)
+    end
+  end
+
   describe ".require_config" do
     let(:adapter_class) do
       Class.new(described_class) do
@@ -21,9 +30,8 @@ describe Lita::Adapter do
     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/)
+      expect(Lita.logger).to receive(:fatal).with(/foo, bar, baz, blah, bleh/)
+      expect { subject }.to raise_error(SystemExit)
     end
   end
 end

data/spec/lita/adapters/shell_spec.rb

@@ -12,16 +12,25 @@ describe Lita::Adapters::Shell do
 
     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")
+      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
   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
   end
+
+  describe "#shut_down" do
+    it "outputs a blank line" do
+      expect(subject).to receive(:puts)
+      subject.shut_down
+    end
+  end
 end

data/spec/lita/authorization_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe Lita::Authorization, lita: true do
+  let(:user) do
+    user = double("User")
+    allow(user).to receive(:id).and_return("1")
+    user
+  end
+
+  describe ".add_user_to_group" do
+    it "adds users to an auth group" do
+      allow(described_class).to receive(:user_is_admin?).and_return(true)
+      described_class.add_user_to_group(user, "employees")
+      expect(described_class.user_in_group?(user, "employees")).to be_true
+    end
+
+    it "can only be called by admins" do
+      allow(described_class).to receive(:user_is_admin?).and_return(false)
+      described_class.add_user_to_group(user, "employees")
+      expect(described_class.user_in_group?(user, "employees")).to be_false
+    end
+  end
+
+  describe ".remove_user_from_group" do
+    it "removes users from an auth group" do
+      allow(described_class).to receive(:user_is_admin?).and_return(true)
+      described_class.add_user_to_group(user, "employees")
+      described_class.remove_user_from_group(user, "employees")
+      expect(described_class.user_in_group?(user, "employees")).to be_false
+    end
+
+    it "can only be called by admins" do
+      allow(described_class).to receive(:user_is_admin?).and_return(true)
+      described_class.add_user_to_group(user, "employees")
+      allow(described_class).to receive(:user_is_admin?).and_return(false)
+      described_class.remove_user_from_group(user, "employees")
+      expect(described_class.user_in_group?(user, "employees")).to be_true
+    end
+  end
+
+  describe ".user_in_group?" do
+    # Positive case is covered by .add_user_to_group's example.
+
+    it "returns false if the user is in the group" do
+      expect(described_class.user_in_group?(user, "employees")).to be_false
+    end
+  end
+
+  describe ".user_is_admin?" do
+    it "returns true if the user's ID is in the config" do
+      Lita.config.robot.admins = "1"
+      expect(described_class.user_is_admin?(user)).to be_true
+    end
+
+    it "returns false if the user's ID is not in the config" do
+      Lita.config.robot.admins = nil
+      expect(described_class.user_is_admin?(user)).to be_false
+    end
+  end
+end