plat4m 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9df6b644a5e122916e8230965e4e4999441bd067706d2679e905008f0000c0f8
+  data.tar.gz: 0efb88c4163e04fef3499e3f542d9a003ffb7fdd28ced4ff0db4a1d8fb3aa8d8
+SHA512:
+  metadata.gz: e7101d9e5feba298a1b945b010996a7d48f26d3267f31da53b041cf5b4e936eeff29ed8e5ff6277d6548c5d4efda9de05b2779000d3100d611474a99196c5bd7
+  data.tar.gz: d8c7db00c80acc09fe3308b04a33a522263ffe71b40b01096ab5da4614b9b0486c349907d9f66a440feb738e82ef15e96f10f146a93b451f9f2c970450213e1a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Martin Corino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+[![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg)](LICENSE)
+[![Gem Version](https://badge.fury.io/rb/plat4m.svg)](https://badge.fury.io/rb/plat4m)
+
+# Plat4m
+
+Plat4m is a simple runtime system platform scouting and support library specially intended to 
+be used with other Ruby projects to provide light weight runtime system detection and provide 
+support for simple system package management (install/uninstall) support.
+
+Plat4m is definitely not intended as a full fledged runtime system detection system and/or a 
+complete system management solution.

data/lib/plat4m/pkgman.rb

@@ -0,0 +1,60 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m PkgManager
+
+
+module Plat4m
+
+  class PkgManager
+
+    def initialize
+      @has_sudo = false
+    end
+
+    def installed?(pkg)
+      raise NoMethodError
+    end
+
+    def select_uninstalled(*pkgs)
+      pkgs.flatten.select { |pkg| !installed?(pkg) }
+    end
+
+    def available?(pkg)
+      raise NoMethodError
+    end
+
+    def select_available(*pkgs)
+      pkgs.flatten.select { |pkg| available?(pkg) }
+    end
+
+    def make_install_command(*pkgs)
+      raise NoMethodError
+    end
+
+    def install(*pkgs, silent: false)
+      cmd = make_install_command
+      silent ? system("#{cmd} >/dev/null 2>&1") : system(cmd)
+    end
+
+    def make_uninstall_command(*pkgs)
+      raise NoMethodError
+    end
+
+    def uninstall(*pkgs, silent: false)
+      cmd = make_uninstall_command
+      silent ? system("#{cmd} >/dev/null 2>&1") : system(cmd)
+    end
+
+    def is_root?
+      false
+    end
+
+    def has_sudo?
+      @has_sudo
+    end
+
+  end
+
+end

data/lib/plat4m/sniff/darwin.rb

@@ -0,0 +1,206 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m Linux sniffer
+
+
+module Plat4m
+
+  module Sniffer
+
+    module Darwin
+
+      class << self
+
+        def detect_system
+          # determine system platform
+          System.new(System::Platform.new(arch: get_arch, cpus: get_cpu_count),
+                     System::OS.new(id: :darwin, **get_distro))
+        end
+
+        private
+
+        def get_arch
+          arch, _ = RbConfig::CONFIG['arch'].split('-')
+          arch = 'x86' if arch =~ /i\d86/
+          arch
+        end
+
+        def get_cpu_count
+          (system('command -v nproc > /dev/null 2>&1') ? `nproc` : `getconf _NPROCESSORS_ONLN`).to_i
+        end
+
+        def get_distro
+          distro = {
+            distro: 'macosx'
+          }
+          ver = `sw_vers --productVersion`.strip
+          distro[:release] = ver.split('.').first
+          distro[:version] = ver
+          distro[:pkgman] = MacPkgManager.new
+          distro
+        end
+
+        def has_macports?
+          if @has_macports.nil?
+            @has_macports = system('command -v port>/dev/null')
+          end
+        end
+
+        def has_homebrew?
+          if @has_homebrew.nil?
+            @has_homebrew = system('command -v brew>/dev/null')
+          end
+        end
+
+      end
+
+      class MacPkgManager < PkgManager
+
+        def initialize
+          super
+          @has_sudo = system('command -v sudo > /dev/null')
+          @has_macports = system('command -v port>/dev/null')
+          @has_homebrew = system('command -v brew>/dev/null')
+        end
+
+        def installed?(pkg)
+          pkg_manager.installed?(pkg)
+        end
+
+        def available?(pkg)
+          pkg_manager.available?(pkg)
+        end
+
+        def make_install_command(*pkgs)
+          pkg_manager.make_install_command(*pkgs)
+        end
+
+        def make_uninstall_command(*pkgs)
+          pkg_manager.make_uninstall_command(*pkgs)
+        end
+
+        def macports?
+          MacPorts === pkg_manager
+        end
+
+        def homebrew?
+          Homebrew === pkg_manager
+        end
+
+        private
+
+        def is_root?
+          `id -u 2>/dev/null`.chomp == '0'
+        end
+
+        def has_macports?
+          if @has_macports.nil?
+            @has_macports = system('command -v port>/dev/null')
+          end
+        end
+
+        def has_homebrew?
+          if @has_homebrew.nil?
+            @has_homebrew = system('command -v brew>/dev/null')
+          end
+        end
+
+        class Homebrew < PkgManager
+
+          def initialize(owner)
+            super()
+            @owner = owner
+            @has_sudo = @owner.has_sudo?
+          end
+
+          def installed?(pkg)
+            `brew list -1 --formula`.strip.split("\n").include?(pkg) ||
+              `brew list -1 --cask`.strip.split("\n").include?(pkg)
+          end
+
+          def available?(pkg)
+            system(%Q[brew search "/^#{pkg}$/" >/dev/null 2>&1])
+          end
+
+          def make_install_command(*pkgs)
+            "brew install -q #{pkgs.join(' ')}"
+          end
+
+          def make_uninstall_command(*pkgs)
+            "brew uninstall -q #{pkgs.join(' ')}"
+          end
+
+        end
+
+        class MacPorts < PkgManager
+
+          def initialize(owner)
+            super()
+            @owner = owner
+            @has_sudo = @owner.has_sudo?
+            @privileged = File.stat(`which port`.strip).uid == 0
+          end
+
+          def installed?(pkg)
+            !(`port -q installed #{pkg}`.strip.empty?)
+          end
+
+          def available?(pkg)
+            !(`port -q search --exact #{pkg}`.strip.empty?)
+          end
+
+          def make_install_command(*pkgs)
+            auth_cmd("port install #{pkgs.join(' ')}")
+          end
+
+          def make_uninstall_command(*pkgs)
+            auth_cmd("port uninstall #{pkgs.join(' ')}")
+          end
+
+          private
+
+          def is_root?
+            @owner.is_root?
+          end
+
+          def auth_cmd(cmd)
+            raise "Cannot find 'sudo' for command [#{cmd}]" unless !@privileged || is_root? || @has_sudo
+            (!@privileged || is_root?) ? cmd : "sudo #{cmd}"
+          end
+
+        end
+
+        def pkg_manager
+          unless @pkg_manager
+            # # Has Ruby been installed through MacPorts?
+            # if has_macports? &&
+            #   expand('port -q installed installed').strip.split("\n").find { |ln| ln.strip =~ /\Aruby\d+\s/ }
+            #   @pkg_manager = MacPorts.new
+
+            # re we running without root privileges and have Homebrew installed?
+            # (Ruby may be installed using Homebrew itself or using a Ruby version manager like RVM)
+            if !is_root? && has_homebrew?
+              @pkg_manager = Homebrew.new(self)
+
+            # or do we have MacPorts (running either privileged or not).
+            elsif has_macports?
+              @pkg_manager = MacPorts.new(self)
+
+            else
+              raise RuntimeError, 'Unable to determine package manager to use!'
+            end
+          end
+          @pkg_manager
+        end
+
+      end
+
+    end
+
+  end
+
+  self.sniffers[:darwin] = Sniffer::Darwin
+
+end

data/lib/plat4m/sniff/freebsd.rb

@@ -0,0 +1,51 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m Freebsd sniffer
+
+
+module Plat4m
+
+  module Sniffer
+
+    module Freebsd
+
+      class << self
+
+        def detect_system
+          # determine system platform
+          System.new(System::Platform.new(arch: get_arch, cpus: get_cpu_count),
+                     System::OS.new(id: :freebsd, **get_distro))
+        end
+
+        private
+
+        def get_arch
+          arch, _ = RbConfig::CONFIG['arch'].split('-')
+          arch = 'x86' if arch =~ /i\d86/
+          arch
+        end
+
+        def get_cpu_count
+          (system('command -v nproc > /dev/null 2>&1') ? `nproc` : `getconf NPROCESSORS_ONLN`).to_i
+        end
+
+        def get_distro
+          distro = {
+            distro: 'freebsd'
+          }
+          distro[:release] = 0
+          distro[:pkgman] = nil
+          distro
+        end
+
+      end
+
+    end
+
+  end
+
+  self.sniffers[:freebsd] = Sniffer::Freebsd
+
+end

data/lib/plat4m/sniff/linux.rb

@@ -0,0 +1,260 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m Linux sniffer
+
+
+module Plat4m
+
+  module Sniffer
+
+    module Linux
+
+      class << self
+
+        def detect_system
+          # determine system platform
+          System.new(System::Platform.new(arch: get_arch, cpus: get_cpu_count),
+                     System::OS.new(id: :linux, **get_distro))
+        end
+
+        private
+
+        def get_arch
+          arch, _ = RbConfig::CONFIG['arch'].split('-')
+          arch = 'x86' if arch =~ /i\d86/
+          arch
+        end
+
+        def get_cpu_count
+          (system('command -v nproc > /dev/null 2>&1') ? `nproc` : `getconf _NPROCESSORS_ONLN`).to_i
+        end
+
+        def get_distro
+          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
+                     {
+                       variant: 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
+                     {
+                       variant: :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')
+                     {
+                       variant: :suse,
+                       distro: data.shift.split.shift.downcase,
+                       release: (data.find { |s| s.strip =~ /\AVERSION\s*=/ } || '').split('=').last || ''
+                     }
+                   elsif File.file?('/etc/debian_version')
+                     {
+                       variant: :debian,
+                       distro: 'generic',
+                       release: File.read('/etc/debian_version').strip.split('.').shift
+                     }
+                   else
+                     {
+                     }
+                   end
+          distro[:pkgman] = case distro[:variant]
+                            when :debian
+                              Apt.new(distro)
+                            when :rhel
+                              Dnf.new(distro)
+                            when :suse
+                              Zypper.new(distro)
+                            when :arch
+                              Pacman.new(distro)
+                            end
+          distro
+        end
+
+      end
+
+      class NixManager < PkgManager
+
+        def initialize(_distro)
+          super()
+          @has_sudo = system('command -v sudo > /dev/null')
+        end
+
+        def make_install_command(*pkgs)
+          auth_cmd(get_install_command(*pkgs))
+        end
+
+        def make_uninstall_command(*pkgs)
+          auth_cmd(get_uninstall_command(*pkgs))
+        end
+
+        protected
+
+        def get_install_command(*pkgs)
+          raise NoMethodError
+        end
+
+        def get_uninstall_command(*pkgs)
+          raise NoMethodError
+        end
+
+        def is_root?
+          `id -u 2>/dev/null`.chomp == '0'
+        end
+
+        def auth_cmd(cmd)
+          raise "Cannot find 'sudo' for command [#{cmd}]" unless is_root? || has_sudo?
+          is_root? ? cmd : "sudo #{cmd}"
+        end
+
+      end
+
+      class Apt < NixManager
+
+        def installed?(pkg)
+          # get architecture
+          system("dpkg-query -s \"#{pkg}:#{pkg_arch}\" >/dev/null 2>&1") ||
+            system("dpkg-query -s \"#{pkg}:all\" >/dev/null 2>&1") ||
+            (`dpkg-query -s \"#{pkg}\" 2>/dev/null`.strip =~ /Architecture: (#{pkg_arch}|all)/)
+        end
+
+        def available?(pkg)
+          apt_cache.include?(pkg)
+        end
+
+        protected
+
+        def apt_cmd(cmd)
+          "DEBIAN_FRONTEND=noninteractive apt-get -q -o=Dpkg::Use-Pty=0 #{cmd}"
+        end
+
+        def get_install_command(*pkgs)
+          apt_cmd("install -y #{pkgs.flatten.join(' ')}")
+        end
+
+        def get_uninstall_command(*pkgs)
+          apt_cmd("remove -y #{pkgs.flatten.join(' ')}")
+        end
+
+        def update_pkgs
+          system(auth_cmd(apt_cmd('update')))
+        end
+
+        def apt_cache
+          unless @apt_cache
+            update_pkgs
+            @apt_cache = `apt-cache pkgnames`.chomp.split("\n").collect { |s| s.strip }
+          end
+          @apt_cache
+        end
+
+        def pkg_arch
+          @pkg_arch ||= `dpkg --print-architecture`.strip
+        end
+
+      end
+
+      class Dnf < NixManager
+
+        def installed?(pkg)
+          system("dnf list installed #{pkg} >/dev/null 2>&1")
+        end
+
+        def available?(pkg)
+          !!(`dnf repoquery --info #{pkg} 2>/dev/null`.strip =~ /Name\s*:\s*#{pkg}/)
+        end
+
+        protected
+
+        def dnf_cmd(cmd)
+          "dnf #{cmd}"
+        end
+
+        def get_install_command(*pkgs)
+          dnf_cmd("install -y #{pkgs.flatten.join(' ')}")
+        end
+
+        def get_uninstall_command(*pkgs)
+          dnf_cmd("remove -y #{pkgs.flatten.join(' ')}")
+        end
+
+      end
+
+      class Zypper < NixManager
+
+        def installed?(pkg)
+          system("rpm -q --whatprovides #{pkg} >/dev/null 2>&1")
+        end
+
+        def available?(pkg)
+          system("zypper -x -t package #{pkg} >/dev/null 2>&1")
+        end
+
+        protected
+
+        def zypper_cmd(cmd)
+          "zypper -t -i #{cmd}"
+        end
+
+        def get_install_command(*pkgs)
+          zypper_cmd("install -y #{pkgs.flatten.join(' ')}")
+        end
+
+        def get_uninstall_command(*pkgs)
+          zypper_cmd("remove -y #{pkgs.flatten.join(' ')}")
+        end
+
+      end
+
+      class Pacman < NixManager
+
+        def installed?(pkg)
+          system("pacman -Qq #{pkg} >/dev/null 2>&1")
+        end
+
+        def available?(pkg)
+          system(%Q[pacman -Ss "^#{pkg}$" >/dev/null 2>&1])
+        end
+
+        protected
+
+        def pacman_cmd(cmd)
+          "pacman --noconfirm #{cmd}"
+        end
+
+        def get_install_command(*pkgs)
+          pacman_cmd("-S --needed #{ pkgs.join(' ') }")
+        end
+
+        def get_uninstall_command(*pkgs)
+          pacman_cmd("-Rsu #{pkgs.flatten.join(' ')}")
+        end
+
+      end
+
+    end
+
+  end
+
+  self.sniffers[:linux] = Sniffer::Linux
+
+end

data/lib/plat4m/sniff/windows.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m Windows sniffer
+
+
+module Plat4m
+
+  module Sniffer
+
+    module Windows
+
+      class << self
+
+        def detect_system
+          # determine system platform
+          System.new(System::Platform.new(arch: get_arch, cpus: get_cpu_count),
+                     System::OS.new(id: :windows, **get_distro))
+        end
+
+        private
+
+        def get_arch
+          arch, _ = RbConfig::CONFIG['arch'].split('-')
+          arch = 'x86' if arch =~ /i\d86/
+          arch
+        end
+
+        def get_cpu_count
+          ENV['NUMBER_OF_PROCESSORS'].to_i
+        end
+
+        def get_distro
+          distro = {
+            distro: 'windows'
+          }
+          # the 'ver' command returns something like "Microsoft Windows [Version xx.xx.xx.xx]"
+          match = `ver`.strip.match(/\[(.*)\]/)
+          ver = match[1].split.last
+          distro[:release] = ver.split('.').shift
+          distro[:version] = ver
+          distro[:pkgman] = nil
+          distro
+        end
+
+      end
+
+    end
+
+  end
+
+  self.sniffers[:windows] = Sniffer::Darwin
+
+end

data/lib/plat4m/system.rb

@@ -0,0 +1,179 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m System class
+
+
+module Plat4m
+
+  # Instances of this class identify a system and provide access to system management support.
+  class System
+
+    # Provides information about the hardware platform.
+    class Platform
+
+      def initialize(arch: nil, cpus: nil)
+        @arch = arch
+        @bits = @arch.to_s =~ /64/ ? 64 : 32
+        @cpus = cpus
+      end
+
+      attr_reader :arch, :bits, :cpus
+
+      def complete?
+        ::String === @arch && !@arch.empty? &&
+          ::Integer === cpus && @cpus>0
+      end
+
+      def to_s
+        "[#{@arch}: #{@bits}bits, #{cpus} cpu]"
+      end
+
+    end
+
+    # Provides information about the operating system.
+    class OS
+
+      def initialize(id: nil, distro: nil, variant: nil, release: nil, pkgman: nil, **other)
+        @id = id
+        @distro = distro
+        @variant = variant
+        @release = release
+        @pkgman = pkgman
+        @other = other
+        @other.each_key do |key|
+          unless self.method(key.to_sym)
+            singleton_class.class_eval <<~__CODE
+              define_method(:#{key}) do
+                @other['#{key}']
+              end
+            __CODE
+          end
+        end
+      end
+
+      attr_reader :id, :distro, :release, :pkgman
+
+      def variant
+        @variant || @distro
+      end
+
+      alias :distribution :distro
+
+      def complete?
+        ::Symbol === @id &&
+          ::String === @distro && !@distro.empty?
+          ::String === @release && !@release.empty?
+      end
+
+      def is_root?
+        @pkgman ? @pkgman.is_root? : false
+      end
+
+      def has_sudo?
+        @pkgman ? @pkgman.has_sudo? : false
+      end
+
+      def to_s
+        "#{@distro}-#{@release}[#{@id}#{@variant ? " #{@variant}" : ''}}]"
+      end
+
+    end
+
+    def initialize(platform, os)
+      unless platform && platform.complete? && os && os.complete?
+        raise "Invalid system specification [#{os} @ #{platform}]"
+      end
+      @platform = platform
+      @os = os
+    end
+
+    attr_reader :platform, :os
+
+    def kind
+      "#{@platform.arch}-#{@os.id}"
+    end
+
+    def intel?
+      @platform.arch =~ /x86/
+    end
+
+    def arm?
+      @platform.arch =~ /arm/
+    end
+
+    def bits
+      @platform.bits
+    end
+
+    def cpu_count
+      @platform.cpus
+    end
+
+    def linux?
+      @os.id == :linux
+    end
+
+    def windows?
+      @os.id == :windows
+    end
+
+    def darwin?
+      @os.id == :darwin
+    end
+
+    def macosx?
+      darwin? && @os.distro == 'MacOSX'
+    end
+    alias :osx? :macosx?
+
+    def freebsd?
+      @os.id == :freebsd
+    end
+
+    def dev_null
+      windows? ? 'NUL' : '/dev/null'
+    end
+
+  end
+
+  class << self
+
+    # Returns System instance for current system.
+    def current
+      @current ||= detect_current
+    end
+
+    # System sniffer registry.
+    def sniffers
+      @sniffers ||= {}
+    end
+
+    def detect_current
+      case RbConfig::CONFIG['host_os']
+      when /linux/
+        sniffers[:linux].detect_system
+      when /darwin/
+        sniffers[:darwin].detect_system
+      when /freebsd/
+        sniffers[:freebsd].detect_system
+      else
+        if ENV['OS'] =~ /windows/i
+          sniffers[:windows].detect_system
+        else
+          raise "Unknown system!"
+        end
+      end
+    end
+    private :detect_current
+
+  end
+
+end
+
+require_relative 'pkgman'
+require_relative 'sniff/darwin'
+require_relative 'sniff/linux'
+require_relative 'sniff/windows'
+require_relative 'sniff/freebsd'

data/lib/plat4m/version.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m version
+
+
+module Plat4m
+
+  # Current Plat4m version.
+  VERSION = '1.0.0'
+
+end

data/lib/plat4m.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+#
+# Plat4m loader
+
+
+# Plat4m provides methods and classes to scout the details of the computer system and
+# support system management tasks.
+module Plat4m
+
+end
+
+require_relative 'plat4m/version'
+require_relative 'plat4m/system'

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: plat4m
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Martin Corino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-02-20 00:00:00.000000000 Z
+dependencies: []
+description: Plat4m is a simple runtime system platform scouting and support library.
+email: mcorino@m2c-software.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/plat4m.rb
+- lib/plat4m/pkgman.rb
+- lib/plat4m/sniff/darwin.rb
+- lib/plat4m/sniff/freebsd.rb
+- lib/plat4m/sniff/linux.rb
+- lib/plat4m/sniff/windows.rb
+- lib/plat4m/system.rb
+- lib/plat4m/version.rb
+homepage: https://github.com/mcorino/plat4m
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/mcorino/plat4m/issues
+  homepage_uri: https://github.com/mcorino/plat4m
+  github_repo: https://github.com/mcorino/plat4m
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: Runtime system detection.
+test_files: []