glib2 2.2.5 → 3.0.1

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

@@ -64,7 +64,7 @@ module GNOME2
                 task :build => built_file.to_s
               else
                 task :build => [download_task] do
-                  build_patckage_task_body(package)
+                  build_package_task_body(package)
                 end
               end
             end

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

@@ -163,23 +163,13 @@ class GNOME2WindowsBinaryBuildTask
   end
 
   def cmake(package)
-    toolchain_cmake_path = "toolchain.cmake"
-    File.open(toolchain_cmake_path, "w") do |toolchain|
-      toolchain.puts(<<-CMAKE)
-SET(CMAKE_SYSTEM_NAME Windows)
-SET(MSVC_CXX_ARCHITECTURE_ID #{@package.windows.build_architecture})
-SET(CMAKE_SYSTEM_PROCESSOR #{@package.windows.build_architecture})
-
-SET(CMAKE_C_COMPILER #{@package.windows.build_host}-gcc)
-SET(CMAKE_CXX_COMPILER #{@package.windows.build_host}-g++)
-SET(CMAKE_RC_COMPILER #{@package.windows.build_host}-windres)
-
-SET(CMAKE_FIND_ROOT_PATH #{cmake_root_paths.join(" ")})
-      CMAKE
-    end
     sh("cmake",
        ".",
-       "-DCMAKE_TOOLCHAIN_FILE=#{toolchain_cmake_path}",
+       "-DCMAKE_INSTALL_PREFIX=#{dist_dir}",
+       "-DCMAKE_SYSTEM_NAME=Windows",
+       "-DCMAKE_SYSTEM_PROCESSOR=#{@package.windows.build_architecture}",
+       "-DCMAKE_C_COMPILER=#{cc(package)}",
+       "-DCMAKE_CXX_COMPILER=#{cxx(package)}",
        *package.windows.cmake_args) or exit(false)
   end
 
@@ -244,6 +234,13 @@ SET(CMAKE_FIND_ROOT_PATH #{cmake_root_paths.join(" ")})
     cc_command_line.compact.join(" ")
   end
 
+  def cxx(package)
+    cxx_command_line = [
+      "#{@package.windows.build_host}-g++",
+    ]
+    cxx_command_line.compact.join(" ")
+  end
+
   def cppflags(package)
     include_paths = package.windows.include_paths
     if @package.windows.build_dependencies.include?("glib2")

data/lib/mkmf-gnome2.rb

@@ -30,7 +30,7 @@ end
 
 def enable_debug_build_flag(flags)
   if gcc?
-    debug_option_pattern = /(^|\s)?-g\d?(\s|$)?/
+    debug_option_pattern = /(^|\s)-g\d?(\s|$)/
     if debug_option_pattern =~ flags
       flags.gsub(debug_option_pattern, '\\1-g3\\2')
     else
@@ -109,10 +109,13 @@ if ENV['GTK_BASEPATH'] and /cygwin/ !~ RUBY_PLATFORM
   $CFLAGS += " -I#{include_path} "
 end
 
+def windows_platform?
+  /cygwin|mingw|mswin/ === RUBY_PLATFORM
+end
+
 def setup_windows(target_name, base_dir=nil)
   checking_for(checking_message("Windows")) do
-    case RUBY_PLATFORM
-    when /cygwin|mingw|mswin/
+    if windows_platform?
       import_library_name = "libruby-#{target_name}.a"
       $DLDFLAGS << " -Wl,--out-implib=#{import_library_name}"
       $cleanfiles << import_library_name
@@ -189,8 +192,7 @@ def add_depend_package_path(target_name, target_source_dir, target_build_dir)
     $INCFLAGS = "-I#{target_source_dir} #{$INCFLAGS}"
   end
 
-  case RUBY_PLATFORM
-  when /cygwin|mingw|mswin/
+  if windows_platform?
     target_base_dir = Pathname.new(target_source_dir).parent.parent
     target_binary_base_dir = target_base_dir + "vendor" + "local"
     if target_binary_base_dir.exist?
@@ -205,8 +207,7 @@ def add_depend_package_path(target_name, target_source_dir, target_build_dir)
     $INCFLAGS = "-I#{target_build_dir} #{$INCFLAGS}"
   end
 
-  case RUBY_PLATFORM
-  when /cygwin|mingw|mswin/
+  if windows_platform?
     library_base_name = "ruby-#{target_name.gsub(/-/, '_')}"
     case RUBY_PLATFORM
     when /cygwin|mingw/
@@ -450,12 +451,10 @@ def glib_mkenums(prefix, files, g_type_prefix, include_files, options={})
 end
 
 def check_cairo(options={})
-  is_windows = (/mingw|cygwin|mswin/ === RUBY_PLATFORM)
-
   rcairo_source_dir = options[:rcairo_source_dir]
   if rcairo_source_dir.nil?
     suffix = nil
-    if is_windows
+    if windows_platform?
       case RUBY_PLATFORM
       when /\Ax86-mingw/
         suffix = "win32"
@@ -480,7 +479,7 @@ def check_cairo(options={})
   end
 
   unless rcairo_source_dir.nil?
-    if is_windows
+    if windows_platform?
       options = {}
       build_dir = "tmp/#{RUBY_PLATFORM}/cairo/#{RUBY_VERSION}"
       if File.exist?(File.join(rcairo_source_dir, build_dir))

data/test/test-binding.rb

@@ -0,0 +1,97 @@
+# 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
+
+class TestGLibBinding < Test::Unit::TestCase
+  include GLibTestUtils
+
+  class DataObject < GLib::Object
+    type_register
+
+    install_property(GLib::Param::Int.new("source", # name
+                                          "Source", # nick
+                                          "The source data", # blurb
+                                          0,     # min
+                                          100,   # max
+                                          0,     # default
+                                          GLib::Param::READABLE |
+                                          GLib::Param::WRITABLE))
+    install_property(GLib::Param::Int.new("target", # name
+                                          "Target", # nick
+                                          "The target data", # blurb
+                                          0,     # min
+                                          100,   # max
+                                          0,     # default
+                                          GLib::Param::READABLE |
+                                          GLib::Param::WRITABLE))
+
+    attr_reader :source, :target
+    def initialize
+      @source = 0
+      @target = 0
+      super
+    end
+
+    def source=(value)
+      @source = value
+      notify("source")
+    end
+
+    def target=(value)
+      @target = value
+      notify("target")
+    end
+  end
+
+  setup do
+    only_glib_version(2, 26, 0)
+  end
+
+  setup do
+    @source = DataObject.new
+    @target = DataObject.new
+    @binding = @source.bind_property("source", @target, "target", :default)
+  end
+
+  test "#source" do
+    assert_equal(@source, @binding.source)
+  end
+
+  test "#source_property" do
+    assert_equal("source", @binding.source_property)
+  end
+
+  test "#target" do
+    assert_equal(@target, @binding.target)
+  end
+
+  test "#target_property" do
+    assert_equal("target", @binding.target_property)
+  end
+
+  test "#flags" do
+    assert_equal(GLib::BindingFlags::DEFAULT, @binding.flags)
+  end
+
+  test "#unbind" do
+    only_glib_version(2, 38, 0)
+    assert_equal(0, @target.target)
+    @source.source = 10
+    assert_equal(10, @target.target)
+    @binding.unbind
+    @source.source = 20
+    assert_equal(10, @target.target)
+  end
+end

data/test/test-variant-type.rb

@@ -0,0 +1,357 @@
+# 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
+
+class TestGLibVariantType < Test::Unit::TestCase
+  include GLibTestUtils
+
+  sub_test_case "constants" do
+    test "BOOLEAN" do
+      assert_equal("b", GLib::VariantType::BOOLEAN.to_s)
+    end
+
+    test "BYTE" do
+      assert_equal("y", GLib::VariantType::BYTE.to_s)
+    end
+
+    test "INT16" do
+      assert_equal("n", GLib::VariantType::INT16.to_s)
+    end
+
+    test "UINT16" do
+      assert_equal("q", GLib::VariantType::UINT16.to_s)
+    end
+
+    test "INT32" do
+      assert_equal("i", GLib::VariantType::INT32.to_s)
+    end
+
+    test "UINT32" do
+      assert_equal("u", GLib::VariantType::UINT32.to_s)
+    end
+
+    test "INT64" do
+      assert_equal("x", GLib::VariantType::INT64.to_s)
+    end
+
+    test "UINT64" do
+      assert_equal("t", GLib::VariantType::UINT64.to_s)
+    end
+
+    test "HANDLE" do
+      assert_equal("h", GLib::VariantType::HANDLE.to_s)
+    end
+
+    test "DOUBLE" do
+      assert_equal("d", GLib::VariantType::DOUBLE.to_s)
+    end
+
+    test "STRING" do
+      assert_equal("s", GLib::VariantType::STRING.to_s)
+    end
+
+    test "OBJECT_PATH" do
+      assert_equal("o", GLib::VariantType::OBJECT_PATH.to_s)
+    end
+
+    test "SIGNATURE" do
+      assert_equal("g", GLib::VariantType::SIGNATURE.to_s)
+    end
+
+    test "VARIANT" do
+      assert_equal("v", GLib::VariantType::VARIANT.to_s)
+    end
+
+    test "ANY" do
+      assert_equal("*", GLib::VariantType::ANY.to_s)
+    end
+
+    test "BASIC" do
+      assert_equal("?", GLib::VariantType::BASIC.to_s)
+    end
+
+    test "MAYBE" do
+      assert_equal("m*", GLib::VariantType::MAYBE.to_s)
+    end
+
+    test "ARRAY" do
+      assert_equal("a*", GLib::VariantType::ARRAY.to_s)
+    end
+
+    test "TUPLE" do
+      assert_equal("r", GLib::VariantType::TUPLE.to_s)
+    end
+
+    test "UNIT" do
+      assert_equal("()", GLib::VariantType::UNIT.to_s)
+    end
+
+    test "DICT_ENTRY" do
+      assert_equal("{?*}", GLib::VariantType::DICT_ENTRY.to_s)
+    end
+
+    test "DICTIONARY" do
+      assert_equal("a{?*}", GLib::VariantType::DICTIONARY.to_s)
+    end
+
+    test "STRING_ARRAY" do
+      assert_equal("as", GLib::VariantType::STRING_ARRAY.to_s)
+    end
+
+    test "OBJECT_PATH_ARRAY" do
+      assert_equal("ao", GLib::VariantType::OBJECT_PATH_ARRAY.to_s)
+    end
+
+    test "BYTESTRING" do
+      assert_equal("ay", GLib::VariantType::BYTESTRING.to_s)
+    end
+
+    test "BYTESTRING_ARRAY" do
+      assert_equal("aay", GLib::VariantType::BYTESTRING_ARRAY.to_s)
+    end
+
+    test "VARDICT" do
+      assert_equal("a{sv}", GLib::VariantType::VARDICT.to_s)
+    end
+  end
+
+  sub_test_case ".valid?" do
+    test "valid" do
+      assert do
+        GLib::VariantType.valid?("s")
+      end
+    end
+
+    test "invalid" do
+      assert do
+        !GLib::VariantType.valid?("X")
+      end
+    end
+  end
+
+  sub_test_case ".scan" do
+    test "found" do
+      assert_equal("X", GLib::VariantType.scan("sX"))
+    end
+
+    test "not found" do
+      assert_nil(GLib::VariantType.scan("X"))
+    end
+  end
+
+  sub_test_case "#initialize" do
+    test "invalid" do
+      assert_raise(ArgumentError.new("invalid type string: \"X\"")) do
+        GLib::VariantType.new("X")
+      end
+    end
+  end
+
+  test "#to_s" do
+    variant_type = GLib::VariantType.new("s")
+    assert_equal("s", variant_type.to_s)
+  end
+
+  sub_test_case "#definite?" do
+    test "definite" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        variant_type.definite?
+      end
+    end
+
+    test "not definite" do
+      variant_type = GLib::VariantType.new("?")
+      assert do
+        !variant_type.definite?
+      end
+    end
+  end
+
+  sub_test_case "#container?" do
+    test "container" do
+      variant_type = GLib::VariantType.new("a*")
+      assert do
+        variant_type.container?
+      end
+    end
+
+    test "not container" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.container?
+      end
+    end
+  end
+
+  sub_test_case "#basic?" do
+    test "basic" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        variant_type.basic?
+      end
+    end
+
+    test "not basic" do
+      variant_type = GLib::VariantType.new("as")
+      assert do
+        !variant_type.basic?
+      end
+    end
+  end
+
+  sub_test_case "#maybe?" do
+    test "maybe" do
+      variant_type = GLib::VariantType.new("ms")
+      assert do
+        variant_type.maybe?
+      end
+    end
+
+    test "not maybe" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.maybe?
+      end
+    end
+  end
+
+  sub_test_case "#array?" do
+    test "array" do
+      variant_type = GLib::VariantType.new("as")
+      assert do
+        variant_type.array?
+      end
+    end
+
+    test "not array" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.array?
+      end
+    end
+  end
+
+  sub_test_case "#tuple?" do
+    test "tuple" do
+      variant_type = GLib::VariantType.new("(s)")
+      assert do
+        variant_type.tuple?
+      end
+    end
+
+    test "not tuple" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.tuple?
+      end
+    end
+  end
+
+  sub_test_case "#dict_entry?" do
+    test "dictionary entry" do
+      variant_type = GLib::VariantType.new("{ss}")
+      assert do
+        variant_type.dict_entry?
+      end
+    end
+
+    test "not dictionary entry" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.dict_entry?
+      end
+    end
+  end
+
+  sub_test_case "#variant?" do
+    test "variant" do
+      variant_type = GLib::VariantType.new("v")
+      assert do
+        variant_type.variant?
+      end
+    end
+
+    test "not variant" do
+      variant_type = GLib::VariantType.new("s")
+      assert do
+        !variant_type.variant?
+      end
+    end
+  end
+
+  sub_test_case "#==" do
+    test "same" do
+      variant_type = GLib::VariantType.new("s")
+      assert_equal(variant_type,
+                   variant_type)
+    end
+
+    test "equivalence" do
+      assert_equal(GLib::VariantType.new("s"),
+                   GLib::VariantType.new("s"))
+    end
+
+    test "not VariantType" do
+      assert_not_equal(GLib::VariantType.new("s"),
+                       "s")
+    end
+  end
+
+  sub_test_case "#hash and #eql?" do
+    test "Hash key" do
+      hash = {
+        GLib::VariantType.new("s") => :s,
+      }
+      assert_equal(:s, hash[GLib::VariantType.new("s")])
+    end
+  end
+
+  sub_test_case "#is_subtype_of?" do
+    test "subtype" do
+      string = GLib::VariantType.new("s")
+      basic = GLib::VariantType.new("?")
+      assert do
+        string.is_subtype_of?(basic)
+      end
+    end
+
+    test "not subtype" do
+      string = GLib::VariantType.new("s")
+      int32 = GLib::VariantType.new("i")
+      assert do
+        !string.is_subtype_of?(int32)
+      end
+    end
+  end
+
+  sub_test_case "#element" do
+    test "array" do
+      assert_equal(GLib::VariantType.new("s"),
+                   GLib::VariantType.new("as").element)
+    end
+
+    test "maybe" do
+      assert_equal(GLib::VariantType.new("s"),
+                   GLib::VariantType.new("ms").element)
+    end
+
+    test "unexpected" do
+      assert_raise(ArgumentError.new("must be array or maybe type: <s>")) do
+        GLib::VariantType.new("s").element
+      end
+    end
+  end
+end