glib2 3.0.7-x86-mingw32 → 3.0.8-x86-mingw32

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

data/vendor/local/bin/gettext.sh

@@ -49,7 +49,7 @@ if test -z "${ZSH_VERSION+set}"; then
     gettext.sh | */gettext.sh | *\\gettext.sh)
       progname=$0
       package=gettext-runtime
-      version=0.19.5
+      version=0.19.7
       # func_usage
       # outputs to stdout the --help usage message.
       func_usage ()

data/vendor/local/bin/glib-gettextize

@@ -37,7 +37,7 @@ Usage: glib-gettextize [OPTION]... [package-dir]
   -f, --force          force writing of new files even if old exist
 Report bugs to http://bugzilla.gnome.org/."
 package=glib
-version=2.44.1
+version=2.48.0
 try_ln_s=:
 
 # Directory where the sources are stored.

data/vendor/local/bin/glib-mkenums

@@ -129,7 +129,7 @@ sub parse_entries {
 }
 
 sub version {
-    print "glib-mkenums version glib-2.44.1\n";
+    print "glib-mkenums version glib-2.48.0\n";
     print "glib-mkenums comes with ABSOLUTELY NO WARRANTY.\n";
     print "You may redistribute copies of glib-mkenums under the terms of\n";
     print "the GNU General Public License which can be found in the\n";
@@ -148,7 +148,7 @@ sub usage {
     print "  --fhead <text>               Output file header\n";
     print "  --fprod <text>               Per input file production\n";
     print "  --ftail <text>               Output file trailer\n";
-    print "  --eprod <text>               Per enum text (produced prior to value itarations)\n";
+    print "  --eprod <text>               Per enum text (produced prior to value iterations)\n";
     print "  --vhead <text>               Value header, produced before iterating over enum values\n";
     print "  --vprod <text>               Value text, produced for each enum value\n";
     print "  --vtail <text>               Value tail, produced after iterating over enum values\n";