mini_portile2 2.8.4 → 2.8.7

data/lib/mini_portile2/mini_portile.rb

@@ -8,6 +8,7 @@ require 'open-uri'
 require 'cgi'
 require 'rbconfig'
 require 'shellwords'
+require 'open3'
 
 # Monkey patch for Net::HTTP by ruby open-uri fix:
 # https://github.com/ruby/ruby/commit/58835a9
@@ -27,12 +28,14 @@ class Net::HTTP
   end
 end
 
+$MINI_PORTILE_STATIC_LIBS = {}
+
 class MiniPortile
   DEFAULT_TIMEOUT = 10
 
-  attr_reader :name, :version, :original_host
+  attr_reader :name, :version, :original_host, :source_directory
   attr_writer :configure_options
-  attr_accessor :host, :files, :patch_files, :target, :logger, :source_directory
+  attr_accessor :host, :files, :patch_files, :target, :logger
 
   def self.windows?
     target_os =~ /mswin|mingw/
@@ -76,6 +79,24 @@ class MiniPortile
     RbConfig::CONFIG['target_cpu']
   end
 
+  def self.native_path(path)
+    path = File.expand_path(path)
+    if File::ALT_SEPARATOR
+      path.tr(File::SEPARATOR, File::ALT_SEPARATOR)
+    else
+      path
+    end
+  end
+
+  def self.posix_path(path)
+    path = File.expand_path(path)
+    if File::ALT_SEPARATOR
+      "/" + path.tr(File::ALT_SEPARATOR, File::SEPARATOR).tr(":", File::SEPARATOR)
+    else
+      path
+    end
+  end
+
   def initialize(name, version, **kwargs)
     @name = name
     @version = version
@@ -83,15 +104,16 @@ class MiniPortile
     @files = []
     @patch_files = []
     @log_files = {}
-    @logger = STDOUT
+    @logger = kwargs[:logger] || STDOUT
     @source_directory = nil
 
-    @original_host = @host = detect_host
-
-    @gcc_command = kwargs[:gcc_command]
+    @cc_command = kwargs[:cc_command] || kwargs[:gcc_command]
+    @cxx_command = kwargs[:cxx_command]
     @make_command = kwargs[:make_command]
     @open_timeout = kwargs[:open_timeout] || DEFAULT_TIMEOUT
     @read_timeout = kwargs[:read_timeout] || DEFAULT_TIMEOUT
+
+    @original_host = @host = detect_host
   end
 
   def source_directory=(path)
@@ -219,11 +241,10 @@ class MiniPortile
   end
 
   def activate
-    lib_path = File.join(port_path, "lib")
     vars = {
       'PATH'          => File.join(port_path, 'bin'),
-      'CPATH'         => File.join(port_path, 'include'),
-      'LIBRARY_PATH'  => lib_path
+      'CPATH'         => include_path,
+      'LIBRARY_PATH'  => lib_path,
     }.reject { |env, path| !File.directory?(path) }
 
     output "Activating #{@name} #{@version} (from #{port_path})..."
@@ -240,7 +261,7 @@ class MiniPortile
 
     # rely on LDFLAGS when cross-compiling
     if File.exist?(lib_path) && (@host != @original_host)
-      full_path = File.expand_path(lib_path)
+      full_path = native_path(lib_path)
 
       old_value = ENV.fetch("LDFLAGS", "")
 
@@ -250,12 +271,114 @@ class MiniPortile
     end
   end
 
+  # pkg: the pkg-config file name (without the .pc extension)
+  # dir: inject the directory path for the pkg-config file (probably only useful for tests)
+  # static: the name of the static library archive (without the "lib" prefix or the file extension), or nil for dynamic linking
+  #
+  # we might be able to be terribly clever and infer the name of the static archive file, but
+  # unfortunately projects have so much freedom in what they can report (for name, for libs, etc.)
+  # that it feels unreliable to try to do so, so I'm preferring to just have the developer make it
+  # explicit.
+  def mkmf_config(pkg: nil, dir: nil, static: nil)
+    require "mkmf"
+
+    if pkg
+      dir ||= File.join(lib_path, "pkgconfig")
+      pcfile = File.join(dir, "#{pkg}.pc")
+      unless File.exist?(pcfile)
+        raise ArgumentError, "pkg-config file '#{pcfile}' does not exist"
+      end
+
+      output "Configuring MakeMakefile for #{File.basename(pcfile)} (in #{File.dirname(pcfile)})\n"
+
+      # on macos, pkg-config will not return --cflags without this
+      ENV["PKG_CONFIG_ALLOW_SYSTEM_CFLAGS"] = "t"
+
+      # append to PKG_CONFIG_PATH as we go, so later pkg-config files can depend on earlier ones
+      ENV["PKG_CONFIG_PATH"] = [ENV["PKG_CONFIG_PATH"], dir].compact.join(File::PATH_SEPARATOR)
+
+      incflags = minimal_pkg_config(pcfile, "cflags-only-I")
+      cflags = minimal_pkg_config(pcfile, "cflags-only-other")
+      if static
+        ldflags = minimal_pkg_config(pcfile, "libs-only-L", "static")
+        libflags = minimal_pkg_config(pcfile, "libs-only-l", "static")
+      else
+        ldflags = minimal_pkg_config(pcfile, "libs-only-L")
+        libflags = minimal_pkg_config(pcfile, "libs-only-l")
+      end
+    else
+      output "Configuring MakeMakefile for #{@name} #{@version} (from #{path})\n"
+
+      lib_name = name.sub(/\Alib/, "") # TODO: use delete_prefix when we no longer support ruby 2.4
+
+      incflags = Dir.exist?(include_path) ? "-I#{include_path}" : ""
+      cflags = ""
+      ldflags = Dir.exist?(lib_path) ? "-L#{lib_path}" : ""
+      libflags = Dir.exist?(lib_path) ? "-l#{lib_name}" : ""
+    end
+
+    if static
+      libdir = lib_path
+      if pcfile
+        pcfile_libdir = minimal_pkg_config(pcfile, "variable=libdir").strip
+        libdir = pcfile_libdir unless pcfile_libdir.empty?
+      end
+
+      #
+      # keep track of the libraries we're statically linking against, and fix up ldflags and
+      # libflags to make sure we link statically against the recipe's libaries.
+      #
+      # this avoids the unintentionally dynamically linking against system libraries, and makes sure
+      # that if multiple pkg-config files reference each other that we are able to intercept flags
+      # from dependent packages that reference the static archive.
+      #
+      $MINI_PORTILE_STATIC_LIBS[static] = libdir
+      static_ldflags = $MINI_PORTILE_STATIC_LIBS.values.map { |v| "-L#{v}" }
+      static_libflags = $MINI_PORTILE_STATIC_LIBS.keys.map { |v| "-l#{v}" }
+
+      # remove `-L#{libdir}` and `-lfoo`. we don't need them since we link against the static
+      # archive using the full path.
+      ldflags = ldflags.shellsplit.reject { |f| static_ldflags.include?(f) }.shelljoin
+      libflags = libflags.shellsplit.reject { |f| static_libflags.include?(f) }.shelljoin
+
+      # prepend the full path to the static archive to the linker flags
+      static_archive = File.join(libdir, "lib#{static}.#{$LIBEXT}")
+      libflags = [static_archive, libflags].join(" ").strip
+    end
+
+    # prefer this package by prepending to search paths and library flags
+    #
+    # convert the ldflags into a list of directories and append to $LIBPATH (instead of just using
+    # $LDFLAGS) to ensure we get the `-Wl,-rpath` linker flag for re-finding shared libraries.
+    $INCFLAGS = [incflags, $INCFLAGS].join(" ").strip
+    libpaths = ldflags.shellsplit.map { |f| f.sub(/\A-L/, "") }
+    $LIBPATH = libpaths | $LIBPATH
+    $libs = [libflags, $libs].join(" ").strip
+
+    # prefer this package's compiler flags by appending them to the command line
+    $CFLAGS = [$CFLAGS, cflags].join(" ").strip
+    $CXXFLAGS = [$CXXFLAGS, cflags].join(" ").strip
+  end
+
   def path
     File.expand_path(port_path)
   end
 
-  def gcc_cmd
-    (ENV["CC"] || @gcc_command || RbConfig::CONFIG["CC"] || "gcc").dup
+  def include_path
+    File.join(path, "include")
+  end
+
+  def lib_path
+    File.join(path, "lib")
+  end
+
+  def cc_cmd
+    (ENV["CC"] || @cc_command || RbConfig::CONFIG["CC"] || "gcc").dup
+  end
+  alias :gcc_cmd :cc_cmd
+
+  def cxx_cmd
+    (ENV["CXX"] || @cxx_command || RbConfig::CONFIG["CXX"] || "g++").dup
   end
 
   def make_cmd
@@ -265,21 +388,11 @@ class MiniPortile
   private
 
   def native_path(path)
-    path = File.expand_path(path)
-    if File::ALT_SEPARATOR
-      path.tr(File::SEPARATOR, File::ALT_SEPARATOR)
-    else
-      path
-    end
+    MiniPortile.native_path(path)
   end
 
   def posix_path(path)
-    path = File.expand_path(path)
-    if File::ALT_SEPARATOR
-      "/" + path.tr(File::ALT_SEPARATOR, File::SEPARATOR).tr(":", File::SEPARATOR)
-    else
-      path
-    end
+    MiniPortile.posix_path(path)
   end
 
   def tmp_path
@@ -349,24 +462,29 @@ class MiniPortile
       gpg_exe = which('gpg2') || which('gpg') || raise("Neither GPG nor GPG2 is installed")
 
       # import the key into our own keyring
-      gpg_status = IO.popen([gpg_exe, "--status-fd", "1", "--no-default-keyring", "--keyring", KEYRING_NAME, "--import"], "w+") do |io|
-        io.write gpg[:key]
-        io.close_write
-        io.read
+      gpg_error = nil
+      gpg_status = Open3.popen3(gpg_exe, "--status-fd", "1", "--no-default-keyring", "--keyring", KEYRING_NAME, "--import") do |gpg_in, gpg_out, gpg_err, _thread|
+        gpg_in.write gpg[:key]
+        gpg_in.close
+        gpg_error = gpg_err.read
+        gpg_out.read
       end
       key_ids = gpg_status.scan(/\[GNUPG:\] IMPORT_OK \d+ (?<key_id>[0-9a-f]+)/i).map(&:first)
-      raise "invalid gpg key provided" if key_ids.empty?
-
-      # verify the signature against our keyring
-      gpg_status = IO.popen([gpg_exe, "--status-fd", "1", "--no-default-keyring", "--keyring", KEYRING_NAME, "--verify", signature_file, file[:local_path]], &:read)
+      raise "invalid gpg key provided:\n#{gpg_error}" if key_ids.empty?
 
-      # remove the key from our keyring
-      key_ids.each do |key_id|
-        IO.popen([gpg_exe, "--batch", "--yes", "--no-default-keyring", "--keyring", KEYRING_NAME, "--delete-keys", key_id], &:read)
-        raise "unable to delete the imported key" unless $?.exitstatus==0
+      begin
+        # verify the signature against our keyring
+        gpg_status, gpg_error, _status = Open3.capture3(gpg_exe, "--status-fd", "1", "--no-default-keyring", "--keyring", KEYRING_NAME, "--verify", signature_file, file[:local_path])
+
+        raise "signature mismatch:\n#{gpg_error}" unless gpg_status.match(/^\[GNUPG:\] VALIDSIG/)
+      ensure
+        # remove the key from our keyring
+        key_ids.each do |key_id|
+          IO.popen([gpg_exe, "--batch", "--yes", "--no-default-keyring", "--keyring", KEYRING_NAME, "--delete-keys", key_id], &:read)
+          raise "unable to delete the imported key" unless $?.exitstatus==0
+        end
       end
 
-      raise "signature mismatch" unless gpg_status.match(/^\[GNUPG:\] VALIDSIG/)
 
     else
       digest = case
@@ -390,30 +508,6 @@ class MiniPortile
       }
   end
 
-  TAR_EXECUTABLES = %w[gtar bsdtar tar basic-bsdtar]
-  def tar_exe
-    @@tar_exe ||= begin
-      TAR_EXECUTABLES.find { |c|
-        which(c)
-      } or raise("tar not found - please make sure that one of the following commands is in the PATH: #{TAR_EXECUTABLES.join(", ")}")
-    end
-  end
-
-  def tar_compression_switch(filename)
-    case File.extname(filename)
-      when '.gz', '.tgz'
-        'z'
-      when '.bz2', '.tbz2'
-        'j'
-      when '.xz'
-        'J'
-      when '.Z'
-        'Z'
-      else
-        ''
-    end
-  end
-
   # From: http://stackoverflow.com/a/5471032/7672
   # Thanks, Mislav!
   #
@@ -440,6 +534,8 @@ class MiniPortile
       output = `#{gcc_cmd} -v 2>&1`
       if m = output.match(/^Target\: (.*)$/)
         @detect_host = m[1]
+      else
+        @detect_host = nil
       end
 
       @detect_host
@@ -448,12 +544,35 @@ class MiniPortile
     end
   end
 
+  TAR_EXECUTABLES = %w[gtar bsdtar tar basic-bsdtar]
+  def tar_exe
+    @@tar_exe ||= begin
+      TAR_EXECUTABLES.find { |c|
+        which(c)
+      } or raise("tar not found - please make sure that one of the following commands is in the PATH: #{TAR_EXECUTABLES.join(", ")}")
+    end
+  end
+
+  def tar_command(file, target)
+    case File.extname(file)
+      when '.gz', '.tgz'
+        [tar_exe, 'xzf', file, '-C', target]
+      when '.bz2', '.tbz2'
+        [tar_exe, 'xjf', file, '-C', target]
+      when '.xz'
+        # NOTE: OpenBSD's tar command does not support the -J option
+        "xzcat #{file.shellescape} | #{tar_exe.shellescape} xf - -C #{target.shellescape}"
+      else
+        [tar_exe, 'xf', file, '-C', target]
+    end
+  end
+
   def extract_file(file, target)
     filename = File.basename(file)
     FileUtils.mkdir_p target
 
     message "Extracting #{filename} into #{target}... "
-    execute('extract', [tar_exe, "#{tar_compression_switch(filename)}xf", file, "-C", target], {:cd => Dir.pwd, :initial_message => false})
+    execute('extract', tar_command(file, target) , {:cd => Dir.pwd, :initial_message => false})
   end
 
   # command could be an array of args, or one string containing a command passed to the shell. See
@@ -589,7 +708,7 @@ class MiniPortile
         return download_file(redirect.url, full_path, count-1)
       rescue => e
         count = count - 1
-        puts "#{count} retrie(s) left for #{filename} (#{e.message})"
+        @logger.puts "#{count} retrie(s) left for #{filename} (#{e.message})"
         if count > 0
           sleep 1
           return download_file_http(url, full_path, count)
@@ -648,4 +767,29 @@ class MiniPortile
     FileUtils.mkdir_p File.dirname(full_path)
     FileUtils.mv temp_file.path, full_path, :force => true
   end
+
+  #
+  #  this minimal version of pkg_config is based on ruby 29dc9378 (2023-01-09)
+  #
+  #  specifically with the fix from b90e56e6 to support multiple pkg-config options, and removing
+  #  code paths that aren't helpful for mini-portile's use case of parsing pc files.
+  #
+  def minimal_pkg_config(pkg, *pcoptions)
+    if pcoptions.empty?
+      raise ArgumentError, "no pkg-config options are given"
+    end
+
+    if ($PKGCONFIG ||=
+        (pkgconfig = MakeMakefile.with_config("pkg-config") {MakeMakefile.config_string("PKG_CONFIG") || "pkg-config"}) &&
+        MakeMakefile.find_executable0(pkgconfig) && pkgconfig)
+      pkgconfig = $PKGCONFIG
+    else
+      raise RuntimeError, "pkg-config is not found"
+    end
+
+    pcoptions = Array(pcoptions).map { |o| "--#{o}" }
+    response = IO.popen([pkgconfig, *pcoptions, pkg], err:[:child, :out], &:read)
+    raise RuntimeError, response unless $?.success?
+    response.strip
+  end
 end

data/lib/mini_portile2/mini_portile_cmake.rb

@@ -11,6 +11,7 @@ class MiniPortileCMake < MiniPortile
   def initialize(name, version, **kwargs)
     super(name, version, **kwargs)
     @cmake_command = kwargs[:cmake_command]
+    @cmake_build_type = kwargs[:cmake_build_type]
   end
 
   def configure_defaults
@@ -49,6 +50,10 @@ class MiniPortileCMake < MiniPortile
     (ENV["CMAKE"] || @cmake_command || "cmake").dup
   end
 
+  def cmake_build_type
+    (ENV["CMAKE_BUILD_TYPE"] || @cmake_build_type || "Release").dup
+  end
+
   private
 
   def generator_defaults
@@ -62,45 +67,21 @@ class MiniPortileCMake < MiniPortile
   end
 
   def cmake_compile_flags
-    c_compiler, cxx_compiler = find_c_and_cxx_compilers(host)
+    # RbConfig::CONFIG['CC'] and RbConfig::CONFIG['CXX'] can contain additional flags, for example
+    # "clang++ -std=gnu++11" or "clang -fdeclspec". CMake is just looking for the command name.
+    cc_compiler = cc_cmd.split.first
+    cxx_compiler = cxx_cmd.split.first
 
     # needed to ensure cross-compilation with CMake targets the right CPU and compilers
     [
       "-DCMAKE_SYSTEM_NAME=#{cmake_system_name}",
       "-DCMAKE_SYSTEM_PROCESSOR=#{cpu_type}",
-      "-DCMAKE_C_COMPILER=#{c_compiler}",
-      "-DCMAKE_CXX_COMPILER=#{cxx_compiler}"
+      "-DCMAKE_C_COMPILER=#{cc_compiler}",
+      "-DCMAKE_CXX_COMPILER=#{cxx_compiler}",
+      "-DCMAKE_BUILD_TYPE=#{cmake_build_type}",
     ]
   end
 
-  def find_compiler(compilers)
-    compilers.find { |binary| which(binary) }
-  end
-
-  # configure automatically searches for the right compiler based on the
-  # `--host` parameter.  However, CMake doesn't have an equivalent feature.
-  # Search for the right compiler for the target architecture using
-  # some basic heruistics.
-  def find_c_and_cxx_compilers(host)
-    c_compiler = ENV["CC"]
-    cxx_compiler = ENV["CXX"]
-
-    if MiniPortile.darwin?
-      c_compiler ||= 'clang'
-      cxx_compiler ||='clang++'
-    else
-      c_compiler ||= 'gcc'
-      cxx_compiler ||= 'g++'
-    end
-
-    c_platform_compiler = "#{host}-#{c_compiler}"
-    cxx_platform_compiler = "#{host}-#{cxx_compiler}"
-    c_compiler = find_compiler([c_platform_compiler, c_compiler])
-    cxx_compiler = find_compiler([cxx_platform_compiler, cxx_compiler])
-
-    [c_compiler, cxx_compiler]
-  end
-
   # Full list: https://gitlab.kitware.com/cmake/cmake/-/blob/v3.26.4/Modules/CMakeDetermineSystem.cmake?ref_type=tags#L12-31
   def cmake_system_name
     return system_name if system_name

data/lib/mini_portile2/version.rb

@@ -1,3 +1,3 @@
 class MiniPortile
-  VERSION = "2.8.4"
+  VERSION = "2.8.7"
 end

data/mini_portile2.gemspec

@@ -1,7 +1,4 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "mini_portile2/version"
+require_relative "lib/mini_portile2/version"
 
 Gem::Specification.new do |spec|
   spec.name = "mini_portile2"
@@ -10,8 +7,12 @@ Gem::Specification.new do |spec|
   spec.authors = ["Luis Lavena", "Mike Dalessio", "Lars Kanis"]
   spec.email = "mike.dalessio@gmail.com"
 
-  spec.summary = "Simplistic port-like solution for developers"
-  spec.description = "Simplistic port-like solution for developers. It provides a standard and simplified way to compile against dependency libraries without messing up your system."
+  spec.summary = "Simple autoconf and cmake builder for developers"
+  spec.description = <<~TEXT
+    Simple autoconf and cmake builder for developers. It provides a standard way to compile against
+    dependency libraries without requiring system-wide installation. It also simplifies
+    vendoring and cross-compilation by providing a consistent build interface.
+  TEXT
 
   spec.homepage = "https://github.com/flavorjones/mini_portile"
   spec.licenses = ["MIT"]

data/test/assets/pkgconf/libxml2/libxml-2.0.pc

@@ -0,0 +1,13 @@
+prefix=/foo/libxml2/2.11.5
+exec_prefix=${prefix}
+libdir=/foo/libxml2/2.11.5/lib
+includedir=${prefix}/include
+modules=1
+
+Name: libXML
+Version: 2.11.5
+Description: libXML library version2.
+Requires:
+Libs: -L${libdir} -lxml2
+Libs.private: -L/foo/zlib/1.3/lib -lz     -lm  
+Cflags: -I${includedir}/libxml2 -ggdb3

data/test/assets/pkgconf/libxslt/libexslt.pc

@@ -0,0 +1,13 @@
+prefix=/foo/libxslt/1.1.38
+exec_prefix=${prefix}
+libdir=/foo/libxslt/1.1.38/lib
+includedir=${prefix}/include
+
+
+Name: libexslt
+Version: 0.8.21
+Description: EXSLT Extension library
+Requires: libxml-2.0, libxslt
+Cflags: -I${includedir}
+Libs: -L${libdir} -lexslt
+Libs.private: -lm 

data/test/assets/pkgconf/libxslt/libxslt.pc

@@ -0,0 +1,13 @@
+prefix=/foo/libxslt/1.1.38
+exec_prefix=${prefix}
+libdir=/foo/libxslt/1.1.38/lib
+includedir=${prefix}/include
+
+
+Name: libxslt
+Version: 1.1.38
+Description: XSLT library version 2.
+Requires: libxml-2.0
+Cflags: -I${includedir} -Wno-deprecated-enum-enum-conversion
+Libs: -L${libdir} -lxslt
+Libs.private: -lm

data/test/helper.rb

@@ -9,6 +9,12 @@ require 'archive/tar/minitar'
 require 'fileutils'
 require 'erb'
 require 'mini_portile2'
+require 'logger'
+
+puts "#{__FILE__}:#{__LINE__}: relevant RbConfig::CONFIG values:"
+%w[target_os target_cpu CC CXX].each do |key|
+  puts "- #{key}: #{RbConfig::CONFIG[key].inspect}"
+end
 
 class TestCase < Minitest::Test
   include Minitest::Hooks
@@ -18,7 +24,12 @@ class TestCase < Minitest::Test
   attr_accessor :webrick
 
   def start_webrick(path)
-    @webrick = WEBrick::HTTPServer.new(:Port => HTTP_PORT, :DocumentRoot => path).tap do |w|
+    @webrick = WEBrick::HTTPServer.new(
+      :Port => HTTP_PORT,
+      :DocumentRoot => path,
+      :Logger => Logger.new(File::NULL),
+      :AccessLog => [],
+    ).tap do |w|
       Thread.new do
         w.start
       end