ircinch 2.4.0

data/lib/cinch/user.rb

@@ -0,0 +1,489 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+require_relative "target"
+
+module Cinch
+  # @attr_reader [String] authname
+  # @attr_reader [String, nil] away The user's away message, or
+  #   `nil` if not away.
+  # @attr_reader [Array<Channel>] channels All channels the user is
+  #   in.
+  # @attr_reader [String] host
+  # @attr_reader [Integer] idle How long this user has been idle, in seconds.
+  #   This is a snapshot of the last WHOIS.
+  # @attr_reader [String] nick The user's nickname
+  # @attr_reader [Boolean] online True if the user is online.
+  # @attr_reader [Boolean] oper True if the user is an IRC operator.
+  # @attr_reader [String] realname
+  # @attr_reader [Boolean] secure True if the user is using a secure
+  #   connection, i.e. SSL.
+  # @attr_reader [Time] signed_on_at
+  # @attr_reader [Boolean] unknown True if the instance references an user who
+  #   cannot be found on the server.
+  # @attr_reader [String] user
+  #
+  # @version 2.0.0
+  class User < Target
+    include Syncable
+
+    def nick
+      name
+    end
+
+    # @return [String]
+    # @since 1.1.0
+    attr_reader :last_nick
+
+    # @return [Boolean]
+    attr_reader :synced
+    # @since 2.1.0
+    alias_method :synced?, :synced
+
+    # @return [Boolean]
+    # @api private
+    attr_accessor :in_whois
+
+    def user
+      attr(:user, true, false)
+    end
+
+    def host
+      attr(:host, true, false)
+    end
+
+    def realname
+      attr(:realname, true, false)
+    end
+
+    def authname
+      attr(:authname, true, false)
+    end
+
+    def away
+      attr(:away, true, false)
+    end
+
+    def idle
+      attr(:idle, true, false)
+    end
+
+    def signed_on_at
+      attr(:signed_on_at, true, false)
+    end
+
+    def unknown
+      attr(:unknown?, true, false)
+    end
+    alias_method :unknown?, :unknown
+
+    # @note This attribute will be updated by various events, but
+    # unless {#monitor} is being used, this information cannot be
+    # ensured to be always correct.
+    def online
+      attr(:online?, true, false)
+    end
+    alias_method :online?, :online
+
+    def channels
+      attr(:channels, true, false)
+    end
+
+    def secure
+      attr(:secure?, true, false)
+    end
+    alias_method :secure?, :secure
+
+    # @since 2.1.0
+    def oper
+      attr(:oper?, true, false)
+    end
+    alias_method :oper?, :oper
+
+    # @private
+    def user_unsynced
+      attr(:user, true, true)
+    end
+
+    # @private
+    def host_unsynced
+      attr(:host, true, true)
+    end
+
+    # @private
+    def realname_unsynced
+      attr(:realname, true, true)
+    end
+
+    # @private
+    def authname_unsynced
+      attr(:authname, true, true)
+    end
+
+    # @private
+    def idle_unsynced
+      attr(:idle, true, true)
+    end
+
+    # @private
+    def signed_on_at_unsynced
+      attr(:signed_on_at, true, true)
+    end
+
+    # @private
+    def unknown_unsynced
+      attr(:unknown?, true, true)
+    end
+    alias_method :"unknown?_unsynced", "unknown_unsynced"
+
+    # @private
+    def online_unsynced
+      attr(:online?, true, true)
+    end
+    alias_method :"online?_unsynced", "online_unsynced"
+
+    # @private
+    def channels_unsynced
+      attr(:channels, true, true)
+    end
+
+    # @private
+    def secure_unsynced
+      attr(:secure?, true, true)
+    end
+    alias_method :"secure?_unsynced", "secure_unsynced"
+
+    # @private
+    # @since 2.1.0
+    def oper_unsynced
+      attr(:oper?, true, true)
+    end
+    alias_method :"oper?_unsynced", "oper_unsynced"
+
+    # By default, you can use methods like {#user}, {#host} and
+    # alike – If you however fear that another thread might change
+    # data while you're using it and if this means a critical issue to
+    # your code, you can store a clone of the result of this method
+    # and work with that instead.
+    #
+    # @example
+    #   on :channel do |m|
+    #     data = m.user.data.dup
+    #     do_something_with(data.user)
+    #     do_something_with(data.host)
+    #   end
+    # @return [Hash]
+    attr_reader :data
+
+    # @return [Boolean] True if the user is being monitored
+    # @see #monitor
+    # @see #unmonitor
+    # @note The attribute writer is in fact part of the private API
+    attr_reader :monitored
+    # @since 2.1.0
+    alias_method :monitored?, :monitored
+
+    # @api private
+    attr_writer :monitored
+
+    # @note Generally, you shouldn't initialize new instances of this
+    #   class. Use {UserList#find_ensured} instead.
+    def initialize(*args)
+      @data = {
+        user: nil,
+        host: nil,
+        realname: nil,
+        authname: nil,
+        idle: 0,
+        signed_on_at: nil,
+        unknown?: false,
+        online?: false,
+        channels: [],
+        secure?: false,
+        away: nil,
+        oper?: false
+      }
+      case args.size
+      when 2
+        @name, @bot = args
+      when 4
+        @data[:user], @name, @data[:host], @bot = args
+      else
+        raise ArgumentError
+      end
+
+      @synced_attributes = Set.new
+
+      @when_requesting_synced_attribute = lambda { |attr|
+        unless attribute_synced?(attr)
+          @data[:unknown?] = false
+          unsync :unknown?
+
+          refresh
+        end
+      }
+
+      @monitored = false
+    end
+
+    # Checks if the user is identified. Currently officially supports
+    # Quakenet and Freenode.
+    #
+    # @return [Boolean] true if the user is identified
+    # @version 1.1.0
+    def authed?
+      !attr(:authname).nil?
+    end
+
+    # @see Syncable#attr
+    def attr(attribute, data = true, unsync = false)
+      super
+    end
+
+    # Queries the IRC server for information on the user. This will
+    # set the User's state to not synced. After all information are
+    # received, the object will be set back to synced.
+    #
+    # @return [void]
+    # @note The alias `whois` is deprecated and will be removed in a
+    #   future version.
+    def refresh
+      return if @in_whois
+      @data.keys.each do |attr|
+        unsync attr
+      end
+
+      @in_whois = true
+      if @bot.irc.network.whois_only_one_argument?
+        @bot.irc.send "WHOIS #{@name}"
+      else
+        @bot.irc.send "WHOIS #{@name} #{@name}"
+      end
+    end
+    alias_method :whois, :refresh # deprecated
+    undef_method(:whois) # yardoc hack
+
+    # @deprecated
+    def whois
+      Cinch::Utilities::Deprecation.print_deprecation("2.2.0", "User#whois", "User#refresh")
+      refresh
+    end
+
+    # @param [Hash, nil] values A hash of values gathered from WHOIS,
+    #   or `nil` if no data was returned
+    # @return [void]
+    # @api private
+    # @since 1.0.1
+    def end_of_whois(values)
+      @in_whois = false
+      if values.nil?
+        # for some reason, we did not receive user information. one
+        # reason is freenode throttling WHOIS
+        Thread.new do
+          sleep 2
+          refresh
+        end
+        return
+      end
+
+      if values[:unknown?]
+        sync(:unknown?, true, true)
+        self.online = false
+        sync(:idle, 0, true)
+        sync(:channels, [], true)
+
+        fields = @data.keys
+        fields.delete(:unknown?)
+        fields.delete(:idle)
+        fields.delete(:channels)
+        fields.each do |field|
+          sync(field, nil, true)
+        end
+
+        return
+      end
+
+      if values[:registered]
+        values[:authname] ||= nick
+        values.delete(:registered)
+      end
+      {
+        authname: nil,
+        idle: 0,
+        secure?: false,
+        oper?: false,
+        away: nil,
+        channels: []
+      }.merge(values).each do |attr, value|
+        sync(attr, value, true)
+      end
+
+      sync(:unknown?, false, true)
+      self.online = true
+    end
+
+    # @return [void]
+    # @since 1.0.1
+    # @api private
+    # @see Syncable#unsync_all
+    def unsync_all
+      super
+    end
+
+    # @return [String]
+    def to_s
+      @name
+    end
+
+    # @return [String]
+    def inspect
+      "#<User nick=#{@name.inspect}>"
+    end
+
+    # Generates a mask for the user.
+    #
+    # @param [String] s a pattern for generating the mask.
+    #
+    #     - %n = nickname
+    #     - %u = username
+    #     - %h = host
+    #     - %r = realname
+    #     - %a = authname
+    #
+    # @return [Mask]
+    def mask(s = "%n!%u@%h")
+      s = s.gsub(/%(.)/) {
+        case $1
+        when "n"
+          @name
+        when "u"
+          user
+        when "h"
+          host
+        when "r"
+          realname
+        when "a"
+          authname
+        end
+      }
+
+      Mask.new(s)
+    end
+
+    # Check if the user matches a mask.
+    #
+    # @param [Ban, Mask, User, String] other The user or mask to match against
+    # @return [Boolean]
+    def match(other)
+      Mask.from(other) =~ Mask.from(self)
+    end
+    alias_method :=~, :match
+
+    # Starts monitoring a user's online state by either using MONITOR
+    # or periodically running WHOIS.
+    #
+    # @since 2.0.0
+    # @return [void]
+    # @see #unmonitor
+    def monitor
+      if @bot.irc.isupport["MONITOR"] > 0
+        @bot.irc.send "MONITOR + #{@name}"
+      else
+        refresh
+        @monitored_timer = Timer.new(@bot, interval: 30) {
+          refresh
+        }
+        @monitored_timer.start
+      end
+
+      @monitored = true
+    end
+
+    # Stops monitoring a user's online state.
+    #
+    # @since 2.0.0
+    # @return [void]
+    # @see #monitor
+    def unmonitor
+      if @bot.irc.isupport["MONITOR"] > 0
+        @bot.irc.send "MONITOR - #{@name}"
+      else
+        @monitored_timer&.stop
+      end
+
+      @monitored = false
+    end
+
+    # Send data via DCC SEND to a user.
+    #
+    # @param [DCC::DCCableObject] io
+    # @param [String] filename
+    # @since 2.0.0
+    # @return [void]
+    # @note This method blocks.
+    def dcc_send(io, filename = File.basename(io.path))
+      own_ip = bot.config.dcc.own_ip || @bot.irc.socket.addr[2]
+      dcc = DCC::Outgoing::Send.new(receiver: self,
+        filename: filename,
+        io: io,
+        own_ip: own_ip)
+
+      dcc.start_server
+
+      handler = Handler.new(@bot, :message,
+        Pattern.new(/^/,
+          /\001DCC RESUME #{filename} #{dcc.port} (\d+)\001/,
+          /$/)) do |m, position|
+        next unless m.user == self
+        dcc.seek(position.to_i)
+        m.user.send "\001DCC ACCEPT #{filename} #{dcc.port} #{position}\001"
+
+        handler.unregister
+      end
+      @bot.handlers.register(handler)
+
+      @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: waiting" % [filename, io.size, own_ip, dcc.port]
+      dcc.send_handshake
+      begin
+        dcc.listen
+        @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: done" % [filename, io.size, own_ip, dcc.port]
+      rescue Timeout::Error
+        @bot.loggers.info "DCC: Outgoing DCC SEND: File name: %s - Size: %dB - IP: %s - Port: %d - Status: failed (timeout)" % [filename, io.size, own_ip, dcc.port]
+      ensure
+        handler.unregister
+      end
+    end
+
+    # Updates the user's online state and dispatch the correct event.
+    #
+    # @since 2.0.0
+    # @return [void]
+    # @api private
+    def online=(bool)
+      notify = __send__(:"online?_unsynced") != bool && @monitored
+      sync(:online?, bool, true)
+
+      return unless notify
+      if bool
+        @bot.handlers.dispatch(:online, nil, self)
+      else
+        @bot.handlers.dispatch(:offline, nil, self)
+      end
+    end
+
+    # Used to update the user's nick on nickchange events.
+    #
+    # @param [String] new_nick The user's new nick
+    # @api private
+    # @return [void]
+    def update_nick(new_nick)
+      @last_nick, @name = @name, new_nick
+      # Unsync authname because some networks tie authentication to
+      # the nick, so the user might not be authenticated anymore after
+      # changing their nick
+      unsync(:authname)
+      @bot.user_list.update_nick(self)
+    end
+  end
+end

data/lib/cinch/user_list.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "cached_list"
+
+module Cinch
+  # @since 2.0.0
+  # @version 1.1.0
+  # @note In prior versions, this class was called UserManager
+  class UserList < CachedList
+    # Finds or creates a user.
+    # @overload find_ensured(nick)
+    #   Finds or creates a user based on their nick.
+    #
+    #   @param [String] nick The user's nickname
+    #   @return [User]
+    # @overload find_ensured(user, nick, host)
+    #   Finds or creates a user based on their nick but already
+    #   setting user and host.
+    #
+    #   @param [String] user The username
+    #   @param [String] nick The nickname
+    #   @param [String] host The user's hostname
+    #   @return [User]
+    # @return [User]
+    # @see Bot#User
+    def find_ensured(*args)
+      user, host = nil, nil
+      case args.size
+      when 1
+        nick = args.first
+        bargs = [nick]
+      when 3
+        nick = args[1]
+        bargs = args
+        user, _, host = bargs
+      else
+        raise ArgumentError
+      end
+
+      if nick == @bot.nick
+        user_obj = @bot
+      end
+
+      downcased_nick = nick.irc_downcase(@bot.irc.isupport["CASEMAPPING"])
+      @mutex.synchronize do
+        if user_obj.nil?
+          user_obj = @cache[downcased_nick] ||= User.new(*bargs, @bot)
+        end
+        if user && host
+          # Explicitly set user and host whenever we request a User
+          # object to update them on e.g. JOIN.
+          user_obj.sync(:user, user, true)
+          user_obj.sync(:host, host, true)
+        end
+        user_obj
+      end
+    end
+
+    # Finds a user.
+    #
+    # @param [String] nick nick of a user
+    # @return [User, nil]
+    def find(nick)
+      if nick == @bot.nick
+        return @bot
+      end
+
+      downcased_nick = nick.irc_downcase(@bot.irc.isupport["CASEMAPPING"])
+      @mutex.synchronize do
+        return @cache[downcased_nick]
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def update_nick(user)
+      @mutex.synchronize do
+        @cache.delete user.last_nick.irc_downcase(@bot.irc.isupport["CASEMAPPING"])
+        @cache[user.nick.irc_downcase(@bot.irc.isupport["CASEMAPPING"])] = user
+      end
+    end
+
+    # @api private
+    # @return [void]
+    def delete(user)
+      @cache.delete_if { |n, u| u == user }
+    end
+  end
+end

data/lib/cinch/utilities/deprecation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Cinch
+  module Utilities
+    # @since 2.0.0
+    # @api private
+    module Deprecation
+      def self.print_deprecation(version, method, instead = nil)
+        s = "Deprecation warning: Beginning with version #{version}, #{method} should not be used anymore."
+        if !instead.nil?
+          s << " Use #{instead} instead."
+        end
+        warn s
+        warn caller
+      end
+    end
+  end
+end

data/lib/cinch/utilities/encoding.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Cinch
+  module Utilities
+    # @since 2.0.0
+    # @api private
+    module Encoding
+      def self.encode_incoming(string, encoding)
+        string = string.dup
+        if encoding == :irc
+          # If incoming text is valid UTF-8, it will be interpreted as
+          # such. If it fails validation, a CP1252 -> UTF-8 conversion
+          # is performed. This allows you to see non-ASCII from mIRC
+          # users (non-UTF-8) and other users sending you UTF-8.
+          #
+          # (from http://xchat.org/encoding/#hybrid)
+          string.force_encoding("UTF-8")
+          if !string.valid_encoding?
+            string.force_encoding("CP1252").encode!("UTF-8", invalid: :replace, undef: :replace)
+          end
+        else
+          string.force_encoding(encoding).encode!(invalid: :replace, undef: :replace)
+          string = string.chars.select { |c| c.valid_encoding? }.join
+        end
+
+        string
+      end
+
+      def self.encode_outgoing(string, encoding)
+        string = string.dup
+        if encoding == :irc
+          encoding = "UTF-8"
+        end
+
+        string.encode!(encoding, invalid: :replace, undef: :replace).force_encoding("ASCII-8BIT")
+      end
+    end
+  end
+end

data/lib/cinch/utilities/kernel.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Cinch
+  module Utilities
+    # @since 2.0.0
+    # @api private
+    module Kernel
+      # @return [Object]
+      def self.string_to_const(s)
+        return s unless s.is_a?(::String)
+        s.split("::").inject(Kernel) { |base, name| base.const_get(name) }
+      end
+    end
+  end
+end

data/lib/cinch/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Cinch
+  # Version of the library
+  VERSION = "2.4.0"
+end

data/lib/cinch.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "cinch/version"
+require "cinch/utilities/kernel"
+require "cinch/utilities/deprecation"
+require "cinch/utilities/encoding"
+require "cinch/bot"

data/lib/ircinch.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "cinch"
+
+class Ircinch
+  class Error < StandardError; end
+end