pkg-config 1.4.0 → 1.6.5

data/lib/pkg-config.rb

@@ -1,4 +1,4 @@
-# Copyright 2008-2019 Kouhei Sutou <kou@cozmixng.org>
+# Copyright (C) 2008-2025  Sutou Kouhei <kou@cozmixng.org>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -14,18 +14,134 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
-begin
-  require "pkg-config/version"
-rescue LoadError
-end
-
+require "pathname"
 require "rbconfig"
+require "shellwords"
+
+module PKGConfig
+  VERSION = "1.6.5"
+
+  @@paths = []
+  @@override_variables = {}
+
+  module_function
+  def add_path(path)
+    @@paths << path
+  end
+
+  def set_override_variable(key, value)
+    @@override_variables[key] = value
+  end
+
+  def msvc?
+    /mswin/.match(RUBY_PLATFORM) and /^cl\b/.match(RbConfig::CONFIG["CC"])
+  end
+
+  def package_config(package)
+    PackageConfig.new(package,
+                      :msvc_syntax => msvc?,
+                      :override_variables => @@override_variables,
+                      :paths => @@paths)
+  end
+
+  def exist?(pkg)
+    package_config(pkg).exist?
+  end
+
+  def libs(pkg)
+    package_config(pkg).libs
+  end
 
-require 'shellwords'
-require 'English'
-require 'pathname'
+  def libs_only_l(pkg)
+    package_config(pkg).libs_only_l
+  end
+
+  def libs_only_L(pkg)
+    package_config(pkg).libs_only_L
+  end
+
+  def cflags(pkg)
+    package_config(pkg).cflags
+  end
+
+  def cflags_only_I(pkg)
+    package_config(pkg).cflags_only_I
+  end
+
+  def cflags_only_other(pkg)
+    package_config(pkg).cflags_only_other
+  end
+
+  def modversion(pkg)
+    package_config(pkg).version
+  end
+
+  def description(pkg)
+    package_config(pkg).description
+  end
+
+  def variable(pkg, name)
+    package_config(pkg).variable(name)
+  end
+
+  def check_version?(pkg, major=0, minor=0, micro=0)
+    return false unless exist?(pkg)
+    ver = modversion(pkg).split(".").collect {|item| item.to_i}
+    (0..2).each {|i| ver[i] = 0 unless ver[i]}
+
+    (ver[0] > major ||
+     (ver[0] == major && ver[1] > minor) ||
+     (ver[0] == major && ver[1] == minor &&
+      ver[2] >= micro))
+  end
+
+  def have_package(pkg, major=nil, minor=0, micro=0)
+    message = "#{pkg}"
+    unless major.nil?
+      message << " version (>= #{major}.#{minor}.#{micro})"
+    end
+    major ||= 0
+    result = checking_for(checking_message(message), "%s") do
+      if check_version?(pkg, major, minor, micro)
+        "yes (#{modversion(pkg)})"
+      else
+        if exist?(pkg)
+          "no (#{modversion(pkg)})"
+        else
+          "no (nonexistent)"
+        end
+      end
+    end
+    enough_version = result.start_with?("yes")
+    if enough_version
+      libraries = libs_only_l(pkg)
+      dldflags = libs(pkg)
+      dldflags = (Shellwords.shellwords(dldflags) -
+                  Shellwords.shellwords(libraries))
+      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(" ")
+      $libs   += " " + libraries
+      if /mswin/ =~ RUBY_PLATFORM
+        $DLDFLAGS += " " + dldflags
+      else
+        $LDFLAGS += " " + dldflags
+      end
+      $CFLAGS += " " + cflags_only_other(pkg)
+      if defined?($CXXFLAGS)
+        $CXXFLAGS += " " + cflags_only_other(pkg)
+      end
+      $INCFLAGS += " " + cflags_only_I(pkg)
+    end
+    enough_version
+  end
+end
 
 class PackageConfig
+  class Error < StandardError
+  end
+
+  class NotFoundError < Error
+  end
+
   SEPARATOR = File::PATH_SEPARATOR
 
   class << self
@@ -39,6 +155,11 @@ class PackageConfig
       @native_pkg_config_prefix ||= compute_native_pkg_config_prefix
     end
 
+    @default_path = nil
+    def default_path
+      @default_path ||= compute_default_path
+    end
+
     @custom_override_variables = nil
     def custom_override_variables
       @custom_override_variables ||= with_config("override-variables", "")
@@ -47,6 +168,7 @@ class PackageConfig
     def clear_configure_args_cache
       @native_pkg_config = nil
       @native_pkg_config_prefix = nil
+      @default_path = nil
       @custom_override_variables = nil
     end
 
@@ -61,18 +183,25 @@ class PackageConfig
 
     def guess_native_pkg_config
       exeext = RbConfig::CONFIG["EXEEXT"]
-      default_pkg_config = ENV["PKG_CONFIG"] || "pkg-config#{exeext}"
-      pkg_config = with_config("pkg-config", default_pkg_config)
-      pkg_config = Pathname.new(pkg_config)
-      unless pkg_config.absolute?
-        found_pkg_config = search_executable_from_path(pkg_config)
-        pkg_config = found_pkg_config if found_pkg_config
-      end
-      unless pkg_config.absolute?
-        found_pkg_config = search_pkg_config_by_dln_find_exe(pkg_config)
-        pkg_config = found_pkg_config if found_pkg_config
+      candidates = [
+        with_config("pkg-config"),
+        ENV["PKG_CONFIG"],
+        "pkgconf#{exeext}",
+        "pkg-config#{exeext}",
+      ].compact
+      candidates.each do |pkg_config|
+        pkg_config = Pathname.new(pkg_config)
+        return pkg_config if pkg_config.absolute? and pkg_config.exist?
+        unless pkg_config.absolute?
+          found_pkg_config = search_executable_from_path(pkg_config)
+          return found_pkg_config if found_pkg_config
+        end
+        unless pkg_config.absolute?
+          found_pkg_config = search_pkg_config_by_dln_find_exe(pkg_config)
+          return found_pkg_config if found_pkg_config
+        end
       end
-      pkg_config
+      Pathname.new(candidates[0])
     end
 
     def search_executable_from_path(name)
@@ -133,6 +262,129 @@ class PackageConfig
         pkg_config_prefix
       end
     end
+
+    def compute_default_path
+      default_paths = nil
+      if native_pkg_config
+        pc_path = run_command(native_pkg_config.to_s,
+                              "--variable=pc_path",
+                              "pkg-config")
+        if pc_path
+          default_paths = pc_path.strip.split(SEPARATOR)
+          default_paths = nil if default_paths.empty?
+        end
+      end
+      if default_paths.nil?
+        arch_depended_path = Dir.glob("/usr/lib/*/pkgconfig")
+        default_paths = []
+        pkg_config_prefix = native_pkg_config_prefix
+        if pkg_config_prefix
+          pkg_config_arch_depended_paths =
+            Dir.glob((pkg_config_prefix + "lib/*/pkgconfig").to_s)
+          default_paths.concat(pkg_config_arch_depended_paths)
+          default_paths << (pkg_config_prefix + "lib64/pkgconfig").to_s
+          default_paths << (pkg_config_prefix + "libx32/pkgconfig").to_s
+          default_paths << (pkg_config_prefix + "lib/pkgconfig").to_s
+          default_paths << (pkg_config_prefix + "libdata/pkgconfig").to_s
+          default_paths << (pkg_config_prefix + "share/pkgconfig").to_s
+        end
+        conda_prefix = ENV["CONDA_PREFIX"]
+        if conda_prefix
+          default_paths << File.join(conda_prefix, "lib", "pkgconfig")
+          default_paths << File.join(conda_prefix, "share", "pkgconfig")
+        end
+        default_paths << "/usr/local/lib64/pkgconfig"
+        default_paths << "/usr/local/libx32/pkgconfig"
+        default_paths << "/usr/local/lib/pkgconfig"
+        default_paths << "/usr/local/libdata/pkgconfig"
+        default_paths << "/usr/local/share/pkgconfig"
+        default_paths << "/opt/local/lib/pkgconfig"
+        default_paths.concat(arch_depended_path)
+        default_paths << "/usr/lib64/pkgconfig"
+        default_paths << "/usr/libx32/pkgconfig"
+        default_paths << "/usr/lib/pkgconfig"
+        default_paths << "/usr/libdata/pkgconfig"
+        default_paths << "/usr/X11R6/lib/pkgconfig"
+        default_paths << "/usr/X11R6/share/pkgconfig"
+        default_paths << "/usr/X11/lib/pkgconfig"
+        default_paths << "/opt/X11/lib/pkgconfig"
+        default_paths << "/usr/share/pkgconfig"
+      end
+      if Object.const_defined?(:RubyInstaller)
+        mingw_bin_path = RubyInstaller::Runtime.msys2_installation.mingw_bin_path
+        mingw_pkgconfig_path = Pathname.new(mingw_bin_path) + "../lib/pkgconfig"
+        default_paths.unshift(mingw_pkgconfig_path.cleanpath.to_s)
+      end
+      libdir = ENV["PKG_CONFIG_LIBDIR"]
+      default_paths.unshift(libdir) if libdir
+
+      paths = []
+      if /-darwin\d[\d\.]*\z/ =~ RUBY_PLATFORM and
+        /\A(\d+\.\d+)/ =~ run_command("sw_vers", "-productVersion")
+        mac_os_version = $1
+        homebrew_repository_candidates = []
+        if pkg_config_prefix
+          brew_path = pkg_config_prefix + "bin" + "brew"
+          if brew_path.exist?
+            homebrew_repository = run_command(brew_path.to_s, "--repository")
+            if homebrew_repository
+              homebrew_repository_candidates <<
+                Pathname.new(homebrew_repository.strip)
+            end
+          else
+            homebrew_repository_candidates << pkg_config_prefix + "Homebrew"
+            homebrew_repository_candidates << pkg_config_prefix
+          end
+        end
+        brew = search_executable_from_path("brew")
+        if brew
+          homebrew_repository = run_command("brew", "--repository")
+          if homebrew_repository
+            homebrew_repository_candidates <<
+              Pathname(homebrew_repository.strip)
+          end
+          homebrew_prefix = run_command("brew", "--prefix")
+          if homebrew_prefix
+            homebrew_repository_candidates <<
+              Pathname(homebrew_prefix.strip)
+          end
+        end
+        homebrew_repository_candidates.uniq.each do |candidate|
+          mac_pkgconfig_base_path =
+            candidate + "Library/Homebrew/os/mac/pkgconfig"
+          mac_pkgconfig_path = mac_pkgconfig_base_path + mac_os_version
+          unless mac_pkgconfig_path.exist?
+            mac_pkgconfig_path =
+              mac_pkgconfig_base_path + mac_os_version.gsub(/\.\d+\z/, "")
+          end
+          paths << mac_pkgconfig_path.to_s if mac_pkgconfig_path.exist?
+
+          pkgconfig_path = candidate + "lib/pkgconfig"
+          paths << pkgconfig_path.to_s if pkgconfig_path.exist?
+        end
+      end
+      paths.concat(default_paths)
+      [
+        with_config("pkg-config-path") || ENV["PKG_CONFIG_PATH"],
+        *paths,
+      ].compact.join(SEPARATOR)
+    end
+
+    def run_command(*command_line)
+      IO.pipe do |input, output|
+        begin
+          pid = spawn(*command_line,
+                      out: output,
+                      err: File::NULL)
+          output.close
+          _, status = Process.waitpid2(pid)
+          return nil unless status.success?
+          input.read
+        rescue SystemCallError
+          nil
+        end
+      end
+    end
   end
 
   attr_reader :name
@@ -149,8 +401,10 @@ class PackageConfig
       @name = name
     end
     @options = options
-    path = @options[:path] || ENV["PKG_CONFIG_PATH"]
-    @paths = [path, guess_default_path].compact.join(SEPARATOR).split(SEPARATOR)
+    @paths = [
+      @options[:path],
+      self.class.default_path,
+    ].compact.join(SEPARATOR).split(SEPARATOR)
     @paths.unshift(*(@options[:paths] || []))
     @paths = normalize_paths(@paths)
     @msvc_syntax = @options[:msvc_syntax]
@@ -161,6 +415,14 @@ class PackageConfig
     @override_variables = default_override_variables.merge(@override_variables)
   end
 
+  def eql?(other)
+    other.is_a?(self.class) and @name == other.name
+  end
+
+  def hash
+    @name.hash
+  end
+
   def exist?
     not pc_path.nil?
   end
@@ -175,7 +437,7 @@ class PackageConfig
 
   def cflags
     path_flags, other_flags = collect_cflags
-    (other_flags + path_flags).join(" ")
+    (path_flags + other_flags).join(" ")
   end
 
   def cflags_only_I
@@ -187,26 +449,25 @@ class PackageConfig
   end
 
   def libs
-    path_flags, other_flags = collect_libs
-    (path_flags + other_flags).join(" ")
+    collect_libs.join(" ")
   end
 
   def libs_only_l
-    collect_libs[1].find_all do |arg|
+    collect_libs.find_all do |arg|
       if @msvc_syntax
-        /\.lib\z/ =~ arg
+        arg.end_with?(".lib")
       else
-        /\A-l/ =~ arg
+        arg.start_with?("-l")
       end
     end.join(" ")
   end
 
   def libs_only_L
-    collect_libs[0].find_all do |arg|
+    collect_libs.find_all do |arg|
       if @msvc_syntax
-        /\A\/libpath:/ =~ arg
+        arg.start_with?("/libpath:")
       else
-        /\A-L/ =~ arg
+        arg.start_with?("-L")
       end
     end.join(" ")
   end
@@ -250,37 +511,31 @@ class PackageConfig
   end
 
   def collect_requires(&block)
-    packages = []
-    targets = yield(self)
-    targets.each do |name|
-      package = self.class.new(name, @options)
-      packages << package
-      packages.concat(package.collect_requires(&block))
-    end
-    packages_without_self = packages.reject do |package|
-      package.name == @name
-    end
-    packages_without_self.uniq do |package|
-      package.name
+    dependencies = {}
+    pending_packages = yield(self).collect {|name| self.class.new(name, @options)}
+    until pending_packages.empty?
+      package = pending_packages.shift
+      next if dependencies.key?(package)
+      dependencies[package] = true
+      targets = yield(package)
+      targets.each do |name|
+        require_package = self.class.new(name, @options)
+        pending_packages.push(require_package)
+      end
     end
+    dependencies.keys
   end
 
   private
-  def sort_packages(packages)
-    packages.sort_by.with_index do |package, i|
-      [package.path_position, i]
-    end
-  end
-
   def collect_cflags
-    target_packages = sort_packages([self, *all_required_packages])
+    target_packages = [self, *all_required_packages]
     cflags_set = []
     target_packages.each do |package|
       cflags_set << package.declaration("Cflags")
     end
     all_cflags = normalize_cflags(Shellwords.split(cflags_set.join(" ")))
     path_flags, other_flags = all_cflags.partition {|flag| /\A-I/ =~ flag}
-    path_flags = normalize_path_flags(path_flags, "-I")
+    path_flags = path_flags.collect {|flag| normalize_path_flag(flag, "-I")}
     path_flags = path_flags.reject do |flag|
       flag == "-I/usr/include"
     end
@@ -290,23 +545,22 @@ class PackageConfig
         flag.gsub(/\A-I/, "/I")
       end
     end
+    other_flags = merge_back_cflags(other_flags)
     [path_flags, other_flags]
   end
 
-  def normalize_path_flags(path_flags, flag_option)
-    return path_flags unless /-mingw32\z/ === RUBY_PLATFORM
+  def normalize_path_flag(path_flag, flag_option)
+    return path_flag unless /-mingw(?:32|-ucrt)\z/ === RUBY_PLATFORM
 
     pkg_config_prefix = self.class.native_pkg_config_prefix
-    return path_flags unless pkg_config_prefix
+    return path_flag unless pkg_config_prefix
 
     mingw_dir = pkg_config_prefix.basename.to_s
-    path_flags.collect do |path_flag|
-      path = path_flag.sub(/\A#{Regexp.escape(flag_option)}/, "")
-      path = path.sub(/\A\/#{Regexp.escape(mingw_dir)}/i) do
-        pkg_config_prefix.to_s
-      end
-      "#{flag_option}#{path}"
+    path = path_flag.sub(/\A#{Regexp.escape(flag_option)}/, "")
+    path = path.sub(/\A\/#{Regexp.escape(mingw_dir)}/i) do
+      pkg_config_prefix.to_s
     end
+    "#{flag_option}#{path}"
   end
 
   def normalize_cflags(cflags)
@@ -315,10 +569,10 @@ class PackageConfig
     begin
       loop do
         cflag = enumerator.next
-        normalized_cflags << cflag
+        normalized_cflags << cflag.dup
         case cflag
         when "-I"
-          normalized_cflags << enumerator.next
+          normalized_cflags.last << enumerator.next
         end
       end
     rescue StopIteration
@@ -326,39 +580,66 @@ class PackageConfig
     normalized_cflags
   end
 
+  # Implementing behavior compatible with pkgconf's pkgconf_fragment_copy().
+  # This is not a complete reproduction yet, but the goal is to stay compatible.
+  # https://github.com/pkgconf/pkgconf/blob/pkgconf-2.5.1/libpkgconf/fragment.c#L381-L416
+  def merge_back_cflags(cflags)
+    merge_backed_cflags = []
+    cflags.each do |cflag|
+      if mergeable_flag?(cflag)
+        # NOTE: This may be slow because this checks merge_back_cflags N times
+        # (where N is the number of mergeable flags).
+        merge_backed_cflags.delete(cflag)
+      end
+      merge_backed_cflags << cflag
+    end
+    merge_backed_cflags
+  end
+
+  def mergeable_flag?(flag)
+    return false unless flag.start_with?("-")
+    return true if flag.start_with?("-D")
+    if flag.start_with?("-W")
+      return false if flag.start_with?("-Wa,", "-Wl,", "-Wp,")
+      return true
+    end
+    false
+  end
+
   def collect_libs
-    target_packages = sort_packages(required_packages + [self])
+    target_packages = [*required_packages, self]
     libs_set = []
     target_packages.each do |package|
       libs_set << package.declaration("Libs")
     end
-    all_flags = split_lib_flags(libs_set.join(" "))
-    path_flags, other_flags = all_flags.partition {|flag| /\A-L/ =~ flag}
-    path_flags = normalize_path_flags(path_flags, "-L")
-    path_flags = path_flags.reject do |flag|
+    flags = split_lib_flags(libs_set.join(" "))
+    flags = flags.collect do |flag|
+      flag = normalize_path_flag(flag, "-L") if flag.start_with?("-L")
+      flag
+    end
+    flags = flags.reject do |flag|
       /\A-L\/usr\/lib(?:64|x32)?\z/ =~ flag
     end
-    path_flags = path_flags.uniq
+    flags = flags.uniq
     if @msvc_syntax
-      path_flags = path_flags.collect do |flag|
-        flag.gsub(/\A-L/, "/libpath:")
-      end
-      other_flags = other_flags.collect do |flag|
-        if /\A-l/ =~ flag
-          "#{$POSTMATCH}.lib"
+      flags = flags.collect do |flag|
+        if flag.start_with?("-L")
+          flag.gsub(/\A-L/, "/libpath:")
+        elsif flag.start_with?("-l")
+          "#{flag[2..-1]}.lib"
         else
           flag
         end
       end
     end
-    [path_flags, other_flags]
+    flags
   end
 
   def split_lib_flags(libs_command_line)
     all_flags = {}
     flags = []
     in_option = false
-    libs_command_line.gsub(/-([Ll]) /, '\1').split.each do |arg|
+    libs_command_line.gsub(/-([Ll]) /, "\\1").split.each do |arg|
       if in_option
         flags << arg
         in_option = false
@@ -379,26 +660,37 @@ class PackageConfig
 
   IDENTIFIER_RE = /[a-zA-Z\d_\.]+/
   def parse_pc
-    raise ".pc for #{@name} doesn't exist." unless exist?
+    raise NotFoundError, ".pc doesn't exist: <#{@name}>" unless exist?
     @variables = {}
     @declarations = {}
     File.open(pc_path) do |input|
+      current_line = +""
       input.each_line do |line|
-        line = line.gsub(/#.*/, '').strip
-        next if line.empty?
-        case line
-        when /^(#{IDENTIFIER_RE})=/
-          @variables[$1] = $POSTMATCH.strip
-        when /^(#{IDENTIFIER_RE}):/
-          @declarations[$1] = $POSTMATCH.strip
+        if line.dup.force_encoding("UTF-8").valid_encoding?
+          line.force_encoding("UTF-8")
+        end
+        line = line.gsub(/#.*/, "").strip
+        if line.end_with?("\\")
+          current_line += line[0..-2]
+          next
         end
+        current_line += line
+        case current_line
+        when /^(#{IDENTIFIER_RE})\s*=\s*/
+          match = Regexp.last_match
+          @variables[match[1]] = match.post_match.strip
+        when /^(#{IDENTIFIER_RE})\s*:\s*/
+          match = Regexp.last_match
+          @declarations[match[1]] = match.post_match.strip
+        end
+        current_line = +""
       end
     end
   end
 
   def parse_requires(requires)
     return [] if requires.nil?
-    requires_without_version = requires.gsub(/[<>]?=\s*[\d.a-zA-Z_-]+\s*/, '')
+    requires_without_version = requires.gsub(/(?:<|>|<=|>=|=)\s*[\d.a-zA-Z_-]+\s*/, "")
     requires_without_version.split(/[,\s]+/)
   end
 
@@ -418,69 +710,6 @@ class PackageConfig
     end
   end
 
-  def guess_default_path
-    arch_depended_path = Dir.glob("/usr/lib/*/pkgconfig")
-    default_paths = [
-      "/usr/local/lib64/pkgconfig",
-      "/usr/local/libx32/pkgconfig",
-      "/usr/local/lib/pkgconfig",
-      "/usr/local/libdata/pkgconfig",
-      "/usr/local/share/pkgconfig",
-      "/opt/local/lib/pkgconfig",
-      *arch_depended_path,
-      "/usr/lib64/pkgconfig",
-      "/usr/libx32/pkgconfig",
-      "/usr/lib/pkgconfig",
-      "/usr/libdata/pkgconfig",
-      "/usr/X11R6/lib/pkgconfig",
-      "/usr/X11R6/share/pkgconfig",
-      "/usr/X11/lib/pkgconfig",
-      "/opt/X11/lib/pkgconfig",
-      "/usr/share/pkgconfig",
-    ]
-    libdir = ENV["PKG_CONFIG_LIBDIR"]
-    default_paths.unshift(libdir) if libdir
-
-    paths = []
-    pkg_config_prefix = self.class.native_pkg_config_prefix
-    if pkg_config_prefix
-      pkg_config_arch_depended_paths =
-        Dir.glob((pkg_config_prefix + "lib/*/pkgconfig").to_s)
-      paths.concat(pkg_config_arch_depended_paths)
-      paths << (pkg_config_prefix + "lib64/pkgconfig").to_s
-      paths << (pkg_config_prefix + "libx32/pkgconfig").to_s
-      paths << (pkg_config_prefix + "lib/pkgconfig").to_s
-      paths << (pkg_config_prefix + "libdata/pkgconfig").to_s
-    end
-    if /-darwin\d[\d\.]*\z/ =~ RUBY_PLATFORM and
-        /\A(\d+\.\d+)/ =~ `sw_vers -productVersion`
-      mac_os_version = $1
-      homebrew_repository_candidates = []
-      if pkg_config_prefix
-        brew_path = pkg_config_prefix + "bin" + "brew"
-        if brew_path.exist?
-          escaped_brew_path = Shellwords.escape(brew_path.to_s)
-          homebrew_repository = `#{escaped_brew_path} --repository`.chomp
-          homebrew_repository_candidates << Pathname.new(homebrew_repository)
-        else
-          homebrew_repository_candidates << pkg_config_prefix + "Homebrew"
-          homebrew_repository_candidates << pkg_config_prefix
-        end
-      end
-      brew = self.class.__send__(:search_executable_from_path, "brew")
-      if brew
-        homebrew_repository = `brew --repository`.chomp
-        homebrew_repository_candidates << Pathname(homebrew_repository)
-      end
-      homebrew_repository_candidates.uniq.each do |candidate|
-        path = candidate + "Library/Homebrew/os/mac/pkgconfig/#{mac_os_version}"
-        paths << path.to_s if path.exist?
-      end
-    end
-    paths.concat(default_paths)
-    paths.join(SEPARATOR)
-  end
-
   def required_packages
     collect_requires do |package|
       package.requires
@@ -499,109 +728,3 @@ class PackageConfig
     end
   end
 end
-
-module PKGConfig
-  @@paths = []
-  @@override_variables = {}
-
-  module_function
-  def add_path(path)
-    @@paths << path
-  end
-
-  def set_override_variable(key, value)
-    @@override_variables[key] = value
-  end
-
-  def msvc?
-    /mswin/.match(RUBY_PLATFORM) and /^cl\b/.match(RbConfig::CONFIG['CC'])
-  end
-
-  def package_config(package)
-    PackageConfig.new(package,
-                      :msvc_syntax => msvc?,
-                      :override_variables => @@override_variables,
-                      :paths => @@paths)
-  end
-
-  def exist?(pkg)
-    package_config(pkg).exist?
-  end
-
-  def libs(pkg)
-    package_config(pkg).libs
-  end
-
-  def libs_only_l(pkg)
-    package_config(pkg).libs_only_l
-  end
-
-  def libs_only_L(pkg)
-    package_config(pkg).libs_only_L
-  end
-
-  def cflags(pkg)
-    package_config(pkg).cflags
-  end
-
-  def cflags_only_I(pkg)
-    package_config(pkg).cflags_only_I
-  end
-
-  def cflags_only_other(pkg)
-    package_config(pkg).cflags_only_other
-  end
-
-  def modversion(pkg)
-    package_config(pkg).version
-  end
-
-  def description(pkg)
-    package_config(pkg).description
-  end
-
-  def variable(pkg, name)
-    package_config(pkg).variable(name)
-  end
-
-  def check_version?(pkg, major=0, minor=0, micro=0)
-    return false unless exist?(pkg)
-    ver = modversion(pkg).split(".").collect {|item| item.to_i}
-    (0..2).each {|i| ver[i] = 0 unless ver[i]}
-
-    (ver[0] > major ||
-     (ver[0] == major && ver[1] > minor) ||
-     (ver[0] == major && ver[1] == minor &&
-      ver[2] >= micro))
-  end
-
-  def have_package(pkg, major=nil, minor=0, micro=0)
-    message = "#{pkg}"
-    unless major.nil?
-      message << " version (>= #{major}.#{minor}.#{micro})"
-    end
-    major ||= 0
-    enough_version = checking_for(checking_message(message)) do
-      check_version?(pkg, major, minor, micro)
-    end
-    if enough_version
-      libraries = libs_only_l(pkg)
-      dldflags = libs(pkg)
-      dldflags = (Shellwords.shellwords(dldflags) -
-                  Shellwords.shellwords(libraries))
-      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
-      $libs   += ' ' + libraries
-      if /mswin/ =~ RUBY_PLATFORM
-        $DLDFLAGS += ' ' + dldflags
-      else
-        $LDFLAGS += ' ' + dldflags
-      end
-      $CFLAGS += ' ' + cflags_only_other(pkg)
-      if defined?($CXXFLAGS)
-        $CXXFLAGS += ' ' + cflags_only_other(pkg)
-      end
-      $INCFLAGS += ' ' + cflags_only_I(pkg)
-    end
-    enough_version
-  end
-end