tox 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9b379392361313b80d9b376b8f4367cc9298954
-  data.tar.gz: 8b76e5c44863f518b384b016900029a88f127f57
+  metadata.gz: 1ab3125d380817a144ee66674764101ec8e86754
+  data.tar.gz: 2b4f4c0e20c4bec09f30a15db7414926a9eff90e
 SHA512:
-  metadata.gz: 3cf31a4fc75645d1600897f353a82d3332884475f3d89014af12876be2d7df6282340973435658a6c07cf09069c88abac04f9d8de6deb42c36eb18806f2c0c31
-  data.tar.gz: 6133a29001c3ba3ad110f00d3ed37eb7968aeb9459f55ee043496b782623eb5a63689b3ddd21e6d67afbad90661963f523e82d95c5c56bcb0dfb8d91b2d1848d
+  metadata.gz: 560228cc65e59acace9c3e56b36582124ca7372719ecb7b68fadee22eaf7869a88abebb51e0eb459a94066609ddb1ec802a1cc60d96c9d72c319104bdb6c93f7
+  data.tar.gz: 7d441fa2149a92729b072c7716ed3cec8a33968c92550c12caf715ee0b1a714efa5985c3ef348cf1e8869713726d31f82a079111f3bf4ade1d65ac5ec6c02d6d

data/.rubocop.yml

@@ -3,33 +3,32 @@ AllCops:
   DisplayCopNames: true
 
   Exclude:
-    - vendor/**/*
+    - 'vendor/**/*'
 
 Layout/AccessModifierIndentation:
   EnforcedStyle: outdent
 
 Layout/MultilineOperationIndentation:
   Exclude:
-    - ext/**/*
+    - 'ext/**/*'
+
+Lint/InheritException:
+  Enabled: false
 
 Metrics/BlockLength:
   Exclude:
     - '**/*.gemspec'
-    - spec/**/*
-
-Metrics/LineLength:
-  Max: 120
+    - 'spec/**/*'
 
 Style/AndOr:
-  Exclude:
-    - ext/**/*
+  EnforcedStyle: conditionals
 
 Style/DoubleNegation:
   Enabled: false
 
 Style/GlobalVars:
   Exclude:
-    - ext/**/*
+    - 'ext/**/*'
 
 Style/TrailingCommaInArguments:
   EnforcedStyleForMultiline: comma

data/examples/echo_bot.rb

@@ -6,7 +6,7 @@
 # filename as the script argument it can restore private key from this file so
 # it's address will not change between restarts.
 #
-# Based on implementation in C: https://github.com/braiden-vasco/ToxEcho
+# Based on implementation in C: https://github.com/toxon/ToxEcho
 
 require 'bundler/setup'
 
@@ -27,11 +27,13 @@ end
 tox_client = Tox::Client.new tox_options
 
 tox_client.name = NAME
+tox_client.status = Tox::UserStatus::NONE
 tox_client.status_message = STATUS_MESSAGE
 
 puts
 puts "Address:        #{tox_client.address.to_hex}"
 puts "Name:           #{tox_client.name}"
+puts "Status:         #{tox_client.status}"
 puts "Status message: #{tox_client.status_message}"
 puts
 
@@ -39,16 +41,29 @@ puts 'Connecting to the nodes from official list...'
 tox_client.bootstrap_official
 
 tox_client.on_friend_request do |public_key|
-  puts "Got friend request with public key #{public_key.to_hex}. Adding to contacts..."
+  puts "Got friend request with public key #{public_key.to_hex}. " \
+       'Adding to contacts...'
+  puts
+
   tox_client.friend_add_norequest public_key
 end
 
 tox_client.on_friend_message do |friend, text|
-  puts "Got message from friend number #{friend.number} with text #{text.inspect}. Sending it back..."
+  puts 'Message from friend'
+  puts "Number:         #{friend.number}"
+  puts "Name:           #{friend.name}"
+  puts "Public key:     #{friend.public_key.to_hex}"
+  puts "Status:         #{friend.status}"
+  puts "Status message: #{friend.status_message}"
+  puts text.inspect
+  puts
+
   friend.send_message text
 end
 
-puts 'Running. Send me friend request, I\'ll accept it immediately. Then send me a message.'
+puts 'Running. Send me friend request, I\'ll accept it immediately. ' \
+     'Then send me a message.'
+
 begin
   puts
   tox_client.run

data/ext/tox/client.c

@@ -17,22 +17,16 @@
  */
 
 #include "tox.h"
-#include "client.h"
-#include "options.h"
-#include "node.h"
-#include "friend.h"
 
 #include <time.h>
 
-// Instance
-VALUE mTox_cClient;
-
 // Memory management
 static VALUE mTox_cClient_alloc(VALUE klass);
 static void  mTox_cClient_free(mTox_cClient_CDATA *free_cdata);
 
 // Public methods
 
+static VALUE mTox_cClient_public_key(VALUE self);
 static VALUE mTox_cClient_address(VALUE self);
 static VALUE mTox_cClient_savedata(VALUE self);
 
@@ -41,9 +35,14 @@ static VALUE mTox_cClient_bootstrap(VALUE self, VALUE node);
 static VALUE mTox_cClient_name(VALUE self);
 static VALUE mTox_cClient_name_EQUALS(VALUE self, VALUE name);
 
+static VALUE mTox_cClient_status(VALUE self);
+static VALUE mTox_cClient_status_EQUALS(VALUE self, VALUE status);
+
 static VALUE mTox_cClient_status_message(VALUE self);
 static VALUE mTox_cClient_status_message_EQUALS(VALUE self, VALUE status_message);
 
+static VALUE mTox_cClient_friend_numbers(VALUE self);
+
 static VALUE mTox_cClient_friend_add_norequest(VALUE self, VALUE public_key);
 
 // Private methods
@@ -70,31 +69,57 @@ static void on_friend_message(
   VALUE self
 );
 
+static void on_friend_name_change(
+  Tox *tox,
+  uint32_t friend_number,
+  const uint8_t *name,
+  size_t length,
+  VALUE self
+);
+
+static void on_friend_status_message_change(
+  Tox *tox,
+  uint32_t friend_number,
+  const uint8_t *status_message,
+  size_t length,
+  VALUE self
+);
+
+static void on_friend_status_change(
+  Tox *tox,
+  uint32_t friend_number,
+  TOX_USER_STATUS status,
+  VALUE self
+);
+
 /*************************************************************
  * Initialization
  *************************************************************/
 
 void mTox_cClient_INIT()
 {
-  // Instance
-  mTox_cClient = rb_define_class_under(mTox, "Client", rb_cObject);
-
   // Memory management
   rb_define_alloc_func(mTox_cClient, mTox_cClient_alloc);
 
   // Public methods
 
-  rb_define_method(mTox_cClient, "address",  mTox_cClient_address,  0);
-  rb_define_method(mTox_cClient, "savedata", mTox_cClient_savedata, 0);
+  rb_define_method(mTox_cClient, "public_key", mTox_cClient_public_key, 0);
+  rb_define_method(mTox_cClient, "address",    mTox_cClient_address,    0);
+  rb_define_method(mTox_cClient, "savedata",   mTox_cClient_savedata,   0);
 
   rb_define_method(mTox_cClient, "bootstrap", mTox_cClient_bootstrap, 1);
 
   rb_define_method(mTox_cClient, "name",  mTox_cClient_name,        0);
   rb_define_method(mTox_cClient, "name=", mTox_cClient_name_EQUALS, 1);
 
+  rb_define_method(mTox_cClient, "status",  mTox_cClient_status,        0);
+  rb_define_method(mTox_cClient, "status=", mTox_cClient_status_EQUALS, 1);
+
   rb_define_method(mTox_cClient, "status_message",  mTox_cClient_status_message,        0);
   rb_define_method(mTox_cClient, "status_message=", mTox_cClient_status_message_EQUALS, 1);
 
+  rb_define_method(mTox_cClient, "friend_numbers", mTox_cClient_friend_numbers, 0);
+
   rb_define_method(mTox_cClient, "friend_add_norequest", mTox_cClient_friend_add_norequest, 1);
 
   // Private methods
@@ -129,6 +154,25 @@ void mTox_cClient_free(mTox_cClient_CDATA *const free_cdata)
  * Public methods
  *************************************************************/
 
+// Tox::Client#public_key
+VALUE mTox_cClient_public_key(const VALUE self)
+{
+  mTox_cClient_CDATA *self_cdata;
+
+  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+
+  char public_key[TOX_PUBLIC_KEY_SIZE];
+
+  tox_self_get_public_key(self_cdata->tox, (uint8_t*)public_key);
+
+  return rb_funcall(
+    mTox_cPublicKey,
+    rb_intern("new"),
+    1,
+    rb_str_new(public_key, TOX_PUBLIC_KEY_SIZE)
+  );
+}
+
 // Tox::Client#address
 VALUE mTox_cClient_address(const VALUE self)
 {
@@ -141,7 +185,7 @@ VALUE mTox_cClient_address(const VALUE self)
   tox_self_get_address(self_cdata->tox, (uint8_t*)address);
 
   return rb_funcall(
-    rb_const_get(mTox, rb_intern("Address")),
+    mTox_cAddress,
     rb_intern("new"),
     1,
     rb_str_new(address, TOX_ADDRESS_SIZE)
@@ -188,6 +232,12 @@ VALUE mTox_cClient_bootstrap(const VALUE self, const VALUE node)
   switch (error) {
     case TOX_ERR_BOOTSTRAP_OK:
       return Qtrue;
+    case TOX_ERR_BOOTSTRAP_NULL:
+      return Qfalse;
+    case TOX_ERR_BOOTSTRAP_BAD_HOST:
+      return Qfalse;
+    case TOX_ERR_BOOTSTRAP_BAD_PORT:
+      return Qfalse;
     default:
       return Qfalse;
   }
@@ -232,13 +282,65 @@ VALUE mTox_cClient_name_EQUALS(const VALUE self, const VALUE name)
   switch (error) {
     case TOX_ERR_SET_INFO_OK:
       break;
+    case TOX_ERR_SET_INFO_NULL:
+      rb_raise(mTox_eNullError, "tox_self_set_name() failed with TOX_ERR_SET_INFO_NULL");
+    case TOX_ERR_SET_INFO_TOO_LONG:
+      rb_raise(rb_eRuntimeError, "tox_self_set_name() failed with TOX_ERR_SET_INFO_TOO_LONG");
     default:
-      rb_raise(rb_eRuntimeError, "tox_self_set_name() failed");
+      rb_raise(mTox_eUnknownError, "tox_self_set_name() failed");
+  }
+
+  if (!result) {
+    rb_raise(mTox_eUnknownError, "tox_self_set_name() failed");
   }
 
   return name;
 }
 
+// Tox::Client#status
+VALUE mTox_cClient_status(const VALUE self)
+{
+  mTox_cClient_CDATA *self_cdata;
+
+  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+
+  const TOX_USER_STATUS result = tox_self_get_status(self_cdata->tox);
+
+  switch (result) {
+    case TOX_USER_STATUS_NONE:
+      return mTox_mUserStatus_NONE;
+    case TOX_USER_STATUS_AWAY:
+      return mTox_mUserStatus_AWAY;
+    case TOX_USER_STATUS_BUSY:
+      return mTox_mUserStatus_BUSY;
+    default:
+      rb_raise(rb_eNotImpError, "Tox::Client#status has unknown value");
+  }
+}
+
+// Tox::Client#status=
+VALUE mTox_cClient_status_EQUALS(const VALUE self, const VALUE status)
+{
+  mTox_cClient_CDATA *self_cdata;
+
+  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+
+  if (rb_funcall(mTox_mUserStatus_NONE, rb_intern("=="), 1, status)) {
+    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_NONE);
+  }
+  else if (rb_funcall(mTox_mUserStatus_AWAY, rb_intern("=="), 1, status)) {
+    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_AWAY);
+  }
+  else if (rb_funcall(mTox_mUserStatus_BUSY, rb_intern("=="), 1, status)) {
+    tox_self_set_status(self_cdata->tox, TOX_USER_STATUS_BUSY);
+  }
+  else {
+    rb_raise(rb_eArgError, "invalid value for Tox::Client#status=");
+  }
+
+  return status;
+}
+
 // Tox::Client#status_message
 VALUE mTox_cClient_status_message(const VALUE self)
 {
@@ -278,13 +380,47 @@ VALUE mTox_cClient_status_message_EQUALS(const VALUE self, const VALUE status_me
   switch (error) {
     case TOX_ERR_SET_INFO_OK:
       break;
+    case TOX_ERR_SET_INFO_NULL:
+      rb_raise(mTox_eNullError, "tox_self_set_status_message() failed with TOX_ERR_SET_INFO_NULL");
+    case TOX_ERR_SET_INFO_TOO_LONG:
+      rb_raise(rb_eRuntimeError, "tox_self_set_status_message() failed with TOX_ERR_SET_INFO_TOO_LONG");
     default:
-      rb_raise(rb_eRuntimeError, "tox_self_set_status_message() failed");
+      rb_raise(mTox_eUnknownError, "tox_self_set_status_message() failed");
+  }
+
+  if (!result) {
+    rb_raise(mTox_eUnknownError, "tox_self_set_status_message() failed");
   }
 
   return status_message;
 }
 
+// Tox::Client#friend_numbers
+VALUE mTox_cClient_friend_numbers(const VALUE self)
+{
+  mTox_cClient_CDATA *self_cdata;
+
+  Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
+
+  const size_t friend_numbers_size = tox_self_get_friend_list_size(self_cdata->tox);
+
+  if (friend_numbers_size == 0) {
+    return rb_ary_new();
+  }
+
+  uint32_t friend_numbers[friend_numbers_size];
+
+  tox_self_get_friend_list(self_cdata->tox, friend_numbers);
+
+  VALUE friend_number_values[friend_numbers_size];
+
+  for (unsigned long i = 0; i < friend_numbers_size; ++i) {
+    friend_number_values[i] = LONG2NUM(friend_numbers[i]);
+  }
+
+  return rb_ary_new4(friend_numbers_size, friend_number_values);
+}
+
 // Tox::Client#friend_add_norequest
 VALUE mTox_cClient_friend_add_norequest(const VALUE self, const VALUE public_key)
 {
@@ -294,7 +430,18 @@ VALUE mTox_cClient_friend_add_norequest(const VALUE self, const VALUE public_key
 
   Data_Get_Struct(self, mTox_cClient_CDATA, self_cdata);
 
-  return LONG2FIX(tox_friend_add_norequest(self_cdata->tox, (uint8_t*)RSTRING_PTR(public_key), NULL));
+  const VALUE friend_number = LONG2FIX(tox_friend_add_norequest(
+    self_cdata->tox,
+    (uint8_t*)RSTRING_PTR(public_key),
+    NULL
+  ));
+
+  return rb_funcall(
+    self,
+    rb_intern("friend"),
+    1,
+    friend_number
+  );
 }
 
 /*************************************************************
@@ -321,16 +468,33 @@ VALUE mTox_cClient_initialize_with(const VALUE self, const VALUE options)
   switch (error) {
     case TOX_ERR_NEW_OK:
       break;
+    case TOX_ERR_NEW_NULL:
+      rb_raise(mTox_eNullError, "tox_new() failed with TOX_ERR_NEW_NULL");
     case TOX_ERR_NEW_MALLOC:
-      rb_raise(rb_eNoMemError, "tox_new() returned TOX_ERR_NEW_MALLOC");
+      rb_raise(rb_eNoMemError, "tox_new() failed with TOX_ERR_NEW_MALLOC");
+    case TOX_ERR_NEW_PORT_ALLOC:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PORT_ALLOC");
+    case TOX_ERR_NEW_PROXY_BAD_TYPE:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_TYPE");
+    case TOX_ERR_NEW_PROXY_BAD_HOST:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_HOST");
+    case TOX_ERR_NEW_PROXY_BAD_PORT:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_BAD_PORT");
+    case TOX_ERR_NEW_PROXY_NOT_FOUND:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_PROXY_NOT_FOUND");
+    case TOX_ERR_NEW_LOAD_ENCRYPTED:
+      rb_raise(rb_eRuntimeError, "tox_new() failed with TOX_ERR_NEW_LOAD_ENCRYPTED");
     case TOX_ERR_NEW_LOAD_BAD_FORMAT:
-      rb_raise(rb_const_get(mTox_cClient, rb_intern("BadSavedataError")), "savedata format is invalid");
+      rb_raise(mTox_cClient_eBadSavedataError, "tox_new() failed with TOX_ERR_NEW_LOAD_BAD_FORMAT");
     default:
-      rb_raise(rb_eRuntimeError, "tox_new() failed");
+      rb_raise(mTox_eUnknownError, "tox_new() failed");
   }
 
-  tox_callback_friend_request(self_cdata->tox, on_friend_request);
-  tox_callback_friend_message(self_cdata->tox, on_friend_message);
+  tox_callback_friend_request       (self_cdata->tox, on_friend_request);
+  tox_callback_friend_message       (self_cdata->tox, on_friend_message);
+  tox_callback_friend_name          (self_cdata->tox, on_friend_name_change);
+  tox_callback_friend_status_message(self_cdata->tox, on_friend_status_message_change);
+  tox_callback_friend_status        (self_cdata->tox, on_friend_status_change);
 
   return self;
 }
@@ -346,11 +510,17 @@ VALUE mTox_cClient_run_loop(const VALUE self)
 
   delay.tv_sec = 0;
 
+  const VALUE ivar_on_iteration = rb_iv_get(self, "@on_iteration");
+
   while (rb_funcall(self, rb_intern("running?"), 0)) {
     delay.tv_nsec = tox_iteration_interval(self_cdata->tox) * 1000000;
     nanosleep(&delay, NULL);
 
     tox_iterate(self_cdata->tox, self);
+
+    if (Qnil != ivar_on_iteration) {
+      rb_funcall(ivar_on_iteration, rb_intern("call"), 0);
+    }
   }
 
   return self;
@@ -379,7 +549,7 @@ void on_friend_request(
     rb_intern("call"),
     2,
     rb_funcall(
-      rb_const_get(mTox, rb_intern("PublicKey")),
+      mTox_cPublicKey,
       rb_intern("new"),
       1,
       rb_str_new(public_key, TOX_PUBLIC_KEY_SIZE)
@@ -417,3 +587,105 @@ void on_friend_message(
     rb_str_new((char*)text, length)
   );
 }
+
+void on_friend_name_change(
+  Tox *const tox,
+  const uint32_t friend_number,
+  const uint8_t *const name,
+  const size_t length,
+  const VALUE self
+)
+{
+  const VALUE ivar_on_friend_name_change = rb_iv_get(self, "@on_friend_name_change");
+
+  if (Qnil == ivar_on_friend_name_change) {
+    return;
+  }
+
+  rb_funcall(
+    ivar_on_friend_name_change,
+    rb_intern("call"),
+    2,
+    rb_funcall(
+      mTox_cFriend,
+      rb_intern("new"),
+      2,
+      self,
+      LONG2FIX(friend_number)
+    ),
+    rb_str_new(name, length)
+  );
+}
+
+void on_friend_status_message_change(
+  Tox *const tox,
+  const uint32_t friend_number,
+  const uint8_t *const status_message,
+  size_t length,
+  const VALUE self
+)
+{
+  const VALUE ivar_on_friend_status_message_change = rb_iv_get(self, "@on_friend_status_message_change");
+
+  if (Qnil == ivar_on_friend_status_message_change) {
+    return;
+  }
+
+  rb_funcall(
+    ivar_on_friend_status_message_change,
+    rb_intern("call"),
+    2,
+    rb_funcall(
+      mTox_cFriend,
+      rb_intern("new"),
+      2,
+      self,
+      LONG2FIX(friend_number)
+    ),
+    rb_str_new(status_message, length)
+  );
+}
+
+void on_friend_status_change(
+  Tox *const tox,
+  const uint32_t friend_number,
+  const TOX_USER_STATUS status,
+  const VALUE self
+)
+{
+  const VALUE ivar_on_friend_status_change = rb_iv_get(self, "@on_friend_status_change");
+
+  if (Qnil == ivar_on_friend_status_change) {
+    return;
+  }
+
+  VALUE status_value;
+
+  switch (status) {
+    case TOX_USER_STATUS_NONE:
+      status_value = mTox_mUserStatus_NONE;
+      break;
+    case TOX_USER_STATUS_AWAY:
+      status_value = mTox_mUserStatus_AWAY;
+      break;
+    case TOX_USER_STATUS_BUSY:
+      status_value = mTox_mUserStatus_BUSY;
+      break;
+    default:
+      return;
+  }
+
+  rb_funcall(
+    ivar_on_friend_status_change,
+    rb_intern("call"),
+    2,
+    rb_funcall(
+      mTox_cFriend,
+      rb_intern("new"),
+      2,
+      self,
+      LONG2FIX(friend_number)
+    ),
+    status_value
+  );
+}