mij-discord 1.0.0

data/lib/mij-discord/data/user.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module MijDiscord::Data
+  class User
+    include IDObject
+
+    attr_reader :bot
+
+    attr_reader :username
+    alias_method :name, :username
+
+    attr_reader :discriminator
+    alias_method :tag, :discriminator
+
+    attr_reader :bot_account
+    alias_method :bot_account?, :bot_account
+
+    attr_reader :avatar_id
+
+    attr_reader :status
+
+    attr_reader :game
+
+    attr_reader :stream_url
+
+    attr_reader :stream_type
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @id = data['id'].to_i
+      @bot_account = !!data['bot']
+      update_data(data)
+
+      @status = :offline
+
+      @roles = {}
+    end
+
+    def update_data(data)
+      @username = data.fetch('username', @username)
+      @discriminator = data.fetch('discriminator', @discriminator)
+      @avatar_id = data.fetch('avatar', @avatar_id)
+    end
+
+    def update_presence(presence)
+      @status = presence['status'].to_sym
+
+      if (game = presence['game'])
+        @game = game['name']
+        @stream_url = game['url']
+        @stream_type = game['type']
+      else
+        @game = @stream_url = @stream_type = nil
+      end
+    end
+
+    def mention
+      "<@#{@id}>"
+    end
+
+    alias_method :to_s, :mention
+
+    def distinct
+      "#{@username}##{@discriminator}"
+    end
+
+    def pm(text: nil, embed: nil)
+      if text || embed
+        pm.send_message(text: text || '', embed: embed)
+      else
+        @bot.pm_channel(@id)
+      end
+    end
+
+    alias_method :dm, :pm
+
+    def send_file(file, caption: nil)
+      pm.send_file(file, caption: caption)
+    end
+
+    def on(server)
+      id = server.to_id
+      @bot.server(id).member(@id)
+    end
+
+    def webhook?
+      @discriminator == '0000'
+    end
+
+    def current_bot?
+      @bot.profile == self
+    end
+
+    def online?
+      @status == :online?
+    end
+
+    def idle?
+      @status == :idle
+    end
+
+    alias_method :away?, :idle?
+
+    def dnd?
+      @status == :dnd
+    end
+
+    alias_method :busy?, :dnd?
+
+    def invisible?
+      @status == :invisible
+    end
+
+    alias_method :hidden?, :invisible?
+
+    def offline?
+      @status == :offline
+    end
+
+    def member?
+      false
+    end
+
+    def avatar_url(format = nil)
+      return MijDiscord::Core::API::User.default_avatar(@discriminator) unless @avatar_id
+      MijDiscord::Core::API::User.avatar_url(@id, @avatar_id, format)
+    end
+
+    def inspect
+      %(<User id=#{@id} name="#{@username}" tag=#{@discriminator}>)
+    end
+  end
+
+  class Profile < User
+    attr_reader :mfa_enabled
+    alias_method :mfa_enabled?, :mfa_enabled
+
+    def update_data(data)
+      super(data)
+
+      @mfa_enabled = !!data['mfa_enabled']
+    end
+
+    def set_username(name)
+      response = MijDiscord::Core::API::User.update_profile(@bot.token, name, nil)
+      update_data(JSON.parse(response))
+      nil
+    end
+
+    alias_method :username=, :set_username
+    alias_method :set_name, :set_username
+    alias_method :name=, :set_username
+
+    def set_avatar(data, format = :png)
+      if data.is_a?(String)
+        data = "data:image/#{format};base64,#{data}"
+      elsif data.respond_to?(:read)
+        data.binmode if data.respond_to?(:binmode)
+        data = Base64.strict_encode64(data.read)
+        data = "data:image/#{format};base64,#{data}"
+      else
+        raise ArgumentError, 'Invalid avatar data provided'
+      end
+
+      response = MijDiscord::Core::API::User.update_profile(@bot.token, @username, data)
+      update_data(JSON.parse(response))
+      nil
+    end
+
+    alias_method :avatar=, :set_avatar
+  end
+end

data/lib/mij-discord/data/voice.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module MijDiscord::Data
+  class VoiceState
+    attr_reader :user
+
+    attr_reader :mute
+    alias_method :mute?, :mute
+
+    attr_reader :deaf
+    alias_method :deaf?, :deaf
+
+    attr_reader :self_mute
+    alias_method :self_mute?, :self_mute
+
+    attr_reader :self_deaf
+    alias_method :self_deaf?, :self_deaf
+
+    attr_reader :voice_channel
+    alias_method :channel, :voice_channel
+
+    def initialize(user)
+      @user = user
+    end
+
+    def update_data(channel, data)
+      @voice_channel = channel
+
+      @mute = data.fetch('mute', @mute)
+      @deaf = data.fetch('deaf', @deaf)
+      @self_mute = data.fetch('self_mute', @self_mute)
+      @self_deaf = data.fetch('self_deaf', @self_deaf)
+    end
+  end
+
+  class VoiceRegion
+    attr_reader :id
+    alias_method :to_s, :id
+
+    attr_reader :name
+
+    attr_reader :sample_hostname
+
+    attr_reader :sample_port
+
+    attr_reader :vip
+
+    attr_reader :optimal
+
+    attr_reader :deprecated
+
+    attr_reader :custom
+
+    def initialize(data)
+      @id = data['id']
+
+      @name = data['name']
+
+      @sample_hostname = data['sample_hostname']
+      @sample_port = data['sample_port']
+
+      @vip = data['vip']
+      @optimal = data['optimal']
+      @deprecated = data['deprecated']
+      @custom = data['custom']
+    end
+  end
+end

data/lib/mij-discord/events.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module MijDiscord::Events
+  class EventBase
+    FilterMatch = Struct.new(:field, :on, :cmp)
+
+    def initialize(*args)
+      # Nothing
+    end
+
+    def trigger?(params)
+      filters = self.class.event_filters
+
+      result = params.map do |key, param|
+        next true unless filters.has_key?(key)
+
+        check = filters[key].map do |match|
+          on, field, cmp = match.on, match.field, match.cmp
+
+          is_match = case on
+            when Array
+              on.reduce(false) {|a,x| a || trigger_match?(x, param) }
+            else
+              trigger_match?(on, param)
+          end
+
+          next false unless is_match
+
+          value = case field
+            when Array
+              field.reduce(self) {|a,x| a.respond_to?(x) ? a.send(x) : nil }
+            else
+              respond_to?(field) ? send(field) : nil
+          end
+
+          case cmp
+            when :eql?
+              value == param
+            when :neq?
+              value != param
+            when :case
+              param === value
+            when Proc
+              cmp.call(value, param)
+            else
+              false
+          end
+        end
+
+        check.reduce(false, &:|)
+      end
+
+      result.reduce(true, &:&)
+    end
+
+    private
+
+    def trigger_match?(match, key)
+      case match
+        when :any, :all
+          true
+        when :id_obj
+          key.respond_to?(:to_id)
+        when Class
+          match === key
+      end
+    end
+
+    class << self
+      attr_reader :event_filters
+
+      def filter_match(key, field: key, on: :any, cmp: nil, &block)
+        raise ArgumentError, 'No comparison function provided' unless cmp || block
+
+        # @event_filters ||= superclass&.event_filters&.dup || {}
+        filter = (@event_filters[key] ||= [])
+        filter << FilterMatch.new(field, on, block || cmp)
+      end
+
+      def delegate_method(*names, to:)
+        names.each do |name|
+          define_method(name) do |*arg|
+            send(to).send(name, *arg)
+          end
+        end
+      end
+
+      def inherited(sc)
+        filters = @event_filters&.dup || {}
+        sc.instance_variable_set(:@event_filters, filters)
+      end
+    end
+  end
+
+  class DispatcherBase
+    Callback = Struct.new(:key, :block, :filter)
+
+    def initialize(klass)
+      raise ArgumentError, 'Class must inherit from EventBase' unless klass < EventBase
+
+      @klass, @callbacks = klass, {}
+    end
+
+    def add_callback(key = nil, **filter, &block)
+      raise ArgumentError, 'No callback block provided' if block.nil?
+
+      key = block.object_id if key.nil?
+      @callbacks[key] = Callback.new(key, block, filter)
+      key
+    end
+
+    def remove_callback(key)
+      @callbacks.delete(key)
+      nil
+    end
+
+    def callbacks
+      @callbacks.values
+    end
+
+    def trigger(event_args, block_args = nil)
+      event = @klass.new(*event_args)
+
+      @callbacks.each do |_, cb|
+        execute_callback(cb, event, block_args) if event.trigger?(cb.filter)
+      end
+    end
+
+    alias_method :raise, :trigger
+
+    # Must implement execute_callback
+  end
+end

data/lib/mij-discord/events/basic.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module MijDiscord::Events
+  class Generic < EventBase
+    attr_reader :bot
+
+    def initialize(bot)
+      @bot = bot
+    end
+  end
+
+  class Ready < Generic; end
+
+  class Heartbeat < Generic; end
+
+  class Connect < Generic; end
+
+  class Disconnect < Generic; end
+
+  class Exception < Generic
+    attr_reader :type
+
+    attr_reader :payload
+
+    attr_reader :exception
+
+    filter_match(:type, on: Symbol, cmp: :eql?)
+
+    def initialize(bot, type, exception, payload = nil)
+      super(bot)
+
+      @type, @exception, @payload = type, exception, payload
+    end
+  end
+
+  class UpdateUser < Generic
+    attr_reader :user
+
+    filter_match(:user, field: [:user, :name], on: [String, Regexp], cmp: :case)
+    filter_match(:user, on: :id_obj, cmp: :eql?)
+
+    def initialize(bot, user)
+      super(bot)
+
+      @user = user
+    end
+  end
+
+  class EventDispatcher < MijDiscord::Events::DispatcherBase
+    attr_reader :threads
+
+    def initialize(klass, bot)
+      super(klass)
+
+      @bot, @threads = bot, []
+    end
+
+    def execute_callback(callback, event, _)
+      Thread.new do
+        thread = Thread.current
+
+        @threads << thread
+        thread[:mij_discord] = "event-#{callback.key}"
+
+        begin
+          callback.block.call(event, callback.key)
+        rescue LocalJumpError
+          # Allow premature return from callback block
+        rescue => exc
+          @bot.handle_exception(:event, exc, event)
+
+          MijDiscord::LOGGER.error('Events') { 'An error occurred in event callback' }
+          MijDiscord::LOGGER.error('Events') { exc }
+        ensure
+          @threads.delete(thread)
+        end
+      end
+    end
+  end
+end