codebot 1.2.0

data/lib/codebot/irc_connection.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'codebot/message'
+require 'codebot/thread_controller'
+require 'codebot/ext/cinch/ssl_extensions'
+require 'cinch'
+require 'cinch/plugins/identify'
+
+module Codebot
+  # This class manages an IRC connection running in a separate thread.
+  class IRCConnection < ThreadController
+    # @return [Core] the bot this connection belongs to
+    attr_reader :core
+
+    # @return [Network] the connected network
+    attr_reader :network
+
+    # Constructs a new IRC connection.
+    #
+    # @param core [Core] the bot this connection belongs to
+    # @param network [Network] the network to connect to
+    def initialize(core, network)
+      @core     = core
+      @network  = network
+      @messages = Queue.new
+      @ready    = Queue.new
+    end
+
+    # Schedules a message for delivery.
+    #
+    # @param message [Message] the message
+    def enqueue(message)
+      @messages << message
+    end
+
+    # Sets this connection to be available for delivering messages.
+    def set_ready!
+      @ready << true if @ready.empty?
+    end
+
+    # Starts a new managed thread if no thread is currently running.
+    # The thread invokes the +run+ method of the class that manages it.
+    #
+    # @return [Thread, nil] the newly created thread, or +nil+ if
+    #                       there was already a running thread
+    def start(*)
+      super(self)
+    end
+
+    def configure_nickserv_identification(net, conn)
+      return unless net.nickserv?
+
+      conn.plugins.plugins = [Cinch::Plugins::Identify]
+      conn.plugins.options[Cinch::Plugins::Identify] = {
+        username: nil_or_empty_string(net.nickserv_username),
+        password: net.nickserv_password,
+        type: :nickserv
+      }
+    end
+
+    private
+
+    # Starts this IRC thread.
+    #
+    # @param connection [IRCConnection] the connection the thread controls
+    def run(connection)
+      @connection = connection
+      bot = create_bot(connection)
+      thread = Thread.new { bot.start }
+      @ready.pop
+      loop { deliver bot, dequeue }
+    ensure
+      thread.exit unless thread.nil?
+    end
+
+    # Dequeue the next message.
+    #
+    # @return the message
+    def dequeue
+      @messages.pop
+    end
+
+    # Delivers a message to an IRC channel.
+    #
+    # @param bot [Cinch::Bot] the IRC bot
+    # @param message [Message] the message to deliver
+    def deliver(bot, message)
+      channel = bot.Channel(message.channel.name)
+      message.format.to_a.each do |msg|
+        channel.send msg
+      end
+    end
+
+    # Gets the list of channels associated with this network.
+    #
+    # @param config [Config] the configuration to search
+    # @param network [Network] the network to search for
+    # @return [Array<Channel>] the list of channels
+    def channels(config, network)
+      config.integrations.map(&:channels).flatten.select do |channel|
+        network == channel.network
+      end
+    end
+
+    # Gets the list of channel names and keys associated with this network.
+    # Each array element is a string containing either the channel name if no
+    # key is needed, or the channel name and key, separated by a space.
+    #
+    # @param config [Config] the configuration to search
+    # @param network [Network] the network to search for
+    # @return [Array<String>] the list of channel names and keys
+    def channel_array(config, network)
+      channels(config, network).map do |channel|
+        "#{channel.name} #{channel.key}".strip
+      end
+    end
+
+    def nil_or_empty_string(val)
+      if val.to_s.empty?
+        nil
+      else
+        val
+      end
+    end
+
+    # Constructs a new bot for the given IRC network.
+    #
+    # @param con [IRCConnection] the connection the thread controls
+    def create_bot(con) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      net = con.network
+      chan_ary = channel_array(con.core.config, network)
+      cc = self
+      Cinch::Bot.new do
+        configure do |c|
+          c.channels      = chan_ary
+          c.local_host    = net.bind
+          c.modes         = net.modes.to_s.gsub(/\A\+/, '').chars.uniq
+          c.nick          = net.nick
+          c.password      = net.server_password
+          c.port          = net.real_port
+          c.realname      = Codebot::WEBSITE
+          if net.sasl?
+            c.sasl.username = net.sasl_username
+            c.sasl.password = net.sasl_password
+          end
+          c.server        = net.host
+          c.ssl.use       = net.secure
+          c.ssl.verify    = net.secure
+          c.user          = Codebot::PROJECT.downcase
+          cc.configure_nickserv_identification(net, c)
+        end
+        on(:join) { con.set_ready! }
+      end
+    end
+  end
+end

data/lib/codebot/message.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'codebot/payload'
+require 'codebot/formatters'
+
+module Codebot
+  # An IRC message generated by a {Request} and sent to a {Channel}.
+  class Message
+    # @return [Channel] the channel to send this message to
+    attr_reader :channel
+
+    # @return [Symbol] the event that caused this message to be sent
+    attr_reader :event
+
+    # @return [Payload] the parsed request payload
+    attr_reader :payload
+
+    # Constructs a new message for delivery to an IRC channel.
+    #
+    # @param channel [Channel] the channel to send this message to
+    # @param event [Symbol] the event that caused this message to be sent
+    # @param payload [Payload] the parsed request payload
+    def initialize(channel, event, payload, integration)
+      @channel = channel
+      @event   = event
+      @payload = payload
+      @integration = integration
+    end
+
+    # Formats this message for delivery to an IRC channel.
+    #
+    # @return [Array<String>] the formatted IRC messages
+    def format
+      Formatters.format(@event, @payload.to_json, @integration)
+    end
+  end
+end

data/lib/codebot/metadata.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Codebot
+  # The project name.
+  PROJECT = 'Codebot'.freeze
+
+  # The current project version.
+  VERSION = '1.2.0'.freeze
+
+  # The project website.
+  WEBSITE = 'https://github.com/olabini/codebot'.freeze
+
+  # The URL to report issues with a message formatter to.
+  FORMATTER_ISSUE_URL = 'https://github.com/olabini/codebot/issues/new?template=formatter_issue.md'.freeze
+end

data/lib/codebot/network.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'codebot/sanitizers'
+require 'codebot/serializable'
+
+module Codebot
+  # This class represents an IRC network notifications can be delivered to.
+  class Network < Serializable # rubocop:disable Metrics/ClassLength
+    include Sanitizers
+
+    # @return [String] the name of this network
+    attr_reader :name
+
+    # @return [String] the hostname or IP address used for connecting to this
+    #                  network
+    attr_reader :host
+
+    # @return [Integer] the port used for connecting to this network
+    attr_reader :port
+
+    # @return [Boolean] whether TLS should be used when connecting to this
+    #                   network
+    attr_reader :secure
+
+    # @return [String] the server password
+    attr_reader :server_password
+
+    # @return [String] the primary nickname for this network
+    attr_reader :nick
+
+    # @return [String] the username for SASL authentication
+    attr_reader :sasl_username
+
+    # @return [String] the password for SASL authentication
+    attr_reader :sasl_password
+
+    # @return [String] the username for NickServ authentication
+    attr_reader :nickserv_username
+
+    # @return [String] the password for NickServ authentication
+    attr_reader :nickserv_password
+
+    # @return [String] the address to bind to
+    attr_reader :bind
+
+    # @return [String] user modes to set
+    attr_reader :modes
+
+    # Creates a new network from the supplied hash.
+    #
+    # @param params [Hash] A hash with symbolic keys representing the instance
+    #                      attributes of this network. The keys +:name+ and
+    #                      +:host+ are required.
+    def initialize(params)
+      update!(params)
+    end
+
+    # Updates the network from the supplied hash.
+    #
+    # @param params [Hash] A hash with symbolic keys representing the instance
+    #                      attributes of this network.
+    def update!(params)
+      self.name            = params[:name]
+      self.server_password = params[:server_password]
+      self.nick            = params[:nick]
+      self.bind            = params[:bind]
+      self.modes           = params[:modes]
+      update_complicated!(params)
+    end
+
+    def update_complicated!(params)
+      update_connection(params[:host], params[:port], params[:secure])
+      update_sasl(params[:disable_sasl],
+                  params[:sasl_username], params[:sasl_password])
+      update_nickserv(params[:disable_nickserv],
+                      params[:nickserv_username], params[:nickserv_password])
+    end
+
+    def name=(name)
+      @name = valid! name, valid_identifier(name), :@name,
+                     required: true,
+                     required_error: 'networks must have a name',
+                     invalid_error: 'invalid network name %s'
+    end
+
+    # Updates the connection details of this network.
+    #
+    # @param host [String] the new hostname, or +nil+ to keep the current value
+    # @param port [Integer] the new port, or +nil+ to keep the current value
+    # @param secure [Boolean] whether to connect over TLS, or +nil+ to keep the
+    #                         current value
+    def update_connection(host, port, secure)
+      @host = valid! host, valid_host(host), :@host,
+                     required: true,
+                     required_error: 'networks must have a hostname',
+                     invalid_error: 'invalid hostname %s'
+      @port = valid! port, valid_port(port), :@port,
+                     invalid_error: 'invalid port number %s'
+      @secure = valid!(secure, valid_boolean(secure), :@secure,
+                       invalid_error: 'secure must be a boolean') { false }
+    end
+
+    def server_password=(pass)
+      @server_password = valid! pass, valid_string(pass), :@server_password,
+                                invalid_error: 'invalid server password %s'
+    end
+
+    def nick=(nick)
+      @nick = valid! nick, valid_string(nick), :@nick,
+                     required: true,
+                     required_error: "no nickname for #{@name.inspect} given",
+                     invalid_error: 'invalid nickname %s'
+    end
+
+    # Updates the SASL authentication details of this network.
+    #
+    # @param disable [Boolean] whether to disable SASL, or +nil+ to keep the
+    #                          current value.
+    # @param user [String] the SASL username, or +nil+ to keep the current value
+    # @param pass [String] the SASL password, or +nil+ to keep the current value
+    def update_sasl(disable, user, pass)
+      @sasl_username = valid! user, valid_string(user), :@sasl_username,
+                              invalid_error: 'invalid SASL username %s'
+      @sasl_password = valid! pass, valid_string(pass), :@sasl_password,
+                              invalid_error: 'invalid SASL password %s'
+      return unless disable
+
+      @sasl_username = nil
+      @sasl_password = nil
+    end
+
+    # Updates the NickServ authentication details of this network.
+    #
+    # @param disable [Boolean] whether to disable NickServ, or +nil+ to keep the
+    #                          current value.
+    # @param user [String] the NickServ username, or +nil+ to keep the
+    #                          current value
+    # @param pass [String] the NickServ password, or +nil+ to keep the
+    #                          current value
+    def update_nickserv(disable, user, pass)
+      @nickserv_username = valid! user, valid_string(user), :@nickserv_username,
+                                  invalid_error: 'invalid NickServ username %s'
+      @nickserv_password = valid! pass, valid_string(pass), :@nickserv_password,
+                                  invalid_error: 'invalid NickServ password %s'
+      return unless disable
+
+      @nickserv_username = nil
+      @nickserv_password = nil
+    end
+
+    def bind=(bind)
+      @bind = valid! bind, valid_string(bind), :@bind,
+                     invalid_error: 'invalid bind host %s'
+    end
+
+    def modes=(modes)
+      @modes = valid! modes, valid_string(modes), :@modes,
+                      invalid_error: 'invalid user modes %s'
+    end
+
+    # Checks whether the name of this network is equal to another name.
+    #
+    # @param name [String] the other name
+    # @return [Boolean] +true+ if the names are equal, +false+ otherwise
+    def name_eql?(name)
+      @name.casecmp(name).zero?
+    end
+
+    # Returns the port used for connecting to this network, or the default port
+    # if no port is set.
+    #
+    # @return [Integer] the port
+    def real_port
+      port || (secure ? 6697 : 6667)
+    end
+
+    # Checks whether SASL is enabled for this network.
+    #
+    # @return [Boolean] whether SASL is enabled
+    def sasl?
+      !sasl_username.to_s.empty? && !sasl_password.to_s.empty?
+    end
+
+    # Checks whether NickServ is enabled for this network.
+    #
+    # @return [Boolean] whether NickServ is enabled
+    def nickserv?
+      !nickserv_username.to_s.empty? || !nickserv_password.to_s.empty?
+    end
+
+    # Checks whether this network is equal to another network.
+    #
+    # @param other [Object] the other network
+    # @return [Boolean] +true+ if the networks are equal, +false+ otherwise
+    def ==(other)
+      other.is_a?(Network) &&
+        name_eql?(other.name) &&
+        host.eql?(other.host) &&
+        port.eql?(other.port) &&
+        secure.eql?(other.secure)
+    end
+
+    # Generates a hash for this network.
+    #
+    # @return [Integer] the hash
+    def hash
+      [name, host, port, secure].hash
+    end
+
+    alias eql? ==
+
+    # Serializes this network.
+    #
+    # @param _conf [Hash] the deserialized configuration
+    # @return [Array, Hash] the serialized object
+    def serialize(_conf)
+      [name, Network.fields.map { |sym| [sym.to_s, send(sym)] }.to_h]
+    end
+
+    # Deserializes a network.
+    #
+    # @param name [String] the name of the network
+    # @param data [Hash] the serialized data
+    # @return [Hash] the parameters to pass to the initializer
+    def self.deserialize(name, data)
+      fields.map { |sym| [sym, data[sym.to_s]] }.to_h.merge(name: name)
+    end
+
+    # @return [true] to indicate that data is serialized into a hash
+    def self.serialize_as_hash?
+      true
+    end
+
+    # @return [Array<Symbol>] the fields used for serializing this network
+    def self.fields
+      %i[host port secure server_password nick sasl_username sasl_password
+         nickserv_username nickserv_password bind modes]
+    end
+  end
+end