glib2 2.2.5 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7e949298ce137e91f0c483674d00ecf223360e5
-  data.tar.gz: 631153ad8255b6e980ab84a72a584b638d3b7b63
+  metadata.gz: f3350aed00d1e10329978c1547d477341e7a5344
+  data.tar.gz: 533b7ac7dccd7cc39d00cfe78eaa41d759fad8f1
 SHA512:
-  metadata.gz: 14de6f353a8cc06e27ef8d5b318979c760d6173ecd7c88d676ecaa48eef5d3da41fd99e1249c2132af76b9b5301ef51cd5d7f9b4804eda75b2f87d210310db73
-  data.tar.gz: 9d064c4df47b03609136ab7eb8d83fe28dc9d18c46db55e46c7ec41a524f87092c7ed3befa6b24ebecf5591528e11df80414b5887fab9cb2ca2c4cd022b79cd2
+  metadata.gz: 2a8471eeed482a55d90eabe8a042664d37cf36240916f08a49a7256010f1c37871f5608e57514e33450a17025116c48ee939e01f4f3d390647ca23f40c88aaff
+  data.tar.gz: 4e5307bcd6e7862e5ca7ad05c172c98f121895f72eb8753e32e9781cd38c21a104a1913b05d220095683ee98c87cdc94adcb0c46495244a4dde4a4d78b7a85df

data/Rakefile

@@ -1,4 +1,20 @@
 # -*- ruby -*-
+#
+# Copyright (C) 2011-2015  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
+# 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
 
 $LOAD_PATH.unshift("./lib")
 require 'gnome2/rake/package-task'
@@ -38,7 +54,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "gettext",
       :download_site => :gnu,
       :label => "gettext-runtime",
-      :version => "0.19.2",
+      :version => "0.19.5",
       :base_dir_in_package => "gettext-runtime",
       :windows => {
         :built_file => "bin/libintl-8.dll",
@@ -57,7 +73,7 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.42.1",
+      :version => "2.44.1",
       :compression_method => "xz",
       :windows => {
         :need_autoreconf => true,
@@ -85,33 +101,62 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "nettle",
       :download_base_url => "http://www.lysator.liu.se/~nisse/archive",
       :label => "Nettle",
-      :version => "2.7.1",
+      :version => "3.1.1",
       :windows => {
         :configure_args => [],
-        :built_file => "bin/libnettle-4-7.dll",
+        :built_file => "bin/libnettle-6-1.dll",
+      },
+    },
+    {
+      :name => "libtasn1",
+      :download_site => :gnu,
+      :label => "Libtasn1",
+      :version => "4.6",
+      :windows => {
+        :built_file => "bin/libtasn1-6.dll",
+      },
+    },
+    {
+      :name => "libidn",
+      :download_site => :gnu,
+      :label => "Libidn",
+      :version => "1.32",
+      :windows => {
+        :built_file => "bin/libidn-11.dll",
+      },
+    },
+    {
+      :name => "p11-kit",
+      :download_base_url => "http://p11-glue.freedesktop.org/releases",
+      :label => "p11-kit",
+      :version => "0.23.1",
+      :windows => {
+        :built_file => "bin/libp11-kit-0.dll",
       },
     },
     {
       :name => "gnutls",
-      :download_base_url => "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.2",
+      :download_base_url => "ftp://ftp.gnutls.org/gcrypt/gnutls/v3.4",
       :label => "GnuTLS",
-      :version => "3.2.21",
+      :version => "3.4.4",
       :compression_method => "xz",
       :windows => {
         :configure_args => [
           "--disable-cxx",
+          "--disable-tools",
+          "--disable-doc",
         ],
         :use_cc_environment_variable => false,
         :patches => [
         ],
-        :built_file => "bin/libgnutls-28.dll",
+        :built_file => "bin/libgnutls-30.dll",
       },
     },
     {
       :name => "glib-networking",
       :download_site => :gnome,
       :label => "glib-networking",
-      :version => "2.42.1",
+      :version => "2.44.0",
       :compression_method => "xz",
       :windows => {
         :configure_args => [

data/ext/glib2/extconf.rb

@@ -61,7 +61,7 @@ ignore_headers = [
   "gmain.h",
   "gscanner.h",
 ]
-unless (/mingw|cygwin|mswin/ === RUBY_PLATFORM)
+unless windows_platform?
   ignore_headers << "gwin32.h"
 end
 headers = include_paths.split.inject([]) do |result, path|

data/ext/glib2/glib2.def

@@ -52,6 +52,8 @@ EXPORTS
 	rbgobj_register_class
 	rbgobj_register_property_getter
 	rbgobj_register_property_setter
+	rbgobj_class_init_func
+	rbgobj_register_type
 	rbgobj_set_signal_func
 	rbgobj_get_signal_func
 	rbgobj_add_constants
@@ -67,6 +69,7 @@ EXPORTS
 	rbg_rval_inspect
 	rbg_string_value_ptr
 	rbg_rval2cstr
+	rbg_rval2cstr_ptr
 	rbg_rval2cstr_accept_nil
 	rbg_rval2cstr_accept_symbol
 	rbg_rval2cstr_accept_symbol_accept_nil
@@ -101,6 +104,8 @@ EXPORTS
         rbg_gslist2rval
         rbg_glist2rval_with_type
         rbg_gslist2rval_with_type
+	rbg_rval2glist
+	rbg_rval2gslist
 	rbg_define_method
 	rbg_define_singleton_method
 	rbg_to_array
@@ -110,6 +115,7 @@ EXPORTS
 	rbg_scan_options
 	rbg_inspect
 	rbg_interrupt_source_new
+	rbg_name_to_nick
 	rbgutil_id_module_eval		DATA
 	rbgutil_def_setters
 	rbgutil_glist2ary
@@ -140,6 +146,8 @@ EXPORTS
 	rbglib_uint64_to_num
 	rbglib_num_to_int64
 	rbglib_int64_to_num
+	rbg_variant_to_ruby
+	rbg_variant_from_ruby
 
 	g_source_get_type
 	g_connect_flags_get_type

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

@@ -0,0 +1,296 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ *  Copyright (C) 2015  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
+ *  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
+ */
+
+#include "rbgprivate.h"
+
+#define RG_TARGET_NAMESPACE cVariantType
+
+#define _SELF(s) (RVAL2GVARIANTTYPE(s))
+
+static VALUE RG_TARGET_NAMESPACE;
+
+static VALUE
+rg_s_valid_p(G_GNUC_UNUSED VALUE klass, VALUE rb_string)
+{
+    gboolean is_valid;
+
+    is_valid = g_variant_type_string_is_valid(StringValueCStr(rb_string));
+
+    return CBOOL2RVAL(is_valid);
+}
+
+static VALUE
+rg_s_scan(G_GNUC_UNUSED VALUE klass, VALUE rb_string)
+{
+    gboolean found;
+    const gchar *string;
+    const gchar *end;
+
+    string = StringValueCStr(rb_string);
+    found = g_variant_type_string_scan(string, NULL, &end);
+
+    if (!found) {
+        return Qnil;
+    }
+
+    return CSTR2RVAL(end);
+}
+
+static VALUE
+rg_initialize(VALUE self, VALUE rb_string)
+{
+    GVariantType *variant_type;
+    const gchar *string;
+
+    string = StringValueCStr(rb_string);
+    if (!g_variant_type_string_is_valid(string)) {
+        rb_raise(rb_eArgError,
+                 "invalid type string: %s", rbg_inspect(rb_string));
+    }
+
+    variant_type = g_variant_type_new(string);
+    G_INITIALIZE(self, variant_type);
+
+    return Qnil;
+}
+
+static VALUE
+rg_to_s(VALUE self)
+{
+    GVariantType *variant_type;
+    const gchar *string;
+    gsize string_length;
+
+    variant_type = _SELF(self);
+    string = g_variant_type_peek_string(variant_type);
+    string_length = g_variant_type_get_string_length(variant_type);
+
+    return CSTR2RVAL_LEN(string, string_length);
+}
+
+static VALUE
+rg_definite_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_definite(variant_type));
+}
+
+static VALUE
+rg_container_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_container(variant_type));
+}
+
+static VALUE
+rg_basic_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_basic(variant_type));
+}
+
+static VALUE
+rg_maybe_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_maybe(variant_type));
+}
+
+static VALUE
+rg_array_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_array(variant_type));
+}
+
+static VALUE
+rg_tuple_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_tuple(variant_type));
+}
+
+static VALUE
+rg_dict_entry_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_dict_entry(variant_type));
+}
+
+static VALUE
+rg_variant_p(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return CBOOL2RVAL(g_variant_type_is_variant(variant_type));
+}
+
+static VALUE
+rg_operator_eq(VALUE self, VALUE other)
+{
+    GVariantType *variant_type1;
+    GVariantType *variant_type2;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(other, RG_TARGET_NAMESPACE)))
+        return Qfalse;
+
+    variant_type1 = _SELF(self);
+    variant_type2 = _SELF(other);
+    return CBOOL2RVAL(g_variant_type_equal(variant_type1, variant_type2));
+}
+
+static VALUE
+rg_hash(VALUE self)
+{
+    GVariantType *variant_type;
+
+    variant_type = _SELF(self);
+    return UINT2NUM(g_variant_type_hash(variant_type));
+}
+
+static VALUE
+rg_is_subtype_of_p(VALUE self, VALUE rb_subtype)
+{
+    GVariantType *variant_type;
+    GVariantType *sub_variant_type;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_subtype, RG_TARGET_NAMESPACE)))
+        return Qfalse;
+
+    variant_type = _SELF(self);
+    sub_variant_type = _SELF(rb_subtype);
+    return CBOOL2RVAL(g_variant_type_is_subtype_of(variant_type,
+                                                   sub_variant_type));
+}
+
+static VALUE
+rg_element(VALUE self)
+{
+    GVariantType *variant_type;
+    const GVariantType *element;
+
+    variant_type = _SELF(self);
+    if (!(g_variant_type_is_array(variant_type) ||
+          g_variant_type_is_maybe(variant_type))) {
+        rb_raise(rb_eArgError,
+                 "must be array or maybe type: <%.*s>",
+                 (int)g_variant_type_get_string_length(variant_type),
+                 g_variant_type_peek_string(variant_type));
+    }
+
+    element = g_variant_type_element(variant_type);
+    return GVARIANTTYPE2RVAL((GVariantType *)element);
+}
+
+void
+Init_glib_variant_type(void)
+{
+    RG_TARGET_NAMESPACE = G_DEF_CLASS(G_TYPE_VARIANT_TYPE, "VariantType", mGLib);
+
+    RG_DEF_SMETHOD_P(valid, 1);
+    RG_DEF_SMETHOD(scan, 1);
+
+    RG_DEF_METHOD(initialize, 1);
+    RG_DEF_METHOD(to_s, 0);
+
+    RG_DEF_METHOD_P(definite, 0);
+    RG_DEF_METHOD_P(container, 0);
+    RG_DEF_METHOD_P(basic, 0);
+    RG_DEF_METHOD_P(maybe, 0);
+    RG_DEF_METHOD_P(array, 0);
+    RG_DEF_METHOD_P(tuple, 0);
+    RG_DEF_METHOD_P(dict_entry, 0);
+    RG_DEF_METHOD_P(variant, 0);
+
+    RG_DEF_METHOD_OPERATOR("==", eq, 1);
+
+    RG_DEF_METHOD(hash, 0);
+    RG_DEF_ALIAS("eql?", "==");
+
+    RG_DEF_METHOD_P(is_subtype_of, 1);
+
+    RG_DEF_METHOD(element, 0);
+
+    {
+        ID id_new;
+
+        CONST_ID(id_new, "new");
+
+#define DEF_TYPE(name) do {                                             \
+            const GVariantType *type = G_VARIANT_TYPE_ ## name;         \
+            const gchar *type_string;                                   \
+            gsize type_string_length;                                   \
+            VALUE rb_type_string;                                       \
+                                                                        \
+            type_string = g_variant_type_peek_string(type);             \
+            type_string_length = g_variant_type_get_string_length(type); \
+            rb_type_string = rb_str_new(type_string,                    \
+                                        type_string_length);            \
+            rb_define_const(RG_TARGET_NAMESPACE, G_STRINGIFY(name),     \
+                            rb_funcall(RG_TARGET_NAMESPACE, id_new, 1,  \
+                                       rb_type_string));                \
+        } while (0)
+
+        DEF_TYPE(BOOLEAN);
+        DEF_TYPE(BYTE);
+        DEF_TYPE(INT16);
+        DEF_TYPE(UINT16);
+        DEF_TYPE(INT32);
+        DEF_TYPE(UINT32);
+        DEF_TYPE(INT64);
+        DEF_TYPE(UINT64);
+        DEF_TYPE(HANDLE);
+        DEF_TYPE(DOUBLE);
+        DEF_TYPE(STRING);
+        DEF_TYPE(OBJECT_PATH);
+        DEF_TYPE(SIGNATURE);
+        DEF_TYPE(VARIANT);
+        DEF_TYPE(ANY);
+        DEF_TYPE(BASIC);
+        DEF_TYPE(MAYBE);
+        DEF_TYPE(ARRAY);
+        DEF_TYPE(TUPLE);
+        DEF_TYPE(UNIT);
+        DEF_TYPE(DICT_ENTRY);
+        DEF_TYPE(DICTIONARY);
+        DEF_TYPE(STRING_ARRAY);
+        DEF_TYPE(OBJECT_PATH_ARRAY);
+        DEF_TYPE(BYTESTRING);
+        DEF_TYPE(BYTESTRING_ARRAY);
+        DEF_TYPE(VARDICT);
+
+#undef DEF_TYPE
+    }
+}