wxruby3 0.9.7 → 0.9.8

data/rakelib/gem.rb

@@ -13,6 +13,13 @@ begin
   require 'rubygems/builder'
 rescue LoadError
 end
+require 'zlib'
+require 'tempfile'
+require 'json'
+require 'uri'
+require 'net/https'
+require 'fileutils'
+require 'digest/sha2'
 
 require_relative './lib/config'
 require_relative './install'
@@ -21,60 +28,305 @@ module WXRuby3
 
   module Gem
 
-    def self.manifest(gemtype = :src)
-      # create MANIFEST list with included files
-      manifest = Rake::FileList.new
-      manifest.include %w[bin/*] # *nix executables in bin/
-      manifest.exclude %w[bin/*.bat] unless WXRuby3.config.windows?
-      manifest.include %w[assets/**/* lib/**/* samples/**/* tests/**/*]
-      if gemtype == :bin
-        if WXRuby3.config.get_config('with-wxwin')
-          manifest.include "ext/*.#{WXRuby3.config.dll_mask}"
-        end
-        manifest.include 'ext/mkrf_conf_bingem.rb'
-        manifest.include %w[rakelib/prepost.* rakelib/install.rb rakelib/lib/config.rb rakelib/lib/config/**/* rakelib/lib/ext/**/* rakelib/yard/**/*]
-        manifest.include WXRuby3::BUILD_CFG
-      else
+    BINPKG_EXT = '.pkg'
+    DIGEST_EXT = '.sha'
+
+    class << self
+
+      # Gem helpers
+
+      def manifest
+        # create MANIFEST list with included files
+        manifest = Rake::FileList.new
+        manifest.include %w[bin/*] # *nix executables in bin/
+        manifest.exclude %w[bin/*.bat] unless WXRuby3.config.windows?
+        manifest.include %w[assets/**/* lib/**/* samples/**/* tests/**/*]
         manifest.exclude "lib/*.#{WXRuby3.config.dll_mask}"
-        manifest.include 'ext/wxruby3/wxruby.ico', 'ext/wxruby3/swig/**/*', 'ext/wxruby3/include/**/*'
+        manifest.include 'ext/mkrf_conf_ext.rb', 'ext/wxruby3/wxruby.ico', 'ext/wxruby3/swig/**/*', 'ext/wxruby3/include/**/*'
         manifest.exclude 'ext/wxruby3/swig/classes/**/*'
         manifest.include 'rakelib/**/*'
         manifest.exclude %w[rakelib/run.* rakelib/help.* rakelib/package.* rakelib/memcheck.* rakelib/memcheck/**/*]
-        manifest.include 'rakefile'
+        manifest.include %w{LICENSE README.md CREDITS.md INSTALL.md .yardopts}
+        manifest
       end
-      manifest.include %w{LICENSE README.md CREDITS.md INSTALL.md .yardopts}
-      manifest
-    end
 
-    def self.define_spec(name, version, gemtype = :src, &block)
-      gemspec = ::Gem::Specification.new(name, version)
-      if gemtype == :bin
-        platform = ::Gem::Platform.local.to_s
-        gemspec.platform = platform
+      def define_spec(&block)
+        gemspec = ::Gem::Specification.new('wxruby3', WXRuby3::WXRUBY_VERSION)
+        gemspec.required_rubygems_version = ::Gem::Requirement.new(">= 0") if gemspec.respond_to? :required_rubygems_version=
+        block.call(gemspec) if block_given?
+        gemspec
       end
-      gemspec.required_rubygems_version = ::Gem::Requirement.new(">= 0") if gemspec.respond_to? :required_rubygems_version=
-      block.call(gemspec) if block_given?
-      gemspec
-    end
 
-    def self.gem_name(name, version, gemtype = :src)
-      define_spec(name, version, gemtype).full_name
-    end
+      def gem_name
+        define_spec.full_name
+      end
+      private :gem_name
 
-    def self.gem_file(name, version, gemtype = :src)
-      File.join('pkg', "#{WXRuby3::Gem.gem_name(name, version, gemtype)}.gem")
-    end
+      def gem_file
+        File.join('pkg', "#{gem_name}.gem")
+      end
+
+      def build_gem(gemspec)
+        if defined?(::Gem::Package) && ::Gem::Package.respond_to?(:build)
+          gem_file_name = ::Gem::Package.build(gemspec)
+        else
+          gem_file_name = ::Gem::Builder.new(gemspec).build
+        end
+
+        FileUtils.mkdir_p('pkg')
 
-    def self.build_gem(gemspec)
-      if defined?(::Gem::Package) && ::Gem::Package.respond_to?(:build)
-        gem_file_name = ::Gem::Package.build(gemspec)
-      else
-        gem_file_name = ::Gem::Builder.new(gemspec).build
+        FileUtils.mv(gem_file_name, 'pkg')
       end
 
-      FileUtils.mkdir_p('pkg')
+      # Binary package helpers
+
+      def bin_pkg_manifest
+        # create MANIFEST list with included files
+        manifest = Rake::FileList.new
+        manifest.include "lib/*.#{WXRuby3.config.dll_mask}"
+        manifest.include 'lib/wx/**/events/*.rb', 'lib/wx/**/ext/*.rb', 'lib/wx/core/font/*.rb'
+        manifest.include "lib/wx/doc/gen/**/*.rb"
+        if WXRuby3.config.get_config('with-wxwin')
+          manifest.include "ext/*.#{WXRuby3.config.dll_mask}"
+        end
+        manifest
+      end
+
+      def make_bin_name
+        os = WXRuby3.config.sysinfo.os
+        case os.id
+        when :windows
+          "wxruby3_#{os.distro}_ruby#{WXRuby3::Config.rb_ver_major}#{WXRuby3::Config.rb_ver_minor}"
+        else
+          "wxruby3_#{os.distro}_#{os.release || '0'}_ruby#{WXRuby3::Config.rb_ver_major}#{WXRuby3::Config.rb_ver_minor}"
+        end
+      end
+      private :make_bin_name
+
+      def bin_pkg_name
+        gemspec = ::Gem::Specification.new(make_bin_name, WXRuby3::WXRUBY_VERSION)
+        platform = ::Gem::Platform.new(RB_CONFIG["arch"])
+        if platform.os == 'darwin'
+          # loose the version for darwin kernels as that does not seem to affect wxRuby runtime compatibility
+          # (until proven otherwise)
+          platform.version = nil
+        end
+        gemspec.platform = platform.to_s
+        gemspec.full_name
+      end
+      private :bin_pkg_name
+
+      def bin_pkg_file
+        File.join('pkg', bin_pkg_name+BINPKG_EXT)
+      end
+
+      def build_bin_pkg
+        # make sure pkg directory exists
+        FileUtils.mkdir_p('pkg')
+
+        fname = bin_pkg_file
+
+        # package registry and essential config
+        registry = []
+        config = %w{wxwininstdir with-wxwin}.reduce({}) { |h, k| h[k] = WXRuby3.config.get_config(k); h }
+        # package temp deflate stream
+        deflate_stream = Tempfile.new(File.basename(fname, '.*'), binmode: true)
+        begin
+          # pack binaries into temp deflate stream
+          bin_pkg_manifest.each do |path|
+            registry << pack_file(deflate_stream, path)
+          end
+          # convert registry and config to deflated json string
+          registry_json_z = Zlib::Deflate.deflate(registry.to_json)
+          config_json_z = Zlib::Deflate.deflate(config.to_json)
+
+          # create final package archive
+          deflate_stream.rewind
+          digest = Digest::SHA256.new
+          File.open(fname, 'w', binmode: true) do |fout|
+            # pack config
+            data = [config_json_z.size].pack('Q')
+            digest << data
+            fout.write(data)
+            digest << config_json_z
+            fout.write(config_json_z)
+            # pack registry
+            data = [registry_json_z.size].pack('Q')
+            digest << data
+            fout.write(data)
+            digest << registry_json_z
+            fout.write(registry_json_z)
+            # pack files
+            registry.each do |entry|
+              if entry[2] > 0
+                data = deflate_stream.read(entry[2])
+                digest << data
+                fout.write(data)
+              end
+            end
+          end
+          sha_file = File.join('pkg', bin_pkg_name+DIGEST_EXT)
+          File.open(sha_file, 'w') { |fsha| fsha << digest.hexdigest! }
+        ensure
+          deflate_stream.close(true)
+        end
+      end
+
+      def pack_file(os, path)
+        pack = true
+        entry = [path, File.stat(path).mode, 0]
+        unless WXRuby3.config.windows?
+          if File.symlink?(path)
+            pack = false
+            entry << File.readlink(path)
+          end
+        end
+        if pack
+          offs = os.tell
+          os.write(Zlib::Deflate.deflate(File.read(path, binmode: true)))
+          entry[2] = os.tell - offs # packed data size
+        end
+        entry
+      end
+      private :pack_file
+
+      # Gem installation helpers
+
+      def install_gem(prebuilt_only: false, package: nil)
+        # check if a user specified binary package is to be used
+        if package
+          uri = File.file?(package) ? nil : URI(package)
+          if uri.nil? || uri.scheme == 'file'
+            filename = package
+            if uri
+              filename = uri.host ? "#{uri.host}:#{uri.path}" : uri.path
+              filename = nil unless File.file?(filename)
+            end
+            if filename
+              $stdout.puts "Installing user package #{filename}..."
+              exit(1) unless install_bin_pkg(filename)
+              $stdout.puts 'Done!'
+              true
+            else
+              $stderr.puts "ERROR: Cannot access file #{package}."
+              exit(1)
+            end
+          elsif uri.scheme == 'http' || uri.scheme == 'https'
+            # download the binary release package
+            $stdout.puts "Downloading #{uri.path}..."
+            filename = File.basename(uri.path)
+            if WXRuby3.config.download_file(uri.path, filename)
+              sha_file = File.basename(filename, '.*')+DIGEST_EXT
+              uri.path = File.join(File.dirname(uri.path), sha_file)
+              unless WXRuby3.config.download_file(uri.path, sha_file)
+                $stderr.puts "ERROR: Unable to download digest signature for binary release package : #{package}"
+                exit(1)
+              end
+              exit(1) unless install_bin_pkg(filename)
+              true
+            else
+              $stderr.puts "ERROR: Unable to download binary release package (#{package})!"
+              exit(1)
+            end
+          else
+          end
+        # check if there exists a pre-built binary release package for the current platform
+        elsif has_release_package?
+          # download the binary release package
+          $stdout.puts "Downloading #{bin_pkg_url(BINPKG_EXT)}..."
+          if WXRuby3.config.download_file(bin_pkg_url(BINPKG_EXT), bin_pkg_name+BINPKG_EXT)
+            unless WXRuby3.config.download_file(bin_pkg_url(DIGEST_EXT), bin_pkg_name+DIGEST_EXT)
+              $stderr.puts "ERROR: Unable to download digest signature for binary release package : #{bin_pkg_name}"
+              exit(1)
+            end
+            exit(1) unless install_bin_pkg(bin_pkg_name+BINPKG_EXT)
+            true
+          else
+            if prebuilt_only
+              $stderr.puts "ERROR: Unable to download binary release package (#{bin_pkg_name})!"
+              exit(1)
+            end
+            $stdout.puts "WARNING: Unable to download binary release package (#{bin_pkg_name})! Reverting to source install."
+            false
+          end
+        else
+          if prebuilt_only
+            $stderr.puts "ERROR: No binary release package available!"
+            exit(1)
+          end
+          false
+        end
+      end
+
+      def bin_pkg_url(ext)
+        # which package are we looking for
+        pkg_name = bin_pkg_name
+        "https://github.com/mcorino/wxRuby3/releases/download/v#{WXRuby3::WXRUBY_VERSION}/#{pkg_name}#{ext}"
+      end
+      private :bin_pkg_url
+
+      def has_release_package?
+        # check if the release package exists on Github
+        uri = URI(bin_pkg_url(BINPKG_EXT))
+        $stdout.print "Checking #{uri.to_s}..." if WXRuby3.config.verbose?
+        response = Net::HTTP.start('github.com', use_ssl: true) do |http|
+          request = Net::HTTP::Head.new(uri)
+          http.request(request)
+        end
+        $stdout.puts "response #{response}" if WXRuby3.config.verbose?
+        # directly found or with redirect
+        Net::HTTPOK === response || Net::HTTPRedirection === response
+      end
+      private :has_release_package?
+
+      def install_bin_pkg(fname)
+        # first get digest signature (if available)
+        sha_file = File.join(File.dirname(fname), File.basename(fname, '.*')+DIGEST_EXT)
+        unless File.file?(sha_file)
+          $stderr.puts "ERROR: Cannot access package digest signature file : #{sha_file}."
+          return false
+        end
+        sha_sig = File.read(sha_file)
+        File.open(fname, 'r', binmode: true) do |fin|
+          # check digest signature
+          digest = Digest::SHA256.new
+          while (data = fin.read(1024*1024))
+            digest << data
+          end
+          if sha_sig != digest.hexdigest!
+            $stderr.puts 'ERROR: Package digest signature does NOT match.'
+            return false
+          end
+          fin.rewind
+          # get packed config size
+          config_size = fin.read(8).unpack('Q').shift
+          # unpack config
+          config = JSON.parse!(Zlib::Inflate.inflate(fin.read(config_size)))
+          # get packed registry size
+          registry_size = fin.read(8).unpack('Q').shift
+          # unpack registry
+          registry = JSON.parse!(Zlib::Inflate.inflate(fin.read(registry_size)))
+          # unpack and create binaries
+          registry.each do |entry|
+            path, mode, size, symlink = entry
+            if symlink
+              FileUtils.mkdir_p(File.dirname(symlink))
+              FileUtils.ln_s(symlink, path)
+            else
+              FileUtils.mkdir_p(File.dirname(path))
+              File.open(path, 'w', binmode: true) do |fbin|
+                fbin << Zlib::Inflate.inflate(fin.read(size))
+              end
+              File.chmod(mode, path)
+            end
+          end
+          # merge config
+          config.each_pair { |k,v| WXRuby3.config.set_config(k, v) }
+        end
+        true
+      end
+      private :install_bin_pkg
 
-      FileUtils.mv(gem_file_name, 'pkg')
     end
 
   end

data/rakelib/install.rb

@@ -67,7 +67,7 @@ module WXRuby3
               FileUtils.ln_s(File.join('.', File.basename(src_shlib)), File.join('ext', File.basename(shlib)))
             else
               FileUtils.cp(shlib, inshlib = File.join('ext', File.basename(shlib)))
-              unless WXRuby3.config.patch_rpath(inshlib, WXRuby3.config.get_rpath_origin)
+              unless WXRuby3.config.update_shlib_loadpaths(inshlib)
                 # cleanup and exit
                 FileUtils.rm_f(Dir["ext/*.#{WXRuby3.config.dll_mask}"])
                 exit(1)
@@ -77,14 +77,14 @@ module WXRuby3
           end
           # prepare wxRuby shared libs
           Dir["lib/*.#{WXRuby3.config.dll_mask}"].each do |shlib|
-            unless WXRuby3.config.patch_rpath(shlib, WXRuby3.config.get_rpath_origin, "#{WXRuby3.config.get_rpath_origin}/../ext")
+            unless WXRuby3.config.update_shlib_loadpaths(shlib) && WXRuby3.config.update_shlib_ruby_libpath(shlib)
               # cleanup and exit
               FileUtils.rm_f(Dir["ext/*.#{WXRuby3.config.dll_mask}"])
               exit(1)
             end
           end
           (wxwin_inshlibs + Dir["lib/*.#{WXRuby3.config.dll_mask}"]).each do |shlib|
-            unless WXRuby3.config.update_shlib_loadpaths(shlib, WXRuby3::Install.wxwin_shlibs)
+            unless WXRuby3.config.update_shlib_wxwin_libpaths(shlib, WXRuby3::Install.wxwin_shlibs)
               # cleanup and exit
               FileUtils.rm_f(Dir["ext/*.#{WXRuby3.config.dll_mask}"])
               exit(1)

data/rakelib/lib/config/{cygwin.rb → freebsd.rb}

@@ -6,4 +6,4 @@
 # wxRuby3 buildtools configuration
 ###
 
-raise "Cygwin platform is unsupported as yet."
+raise "Freebsd platform is unsupported as yet."

data/rakelib/lib/config/linux.rb

@@ -7,7 +7,7 @@
 ###
 
 require_relative './unixish'
-require_relative 'pkgman/base'
+require_relative 'pkgman/linux'
 
 module WXRuby3
 
@@ -42,6 +42,7 @@ module WXRuby3
             end
             true
           end
+          protected :check_rpath_patch
 
           def patch_rpath(shlib, *rpath)
             if check_rpath_patch
@@ -50,6 +51,7 @@ module WXRuby3
             end
             false
           end
+          protected :patch_rpath
 
           def check_tool_pkgs
             pkg_deps = super

data/rakelib/lib/config/macosx.rb

@@ -9,6 +9,8 @@
 require_relative './unixish'
 require_relative 'pkgman/macosx'
 
+require 'pathname'
+
 module WXRuby3
 
   module Config
@@ -33,12 +35,7 @@ module WXRuby3
           def get_rpath_origin
             "@loader_path"
           end
-
-          def check_rpath_patch
-            # no need to check anything; install_name_tool is part of XCode cmdline tools
-            # and without these we couldn't build anything
-            true
-          end
+          protected :get_rpath_origin
 
           def patch_rpath(shlib, *rpath)
             # don't leave old rpath-s behind
@@ -47,13 +44,44 @@ module WXRuby3
             sh("install_name_tool #{rpath.collect {|rp| "-add_rpath '#{rp}'"}.join(' ')} #{shlib} 2>/dev/null", verbose: false) { |_,_| }
             true
           end
-
-          def update_shlib_loadpaths(shlib, deplibs)
-            changes = deplibs.collect { |dl| "-change '#{dl}' '@rpath/#{File.basename(dl)}'"}
-            sh("install_name_tool #{changes.join(' ')} #{shlib} 2>/dev/null", verbose: false) { |_,_| }
+          protected :patch_rpath
+
+          # add Ruby library path for wxruby shared libraries
+          def update_shlib_ruby_libpath(shlib)
+            # fix lookup for the Ruby shared library
+            # on MacOSX the Ruby library will be linked with it's full path from the **development** environment
+            # which is no use after binary deployment so we change that to be relative to the executable's path
+            # loading the shared libs (which is always going to be the Ruby exe)
+
+            # get the development folder holding ruby lib
+            ruby_libdir = Pathname.new(RB_CONFIG['libdir'])
+            # determine the relative path to the lib directory from the executable dir
+            # (this remains constant for any similar deployed Ruby for this platform)
+            rel_ruby_libdir = ruby_libdir.relative_path_from(RB_CONFIG['bindir'])
+            # get the Ruby library name used for linking
+            ld_ruby_lib = (RB_CONFIG['LIBRUBYARG_SHARED'].split.find { |s| s =~ /^-lruby/ }).sub(/^-l/,'')
+            # match the full shared library name that will be linked
+            ruby_so = [RB_CONFIG['LIBRUBY_SO'], RB_CONFIG['LIBRUBY_SONAME'], *RB_CONFIG['LIBRUBY_ALIASES'].split].find do |soname|
+              soname =~ /^lib#{ld_ruby_lib}\./
+            end
+            # form the full path of the shared Ruby library linked
+            ruby_lib = File.join(ruby_libdir.to_s, RB_CONFIG['LIBRUBY_SO'])
+            # change the full path to a path relative to the Ruby executable
+            sh("install_name_tool -change #{ruby_lib} '@executable_path/#{rel_ruby_libdir.to_s}/#{ruby_so}' #{shlib}")
             true
           end
 
+          # add deployment lookup paths for wxwidgets shared libraries
+          def update_shlib_wxwin_libpaths(shlib, deplibs)
+            if super
+              changes = deplibs.collect { |dl| "-change '#{dl}' '@rpath/#{File.basename(dl)}'"}
+              sh("install_name_tool #{changes.join(' ')} #{shlib} 2>/dev/null", verbose: false) { |_,_| }
+              true
+            else
+              false
+            end
+          end
+
           def check_tool_pkgs
             pkg_deps = super
             # need g++ to build wxRuby3 extensions in any case
@@ -104,7 +132,10 @@ module WXRuby3
           private
 
           def wx_configure
-            bash('./configure --disable-optimise --disable-sys-libs --without-liblzma --prefix=`pwd`/install --disable-tests --without-subdirs --disable-debug_info CFLAGS="-Wno-unused-but-set-variable"')
+            bash("./configure --with-macosx-version-min=#{WXRuby3.config.sysinfo.os.release}.0 " +
+                   "--disable-optimise --disable-sys-libs --without-liblzma --without-regex " +
+                   "--prefix=`pwd`/install --disable-tests --without-subdirs --disable-debug_info " +
+                   "CFLAGS=\"-Wno-unused-but-set-variable\"")
           end
 
           def wx_make

data/rakelib/lib/config/mingw.rb

@@ -171,7 +171,7 @@ module WXRuby3
             mkdir(tmp_tool_root) unless File.directory?(tmp_tool_root)
             # download
             chdir(tmp_tool_root) do
-              unless sh("curl -L #{url} --output #{zip}")
+              unless download_file(url, zip)
                 STDERR.puts "ERROR: Failed to download installation package for #{exe}"
                 exit(1)
               end
@@ -242,7 +242,7 @@ module WXRuby3
           @wx_cppflags.each { |flags| flags.gsub!(/-I(\S+)/) { |s| "-I#{win_path($1)}" } }
           @wx_libs.each { |libflag| libflag.gsub!(/-L(\S+)/) { |s| "-L#{win_path($1)}" } }
 
-          @extra_cflags.concat %w[-Wno-unused-function -Wno-conversion-null -Wno-maybe-uninitialized]
+          @extra_cflags.concat %w[-Wno-unused-function -Wno-conversion-null -Wno-maybe-uninitialized -Wno-deprecated-copy]
           @extra_cflags << ' -Wno-deprecated-declarations' unless @no_deprecated
 
           # create a .dll binary

data/rakelib/lib/config/pkgman/{base.rb → linux.rb}

@@ -14,6 +14,17 @@ module WXRuby3
 
       module PkgManager
 
+        PLATFORM_DEPS = {
+          debian: %w[libgtk-3-dev libwebkit2gtk-4.0-dev libgspell-1-dev libunwind-dev libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libcurl4-openssl-dev libsecret-1-dev libnotify-dev],
+          rhel: %w[expat-devel findutils gspell-devel gstreamer1-plugins-base-devel gtk3-devel libcurl-devel libjpeg-devel libnotify-devel libpng-devel libSM-devel libsecret-devel libtiff-devel SDL-devel webkit2gtk4.1-devel zlib-devel],
+          suse: %w[gtk3-devel webkit2gtk3-devel gspell-devel gstreamer-devel gstreamer-plugins-base-devel libcurl-devel libsecret-devel libnotify-devel libSDL-devel zlib-devel libjpeg-devel libpng-devel],
+          arch: %w[pkg-config gtk3 webkit2gtk gspell libunwind gstreamer curl libsecret libnotify libpng12]
+        }
+        PLATFORM_ALTS = {
+          suse: { 'g++' => 'gcc-c++' },
+          rhel: { 'git' => 'git-core' },
+          arch: { 'g++' => 'gcc' }
+        }
         MIN_GENERIC_PKGS = %w[gtk3-devel patchelf g++ make git webkit2gtk3-devel gspell-devel gstreamer-devel gstreamer-plugins-base-devel libcurl-devel libsecret-devel libnotify-devel libSDL-devel zlib-devel]
 
         class << self
@@ -21,25 +32,21 @@ module WXRuby3
           def install(pkgs)
             # do we need to install anything?
             if !pkgs.empty? || builds_wxwidgets?
-              # determine the linux distro specs
-              distro = get_distro
-              begin
-                # load distro installation support
-                require_relative "./#{distro[:type]}"
-              rescue LoadError
+              # check linux distro compatibility
+              unless no_autoinstall? || pkgman
                 # do we need to build wxWidgets?
                 pkgs.concat(MIN_GENERIC_PKGS) if builds_wxwidgets?
                 $stderr.puts <<~__ERROR_TXT
-                  ERROR: Do not know how to install required packages for distro type '#{distro[:type]}'.
+                  ERROR: Do not know how to install required packages for distro type '#{WXRuby3.config.sysinfo.os.variant}'.
   
-                  Make sure the following packages (or equivalent) are installed and than try again with `WXRUBY_NO_AUTOINSTALL=1`:
+                  Make sure the following packages (or equivalent) are installed and than try again with `--no-autoinstall`:
                   #{pkgs.join(', ')}
                   __ERROR_TXT
                 exit(1)
               end
               # can we install?
               unless no_autoinstall? || has_sudo? || is_root?
-                $stderr.puts 'ERROR: Cannot check for or install required packages. Please install sudo or run as root and try again.'
+                $stderr.puts 'ERROR: Cannot check for or install required packages. Please install sudo and try again.'
                 exit(1)
               end
               # do we need to build wxWidgets?
@@ -60,7 +67,7 @@ module WXRuby3
                   exit(1)
                 end
                 # do the actual install
-                unless do_install(distro, pkgs)
+                unless run(pkgman.make_install_command(*pkgs))
                   $stderr.puts <<~__ERROR_TXT
                     ERROR: Failed to install all or some of the following required software packages:
                     #{pkgs.join(', ')}
@@ -78,6 +85,23 @@ module WXRuby3
 
           private
 
+          def pkgman
+            @pkgman ||= WXRuby3.config.sysinfo.os.pkgman
+          end
+
+          def platform_pkgs
+            PLATFORM_DEPS[WXRuby3.config.sysinfo.os.variant.to_sym] || []
+          end
+
+          def add_platform_pkgs(pkgs)
+            # transform any platform specific package alternatives
+            (PLATFORM_ALTS[WXRuby3.config.sysinfo.os.variant.to_sym] || {}).each_pair do |org, alt|
+              pkgs << alt if pkgs.delete(org)
+            end
+            # add any other platform specific package dependencies
+            pkgs.concat(pkgman.select_uninstalled(platform_pkgs))
+          end
+
           def builds_wxwidgets?
             Config.get_config('with-wxwin') && Config.get_cfg_string('wxwin').empty?
           end
@@ -100,8 +124,8 @@ module WXRuby3
 
           def run(cmd)
             $stdout.print "Running #{cmd}..."
-            rc = WXRuby3.config.sh("#{is_root? ? '' : 'sudo '}#{cmd}")
-            $stderr.puts (rc ? 'done!' : 'FAILED!')
+            rc = WXRuby3.config.sh(cmd)
+            $stderr.puts(rc ? 'done!' : 'FAILED!')
             rc
           end
 
@@ -109,55 +133,6 @@ module WXRuby3
             `#{is_root? ? '' : 'sudo '}#{cmd}`
           end
 
-          def get_distro
-            if File.file?('/etc/os-release') # works with most (if not all) recent distro releases
-              data = File.readlines('/etc/os-release').reduce({}) do |hash, line|
-                val, var = line.split('=')
-                hash[val] = var.strip.gsub(/(\A")|("\Z)/, '')
-                hash
-              end
-              {
-                type: if data['ID_LIKE']
-                        data['ID_LIKE'].split.first.to_sym
-                      elsif File.file?('/etc/redhat-release')
-                        :rhel
-                      elsif File.file?('/etc/SUSE-brand') || File.file?('/etc/SuSE-release')
-                        :suse
-                      elsif File.file?('/etc/debian_version')
-                        :debian
-                      else
-                        data['ID'].to_sym
-                      end,
-                distro: data['ID'].downcase,
-                release: data['VERSION_ID']
-              }
-            elsif File.file?('/etc/redhat-release')
-              data = File.read('/etc/redhat-release').strip
-              {
-                type: :rhel,
-                distro: data.split.shift.downcase,
-                release: data =~ /\d+(\.\d+)*/ ? $~[0] : ''
-              }
-            elsif File.file?('/etc/SUSE-brand') || File.file?('/etc/SuSE-release')
-              data = File.readlines(File.file?('/etc/SUSE-brand') ? '/etc/SUSE-brand' : '/etc/SuSE-release')
-              {
-                type: :suse,
-                distro: data.shift.split.shift.downcase,
-                release: (data.find { |s| s.strip =~ /\AVERSION\s*=/ } || '').split('=').last || ''
-              }
-            elsif File.file?('/etc/debian_version')
-              {
-                type: :debian,
-                distro: 'generic',
-                release: File.read('/etc/debian_version').strip
-              }
-            else
-              {
-                type: :unknown
-              }
-            end
-          end
-
         end
 
       end