rdiscord_sdk 1.1.0

data/ext/rdiscord_sdk/extconf.rb

@@ -0,0 +1,54 @@
+require "mkmf-rice"
+
+# Add compiler and linker flags
+def add_flags(type, flags)
+  case type
+  when :c
+    $CFLAGS << " #{flags} "
+  when :ld
+    $LDFLAGS << " #{flags} "
+  end
+end
+
+THIRDPARTY_DIR = File.join(File.dirname(__FILE__), "../../third-party")
+puts "THIRDPARTY_DIR: #{THIRDPARTY_DIR}"
+HEADER_DIR = File.join(THIRDPARTY_DIR, "include")
+LIBRARY_DIR = if RUBY_PLATFORM.start_with?("x86_64") or RUBY_PLATFORM.start_with?("x64")
+    File.join(THIRDPARTY_DIR, "lib/x86_64")
+  else
+    puts "Blindly assuming x86. If you get linker errors, this is why."
+    File.join(THIRDPARTY_DIR, "lib/x86")
+  end
+
+add_flags(:ld, "-L#{LIBRARY_DIR}")
+add_flags(:ld, "-Wl,-R. -Wl,-R./lib")
+add_flags(:ld, "-l:discord_game_sdk#{RUBY_PLATFORM.end_with?("linux") ? ".so" : ".dll.lib"}")
+add_flags(:c, "-g")
+$LDFLAGS.gsub!(/\n/, " ")
+
+# Grab all discord source files because ruby is dumb
+
+discord_srcs = Dir.glob("#{THIRDPARTY_DIR}/**/*.cpp").map { |path| File.basename(path) }
+Dir.glob("#{THIRDPARTY_DIR}/*/") do |path|
+  puts path
+  dir = File.basename(path)
+  $VPATH << "#{THIRDPARTY_DIR}/#{dir}"
+  $INCFLAGS << " -I#{THIRDPARTY_DIR}/#{dir}"
+end
+ext_srcs = Dir.glob("#{$srcdir}/**/*.cpp").map { |path| File.basename(path) }
+Dir.glob("#{$srcdir}/*/") do |path|
+  dir = File.basename(path)
+  next if excluded.include?(dir)
+  $VPATH << "$(srcdir)/#{dir}"
+  $INCFLAGS << " -I$(srcdir)/#{dir}"
+end
+
+$srcs = discord_srcs + ext_srcs
+
+puts "LDFLAGS: #{$LDFLAGS}"
+puts "CFLAGS: #{$CFLAGS}"
+puts "VPATH: #{$VPATH}"
+puts "INCFLAGS: #{$INCFLAGS}"
+puts "SRCS: #{$srcs}"
+
+create_makefile("rdiscord_sdk")

data/ext/rdiscord_sdk/gem_activity_manager.cpp

@@ -0,0 +1,273 @@
+#include "gem_activity_manager.h"
+#include "common.h"
+#include "activity.h"
+#include "user.h"
+#include "discord.h"
+
+using namespace Rice;
+
+Module rb_mActivityManager;
+
+Object rb_activity_manager_register_command(const char* command) {
+    CHECK_CORE_INITIALIZED;
+    return rb_result_to_obj(
+            DiscordSDK.core->ActivityManager().RegisterCommand(command)
+        );
+}
+
+Object rb_activity_manager_register_steam(int steam_id) {
+    CHECK_CORE_INITIALIZED;
+    return rb_result_to_obj(
+        DiscordSDK.core->ActivityManager().RegisterSteam(steam_id)
+    );
+}
+
+Object rb_activity_manager_update_activity(Object rb_activity) {
+    CHECK_CORE_INITIALIZED;
+    VALUE callback_proc = rb_common_get_callback_proc(1);
+    
+    auto fn = rb_discord_callback_wrapper_basic(callback_proc);
+
+    GET_ACTIVITY(rb_activity);
+    DiscordSDK.core->ActivityManager().UpdateActivity(
+        *activity,
+        fn
+    );
+
+    return Qnil;
+}
+
+Object rb_activity_manager_clear_activity() {
+    CHECK_CORE_INITIALIZED;
+    VALUE callback_proc = rb_common_get_callback_proc(1);
+
+    auto fn = rb_discord_callback_wrapper_basic(callback_proc);
+    DiscordSDK.core->ActivityManager().ClearActivity(fn);
+
+    return Qnil;
+}
+
+Object rb_activity_manager_send_request_reply(std::int64_t user_id, int reply) {
+    CHECK_CORE_INITIALIZED;
+    VALUE callback_proc = rb_common_get_callback_proc(1);
+
+    auto fn = rb_discord_callback_wrapper_basic(callback_proc);
+
+    DiscordSDK.core->ActivityManager().SendRequestReply(
+        user_id,
+        (discord::ActivityJoinRequestReply) reply,
+        fn
+    );
+
+    return Qnil;
+}
+
+Object rb_activity_manager_send_invite(std::int64_t user_id, int type, const char* content) {
+    CHECK_CORE_INITIALIZED;
+    VALUE callback_proc = rb_common_get_callback_proc(1);
+
+    auto fn = rb_discord_callback_wrapper_basic(callback_proc);
+
+    DiscordSDK.core->ActivityManager().SendInvite(
+        user_id,
+        (discord::ActivityActionType) type,
+        content,
+        fn
+    );
+
+    return Qnil;
+}
+
+Object rb_activity_manager_accept_invite(std::int64_t user_id) {
+    CHECK_CORE_INITIALIZED;
+    VALUE callback_proc = rb_common_get_callback_proc(1);
+
+    auto fn = rb_discord_callback_wrapper_basic(callback_proc);
+
+    DiscordSDK.core->ActivityManager().AcceptInvite(
+        user_id,
+        fn
+    );
+
+    return Qnil;
+}
+
+int rb_activity_manager_on_activity_join_connect() {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE event_proc = rb_common_get_event_proc(1);
+    int token = DiscordSDK.core->ActivityManager().OnActivityJoin.Connect(
+        [event_proc](const char* secret) {
+            if (event_proc == Qnil)
+                return;
+
+            if (!rb_obj_is_kind_of(event_proc, rb_cProc))
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(event_proc));
+
+            VALUE array = rb_ary_new_from_args(2, event_proc, rb_str_new_cstr(secret));
+            int state;
+            rb_protect(rb_discord_call_proc, array, &state);
+
+            LOG_ERROR_IF_STATE;
+        }
+    );
+    rb_common_add_proc_to_hash(Symbol("activity_join_connect" + token), event_proc);
+
+    return token;
+}
+
+Object rb_activity_manager_on_activity_join_disconnect(int token) {
+    CHECK_CORE_INITIALIZED;
+
+    DiscordSDK.core->ActivityManager().OnActivityJoin.Disconnect(token);
+    rb_hash_delete(rb_oProcEvents, Symbol("on_activity_join" + token)); // Delete event proc, we use hashes instead of arrays to delete specific entries
+
+    return Qnil;
+}
+
+int rb_activity_manager_on_activity_spectate_connect() {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE event_proc = rb_common_get_event_proc(1);
+    int token = DiscordSDK.core->ActivityManager().OnActivitySpectate.Connect(
+        [event_proc](const char* secret) {
+            if (event_proc == Qnil)
+                return;
+
+            if (!rb_obj_is_kind_of(event_proc, rb_cProc))
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(event_proc));
+
+            VALUE array = rb_ary_new_from_args(2, event_proc, rb_str_new_cstr(secret));
+            int state;
+            rb_protect(rb_discord_call_proc, array, &state);
+
+            LOG_ERROR_IF_STATE;
+        }
+    );
+    rb_common_add_proc_to_hash(Symbol("on_activity_spectate" + token), event_proc);
+
+    return token;
+}
+
+Object rb_activity_manager_on_activity_spectate_disconnect(int token) {
+    CHECK_CORE_INITIALIZED;
+
+    DiscordSDK.core->ActivityManager().OnActivitySpectate.Disconnect(token);
+    rb_hash_delete(rb_oProcEvents, Symbol("on_activity_spectate" + token));
+
+    return Qnil;
+}
+
+int rb_activity_manager_on_activity_join_request_connect() {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE event_proc = rb_common_get_event_proc(1);
+    int token = DiscordSDK.core->ActivityManager().OnActivityJoinRequest.Connect(
+        [event_proc](const discord::User &user) {
+            if (event_proc == Qnil)
+                return;
+            
+            if (!rb_obj_is_kind_of(event_proc, rb_cProc))
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(event_proc));
+
+            VALUE argv = rb_ary_new();
+            Object rb_user = rb_class_new_instance(0, &argv, rb_cUser);
+            setPrivateData(rb_user, (void*) &user);
+
+            VALUE array = rb_ary_new_from_args(2, event_proc, rb_user);
+            int state;
+            rb_protect(rb_discord_call_proc, array, &state);
+
+            LOG_ERROR_IF_STATE;
+        }
+    );
+    rb_common_add_proc_to_hash(Symbol("on_activity_join_request" + token), event_proc);
+
+    return token;
+}
+
+Object rb_activity_manager_on_activity_join_request_disconnect(int token) {
+    CHECK_CORE_INITIALIZED;
+
+    DiscordSDK.core->ActivityManager().OnActivityJoinRequest.Disconnect(token);
+    rb_hash_delete(rb_oProcEvents, Symbol("on_activity_join_request" + token));
+
+    return Qnil;
+}
+
+int rb_activity_manager_on_activity_invite_connect() {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE event_proc = rb_common_get_event_proc(1);
+    int token = DiscordSDK.core->ActivityManager().OnActivityInvite.Connect(
+        [event_proc](discord::ActivityActionType action_type, const discord::User &user, const discord::Activity &activity) {
+            if (event_proc == Qnil)
+                return;
+
+            if (!rb_obj_is_kind_of(event_proc, rb_cProc))
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(event_proc));
+
+            VALUE argv = rb_ary_new();
+            Object rb_user = rb_class_new_instance(0, &argv, rb_cUser);
+            setPrivateData(rb_user, (void*) &user);
+
+            VALUE argv2 = rb_ary_new();
+            Object rb_activity = rb_class_new_instance(0, &argv2, rb_cActivity);
+            setPrivateData(rb_activity, (void*) &activity);
+
+            VALUE array = rb_ary_new_from_args(4, event_proc, rb_user, rb_activity, INT2NUM((int) action_type));
+            int state;
+            rb_protect(rb_discord_call_proc, array, &state);
+
+            LOG_ERROR_IF_STATE;
+        }
+    );
+    rb_common_add_proc_to_hash(Symbol("on_activity_invite" + token), event_proc);
+
+    return token;
+}
+
+Object rb_activity_manager_on_activity_invite_disconnect(int token) {
+    CHECK_CORE_INITIALIZED;
+
+    DiscordSDK.core->ActivityManager().OnActivityInvite.Disconnect(token);
+    rb_hash_delete(rb_oProcEvents, Symbol("on_activity_invite" + token));
+
+    return Qnil;
+}
+
+void rb_activity_init_manager(Module module) {
+    rb_mActivityManager = define_module_under(module, "ActivityManager");
+    rb_mActivityManager.define_module_function(
+            "register_command", 
+            &rb_activity_manager_register_command
+        );
+    rb_mActivityManager.define_module_function(
+            "register_steam",
+            &rb_activity_manager_register_steam
+        );
+    rb_mActivityManager.define_module_function(
+            "update_activity",
+            &rb_activity_manager_update_activity
+    );
+    rb_mActivityManager.define_module_function(
+            "clear_activity",
+            &rb_activity_manager_clear_activity
+    );
+    rb_mActivityManager.define_module_function(
+            "send_request_reply",
+            &rb_activity_manager_send_request_reply
+    );
+    rb_mActivityManager.define_module_function(
+            "send_invite",
+            &rb_activity_manager_send_invite
+    );
+    rb_mActivityManager.define_module_function(
+            "accept_invite",
+            &rb_activity_manager_accept_invite
+    );
+    DEF_METHOD_EVENT(rb_mActivityManager, activity_join, activity_manager);
+    DEF_METHOD_EVENT(rb_mActivityManager, activity_spectate, activity_manager);
+    DEF_METHOD_EVENT(rb_mActivityManager, activity_join_request, activity_manager);
+    DEF_METHOD_EVENT(rb_mActivityManager, activity_invite, activity_manager);
+}

data/ext/rdiscord_sdk/gem_activity_manager.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "rdiscord_sdk.h"
+
+using namespace Rice;
+
+extern Module rb_mActivityManager;
+void rb_activity_init_manager(Module module);

data/ext/rdiscord_sdk/gem_user_manager.cpp

@@ -0,0 +1,114 @@
+#include "gem_user_manager.h"
+#include "common.h"
+#include "user.h"
+#include "discord.h"
+
+using namespace Rice;
+
+Module rb_mUserManager;
+
+
+
+// Thanks discord for not making this behave like a callback!!
+Object rb_user_manager_get_current_user() {
+    CHECK_CORE_INITIALIZED;
+
+    discord::User* user = new discord::User();
+    discord::Result result = DiscordSDK.core->UserManager().GetCurrentUser(user);
+
+    VALUE argv = rb_ary_new();
+    VALUE rb_user = rb_class_new_instance(0, &argv, rb_cUser);
+    setPrivateData(rb_user, (void*) user);
+
+    return rb_ary_new_from_args(2, (int) result, rb_user);
+}
+
+Object rb_user_manager_get_user(std::int64_t id) {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE callback_proc = rb_common_get_callback_proc(2);
+    DiscordSDK.core->UserManager().GetUser(id, 
+        [callback_proc](discord::Result result, const discord::User &user){
+            if (callback_proc == Qnil)
+               return;
+
+            if (!rb_obj_is_kind_of(callback_proc, rb_cProc)) {
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(callback_proc));
+            }
+
+            VALUE argv = rb_ary_new();
+            VALUE rb_user = rb_class_new_instance(0, &argv, rb_cUser);
+            setPrivateData(rb_user, (void*) &user);
+
+            rb_ary_delete(rb_oPendingCallbacks, callback_proc);
+            VALUE ary = rb_ary_new_from_args(3, callback_proc, INT2NUM((int) result), rb_user);
+
+            int state;
+            rb_protect(rb_discord_call_proc, ary, &state);
+            LOG_ERROR_IF_STATE;
+        }
+    );
+
+    return Qnil;
+}
+
+Object rb_user_manager_get_current_user_premium_type() {
+    CHECK_CORE_INITIALIZED;
+
+    discord::PremiumType premium_type;
+    discord::Result result = DiscordSDK.core->UserManager().GetCurrentUserPremiumType(&premium_type);
+
+    return rb_ary_new_from_args(2, INT2NUM((int) result), INT2NUM((int) premium_type));
+}
+
+Object rb_user_manager_current_user_has_flag(int flag) {
+    CHECK_CORE_INITIALIZED;
+
+    bool has_flag;
+    discord::Result result = DiscordSDK.core->UserManager().CurrentUserHasFlag((discord::UserFlag) flag, &has_flag);
+
+    return rb_ary_new_from_args(2, INT2NUM((int) result), BOOL2RB(has_flag));
+}
+
+int rb_user_manager_on_current_user_update_connect() {
+    CHECK_CORE_INITIALIZED;
+
+    VALUE event_proc  = rb_common_get_event_proc(0);
+    int token = DiscordSDK.core->UserManager().OnCurrentUserUpdate.Connect(
+        [event_proc]() {
+            if (event_proc == Qnil)
+                return;
+            
+            if (!rb_obj_is_kind_of(event_proc, rb_cProc))
+                rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(event_proc));
+
+            
+            VALUE array = rb_ary_new_from_args(1, event_proc);
+            int state;
+            rb_protect(rb_discord_call_proc, array, &state);
+
+            LOG_ERROR_IF_STATE;
+        }
+    );
+    rb_common_add_proc_to_hash(Symbol("on_current_user_update" + token), event_proc);
+    
+    return token;
+}
+
+Object rb_user_manager_on_current_user_update_disconnect(int token) {
+    CHECK_CORE_INITIALIZED;
+
+    DiscordSDK.core->UserManager().OnCurrentUserUpdate.Disconnect(token);
+    rb_hash_delete(rb_oPendingCallbacks, Symbol("on_current_user_update" + token));
+
+    return Qnil;
+}
+
+void rb_user_init_manager(Module module) {
+    rb_mUserManager = define_module_under(module, "UserManager");
+    rb_mUserManager.define_module_function("get_current_user", &rb_user_manager_get_current_user);
+    rb_mUserManager.define_module_function("get_user", &rb_user_manager_get_user);
+    rb_mUserManager.define_module_function("get_current_user_premium_type", &rb_user_manager_get_current_user_premium_type);
+    rb_mUserManager.define_module_function("current_user_has_flag", &rb_user_manager_current_user_has_flag);
+    DEF_METHOD_EVENT(rb_mUserManager, current_user_update, user_manager);
+}

data/ext/rdiscord_sdk/gem_user_manager.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "rdiscord_sdk.h"
+
+using namespace Rice;
+
+extern Module rb_mUserManager;
+void rb_user_init_manager(Module module);

data/ext/rdiscord_sdk/rdiscord_sdk.cpp

@@ -0,0 +1,77 @@
+#include "rdiscord_sdk.h"
+#include "common.h"
+#include "gem_activity_manager.h"
+#include "activity.h"
+#include "user.h"
+#include "gem_user_manager.h"
+
+using namespace Rice;
+
+VALUE rb_oPendingCallbacks;
+VALUE rb_oProcEvents;
+
+Module rb_mDiscord;
+DiscordStruct DiscordSDK;
+
+Object rb_core_initialize(long long client_id, long flags) {
+    if (DiscordSDK.core) {
+        rb_raise(rb_eRuntimeError, "Discord already initialized!");
+    }
+    discord::Core* core;
+    auto result = discord::Core::Create(client_id, flags, &core);
+    DiscordSDK.core.reset(core);
+    return rb_result_to_obj(result);
+}
+
+void rb_core_log_hook(discord::LogLevel minLevel, const char* message) {
+    if (!DiscordSDK.log_hook) {
+        return;
+    }
+    VALUE args = rb_ary_new_from_args(2, minLevel, message);
+    rb_proc_call(DiscordSDK.log_hook, args);
+}
+
+Object rb_core_set_log_hook(int loglevel) {
+    CHECK_CORE_INITIALIZED;
+    if (DiscordSDK.log_hook) {
+        rb_hash_delete(rb_oProcEvents, Symbol("log_hook"));
+    }
+
+    DiscordSDK.log_hook = rb_common_get_event_proc(2);
+    rb_common_add_proc_to_hash(Symbol("log_hook"), DiscordSDK.log_hook);
+    
+    DiscordSDK.core->SetLogHook(
+        (discord::LogLevel) loglevel,
+        rb_core_log_hook   
+    );
+
+    return Qnil;
+}
+
+Object rb_core_run_callbacks() {
+    CHECK_CORE_INITIALIZED;
+    return rb_result_to_obj(DiscordSDK.core->RunCallbacks());
+}
+
+extern "C"
+void Init_rdiscord_sdk()
+{
+    rb_oPendingCallbacks = rb_ary_new();
+    rb_oProcEvents = rb_hash_new();
+
+    rb_mDiscord = define_module("Discord");
+    rb_mDiscord.define_module_function("init", &rb_core_initialize);
+    rb_mDiscord.define_module_function("set_log_hook", &rb_core_set_log_hook);
+    rb_mDiscord.define_module_function("run_callbacks", &rb_core_run_callbacks);
+
+    rb_global_variable(&rb_oProcEvents);
+    rb_global_variable(&rb_oPendingCallbacks);
+
+    rb_gv_set("$discord_proc_events", rb_oProcEvents);
+    rb_gv_set("$discord_pending_callbacks", rb_oPendingCallbacks);
+
+    rb_activity_init_manager(rb_mDiscord);
+    rb_activity_init_class(rb_mDiscord);
+    rb_user_init_class(rb_mDiscord);
+    rb_user_init_manager(rb_mDiscord);
+}

data/ext/rdiscord_sdk/rdiscord_sdk.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include <discord.h>
+
+using namespace Rice;
+
+extern Module rb_mDiscord;
+
+struct DiscordStruct {
+    std::unique_ptr<discord::Core> core;
+    Object log_hook;
+};
+extern DiscordStruct DiscordSDK;
+
+extern "C"
+void Init_rdiscord_sdk();

data/ext/rdiscord_sdk/user.cpp

@@ -0,0 +1,98 @@
+#include "user.h"
+#include <rice/rice.hpp>
+#include "discord.h"
+#include "common.h"
+#include <cstdint>
+using namespace Rice;
+
+Class rb_cUser;
+
+DEF_TYPE_CUSTOMTYPENAME(discord::User, User_rbType);
+
+Object rb_user_initialize(Object self) {
+    discord::User* user = new discord::User();
+    setPrivateData(self, user);
+
+    return self;
+}
+
+std::int64_t rb_user_get_id(Object self) {
+    GET_USER(self);
+
+    return user->GetId();
+}
+
+Object rb_user_set_id(Object self, std::int64_t id) {
+    GET_USER(self);
+
+    user->SetId(id);
+
+    return Qnil;
+}
+
+const char* rb_user_get_username(Object self) {
+    GET_USER(self);
+
+    return user->GetUsername();
+}
+
+Object rb_user_set_username(Object self, const char* username) {
+    GET_USER(self);
+
+    user->SetUsername(username);
+
+    return Qnil;
+}
+
+const char* rb_user_get_discriminator(Object self) {
+    GET_USER(self);
+
+    return user->GetDiscriminator();
+}
+
+Object rb_user_set_discriminator(Object self, const char* discriminator) {
+    GET_USER(self);
+
+    user->SetDiscriminator(discriminator);
+
+    return Qnil;
+}
+
+const char* rb_user_get_avatar(Object self) {
+    GET_USER(self);
+
+    return user->GetAvatar();
+}
+
+Object rb_user_set_avatar(Object self, const char* avatar) {
+    GET_USER(self);
+
+    user->SetAvatar(avatar);
+
+    return Qnil;
+}
+
+bool rb_user_get_bot(Object self) {
+    GET_USER(self);
+
+    return user->GetBot();
+}
+
+Object rb_user_set_bot(Object self, bool bot) {
+    GET_USER(self);
+
+    user->SetBot(bot);
+
+    return Qnil;
+}
+
+void rb_user_init_class(Module module) {
+    rb_cUser = define_class_under(module, "User");
+    rb_define_alloc_func(rb_cUser, classAllocate<&User_rbType>);
+    rb_cUser.define_method("initialize", &rb_user_initialize);
+    DEF_METHOD_GET_SET(rb_cUser, id, user);
+    DEF_METHOD_GET_SET(rb_cUser, username, user);
+    DEF_METHOD_GET_SET(rb_cUser, discriminator, user);
+    DEF_METHOD_GET_SET(rb_cUser, avatar, user);
+    DEF_METHOD_GET_SET(rb_cUser, bot, user);
+}

data/ext/rdiscord_sdk/user.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include "rdiscord_sdk.h"
+#include "discord.h"
+#include "common.h"
+
+using namespace Rice;
+
+extern Class rb_cUser;
+void rb_user_init_class(Module module);
+
+Object rb_user_initialize(Object self);
+
+#define GET_USER(obj) \
+if (!obj.is_a(rb_cUser)) { \
+    rb_raise(rb_eTypeError, "User is not a Discord::User"); \
+} \
+discord::User* user = getPrivateData<discord::User>(obj);