glib2 3.3.7 → 3.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b942598f5c00a7a244ac39b488f99db909b1366e32ec4aac9a9ceab228eedb39
-  data.tar.gz: 2492a173ad5a94b094973ea8fa84fc134d5ed18a443fa3f044871f01ef91a975
+  metadata.gz: 2bd17bde266ff29b1445dd41b0a33549472b10082d3a33dd566e90200ee16ca1
+  data.tar.gz: f8ff9860d9fbe9a600546aaf66332022537f8ad5376712a6bdabc46b92903984
 SHA512:
-  metadata.gz: 73912d2b11e3e4d11c1cbbe11c7efdcc34edb6e075e4710e7c738ab10d88d4d29e096d07afa4bd5d768296bc0def3a34a93ebe7cef5c95a49543ab2db1fd83d5
-  data.tar.gz: 4455e42d37a1cf8112dd9b0ac11e1e4ff5af9a924a4aa1ee19a549646a30a34d328c96b904bcf3d45f5f420879490cad10b69ddf38c58b87efa57905be7a31df
+  metadata.gz: b47ecb4c251f0d6d573a25177c313c221563961ef55d89130a67ed1aabad171ec90147434c1c7aee708a448c2df43fd7704af2e95d6d82a48ad7f6b11e1163ed
+  data.tar.gz: 83491d543291507cfe2bb44a41689866dc1ae35d987f3fd3b4a8d02f3be33b81e8f2ccfd51a28d124c23dc7c7667848ec1bf5dc2374022ede9eec91256acbca5

data/README.md

@@ -4,39 +4,24 @@ Ruby/GLib2 is a Ruby binding of GLib-2.12.x.
 
 ## Requirements
 
-  Ruby >= 1.9.x: http://www.ruby-lang.org/
-  pkg-config.rb: http://github.com/rcairo/pkg-config
-  GLib >= 2.12.x: http://www.gtk.org/
+  * Ruby >= 1.9.x: https://www.ruby-lang.org/
+  * pkg-config.rb: https://github.com/rcairo/pkg-config
+  * GLib >= 2.12.x: https://www.gtk.org/
 
-## Install (RubyGems)
+## Install
 
-```
-  % sudo gem install glib2
-```
-Windows:
-
-```
-  > gem install glib2 --platform x86-mingw32
-```
-
-## Install (traditional)
-
-Install ruby-1.9.x or later, pkg-config.rb and GLib-2.12.x.
-
-```
-  % ruby extconf.rb
-  % make
-  % sudo make install
+```bash
+gem install glib2
 ```
 
 ## Copying
 
-   Copyright (c) 2002-2010 Ruby-GNOME2 Project Team
+Copyright (c) 2002-2019 Ruby-GNOME Project Team
 
-   This program is free software.
-   You can distribute/modify this program under the terms of
-   the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
+This program is free software.
+You can distribute/modify this program under the terms of
+the GNU LESSER GENERAL PUBLIC LICENSE Version 2.1.
 
 ## Project Website
 
-   https://ruby-gnome2.osdn.jp/
+https://ruby-gnome2.osdn.jp/

data/ext/glib2/rbglib-bytes.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2017-2019  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
@@ -27,6 +27,26 @@
 #if GLIB_CHECK_VERSION(2, 32, 0)
 static VALUE RG_TARGET_NAMESPACE;
 
+static VALUE
+rg_s_try_convert(VALUE self, VALUE value)
+{
+    if (NIL_P(value)) {
+        return value;
+    }
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(value, self))) {
+        return value;
+    }
+
+    if (RB_TYPE_P(value, RUBY_T_STRING)) {
+        ID id_new;
+        CONST_ID(id_new, "new");
+        return rb_funcall(self, id_new, 1, value);
+    }
+
+    return Qnil;
+}
+
 static VALUE
 rg_initialize(int argc, VALUE *argv, VALUE self)
 {
@@ -37,13 +57,14 @@ rg_initialize(int argc, VALUE *argv, VALUE self)
     if (NIL_P(rb_data)) {
         bytes = g_bytes_new(NULL, 0);
     } else {
-        const gchar *data = RVAL2CSTR_PTR(rb_data);
-        if (RB_OBJ_FROZEN(rb_data)) {
-            bytes = g_bytes_new_static(data, RSTRING_LEN(rb_data));
-            rb_iv_set(self, "source", rb_data);
-        } else {
-            bytes = g_bytes_new(data, RSTRING_LEN(rb_data));
+        const gchar *data;
+        if (!RB_OBJ_FROZEN(rb_data)) {
+            rb_data = rb_str_dup(rb_data);
+            rb_str_freeze(rb_data);
         }
+        data = RVAL2CSTR_PTR(rb_data);
+        bytes = g_bytes_new_static(data, RSTRING_LEN(rb_data));
+        rb_iv_set(self, "source", rb_data);
     }
     G_INITIALIZE(self, bytes);
 
@@ -98,6 +119,8 @@ Init_glib_bytes(void)
 #if GLIB_CHECK_VERSION(2, 32, 0)
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_BYTES, "Bytes", mGLib);
 
+    RG_DEF_SMETHOD(try_convert, 1);
+
     RG_DEF_METHOD(initialize, -1);
     RG_DEF_METHOD(to_s, 0);
     RG_DEF_ALIAS("to_str", "to_s");

data/ext/glib2/rbglib.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2015  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2019  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -220,7 +220,7 @@ rbg_cstr2rval_with_free(gchar *str)
     return rbg_cstr2rval_free(str);
 }
 
-static rb_encoding *filename_encoding_if_not_utf8;
+rb_encoding *rbg_filename_encoding;
 
 static VALUE
 rbg_filename_to_ruby_body(VALUE filename)
@@ -234,9 +234,9 @@ rbg_filename_to_ruby_body(VALUE filename)
 
     /* if needed, change encoding of Ruby String to filename encoding, so that
        upcoming File operations will work properly */
-    return filename_encoding_if_not_utf8 != NULL ?
-        rb_str_export_to_enc(rb_filename, filename_encoding_if_not_utf8) :
-        rb_filename;
+    return rbg_filename_encoding == rb_utf8_encoding() ?
+        rb_filename :
+        rb_str_export_to_enc(rb_filename, rbg_filename_encoding);
 }
 
 static VALUE
@@ -257,7 +257,7 @@ rbg_filename_to_ruby(const gchar *filename)
     if (filename == NULL)
         return Qnil;
 
-    if (filename_encoding_if_not_utf8 == NULL)
+    if (rbg_filename_encoding == rb_utf8_encoding())
         return CSTR2RVAL(filename);
 
     filename_utf8 = g_filename_to_utf8(filename, -1, NULL, &written, &error);
@@ -278,15 +278,15 @@ rbg_filename_to_ruby_free(gchar *filename)
         return Qnil;
 
     /* convert filename to UTF-8 if needed */
-    if (filename_encoding_if_not_utf8 != NULL) {
+    if (rbg_filename_encoding == rb_utf8_encoding()) {
+        filename_utf8 = filename;
+    } else {
         GError *error = NULL;
 
         filename_utf8 = g_filename_to_utf8(filename, -1, NULL, &written, &error);
         g_free(filename);
         if (error != NULL)
             RAISE_GERROR(error);
-    } else {
-        filename_utf8 = filename;
     }
 
     return rb_ensure(rbg_filename_to_ruby_body, (VALUE)filename_utf8,
@@ -306,10 +306,14 @@ rbg_filename_from_ruby(VALUE filename)
         filename = rb_str_export_to_enc(filename, rb_utf8_encoding());
 
     /* convert it to filename encoding if needed */
-    if (filename_encoding_if_not_utf8 == NULL)
-        return g_strdup(RSTRING_PTR(filename));
-
-    retval = g_filename_from_utf8(RSTRING_PTR(filename), -1, NULL, &written, &error);
+    if (rbg_filename_encoding == rb_utf8_encoding())
+        return g_strndup(RSTRING_PTR(filename), RSTRING_LEN(filename));
+
+    retval = g_filename_from_utf8(RSTRING_PTR(filename),
+                                  RSTRING_LEN(filename),
+                                  NULL,
+                                  &written,
+                                  &error);
     if (error != NULL)
         RAISE_GERROR(error);
 
@@ -1097,12 +1101,13 @@ Init_glib2(void)
         || filename_charsets[0] == NULL
         || !strcmp(filename_charsets[0], "UTF-8")
         || rb_enc_find(filename_charsets[0]) == rb_enc_find("ASCII-8BIT")) {
-        /* set to NULL, mean do not perform transcoding, either filename
-           encoding is unknown, UTF-8, or unsupported */
-        filename_encoding_if_not_utf8 = NULL;
+        rbg_filename_encoding = rb_utf8_encoding();
     } else {
-        filename_encoding_if_not_utf8 = rb_enc_find(filename_charsets[0]);
+        rbg_filename_encoding = rb_enc_find(filename_charsets[0]);
     }
+    rb_define_const(RG_TARGET_NAMESPACE,
+                    "FILENAME_ENCODING",
+                    rb_enc_from_encoding(rbg_filename_encoding));
 
 /* Don't implement them.
 #define     G_DIR_SEPARATOR_S

data/ext/glib2/rbglib.h

@@ -36,7 +36,7 @@ extern "C" {
 
 #define RBGLIB_MAJOR_VERSION 3
 #define RBGLIB_MINOR_VERSION 3
-#define RBGLIB_MICRO_VERSION 7
+#define RBGLIB_MICRO_VERSION 8
 
 #ifndef RB_ZALLOC
 #  ifdef ZALLOC

data/ext/glib2/rbglib_convert.c

@@ -35,12 +35,18 @@ rg_s_convert(G_GNUC_UNUSED VALUE self, VALUE str, VALUE to, VALUE from)
 
     StringValue(str);
     ret = g_convert(RSTRING_PTR(str), RSTRING_LEN(str),
-                    StringValuePtr(to), StringValuePtr(from),
+                    StringValueCStr(to), StringValueCStr(from),
                     NULL, &written, &err);
 
     if (err != NULL)
         RAISE_GERROR(err);
-    s = rb_str_new(ret, written);
+    {
+        rb_encoding *encoding = rb_enc_find(StringValueCStr(to));
+        if (!encoding) {
+            encoding = rb_ascii8bit_encoding();
+        }
+        s = rb_enc_str_new(ret, written, encoding);
+    }
     g_free(ret);
     return s;
 }
@@ -110,7 +116,7 @@ rg_s_filename_from_utf8(G_GNUC_UNUSED VALUE self, VALUE str)
 
     if (err != NULL)
         RAISE_GERROR(err);
-    s = rb_str_new(ret, written);
+    s = rb_enc_str_new(ret, written, rbg_filename_encoding);
     g_free(ret);
     return s;
 }

data/ext/glib2/rbgobj_enums.c

@@ -1,7 +1,7 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2019  Ruby-GNOME2 Project Team
- *  Copyright (C) 2004-2006  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2004-2006  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -27,9 +27,11 @@
 
 VALUE RG_TARGET_NAMESPACE;
 
+static ID id_find;
 static ID id_new;
-static ID id_to_s;
 static ID id_to_i;
+static ID id_to_s;
+static ID id_values;
 
 /**********************************************************************/
 
@@ -55,31 +57,20 @@ nick_to_const_name(const gchar *nick)
 VALUE
 rg_enum_resolve_value(VALUE klass, VALUE nick)
 {
-    VALUE value = Qnil;
-    gchar *const_nick;
-    ID const_nick_id;
-
     if (RVAL2CBOOL(rb_obj_is_kind_of(nick, klass)))
         return nick;
-
-    nick = rb_funcall(nick, id_to_s, 0);
-    const_nick = nick_to_const_name(RVAL2CSTR(nick));
-    const_nick_id = rb_intern(const_nick);
-    if (rb_const_defined(klass, const_nick_id)) {
-        value = rb_const_get(klass, const_nick_id);
-    }
-    g_free(const_nick);
-
-    return value;
+    return rb_funcall(klass, id_find, 1, nick);
 }
 
 void
 rg_enum_add_constants(VALUE mod, GType enum_type, const gchar *strip_prefix)
 {
+    VALUE klass;
     GEnumClass *gclass;
     guint i;
     size_t prefix_len = strlen(strip_prefix);
 
+    klass = GTYPE2CLASS(enum_type);
     gclass = G_ENUM_CLASS(g_type_class_ref(enum_type));
 
     for (i = 0; i < gclass->n_values; i++) {
@@ -90,8 +81,9 @@ rg_enum_add_constants(VALUE mod, GType enum_type, const gchar *strip_prefix)
                       value->value_name, strip_prefix);
         } else {
             const char* name = value->value_name + prefix_len;
-            rbgobj_define_const(mod, name,
-                                rbgobj_make_enum(value->value, enum_type));
+            rbgobj_define_const(mod,
+                                name,
+                                rb_funcall(klass, id_find, 1, INT2NUM(value->value)));
         }
     }
 
@@ -135,16 +127,20 @@ enum_get_holder(VALUE rb_enum)
     return holder;
 }
 
-static VALUE
-make_enum(gint n, VALUE klass)
-{
-    return rb_funcall(klass, id_new, 1, INT2NUM(n));
-}
-
 VALUE
 rbgobj_make_enum(gint n, GType gtype)
 {
-    return make_enum(n, GTYPE2CLASS(gtype));
+    VALUE klass = GTYPE2CLASS(gtype);
+    VALUE enum_value;
+
+    enum_value = rb_funcall(klass, id_find, 1, INT2NUM(n));
+    if (NIL_P(enum_value)) {
+        enum_value = rb_funcall(klass,
+                                id_new,
+                                1,
+                                INT2NUM(n));
+    }
+    return enum_value;
 }
 
 gint
@@ -184,36 +180,25 @@ void
 rbgobj_init_enum_class(VALUE klass)
 {
     GEnumClass* gclass = g_type_class_ref(CLASS2GTYPE(klass));
+    VALUE values;
     guint i;
 
+    values = rb_hash_new();
+    rb_iv_set(klass, "values", values);
     for (i = 0; i < gclass->n_values; i++) {
         GEnumValue* entry = &(gclass->values[i]);
+        VALUE rb_raw_enum_value;
+        VALUE value;
         gchar *const_nick_name;
 
+        rb_raw_enum_value = INT2NUM(entry->value);
+        value = rb_funcall(klass, id_new, 1, rb_raw_enum_value);
+        rb_hash_aset(values, rb_raw_enum_value, value);
         const_nick_name = nick_to_const_name(entry->value_nick);
-
-#if 0
-        {
-            ID id = rb_intern(const_nick_name);
-            if (rb_is_const_id(id)) {
-                VALUE value;
-
-                value = make_enum(entry->value, klass);
-                rb_define_const(klass, const_nick_name, value);
-            }
+        if (const_nick_name) {
+            rbgobj_define_const(klass, const_nick_name, value);
+            g_free(const_nick_name);
         }
-#else
-        {
-            if (const_nick_name) {
-                VALUE value;
-
-                value = make_enum(entry->value, klass);
-                rbgobj_define_const(klass, const_nick_name, value);
-            }
-        }
-#endif
-
-        g_free(const_nick_name);
     }
 
     g_type_class_unref(gclass);
@@ -230,42 +215,32 @@ rg_s_range(VALUE self)
     return result;
 }
 
-struct enum_s_values_body_args {
-    GEnumClass *gclass;
-    VALUE self;
-};
-
-static VALUE
-enum_s_values_body(VALUE value)
-{
-    struct enum_s_values_body_args *args = (struct enum_s_values_body_args *)value;
-    VALUE result = rb_ary_new();
-    guint i;
-
-    for (i = 0; i < args->gclass->n_values; i++)
-        rb_ary_push(result, make_enum(args->gclass->values[i].value, args->self));
-
-    return result;
-}
-
 static VALUE
-enum_s_values_ensure(VALUE gclass)
+rg_s_values(VALUE self)
 {
-    g_type_class_unref((GEnumClass *)gclass);
-
-    return Qnil;
+    VALUE values = rb_iv_get(self, "values");
+    return rb_funcall(values, id_values, 0);
 }
 
 static VALUE
-rg_s_values(VALUE self)
+rg_s_find(VALUE self, VALUE key)
 {
-    struct enum_s_values_body_args args = {
-        g_type_class_ref(CLASS2GTYPE(self)),
-        self
-    };
-
-    return rb_ensure(enum_s_values_body, (VALUE)&args,
-                     enum_s_values_ensure, (VALUE)args.gclass);
+    if (RB_TYPE_P(key, RUBY_T_FIXNUM)) {
+        VALUE values = rb_iv_get(self, "values");
+        return rb_hash_aref(values, key);
+    } else if (RB_TYPE_P(key, RUBY_T_STRING) || RB_TYPE_P(key, RUBY_T_SYMBOL)) {
+        VALUE nick = rb_funcall(key, id_to_s, 0);
+        gchar *const_nick = nick_to_const_name(RVAL2CSTR(nick));
+        ID const_nick_id = rb_intern(const_nick);
+        g_free(const_nick);
+        if (rb_const_defined(self, const_nick_id)) {
+            return rb_const_get(self, const_nick_id);
+        } else {
+            return Qnil;
+        }
+    } else {
+        return Qnil;
+    }
 }
 
 VALUE
@@ -433,9 +408,11 @@ rg_coerce(VALUE self, VALUE other)
 void
 Init_gobject_genums(void)
 {
+    id_find = rb_intern("find");
     id_new = rb_intern("new");
-    id_to_s = rb_intern("to_s");
     id_to_i = rb_intern("to_i");
+    id_to_s = rb_intern("to_s");
+    id_values = rb_intern("values");
 
     RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_ENUM, "Enum", mGLib);
 
@@ -444,6 +421,7 @@ Init_gobject_genums(void)
 
     RG_DEF_SMETHOD(range, 0);
     RG_DEF_SMETHOD(values, 0);
+    RG_DEF_SMETHOD(find, 1);
 
     rb_define_alloc_func(RG_TARGET_NAMESPACE, rbgobj_enum_alloc_func);
 

data/ext/glib2/rbgobj_type.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2018  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2019  Ruby-GNOME Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -377,7 +377,7 @@ rbgobj_class_info_lookup(VALUE klass)
     if (TYPE(klass) == T_CLASS) {
         VALUE super;
         super = rb_funcall(klass, id_superclass, 0);
-        return rbgobj_lookup_class(super);
+        return rbgobj_class_info_lookup(super);
     }
 
     rb_raise(rb_eRuntimeError, "can't get gobject class information");
@@ -605,6 +605,61 @@ rbgobj_gtype_get(VALUE self)
     rb_raise(rb_eTypeError, "Not a GLib::Type");
 }
 
+static VALUE
+rg_s_try_convert(VALUE self, VALUE value)
+{
+    ID id_new;
+    CONST_ID(id_new, "new");
+
+    if (NIL_P(value))
+        return Qnil;
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(value, RG_TARGET_NAMESPACE)))
+        return value;
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(value, rb_cInteger))) {
+        GType gtype = NUM2ULONG(value);
+        if (!g_type_name(gtype))
+            return Qnil;
+        return rb_funcall(self, id_new, 1, value);
+    }
+
+    if (RB_TYPE_P(value, RUBY_T_SYMBOL)) {
+        value = rb_sym2str(value);
+    }
+
+    if (RB_TYPE_P(value, RUBY_T_STRING)) {
+        GType gtype = g_type_from_name(RVAL2CSTR(value));
+        if (gtype == G_TYPE_INVALID) {
+            return Qnil;
+        }
+        return rb_funcall(self, id_new, 1, value);
+    }
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(value, rb_cClass))) {
+        for (; !NIL_P(value); value = rb_funcall(value, id_superclass, 0)) {
+            RGObjClassInfo *cinfo;
+            VALUE data = rb_hash_aref(klass_to_cinfo, value);
+
+            if (NIL_P(data))
+                continue;
+
+            if (RTYPEDDATA_P(data)) {
+                TypedData_Get_Struct(data,
+                                     RGObjClassInfo,
+                                     RTYPEDDATA_TYPE(data),
+                                     cinfo);
+            } else {
+                Data_Get_Struct(data, RGObjClassInfo, cinfo);
+            }
+            return rb_funcall(self, id_new, 1, ULONG2NUM(cinfo->gtype));
+        }
+        return Qnil;
+    }
+
+    return Qnil;
+}
+
 static VALUE
 rg_initialize(VALUE self, VALUE type)
 {
@@ -930,6 +985,8 @@ Init_gobject_gtype(void)
 
     RG_TARGET_NAMESPACE = rb_define_class_under(mGLib, "Type", rb_cObject);
 
+    RG_DEF_SMETHOD(try_convert, 1);
+
     rb_define_alias(CLASS_OF(RG_TARGET_NAMESPACE), "[]", "new");
     RG_DEF_METHOD(initialize, 1);
     RG_DEF_METHOD(inspect, 0);

data/ext/glib2/rbgprivate.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2007-2018  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2007-2019  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
@@ -60,6 +60,7 @@ typedef struct {
 } boxed_holder;
 
 G_GNUC_INTERNAL extern GStaticPrivate rg_polling_key;
+G_GNUC_INTERNAL extern rb_encoding *rbg_filename_encoding;
 
 extern VALUE rbgobj_cEnum;
 extern VALUE rbgobj_cFlags;

data/glib2.gemspec

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright (C) 2018-2019  Ruby-GNOME2 Project Team
+# Copyright (C) 2018-2019  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
@@ -25,7 +25,7 @@ Gem::Specification.new do |s|
     "Ruby/GLib2 provides " +
     "base features for GLib2 based bindings and " +
     "many useful utility features."
-  s.author        = "The Ruby-GNOME2 Project Team"
+  s.author        = "The Ruby-GNOME Project Team"
   s.email         = "ruby-gnome2-devel-en@lists.sourceforge.net"
   s.homepage      = "https://ruby-gnome2.osdn.jp/"
   s.licenses      = ["LGPL-2.1+"]

data/lib/glib-mkenums.rb

@@ -112,7 +112,10 @@ GType #{@enum_name}_get_type (void);
       data.force_encoding("utf-8") if data.respond_to?(:force_encoding)
       data.scan(/^\s*typedef\s+enum\s*(\/\*<\s*flags\s*>\*\/)?\s*
                 \{?\s*(.*?)
-                \}\s*(\w+);/mx) do |force_flags, constants, name|
+                \}\s*(\w+)
+                # GLIB_DEPRECATED_TYPE_IN_2_38_FOR(GTestSubprocessFlags)
+                (?:\s+[\w()\s]+)?
+                ;/mx) do |force_flags, constants, name|
         enum_options = {}
         enum_options[:force_flags] = !force_flags.nil?
         force_flags_patterns = [(options[:force_flags] || [])].flatten

data/lib/glib2.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2005-2018  Ruby-GNOME2 Project Team
+# Copyright (C) 2005-2019  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
@@ -148,23 +148,50 @@ module GLib
 
 
   class Enum
-    def _dump(limit)
-      Marshal.dump(to_i, limit)
+    class << self
+      def try_convert(value)
+        if value.is_a?(self)
+          value
+        else
+          find(value)
+        end
+      end
+
+      def _load(obj)
+        new(Marshal.load(obj))
+      end
     end
 
-    def self._load(obj)
-      new(Marshal.load(obj))
+    def _dump(limit)
+      Marshal.dump(to_i, limit)
     end
   end
 
 
   class Flags
-    def _dump(limit)
-      Marshal.dump(to_i, limit)
+    class << self
+      def try_convert(value)
+        case value
+        when self
+          value
+        when Integer, String, Symbol, Array
+          begin
+            new(value)
+          rescue ArgumentError
+            nil
+          end
+        else
+          nil
+        end
+      end
+
+      def _load(obj)
+        new(Marshal.load(obj))
+      end
     end
 
-    def self._load(obj)
-      new(Marshal.load(obj))
+    def _dump(limit)
+      Marshal.dump(to_i, limit)
     end
 
     # FIXME

data/test/test-bytes.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2017  Ruby-GNOME2 Project Team
+# Copyright (C) 2017-2019  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
@@ -21,6 +21,27 @@ class TestGLibBytes < Test::Unit::TestCase
     only_glib_version(2, 32, 0)
   end
 
+  sub_test_case ".try_convert" do
+    def test_nil
+      assert_nil(GLib::Bytes.try_convert(nil))
+    end
+
+    def test_bytes
+      bytes = GLib::Bytes.new("Hello")
+      assert_equal(bytes,
+                   GLib::Bytes.try_convert(bytes))
+    end
+
+    def test_string
+      assert_equal("Hello",
+                   GLib::Bytes.try_convert("Hello").to_s)
+    end
+
+    def test_unconvertable
+      assert_nil(GLib::Bytes.try_convert([]))
+    end
+  end
+
   sub_test_case ".new" do
     def create_bytes(options={})
       data = "Hello"

data/test/test-enum.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2015-2019  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
@@ -14,10 +14,41 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-require 'test/unit'
-require 'glib2'
-
 class TestEnum < Test::Unit::TestCase
+  sub_test_case(".try_convert") do
+    def test_nil
+      assert_nil(GLib::NormalizeMode.try_convert(nil))
+    end
+
+    def test_enum
+      assert_equal(GLib::NormalizeMode::NFD,
+                   GLib::NormalizeMode.try_convert(GLib::NormalizeMode::NFD))
+    end
+
+    def test_integer
+      assert_equal(GLib::NormalizeMode::NFD,
+                   GLib::NormalizeMode.try_convert(GLib::NormalizeMode::NFD.to_i))
+    end
+
+    def test_string
+      assert_equal(GLib::NormalizeMode::NFD,
+                   GLib::NormalizeMode.try_convert("nfd"))
+    end
+
+    def test_symbol
+      assert_equal(GLib::NormalizeMode::NFD,
+                   GLib::NormalizeMode.try_convert(:nfd))
+    end
+
+    def test_nonexistent
+      assert_nil(GLib::NormalizeMode.try_convert(:nonexistent))
+    end
+
+    def test_unconvertable
+      assert_nil(GLib::NormalizeMode.try_convert([]))
+    end
+  end
+
   def test_enum_by_symbol
     original = [0x00c1].pack("U*") # A with acute
 

data/test/test-flags.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2015-2019  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
@@ -13,11 +13,47 @@
 # You should have received a copy of the GNU Lesser General Public
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- 
-require 'test/unit'
-require 'glib2'
 
 class TestFlags < Test::Unit::TestCase
+  sub_test_case(".try_convert") do
+    def test_nil
+      assert_nil(GLib::KeyFile::Flags.try_convert(nil))
+    end
+
+    def test_flags
+      assert_equal(GLib::KeyFile::Flags::KEEP_COMMENTS,
+                   GLib::KeyFile::Flags.try_convert(GLib::KeyFile::Flags::KEEP_COMMENTS))
+    end
+
+    def test_integer
+      assert_equal(GLib::KeyFile::Flags.new(1),
+                   GLib::KeyFile::Flags.try_convert(1))
+    end
+
+    def test_string
+      assert_equal(GLib::KeyFile::Flags.new("keep_comments"),
+                   GLib::KeyFile::Flags.try_convert("keep_comments"))
+    end
+
+    def test_symbol
+      assert_equal(GLib::KeyFile::Flags.new(:keep_comments),
+                   GLib::KeyFile::Flags.try_convert(:keep_comments))
+    end
+
+    def test_array
+      assert_equal(GLib::KeyFile::Flags.new(1 | 2),
+                   GLib::KeyFile::Flags.try_convert([1, :keep_translations]))
+    end
+
+    def test_nonexistent
+      assert_nil(GLib::KeyFile::Flags.try_convert(:nonexistent))
+    end
+
+    def test_unconvertable
+      assert_nil(GLib::KeyFile::Flags.try_convert({}))
+    end
+  end
+
   {
     '<=>' => [
       [0b0000, 0.0, nil],

data/test/test-glib2.rb

@@ -1,6 +1,6 @@
-# encoding: ascii-8bit
+# coding: ascii-8bit
 #
-# Copyright (C) 2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2015-2019  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
@@ -49,37 +49,37 @@ class TestGLib < Test::Unit::TestCase
   def test_convert
     assert_kind_of(String, GLib.charset)
 
-    sjis = "\202\261\202\361\202\311\202\277\202\315\220\242\212E"
-    euc  = "\244\263\244\363\244\313\244\301\244\317\300\244\263\246"
-    utf8 = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257\344\270\226\347\225\214"
-    assert_equal(GLib.convert(sjis, "UTF-8", "SHIFT_JIS"), utf8)
-    assert_equal(GLib.convert(sjis, "EUC-JP", "SHIFT_JIS"), euc)
-    assert_equal(GLib.convert(sjis, "SHIFT_JIS", "SHIFT_JIS"), sjis)
-    assert_equal(GLib.convert(euc, "UTF-8", "EUC-JP"), utf8)
-    assert_equal(GLib.convert(euc, "EUC-JP", "EUC-JP"), euc)
-    assert_equal(GLib.convert(euc, "SHIFT_JIS", "EUC-JP"), sjis)
-    assert_equal(GLib.convert(utf8, "UTF-8", "UTF-8"), utf8)
-    assert_equal(GLib.convert(utf8, "EUC-JP", "UTF-8"), euc)
-    assert_equal(GLib.convert(utf8, "SHIFT_JIS", "UTF-8"), sjis)
+    sjis = "\202\261\202\361\202\311\202\277\202\315\220\242\212E".force_encoding("Shift_JIS")
+    euc  = "\244\263\244\363\244\313\244\301\244\317\300\244\263\246".force_encoding("EUC-JP")
+    utf8 = "\343\201\223\343\202\223\343\201\253\343\201\241\343\201\257\344\270\226\347\225\214".force_encoding("UTF-8")
+    assert_equal(utf8, GLib.convert(sjis, "UTF-8", "SHIFT_JIS"))
+    assert_equal(euc, GLib.convert(sjis, "EUC-JP", "SHIFT_JIS"))
+    assert_equal(sjis, GLib.convert(sjis, "SHIFT_JIS", "SHIFT_JIS"))
+    assert_equal(utf8, GLib.convert(euc, "UTF-8", "EUC-JP"))
+    assert_equal(euc, GLib.convert(euc, "EUC-JP", "EUC-JP"))
+    assert_equal(sjis, GLib.convert(euc, "SHIFT_JIS", "EUC-JP"))
+    assert_equal(utf8, GLib.convert(utf8, "UTF-8", "UTF-8"))
+    assert_equal(euc, GLib.convert(utf8, "EUC-JP", "UTF-8"))
+    assert_equal(sjis, GLib.convert(utf8, "SHIFT_JIS", "UTF-8"))
   end
 
-  def tet_locale_to_utf8
-    assert_equal(Encoding::UTF8,
+  def test_locale_to_utf8
+    assert_equal(Encoding::UTF_8,
                  GLib.locale_to_utf8("ascii").encoding)
   end
 
-  def tet_locale_from_utf8
+  def test_locale_from_utf8
     assert_equal(Encoding::ASCII_8BIT,
                  GLib.locale_from_utf8("ascii").encoding)
   end
 
-  def tet_filename_to_utf8
-    assert_equal(Encoding::UTF8,
+  def test_filename_to_utf8
+    assert_equal(Encoding::UTF_8,
                  GLib.filename_to_utf8("ascii.txt").encoding)
   end
 
-  def tet_filename_from_utf8
-    assert_equal(Encoding::ASCII_8BIT,
+  def test_filename_from_utf8
+    assert_equal(GLib::FILENAME_ENCODING,
                  GLib.filename_from_utf8("ascii.txt").encoding)
   end
 

data/test/test-type.rb

@@ -0,0 +1,51 @@
+# Copyright (C) 2019  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
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+class TestGLibType < Test::Unit::TestCase
+  sub_test_case(".try_convert") do
+    def test_nil
+      assert_nil(GLib::Type.try_convert(nil))
+    end
+
+    def test_type
+      assert_equal(GLib::Type::STRING,
+                   GLib::Type.try_convert(GLib::Type::STRING))
+    end
+
+    def test_integer
+      assert_equal(GLib::Type::STRING,
+                   GLib::Type.try_convert(GLib::Type::STRING.to_i))
+    end
+
+    def test_string
+      assert_equal(GLib::Type::STRING,
+                   GLib::Type.try_convert("gchararray"))
+    end
+
+    def test_symbol
+      assert_equal(GLib::Type::STRING,
+                   GLib::Type.try_convert(:gchararray))
+    end
+
+    def test_nonexistent
+      assert_nil(GLib::Type.try_convert(:nonexistent))
+    end
+
+    def test_unconvertable
+      assert_nil(GLib::Type.try_convert([]))
+    end
+  end
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glib2
 version: !ruby/object:Gem::Version
-  version: 3.3.7
+  version: 3.3.8
 platform: ruby
 authors:
-- The Ruby-GNOME2 Project Team
+- The Ruby-GNOME Project Team
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2019-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config
@@ -192,6 +193,7 @@ files:
 - test/test-time-zone.rb
 - test/test-timeout.rb
 - test/test-type-interface.rb
+- test/test-type.rb
 - test/test-unicode.rb
 - test/test-utils.rb
 - test/test-value.rb