macos.rb 0.50.0

data/lib/MacOS/DiskUtil.rb

@@ -0,0 +1,63 @@
+# MacOS/DiskUtil.rb
+# MacOS::DiskUtil
+
+require 'plist'
+
+module MacOS
+  class DiskUtil
+
+    class << self
+      def xml_volume_plist
+        `diskutil list -plist`
+      end
+
+      def volume_plist
+        Plist.parse_xml(xml_volume_plist)
+      end
+
+      def volumes_and_partitions
+        volume_plist["AllDisksAndPartitions"].select do |dp|
+          !dp["Partitions"].empty?
+        end
+      end
+
+      def volume_partitions(volume)
+        volume["Partitions"]
+      end
+
+      def volumes
+        volumes_and_partitions.collect do |volume|
+          volume_partitions(volume).collect do |partition|
+            {
+              device_id: partition["DeviceIdentifier"],
+              mount_point: partition["MountPoint"],
+              name: partition["VolumeName"],
+              size: partition["Size"],
+            }
+          end
+        end.flatten.compact
+      end
+
+      def external_volumes
+        volumes.reject{|v| v[:mount_point].nil?}
+      end
+
+      def free_bytes_for_device_id(device_id)
+        `df -k`.split("\n").detect do |partition_data|
+          if partition_data.split.first.match(device_id)
+            return partition_data.split[3].to_i * 1024
+          end
+        end
+      end
+
+      def free_bytes_for_volume_name(volume_name)
+        `df -k`.split("\n").detect do |partition_data|
+          if partition_data.split.last.match(volume_name)
+            return partition_data.split[3].to_i * 1024
+          end
+        end
+      end
+    end # class << self
+
+  end
+end

data/lib/MacOS/Dmg.rb

@@ -0,0 +1,99 @@
+# MacOS/Dmg.rb
+# MacOS::Dmg
+
+# History: Extracted the methods from install_macports to be used in install_homebrew, but didn't finish this and just placed the methods (with some modification) directly into install_homebrew.
+
+require 'shellwords'
+
+module MacOS
+  class Dmg
+
+    class << self
+      attr_accessor :verbose
+
+      def mount(path_to_dmg)
+        puts "hdiutil attach #{Shellwords.escape(path_to_dmg)}" if verbose
+        system "hdiutil attach #{Shellwords.escape(path_to_dmg)}"
+      end
+      alias_method :attach, :mount
+
+      def run_installer(mount_point:, pkg_name:)
+        starting_working_directory = Dir.pwd
+        puts "cd #{full_path_to_mount_point(mount_point)}" if verbose
+        Dir.chdir(full_path_to_mount_point(mount_point))
+        puts "sudo installer -pkg #{Shellwords.escape(pkg_name)} -target '/'" if verbose
+        system "sudo installer -pkg #{Shellwords.escape(pkg_name)} -target '/'"
+        Dir.chdir(starting_working_directory)
+      end
+
+      def unmount(mount_point)
+        puts "hdiutil detach -Force #{Shellwords.escape(full_path_to_mount_point(mount_point))}" if verbose
+        system "hdiutil detach -Force #{Shellwords.escape(full_path_to_mount_point(mount_point))}"
+      end
+      alias_method :detach, :unmount
+
+      def install(path_to_dmg:, disk_image_name:, mount_point: nil, package: nil)
+        dmg = new(path_to_dmg: path_to_dmg, disk_image_name: disk_image_name, mount_point: mount_point, package: package)
+        dmg.mount
+        dmg.run_installer
+        dmg.unmount
+      end
+
+      private
+
+      def full_path_to_mount_point(mount_point)
+        File.join('/', 'Volumes', mount_point)
+      end
+    end # class << self
+
+    attr_accessor :disk_image_name
+    attr_accessor :package
+    attr_accessor :path_to_dmg
+
+    attr_writer :mount_point
+    attr_writer :pkg_name
+
+    def initialize(path_to_dmg:, disk_image_name: nil, mount_point: nil, package: nil)
+      @path_to_dmg = path_to_dmg
+      @disk_image_name = disk_image_name
+      @mount_point = mount_point
+      @package = package
+    end
+
+    alias_method :filename, :disk_image_name
+    alias_method :dmg_filename, :disk_image_name
+    alias_method :image_name, :disk_image_name
+    alias_method :filename=, :disk_image_name=
+    alias_method :dmg_filename=, :disk_image_name=
+    alias_method :image_name=, :disk_image_name=
+
+    def pkg_name
+      @pkg_name || (@package + '.pkg')
+    end
+
+    def mount_point
+      @mount_point || @disk_image_name.split('.').first
+    end
+
+    def mount
+      MacOS::Dmg.mount(@path_to_dmg)
+    end
+    alias_method :attach, :mount
+
+    def run_installer
+      MacOS::Dmg.run_installer(pkg_name: pkg_name, mount_point: mount_point)
+    end
+
+    def unmount
+      MacOS::Dmg.unmount(mount_point)
+    end
+    alias_method :detach, :unmount
+
+    def install
+      mount
+      run_installer
+      unmount
+    end
+
+  end
+end

data/lib/MacOS/HardwarePort.rb

@@ -0,0 +1,79 @@
+# MacOS/HardwarePort.rb
+# MacOS::HardwarePort
+
+module MacOS
+  class HardwarePort
+
+    class << self
+
+      def parse(output = nil)
+        output ||= self.output
+        hardware_ports = []
+        hardware_port = nil
+        output.each_line do |line|
+          # p line
+          if line == "\n" || line == ""
+            hardware_ports << hardware_port if hardware_port
+            hardware_port = new
+          else
+            label, value = line.match(/^(.+): (.+)/)&.captures
+            case label
+            when 'Hardware Port'; hardware_port.hardware_port = value
+            when 'Device'; hardware_port.device = value
+            when 'Ethernet Address'; hardware_port.ethernet_address = value
+            end
+          end
+        end
+        hardware_ports
+      end
+      alias_method :all, :parse
+      alias_method :hardware_ports, :parse
+      alias_method :ports, :parse
+
+      def find_by_interface(interface)
+        all.detect{|hardware_port| hardware_port.interface == interface}
+      end
+      alias_method :find_by_device, :find_by_interface
+
+      def find_by_name(name)
+        all.detect{|hardware_port| hardware_port.name == name}
+      end
+      alias_method :find_by_hardware_port, :find_by_name
+
+      def find_by_mac_address(mac_address)
+        all.detect{|hardware_port| hardware_port.ethernet_address == mac_address}
+      end
+      alias_method :find_by_ethernet_address, :find_by_mac_address
+
+      private
+
+      def output
+        `networksetup -listallhardwareports`
+      end
+
+    end # class << self
+
+    attr_accessor :hardware_port
+    attr_accessor :device
+    attr_accessor :ethernet_address
+
+    def initialize(hardware_port: nil, device: nil, ethernet_address: nil)
+      @hardware_port = hardware_port
+      @device = device
+      @ethernet_address = ethernet_address
+    end
+
+    def name
+      @hardware_port
+    end
+
+    def mac_address
+      @ethernet_address
+    end
+
+    def interface
+      @device
+    end
+
+  end
+end

data/lib/MacOS/IfConfig.rb

@@ -0,0 +1,183 @@
+# MacOS/IfConfig.rb
+# MacOS::IfConfig
+
+module MacOS
+  class IfConfig
+    class << self
+      def parse(output = nil)
+        output ||= self.output
+        ifconfigs = []
+        ifconfig = nil
+        output.each_line do |line|
+          if line =~ /^\t/
+            case line
+            when /ether/
+              ifconfig.mac_address = line[/ *ether (.+?) ?$/, 1]
+            when /inet /
+              if line.match(/broadcast/)
+                ifconfig.ipv4_address, ifconfig.netmask, ifconfig.broadcast_address = line.match(/ *inet (\d+(?:\.\d+){3}) netmask (.+) broadcast (.+)$/)&.captures
+              elsif line.match(/-->/)
+                ipv4_address_from, ipv4_address_to, ifconfig.netmask = line.match(/inet (.+) --> (.+) netmask (.+)$/)&.captures
+                ifconfig.ipv4_address = ipv4_address_from
+              else
+                ifconfig.ipv4_address, ifconfig.netmask = line.match(/ *inet (\d+(?:\.\d+){3}) netmask (.+?) ?$/)&.captures
+              end
+            when /status\:/
+              ifconfig.status = line[/ *status: (.+)$/, 1]
+            end
+          else
+            ifconfigs << ifconfig if ifconfig
+            ifconfig = new
+            ifconfig.interface, rest_of_line = line.match(/^(.+?): (.+)$/)&.captures
+            if rest_of_line =~ /flags=\w+<([^>]+)>/
+              ifconfig.flags = $1.split(',')
+            end
+          end
+        end
+        ifconfigs << ifconfig if ifconfig
+        ifconfigs
+      end
+      alias_method :all, :parse
+      alias_method :interfaces, :parse
+      alias_method :all_interfaces, :parse
+
+      def interface_names
+        all.collect(&:interface_name)
+      end
+
+      def active_interfaces
+        all.select(&:active?)
+      end
+      alias_method :active, :active_interfaces
+
+      def active_interfaces_names
+        all.select(&:active?).collect(&:interface_name)
+      end
+
+      def inactive_interfaces
+        all.select(&:inactive?)
+      end
+      alias_method :inactive, :inactive_interfaces
+
+      def inactive_interfaces_names
+        all.select(&:inactive?).collect(&:interface_name)
+      end
+
+      def up_interfaces
+        all.select(&:up?)
+      end
+      alias_method :up, :up_interfaces
+
+      def up_interfaces_names
+        all.select(&:up?).collect(&:interface_name)
+      end
+
+      def mac_addresses
+        all.collect(&:mac_address).compact
+      end
+      alias_method :ethernet_addresses, :mac_addresses
+
+      def ipv4_addresses
+        all.collect(&:ipv4_address).compact
+      end
+
+      def find_by_interface(interface)
+        all.find{|ifconfig| ifconfig.interface == interface}
+      end
+
+      def find_by_mac_address(mac_address)
+        all.find{|ifconfig| ifconfig.mac_address == mac_address}
+      end
+
+      def find_by_ipv4_address(ipv4_address)
+        all.find{|ifconfig| ifconfig.ipv4_address == ipv4_address}
+      end
+
+      def all_matching(pattern)
+        pattern = Regexp.union(pattern)
+        all.select{|ifconfig| ifconfig.name =~ pattern}
+      end
+
+      def bring_down_interface(interface_name)
+        system('sudo', 'ifconfig', interface_name, 'down', exception: true)
+      end
+
+      def bring_down_matching_interfaces(pattern)
+        matching_interfaces = all_matching(pattern).select(&:up?)
+        matching_interfaces.each do |ifconfig|
+          bring_down_interface(ifconfig.name)
+        end
+        matching_interfaces.map(&:name)
+      end
+
+      def destroy_interface(interface_name)
+        system('sudo', 'ifconfig', interface_name, 'destroy', exception: true)
+      end
+
+      private
+
+      def output
+        `ifconfig -a`
+      end
+    end # class << self
+
+    attr_accessor(
+      :broadcast_address,
+      :flags,
+      :interface,
+      :ipv4_address,
+      :mac_address,
+      :netmask,
+      :status
+    )
+
+    def initialize(
+      broadcast_address: nil,
+      flags: nil,
+      interface: nil,
+      ipv4_address: nil,
+      mac_address: nil,
+      netmask: nil,
+      status: nil
+    )
+      @broadcast_address = broadcast_address
+      @flags = flags
+      @interface = interface
+      @ipv4_address = ipv4_address
+      @mac_address = mac_address
+      @netmask = netmask
+      @status = status
+    end
+
+    def interface_name
+      @interface
+    end
+    alias_method :name, :interface_name
+
+    def ethernet_address
+      @mac_address
+    end
+
+    def active?
+      @status == 'active'
+    end
+
+    def inactive?
+      @status == 'inactive'
+    end
+
+    # For interfaces with status field (physical), check active status and IP address.
+    # For interfaces with flags only (virtual), check UP flag and IP address.
+    def up?
+      if @status
+        active? && @ipv4_address
+      else
+        (@flags && @flags.include?('UP')) && @ipv4_address
+      end
+    end
+
+    def virtual?
+      @interface =~ /^(utun|awdl|llw|lo|bridge|gif|stf)\d*/
+    end
+  end
+end

data/lib/MacOS/Keychain.rb

@@ -0,0 +1,26 @@
+# MacOS/Keychain.rb
+# MacOS::Keychain
+
+require 'open3'
+require 'shellwords'
+
+module MacOS
+  class Keychain
+    class << self
+
+      def find_generic_password_command(key)
+        "security find-generic-password -ga #{Shellwords.escape(key)}"
+      end
+
+      def find_generic_password(key)
+        Open3.capture3(find_generic_password_command(key))
+      end
+
+      def wifi_password(wifi_ssid)
+        stdout, stderr, status = find_generic_password(wifi_ssid)
+        stderr[/password: "(.+)"/, 1]
+      end
+
+    end # class << self
+  end
+end

data/lib/MacOS/LaunchControl.rb

@@ -0,0 +1,36 @@
+# MacOS/LaunchControl.rb
+# MacOS::LaunchControl
+
+require 'shellwords'
+
+module MacOS
+  class LaunchControl
+
+    class << self
+
+      def load(path_to_plist)
+        system("launchctl load -w #{Shellwords.escape(path_to_plist)}")
+      end
+
+      def unload(path_to_plist)
+        system("launchctl unload -w #{Shellwords.escape(path_to_plist)}")
+      end
+
+    end # class << self
+
+    attr_accessor :path_to_plist
+
+    def initialize(path_to_plist = nil)
+      @path_to_plist = path_to_plist
+    end
+
+    def load
+      MacOS::LaunchControl.load(path_to_plist)
+    end
+
+    def unload(path_to_plist = @path_to_plist)
+      MacOS::LaunchControl.unload(path_to_plist)
+    end
+
+  end
+end

data/lib/MacOS/SystemProfiler.rb

@@ -0,0 +1,119 @@
+# MacOS/SystemProfiler.rb
+# MacOS::SystemProfiler
+
+# Description: This uses the built-in system_profiler command on MacOS to get access to the version numbers on any
+# version of MacOS which has a system_profiler command and which returns results in a known format.
+
+require 'Version'
+
+module MacOS
+  module SystemProfiler
+
+    module_function
+
+    def system_profiler_output
+      `system_profiler SPSoftwareDataType`.force_encoding('UTF-8')
+    end
+
+    # The value system_profiler gives for a field, such as 'Boot Volume'.
+    def field(name)
+      system_profiler_output[/#{Regexp.escape(name)}: (?<value>.+)$/, :value]
+    end
+    private_class_method :field
+
+    def system_version_data
+      field('System Version')
+    end
+
+    def system_version_string
+      earlier_versions = system_version_data.split[3] # OSX 10.4 to 10.9 at least
+      later_versions = system_version_data.split[1] # MacOS 10.14 at least
+      earlier_versions || later_versions
+    end
+
+    def system_version
+      Version.new(system_version_string)
+    end
+
+    def major_system_version
+      system_version.major
+    end
+
+    def minor_system_version
+      system_version.minor
+    end
+
+    def tiny_system_version
+      system_version.tiny
+    end
+
+    def kernel_version_data
+      field('Kernel Version')
+    end
+
+    def kernel_name
+      kernel_version_data.split.first
+    end
+
+    def kernel_version_string
+      kernel_version_data.split.last
+    end
+
+    def kernel_version
+      Version.new(kernel_version_string)
+    end
+
+    def boot_volume_data
+      field('Boot Volume')
+    end
+    alias_method :boot_volume_string, :boot_volume_data
+
+    def boot_mode_data
+      field('Boot Mode')
+    end
+    alias_method :boot_mode_string, :boot_mode_data
+    alias_method :boot_mode, :boot_mode_data
+
+    def computer_name_data
+      field('Computer Name')
+    end
+    alias_method :computer_name_string, :computer_name_data
+    alias_method :computer_name, :computer_name_data
+
+    def username_data
+      field('User Name')
+    end
+    alias_method :username_string, :username_data
+    alias_method :username, :username_data
+
+    def secure_virtual_memory_data
+      field('Secure Virtual Memory')
+    end
+    alias_method :secure_virtual_memory_string, :secure_virtual_memory_data
+    alias_method :secure_virtual_memory, :secure_virtual_memory_data
+
+    def system_integrity_protection_data
+      field('System Integrity Protection')
+    end
+    alias_method :system_integrity_protection_string, :system_integrity_protection_data
+    alias_method :system_integrity_protection, :system_integrity_protection_data
+
+    def time_since_boot_data
+      field('Time since boot')
+    end
+    alias_method :time_since_boot_string, :time_since_boot_data
+    alias_method :time_since_boot, :time_since_boot_data
+
+    # The aliases as module functions too, alias_method making instance methods alone.
+    module_function(
+      :boot_volume_string,
+      :boot_mode_string, :boot_mode,
+      :computer_name_string, :computer_name,
+      :username_string, :username,
+      :secure_virtual_memory_string, :secure_virtual_memory,
+      :system_integrity_protection_string, :system_integrity_protection,
+      :time_since_boot_string, :time_since_boot
+    )
+
+  end
+end

data/lib/MacOS/USBFlashDrive.rb

@@ -0,0 +1,26 @@
+# MacOS/USBFlashDrive.rb
+# MacOS::USBFlashDrive
+
+require 'open3'
+require 'shellwords'
+
+module MacOS
+  class USBFlashDrive
+    class << self
+
+      def system_profiler_usb_data_type_command
+        "system_profiler SPUSBDataType"
+      end
+
+      def raw_system_profiler_output
+        Open3.capture3(system_profiler_usb_data_type_command)
+      end
+
+      def all_mount_points
+        stdout, stderr, status = raw_system_profiler_output
+        stdout.scan(/Mount Point: (.+)$/).flatten
+      end
+
+    end # class << self
+  end
+end

data/lib/MacOS/Users.rb

@@ -0,0 +1,16 @@
+# MacOS/Users.rb
+# MacOS::Users
+
+# Description: Lists the real (human) user accounts on the system, excluding system and service accounts.
+
+module MacOS
+  module Users
+    module_function
+
+    def all
+      `dscl . list /users`.split("\n")
+        .reject{|username| username =~ /^_/}
+        .reject{|username| %w{daemon nobody root}.include?(username)}
+    end
+  end
+end

data/lib/MacOS/VERSION.rb

@@ -0,0 +1,6 @@
+# MacOS/VERSION.rb
+# MacOS::VERSION
+
+module MacOS
+  VERSION = '0.50.0'
+end

data/lib/MacOS/VPN.rb

@@ -0,0 +1,13 @@
+# MacOS/VPN.rb
+# MacOS::VPN
+
+# Notes:
+# 1. Taken from mercurial-0.4.3.
+
+module MacOS
+  module VPN
+    def self.up?
+      MacOS::IfConfig.up_interfaces.detect{|ifconfig| ifconfig.interface.match(/utun/)}
+    end
+  end
+end