glib2 3.3.2 → 3.3.3

data/lib/gnome2/rake/source-download-task.rb

@@ -1,6 +1,4 @@
-# -*- ruby -*-
-#
-# Copyright (C) 2013-2015  Ruby-GNOME2 Project Team
+# Copyright (C) 2013-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
@@ -16,86 +14,14 @@
 # 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 "open-uri"
-require "pathname"
-
-require "rake"
-
 module GNOME2
   module Rake
     class SourceDownloadTask
-      include ::Rake::DSL
-
       def initialize(package)
         @package = package
       end
 
       def define
-        namespace :source do
-          namespace :downloader do
-            task :before
-            define_download_tasks
-            download_tasks = @package.external_packages.collect do |package|
-              "source:downloader:download:#{package.name}"
-            end
-            task :download => download_tasks
-            task :after
-          end
-
-          desc "Dowanload sources"
-          task :download => [
-            "source:downloader:before",
-            "source:downloader:download",
-            "source:downloader:after",
-          ]
-        end
-      end
-
-      private
-      def define_download_tasks
-        namespace :download do
-          @package.external_packages.each do |package|
-            download_dir = @package.download_dir
-            tar_full_path = download_dir + package.archive_base_name
-
-            task :before
-            task :after
-            desc "Download #{package.label} into #{download_dir}."
-            # task package[:name] => [:before, tar_full_path.to_s, :after]
-            task package[:name] => tar_full_path.to_s
-
-            directory_path = tar_full_path.dirname
-            directory directory_path.to_s
-            file tar_full_path.to_s => directory_path.to_s do
-              archive_url = package.archive_url
-              rake_output_message "Downloading... #{archive_url}"
-              download(archive_url, tar_full_path)
-            end
-          end
-        end
-      end
-
-      def download(url, output_path)
-        OpenURI.singleton_class.class_eval do
-          alias_method :redirectable_original?, :redirectable?
-          def redirectable?(uri1, uri2)
-            redirectable_original?(uri1, uri2) or
-              (uri1.scheme.downcase == "http" and
-               uri2.scheme.downcase == "https")
-          end
-        end
-        begin
-          open(url) do |input|
-            output_path.open("wb") do |output_file|
-              output_file.print(input.read)
-            end
-          end
-        ensure
-          OpenURI.singleton_class.class_eval do
-            alias_method :redirectable?, :redirectable_original?
-            remove_method :redirectable_original?
-          end
-        end
       end
     end
   end

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

@@ -1,37 +1,15 @@
-# Copyright(C) 2012-2015 Ruby-GNOME2 Project.
+# Copyright(C) 2012-2019 Ruby-GNOME2 Project.
 #
 # This program is licenced under the same license of Ruby-GNOME2.
 
-require "open-uri"
-require "pathname"
-require "tempfile"
-require "tmpdir"
-
 module GNOME2
   module Rake
     class WindowsBinaryBuildTask
-      include ::Rake::DSL
-
       def initialize(package)
         @package = package
       end
 
       def define
-        namespace :windows do
-          namespace :builder do
-            task :before
-            define_build_tasks
-            build_tasks = build_packages.collect do |package|
-              "windows:builder:build:#{package.name}"
-            end
-            task :build => build_tasks
-            task :after
-          end
-          desc "Build Windows binaries"
-          task :build => ["windows:builder:before",
-            "windows:builder:build",
-            "windows:builder:after"]
-        end
       end
 
       def rcairo_binary_base_dir
@@ -47,417 +25,9 @@ module GNOME2
       end
 
       private
-      def define_build_tasks
-        namespace :build do
-          task :prepare
-
-          build_packages.each do |package|
-            namespace package.name do
-              task :before
-              download_task = "source:downloader:download:#{package.name}"
-              built_file = package.windows.built_file
-              if built_file
-                built_file = dist_dir + built_file
-                file built_file.to_s do
-                  ::Rake::Task["windows:builder:build:prepare"].invoke
-                  ::Rake::Task[download_task].invoke
-                  build_package_task_body(package)
-                end
-                task :build => built_file.to_s
-              else
-                task :build => [:prepare, download_task] do
-                  build_package_task_body(package)
-                end
-              end
-              task :after
-            end
-
-            prefix = "windows:builder:build:#{package.name}"
-            desc "Build #{package.label} and install it into #{dist_dir}."
-            task package.name => [
-              "#{prefix}:before",
-              "#{prefix}:build",
-              "#{prefix}:after",
-            ]
-          end
-        end
-      end
-
-      def build_package_task_body(package)
-        package_tmp_dir = @package.tmp_dir + "windows" + package.name
-        rm_rf(package_tmp_dir)
-        mkdir_p(package_tmp_dir)
-
-        tar_full_path = @package.download_dir + package.archive_base_name
-        Dir.chdir(package_tmp_dir.to_s) do
-          sh("tar", "xf", tar_full_path.to_s)
-        end
-
-        env = build_env
-        package_dir_path =
-          package_tmp_dir + package.base_name + package.base_dir_in_package
-        Dir.chdir(package_dir_path.to_s) do
-          package.windows.patches.each do |patch|
-            sh("patch -p1 < #{@package.patches_dir}/#{patch}")
-          end
-          common_make_args = []
-          common_make_args << "MAKE=make"
-          common_make_args << "GLIB_COMPILE_SCHEMAS=glib-compile-schemas"
-          if package.windows.use_cc_environment_variable?
-            common_make_args << cc_env(package)
-          end
-          add_gobject_introspection_make_args(package, common_make_args)
-          common_make_args.concat(package.windows.make_args)
-          build_make_args = common_make_args.dup
-          install_make_args = common_make_args.dup
-          if package.windows.build_concurrently?
-            make_n_jobs = ENV["MAKE_N_JOBS"]
-            build_make_args << "-j#{make_n_jobs}" if make_n_jobs
-          end
-          # build_make_args << "--debug"
-          # build_make_args << "V=1"
-          # build_make_args << "VERBOSE=1"
-          # env["GI_SCANNER_DEBUG"] = "save-temps"
-          if File.exist?("meson.build")
-            source_dir = Dir.pwd
-            build_dir = "build"
-            mkdir_p(build_dir)
-            Dir.chdir(build_dir) do
-              meson(env, package, source_dir)
-              sh(env.merge(make_args_to_env(build_make_args)),
-                 "nice", "ninja") or exit(false)
-              sh(env.merge(make_args_to_env(install_make_args)),
-                 "ninja", "install") or exit(false)
-            end
-          else
-            if File.exist?("Makefile.am") or File.exist?("Makefile.in")
-              configure(env, package)
-            else
-              cmake(env, package)
-            end
-            sh(env, "nice", "make", *build_make_args) or exit(false)
-            sh(env, "make", "install", *install_make_args) or exit(false)
-          end
-
-          package_license_dir = license_dir + package.name
-          mkdir_p(package_license_dir)
-          package_license_files = ["AUTHORS", "COPYING", "COPYING.LIB"]
-          package_license_files = package_license_files.reject do |file|
-            not File.exist?(file)
-          end
-          cp(package_license_files, package_license_dir)
-          bundled_packages = package.bundled_packages
-          bundled_packages.each do |bundled_package|
-            bundled_package_license_dir = license_dir + bundled_package[:name]
-            mkdir_p(bundled_package_license_dir)
-            license_files = bundled_package[:license_files].collect do |file|
-              File.join(bundled_package[:path], file)
-            end
-            cp(license_files, bundled_package_license_dir)
-          end
-        end
-      end
-
-      def build_env
-        path = "#{g_ir_scanner_bin_dir}:#{ENV["PATH"]}"
-        env = {
-          "GI_HOST_OS" => "nt",
-          "MSYSTEM" => "MINGW64",
-          "GREP_OPTIONS" => "--text",
-          "PATH" => path,
-          "PKG_CONFIG" => pkg_config,
-        }
-        depended_packages = @package.windows.build_dependencies
-        use_packages = [@package.name] + depended_packages
-        pkg_config_path = [rcairo_pkgconfig_path]
-        use_packages.each do |package|
-          path = "../#{package}/#{@package.windows.relative_binary_dir}/lib/pkgconfig"
-          pkg_config_path << path
-        end
-        env["PKG_CONFIG_PATH"] = pkg_config_path.collect do |path|
-          File.expand_path(path)
-        end.join(":")
-        env
-      end
-
-      def configure(env, package)
-        sh(env, "./autogen.sh") if package.windows.need_autogen?
-        if package.windows.need_autoreconf?
-          sh(env, "autoreconf", "--install", "--force")
-        end
-        sh(env, "env")
-        sh(env,
-           "./configure",
-           cc_env(package),
-           dlltool_env,
-           "CPPFLAGS=#{cppflags(package)}",
-           "LDFLAGS=#{ldflags(package)}",
-           "--prefix=#{dist_dir}",
-           "--host=#{@package.windows.build_host}",
-           # "--target=#{@package.windows.build_host}",
-           # "--build=x86_64-pc-linux-gnu",
-           *package.windows.configure_args) or exit(false)
-        if package.windows.force_to_disable_deplibs_check?
-          sh(env,
-             "sed",
-             "-i",
-             "-e", "s/valid_a_lib=false/valid_a_lib=:/g",
-             "libtool")
-        end
-      end
-
-      def meson(env, package, source_dir)
-        cross_file = Tempfile.new("meson-cross-file")
-        cross_file.puts(<<-CROSS_FILE)
-[host_machine]
-system = 'windows'
-cpu_family = '#{meson_cpu_family}'
-cpu = '#{meson_cpu}'
-endian = 'littel'
-
-[binaries]
-c = '/usr/bin/#{cc(package)}'
-cpp = '/usr/bin/#{cxx(package)}'
-ar = '/usr/bin/#{ar}'
-strip = '/usr/bin/#{strip}'
-dlltool = '/usr/bin/#{dlltool}'
-pkgconfig = '/usr/bin/#{pkg_config}'
-windres = '/usr/bin/#{windres}'
-exe_wrapper = 'wine'
-
-[properties]
-root = '/usr/#{@package.windows.build_host}'
-        CROSS_FILE
-        cross_file.close
-        sh(env.merge({
-                       "CPPFLAGS" => cppflags(package),
-                       "LDFLAGS" => ldflags(package),
-                     }),
-           "meson",
-           source_dir,
-           ".",
-           "--prefix=#{dist_dir}",
-           "--libdir=lib",
-           "--cross-file=#{cross_file.path}",
-           *package.windows.meson_args) or exit(false)
-      end
-
-      def meson_cpu_family
-        case @package.windows.build_architecture
-        when "x86"
-          "x86"
-        when "x86_64"
-          "x86_64"
-        end
-      end
-
-      def meson_cpu
-        case @package.windows.build_architecture
-        when "x86"
-          "i686"
-        when "x86_64"
-          "x86_64"
-        end
-      end
-
-      def cmake(env, package)
-        sh(env,
-           "cmake",
-           ".",
-           "-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
-
-      def cc_env(package)
-        "CC=#{cc(package)}"
-      end
-
-      def dlltool_env
-        "DLLTOOL=#{dlltool}"
-      end
-
-      def build_packages
-        packages = @package.external_packages.select do |package|
-          package.windows.build?
-        end
-        # For backward compatibility
-        packages + @package.windows.build_packages
-      end
-
-      def dist_dir
-        @package.windows.absolute_binary_dir
-      end
-
-      def license_dir
-        dist_dir + "share" + "license"
-      end
-
-      def glib2_include_path
-        "#{glib2_binary_base_dir}/include"
-      end
-
-      def glib2_lib_path
-        "#{glib2_binary_base_dir}/lib"
-      end
-
       def rcairo_dir
         @package.project_root_dir.parent + "rcairo"
       end
-
-      def rcairo_pkgconfig_path
-        "#{rcairo_binary_base_dir}/lib/pkgconfig"
-      end
-
-      def rcairo_include_path
-        "#{rcairo_binary_base_dir}/include"
-      end
-
-      def rcairo_lib_path
-        "#{rcairo_binary_base_dir}/lib"
-      end
-
-      def cc(package)
-        cc_command_line = [
-          "#{@package.windows.build_host}-gcc",
-          *package.windows.cc_args,
-        ]
-        cc_command_line.compact.join(" ")
-      end
-
-      def cxx(package)
-        cxx_command_line = [
-          "#{@package.windows.build_host}-g++",
-        ]
-        cxx_command_line.compact.join(" ")
-      end
-
-      def ar
-        "#{@package.windows.build_host}-ar"
-      end
-
-      def strip
-        "#{@package.windows.build_host}-strip"
-      end
-
-      def dlltool
-        "#{@package.windows.build_host}-dlltool"
-      end
-
-      def pkg_config
-        "#{@package.windows.build_host}-pkg-config"
-      end
-
-      def windres
-        "#{@package.windows.build_host}-windres"
-      end
-
-      def g_ir_scanner_bin_dir
-        "#{@package.project_root_dir}/gobject-introspection/" +
-          "#{@package.native.relative_binary_dir}/bin"
-      end
-
-      def g_ir_scanner
-        "#{g_ir_scanner_bin_dir}/g-ir-scanner"
-      end
-
-      def cppflags(package)
-        include_paths = package.windows.include_paths
-        if @package.windows.build_dependencies.include?("glib2")
-          include_paths += [glib2_include_path]
-        end
-        include_paths += [
-          rcairo_include_path,
-          dist_dir + 'include',
-        ]
-        cppflags = include_paths.collect do |path|
-          "-I#{path}"
-        end
-        cppflags.join(" ")
-      end
-
-      def ldflags(package)
-        library_paths = package.windows.library_paths
-        if @package.windows.build_dependencies.include?("glib2")
-          library_paths += [glib2_lib_path]
-        end
-        library_paths += [
-          rcairo_lib_path,
-          dist_dir + 'lib',
-        ]
-        ldflags = library_paths.collect do |path|
-          "-L#{path}"
-        end
-        ldflags.join(" ")
-      end
-
-      def cmake_root_paths
-        paths = [
-          "/usr/#{@package.windows.build_host}",
-          rcairo_binary_base_dir.to_path,
-        ]
-        @package.windows.build_dependencies.each do |package|
-          paths << binary_base_dir(package).to_path
-        end
-        paths
-      end
-
-      def make_args_to_env(make_args)
-        env = {}
-        make_args.each do |arg|
-          key, value = arg.split("=", 2)
-          env[key] = value
-        end
-        env
-      end
-
-      def add_gobject_introspection_make_args(package, common_make_args)
-        return unless use_gobject_introspection?(package)
-
-        introspection_scanner = "INTROSPECTION_SCANNER=#{g_ir_scanner}"
-        common_make_args << introspection_scanner
-
-
-        dependencies = [
-          "gobject-introspection",
-          @package.name,
-        ]
-        dependencies += @package.windows.gobject_introspection_dependencies
-
-        gi_base_dir = binary_base_dir("gobject-introspection")
-        introspection_compiler = "INTROSPECTION_COMPILER="
-        introspection_compiler << "#{gi_base_dir}/bin/g-ir-compiler.exe"
-        introspection_compiler_args = ""
-        dependencies.each do |dependent_package|
-          gir_dir = "#{binary_base_dir(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 << dlltool_env
-
-        data_dirs = dependencies.collect do |dependent_package|
-          "#{binary_base_dir(dependent_package)}/share"
-        end
-        common_make_args << "XDG_DATA_DIRS=#{data_dirs.join(File::PATH_SEPARATOR)}"
-      end
-
-      def use_gobject_introspection?(package)
-        return false unless package.windows.use_gobject_introspection?
-        @package.windows.build_dependencies.include?("gobject-introspection")
-      end
     end
   end
 end