glib2 3.0.7-x64-mingw32 → 3.0.8-x64-mingw32

data/ext/glib2/rbgobj_value.c

@@ -122,12 +122,14 @@ rbgobj_gvalue_to_rvalue(const GValue* value)
                 return func(value);
             }
         }
+#if GLIB_CHECK_VERSION(2, 26, 0)
       case G_TYPE_VARIANT:
         {
             GVariant *variant = g_value_peek_pointer(value);
             rvalue = rbg_variant_to_ruby(variant);
             return rvalue;
         }
+#endif
       default:
         if (!rbgobj_convert_gvalue2rvalue(fundamental_type, value, &rvalue)) {
             GValueToRValueFunc func;
@@ -308,7 +310,11 @@ rbgobj_rvalue_to_gvalue(VALUE val, GValue* result)
                 return;
             }
         }
-
+#if GLIB_CHECK_VERSION(2, 26, 0)
+      case G_TYPE_VARIANT:
+        g_value_set_variant(result, rbg_variant_from_ruby(val));
+        break;
+#endif
       default:
         if (!rbgobj_convert_rvalue2gvalue(fundamental_type, val, result)) {
             RValueToGValueFunc func =

data/ext/glib2/rbgprivate.h

@@ -152,6 +152,8 @@ G_GNUC_INTERNAL void Init_glib_keyfile(void);
 G_GNUC_INTERNAL void Init_glib_bookmark_file(void);
 G_GNUC_INTERNAL void Init_glib_variant_type(void);
 G_GNUC_INTERNAL void Init_glib_variant(void);
+G_GNUC_INTERNAL void Init_glib_regex(void);
+G_GNUC_INTERNAL void Init_glib_matchinfo(void);
 
 G_GNUC_INTERNAL void Init_gobject_convert(void);
 G_GNUC_INTERNAL void Init_gobject_gtype(void);

data/ext/glib2/rbgutil.c

@@ -201,6 +201,13 @@ rbg_name_to_nick(const gchar *name)
     return nick;
 }
 
+void *
+rbg_memzero(void *pointer, size_t size)
+{
+    memset(pointer, 0, size);
+    return pointer;
+}
+
 void
 Init_gutil(void)
 {

data/ext/glib2/rbgutil.h

@@ -109,6 +109,8 @@ extern GSource *rbg_interrupt_source_new(void);
 
 extern gchar *rbg_name_to_nick(const gchar *name);
 
+extern void *rbg_memzero(void *poitner, size_t size);
+
 /*< protected >*/
 RUBY_GLIB2_VAR ID rbgutil_id_module_eval;
 extern void rbgutil_glibid_r2g_func(VALUE from, GValue* to);

data/lib/glib2.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2005-2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2005-2016  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
@@ -241,6 +241,7 @@ GLib::Log.set_log_domain(GLib::Thread::LOG_DOMAIN)
 GLib::Log.set_log_domain(GLib::Module::LOG_DOMAIN)
 
 require 'glib2/version'
+require "glib2/regex"
 =begin
 Don't we need this?
 ObjectSpace.define_finalizer(GLib) {

data/lib/glib2/regex.rb

@@ -0,0 +1,29 @@
+# Copyright (C) 2016  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
+
+module GLib
+  class Regex
+    class << self
+      def match?(pattern, string, options={})
+        new(pattern, options).match(string, options).matches?
+      end
+
+      def split(pattern, string, options={})
+        new(pattern, options).split(string, options)
+      end
+    end
+  end
+end

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

@@ -123,7 +123,8 @@ module GNOME2
                                               :need_autogen,
                                               :need_autoreconf,
                                               :build_concurrently,
-                                              :use_cc_environment_variable)
+                                              :use_cc_environment_variable,
+                                              :gobject_introspection_compiler_split_args)
         def initialize(properties)
           super()
           properties.each do |key, value|
@@ -178,6 +179,10 @@ module GNOME2
         def use_cc_environment_variable?
           use_cc_environment_variable.nil? ? true : use_cc_environment_variable
         end
+
+        def gobject_introspection_compiler_split_args?
+          gobject_introspection_compiler_split_args
+        end
       end
 
       class NativeConfiguration < Struct.new(:build,

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

@@ -119,7 +119,7 @@ module GNOME2
           s.author                = @author
           s.email                 = @email
           s.homepage              = @homepage
-          s.licenses              = ["LGPLv2.1 or later"]
+          s.licenses              = ["LGPLv2.1+"]
           s.version               = version
           extensions              = FileList["ext/#{@name}/extconf.rb"]
           extensions.existing!

data/lib/gnome2/rake/package.rb

@@ -126,6 +126,15 @@ module GNOME2
           end
         end
 
+        def build_arch
+          case build_architecture
+          when "x86"
+            "i686"
+          when "x64"
+            "x86_64"
+          end
+        end
+
         def build_architecture
           ENV["RUBY_GNOME2_BUILD_ARCHITECTURE"] || "x86"
         end

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

@@ -120,7 +120,7 @@ class GNOME2WindowsBinaryBuildTask
       if package.windows.use_cc_environment_variable?
         common_make_args << cc_env(package)
       end
-      add_gobject_introspection_make_args(common_make_args)
+      add_gobject_introspection_make_args(package, common_make_args)
       build_make_args = common_make_args.dup
       install_make_args = common_make_args.dup
       if package.windows.build_concurrently?
@@ -128,6 +128,9 @@ class GNOME2WindowsBinaryBuildTask
         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"
       sh("nice", "make", *build_make_args) or exit(false)
       sh("make", "install", *install_make_args) or exit(false)
 
@@ -152,9 +155,10 @@ class GNOME2WindowsBinaryBuildTask
 
   def configure(package)
     sh("./autogen.sh") if package.windows.need_autogen?
-    sh("autoreconf --install") if package.windows.need_autoreconf?
+    sh("autoreconf", "--install", "--force") if package.windows.need_autoreconf?
     sh("./configure",
        cc_env(package),
+       dlltool_env,
        "CPPFLAGS=#{cppflags(package)}",
        "LDFLAGS=#{ldflags(package)}",
        "--prefix=#{dist_dir}",
@@ -177,6 +181,10 @@ class GNOME2WindowsBinaryBuildTask
     "CC=#{cc(package)}"
   end
 
+  def dlltool_env
+    "DLLTOOL=#{dlltool}"
+  end
+
   def build_packages
     packages = @package.external_packages.select do |package|
       package.windows.build?
@@ -241,6 +249,10 @@ class GNOME2WindowsBinaryBuildTask
     cxx_command_line.compact.join(" ")
   end
 
+  def dlltool
+    "#{@package.windows.build_host}-dlltool"
+  end
+
   def cppflags(package)
     include_paths = package.windows.include_paths
     if @package.windows.build_dependencies.include?("glib2")
@@ -282,7 +294,7 @@ class GNOME2WindowsBinaryBuildTask
     paths
   end
 
-  def add_gobject_introspection_make_args(common_make_args)
+  def add_gobject_introspection_make_args(package, common_make_args)
     unless @package.windows.build_dependencies.include?("gobject-introspection")
       return
     end
@@ -299,21 +311,33 @@ class GNOME2WindowsBinaryBuildTask
     ]
     dependencies += @package.windows.gobject_introspection_dependencies
 
-    compute_base_dir = lambda do |package|
-      "#{@package.project_root_dir}/#{package}/vendor/local"
+    compute_base_dir = lambda do |dependent_package|
+      "#{@package.project_root_dir}/#{dependent_package}/vendor/local"
     end
 
     gi_base_dir = compute_base_dir.call("gobject-introspection")
     introspection_compiler = "INTROSPECTION_COMPILER="
     introspection_compiler << "#{gi_base_dir}/bin/g-ir-compiler.exe"
-    dependencies.each do |package|
-      gir_dir = "#{compute_base_dir.call(package)}/share/gir-1.0"
-      introspection_compiler << " --includedir=#{gir_dir}"
+    introspection_compiler_args = ""
+    dependencies.each do |dependent_package|
+      gir_dir = "#{compute_base_dir.call(dependent_package)}/share/gir-1.0"
+      introspection_compiler_args << " --includedir=#{gir_dir}"
+    end
+    if package.windows.gobject_introspection_compiler_split_args?
+      common_make_args << introspection_compiler
+      common_make_args <<
+        "INTROSPECTION_COMPILER_ARGS=#{introspection_compiler_args}"
+      common_make_args <<
+        "INTROSPECTION_COMPILER_OPTS=#{introspection_compiler_args}"
+    else
+      introspection_compiler << " #{introspection_compiler_args}"
+      common_make_args << introspection_compiler
     end
-    common_make_args << introspection_compiler
 
-    data_dirs = dependencies.collect do |package|
-      "#{compute_base_dir.call(package)}/share"
+    common_make_args << dlltool_env
+
+    data_dirs = dependencies.collect do |dependent_package|
+      "#{compute_base_dir.call(dependent_package)}/share"
     end
     common_make_args << "XDG_DATA_DIRS=#{data_dirs.join(File::PATH_SEPARATOR)}"
   end

data/lib/mkmf-gnome2.rb

@@ -503,6 +503,8 @@ def package_platform
     :redhat
   elsif File.exist?("/etc/SuSE-release")
     :suse
+  elsif File.exist?("/etc/altlinux-release")
+    :altlinux
   elsif find_executable("pacman")
     :arch
   elsif find_executable("brew")
@@ -536,7 +538,7 @@ def install_missing_native_package(native_package_info)
   package_command_line = [package_name, *options].join(" ")
   need_super_user_priviledge = true
   case platform
-  when :debian
+  when :debian, :altlinux
     install_command = "apt-get install -V -y #{package_command_line}"
   when :fedora, :redhat
     install_command = "yum install -y #{package_command_line}"

data/test/test-match-info.rb

@@ -0,0 +1,113 @@
+# Copyright (C) 2015-2016  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
+
+class TestMatchInfo < Test::Unit::TestCase
+  def test_string
+    regex = GLib::Regex.new("[A-Z]+")
+    match_info = regex.match("abc def")
+    assert_equal("abc def", match_info.string)
+  end
+
+  def test_regex
+    regex = GLib::Regex.new("[A-Z]+")
+    match_info = regex.match("abc def")
+    assert_equal("[A-Z]+", match_info.regex.pattern)
+  end
+
+  def test_partial_match
+    flags = GLib::RegexMatchFlags::PARTIAL_SOFT
+    regex = GLib::Regex.new("jan")
+    match_info = regex.match_all("ja", :match_options => flags)
+    assert do
+      !match_info.matches?
+    end
+    assert do
+      match_info.partial_match?
+    end
+  end
+
+  sub_test_case "fetch" do
+    test "Integer" do
+      regex = GLib::Regex.new("[A-Z]+")
+      match_info = regex.match_all("abc DEF ghi JKL mnop")
+      assert_equal("DEF", match_info.fetch(0))
+      assert_equal("DE", match_info.fetch(1))
+    end
+
+    test "String" do
+      regex = GLib::Regex.new("(?<a_name>fo+)")
+      match_info = regex.match("tatafoo")
+      assert_equal("foo", match_info.fetch("a_name"))
+    end
+
+    test "Symbol" do
+      regex = GLib::Regex.new("(?<a_name>fo+)")
+      match_info = regex.match("tatafoo")
+      assert_equal("foo", match_info.fetch(:a_name))
+    end
+
+    test "[]" do
+      regex = GLib::Regex.new("(?<a_name>fo+)")
+      match_info = regex.match("tatafoo")
+      assert_equal("foo", match_info[:a_name])
+    end
+  end
+
+  sub_test_case "fetch_pos" do
+    test "Integer" do
+      regex = GLib::Regex.new("[A-Z]+")
+      match_info = regex.match_all("abc DEF ghi JKL mnop")
+      assert_equal([4, 7], match_info.fetch_pos(0))
+      assert_equal([4, 6], match_info.fetch_pos(1))
+    end
+
+    test "String" do
+      regex = GLib::Regex.new("(?<a_name>fo+)")
+      match_info = regex.match("tatafoo")
+      assert_equal([4, 7], match_info.fetch_pos("a_name"))
+    end
+
+    test "Symbol" do
+      regex = GLib::Regex.new("(?<a_name>fo+)")
+      match_info = regex.match("tatafoo")
+      assert_equal([4, 7], match_info.fetch_pos(:a_name))
+    end
+  end
+
+  def test_fetch_all
+    regex = GLib::Regex.new("[A-Z]+")
+    str = "abc DEF ghi JKL mnop"
+    match_info = regex.match_all(str)
+    assert_equal(["DEF", "DE", "D"], match_info.fetch_all)
+  end
+
+  def test_next
+    regex = GLib::Regex.new("[A-Z]+")
+    str = "abc DEF ghi JKL mnop"
+    match_info = regex.match(str)
+    assert_equal("DEF", match_info[0])
+    assert {match_info.next}
+    assert_equal("JKL", match_info[0])
+    assert {!match_info.next}
+  end
+
+  def test_expand_references
+    regex = GLib::Regex.new("a(?P<G>.)c")
+    match_info = regex.match("xabcy")
+    expanded_string = match_info.expand_references("X\\g<G>X")
+    assert_equal("XbX", expanded_string)
+  end
+end

data/test/test-regex.rb

@@ -0,0 +1,320 @@
+# Copyright (C) 2015-2016  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
+
+class TestRegex < Test::Unit::TestCase
+  def test_enum_match_flags
+    assert_const_defined(GLib, :RegexMatchFlags)
+    assert_kind_of(GLib::RegexMatchFlags, GLib::RegexMatchFlags::PARTIAL_HARD)
+  end
+
+  def test_enum_compile_flags
+    assert_const_defined(GLib, :RegexCompileFlags)
+    assert_kind_of(GLib::RegexCompileFlags, GLib::RegexCompileFlags::CASELESS)
+  end
+
+  def test_pattern
+    regex = GLib::Regex.new("to??")
+    assert_equal("to??", regex.pattern)
+  end
+
+  def test_compile_flags
+    flags = GLib::RegexCompileFlags::CASELESS
+    regex = GLib::Regex.new("to??", :compile_options => flags)
+    assert_equal(flags, regex.compile_flags)
+  end
+
+  def test_match_flags
+    flags = GLib::RegexMatchFlags::PARTIAL_HARD
+    regex = GLib::Regex.new("to??", :match_options => flags)
+    assert_equal(flags, regex.match_flags)
+  end
+
+  sub_test_case "split" do
+    test "no options" do
+      regex = GLib::Regex.new("\s")
+      string_to_split = "a bc"
+      splited_strings = regex.split(string_to_split)
+      assert_equal(["a", "bc"], splited_strings)
+    end
+
+    test "start_position" do
+      regex = GLib::Regex.new("\s")
+      string_to_split = "a bc"
+      splited_strings = regex.split(string_to_split, :start_position => 2)
+      assert_equal(["bc"], splited_strings)
+    end
+
+    test "max_tokens" do
+      regex = GLib::Regex.new("\s")
+      string_to_split = "a bc de fg"
+      splited_strings = regex.split(string_to_split, :max_tokens => 2)
+      assert_equal(["a", "bc de fg"], splited_strings)
+    end
+
+    test "match_options" do
+      regex = GLib::Regex.new("a?b?")
+      string_to_split = "toto ab"
+      splited_strings = regex.split(string_to_split)
+      assert_equal(["t", "o", "t", "o", " "],
+                   splited_strings)
+      splited_strings = regex.split(string_to_split,
+                                    :match_options => :notempty)
+      assert_equal(["toto ", ""], splited_strings)
+    end
+  end
+
+  sub_test_case "match" do
+    setup do
+      @regex = GLib::Regex.new("[A-Z]+")
+    end
+
+    test "no match no options" do
+      match_info = @regex.match("abc def")
+      assert do
+        not match_info.matches?
+      end
+    end
+
+    test "matched no options" do
+      match_info = @regex.match("abc DEF")
+      assert do
+        match_info.matches?
+      end
+    end
+
+    test "no match and start position option" do
+      match_info = @regex.match("abc def", :start_position => 4)
+      assert do
+        not match_info.matches?
+      end
+    end
+
+    test "matched and start position option" do
+      match_info = @regex.match("abc DEF", :start_position => 4)
+      assert do
+        match_info.matches?
+      end
+    end
+  end
+
+  sub_test_case "max_backref" do
+    test "none" do
+      regex = GLib::Regex.new("to?o")
+      assert_equal(0, regex.max_backref)
+    end
+
+    test "one" do
+      regex = GLib::Regex.new("(to(?)o)\\g1")
+      assert_equal(1, regex.max_backref)
+    end
+  end
+
+  sub_test_case "capture_count" do
+    test "none" do
+      regex = GLib::Regex.new("to?o")
+      assert_equal(0, regex.capture_count)
+    end
+
+    test "one" do
+      regex = GLib::Regex.new("(to(\?)o)")
+      assert_equal(1, regex.capture_count)
+    end
+
+    test "three" do
+      regex = GLib::Regex.new("((red|white) (king|queen))")
+      assert_equal(3, regex.capture_count)
+    end
+  end
+
+  sub_test_case "has_cr_or_lf" do
+    test "none" do
+      regex = GLib::Regex.new("to?o")
+      assert do
+        not regex.has_cr_or_lf?
+      end
+    end
+
+    test "both" do
+      regex = GLib::Regex.new("to\no")
+      assert do
+        regex.has_cr_or_lf?
+      end
+    end
+
+    test "cr" do
+      regex = GLib::Regex.new("to\rtiti")
+      assert do
+        regex.has_cr_or_lf?
+      end
+    end
+  end
+
+  sub_test_case "max_lookbehind" do
+    test "none" do
+      regex = GLib::Regex.new("to?o")
+      assert_equal(0, regex.max_lookbehind)
+    end
+
+    test "three" do
+      regex = GLib::Regex.new("(?<!foo)bar")
+      assert_equal(3, regex.max_lookbehind)
+    end
+  end
+
+  sub_test_case "string_number" do
+    test "none" do
+      regex = GLib::Regex.new("too")
+      assert_equal(-1, regex.string_number("a_name"))
+    end
+
+    test "one" do
+      regex = GLib::Regex.new("(?<a_name>foo)bar")
+      assert_equal(1, regex.string_number("a_name"))
+    end
+
+    test "two" do
+      regex = GLib::Regex.new("(?<another_name>foo)(?<a_name>bar)")
+      assert_equal(2, regex.string_number("a_name"))
+    end
+  end
+
+  def test_regex_escape_string
+    assert_equal("a\\.b\\*c", GLib::Regex.escape_string("a.b*c"))
+  end
+
+  sub_test_case "match?" do
+    test "true" do
+      assert do
+        GLib::Regex.match?("to", "tatota")
+      end
+    end
+
+    test "false" do
+      assert do
+        not GLib::Regex.match?("ti", "tatota")
+      end
+    end
+  end
+
+  sub_test_case "match_all" do
+    test "no match" do
+      regex = GLib::Regex.new("[A-Z]+")
+      assert do
+        not regex.match_all("abc def").matches?
+      end
+    end
+
+    test ":start_position" do
+      regex = GLib::Regex.new("[A-Z]")
+      assert do
+        regex.match_all("a B c", :start_position => 2).matches?
+      end
+      assert do
+        not regex.match_all("a B c", :start_position => 3).matches?
+      end
+    end
+
+    test "match all" do
+      regex = GLib::Regex.new("<.*>")
+      assert_equal(3, regex.match_all("<a> <b> <c>").match_count)
+    end
+  end
+
+  sub_test_case "split simple" do
+    test "no options" do
+      splited_strings = GLib::Regex.split("\s", "a bc")
+      assert_equal(["a", "bc"], splited_strings)
+    end
+
+    test "match_options" do
+      splited_strings = GLib::Regex.split("a?b?", "toto ab")
+      assert_equal(["t", "o", "t", "o", " "], splited_strings)
+
+      splited_strings = GLib::Regex.split("a?b?",
+                                    "toto ab",
+                                    :match_options => :notempty)
+      assert_equal(["toto ", ""], splited_strings)
+    end
+  end
+
+  sub_test_case "replace" do
+    test "simple" do
+      regex = GLib::Regex.new("\\s")
+      assert_equal("a_bc", regex.replace("a bc", "_"))
+    end
+
+    test "back reference" do
+      regex = GLib::Regex.new("\\s")
+      assert_equal("a_ _bc", regex.replace("a bc", "_\\0_"))
+    end
+
+    test "literal" do
+      regex = GLib::Regex.new("\\s")
+      assert_equal("a_\\0_bc",
+                   regex.replace("a bc",
+                                 "_\\0_",
+                                 :literal => true))
+    end
+
+    sub_test_case "eval" do
+      test "all" do
+        regex = GLib::Regex.new("1|2|3|4")
+        modified_string = regex.replace(" 4 3 2 1") do |match_info|
+          "to"
+        end
+        assert_equal(" to to to to", modified_string)
+      end
+
+      test "break" do
+        regex = GLib::Regex.new("1|2|3|4")
+        modified_string = regex.replace(" 4 3 2 1") do |match_info|
+          break "to"
+        end
+        assert_equal(" to 3 2 1", modified_string)
+      end
+    end
+  end
+
+  sub_test_case "check_replacement" do
+    test "no references" do
+      assert_true(GLib::Regex.check_replacement("foo\\n"))
+    end
+
+    test "with references" do
+      assert_true(GLib::Regex.check_replacement("\\0\\1"))
+    end
+
+    test "invalid" do
+      assert_raise(GLib::Error) do
+        GLib::Regex.check_replacement("\\")
+      end
+    end
+  end
+
+  sub_test_case "have_reference?" do
+    test "no references" do
+      assert do
+        not GLib::Regex.have_reference?("foo\\n")
+      end
+    end
+
+    test "with references" do
+      assert do
+        GLib::Regex.have_reference?("\\0\\1")
+      end
+    end
+  end
+end