chatrix-bot 1.0.0.pre

data/lib/chatrix/bot/plugin.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'chatrix/bot/command'
+require 'chatrix/bot/pattern'
+
+module Chatrix
+  class Bot
+    # Base class for bot plugins.
+    #
+    # Plugins will get their class name (lowercased) as their main
+    # command name. Meaning if you make a class as such:
+    #   class MyPlugin < Plugin
+    # It will be called using `!myplugin` in the chat.
+    #
+    # Additional command aliases can be specified with TODO.
+    class Plugin
+      # Initializes a new Plugin instance.
+      # @param bot [Chatrix::Bot] The bot instance in control of the plugin.
+      def initialize(bot)
+        @bot = bot
+        @log = @bot.log
+      end
+
+      # Handles a plugin command.
+      #
+      # @param room [Room] The room the command was sent in.
+      # @param sender [User] The user who issued the command.
+      # @param name [String] The name of the command.
+      # @param body [String] The command body (text after command name).
+      def handle_command(room, sender, name, body)
+        command = self.class.command name
+
+        unless @bot.admin? sender
+          check_command_permissions(room, command, sender)
+        end
+
+        data = command.parse body
+        meth = command.handler || :on_command
+        send(meth, room, sender, command.name, data) if respond_to? meth
+      end
+
+      # Parses a message from a room.
+      # If there are any patterns registred for the plugin that matches the
+      # message body, the relevant handlers on the plugin will be invoked for
+      # the message.
+      #
+      # All messages, regardless of patterns, will be passed to the
+      # `:on_message` method, if it is defined.
+      #
+      # @param room [Room] The room the message was sent in.
+      # @param sender [User] The user who sent the message.
+      # @param message [Message] The message that was sent.
+      def parse_message(room, message)
+        send(:on_message, room, message) if respond_to? :on_message
+        pattern = self.class.match message.body
+        handle_match(room, message, pattern) if pattern
+      rescue => e
+        @log.error "Error while parsing message in #{self.class}: #{e.inspect}"
+      end
+
+      private
+
+      def handle_match(room, message, pattern)
+        meth = pattern.handler || :on_match
+        return unless respond_to? meth
+        send meth, room, message, pattern.match(message.body)
+      end
+
+      def check_command_permissions(room, command, sender)
+        user_power = sender.power_in room
+        raise PermissionError unless user_power >= self.class.command_power
+        command.test
+      end
+
+      class << self
+        attr_reader :commands
+
+        attr_reader :command_power
+
+        def inherited(subclass)
+          {
+            :@commands => [], :@patterns => [], :@command_power => 0
+          }.each { |var, val| subclass.instance_variable_set(var, val) }
+        end
+
+        def command?(name)
+          !command(name).nil?
+        end
+
+        # Gets the command with the specified name (or alias).
+        # @param name [String] The name to search for, can also be an alias.
+        # @return [Command] The command with the specified name or alias.
+        def command(name)
+          @commands.find { |c| c.name_or_alias?(name) }
+        end
+
+        # Attempts to match the given string against all the patterns defined
+        # for the plugin.
+        # @param text [String] The text to check for matches.
+        # @return [Pattern, nil] The result of the first successful match,
+        #   or `nil` if no match was found.
+        def match(text)
+          @patterns.find { |p| p.match? text }
+        end
+
+        protected
+
+        # Registers a command that the plugin should respond to.
+        #
+        # @param command [String] The name of the command.
+        # @param syntax [String] Command syntax, this is used to determine
+        #   the parameters accepted by the command. See {Parameter} for more
+        #   information on parameters and {Command} for more information
+        #   regarding the structure of the syntax string.
+        # @param help [String] Help text for the command.
+        # @param opts [Hash] Additional options.
+        #
+        # @option opts [Symbol] :handler Name of the method in the plugin class
+        #   that should handle this command.
+        # @option opts [Array<String>] :aliases A list of aliases that can be
+        #   used to call this command in addition to the main name.
+        def register_command(command, syntax, help, opts = {})
+          @commands.push Command.new command.to_s.downcase, syntax, help, opts
+        end
+
+        # Registers a RegEx pattern that the plugin should listen to
+        # with an optional explicit handler for the match.
+        #
+        # @param pattern [Regexp] The RegEx pattern to add.
+        # @param handler [Symbol, nil] The method to call on the plugin when
+        #   a matching message is detected.
+        def register_pattern(pattern, handler = nil)
+          @patterns.push Pattern.new pattern, handler
+        end
+
+        # Adds RegEx patterns to the plugin.
+        # @param patterns [Regexp] RegEx patterns to add.
+        def register_patterns(*patterns)
+          patterns.each { |p| @patterns.push Pattern.new p }
+        end
+
+        def command_restriction(level)
+          @command_power = level
+        end
+      end
+    end
+  end
+end

data/lib/chatrix/bot/plugin_manager.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'chatrix/bot/plugins'
+
+module Chatrix
+  class Bot
+    # Manages plugins for the bot.
+    class PluginManager
+      def initialize(bot)
+        @bot = bot
+
+        @log = @bot.log
+
+        # The plugins hash will have the plugin type as the key, and the
+        # instance of the plugin as the value.
+        @plugins = {}
+
+        add_standard_plugins
+      end
+
+      def add(type)
+        unless type < Plugin
+          raise ArgumentError, 'Argument must be a plugin type'
+        end
+
+        return if @plugins.key? type
+
+        @log.info "Adding new plugin: #{type}"
+
+        @plugins[type] = type.new @bot
+      end
+
+      def remove(type)
+        return unless @plugins.key? type
+        @log.info "Removing plugin: #{type}"
+        plugin = @plugins[type]
+        plugin.removed if plugin.respond_to? :removed
+        @plugins[type] = nil
+      end
+
+      def types
+        @plugins.keys
+      end
+
+      def plugins
+        @plugins.values
+      end
+
+      def parse_message(room, message)
+        return parse_command(room, message) if Command.command? message.body
+        plugins.each { |p| p.parse_message room, message }
+      end
+
+      private
+
+      def parse_command(room, message)
+        data = Command.parse message.body
+
+        type = types.find { |t| t.command? data[:name] }
+
+        plugin = @plugins[type]
+
+        send_command(plugin, room, message.sender, data) if plugin
+      end
+
+      def send_command(plugin, room, sender, data)
+        plugin.handle_command(room, sender, data[:name], data[:body])
+      rescue PermissionError
+        room.messaging.send_notice <<~EOF
+          I'm sorry, #{sender}, I cannot let you do that.
+        EOF
+      rescue => e
+        @log.error "Error parsing #{data[:name]} command in #{room}"
+        room.messaging.send_notice "Command error: #{e.class}:#{e.message}"
+      end
+
+      def add_standard_plugins
+        Plugins.constants.each { |c| add(Plugins.const_get(c)) }
+      end
+    end
+  end
+end

data/lib/chatrix/bot/plugins.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'chatrix/bot/plugin'
+
+module Chatrix
+  class Bot
+    # Contains a number of standard plugins for the bot.
+    module Plugins
+    end
+  end
+end
+
+require 'chatrix/bot/plugins/help'
+require 'chatrix/bot/plugins/echo'
+require 'chatrix/bot/plugins/hug'

data/lib/chatrix/bot/plugins/echo.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Chatrix
+  class Bot
+    module Plugins
+      # Provides a command to make the bot echo what was passed in as
+      # argument to the command.
+      class Echo < Plugin
+        command_restriction 50
+
+        register_command 'echo', '<text>',
+                         'Makes the bot echo the specified text to chat',
+                         aliases: ['say'], handler: :say
+
+        register_command 'act', '<text>',
+                         'Makes the bot perform an emote',
+                         aliases: %w(em emote), handler: :emote
+
+        register_command 'notice', '<text>', 'Sends a notice', handler: :notice
+
+        def say(room, _sender, _command, args)
+          room.messaging.send_message args[:text]
+        end
+
+        def emote(room, _sender, _command, args)
+          room.messaging.send_emote args[:text]
+        end
+
+        def notice(room, _sender, _command, args)
+          room.messaging.send_notice args[:text]
+        end
+      end
+    end
+  end
+end

data/lib/chatrix/bot/plugins/help.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Chatrix
+  class Bot
+    module Plugins
+      # Provides a help command.
+      class Help < Plugin
+        register_command 'help', '[command]',
+                         'Gives general help or specific help for a command',
+                         handler: :help, aliases: ['h']
+
+        def help(room, sender, _command, args)
+          @log.debug "#{sender} is requesting help"
+          command = args[:command]
+          command.nil? ? general_help(room) : command_help(room, command)
+        end
+
+        private
+
+        def general_help(room)
+          commands = []
+
+          @bot.plugin_manager.types.each do |type|
+            commands.concat type.commands.map(&:name)
+          end
+
+          room.messaging.send_notice <<~EOF
+            Available commands: #{commands.uniq.join ', '}
+            For help about a command, type #{Command.stylize('help')} <command>
+          EOF
+        end
+
+        def command_help(room, command)
+          type = @bot.plugin_manager.types.find { |t| t.command? command }
+
+          cmd = type.command(command) if type
+
+          if cmd
+            room.messaging.send_notice <<~EOF
+              Command #{cmd.name} provided by #{type} plugin.
+              #{cmd.usage}
+            EOF
+          else
+            room.messaging.send_notice 'No plugin found providing that command'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chatrix/bot/plugins/hug.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Chatrix
+  class Bot
+    module Plugins
+      # Plugin that hugs sad people!
+      class Hug < Plugin
+        # Matches :(, :'(, D:, D':, ):, )':, ;-;, ;_;
+        register_pattern(/(?<!\S)(?:\:'?\(|D'?:|\)'?:|;[\-_];)(?!\S)/, :hug)
+        register_pattern(/(?<!\S)(?:\:'?c)(?!\S)/i, :hug)
+
+        # Method to handle messages that contain sad faces.
+        def hug(room, message, _match)
+          sender = message.sender
+          @log.debug "#{sender} is in need of some love!"
+          room.messaging.send_emote "hugs #{sender.displayname || sender}"
+          @log.debug 'Love sent'
+        end
+      end
+    end
+  end
+end

data/lib/chatrix/bot/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Chatrix
+  class Bot
+    # The current version of chatrix-bot.
+    VERSION = '1.0.0.pre'
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: chatrix-bot
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre
+platform: ruby
+authors:
+- Adam Hellberg
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chatrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+description: 
+email:
+- sharparam@sharparam.com
+executables:
+- chatrix-bot
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- chatrix-bot.gemspec
+- exe/chatrix-bot
+- lib/chatrix/bot.rb
+- lib/chatrix/bot/command.rb
+- lib/chatrix/bot/config.rb
+- lib/chatrix/bot/errors.rb
+- lib/chatrix/bot/parameter.rb
+- lib/chatrix/bot/pattern.rb
+- lib/chatrix/bot/plugin.rb
+- lib/chatrix/bot/plugin_manager.rb
+- lib/chatrix/bot/plugins.rb
+- lib/chatrix/bot/plugins/echo.rb
+- lib/chatrix/bot/plugins/help.rb
+- lib/chatrix/bot/plugins/hug.rb
+- lib/chatrix/bot/version.rb
+homepage: https://github.com/Sharparam/chatrix-bot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A Ruby chatbot for Matrix with plugin support
+test_files: []
+has_rdoc: