mini_portile2 2.8.1 → 2.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d467d59c8fe3298a010263ffcf5de58be5ba9be7757dbce500fd96251a2c864e
-  data.tar.gz: 70534d0b13bcdc0fe91c5524f8d40414ee1cc29fc357806aea4bbe52cc39129b
+  metadata.gz: 8f53843a25ac2651fd9970c34a44edf44de0904f99d9e63eadb3802f8dcd59bc
+  data.tar.gz: 075527f5c56f12de2ba5e3dfd72965a0093f62558eabb02571be5aee61cbe9f5
 SHA512:
-  metadata.gz: d67bc2e58d7fa53a4315fdaa1ab56f8ca5fe6b0a42e020b511e3aef3f7185690fbb51ee8f1bd5ccec48f0b37ef9037f45d7c56973ae3fdffadcfddc8679b6594
-  data.tar.gz: f2ab11a49573096c9b7fe150d1fcde07161a36514b6bb885e455f82cf270a70465987b131d359e898bd99850c616989afcbf48a9de1b5dbfb46831f9eea46f42
+  metadata.gz: 0e251640701cf8ea166e1ce6725b8e7bf3d3dbf20a659a6b90ffe127667a80f908fab5b7f816f8a766edd4166464d5375c53a3c31c862a4a7a04e0e87929127d
+  data.tar.gz: 1d540e216342ef799de2188935d6de440b865606a244dd7ca6a27146a259bf5a1211c53b49668eee668187770e5e030d06508b4605779c4366999dcf831cc2b3

data/.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
       fail-fast: false
       matrix:
         platform: [ubuntu-latest, windows-latest, macos-latest]
-        ruby: ["2.3", "2.4", "2.5", "2.6", "2.7", "3.0", "3.1", "head"]
+        ruby: ["2.3", "2.4", "2.5", "2.6", "2.7", "3.0", "3.1", "3.2", "head"]
     runs-on: ${{ matrix.platform }}
     steps:
       - name: configure git crlf on windows
@@ -33,7 +33,7 @@ jobs:
         run: |
           git config --system core.autocrlf false
           git config --system core.eol lf
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: MSP-Greg/setup-ruby-pkgs@v1
         with:
           apt-get: _update_ build-essential cmake
@@ -57,15 +57,32 @@ jobs:
         run: |
           git config --system core.autocrlf false
           git config --system core.eol lf
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: MSP-Greg/setup-ruby-pkgs@v1
         with:
           apt-get: _update_ build-essential cmake
           mingw: _upgrade_ cmake
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         with:
           path: examples/ports/archives
-          key: ${{ matrix.platform }}-examples-${{ hashFiles('examples/Rakefile') }}
+          key: examples-${{ hashFiles('examples/Rakefile') }}
+      - run: bundle exec rake test:examples
+
+  fedora: # see https://github.com/flavorjones/mini_portile/issues/118
+    runs-on: ubuntu-latest
+    container:
+      image: fedora:35
+    steps:
+      - run: |
+          dnf group install -y "C Development Tools and Libraries"
+          dnf install -y ruby ruby-devel libyaml-devel git-all patch cmake xz
+      - uses: actions/checkout@v3
+      - uses: actions/cache@v3
+        with:
+          path: examples/ports/archives
+          key: examples-${{ hashFiles('examples/Rakefile') }}
+      - run: bundle install
+      - run: bundle exec rake test:unit
       - run: bundle exec rake test:examples

data/.gitignore

@@ -3,3 +3,4 @@ Gemfile.lock
 pkg
 ports
 tmp
+mkmf.log

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 ## mini_portile changelog
 
+### 2.8.5 / 2023-10-22
+
+#### Added
+
+- New methods `#lib_path` and `#include_path` which point at the installed directories under `ports`. (by @flavorjones)
+- Add config param for CMAKE_BUILD_TYPE, which now defaults to `Release`. (#136 by @Watson1978)
+
+#### Experimental
+
+Introduce experimental support for `MiniPortile#mkmf_config` which sets up MakeMakefile variables to properly link against the recipe. This should make it easier for C extensions to package third-party libraries. (by @flavorjones)
+
+- With no arguments, will set up just `$INCFLAGS`, `$libs`, and `$LIBPATH`.
+- Optionally, if provided a pkg-config file, will use that config to more precisely set `$INCFLAGS`, `$libs`, `$LIBPATH`, and `$CFLAGS`/`$CXXFLAGS`.
+- Optionally, if provided the name of a static archive, will rewrite linker flags to ensure correct linkage.
+
+Note that the behavior may change slightly before official support is announced. Please comment on [#118](https://github.com/flavorjones/mini_portile/issues/118) if you have feedback.
+
+
+### 2.8.4 / 2023-07-18
+
+- cmake: set CMAKE compile flags to configure cross-compilation similarly to `autotools` `--host` flag: `SYSTEM_NAME`, `SYSTEM_PROCESSOR`, `C_COMPILER`, and `CXX_COMPILER`. [#130] (Thanks, @stanhu!)
+
+
+### 2.8.3 / 2023-07-18
+
+#### Fixed
+
+- cmake: only use MSYS/NMake generators when available. [#129] (Thanks, @stanhu!)
+
+
+### 2.8.2 / 2023-04-30
+
+#### Fixed
+
+- Ensure that the `source_directory` option will work when given a Windows path to an autoconf directory. [#126]
+
+
 ### 2.8.1 / 2022-12-24
 
 #### Fixed

data/README.md

@@ -138,8 +138,8 @@ This is configurable as above, except for Windows systems where it's hardcoded t
 The cmake command used is configurable, and in order of preference will use:
 
 - the `CMAKE` environment variable (if present)
-- the `cmake_command` value passed in to the constructor
-- `"cmake"`
+- the `:cmake_command` keyword argument passed into the constructor
+- `"cmake"` (the default)
 
 You can pass it in like so:
 
@@ -147,6 +147,19 @@ You can pass it in like so:
 MiniPortileCMake.new("libfoobar", "1.3.5", cmake_command: "cmake3")
 ```
 
+#### `cmake_build_type`
+
+The cmake build type is configurable as of v2.8.5, and in order of preference will use:
+
+- the `CMAKE_BUILD_TYPE` environment variable (if present)
+- the `:cmake_build_type` keyword argument passed into the constructor
+- `"Release"` (the default)
+
+You can pass it in like so:
+
+``` ruby
+MiniPortileCMake.new("libfoobar", "1.3.5", cmake_build_type: "Debug")
+```
 
 ### Local source directories
 

data/lib/mini_portile2/mini_portile.rb

@@ -27,25 +27,73 @@ 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?
-    RbConfig::CONFIG['target_os'] =~ /mswin|mingw/
+    target_os =~ /mswin|mingw/
   end
 
   # GNU MinGW compiled Ruby?
   def self.mingw?
-    RbConfig::CONFIG['target_os'] =~ /mingw/
+    target_os =~ /mingw/
   end
 
   # MS Visual-C compiled Ruby?
   def self.mswin?
-    RbConfig::CONFIG['target_os'] =~ /mswin/
+    target_os =~ /mswin/
+  end
+
+  def self.darwin?
+    target_os =~ /darwin/
+  end
+
+  def self.freebsd?
+    target_os =~ /freebsd/
+  end
+
+  def self.openbsd?
+    target_os =~ /openbsd/
+  end
+
+  def self.linux?
+    target_os =~ /linux/
+  end
+
+  def self.solaris?
+    target_os =~ /solaris/
+  end
+
+  def self.target_os
+    RbConfig::CONFIG['target_os']
+  end
+
+  def self.target_cpu
+    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)
@@ -58,21 +106,21 @@ class MiniPortile
     @logger = STDOUT
     @source_directory = nil
 
-    @original_host = @host = detect_host
-
     @gcc_command = kwargs[:gcc_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)
-    @source_directory = File.expand_path(path)
+    @source_directory = posix_path(path)
   end
 
   def prepare_build_directory
     raise "source_directory is not set" if source_directory.nil?
-    output "Building #{@name} #{@version} from source at '#{source_directory}'"
+    output "Building #{@name} from source at '#{source_directory}'"
     FileUtils.mkdir_p(File.join(tmp_path, [name, version].join("-")))
     FileUtils.rm_rf(port_path) # make sure we always re-install
   end
@@ -137,7 +185,7 @@ class MiniPortile
       # Windows doesn't recognize the shebang.
       command.unshift("sh")
     end
-    execute('configure', command + computed_options)
+    execute('configure', command + computed_options, altlog: "config.log")
   end
 
   def compile
@@ -191,19 +239,15 @@ 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})..."
     vars.each do |var, path|
-      full_path = File.expand_path(path)
-
-      # turn into a valid Windows path (if required)
-      full_path.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+      full_path = native_path(path)
 
       # save current variable value
       old_value = ENV[var] || ''
@@ -215,7 +259,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", "")
 
@@ -225,10 +269,109 @@ 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
+        variables = minimal_pkg_config(pcfile, "print-variables").split("\n").map(&:strip)
+        if variables.include?("libdir")
+          libdir = minimal_pkg_config(pcfile, "variable=libdir")
+        end
+      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 include_path
+    File.join(path, "include")
+  end
+
+  def lib_path
+    File.join(path, "lib")
+  end
+
   def gcc_cmd
     (ENV["CC"] || @gcc_command || RbConfig::CONFIG["CC"] || "gcc").dup
   end
@@ -237,7 +380,15 @@ class MiniPortile
     (ENV["MAKE"] || @make_command || ENV["make"] || "make").dup
   end
 
-private
+  private
+
+  def native_path(path)
+    MiniPortile.native_path(path)
+  end
+
+  def posix_path(path)
+    MiniPortile.posix_path(path)
+  end
 
   def tmp_path
     "tmp/#{@host}/ports/#{@name}/#{@version}"
@@ -420,6 +571,7 @@ private
     opt_debug =   command_opts.fetch(:debug, false)
     opt_cd =      command_opts.fetch(:cd) { work_path }
     opt_env =     command_opts.fetch(:env) { Hash.new }
+    opt_altlog =  command_opts.fetch(:altlog, nil)
 
     log_out = log_file(action)
 
@@ -450,12 +602,12 @@ private
         output "OK"
         return true
       else
-        if File.exist? log_out
-          output "ERROR, review '#{log_out}' to see what happened. Last lines are:"
-          output("=" * 72)
-          log_lines = File.readlines(log_out)
-          output(log_lines[-[log_lines.length, 20].min .. -1])
-          output("=" * 72)
+        output "ERROR. Please review logs to see what happened:\n"
+        [log_out, opt_altlog].compact.each do |log|
+          next unless File.exist?(log)
+          output("----- contents of '#{log}' -----")
+          output(File.read(log))
+          output("----- end of file -----")
         end
         raise "Failed to complete #{action} task"
       end
@@ -604,4 +756,29 @@ private
     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

@@ -1,6 +1,9 @@
 require 'mini_portile2/mini_portile'
+require 'open3'
 
 class MiniPortileCMake < MiniPortile
+  attr_accessor :system_name
+
   def configure_prefix
     "-DCMAKE_INSTALL_PREFIX=#{File.expand_path(port_path)}"
   end
@@ -8,16 +11,14 @@ 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
-    if MiniPortile.mswin?
-      ['-G', 'NMake Makefiles']
-    elsif MiniPortile.mingw?
-      ['-G', 'MSYS Makefiles']
-    else
-      []
-    end
+    [
+      generator_defaults,
+      cmake_compile_flags,
+    ].flatten
   end
 
   def configure
@@ -48,4 +49,96 @@ class MiniPortileCMake < MiniPortile
   def cmake_cmd
     (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
+    if MiniPortile.mswin? && generator_available?('NMake')
+      ['-G', 'NMake Makefiles']
+    elsif MiniPortile.mingw? && generator_available?('MSYS')
+      ['-G', 'MSYS Makefiles']
+    else
+      []
+    end
+  end
+
+  def cmake_compile_flags
+    c_compiler, cxx_compiler = find_c_and_cxx_compilers(host)
+
+    # 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_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
+
+    if MiniPortile.linux?
+      'Linux'
+    elsif MiniPortile.darwin?
+      'Darwin'
+    elsif MiniPortile.windows?
+      'Windows'
+    elsif MiniPortile.freebsd?
+      'FreeBSD'
+    elsif MiniPortile.openbsd?
+      'OpenBSD'
+    elsif MiniPortile.solaris?
+      'SunOS'
+    else
+      raise "Unable to set CMAKE_SYSTEM_NAME for #{MiniPortile.target_os}"
+    end
+  end
+
+  def generator_available?(generator_type)
+    stdout_str, status = Open3.capture2("#{cmake_cmd} --help")
+
+    raise 'Unable to determine whether CMake supports #{generator_type} Makefile generator' unless status.success?
+
+    stdout_str.include?("#{generator_type} Makefiles")
+  end
+
+  def cpu_type
+    return 'x86_64' if MiniPortile.target_cpu == 'x64'
+
+    MiniPortile.target_cpu
+  end
 end

data/lib/mini_portile2/version.rb

@@ -1,3 +1,3 @@
 class MiniPortile
-  VERSION = "2.8.1"
+  VERSION = "2.8.5"
 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/test_activate.rb

@@ -0,0 +1,139 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestActivate < TestCase
+  attr_reader :recipe
+
+  def setup
+    super
+
+    @save_env = %w[PATH CPATH LIBRARY_PATH LDFLAGS].inject({}) do |env, var|
+      env.update(var => ENV[var])
+    end
+
+    FileUtils.rm_rf(["tmp", "ports"]) # remove any previous test files
+
+    @recipe = MiniPortile.new("foo", "1.0.0").tap do |recipe|
+      recipe.logger = StringIO.new
+    end
+  end
+
+  def teardown
+    FileUtils.rm_rf(["tmp", "ports"]) # remove any previous test files
+
+    @save_env.each do |var, val|
+      ENV[var] = val
+    end
+
+    super
+  end
+
+  def test_PATH_env_var_when_bin_does_not_exist
+    ENV["PATH"] = "foo"
+    refute(Dir.exist?(bin_path))
+    refute_includes(path_elements('PATH'), bin_path)
+
+    recipe.activate
+
+    refute_includes(path_elements('PATH'), bin_path)
+  end
+
+  def test_PATH_env_var_when_bin_exists
+    ENV["PATH"] = "foo"
+    FileUtils.mkdir_p(bin_path)
+    refute_includes(path_elements('PATH'), bin_path)
+
+    recipe.activate
+
+    assert_includes(path_elements('PATH'), bin_path)
+    assert_equal(path_elements('PATH').first, bin_path)
+  end
+
+  def test_CPATH_env_var_when_include_does_not_exist
+    ENV["CPATH"] = "foo"
+    refute(Dir.exist?(include_path))
+    refute_includes(path_elements('CPATH'), include_path)
+
+    recipe.activate
+
+    refute_includes(path_elements('CPATH'), include_path)
+  end
+
+  def test_CPATH_env_var_when_include_exists
+    ENV["CPATH"] = "foo"
+    FileUtils.mkdir_p(include_path)
+    refute_includes(path_elements('CPATH'), include_path)
+
+    recipe.activate
+
+    assert_includes(path_elements('CPATH'), include_path)
+    assert_equal(path_elements('CPATH').first, include_path)
+  end
+
+  def test_LIBRARY_PATH_env_var_when_lib_does_not_exist
+    ENV["LIBRARY_PATH"] = "foo"
+    refute(Dir.exist?(lib_path))
+    refute_includes(path_elements('LIBRARY_PATH'), lib_path)
+
+    recipe.activate
+
+    refute_includes(path_elements('LIBRARY_PATH'), lib_path)
+  end
+
+  def test_LIBRARY_PATH_env_var_when_lib_exists
+    ENV["LIBRARY_PATH"] = "foo"
+    FileUtils.mkdir_p(lib_path)
+    refute_includes(path_elements('LIBRARY_PATH'), lib_path)
+
+    recipe.activate
+
+    assert_includes(path_elements('LIBRARY_PATH'), lib_path)
+    assert_equal(path_elements('LIBRARY_PATH').first, lib_path)
+  end
+
+  def test_LDFLAGS_env_var_when_not_cross_compiling
+    ENV["LDFLAGS"] = "-lfoo"
+    FileUtils.mkdir_p(lib_path)
+    assert_equal(recipe.host, recipe.original_host) # assert on setup)
+
+    refute_includes(flag_elements('LDFLAGS'), "-L#{lib_path}")
+
+    recipe.activate
+
+    refute_includes(flag_elements('LDFLAGS'), "-L#{lib_path}")
+  end
+
+  def test_LDFLAGS_env_var_when_cross_compiling
+    ENV["LDFLAGS"] = "-lfoo"
+    recipe.host = recipe.original_host + "-x" # make them not-equal
+    FileUtils.mkdir_p(lib_path)
+
+    refute_includes(flag_elements('LDFLAGS'), "-L#{lib_path}")
+
+    recipe.activate
+
+    assert_includes(flag_elements('LDFLAGS'), "-L#{lib_path}")
+    assert_equal(flag_elements('LDFLAGS').first, "-L#{lib_path}")
+  end
+
+  private
+
+  def path_elements(varname)
+    ENV.fetch(varname, "").split(File::PATH_SEPARATOR)
+  end
+
+  def flag_elements(varname)
+    ENV.fetch(varname, "").split
+  end
+
+  def bin_path
+    MiniPortile.native_path(File.join(recipe.path, "bin"))
+  end
+
+  def include_path
+    MiniPortile.native_path(File.join(recipe.path, "include"))
+  end
+
+  def lib_path
+    MiniPortile.native_path(File.join(recipe.path, "lib"))
+  end
+end

data/test/test_cmake.rb

@@ -14,13 +14,11 @@ class TestCMake < TestCase
     create_tar(@tar_path, @assets_path, "test-cmake-1.0")
     start_webrick(File.dirname(@tar_path))
 
-    @recipe = MiniPortileCMake.new("test-cmake", "1.0").tap do |recipe|
-      recipe.files << "http://localhost:#{HTTP_PORT}/#{ERB::Util.url_encode(File.basename(@tar_path))}"
-      recipe.patch_files << File.join(@assets_path, "patch 1.diff")
-      git_dir = File.join(@assets_path, "git")
-      with_custom_git_dir(git_dir) do
-        recipe.cook
-      end
+    @recipe = init_recipe
+
+    git_dir = File.join(@assets_path, "git")
+    with_custom_git_dir(git_dir) do
+      recipe.cook
     end
   end
 
@@ -57,9 +55,16 @@ class TestCMake < TestCase
     binary = File.join(recipe.path, "bin", exe_name)
     assert File.exist?(binary), binary
   end
+
+  def init_recipe
+    MiniPortileCMake.new("test-cmake", "1.0").tap do |recipe|
+      recipe.files << "http://localhost:#{HTTP_PORT}/#{ERB::Util.url_encode(File.basename(@tar_path))}"
+      recipe.patch_files << File.join(@assets_path, "patch 1.diff")
+    end
+  end
 end
 
-class TestCMakeConfig < TestCase
+class TestCMakeConfig < TestCMake
   def test_make_command_configuration
     MiniPortile.stub(:mswin?, false) do
       without_env("MAKE") do
@@ -77,6 +82,109 @@ class TestCMakeConfig < TestCase
     end
   end
 
+  def test_configure_defaults_with_macos
+    recipe = init_recipe
+    recipe.host = 'some-host'
+
+    with_env({ "CC" => nil, "CXX" => nil }) do
+      MiniPortile.stub(:darwin?, true) do
+        with_stubbed_target(os: 'darwin22', cpu: 'arm64') do
+          with_compilers(recipe, host_prefix: true, c_compiler: 'clang', cxx_compiler: 'clang++') do
+            Open3.stub(:capture2, cmake_help_mock('Unix')) do
+              assert_equal(
+                [
+                  "-DCMAKE_SYSTEM_NAME=Darwin",
+                  "-DCMAKE_SYSTEM_PROCESSOR=arm64",
+                  "-DCMAKE_C_COMPILER=some-host-clang",
+                  "-DCMAKE_CXX_COMPILER=some-host-clang++",
+                  "-DCMAKE_BUILD_TYPE=Release"
+                ],
+                recipe.configure_defaults)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_configure_defaults_with_manual_system_name
+    recipe = init_recipe
+    recipe.system_name = 'Custom'
+
+    MiniPortile.stub(:darwin?, false) do
+      with_stubbed_target do
+        with_compilers(recipe) do
+          Open3.stub(:capture2, cmake_help_mock('Unix')) do
+            assert_equal(
+              [
+                "-DCMAKE_SYSTEM_NAME=Custom",
+                "-DCMAKE_SYSTEM_PROCESSOR=x86_64",
+                "-DCMAKE_C_COMPILER=gcc",
+                "-DCMAKE_CXX_COMPILER=g++",
+                "-DCMAKE_BUILD_TYPE=Release"
+              ],
+              recipe.configure_defaults)
+          end
+        end
+      end
+    end
+  end
+
+  def test_configure_defaults_with_unix_makefiles
+    recipe = init_recipe
+
+    MiniPortile.stub(:linux?, true) do
+      MiniPortile.stub(:darwin?, false) do
+        with_stubbed_target do
+          with_compilers(recipe) do
+            Open3.stub(:capture2, cmake_help_mock('Unix')) do
+              MiniPortile.stub(:mingw?, true) do
+                assert_equal(default_x86_compile_flags,
+                            recipe.configure_defaults)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_configure_defaults_with_msys_makefiles
+    recipe = init_recipe
+
+    MiniPortile.stub(:linux?, true) do
+      MiniPortile.stub(:darwin?, false) do
+        with_stubbed_target do
+          with_compilers(recipe) do
+            Open3.stub(:capture2, cmake_help_mock('MSYS')) do
+              MiniPortile.stub(:mingw?, true) do
+                assert_equal(['-G', 'MSYS Makefiles'] + default_x86_compile_flags, recipe.configure_defaults)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def test_configure_defaults_with_nmake_makefiles
+    recipe = init_recipe
+
+    MiniPortile.stub(:linux?, true) do
+      MiniPortile.stub(:darwin?, false) do
+        with_stubbed_target do
+          with_compilers(recipe) do
+            Open3.stub(:capture2, cmake_help_mock('NMake')) do
+              MiniPortile.stub(:mswin?, true) do
+                assert_equal(['-G', 'NMake Makefiles'] + default_x86_compile_flags, recipe.configure_defaults)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
   def test_cmake_command_configuration
     without_env("CMAKE") do
       assert_equal("cmake", MiniPortileCMake.new("test", "1.0.0").cmake_cmd)
@@ -87,4 +195,67 @@ class TestCMakeConfig < TestCase
       assert_equal("asdf", MiniPortileCMake.new("test", "1.0.0", cmake_command: "xyzzy").cmake_cmd)
     end
   end
+
+  def test_cmake_build_type_configuration
+    without_env("CMAKE_BUILD_TYPE") do
+      assert_equal("Release", MiniPortileCMake.new("test", "1.0.0").cmake_build_type)
+      assert_equal("xyzzy", MiniPortileCMake.new("test", "1.0.0", cmake_build_type: "xyzzy").cmake_build_type)
+    end
+    with_env("CMAKE_BUILD_TYPE"=>"Debug") do
+      assert_equal("Debug", MiniPortileCMake.new("test", "1.0.0").cmake_build_type)
+      assert_equal("Debug", MiniPortileCMake.new("test", "1.0.0", cmake_build_type: "xyzzy").cmake_build_type)
+    end
+  end
+
+  private
+
+  def with_stubbed_target(os: 'linux', cpu: 'x86_64')
+    MiniPortile.stub(:target_os, os) do
+      MiniPortile.stub(:target_cpu, cpu) do
+        yield
+      end
+    end
+  end
+
+  def with_compilers(recipe, host_prefix: false, c_compiler: 'gcc', cxx_compiler: 'g++')
+    mock = MiniTest::Mock.new
+
+    if host_prefix
+      mock.expect(:call, true, ["#{recipe.host}-#{c_compiler}"])
+      mock.expect(:call, true, ["#{recipe.host}-#{cxx_compiler}"])
+    else
+      mock.expect(:call, false, ["#{recipe.host}-#{c_compiler}"])
+      mock.expect(:call, true, [c_compiler])
+      mock.expect(:call, false, ["#{recipe.host}-#{cxx_compiler}"])
+      mock.expect(:call, true, [cxx_compiler])
+    end
+
+    recipe.stub(:which, mock) do
+      yield
+    end
+  end
+
+  def default_x86_compile_flags
+    [
+      "-DCMAKE_SYSTEM_NAME=Linux",
+      "-DCMAKE_SYSTEM_PROCESSOR=x86_64",
+      "-DCMAKE_C_COMPILER=gcc",
+      "-DCMAKE_CXX_COMPILER=g++",
+      "-DCMAKE_BUILD_TYPE=Release"
+    ]
+  end
+
+  def cmake_help_mock(generator_type)
+    open3_mock = MiniTest::Mock.new
+    cmake_script = <<~SCRIPT
+      echo "The following generators are available on this platform (* marks default):"
+      echo "* #{generator_type} Makefiles               = Generates standard #{generator_type.upcase} makefiles."
+    SCRIPT
+
+    exit_status = MiniTest::Mock.new
+    exit_status.expect(:success?, true)
+    expected_output = [cmake_script, exit_status]
+    open3_mock.expect(:call, expected_output, ['cmake --help'])
+    open3_mock
+  end
 end

data/test/test_mkmf_config.rb

@@ -0,0 +1,202 @@
+require File.expand_path('../helper', __FILE__)
+
+require "mkmf" # initialize $LDFLAGS et al here, instead of in the middle of a test
+
+class TestMkmfConfig < TestCase
+  attr_reader :recipe
+
+  LIBXML_PCP = File.join(__dir__, "assets", "pkgconf", "libxml2")
+  LIBXSLT_PCP = File.join(__dir__, "assets", "pkgconf", "libxslt")
+
+  def make_recipe(name, version)
+    MiniPortile.new(name, version).tap do |recipe|
+      recipe.logger = StringIO.new # hush output
+    end
+  end
+
+  def setup
+    super
+
+    @save_env = %w[PATH CPATH LIBRARY_PATH LDFLAGS PKG_CONFIG_PATH].inject({}) do |env, var|
+      env.update(var => ENV[var])
+    end
+    $INCFLAGS = "-I/xxx"
+    $LIBPATH = ["xxx"]
+    $CFLAGS = "-xxx"
+    $CXXFLAGS = "-xxx"
+    $libs = "-lxxx"
+    $MINI_PORTILE_STATIC_LIBS = {}
+
+    FileUtils.rm_rf(["tmp", "ports"]) # remove any previous test files
+
+    @recipe = make_recipe("libfoo", "1.0.0")
+  end
+
+  def teardown
+    FileUtils.rm_rf(["tmp", "ports"]) # remove any previous test files
+
+    $INCFLAGS = ""
+    $LIBPATH = []
+    $CFLAGS = ""
+    $CXXFLAGS = ""
+    $libs = ""
+    $MINI_PORTILE_STATIC_LIBS = {}
+    @save_env.each do |var, val|
+      ENV[var] = val
+    end
+
+    super
+  end
+
+  def test_mkmf_config_recipe_LIBPATH_global_lib_dir_does_not_exist
+    recipe.mkmf_config
+
+    refute_includes($LIBPATH, recipe.lib_path)
+    refute_includes($libs.shellsplit, "-lfoo")
+  end
+
+  def test_mkmf_config_recipe_LIBPATH_global_not_static
+    FileUtils.mkdir_p(recipe.lib_path)
+
+    recipe.mkmf_config
+
+    assert_includes($LIBPATH, recipe.lib_path)
+    assert_operator($LIBPATH.index(recipe.lib_path), :<, $LIBPATH.index("xxx")) # prepend
+
+    assert_includes($libs.shellsplit, "-lfoo") # note the recipe name is "libfoo"
+    assert_match(%r{-lfoo.*-lxxx}, $libs) # prepend
+  end
+
+  def test_mkmf_config_recipe_LIBPATH_global_static
+    FileUtils.mkdir_p(recipe.lib_path)
+    static_lib_path = File.join(recipe.lib_path, "libfoo.#{$LIBEXT}")
+
+    recipe.mkmf_config(static: "foo")
+
+    refute_includes($LIBPATH, recipe.lib_path)
+
+    refute_includes($libs.shellsplit, "-lfoo") # note the recipe name is "libfoo"
+    assert_includes($libs.shellsplit, static_lib_path)
+    assert_match(%r{#{static_lib_path}.*-lxxx}, $libs) # prepend
+  end
+
+  def test_mkmf_config_recipe_INCFLAGS_global_include_dir_does_not_exist
+    recipe.mkmf_config
+
+    refute_includes($INCFLAGS.shellsplit, "-I#{recipe.include_path}")
+  end
+
+  def test_mkmf_config_recipe_INCFLAGS_global
+    FileUtils.mkdir_p(recipe.include_path)
+
+    recipe.mkmf_config
+
+    assert_includes($INCFLAGS.shellsplit, "-I#{recipe.include_path}")
+    assert_match(%r{-I#{recipe.include_path}.*-I/xxx}, $INCFLAGS) # prepend
+  end
+
+  def test_mkmf_config_pkgconf_does_not_exist
+    assert_raises(ArgumentError) do
+      recipe.mkmf_config(pkg: "foo")
+    end
+  end
+
+  def test_mkmf_config_pkgconf_LIBPATH_global_not_static
+    # can't get the pkgconf utility to install on windows with ruby 2.3 in CI
+    skip if MiniPortile.windows? && RUBY_VERSION < "2.4"
+
+    recipe.mkmf_config(pkg: "libxml-2.0", dir: LIBXML_PCP)
+
+    assert_includes($LIBPATH, "/foo/libxml2/2.11.5/lib")
+    assert_operator($LIBPATH.index("/foo/libxml2/2.11.5/lib"), :<, $LIBPATH.index("xxx")) # prepend
+    refute_includes($LIBPATH, "/foo/zlib/1.3/lib")
+
+    assert_includes($libs.shellsplit, "-lxml2")
+    assert_match(%r{-lxml2.*-lxxx}, $libs) # prepend
+    refute_includes($libs.shellsplit, "-lz")
+  end
+
+  def test_mkmf_config_pkgconf_LIBPATH_global_static
+    # can't get the pkgconf utility to install on windows with ruby 2.3 in CI
+    skip if MiniPortile.windows? && RUBY_VERSION < "2.4"
+
+    static_lib_path = "/foo/libxml2/2.11.5/lib/libxml2.#{$LIBEXT}"
+
+    recipe.mkmf_config(pkg: "libxml-2.0", dir: LIBXML_PCP, static: "xml2")
+
+    refute_includes($LIBPATH, "/foo/libxml2/2.11.5/lib")
+    refute_includes($libs.shellsplit, "-lxml2")
+    assert_includes($libs.shellsplit, static_lib_path)
+    assert_match(%r{#{static_lib_path}.*-lxxx}, $libs) # prepend
+
+    assert_includes($LIBPATH, "/foo/zlib/1.3/lib") # from --static
+    assert_includes($libs.shellsplit, "-lz") # from --static
+  end
+
+  def test_mkmf_config_pkgconf_CFLAGS_global
+    # can't get the pkgconf utility to install on windows with ruby 2.3 in CI
+    skip if MiniPortile.windows? && RUBY_VERSION < "2.4"
+
+    recipe.mkmf_config(pkg: "libxml-2.0", dir: LIBXML_PCP)
+
+    assert_includes($INCFLAGS.shellsplit, "-I/foo/libxml2/2.11.5/include/libxml2")
+    assert_match(%r{-I/foo/libxml2/2.11.5/include/libxml2.*-I/xxx}, $INCFLAGS) # prepend
+
+    assert_includes($CFLAGS.shellsplit, "-ggdb3")
+    assert_match(%r{-xxx.*-ggdb3}, $CFLAGS) # append
+
+    assert_includes($CXXFLAGS.shellsplit, "-ggdb3")
+    assert_match(%r{-xxx.*-ggdb3}, $CXXFLAGS) # append
+  end
+
+  def test_mkmf_config_pkgconf_path_accumulation
+    # can't get the pkgconf utility to install on windows with ruby 2.3 in CI
+    skip if MiniPortile.windows? && RUBY_VERSION < "2.4"
+
+    (ENV["PKG_CONFIG_PATH"] || "").split(File::PATH_SEPARATOR).tap do |pcpaths|
+      refute_includes(pcpaths, LIBXML_PCP)
+      refute_includes(pcpaths, LIBXSLT_PCP)
+    end
+
+    make_recipe("libxml2", "2.11.5").tap do |recipe|
+      recipe.mkmf_config(pkg: "libxml-2.0", dir: LIBXML_PCP, static: "xml2")
+
+      ENV["PKG_CONFIG_PATH"].split(File::PATH_SEPARATOR).tap do |pcpaths|
+        assert_includes(pcpaths, LIBXML_PCP)
+        refute_includes(pcpaths, LIBXSLT_PCP)
+      end
+    end
+
+    make_recipe("libxslt", "1.13.8").tap do |recipe|
+      recipe.mkmf_config(pkg: "libxslt", dir: LIBXSLT_PCP, static: "xslt")
+
+      ENV["PKG_CONFIG_PATH"].split(File::PATH_SEPARATOR).tap do |pcpaths|
+        assert_includes(pcpaths, LIBXML_PCP)
+        assert_includes(pcpaths, LIBXSLT_PCP)
+      end
+
+      recipe.mkmf_config(pkg: "libexslt", dir: LIBXSLT_PCP, static: "exslt")
+    end
+
+    $INCFLAGS.shellsplit.tap do |incflags|
+      assert_includes(incflags, "-I/foo/libxml2/2.11.5/include/libxml2")
+      assert_includes(incflags, "-I/foo/libxslt/1.1.38/include")
+    end
+    $CFLAGS.shellsplit.tap do |cflags|
+      assert_includes(cflags, "-ggdb3")
+      assert_includes(cflags, "-Wno-deprecated-enum-enum-conversion")
+    end
+    refute_includes($LIBPATH, "/foo/libxml2/2.11.5/lib")
+    refute_includes($LIBPATH, "/foo/libxslt/1.1.38/lib")
+    assert_includes($LIBPATH, "/foo/zlib/1.3/lib") # from `--static`
+    $libs.shellsplit.tap do |libflags|
+      refute_includes(libflags, "-lxml2")
+      assert_includes(libflags, "/foo/libxml2/2.11.5/lib/libxml2.#{$LIBEXT}")
+      refute_includes(libflags, "-lxslt")
+      assert_includes(libflags, "/foo/libxslt/1.1.38/lib/libxslt.#{$LIBEXT}")
+      refute_includes(libflags, "-lexslt")
+      assert_includes(libflags, "/foo/libxslt/1.1.38/lib/libexslt.#{$LIBEXT}")
+      assert_includes(libflags, "-lz") # from `--static`
+    end
+  end
+end

data/test/test_recipe.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRecipe < TestCase
+  def test_path
+    recipe = MiniPortile.new("libfoo", "1.0.0")
+    assert_equal(File.expand_path(File.join(recipe.target, recipe.host, recipe.name, recipe.version)), recipe.path)
+  end
+
+  def test_lib_path
+    recipe = MiniPortile.new("libfoo", "1.0.0")
+    assert_equal(File.join(recipe.path, "lib"), recipe.lib_path)
+  end
+
+  def test_include_path
+    recipe = MiniPortile.new("libfoo", "1.0.0")
+    assert_equal(File.join(recipe.path, "include"), recipe.include_path)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mini_portile2
 version: !ruby/object:Gem::Version
-  version: 2.8.1
+  version: 2.8.5
 platform: ruby
 authors:
 - Luis Lavena
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-24 00:00:00.000000000 Z
+date: 2023-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,9 +96,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
-description: Simplistic port-like solution for developers. It provides a standard
-  and simplified way to compile against dependency libraries without messing up your
-  system.
+description: |
+  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.
 email: mike.dalessio@gmail.com
 executables: []
 extensions: []
@@ -123,17 +124,23 @@ files:
 - test/assets/gpg-fixtures/data.asc
 - test/assets/gpg-fixtures/data.invalid.asc
 - test/assets/patch 1.diff
+- test/assets/pkgconf/libxml2/libxml-2.0.pc
+- test/assets/pkgconf/libxslt/libexslt.pc
+- test/assets/pkgconf/libxslt/libxslt.pc
 - test/assets/test mini portile-1.0.0/configure
 - test/assets/test-cmake-1.0/CMakeLists.txt
 - test/assets/test-cmake-1.0/hello.c
 - test/assets/test-download-archive.tar.gz
 - test/helper.rb
+- test/test_activate.rb
 - test/test_cmake.rb
 - test/test_cook.rb
 - test/test_digest.rb
 - test/test_download.rb
 - test/test_execute.rb
+- test/test_mkmf_config.rb
 - test/test_proxy.rb
+- test/test_recipe.rb
 homepage: https://github.com/flavorjones/mini_portile
 licenses:
 - MIT
@@ -153,24 +160,30 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
-summary: Simplistic port-like solution for developers
+summary: Simple autoconf and cmake builder for developers
 test_files:
 - test/assets/git/config
 - test/assets/gpg-fixtures/data
 - test/assets/gpg-fixtures/data.asc
 - test/assets/gpg-fixtures/data.invalid.asc
 - test/assets/patch 1.diff
+- test/assets/pkgconf/libxml2/libxml-2.0.pc
+- test/assets/pkgconf/libxslt/libexslt.pc
+- test/assets/pkgconf/libxslt/libxslt.pc
 - test/assets/test mini portile-1.0.0/configure
 - test/assets/test-cmake-1.0/CMakeLists.txt
 - test/assets/test-cmake-1.0/hello.c
 - test/assets/test-download-archive.tar.gz
 - test/helper.rb
+- test/test_activate.rb
 - test/test_cmake.rb
 - test/test_cook.rb
 - test/test_digest.rb
 - test/test_download.rb
 - test/test_execute.rb
+- test/test_mkmf_config.rb
 - test/test_proxy.rb
+- test/test_recipe.rb