glib2 3.4.9 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c89356959f6eaabab6237b23ed3e3820a0590869d2390ba5d6c6063aafe36fcb
-  data.tar.gz: 07b367f72d3fe0cda25c855309a960f4d82367b98e2c92bdfe15cfea8dc2060f
+  metadata.gz: 3ffe632b39b4bf1a97a57a079224989e6a2e7c83f09b4a6a3d27806fd95f541f
+  data.tar.gz: 0dd688a0ce0b2dbb4df08c4a4c282245683a8f2cbea27d55b7f2833ae029c550
 SHA512:
-  metadata.gz: 6ba67d05ed39fd2a1e8fa4f4ca4132b67670a1437469479a4904fce4783c73ab0353100bb9ddb416f250881070a68019058c4c1c7b429af959fa05e12e0a1fa1
-  data.tar.gz: d87db1a676ee3c60e0855c29c567222524a9d14ee788a70af341866dff199ab46f8dfc58ca51c5b8612474df23ea2ad86bf6ec70950804898c88b2268bcde122
+  metadata.gz: edb56979dce1a887f979d32b1a86830ea1a57aee20b9cc68fb1e31b5b8f437ba8f4734601c1a810cea3d3fa09e4e90ad0bc997a3b035bade74ee22c6343675fd
+  data.tar.gz: 46d9ddd70c9edd57e4af6bdaf336817b47eb5a2f3371e53af5f2f08f8853fb24790bf547920aa1a1df11cbb30cefaa10d36f727302b4b1c9bed1702d34b7c550

data/ext/glib2/extconf.rb

@@ -28,12 +28,13 @@ require "mkmf-gnome"
 
 unless required_pkg_config_package([package_id, 2, 12, 0],
                                    :alt_linux => "glib2-devel",
-                                   :debian => "libglib2.0-dev",
-                                   :redhat => "pkgconfig(#{package_id})",
                                    :arch_linux => "glib2",
+                                   :debian => "libglib2.0-dev",
+                                   :gentoo_linux => "dev-libs/glib",
                                    :homebrew => "glib",
                                    :macports => "glib2",
-                                   :msys2 => "glib2")
+                                   :msys2 => "glib2",
+                                   :redhat => "pkgconfig(#{package_id})")
   exit(false)
 end
 PKGConfig.have_package('gthread-2.0')

data/ext/glib2/glib2.def

@@ -76,11 +76,14 @@ EXPORTS
 	g_rclosure_new
 	g_rclosure_new_call
 	g_rclosure_attach
+	g_rclosure_attach_gobject
 	g_rclosure_set_tag
 	rbgobj_ruby_value_get_type
 	g_value_get_ruby_value
 	g_value_set_ruby_value
 	g_key_file_get_type
+	rbg_mGLib
+	rbg_cGLibObject
 	rbg_rval_inspect
 	rbg_string_value_ptr
 	rbg_rval2cstr
@@ -127,6 +130,7 @@ EXPORTS
 	rbg_rval2glist
 	rbg_rval2gslist
 	rbg_define_method
+	rbg_define_private_method
 	rbg_define_singleton_method
 	rbg_to_array
 	rbg_to_hash
@@ -153,6 +157,7 @@ EXPORTS
 	rbgutil_glibid_r2g_func
 	rbgutil_sym_g2r_func
 	rbgutil_protect
+	rbgutil_on_callback_error
 	rbgutil_invoke_callback
 	rbgutil_start_callback_dispatch_thread
 	rbgutil_stop_callback_dispatch_thread

data/ext/glib2/rbglib-bytes.c

@@ -122,7 +122,7 @@ rg_pointer(VALUE self)
 void
 Init_glib_bytes(void)
 {
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BYTES, "Bytes", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BYTES, "Bytes", rbg_mGLib());
 
     RG_DEF_SMETHOD(try_convert, 1);
 

data/ext/glib2/rbglib-gc.c

@@ -191,7 +191,7 @@ void
 Init_glib_gc(void)
 {
     VALUE gc_marker = rbg_gc_marker_new_raw();
-    rb_ivar_set(mGLib, rb_intern("gc_marker"), gc_marker);
+    rb_ivar_set(rbg_mGLib(), rb_intern("gc_marker"), gc_marker);
     TypedData_Get_Struct(gc_marker,
                          RBGGCMarker,
                          &rbg_gc_marker_type,

data/ext/glib2/rbglib-variant-type.c

@@ -234,7 +234,7 @@ rg_element(VALUE self)
 void
 Init_glib_variant_type(void)
 {
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT_TYPE, "VariantType", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT_TYPE, "VariantType", rbg_mGLib());
 
     RG_DEF_SMETHOD_P(valid, 1);
     RG_DEF_SMETHOD(scan, 1);

data/ext/glib2/rbglib-variant.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2015-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2015-2022  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -69,9 +69,10 @@ rbg_variant_to_ruby(GVariant *variant)
         VALUE value = rbg_variant_to_ruby(val);
         g_variant_unref(val);
         return value;
-    } else if (g_variant_type_is_array(type)) {
+    } else if (g_variant_type_is_array(type) ||
+               g_variant_type_is_tuple(type)) {
         gsize i, len = g_variant_n_children(variant);
-        VALUE ary = rb_ary_new2(len);
+        VALUE ary = rb_ary_new_capa(len);
         for (i = 0; i < len; i++) {
             GVariant *val = g_variant_get_child_value(variant, i);
             rb_ary_store(ary, i, rbg_variant_to_ruby(val));
@@ -106,10 +107,53 @@ rg_variant_free(gpointer object)
     g_variant_unref(variant);
 }
 
+static const rb_data_type_t rbg_variant_type = {
+    "GLib::Variant",
+    {
+        NULL,
+        rg_variant_free,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 rg_variant_allocate(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, NULL, rg_variant_free, NULL);
+    return TypedData_Wrap_Struct(klass, &rbg_variant_type, NULL);
+}
+
+static VALUE
+rg_s_parse(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_text;
+    VALUE rb_variant_type;
+    rb_scan_args(argc, argv, "11", &rb_text, &rb_variant_type);
+    const gchar *text = RVAL2CSTR(rb_text);
+    const gchar *limit = text + RSTRING_LEN(rb_text);
+    const GVariantType *variant_type = NULL;
+    if (!NIL_P(rb_variant_type)) {
+        variant_type = RVAL2GVARIANTTYPE(rb_variant_type);
+    }
+    GError *error = NULL;
+    GVariant *variant = g_variant_parse(variant_type,
+                                        text,
+                                        limit,
+                                        NULL,
+                                        &error);
+    if (error) {
+        GError *detailed_error = NULL;
+        gchar *context = g_variant_parse_error_print_context(error, text);
+        g_set_error_literal(&detailed_error,
+                            error->domain,
+                            error->code,
+                            context);
+        g_free(context);
+        g_error_free(error);
+        RG_RAISE_ERROR(detailed_error);
+    }
+    return TypedData_Wrap_Struct(klass, &rbg_variant_type, variant);
 }
 
 static GVariant *
@@ -282,14 +326,44 @@ rg_type(VALUE self)
     return GVARIANTTYPE2RVAL((GVariantType *)g_variant_get_type(variant));
 }
 
+static VALUE
+rg_to_s(int argc, VALUE *argv, VALUE self)
+{
+    VALUE options = Qnil;
+    gboolean type_annotate = false;
+    rb_scan_args(argc, argv, ":", &options);
+    if (!NIL_P(options)) {
+        ID keywords[1];
+        VALUE values[1];
+        keywords[0] = rb_intern("type_annotate");
+        rb_get_kwargs(options, keywords, 0, 1, values);
+        if (values[0] != Qundef) {
+            type_annotate = CBOOL2RVAL(values[0]);
+        }
+    }
+
+    GVariant *variant = _SELF(self);
+    gchar *string = g_variant_print(variant, type_annotate);
+    return CSTR2RVAL_FREE(string);
+}
+
 void
 Init_glib_variant(void)
 {
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT, "Variant", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT, "Variant", rbg_mGLib());
 
     rb_define_alloc_func(RG_TARGET_NAMESPACE, rg_variant_allocate);
 
+    RG_DEF_SMETHOD(parse, -1);
+
     RG_DEF_METHOD(initialize, -1);
     RG_DEF_METHOD(value, 0);
     RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD(to_s, -1);
+
+    G_DEF_ERROR(G_VARIANT_PARSE_ERROR,
+                "VariantParseError",
+                rbg_mGLib(),
+                rb_eRuntimeError,
+                G_TYPE_VARIANT_PARSE_ERROR);
 }

data/ext/glib2/rbglib.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2011-2022  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -29,6 +29,12 @@ static ID id_inspect;
 
 VALUE RG_TARGET_NAMESPACE;
 
+VALUE
+rbg_mGLib(void)
+{
+    return RG_TARGET_NAMESPACE;
+}
+
 const gchar *
 rbg_rval2cstr(VALUE *str)
 {
@@ -1067,6 +1073,25 @@ rg_s_os_unix_p(G_GNUC_UNUSED VALUE self)
 #endif
 }
 
+static VALUE
+rg_s_malloc(G_GNUC_UNUSED VALUE self, VALUE size)
+{
+    return POINTER2NUM(g_malloc(NUM2SIZET(size)));
+}
+
+static VALUE
+rg_s_malloc0(G_GNUC_UNUSED VALUE self, VALUE size)
+{
+    return POINTER2NUM(g_malloc0(NUM2SIZET(size)));
+}
+
+static VALUE
+rg_s_free(G_GNUC_UNUSED VALUE self, VALUE address)
+{
+    g_free(NUM2POINTER(address));
+    return RUBY_Qnil;
+}
+
 extern void Init_glib2(void);
 
 void
@@ -1153,6 +1178,10 @@ Init_glib2(void)
     RG_DEF_SMETHOD_P(os_beos, 0);
     RG_DEF_SMETHOD_P(os_unix, 0);
 
+    RG_DEF_SMETHOD(malloc, 1);
+    RG_DEF_SMETHOD(malloc0, 1);
+    RG_DEF_SMETHOD(free, 1);
+
     rb_define_const(RG_TARGET_NAMESPACE, "DIR_SEPARATOR", CSTR2RVAL(G_DIR_SEPARATOR_S));
     rb_define_const(RG_TARGET_NAMESPACE, "SEARCHPATH_SEPARATOR", CSTR2RVAL(G_SEARCHPATH_SEPARATOR_S));
 

data/ext/glib2/rbglib.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2002-2022  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -31,9 +31,9 @@
 
 G_BEGIN_DECLS
 
-#define RBGLIB_MAJOR_VERSION 3
-#define RBGLIB_MINOR_VERSION 4
-#define RBGLIB_MICRO_VERSION 9
+#define RBGLIB_MAJOR_VERSION 4
+#define RBGLIB_MINOR_VERSION 0
+#define RBGLIB_MICRO_VERSION 0
 
 #ifndef RB_ZALLOC
 #  ifdef ZALLOC
@@ -142,6 +142,14 @@ G_BEGIN_DECLS
 #define RVAL2POINTER(value) ((gpointer)(value))
 #define POINTER2RVAL(pointer) ((VALUE)(pointer))
 
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define NUM2POINTER(number) ((gpointer)NUM2ULONG(number))
+#  define POINTER2NUM(pointer) ULONG2NUM((unsigned long)pointer)
+#else
+#  define NUM2POINTER(number) ((gpointer)NUM2ULL(number))
+#  define POINTER2NUM(pointer) ULL2NUM((unsigned LONG_LONG)pointer)
+#endif
+
 #define GINTS2RVAL(ary, n) rbg_gints2rval(ary, n)
 #define GINTS2RVAL_FREE(ary, n) rbg_gints2rval(ary, n)
 
@@ -165,8 +173,13 @@ G_BEGIN_DECLS
 #  define RUBY_GLIB2_VAR extern
 #endif
 
+/* Deprecated. Use rbg_mGLib() instead. */
+G_GNUC_DEPRECATED_FOR(rbg_mGLib())
 RUBY_GLIB2_VAR VALUE mGLib;
 
+extern VALUE rbg_mGLib(void);
+extern VALUE rbg_cGLibObject(void);
+
 extern const gchar *rbg_rval_inspect(VALUE object);
 
 extern gchar* rbg_string_value_ptr(volatile VALUE* ptr); /* no longer used */

data/ext/glib2/rbglib_bookmarkfile.c

@@ -500,9 +500,10 @@ rg_move_item(VALUE self, VALUE old_uri, VALUE new_uri)
 void
 Init_glib_bookmark_file(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BOOKMARK_FILE, "BookmarkFile", mGLib);
+    VALUE RG_TARGET_NAMESPACE =
+        G_DEF_CLASS(G_TYPE_BOOKMARK_FILE, "BookmarkFile", rbg_mGLib());
 
-    G_DEF_ERROR(G_BOOKMARK_FILE_ERROR, "BookmarkFileError", mGLib, 
+    G_DEF_ERROR(G_BOOKMARK_FILE_ERROR, "BookmarkFileError", rbg_mGLib(),
                 rb_eRuntimeError, G_TYPE_BOOKMARK_FILE_ERROR);
 
     RG_DEF_METHOD(initialize, 0);

data/ext/glib2/rbglib_convert.c

@@ -23,8 +23,6 @@
 #include "rbgprivate.h"
 #include "rbglib.h"
 
-#define RG_TARGET_NAMESPACE mGLib
-
 static VALUE
 rg_s_convert(G_GNUC_UNUSED VALUE self, VALUE str, VALUE to, VALUE from)
 {
@@ -171,6 +169,8 @@ rg_s_utf8_validate(G_GNUC_UNUSED VALUE self, VALUE str)
 void
 Init_glib_convert(void)
 {
+    VALUE RG_TARGET_NAMESPACE = rbg_mGLib();
+
     VALUE cCharError = G_DEF_ERROR2(G_CONVERT_ERROR, "ConvertError", RG_TARGET_NAMESPACE, rb_eIOError);
 
     rb_define_const(cCharError, "NO_CONVERSION", INT2NUM(G_CONVERT_ERROR_NO_CONVERSION));

data/ext/glib2/rbglib_datetime.c

@@ -1,5 +1,5 @@
 /*
- *  Copyright (C) 2016-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2016-2022  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -53,7 +53,7 @@ is_timezone(VALUE rb_timezone)
 {
     VALUE rb_cTimeZone;
 
-    rb_cTimeZone = rb_const_get(mGLib, rb_intern("TimeZone"));
+    rb_cTimeZone = rb_const_get(rbg_mGLib(), rb_intern("TimeZone"));
     return RVAL2CBOOL(rb_obj_is_kind_of(rb_timezone, rb_cTimeZone));
 }
 
@@ -230,12 +230,20 @@ rg_format(VALUE self, VALUE rb_format)
     return CSTR2RVAL(g_date_time_format(_SELF(self), format));
 }
 
+#if GLIB_CHECK_VERSION(2, 62, 0)
+static VALUE
+rg_format_iso8601(VALUE self)
+{
+    return CSTR2RVAL(g_date_time_format_iso8601(_SELF(self)));
+}
+#endif
+
 void
 Init_glib_date_time(void)
 {
     VALUE RG_TARGET_NAMESPACE;
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_DATE_TIME, "DateTime", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_DATE_TIME, "DateTime", rbg_mGLib());
 
     RG_DEF_SMETHOD(now, -1);
 
@@ -247,4 +255,7 @@ Init_glib_date_time(void)
     RG_DEF_METHOD(minute, 0);
     RG_DEF_METHOD(second, 0);
     RG_DEF_METHOD(format, 1);
+#if GLIB_CHECK_VERSION(2, 62, 0)
+    RG_DEF_METHOD(format_iso8601, 0);
+#endif
 }

data/ext/glib2/rbglib_error.c

@@ -23,8 +23,13 @@
 #include <ctype.h>
 
 static ID id_code;
+static ID id_CODE;
+static const char *name_CODE = "CODE";
 static ID id_domain;
-static ID id_code_classes;
+static ID id_DOMAIN;
+static const char *name_DOMAIN = "DOMAIN";
+static ID id_CODE_CLASSES;
+static const char *name_CODE_CLASSES = "CODE_CLASSES";
 static VALUE gerror_table;
 static VALUE generic_error;
 static VALUE error_info;
@@ -44,13 +49,9 @@ rbgerr_gerror2exception(GError *error)
     exception_klass = rb_hash_aref(gerror_table, UINT2NUM(error->domain));
     if (NIL_P(exception_klass)) {
         exception_klass = generic_error;
-    } else {
-        VALUE code_class = Qnil;
-        VALUE code_classes;
-        code_classes = rb_ivar_get(exception_klass, id_code_classes);
-        if (!NIL_P(code_classes)) {
-            code_class = rb_hash_aref(code_classes, INT2NUM(error->code));
-        }
+    } else if (rb_const_defined_at(exception_klass, id_CODE_CLASSES)) {
+        VALUE code_classes = rb_const_get(exception_klass, id_CODE_CLASSES);
+        VALUE code_class = rb_hash_aref(code_classes, INT2NUM(error->code));
         if (!NIL_P(code_class)) {
             exception_klass = code_class;
         }
@@ -111,16 +112,17 @@ rbgerr_define_gerror(GQuark domain, const gchar *name, VALUE module, VALUE paren
     VALUE code_classes;
     VALUE rb_domain = rb_str_new_cstr(g_quark_to_string(domain));
     rbgutil_string_set_utf8_encoding(rb_domain);
+    rb_obj_freeze(rb_domain);
 
     error_class = rb_define_class_under(module, name, parent);
-    rb_ivar_set(error_class, id_code, Qnil);
-    rb_ivar_set(error_class, id_domain, rb_domain);
+    rb_define_const(error_class, name_CODE, Qnil);
+    rb_define_const(error_class, name_DOMAIN, rb_domain);
     rb_prepend_module(error_class, error_info);
 
     rb_hash_aset(gerror_table, UINT2NUM(domain), error_class);
 
     code_classes = rb_hash_new();
-    rb_ivar_set(error_class, id_code_classes, code_classes);
+    rb_define_const(error_class, name_CODE_CLASSES, code_classes);
 
     if (gtype != G_TYPE_INVALID) {
         GEnumClass* gclass = g_type_class_ref(gtype);
@@ -146,14 +148,16 @@ rbgerr_define_gerror(GQuark domain, const gchar *name, VALUE module, VALUE paren
                                                code_class_name,
                                                error_class);
             g_free(code_class_name);
-            rb_ivar_set(code_class, id_code, INT2NUM(entry->value));
-            rb_ivar_set(code_class, id_domain, rb_domain);
+            rb_define_const(code_class, name_CODE, INT2NUM(entry->value));
+            rb_define_const(code_class, name_DOMAIN, rb_domain);
             rb_hash_aset(code_classes, INT2NUM(entry->value), code_class);
         }
 
         g_type_class_unref(gclass);
     }
 
+    rb_obj_freeze(code_classes);
+
     return error_class;
 }
 
@@ -161,8 +165,8 @@ static VALUE
 rg_initialize(int argc, VALUE *argv, VALUE self)
 {
     VALUE klass = rb_obj_class(self);
-    rb_ivar_set(self, id_code, rb_ivar_get(klass, id_code));
-    rb_ivar_set(self, id_domain, rb_ivar_get(klass, id_domain));
+    rb_ivar_set(self, id_code, rb_const_get(klass, id_CODE));
+    rb_ivar_set(self, id_domain, rb_const_get(klass, id_DOMAIN));
     return rb_call_super(argc, argv);
 }
 
@@ -178,18 +182,22 @@ void
 Init_glib_error(void)
 {
     id_code = rb_intern("@code");
+    id_CODE = rb_intern(name_CODE);
     id_domain = rb_intern("@domain");
-    id_code_classes = rb_intern("@code_classes");
+    id_DOMAIN = rb_intern(name_DOMAIN);
+    id_CODE_CLASSES = rb_intern(name_CODE_CLASSES);
     gerror_table = rb_hash_new();
     rb_global_variable(&gerror_table);
 
 #define RG_TARGET_NAMESPACE error_info
-    error_info = rb_define_module_under(mGLib, "ErrorInfo");
+    error_info = rb_define_module_under(rbg_mGLib(), "ErrorInfo");
     rb_define_attr(error_info, "code", TRUE, FALSE);
     rb_define_attr(error_info, "domain", TRUE, FALSE);
     RG_DEF_METHOD(initialize, -1);
 
-    generic_error = rb_define_class_under(mGLib, "Error", rb_eRuntimeError);
+    generic_error = rb_define_class_under(rbg_mGLib(), "Error", rb_eRuntimeError);
+    rb_define_const(generic_error, name_CODE, Qnil);
+    rb_define_const(generic_error, name_DOMAIN, Qnil);
     rb_include_module(generic_error, error_info);
 }
 

data/ext/glib2/rbglib_fileutils.c

@@ -71,7 +71,7 @@ rbglib_m_format_size(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
 void
 Init_glib_fileutils(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_FILE_ERROR, "FileError", mGLib, rb_eIOError);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_FILE_ERROR, "FileError", rbg_mGLib(), rb_eIOError);
 
     rb_define_const(RG_TARGET_NAMESPACE, "EXIST", INT2NUM(G_FILE_ERROR_EXIST));
     rb_define_const(RG_TARGET_NAMESPACE, "ISDIR", INT2NUM(G_FILE_ERROR_ISDIR));
@@ -98,6 +98,6 @@ Init_glib_fileutils(void)
     rb_define_const(RG_TARGET_NAMESPACE, "PERM", INT2NUM(G_FILE_ERROR_PERM));
     rb_define_const(RG_TARGET_NAMESPACE, "FAILED", INT2NUM(G_FILE_ERROR_FAILED));
 
-    rbg_define_singleton_method(mGLib, "format_size",
+    rbg_define_singleton_method(rbg_mGLib(), "format_size",
                                 rbglib_m_format_size, -1);
 }

data/ext/glib2/rbglib_gettext.c

@@ -43,6 +43,6 @@ Init_glib_gettext(void)
 {
     VALUE RG_TARGET_NAMESPACE;
 
-    RG_TARGET_NAMESPACE = rb_define_module_under(mGLib, "GetText");
+    RG_TARGET_NAMESPACE = rb_define_module_under(rbg_mGLib(), "GetText");
     RG_DEF_SMETHOD(bindtextdomain, -1);
 }

data/ext/glib2/rbglib_i18n.c

@@ -24,8 +24,6 @@
 #undef _
 #include <glib/gi18n.h>
 
-#define RG_TARGET_NAMESPACE mGLib
-
 static VALUE
 rg_s_language_names(G_GNUC_UNUSED VALUE self)
 {
@@ -35,6 +33,8 @@ rg_s_language_names(G_GNUC_UNUSED VALUE self)
 void
 Init_glib_i18n(void)
 {
+    VALUE RG_TARGET_NAMESPACE = rbg_mGLib();
+
     /* glib/gi18n.h */
     RG_DEF_SMETHOD(language_names, 0);
 }

data/ext/glib2/rbglib_io_constants.c

@@ -23,7 +23,7 @@
 void
 Init_glib_io_constants(void)
 {
-    VALUE RG_TARGET_NAMESPACE = mGLib;
+    VALUE RG_TARGET_NAMESPACE = rbg_mGLib();
 
     /* GIOCondition */
     G_DEF_CLASS(G_TYPE_IO_CONDITION, "IOCondition", RG_TARGET_NAMESPACE);

data/ext/glib2/rbglib_iochannel.c

@@ -777,7 +777,7 @@ rg_print(int argc, VALUE *argv, VALUE out)
 void
 Init_glib_io_channel(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_IO_CHANNEL, "IOChannel", mGLib); 
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_IO_CHANNEL, "IOChannel", rbg_mGLib()); 
 
     rb_include_module(RG_TARGET_NAMESPACE, rb_mEnumerable);
 
@@ -851,7 +851,7 @@ Init_glib_io_channel(void)
     rb_define_const(RG_TARGET_NAMESPACE, "FLAG_GET_MASK", INT2NUM(G_IO_FLAG_GET_MASK));
     rb_define_const(RG_TARGET_NAMESPACE, "FLAG_SET_MASK", INT2NUM(G_IO_FLAG_SET_MASK));
 
-    rb_mIOChannelSource = rb_define_module_under(mGLib, "IOChannelSource");
+    rb_mIOChannelSource = rb_define_module_under(rbg_mGLib(), "IOChannelSource");
     rb_define_method(rb_mIOChannelSource,
                      "set_callback",
                      rg_io_channel_source_set_callback,

data/ext/glib2/rbglib_iochannel_win32_socket.c

@@ -47,9 +47,9 @@ Init_glib_io_channel_win32_socket(void)
     /* GIOWin32Channel */
     VALUE RG_TARGET_NAMESPACE;
     RG_TARGET_NAMESPACE =
-        rb_define_class_under(mGLib,
+        rb_define_class_under(rbg_mGLib(),
                               "IOChannelWin32Socket",
-                              rb_const_get(mGLib, rb_intern("IOChannel")));
+                              rb_const_get(rbg_mGLib(), rb_intern("IOChannel")));
     RG_DEF_METHOD(initialize, 1);
 #endif
 }

data/ext/glib2/rbglib_iochannelerror.c

@@ -32,7 +32,7 @@ rg_s_from_errno(G_GNUC_UNUSED VALUE self, VALUE errno_)
 void
 Init_glib_io_channelerror(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_IO_CHANNEL_ERROR, "IOChannelError", mGLib, rb_eIOError);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_ERROR2(G_IO_CHANNEL_ERROR, "IOChannelError", rbg_mGLib(), rb_eIOError);
 
     /* GIOChannelError */
     RG_DEF_SMETHOD(from_errno, 1);

data/ext/glib2/rbglib_keyfile.c

@@ -631,8 +631,8 @@ rg_remove_comment(VALUE self, VALUE group_name, VALUE key)
 void
 Init_glib_keyfile(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_KEY_FILE, "KeyFile", mGLib);   
-    G_DEF_ERROR(G_KEY_FILE_ERROR, "KeyFileError", mGLib, 
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_KEY_FILE, "KeyFile", rbg_mGLib());   
+    G_DEF_ERROR(G_KEY_FILE_ERROR, "KeyFileError", rbg_mGLib(), 
                 rb_eRuntimeError, G_TYPE_KEY_FILE_ERROR);
 
     RG_DEF_METHOD(initialize, 0);

data/ext/glib2/rbglib_maincontext.c

@@ -498,11 +498,11 @@ child_watch_add(VALUE self, VALUE pid)
 void
 Init_glib_main_context(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MAIN_CONTEXT, "MainContext", mGLib); 
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MAIN_CONTEXT, "MainContext", rbg_mGLib()); 
 
-    VALUE timeout = rb_define_module_under(mGLib, "Timeout");
-    VALUE idle = rb_define_module_under(mGLib, "Idle");
-    VALUE child_watch = rb_define_module_under(mGLib, "ChildWatch");
+    VALUE timeout = rb_define_module_under(rbg_mGLib(), "Timeout");
+    VALUE idle = rb_define_module_under(rbg_mGLib(), "Idle");
+    VALUE child_watch = rb_define_module_under(rbg_mGLib(), "ChildWatch");
 
     id_call = rb_intern("call");
 
@@ -510,10 +510,10 @@ Init_glib_main_context(void)
 
     main_thread = g_thread_self();
 
-    rbg_define_singleton_method(mGLib, "set_ruby_thread_priority",
+    rbg_define_singleton_method(rbg_mGLib(), "set_ruby_thread_priority",
                                ruby_source_set_priority, 1);
 
-    mGLibSource = rb_const_get(mGLib, rb_intern("Source"));
+    mGLibSource = rb_const_get(rbg_mGLib(), rb_intern("Source"));
     rbg_define_singleton_method(mGLibSource, "remove", source_remove, 1);
     rbg_define_singleton_method(mGLibSource, "current", source_current_source, 0);
 /*

data/ext/glib2/rbglib_mainloop.c

@@ -119,7 +119,7 @@ rg_context(VALUE self)
 void
 Init_glib_main_loop(void)
 {
-    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MAIN_LOOP, "MainLoop", mGLib);
+    VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MAIN_LOOP, "MainLoop", rbg_mGLib());
 
     RG_DEF_METHOD(initialize, -1);
     RG_DEF_METHOD(run, 0);

data/ext/glib2/rbglib_matchinfo.c

@@ -163,7 +163,7 @@ Init_glib_matchinfo(void)
 {
     VALUE RG_TARGET_NAMESPACE;
 
-    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MATCH_INFO, "MatchInfo", mGLib);
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_MATCH_INFO, "MatchInfo", rbg_mGLib());
     RG_DEF_METHOD(regex, 0);
     RG_DEF_METHOD(string, 0);
     RG_DEF_METHOD_P(matches, 0);