codebot 1.2.0

data/lib/codebot/options/network.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'codebot/network_manager'
+
+module Codebot
+  module Options
+    # A class that handles the +codebot network+ command.
+    class Network < Thor
+      check_unknown_options!
+
+      # Sets shared options for connecting to the IRC network.
+      def self.shared_connection_options
+        option :host, aliases: '-H',
+                      desc: 'Set the server hostname or address'
+        option :port, type: :numeric, aliases: '-p',
+                      desc: 'Set the port to connect to'
+        option :secure, type: :boolean, aliases: '-s',
+                        desc: 'Connect securely using TLS'
+        option :server_password, desc: 'Set the server password'
+        option :nick, aliases: '-N',
+                      desc: 'Set the nickname'
+      end
+
+      # Sets shared options for authenticating to the IRC network.
+      def self.shared_authentication_options
+        # Not a boolean to prevent thor from generating --no-disable-sasl flag
+        option :disable_sasl, type: :string, banner: '',
+                              desc: 'Disable SASL authentication'
+        option :sasl_username, desc: 'Set the username for SASL authentication'
+        option :sasl_password, desc: 'Set the password for SASL authentication'
+
+        option :disable_nickserv, type: :string, banner: '',
+                                  desc: 'Disable NickServ authentication'
+        option :nickserv_username,
+               desc: 'Set the username for NickServ authentication'
+        option :nickserv_password,
+               desc: 'Set the password for NickServ authentication'
+      end
+
+      # Sets shared options for specifying properties belonging to the
+      # {::Codebot::Network} class.
+      def self.shared_propery_options
+        shared_connection_options
+        shared_authentication_options
+        option :bind, aliases: '-b',
+                      desc: 'Bind to the specified IP address or host'
+        option :modes, aliases: '-m',
+                       desc: 'Set user modes'
+      end
+
+      desc 'create NAME', 'Add a new IRC network'
+      shared_propery_options
+
+      # Creates a new network with the specified name.
+      #
+      # @param name [String] the name of the new network
+      def create(name)
+        Options.with_core(parent_options, true) do |core|
+          NetworkManager.new(core.config).create(options.merge(name: name))
+        end
+      end
+
+      desc 'update NAME', 'Edit an IRC network'
+      option :name, aliases: '-n',
+                    banner: 'NEW-NAME',
+                    desc: 'Rename this network'
+      shared_propery_options
+
+      # Updates the network with the specified name.
+      #
+      # @param name [String] the name of the network
+      def update(name)
+        Options.with_core(parent_options, true) do |core|
+          NetworkManager.new(core.config).update(name, options)
+        end
+      end
+
+      desc 'list [SEARCH]', 'List networks'
+
+      # Lists all networks, or networks with names containing the given search
+      # term.
+      #
+      # @param search [String, nil] an optional search term
+      def list(search = nil)
+        Options.with_core(parent_options, true) do |core|
+          NetworkManager.new(core.config).list(search)
+        end
+      end
+
+      desc 'destroy NAME', 'Delete an IRC network'
+
+      # Destroys the network with the specified name.
+      #
+      # @param name [String] the name of the network
+      def destroy(name)
+        Options.with_core(parent_options, true) do |core|
+          NetworkManager.new(core.config).destroy(name, options)
+        end
+      end
+
+      # Ensures that thor uses the correct exit code.
+      #
+      # @return true
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/codebot/payload.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Codebot
+  # A JSON request payload.
+  class Payload
+    # @return [Object] the JSON object parsed from the request payload
+    attr_reader :json
+
+    # Constructs a new payload.
+    #
+    # @param payload [String] the request payload
+    def initialize(payload)
+      @json = JSON.parse payload
+    end
+
+    # Returns the JSON payload.
+    #
+    # @return [Object] the JSON object
+    def to_json
+      @json
+    end
+
+    # Returns the JSON string corresponding to the payload.
+    #
+    # @return [String] the JSON string
+    def to_s
+      @json.to_s
+    end
+  end
+end

data/lib/codebot/request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'codebot/message'
+require 'codebot/payload'
+
+module Codebot
+  # A request which was received by the web server and can be delivered to the
+  # IRC client.
+  class Request
+    # @return [Integration] the integration to deliver this request to
+    attr_reader :integration
+
+    # @return [Symbol] the event that triggered the webhook delivery
+    attr_reader :event
+
+    # @return [Payload] the parsed request payload
+    attr_reader :payload
+
+    # Constructs a new request for delivery to the IRC client.
+    #
+    # @param integration [Integration] the integration for which the request
+    #                                  was made
+    # @param event [Symbol] the event that triggered the webhook delivery
+    # @param payload [String] a JSON string containing the request payload
+    def initialize(integration, event, payload)
+      @integration = integration
+      @event       = event
+      @payload     = Payload.new payload
+    end
+
+    # Invokes the given block for each network this request needs to be
+    # delivered to.
+    #
+    # @yieldparam [Network] the network
+    # @yieldparam [Array<Channels>] channels that belong to the network and
+    #                               that a notification should be delivered to
+    def each_network
+      integration.channels.group_by(&:network).each do |network, channels|
+        yield network, channels
+      end
+    end
+
+    # Creates a message for a given channel from this request.
+    #
+    # @param channel [Channel] the channel
+    # @return [Message] the created message
+    def to_message_for(channel)
+      Message.new(channel, @event, @payload, @integration)
+    end
+  end
+end

data/lib/codebot/sanitizers.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'codebot/cryptography'
+require 'codebot/validation_error'
+
+module Codebot
+  # This module provides data sanitization methods shared among multiple
+  # classes.
+  module Sanitizers
+    # Sanitizes an identifier.
+    #
+    # @param identifier [String, nil] the identifier to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_identifier(identifier)
+      identifier.downcase if /\A[[:alnum:]_-]+\z/ =~ identifier
+    end
+
+    # Sanitizes an endpoint name.
+    #
+    # @param endpoint [String, nil] the endpoint name to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_endpoint(endpoint)
+      endpoint if /\A[[:alnum:]_-]*\z/ =~ endpoint
+    end
+
+    # Sanitizes a webhook secret.
+    #
+    # @param secret [String, nil] the webhook secret to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_secret(secret)
+      secret if /\A[[:print:]]*\z/ =~ secret
+    end
+
+    # Sanitizes a hostname.
+    #
+    # @param host [String, nil] the hostname to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_host(host)
+      host if /\A[[:graph:]]+\z/ =~ host
+    end
+
+    # Sanitizes a TCP/IP port number.
+    #
+    # @param port [#to_i, #to_s] the port number to sanitize
+    # @return [Integer, nil] the sanitized value or +nil+ on error
+    def valid_port(port)
+      port_number = port.to_s.to_i(10) if /\A[0-9]+\z/ =~ port.to_s
+      port_number if (1...2**16).cover? port_number
+    end
+
+    # Sanitizes a boolean value.
+    #
+    # @param bool [Boolean, nil] the boolean to sanitize
+    # @return [Boolean, nil] the sanitized value or +nil+ on error
+    def valid_boolean(bool)
+      bool if [true, false].include? bool
+    end
+
+    # Sanitizes a string.
+    #
+    # @param str [String, nil] the string to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_string(str)
+      str if str.is_a? String
+    end
+
+    # Sanitizes a channel name.
+    #
+    # @param channel [String, nil] the channel name to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_channel_name(channel)
+      # Colons are currently not considered valid characters because some IRCds
+      # use them to delimit channel masks. This might change in the future.
+      channel if /\A[&#\+!][[:graph:]&&[^:,]]{,49}\z/ =~ channel
+    end
+
+    # Sanitizes a channel key.
+    #
+    # @param key [String, nil] the channel key to sanitize
+    # @return [String, nil] the sanitized value or +nil+ on error
+    def valid_channel_key(key)
+      key if /\A[[:graph:]&&[^,]]*\z/ =~ key
+    end
+
+    # Sanitizes a network name.
+    #
+    # @param name [String] the name of the network
+    # @param conf [Hash] the configuration containing all networks
+    # @return [Network, nil] the corresponding network or +nil+ on error
+    def valid_network(name, conf)
+      return if name.nil?
+
+      conf[:networks].find { |net| net.name_eql? name }
+    end
+
+    # This method requires a validation to succeed, raising an exception if it
+    # does not. If no original value was provided, it returns, in this order,
+    # the given fallback, the return value of any block passed to this method,
+    # or, finally, +nil+, unless the +:required+ option is set, in which case
+    # a +ValidationError+ is raised.
+    #
+    # @param original [Object] the original value
+    # @param sanitized [Object] the sanitized value
+    # @param fallback [Object] an optional symbol representing an instance
+    #                          variable to be returned when the original value
+    #                          is +nil+
+    # @raise [ValidationError] if the sanitization failed. The error message may
+    #                          be set using the +:invalid_error+ option.
+    # @raise [ValidationError] if the +:required+ option is set, but neither an
+    #                          original value nor a fallback value was specified
+    #                          and no block was given. The error message may be
+    #                          set using the +:required_error+ option.
+    # @param options [Hash] a hash optionally containing additional settings.
+    def valid!(original, sanitized, fallback = nil, options = {})
+      return sanitized unless sanitized.nil?
+      unless original.nil?
+        raise ValidationError, options[:invalid_error] % original.inspect
+      end
+      return instance_variable_get(fallback) if fallback_exist?(fallback)
+      return yield if block_given?
+      raise ValidationError, options[:required_error] if options[:required]
+    end
+
+    private
+
+    def fallback_exist?(fallback)
+      !fallback.nil? && instance_variable_defined?(fallback)
+    end
+  end
+end

data/lib/codebot/serializable.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'codebot/configuration_error'
+
+module Codebot
+  # A class that can be serialized. Child classes should override the
+  # {#serialize} and {::deserialize} methods, and change {::serialize_as_hash?}
+  # to return +true+ if the {#serialize} method returns an +Array+ containing
+  # two elements representing key and value of a +Hash+.
+  class Serializable
+    # Serializes an array into an array or a hash.
+    #
+    # @param ary [Array] the data to serialize
+    # @param conf [Hash] the deserialized configuration
+    # @return [Array, Hash] the serialized data
+    def self.serialize_all(ary, conf)
+      data = ary.map { |entry| entry.serialize(conf) }
+      return data.to_h if serialize_as_hash?
+
+      data
+    end
+
+    # Deserializes an array or a hash into an array.
+    #
+    # @param data [Array, Hash] the data to deserialize
+    # @param conf [Hash] the previously deserialized configuration
+    # @return [Array] the deserialized data
+    def self.deserialize_all(data, conf)
+      return [] if data.nil?
+
+      if serialize_as_hash?
+        deserialize_all_from_hash(data, conf)
+      else
+        deserialize_all_from_array(data, conf)
+      end
+    end
+
+    # Serializes this object.
+    #
+    # @note Child classes should override this method.
+    # @param _conf [Hash] the deserialized configuration
+    # @return [Array, Hash] the serialized object
+    def serialize(_conf)
+      []
+    end
+
+    # Deserializes an object.
+    #
+    # @note Child classes should override this method.
+    # @param _key [Object] the hash key if the value was serialized into a hash
+    # @param _val [Hash] the serialized data
+    # @return [Hash] the parameters to pass to the initializer
+    def self.deserialize(_key = nil, _val)
+      {}
+    end
+
+    # Returns whether data is serialized into a hash rather than an array.
+    #
+    # @note Child classes might want to override this method.
+    # @return [Boolean] whether data is serialized into an array containing two
+    #                   elements representing key and value of a +Hash+.
+    def self.serialize_as_hash?
+      false
+    end
+
+    # Deserializes an array into an array.
+    #
+    # @param data [Array] the data to deserialize
+    # @param conf [Hash] the previously deserialized configuration
+    # @return [Array] the deserialized data
+    def self.deserialize_all_from_array(data, conf)
+      unless data.is_a? Array
+        raise ConfigurationError, "#{name}: invalid array #{data.inspect}"
+      end
+
+      data.map { |item| new(deserialize(item).merge(config: conf)) }
+    end
+
+    # Deserializes a hash into an array.
+    #
+    # @param data [Hash] the data to deserialize
+    # @param conf [Hash] the previously deserialized configuration
+    # @return [Array] the deserialized data
+    def self.deserialize_all_from_hash(data, conf)
+      unless data.is_a? Hash
+        raise ConfigurationError, "#{name}: invalid hash #{data.inspect}"
+      end
+
+      data.map do |item|
+        unless item.length == 2
+          raise ConfigurationError, "#{name}: invalid member #{item.inspect}"
+        end
+
+        new(deserialize(*item).merge(config: conf))
+      end
+    end
+
+    private_class_method :deserialize_all_from_array
+    private_class_method :deserialize_all_from_hash
+  end
+end

data/lib/codebot/shortener.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Codebot
+  module Shortener
+    # Shortens URLs using Github shortener
+    class Github
+      # Shortens a URL with GitHub's git.io URL shortener. The domain
+      # must belong to GitHub.
+      #
+      # @param url [String] the long URL
+      # @return [String] the shortened URL, or the original URL if an error
+      #                  occurred.
+      def shorten_url(url)
+        return url if url.to_s.empty?
+
+        uri = URI('https://git.io')
+        res = Net::HTTP.post_form uri, 'url' => url.to_s
+        res['location'] || url.to_s
+      rescue StandardError
+        url.to_s
+      end
+    end
+
+    # Shortens URLs using a custom shortener
+    class Custom
+      def initialize(shortener_url, shortener_secret)
+        @shortener_url = URI(shortener_url)
+        @shortener_secret = shortener_secret
+      end
+
+      def shorten_url(url)
+        return url if url.to_s.empty?
+
+        res = Net::HTTP.post_form @shortener_url,
+                                  'url' => url.to_s,
+                                  'secret' => @shortener_secret
+        res.body.strip || url.to_s
+      rescue StandardError
+        url.to_s
+      end
+    end
+  end
+end