rdiscord_sdk 1.1.0

data/README.md

@@ -0,0 +1,187 @@
+# R(uby) Discord SDK
+
+This is a Ruby gem that implements bindings to the [Discord Game SDK](https://discord.com/developers/docs/game-sdk/discord).
+It is intended to be used in [ModShot](https://github.com/Astrabit-ST/Modshot-Core), although will work in any ruby application.
+
+## Whats the difference between this and ruby_discord_game_sdk?
+
+Well, [ruby_discord_game_sdk](https://github.com/rkevin-arch/ruby_discord_game_sdk) is written in pure C, making it very hard to understand and interpret.
+This means it's very difficult to understand how it works, what it does, and to add new features. 
+rdiscord_sdk is instead built in C++ meaning it's easier to abstract, and to modify the source. The name may be obtuse, but it sure as hell isn't internally.
+My goal is to provide extra levels of abstraction over ruby_discord_game_sdk, and provide full functionality as well. Wether that will happen, I'm not sure.
+
+## Disclaimer
+Some portions of code are untested because they can be extremely hard to test, namely events.
+Keep that in mind.
+
+## Usage
+
+This gem (at the moment) exposes SDK functions without much abstraction, so as long as you can grasp C#, you should be able to transfer the example code to ruby code.
+There are a couple of minor differences, such as the lack of a need to initialize managers (C++ Discord SDK bindings automatically do that for you).
+
+- Setting up the SDK is the same as ruby_discord_game_sdk `Discord::init(client_id, flags)`
+- Enums are just constants inside lib/rdiscord_sdk/enums.rb (So `Discord.Result.Ok` ~> `Discord::Result::Ok`)
+- The module for SDK functions is under `Discord`, not `DiscordSDK`
+- Callbacks are method blocks
+- Events are also method blocks
+- Pending callbacks and events are accessible
+- Some functions return an array, usually the result being at [0] and an object at [1] (such as Discord::UserManager.get_current_user)
+
+As mentioned above, some functions return arrays. An easy way to deal with these would be to:
+```rb
+result, user = Discord::UserManager.get_current_user
+```
+It's not the best, but it works. I don't want to discard a result, in case you ever want to know what went wrong.
+If you don't want the result, you can just do:
+```rb
+_, user = Discord::UserManager.get_current_user
+```
+`_` is widely understood as a dummy variable, so it's good practice to use it when you don't care about a specific return value.
+
+## Callbacks & Events
+
+As mentioned before, callbacks and events are method blocks and procs, and are not usually required. If you've coded ruby before, just use them how you normally would.
+Generally, when you see `() => {}` in the SDK documentation, that is referring to a callback or event, and so you should substitute it with a block instead.
+
+Docs:
+```cs
+var userManager = discord.GetUserManager();
+var activity = new Discord.Activity
+activityManager.UpdateActivity(activity, (result) =>
+{
+    if (result == Discord.Result.Ok)
+    {
+        Console.WriteLine("Success!");
+    }
+    else
+    {
+        Console.WriteLine("Failed");
+    }
+}
+```
+rdiscord_sdk equivalent:
+```rb
+Discord::ActivityManager.update_activity(Discord::Activity.new) do |result|
+    if result == Discord::Result::Ok
+        puts "Success!"
+    else
+        puts "Failed"
+    end
+end
+```
+
+If no block is provided, and an error occurs, it should be logged to stderr. (or your log hook if that is set up)
+
+Events work a little bit differently than in the SDK docs. As far as I can tell, the docs don't cover "connecting" or "disconnecting".
+Events require you to "connect" to them, meaning you can subscribe multiple blocks to any single event. (iirc the cap is 4?)
+When you add something to an event, it will return a token, an identifier to the block passed into the event, which **must** be used when removing blocks from an event.
+It's sort of like a subscriber system, where things can subscribe to an event, and then unsubscribe from said event at any point.
+
+Events and pending callbacks are stored in a global array and hash respectively, if you ever need to access them for some reason. 
+**I would not suggest trying to modify them.** It will inevitably cause bad problems.
+
+C# code:
+```cs
+activityManager.OnActivityJoin += secret => {
+    Console.WriteLine("OnJoin {0}", secret);
+}
+```
+rdiscord_sdk equivalent:
+```rb
+token = Discord::ActivityManager.on_activity_join_connect do |secret|
+            puts "OnJoin #{secret}"
+        end
+
+Discord::ActivtyManager.on_activity_join_disconnect(token) # I'm not sure what the C# equivalent is
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rdiscord_sdk'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rdiscord_sdk
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [GPL-3]() license.
+
+This gem also uses the [Discord SDK](https://discord.com/developers/docs/game-sdk/discord), which is proprietary. Everything under `third_party/` is owned by Discord.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Speak2Erase/rdiscord_sdk.
+
+## Development Progress
+
+### Data Classes
+
+- [x] DiscordUser
+- [ ] DiscordOAuth2Token
+- [ ] DiscordImageHandle
+- [ ] DiscordImageDimensions
+- [x] DiscordActivityTimestamps
+- [x] DiscordActivityAssets
+- [x] DiscordPartySize
+- [x] DiscordActivityParty
+- [x] DiscordActivitySecrets
+- [x] DiscordActivity
+- [ ] DiscordPresence
+- [ ] DiscordRelationship
+- [ ] DiscordLobby
+- [ ] DiscordFileStat
+- [ ] DiscordEntitlement
+- [ ] DiscordSkuPrive
+- [ ] DiscordSku
+- [ ] DiscordInputMode
+- [ ] DiscordUserAchievement
+
+### Managers implemented
+- [ ] ApplicationManager
+- [x] UserManager
+- [ ] ImageManager
+- [x] ActivityManager
+- [ ] RelationshipManager
+- [ ] LobbyManager
+- [ ] NetworkManager
+- [ ] OverlayManager
+- [ ] StorageManager
+- [ ] StoreManager
+- [ ] VoiceManager
+- [ ] AchievementManager
+
+### Others
+- [ ] Core functionality
+  - [x] Initialization
+  - [ ] Teardown
+  - [x] Run callbacks
+  - [x] Log hooks
+- [x] All enums
+- [ ] DiscordLobbyTransaction
+- [ ] DiscordLobbySearchQuery
+- [x] Events
+  - [x] UserEvents
+  - [x] ActivityEvents
+  - [ ] RelationshipEvents
+  - [ ] LobbyEvents
+  - [ ] NetworkEvents
+  - [ ] OverlayEvents
+  - [ ] StoreEvents
+  - [ ] VoiceEvents
+  - [ ] AchievementEvents

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+require "rake/extensiontask"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop
+
+task build: :compile
+
+Rake::ExtensionTask.new("rdiscord_sdk") do |ext|
+  ext.lib_dir = "lib/rdiscord_sdk"
+end
+
+task default: %i[clobber compile]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rdiscord_sdk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/rdiscord_sdk/activity.cpp

@@ -0,0 +1,297 @@
+#include "activity.h"
+#include <rice/rice.hpp>
+#include "discord.h"
+#include "common.h"
+#include <cstdint>
+using namespace Rice;
+
+Class rb_cActivity;
+
+DEF_TYPE_CUSTOMTYPENAME(discord::Activity, Activity_rbType);
+
+Object rb_activity_initialize(Object self) {
+    discord::Activity* activity = new discord::Activity();
+    setPrivateData(self, activity);
+
+    return self;
+}
+
+int rb_activity_get_type(Object self) {
+    GET_ACTIVITY(self);
+
+    return (int) activity->GetType();
+}
+
+Object rb_activity_set_type(Object self, int type) {
+    GET_ACTIVITY(self);
+
+    activity->SetType((discord::ActivityType) type);
+
+    return Qnil;
+}
+
+std::int64_t rb_activity_get_application_id(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetApplicationId();
+}
+
+Object rb_activity_set_application_id(Object self, std::int64_t id) {
+    GET_ACTIVITY(self);
+
+    activity->SetApplicationId(id);
+
+    return Qnil;
+}
+
+const char* rb_activity_get_name(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetName();
+}
+
+Object rb_activity_set_name(Object self, const char* name) {
+    GET_ACTIVITY(self);
+
+    activity->SetName(name);
+
+    return Qnil;
+}
+
+const char* rb_activity_get_state(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetState();
+}
+
+Object rb_activity_set_state(Object self, const char* state) {
+    GET_ACTIVITY(self);
+
+    activity->SetState(state);
+
+    return Qnil;
+}
+
+const char* rb_activity_get_details(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetDetails();
+}
+
+Object rb_activity_set_details(Object self, const char* details) {
+    GET_ACTIVITY(self);
+
+    activity->SetDetails(details);
+
+    return Qnil;
+}
+
+bool rb_activity_get_instance(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetInstance();
+}
+
+Object rb_activity_set_instance(Object self, bool instance) {
+    GET_ACTIVITY(self);
+
+    activity->SetInstance(instance);
+
+    return Qnil;
+}
+
+std::int64_t rb_activity_timestamp_get_timestamp_start(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetTimestamps().GetStart();
+}
+
+Object rb_activity_timestamp_set_timestamp_start(Object self, std::int64_t start) {
+    GET_ACTIVITY(self);
+
+    activity->GetTimestamps().SetStart(start);
+
+    return Qnil;
+}
+
+std::int64_t rb_activity_timestamp_get_timestamp_end(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetTimestamps().GetEnd();
+}
+
+Object rb_activity_timestamp_set_timestamp_end(Object self, std::int64_t end) {
+    GET_ACTIVITY(self);
+
+    activity->GetTimestamps().SetEnd(end);
+
+    return Qnil;
+}
+
+const char* rb_activity_assets_get_large_image(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetAssets().GetLargeImage();
+}
+
+Object rb_activity_assets_set_large_image(Object self, const char* largeImage) {
+    GET_ACTIVITY(self);
+
+    activity->GetAssets().SetLargeImage(largeImage);
+
+    return Qnil;
+}
+
+const char* rb_activity_assets_get_large_text(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetAssets().GetLargeText();
+}
+
+Object rb_activity_assets_set_large_text(Object self, const char* largeText) {
+    GET_ACTIVITY(self);
+
+    activity->GetAssets().SetLargeText(largeText);
+
+    return Qnil;
+}
+
+const char* rb_activity_assets_get_small_image(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetAssets().GetSmallImage();
+}
+
+Object rb_activity_assets_set_small_image(Object self, const char* smallImage) {
+    GET_ACTIVITY(self);
+
+    activity->GetAssets().SetSmallImage(smallImage);
+
+    return Qnil;
+}
+
+const char* rb_activity_assets_get_small_text(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetAssets().GetSmallText();
+}
+
+Object rb_activity_assets_set_small_text(Object self, const char* smallText) {
+    GET_ACTIVITY(self);
+
+    activity->GetAssets().SetSmallText(smallText);
+
+    return Qnil;
+}
+
+const char* rb_activity_party_get_party_id(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetParty().GetId();
+}
+
+Object rb_activity_party_set_party_id(Object self, const char* id) {
+    GET_ACTIVITY(self);
+
+    activity->GetParty().SetId(id);
+
+    return Qnil;
+}
+
+std::int32_t rb_activity_party_get_party_size(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetParty().GetSize().GetCurrentSize();
+}
+
+Object rb_activity_party_set_party_size(Object self, std::int32_t size) {
+    GET_ACTIVITY(self);
+
+    activity->GetParty().GetSize().SetCurrentSize(size);
+
+    return Qnil;
+}
+
+std::int32_t rb_activity_party_get_party_max(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetParty().GetSize().GetMaxSize();
+}
+
+Object rb_activity_party_set_party_max(Object self, std::int32_t max) {
+    GET_ACTIVITY(self);
+
+    activity->GetParty().GetSize().SetMaxSize(max);
+
+    return Qnil;
+}
+
+const char* rb_activity_secrets_get_secret_match(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetSecrets().GetMatch();
+}
+
+Object rb_activity_secrets_set_secret_match(Object self, const char* match) {
+    GET_ACTIVITY(self);
+
+    activity->GetSecrets().SetMatch(match);
+
+    return Qnil;
+}
+
+const char* rb_activity_secrets_get_secret_join(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetSecrets().GetJoin();
+}
+
+Object rb_activity_secrets_set_secret_join(Object self, const char* join) {
+    GET_ACTIVITY(self);
+
+    activity->GetSecrets().SetJoin(join);
+
+    return Qnil;
+}
+
+const char* rb_activity_secrets_get_secret_spectate(Object self) {
+    GET_ACTIVITY(self);
+
+    return activity->GetSecrets().GetSpectate();
+}
+
+Object rb_activity_secrets_set_secret_spectate(Object self, const char* spectate) {
+    GET_ACTIVITY(self);
+
+    activity->GetSecrets().SetSpectate(spectate);
+
+    return Qnil;
+}
+
+void rb_activity_init_class(Module module) {
+    rb_cActivity = define_class_under(module, "Activity");
+    rb_cActivity.define_method("initialize", &rb_activity_initialize);
+    rb_define_alloc_func(rb_cActivity, classAllocate<&Activity_rbType>);
+    DEF_METHOD_GET_SET(rb_cActivity, type, activity);
+    DEF_METHOD_GET_SET(rb_cActivity, application_id, activity);
+    DEF_METHOD_GET_SET(rb_cActivity, name, activity);
+    DEF_METHOD_GET_SET(rb_cActivity, state, activity);
+    DEF_METHOD_GET_SET(rb_cActivity, details, activity);
+    DEF_METHOD_GET_SET(rb_cActivity, instance, activity);
+    // Timestamps
+    DEF_METHOD_GET_SET(rb_cActivity, timestamp_start, activity_timestamp);
+    DEF_METHOD_GET_SET(rb_cActivity, timestamp_end, activity_timestamp);
+    // Assets
+    DEF_METHOD_GET_SET(rb_cActivity, large_image, activity_assets);
+    DEF_METHOD_GET_SET(rb_cActivity, large_text, activity_assets);
+    DEF_METHOD_GET_SET(rb_cActivity, small_image, activity_assets);
+    DEF_METHOD_GET_SET(rb_cActivity, small_text, activity_assets);
+    // Party
+    DEF_METHOD_GET_SET(rb_cActivity, party_id, activity_party);
+    DEF_METHOD_GET_SET(rb_cActivity, party_size, activity_party);
+    DEF_METHOD_GET_SET(rb_cActivity, party_max, activity_party);
+    // Secrets
+    DEF_METHOD_GET_SET(rb_cActivity, secret_match, activity_secrets);
+    DEF_METHOD_GET_SET(rb_cActivity, secret_join, activity_secrets);
+    DEF_METHOD_GET_SET(rb_cActivity, secret_spectate, activity_secrets);
+}

data/ext/rdiscord_sdk/activity.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include "rdiscord_sdk.h"
+#include "discord.h"
+#include "common.h"
+
+using namespace Rice;
+
+extern Class rb_cActivity;
+void rb_activity_init_class(Module module);
+
+#define GET_ACTIVITY(obj) \
+if (!obj.is_a(rb_cActivity)) { \
+    rb_raise(rb_eTypeError, "Activity is not a Discord::Activity"); \
+} \
+discord::Activity* activity = getPrivateData<discord::Activity>(obj);

data/ext/rdiscord_sdk/common.cpp

@@ -0,0 +1,65 @@
+#include "common.h"
+#include <functional>
+#include <iostream>
+
+using namespace Rice;
+
+VALUE rb_common_get_callback_proc(int args) {
+    if (!rb_block_given_p())
+    {
+        return Qnil;
+    }
+    VALUE proc = rb_block_proc();
+    if (rb_proc_arity(proc) != args) {
+        rb_raise(rb_eRuntimeError, "Passed block should take %d arguments, got %d instead", args, rb_proc_arity(proc));
+    }
+    rb_ary_push(rb_oPendingCallbacks, proc);
+    return proc;
+}
+
+VALUE rb_common_get_event_proc(int args) {
+    if (!rb_block_given_p())
+    {
+        return Qnil;
+    }
+
+    VALUE proc = rb_block_proc();
+    if (rb_proc_arity(proc) != args) {
+        rb_raise(rb_eRuntimeError, "Passed block should take %d arguments, got %d instead", args, rb_proc_arity(proc));
+    }
+    return proc;
+}
+
+void rb_common_add_proc_to_hash(VALUE key, VALUE proc) {
+    rb_hash_aset(rb_oProcEvents, key, proc);
+}
+
+VALUE rb_result_to_obj(discord::Result result) {
+    return INT2NUM((int) result);
+}
+
+VALUE rb_discord_call_proc(VALUE ary) {
+    VALUE proc = rb_ary_shift(ary);
+    return rb_proc_call(proc, ary);
+}
+
+/*  Discord's C++ API doesn't have callback data, so this is the easiest way (i could think of) to make a callback know what proc it has */
+std::function<void(discord::Result)> rb_discord_callback_wrapper_basic(VALUE proc) {    
+    std::function<void(discord::Result)> fn = [proc](discord::Result result){
+        if (proc == Qnil)
+            return;
+
+        if (!rb_obj_is_kind_of(proc, rb_cProc)) {
+            rb_raise(rb_eTypeError, "Proc expected in callback, got %d instead", rb_obj_classname(proc));
+        }
+
+        rb_ary_delete(rb_oPendingCallbacks, proc);
+        VALUE ary = rb_ary_new_from_args(2, proc, INT2NUM((int) result));
+
+        int state;
+        rb_protect(rb_discord_call_proc, ary, &state);
+        LOG_ERROR_IF_STATE;
+    };
+    return fn;
+}
+

data/ext/rdiscord_sdk/common.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "rdiscord_sdk.h"
+#include <exception>
+
+#define BOOL2RB(val) ((val) ? Qtrue : Qfalse)
+
+#define CHECK_CORE_INITIALIZED \
+    if (!DiscordSDK.core) \
+        rb_raise(rb_eRuntimeError, "The Discord SDK core is not initialized!");
+
+template <class C> inline C *getPrivateData(VALUE self) {
+    C *c = static_cast<C *>(RTYPEDDATA_DATA(self));
+    if (!c) {
+        rb_raise(rb_eStandardError, "RTYPEDDATA_DATA for object missing data");
+    }
+    return c;
+}
+
+static inline void setPrivateData(VALUE self, void *p) {
+    RTYPEDDATA_DATA(self) = p;
+}
+
+
+#define GUARD_EXC(exp) \
+{ \
+    try { \
+        exp \
+    } catch (std::exception &error) { \
+        rb_raise(rb_eFatal, "%s", error.what();) \
+    } \
+}
+
+template <rb_data_type_t *rbType> static VALUE classAllocate(VALUE klass) {
+    return rb_data_typed_object_wrap(klass, 0, rbType);
+}
+
+template <class C> static void freeInstance(void *inst) {
+    delete static_cast<C *>(inst);
+}
+
+#define DEF_TYPE_FLAGS 0
+
+#define DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, Free, Typename) \
+rb_data_type_t Typename = {Name, {0, Free, 0, 0, 0}, 0, 0, DEF_TYPE_FLAGS}
+
+#define DEF_TYPE_CUSTOMTYPENAME(Klass, Typename) \
+DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, #Klass, freeInstance<Klass>, Typename)
+
+#define DEF_TYPE_CUSTOMNAME(Klass, Name) \
+DEF_TYPE_CUSTOMNAME_AND_FREE(Klass, Name, freeInstance<Klass>, Klass##_rbType)
+
+#define DEF_TYPE(Klass) DEF_TYPE_CUSTOMNAME(Klass, #Klass)
+
+using namespace Rice;
+
+#define DEF_METHOD_SET(klass, name, subclass) \
+klass.define_method(#name, &rb_##subclass##_get_##name);
+
+#define DEF_METHOD_GET(klass, name, subclass) \
+klass.define_method(#name "=", &rb_##subclass##_set_##name);
+
+#define DEF_METHOD_GET_SET(klass, name, subclass) \
+klass.define_method(#name, &rb_##subclass##_get_##name); \
+klass.define_method(#name "=", &rb_##subclass##_set_##name);
+
+#define DEF_METHOD_EVENT(klass, name, subclass) \
+klass.define_module_function("on_" #name "_connect", &rb_##subclass##_on_##name##_connect); \
+klass.define_module_function("on_" #name "_disconect", &rb_##subclass##_on_##name##_disconnect);
+
+#define LOG_ERROR_IF_STATE \
+if (state) { \
+    /* callback function broke, theres not much we can do other than print out an error */  \
+    VALUE exception = rb_sprintf("[DiscordGameSDK] Callback function error: %" PRIsVALUE, rb_errinfo()); \
+    fwrite(StringValuePtr(exception), 1, RSTRING_LEN(exception), stderr); \
+    rb_set_errinfo(Qnil); \
+}
+
+VALUE rb_common_get_callback_proc(int args);
+VALUE rb_common_get_event_proc(int args);
+void rb_common_add_proc_to_hash(VALUE key, VALUE proc);
+
+VALUE rb_result_to_obj(discord::Result);
+extern VALUE rb_oPendingCallbacks;
+extern VALUE rb_oProcEvents;
+
+VALUE rb_discord_call_proc(VALUE ary);
+std::function<void(discord::Result)> rb_discord_callback_wrapper_basic(VALUE proc);