glib2 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '02369ea278700a7eb9a86d3d262c1285e20ec17e'
-  data.tar.gz: ff3fa9197fd8bdc49974be2694c7cba5a56c554d
+SHA256:
+  metadata.gz: 6fbf19f5f9864d9781239ddb41fd1fcd43c59a8680e0782f2c46c385f025c093
+  data.tar.gz: 969f873a3454bbdb99e821c32555fd6cb89bdeaace83f85163a40dbc1c364340
 SHA512:
-  metadata.gz: 3dde83bcd8b3546d1db154aa76e99d7d63b7d4c5942168b6f5de287969d85e0d425e9d3e95f663a7fca2d99024aadcc8e33f4837d34a41d93668161c1411ba46
-  data.tar.gz: 3026321f0348810656ec618752da8d0dc2821ef17feb7897bab8ae53def124b2e3bf85c1b1e9f368e5efe8d833c450e1ec18c54194c7077f42847e48d1271359
+  metadata.gz: 614bd21a3057319d9ffa518e8e861cdafa1e1cbbf849d22962b3f1f2cbce0d8140e7a0f90fa685c4513978c3b0e0e072b94cf643acf99d38b866f5d8d497add9
+  data.tar.gz: cc89b4781a3e048a5a70ff03956bbed2d71f951ed5d17d64cd851f68f7fb06f5630314103a7c9822e9dbe70183bb55957885006b775a0cfaee03310d2868adc7

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+# Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -88,12 +88,13 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.54.1",
+      :version => "2.56.0",
       :compression_method => "xz",
       :windows => {
         :need_autoreconf => true,
         :patches => [
           "glib-2.54.1-add-missing-exeext.diff",
+          "glib-2.56.0-add-missing-weekday-full-is-locale.patch",
         ],
         :built_file => "bin/libglib-2.0-0.dll",
       },
@@ -126,32 +127,33 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "libtasn1",
       :download_site => :gnu,
       :label => "Libtasn1",
-      :version => "4.12",
+      :version => "4.13",
       :windows => {
         :built_file => "bin/libtasn1-6.dll",
       },
     },
     {
-      :name => "libidn",
+      :name => "libidn2",
       :download_site => :gnu,
-      :label => "Libidn",
-      :version => "1.33",
+      :download_name => "libidn",
+      :label => "Libidn2",
+      :version => "2.0.4",
       :windows => {
-        :built_file => "bin/libidn-11.dll",
+        :built_file => "bin/libidn2-0.dll",
       },
     },
     {
-      :name => "p11-kit",
-      :download_base_url => "https://p11-glue.freedesktop.org/releases",
+      :name => "p11-glue/p11-kit",
+      :download_site => :github,
       :label => "p11-kit",
-      :version => "0.23.2",
+      :version => "0.23.3",
       :windows => {
         :built_file => "bin/libp11-kit-0.dll",
       },
     },
     {
       :name => "gnutls",
-      :download_base_url => "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.4",
+      :download_base_url => "https://www.gnupg.org/ftp/gcrypt/gnutls/v3.4",
       :label => "GnuTLS",
       :version => "3.4.10",
       :compression_method => "xz",
@@ -171,13 +173,12 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib-networking",
       :download_site => :gnome,
       :label => "glib-networking",
-      :version => "2.54.0",
+      :version => "2.56.0",
       :compression_method => "xz",
       :windows => {
-        :configure_args => [
-          "--without-libproxy",
-          "--without-gnome-proxy",
-          "--without-ca-certificates",
+        :meson_args => [
+          "-Dlibproxy_support=false",
+          "-Dgnome_proxy_support=false",
         ],
         :built_file => "lib/gio/modules/libgiognutls.dll",
       },

data/ext/glib2/glib2.def

@@ -39,6 +39,9 @@ EXPORTS
 	rbgobj_rvalue_to_gvalue
 	rbgobj_initialize_gvalue
 	rbgobj_initialize_object
+	rbgobj_class_info_lookup
+	rbgobj_class_info_lookup_by_gtype
+	rbgobj_class_info_define
 	rbgobj_lookup_class
 	rbgobj_lookup_class_by_gtype
 	rbgobj_gtype_to_ruby_class

data/ext/glib2/rbglib-bytes.c

@@ -66,6 +66,7 @@ rg_to_s(VALUE self)
 #  else
     rb_data = rb_enc_str_new(data, size, rb_ascii8bit_encoding());
 #  endif
+    rb_obj_freeze(rb_data);
     return rb_data;
 }
 

data/ext/glib2/rbglib.h

@@ -36,7 +36,7 @@ extern "C" {
 
 #define RBGLIB_MAJOR_VERSION 3
 #define RBGLIB_MINOR_VERSION 2
-#define RBGLIB_MICRO_VERSION 1
+#define RBGLIB_MICRO_VERSION 2
 
 #ifndef RB_ZALLOC
 #  ifdef ZALLOC
@@ -46,6 +46,10 @@ extern "C" {
 #  endif
 #endif
 
+#ifndef RB_ALLOC_N
+#  define RB_ALLOC_N(type, n) ALLOC_N(type, n)
+#endif
+
 /* For Ruby < 2.3 */
 #ifndef RB_OBJ_FROZEN
 #  define RB_OBJ_FROZEN(obj) OBJ_FROZEN(obj)

data/ext/glib2/rbgobj_object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2003  Masahiro Sakai
  *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
@@ -58,8 +58,9 @@ holder_mark(gobj_holder *holder)
 }
 
 static void
-holder_unref(gobj_holder *holder)
+holder_unref(void *data)
 {
+    gobj_holder *holder = data;
     if (holder->gobj) {
         if (!holder->destroyed) {
             g_object_set_qdata(holder->gobj, RUBY_GOBJECT_OBJ_KEY, NULL);
@@ -71,19 +72,37 @@ holder_unref(gobj_holder *holder)
 }
 
 static void
-holder_free(gobj_holder *holder)
+holder_free(void *data)
 {
+    gobj_holder *holder = data;
     holder_unref(holder);
     xfree(holder);
 }
 
+static const rb_data_type_t rg_glib_object_type = {
+    "GLib::Object",
+    {
+        holder_mark,
+        holder_free,
+        NULL,
+        NULL,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 rbgobj_object_alloc_func(VALUE klass)
 {
     gobj_holder* holder;
     VALUE result;
 
-    result = Data_Make_Struct(klass, gobj_holder, holder_mark, holder_free, holder);
+    result = TypedData_Make_Struct(klass,
+                                   gobj_holder,
+                                   &rg_glib_object_type,
+                                   holder);
     holder->self  = result;
     holder->gobj  = NULL;
     holder->cinfo = NULL;
@@ -105,7 +124,7 @@ rbgobj_gobject_initialize(VALUE obj, gpointer cobj)
     gobj_holder* holder = g_object_get_qdata((GObject*)cobj, RUBY_GOBJECT_OBJ_KEY);
     if (holder)
         rb_raise(rb_eRuntimeError, "ruby wrapper for this GObject* already exists.");
-    Data_Get_Struct(obj, gobj_holder, holder);
+    TypedData_Get_Struct(obj, gobj_holder, &rg_glib_object_type, holder);
     holder->cinfo = RVAL2CINFO(obj);
     holder->gobj  = (GObject*)cobj;
     holder->destroyed = FALSE;
@@ -149,10 +168,7 @@ rbgobj_get_gobject(VALUE obj)
 {
     gobj_holder* holder;
 
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, GTYPE2CLASS(G_TYPE_OBJECT))))
-        rb_raise(rb_eTypeError, "not a GLib::Object");
-
-    Data_Get_Struct(obj, gobj_holder, holder);
+    TypedData_Get_Struct(obj, gobj_holder, &rg_glib_object_type, holder);
 
     if (holder->destroyed)
         rb_raise(rb_eTypeError, "destroyed GLib::Object");
@@ -566,10 +582,7 @@ rg_destroyed_p(VALUE self)
 {
     gobj_holder* holder;
 
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(self, GTYPE2CLASS(G_TYPE_OBJECT))))
-        rb_raise(rb_eTypeError, "not a GLib::Object");
-
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     return CBOOL2RVAL(holder->destroyed);
 }
@@ -582,7 +595,7 @@ rg_inspect(VALUE self)
     char *s;
     VALUE result;
 
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     class_name = rb_class2name(CLASS_OF(self));
     if (!holder->destroyed)
@@ -602,7 +615,7 @@ rg_unref(VALUE self)
 {
     gobj_holder* holder;
 
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     if (holder->destroyed)
         rb_raise(rb_eTypeError, "destroyed GLib::Object");
@@ -780,7 +793,7 @@ static VALUE
 gobj_ref_count(VALUE self)
 {
     gobj_holder* holder;
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
     return INT2NUM(holder->gobj ? holder->gobj->ref_count : 0);
 }
 
@@ -788,7 +801,7 @@ static VALUE
 rg_floating_p(VALUE self)
 {
     gobj_holder* holder;
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
     if (holder->gobj) {
         return CBOOL2RVAL(g_object_is_floating(holder->gobj));
     } else {

data/ext/glib2/rbgobj_type.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -48,133 +48,93 @@ typedef struct {
 } RGObjClassInfoDynamic;
 
 typedef struct {
-    VALUE parent;
     GType gtype;
-    gboolean create_class;
-} RGObjClassByGtypeData;
+    const gchar *name;
+    VALUE module;
+    VALUE parent;
+} RGObjDefineClassData;
 
 static void
-cinfo_mark(RGObjClassInfo* cinfo)
+cinfo_mark(void *data)
 {
+    RGObjClassInfo *cinfo = data;
     rb_gc_mark(cinfo->klass);
 }
 
-const RGObjClassInfo *
-rbgobj_lookup_class(VALUE klass)
+static void
+cinfo_free(void *data)
 {
-    VALUE data = rb_hash_aref(klass_to_cinfo, klass);
-    if (!NIL_P(data)){
-        RGObjClassInfo* cinfo;
-        Data_Get_Struct(data, RGObjClassInfo, cinfo);
-        return cinfo;
-    }
-
-    if (TYPE(klass) == T_CLASS) {
-        VALUE super;
-        super = rb_funcall(klass, id_superclass, 0);
-        return rbgobj_lookup_class(super);
-    }
-
-    rb_raise(rb_eRuntimeError, "can't get gobject class information");
+    RGObjClassInfo *cinfo = data;
+    xfree(cinfo->name);
+    xfree(cinfo->data_type);
 }
 
-static const RGObjClassInfo *rbgobj_lookup_class_by_gtype_without_lock(GType gtype,
-                                                                       VALUE parent,
-                                                                       gboolean create_class);
+static RGObjClassInfo *
+rbgobj_class_info_define_without_lock(GType gtype,
+                                      const gchar *name,
+                                      VALUE module,
+                                      VALUE parent);
 
-static VALUE
-get_superclass(GType gtype)
+static void
+rbgobj_class_info_fill_name(RGObjClassInfo *cinfo)
 {
-    VALUE super_class;
+    VALUE rb_name;
 
-    if (rbgobj_convert_get_superclass(gtype, &super_class))
-        return super_class;
+    if (cinfo->name) {
+        return;
+    }
 
-    switch (gtype) {
-      case G_TYPE_PARAM:
-      case G_TYPE_OBJECT:
-        return cInstantiatable;
-      case G_TYPE_BOXED:
-        return rb_cObject;
-      case G_TYPE_POINTER:
-        return rb_cData;
-      case G_TYPE_ENUM:
-      case G_TYPE_FLAGS:
-        return rb_cObject;
-      default:
-      {
-          GType parent_type;
+    if (!RB_TYPE_P(cinfo->klass, RUBY_T_CLASS)) {
+        return;
+    }
 
-          parent_type = g_type_parent(gtype);
-          if (parent_type == G_TYPE_INVALID) {
-              return cInstantiatable;
-          } else {
-              const RGObjClassInfo *cinfo_super;
-              cinfo_super =
-                  rbgobj_lookup_class_by_gtype_without_lock(parent_type,
-                                                            Qnil,
-                                                            TRUE);
-              return cinfo_super->klass;
-          }
-      }
+    rb_name = rb_funcall(cinfo->klass, rb_intern("name"), 0);
+    if (NIL_P(rb_name)) {
+        return;
     }
+
+    cinfo->name = RB_ALLOC_N(char, RSTRING_LEN(rb_name) + 1);
+    memcpy(cinfo->name, RSTRING_PTR(rb_name), RSTRING_LEN(rb_name));
+    cinfo->name[RSTRING_LEN(rb_name)] = '\0';
+    cinfo->data_type->wrap_struct_name = cinfo->name;
 }
 
-static const RGObjClassInfo *
-rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
-                                          gboolean create_class)
+static RGObjClassInfo *
+rbgobj_class_info_register_without_lock(GType gtype, VALUE klass)
 {
+    rb_data_type_t *data_type;
+    RGObjClassInfo *cinfo;
     GType fundamental_type;
-    RGObjClassInfo* cinfo;
-    RGObjClassInfoDynamic* cinfod;
-    void* gclass = NULL;
+    RGObjClassInfoDynamic *cinfod;
+    void *gclass = NULL;
     VALUE c;
 
-    if (gtype == G_TYPE_INVALID)
-        return NULL;
-
-    cinfo = g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
-    if (cinfo)
-        return cinfo;
-
-    if (!create_class)
-        return NULL;
+    data_type = RB_ZALLOC(rb_data_type_t);
+    data_type->function.dmark = cinfo_mark;
+    data_type->function.dfree = cinfo_free;
+    if (RB_TYPE_P(klass, RUBY_T_CLASS)) {
+        VALUE p = RCLASS_SUPER(klass);
+        while (p != rb_cObject) {
+            if (RTYPEDDATA_P(p)) {
+                data_type->parent = RTYPEDDATA_TYPE(p);
+                break;
+            }
+            p = RCLASS_SUPER(p);
+        }
+    }
+    data_type->flags = RUBY_TYPED_FREE_IMMEDIATELY;
 
-    c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
+    c = TypedData_Make_Struct(rb_cData, RGObjClassInfo, data_type, cinfo);
+    cinfo->klass = klass;
     cinfo->gtype = gtype;
     cinfo->mark  = NULL;
     cinfo->free  = NULL;
     cinfo->flags = 0;
+    cinfo->name = NULL;
+    cinfo->data_type = data_type;
+    rbgobj_class_info_fill_name(cinfo);
 
     fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
-    switch (fundamental_type){
-    case G_TYPE_POINTER:
-    case G_TYPE_BOXED:
-    case G_TYPE_PARAM:
-    case G_TYPE_OBJECT:
-    case G_TYPE_ENUM:
-    case G_TYPE_FLAGS:
-        if (NIL_P(parent)) parent = get_superclass(gtype);
-        cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
-        break;
-
-    case G_TYPE_INTERFACE:
-        cinfo->klass = rb_module_new();
-        break;
-
-    default:
-      if (NIL_P(parent)) parent = get_superclass(gtype);
-      if (NIL_P(parent)) {
-          fprintf(stderr,
-                  "%s: %s's fundamental type %s isn't supported\n",
-                  "rbgobj_lookup_class_by_gtype",
-                  g_type_name(gtype),
-                  g_type_name(fundamental_type));
-          return NULL;
-      }
-      cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
-    }
-
     switch (fundamental_type){
       case G_TYPE_BOXED:
         rb_define_alloc_func(cinfo->klass, rbgobj_boxed_alloc_func);
@@ -217,10 +177,14 @@ rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
         interfaces = g_type_interfaces(gtype, &n_interfaces);
         for (i = 0; i < n_interfaces; i++){
             const RGObjClassInfo *iface_cinfo;
-            iface_cinfo =
-            rbgobj_lookup_class_by_gtype_without_lock(interfaces[i],
-                                                      Qnil,
-                                                      TRUE);
+            iface_cinfo = rbgobj_class_info_lookup_by_gtype(interfaces[i]);
+            if (!iface_cinfo) {
+                iface_cinfo =
+                    rbgobj_class_info_define_without_lock(interfaces[i],
+                                                          NULL,
+                                                          rb_cObject,
+                                                          Qnil);
+            }
             rb_include_module(cinfo->klass, iface_cinfo->klass);
         }
         g_free(interfaces);
@@ -253,55 +217,198 @@ rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
 }
 
 static VALUE
-rbgobj_lookup_class_by_gtype_body(VALUE data)
+get_superclass(GType gtype, VALUE module)
+{
+    VALUE super_class;
+
+    if (rbgobj_convert_get_superclass(gtype, &super_class))
+        return super_class;
+
+    switch (gtype) {
+      case G_TYPE_PARAM:
+      case G_TYPE_OBJECT:
+        return cInstantiatable;
+      case G_TYPE_BOXED:
+        return rb_cObject;
+      case G_TYPE_POINTER:
+        return rb_cData;
+      case G_TYPE_ENUM:
+      case G_TYPE_FLAGS:
+        return rb_cObject;
+      default:
+      {
+          GType parent_type;
+
+          parent_type = g_type_parent(gtype);
+          if (parent_type == G_TYPE_INVALID) {
+              return cInstantiatable;
+          } else {
+              const RGObjClassInfo *cinfo_super;
+              cinfo_super = rbgobj_class_info_lookup_by_gtype(parent_type);
+              if (!cinfo_super) {
+                  cinfo_super = rbgobj_class_info_define_without_lock(parent_type,
+                                                                      NULL,
+                                                                      module,
+                                                                      Qnil);
+              }
+              return cinfo_super->klass;
+          }
+      }
+    }
+}
+
+static RGObjClassInfo *
+rbgobj_class_info_define_without_lock(GType gtype,
+                                      const gchar *name,
+                                      VALUE module,
+                                      VALUE parent)
+{
+    GType fundamental_type;
+    VALUE klass;
+
+    fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
+    switch (fundamental_type){
+    case G_TYPE_POINTER:
+    case G_TYPE_BOXED:
+    case G_TYPE_PARAM:
+    case G_TYPE_OBJECT:
+    case G_TYPE_ENUM:
+    case G_TYPE_FLAGS:
+        if (NIL_P(parent)) parent = get_superclass(gtype, module);
+        klass = rb_funcall(rb_cClass, id_new, 1, parent);
+        break;
+
+    case G_TYPE_INTERFACE:
+        klass = rb_module_new();
+        break;
+
+    default:
+      if (NIL_P(parent)) parent = get_superclass(gtype, module);
+      if (NIL_P(parent)) {
+          fprintf(stderr,
+                  "rbgobj_class_info_define: "
+                  "Unsupported fundamental type: <%s>(%s)\n",
+                  g_type_name(fundamental_type),
+                  g_type_name(gtype));
+          return NULL;
+      }
+      klass = rb_funcall(rb_cClass, id_new, 1, parent);
+    }
+
+    if (name) {
+        rb_define_const(module, name, klass);
+    }
+    return rbgobj_class_info_register_without_lock(gtype, klass);
+}
+
+static VALUE
+rbgobj_class_info_define_body(VALUE data)
 {
-    RGObjClassByGtypeData *cdata = (RGObjClassByGtypeData *)data;
+    RGObjDefineClassData *cdata = (RGObjDefineClassData *)data;
     const RGObjClassInfo *cinfo;
 
-    cinfo = rbgobj_lookup_class_by_gtype_without_lock(cdata->gtype,
-                                                      cdata->parent,
-                                                      cdata->create_class);
+    cinfo = rbgobj_class_info_define_without_lock(cdata->gtype,
+                                                  cdata->name,
+                                                  cdata->module,
+                                                  cdata->parent);
     return (VALUE)cinfo;
 }
 
 static VALUE
-rbgobj_lookup_class_by_gtype_ensure(G_GNUC_UNUSED VALUE data)
+rbgobj_class_info_define_ensure(G_GNUC_UNUSED VALUE data)
 {
     rb_funcall(lookup_class_mutex, id_unlock, 0);
     return Qundef;
 }
 
+RGObjClassInfo *
+rbgobj_class_info_define(GType gtype,
+                         const gchar *name,
+                         VALUE module,
+                         VALUE parent)
+{
+    RGObjDefineClassData data;
+
+    data.gtype = gtype;
+    data.name = name;
+    data.module = module;
+    data.parent = parent;
+
+    rb_funcall(lookup_class_mutex, id_lock, 0);
+    return (RGObjClassInfo *)rb_ensure(rbgobj_class_info_define_body,
+                                       (VALUE)&data,
+                                       rbgobj_class_info_define_ensure,
+                                       (VALUE)&data);
+}
+
+/* deprecated */
+const RGObjClassInfo *
+rbgobj_lookup_class(VALUE klass)
+{
+    return rbgobj_class_info_lookup(klass);
+}
+
+const RGObjClassInfo *
+rbgobj_class_info_lookup(VALUE klass)
+{
+    VALUE data = rb_hash_aref(klass_to_cinfo, klass);
+    if (!NIL_P(data)) {
+        RGObjClassInfo *cinfo;
+        if (RTYPEDDATA_P(data)) {
+            TypedData_Get_Struct(data,
+                                 RGObjClassInfo,
+                                 RTYPEDDATA_TYPE(data),
+                                 cinfo);
+        } else {
+            Data_Get_Struct(data, RGObjClassInfo, cinfo);
+        }
+        return cinfo;
+    }
+
+    if (TYPE(klass) == T_CLASS) {
+        VALUE super;
+        super = rb_funcall(klass, id_superclass, 0);
+        return rbgobj_lookup_class(super);
+    }
+
+    rb_raise(rb_eRuntimeError, "can't get gobject class information");
+    return NULL;
+}
+
+const RGObjClassInfo *
+rbgobj_class_info_lookup_by_gtype(GType gtype)
+{
+    if (gtype == G_TYPE_INVALID)
+        return NULL;
+
+    return g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
+}
+
+/* deprecated */
 const RGObjClassInfo *
 rbgobj_lookup_class_by_gtype(GType gtype, VALUE parent)
 {
     return rbgobj_lookup_class_by_gtype_full(gtype, parent, TRUE);
 }
 
+/* deprecated */
 const RGObjClassInfo *
 rbgobj_lookup_class_by_gtype_full(GType gtype, VALUE parent,
                                   gboolean create_class)
 {
     const RGObjClassInfo *info;
-    RGObjClassByGtypeData data;
 
-    info = rbgobj_lookup_class_by_gtype_without_lock(gtype, parent, FALSE);
-    if (info) {
+    if (gtype == G_TYPE_INVALID)
+        return NULL;
+
+    info = rbgobj_class_info_lookup_by_gtype(gtype);
+    if (info)
         return info;
-    }
 
-    if (!create_class) {
+    if (!create_class)
         return NULL;
-    }
-
-    data.gtype = gtype;
-    data.parent = parent;
-    data.create_class = create_class;
 
-    rb_funcall(lookup_class_mutex, id_lock, 0);
-    return (RGObjClassInfo *)rb_ensure(rbgobj_lookup_class_by_gtype_body,
-                                       (VALUE)&data,
-                                       rbgobj_lookup_class_by_gtype_ensure,
-                                       (VALUE)&data);
+    return rbgobj_class_info_define(gtype, NULL, rb_cObject, parent);
 }
 
 VALUE
@@ -317,14 +424,22 @@ VALUE
 rbgobj_define_class(GType gtype, const gchar *name, VALUE module,
                     RGMarkFunc mark, RGFreeFunc free, VALUE parent)
 {
-    RGObjClassInfo* cinfo;
-    if (gtype == 0)
-        rb_bug("rbgobj_define_class: Invalid gtype [%s]\n", name);
+    RGObjClassInfo *cinfo;
+
+    if (gtype == G_TYPE_INVALID)
+        rb_bug("rbgobj_define_class: Invalid GType: <%s>\n", name);
 
-    cinfo = (RGObjClassInfo*)rbgobj_lookup_class_by_gtype(gtype, parent);
+    cinfo = (RGObjClassInfo *)rbgobj_class_info_lookup_by_gtype(gtype);
+    if (cinfo) {
+        if (!rb_const_defined(module, rb_intern(name))) {
+            rb_define_const(module, name, cinfo->klass);
+            rbgobj_class_info_fill_name(cinfo);
+        }
+    } else {
+        cinfo = rbgobj_class_info_define(gtype, name, module, parent);
+    }
     cinfo->mark = mark;
     cinfo->free = free;
-    rb_define_const(module, name, cinfo->klass);
     return cinfo->klass;
 }
 
@@ -381,8 +496,9 @@ rbgobj_register_class(VALUE klass,
     RGObjClassInfo* cinfo = NULL;
     VALUE c = Qnil;
 
-    if (klass2gtype)
+    if (klass2gtype) {
         c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
+    }
     if (gtype2klass && !cinfo)
         cinfo = g_new(RGObjClassInfo, 1);
 

data/ext/glib2/rbgobject.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2003,2006  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
@@ -134,6 +134,8 @@ typedef struct {
     RGMarkFunc mark;
     RGFreeFunc free;
     int flags; /* RGObjClassFlag */
+    gchar *name;
+    rb_data_type_t *data_type;
 } RGObjClassInfo;
 
 /* rbgobject.c */
@@ -170,8 +172,17 @@ extern gboolean rbgobj_gc_mark_instance(gpointer instance);
 
 
 /* rbgobj_type.c */
+extern const RGObjClassInfo *rbgobj_class_info_lookup(VALUE klass);
+extern const RGObjClassInfo *rbgobj_class_info_lookup_by_gtype(GType gtype);
+extern RGObjClassInfo *rbgobj_class_info_define(GType gtype,
+                                                const gchar *name,
+                                                VALUE module,
+                                                VALUE parent);
+/* deprecated */
 extern const RGObjClassInfo *rbgobj_lookup_class(VALUE klass);
+/* deprecated */
 extern const RGObjClassInfo *rbgobj_lookup_class_by_gtype(GType gtype, VALUE parent);
+/* deprecated */
 extern const RGObjClassInfo *rbgobj_lookup_class_by_gtype_full(GType gtype,
 							       VALUE parent,
 							       gboolean create_object);

data/lib/gnome2/rake/external-package.rb

@@ -1,6 +1,4 @@
-# -*- ruby -*-
-#
-# Copyright (C) 2013-2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2013-2018  Ruby-GNOME2 Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -21,6 +19,7 @@ require "open-uri"
 module GNOME2
   module Rake
     class ExternalPackage < Struct.new(:name,
+                                       :download_name,
                                        :base_name,
                                        :archive_base_name,
                                        :label,
@@ -47,8 +46,13 @@ module GNOME2
         resolve_value(super) || "gz"
       end
 
+      def download_name
+        resolve_value(super) || name
+      end
+
       def base_name
-        resolve_value(super) || "#{name}-#{version}"
+        resolve_value(super) ||
+          "#{name.split('/').last}-#{version.gsub(/\Av/, '')}"
       end
 
       def archive_base_name
@@ -113,6 +117,8 @@ module GNOME2
           latest_version_webkitgtk
         when :icu
           latest_version_icu
+        when :github
+          latest_version_github
         else
           nil
         end
@@ -132,20 +138,23 @@ module GNOME2
         when :gnome
           base_url = gnome_base_url
           release_series = version.gsub(/\A(\d+\.\d+)(?:[^\d].*)?\z/, '\1')
-          base_url << "/#{name}/#{release_series}"
+          base_url << "/#{download_name}/#{release_series}"
         when :freedesktop
           base_url = freedesktop_base_url
-          base_url << "/#{name}/release"
+          base_url << "/#{download_name}/release"
         when :freedesktop_gstreamer
           base_url = freedesktop_gstreamer_base_url
-          base_url << "/#{name}"
+          base_url << "/#{download_name}"
         when :gnu
           base_url = gnu_base_url
-          base_url << "/#{name}"
+          base_url << "/#{download_name}"
         when :webkitgtk
           base_url = webkitgtk_base_url
         when :icu
           base_url = "#{icu_base_url}/#{version}"
+        when :github
+          base_url = github_base_url
+          base_url << "/#{download_name}/releases/download/#{version}"
         else
           base_url = nil
         end
@@ -176,6 +185,10 @@ module GNOME2
         "http://download.icu-project.org/files/icu4c"
       end
 
+      def github_base_url
+        "https://github.com"
+      end
+
       def sort_versions(versions)
         versions.sort_by do |version|
           version.split(".").collect(&:to_i)
@@ -183,7 +196,7 @@ module GNOME2
       end
 
       def latest_version_gnome
-        base_url = "#{gnome_base_url}/#{name}"
+        base_url = "#{gnome_base_url}/#{download_name}"
         minor_versions = []
         open(base_url) do |index|
           index.read.scan(/<a (.+?)>/) do |content,|
@@ -217,7 +230,7 @@ module GNOME2
       end
 
       def latest_version_freedesktop
-        base_url = "#{freedesktop_base_url}/#{name}/release"
+        base_url = "#{freedesktop_base_url}/#{download_name}/release"
         versions = []
         open(base_url) do |index|
           index.read.scan(/<a (.+?)>/) do |content,|
@@ -233,7 +246,7 @@ module GNOME2
       end
 
       def latest_version_freedesktop_gstreamer
-        base_url = "#{freedesktop_gstreamer_base_url}/#{name}"
+        base_url = "#{freedesktop_gstreamer_base_url}/#{download_name}"
         versions = []
         open(base_url) do |index|
           index.read.scan(/<a (.+?)>/) do |content,|
@@ -255,7 +268,7 @@ module GNOME2
       end
 
       def latest_version_gnu
-        base_url = "#{gnu_base_url}/#{name}"
+        base_url = "#{gnu_base_url}/#{download_name}"
         versions = []
         open(base_url) do |index|
           index.read.scan(/<a (.+?)>/) do |content,|
@@ -301,6 +314,13 @@ module GNOME2
         sort_versions(versions).last
       end
 
+      def latest_version_github
+        latest_url = "#{github_base_url}/#{download_name}/releases/latest"
+        open(latest_url) do |latest_page|
+          return latest_page.base_uri.path.split("/").last
+        end
+      end
+
       class WindowsConfiguration < Struct.new(:build,
                                               :include_paths,
                                               :library_paths,

data/lib/gnome2/rake/windows-binary-build-task.rb

@@ -49,32 +49,7 @@ module GNOME2
       private
       def define_build_tasks
         namespace :build do
-          prepare_task_names = []
-          namespace :prepare do
-            prepare_task_names << "pkg_config"
-            task :pkg_config do
-              depended_packages = @package.windows.build_dependencies
-              use_packages = [@package.name] + depended_packages
-              pkg_config_path = use_packages.collect do |package|
-                "../#{package}/#{@package.windows.relative_binary_dir}/lib/pkgconfig"
-              end
-              ENV["PKG_CONFIG_PATH"] = pkg_config_path.collect do |path|
-                File.expand_path(path)
-              end.join(":")
-              ENV["PKG_CONFIG_LIBDIR"] = rcairo_pkgconfig_path
-            end
-
-            prepare_task_names << "pkg_config_for_build"
-            task :pkg_config_for_build do
-              # XXX: Is it needless?
-              # ENV["PKG_CONFIG_FOR_BUILD"] = "env - pkg-config"
-            end
-          end
-
-          full_prepare_task_names = prepare_task_names.collect do |name|
-            "windows:builder:build:prepare:#{name}"
-          end
-          task :prepare => full_prepare_task_names
+          task :prepare
 
           build_packages.each do |package|
             namespace package.name do
@@ -118,6 +93,7 @@ module GNOME2
           sh("tar", "xf", tar_full_path.to_s)
         end
 
+        env = build_env
         package_dir_path =
           package_tmp_dir + package.base_name + package.base_dir_in_package
         Dir.chdir(package_dir_path.to_s) do
@@ -137,30 +113,29 @@ module GNOME2
             make_n_jobs = ENV["MAKE_N_JOBS"]
             build_make_args << "-j#{make_n_jobs}" if make_n_jobs
           end
-          ENV["GREP_OPTIONS"] = "--text"
-          # ENV["GI_SCANNER_DEBUG"] = "save-temps"
+          # build_make_args << "--debug"
+          # build_make_args << "V=1"
+          # build_make_args << "VERBOSE=1"
+          # env["GI_SCANNER_DEBUG"] = "save-temps"
           if File.exist?("meson.build") and not File.exist?("Makefile.am")
             source_dir = Dir.pwd
             build_dir = "build"
             mkdir_p(build_dir)
             Dir.chdir(build_dir) do
-              meson(package, source_dir)
-              sh(make_args_to_env(build_make_args),
+              meson(env, package, source_dir)
+              sh(env.merge(make_args_to_env(build_make_args)),
                  "nice", "ninja") or exit(false)
-              sh(make_args_to_env(install_make_args),
+              sh(env.merge(make_args_to_env(install_make_args)),
                  "ninja", "install") or exit(false)
             end
           else
             if File.exist?("Makefile.in")
-              configure(package)
+              configure(env, package)
             else
-              cmake(package)
+              cmake(env, package)
             end
-            # build_make_args << "--debug"
-            # build_make_args << "V=1"
-            # build_make_args << "VERBOSE=1"
-            sh("nice", "make", *build_make_args) or exit(false)
-            sh("make", "install", *install_make_args) or exit(false)
+            sh(env, "nice", "make", *build_make_args) or exit(false)
+            sh(env, "make", "install", *install_make_args) or exit(false)
           end
 
           package_license_dir = license_dir + package.name
@@ -182,20 +157,46 @@ module GNOME2
         end
       end
 
-      def configure(package)
-        sh("./autogen.sh") if package.windows.need_autogen?
-        sh("autoreconf", "--install", "--force") if package.windows.need_autoreconf?
-        sh("./configure",
+      def build_env
+        path = "#{g_ir_scanner_bin_dir}:#{ENV["PATH"]}"
+        env = {
+          "GI_HOST_OS" => "nt",
+          "MSYSTEM" => "MINGW64",
+          "GREP_OPTIONS" => "--text",
+          "PATH" => path,
+        }
+        depended_packages = @package.windows.build_dependencies
+        use_packages = [@package.name] + depended_packages
+        pkg_config_path = use_packages.collect do |package|
+          "../#{package}/#{@package.windows.relative_binary_dir}/lib/pkgconfig"
+        end
+        env["PKG_CONFIG_PATH"] = pkg_config_path.collect do |path|
+          File.expand_path(path)
+        end.join(":")
+        env["PKG_CONFIG_LIBDIR"] = rcairo_pkgconfig_path
+        env
+      end
+
+      def configure(env, package)
+        sh(env, "./autogen.sh") if package.windows.need_autogen?
+        if package.windows.need_autoreconf?
+          sh(env, "autoreconf", "--install", "--force")
+        end
+        sh(env, "env")
+        sh(env,
+           "./configure",
            cc_env(package),
            dlltool_env,
            "CPPFLAGS=#{cppflags(package)}",
            "LDFLAGS=#{ldflags(package)}",
            "--prefix=#{dist_dir}",
            "--host=#{@package.windows.build_host}",
+           # "--target=#{@package.windows.build_host}",
+           # "--build=x86_64-pc-linux-gnu",
            *package.windows.configure_args) or exit(false)
       end
 
-      def meson(package, source_dir)
+      def meson(env, package, source_dir)
         cross_file = Tempfile.new("meson-cross-file")
         cross_file.puts(<<-CROSS_FILE)
 [host_machine]
@@ -213,21 +214,22 @@ dlltool = '/usr/bin/#{dlltool}'
 pkgconfig = '/usr/bin/pkg-config'
         CROSS_FILE
         cross_file.close
-        sh({
-             "PATH" => "#{g_ir_scanner_bin_dir}:#{ENV["PATH"]}",
-             "CPPFLAGS" => cppflags(package),
-             "LDFLAGS" => ldflags(package),
-           },
+        sh(env.merge({
+                       "CPPFLAGS" => cppflags(package),
+                       "LDFLAGS" => ldflags(package),
+                     }),
            "meson",
            source_dir,
            ".",
            "--prefix=#{dist_dir}",
+           "--libdir=lib",
            "--cross-file=#{cross_file.path}",
            *package.windows.meson_args) or exit(false)
       end
 
-      def cmake(package)
-        sh("cmake",
+      def cmake(env, package)
+        sh(env,
+           "cmake",
            ".",
            "-DCMAKE_INSTALL_PREFIX=#{dist_dir}",
            "-DCMAKE_SYSTEM_NAME=Windows",
@@ -270,8 +272,7 @@ pkgconfig = '/usr/bin/pkg-config'
       end
 
       def rcairo_dir
-        suffix = @package.windows.build_architecture_suffix
-        @package.project_root_dir.parent + "rcairo.#{suffix}"
+        @package.project_root_dir.parent + "rcairo"
       end
 
       def rcairo_pkgconfig_path

data/lib/mkmf-gnome2.rb

@@ -431,17 +431,7 @@ end
 def check_cairo(options={})
   rcairo_source_dir = options[:rcairo_source_dir]
   if rcairo_source_dir.nil?
-    suffix = nil
-    if windows_platform?
-      case RUBY_PLATFORM
-      when /\Ax86-mingw/
-        suffix = "win32"
-      when /\Ax64-mingw/
-        suffix = "win64"
-      end
-    end
     rcairo_source_base_dir = "rcairo"
-    rcairo_source_base_dir << ".#{suffix}" if suffix
     top_dir = options[:top_dir]
     if top_dir
       rcairo_source_dir = File.join(top_dir, "..", rcairo_source_base_dir)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glib2
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
 platform: ruby
 authors:
 - The Ruby-GNOME2 Project Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-19 00:00:00.000000000 Z
+date: 2018-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config
@@ -213,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Ruby/GLib2 is a Ruby binding of GLib-2.x.