sys-proctable 1.2.5 → 1.2.7

data/lib/windows/sys/proctable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'win32ole'
 require 'socket'
 require 'date'
@@ -5,10 +7,8 @@ require 'sys/proctable/version'
 
 # The Sys module serves as a namespace only
 module Sys
-
   # The ProcTable class encapsulates process table information
   class ProcTable
-
     # There is no constructor
     private_class_method :new
 
@@ -77,8 +77,8 @@ module Sys
     # may be useful if you want to know in advance what fields are available
     # without having to perform at least one read of the /proc table.
     #
-    def self.fields
-       @fields
+    class << self
+      attr_reader :fields
     end
 
     # call-seq:
@@ -96,19 +96,21 @@ module Sys
       pid  = kwargs[:pid]
       host = kwargs[:host] || Socket.gethostname
 
-      raise TypeError unless pid.kind_of?(Numeric) if pid
+      if pid && !pid.is_a?(Numeric)
+        raise TypeError
+      end
 
       array  = block_given? ? nil : []
       struct = nil
 
       begin
         wmi = WIN32OLE.connect("winmgmts://#{host}/root/cimv2")
-      rescue WIN32OLERuntimeError => e
-        raise Error, e # Re-raise as ProcTable::Error
+      rescue WIN32OLERuntimeError => err
+        raise Error, err # Re-raise as ProcTable::Error
       else
-        wmi.InstancesOf("Win32_Process").each{ |wproc|
-          if pid
-            next unless wproc.ProcessId == pid
+        wmi.InstancesOf("Win32_Process").each do |wproc|
+          if pid && wproc.ProcessId != pid
+            next
           end
 
           # Some fields are added later, and so are nil initially
@@ -117,7 +119,7 @@ module Sys
             nil, # Added later, based on OS version
             wproc.Name,
             wproc.CreationClassName,
-            self.parse_ms_date(wproc.CreationDate),
+            parse_ms_date(wproc.CreationDate),
             wproc.CSCreationClassName,
             wproc.CSName,
             wproc.Description,
@@ -125,40 +127,40 @@ module Sys
             wproc.ExecutionState,
             wproc.Handle,
             wproc.HandleCount,
-            self.parse_ms_date(wproc.InstallDate),
-            self.convert(wproc.KernelModeTime),
+            parse_ms_date(wproc.InstallDate),
+            convert(wproc.KernelModeTime),
             wproc.MaximumWorkingSetSize,
             wproc.MinimumWorkingSetSize,
             wproc.Name,
             wproc.OSCreationClassName,
             wproc.OSName,
-            self.convert(wproc.OtherOperationCount),
-            self.convert(wproc.OtherTransferCount),
+            convert(wproc.OtherOperationCount),
+            convert(wproc.OtherTransferCount),
             wproc.PageFaults,
             wproc.PageFileUsage,
             wproc.ParentProcessId,
-            self.convert(wproc.PeakPageFileUsage),
-            self.convert(wproc.PeakVirtualSize),
-            self.convert(wproc.PeakWorkingSetSize),
+            convert(wproc.PeakPageFileUsage),
+            convert(wproc.PeakVirtualSize),
+            convert(wproc.PeakWorkingSetSize),
             wproc.Priority,
-            self.convert(wproc.PrivatePageCount),
+            convert(wproc.PrivatePageCount),
             wproc.ProcessId,
             wproc.QuotaNonPagedPoolUsage,
             wproc.QuotaPagedPoolUsage,
             wproc.QuotaPeakNonPagedPoolUsage,
             wproc.QuotaPeakPagedPoolUsage,
-            self.convert(wproc.ReadOperationCount),
-            self.convert(wproc.ReadTransferCount),
+            convert(wproc.ReadOperationCount),
+            convert(wproc.ReadTransferCount),
             wproc.SessionId,
             wproc.Status,
-            self.parse_ms_date(wproc.TerminationDate),
+            parse_ms_date(wproc.TerminationDate),
             wproc.ThreadCount,
-            self.convert(wproc.UserModeTime),
-            self.convert(wproc.VirtualSize),
+            convert(wproc.UserModeTime),
+            convert(wproc.VirtualSize),
             wproc.WindowsVersion,
-            self.convert(wproc.WorkingSetSize),
-            self.convert(wproc.WriteOperationCount),
-            self.convert(wproc.WriteTransferCount)
+            convert(wproc.WorkingSetSize),
+            convert(wproc.WriteOperationCount),
+            convert(wproc.WriteTransferCount)
           )
 
           ###############################################################
@@ -179,30 +181,32 @@ module Sys
           else
             array << struct
           end
-        }
+        end
       end
 
       pid ? struct : array
     end
 
-    private
-
     #######################################################################
     # Converts a string in the format '20040703074625.015625-360' into a
     # Ruby Time object.
     #######################################################################
     def self.parse_ms_date(str)
       return if str.nil?
-      return DateTime.parse(str)
+      DateTime.parse(str)
     end
 
+    private_class_method :parse_ms_date
+
     #####################################################################
     # There is a bug in win32ole where uint64 types are returned as a
     # String instead of a Fixnum.  This method deals with that for now.
     #####################################################################
     def self.convert(str)
       return nil if str.nil? # Return nil, not 0
-      return str.to_i
+      str.to_i
     end
+
+    private_class_method :convert
   end
 end

data/spec/spec_helper.rb

@@ -1,22 +1,13 @@
-RSpec.configure do |config|
-  config.filter_run_excluding :skip_jruby if RUBY_PLATFORM == 'java'
-end
+require 'rspec'
+require 'sys-proctable'
+require 'sys-top'
 
-if RUBY_PLATFORM == 'java'
-  require 'ffi'
-  module Exec
-    extend FFI::Library
-    ffi_lib FFI::Library::LIBC
-    attach_function :fork, [], :int
-  end
-
-  def fork
-    pid = Exec.fork
-    if pid == 0
-      yield if block_given?
-      return nil
-    else
-      return pid
-    end
-  end
+RSpec.configure do |config|
+  config.filter_run_excluding(:aix) unless RbConfig::CONFIG['host_os'] =~ /aix/i
+  config.filter_run_excluding(:darwin) unless RbConfig::CONFIG['host_os'] =~ /mac|darwin/i
+  config.filter_run_excluding(:linux) unless RbConfig::CONFIG['host_os'] =~ /linux/i
+  config.filter_run_excluding(:freebsd) unless RbConfig::CONFIG['host_os'] =~ /freebsd/i
+  config.filter_run_excluding(:sunos) unless RbConfig::CONFIG['host_os'] =~ /sunos|solaris/i
+  config.filter_run_excluding(:windows) unless Gem.win_platform?
+  config.filter_run_excluding(:jruby) if RUBY_PLATFORM == 'java'
 end

data/spec/sys_proctable_aix_spec.rb

@@ -2,13 +2,11 @@
 # sys_proctable_aix_spec.rb
 #
 # Test suite for the AIX version of the sys-proctable library. You
-# should run these tests via the 'rake test' task.
+# should run these tests via the 'rake spec' task.
 #######################################################################
-require 'rspec'
-require 'sys/proctable'
-require_relative 'sys_proctable_all_spec'
+require 'spec_helper'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :aix do
   let(:fields){
     %w[
         addr argc argv bindpro cid clname cmd_args cmdline cwd egid environ
@@ -30,8 +28,8 @@ describe Sys::ProcTable do
     end
 
     @myenv = ENV.to_hash
-    @p1args = %w/aix-child.rb testing how well this works 1/
-    @p2args = %w/aix-child.rb testing how well this works 2/
+    @p1args = %w[aix-child.rb testing how well this works 1]
+    @p2args = %w[aix-child.rb testing how well this works 2]
 
     @pid1 = fork do
       exec('ruby', *@p1args)
@@ -61,212 +59,212 @@ describe Sys::ProcTable do
     File.unlink('aix-child.rb') rescue nil
   end
 
-  context "fields singleton method" do
-    it "responds to a fields method" do
+  context 'fields singleton method' do
+    it 'responds to a fields method' do
       expect(described_class).to respond_to(:fields)
     end
 
-    it "returns the expected results for the fields method" do
+    it 'returns the expected results for the fields method' do
       expect(described_class.fields).to be_kind_of(Array)
       expect(described_class.fields).to eql(fields)
     end
   end
 
-  context "ProcTable::Struct members" do
-    it "contains a flag member and returns the expected value" do
+  context 'ProcTable::Struct members' do
+    it 'contains a flag member and returns the expected value' do
       expect(@p1info).to respond_to(:flag)
-      expect(@p1info.flag).to be_kind_of(Fixnum)
+      expect(@p1info.flag).to be_kind_of(Integer)
     end
 
-    it "contains a flag2 member and returns the expected value" do
+    it 'contains a flag2 member and returns the expected value' do
       expect(@p1info).to respond_to(:flag2)
-      expect(@p1info.flag2).to be_kind_of(Fixnum)
+      expect(@p1info.flag2).to be_kind_of(Integer)
     end
 
-    it "contains a nlwp member and returns the expected value" do
+    it 'contains a nlwp member and returns the expected value' do
       expect(@p1info).to respond_to(:nlwp)
-      expect(@p1info.nlwp).to be_kind_of(Fixnum)
+      expect(@p1info.nlwp).to be_kind_of(Integer)
     end
 
-    it "contains a uid member and returns the expected value" do
+    it 'contains a uid member and returns the expected value' do
       expect(@p1info).to respond_to(:uid)
       expect(@p1info.uid).to be_kind_of(Integer)
-      expect(@p1info.uid).to eql(@p1info.uid)
+      expect(@p1info.uid).to eql(Process.uid)
     end
 
-    it "contains a euid member and returns the expected value" do
+    it 'contains a euid member and returns the expected value' do
       expect(@p1info).to respond_to(:euid)
       expect(@p1info.euid).to be_kind_of(Integer)
-      expect(@p1info.euid).to eql(@p1info.euid)
+      expect(@p1info.euid).to eql(Process.euid)
     end
 
-    it "contains a gid member and returns the expected value" do
+    it 'contains a gid member and returns the expected value' do
       expect(@p1info).to respond_to(:gid)
       expect(@p1info.gid).to be_kind_of(Integer)
-      expect(@p1info.gid).to eql(@p1info.gid)
+      expect(@p1info.gid).to eql(Process.gid)
     end
 
-    it "contains a egid member and returns the expected value" do
+    it 'contains a egid member and returns the expected value' do
       expect(@p1info).to respond_to(:egid)
       expect(@p1info.egid).to be_kind_of(Integer)
-      expect(@p1info.egid).to eql(@p1info.egid)
+      expect(@p1info.egid).to eql(Process.egid)
     end
 
-    it "contains a pid member and returns the expected value" do
+    it 'contains a pid member and returns the expected value' do
       expect(@p1info).to respond_to(:pid)
       expect(@p1info.pid).to be_kind_of(Integer)
-      expect(@p1info.pid).to eql(@p1info.pid)
+      expect(@p1info.pid).to eql(@pid1)
     end
 
-    it "contains a ppid member and returns the expected value" do
+    it 'contains a ppid member and returns the expected value' do
       expect(@p1info).to respond_to(:ppid)
       expect(@p1info.ppid).to be_kind_of(Integer)
-      expect(@p1info.ppid).to eql(@p1info.ppid)
+      expect(@p1info.ppid).to eql(Process.pid)
     end
 
-    it "contains a pgid member and returns the expected value" do
+    it 'contains a pgid member and returns the expected value' do
       expect(@p1info).to respond_to(:pgid)
       expect(@p1info.pgid).to be_kind_of(Integer)
-      expect(@p1info.pgid).to eql(@p1info.pgid)
+      expect(@p1info.pgid).to eql(Process.getpgrp)
     end
 
-    it "contains a sid member and returns the expected value" do
+    it 'contains a sid member and returns the expected value' do
       expect(@p1info).to respond_to(:sid)
       expect(@p1info.sid).to be_kind_of(Integer)
     end
 
-    it "contains a ttydev member and returns the expected value" do
+    it 'contains a ttydev member and returns the expected value' do
       expect(@p1info).to respond_to(:ttydev)
       expect(@p1info.ttydev).to be_kind_of(Integer)
     end
 
-    it "contains a addr member and returns the expected value" do
+    it 'contains a addr member and returns the expected value' do
       expect(@p1info).to respond_to(:addr)
       expect(@p1info.addr).to be_kind_of(Integer)
     end
 
-    it "contains a size member and returns the expected value" do
+    it 'contains a size member and returns the expected value' do
       expect(@p1info).to respond_to(:size)
       expect(@p1info.size).to be_kind_of(Integer)
     end
 
-    it "contains a rssize member and returns the expected value" do
+    it 'contains a rssize member and returns the expected value' do
       expect(@p1info).to respond_to(:rssize)
       expect(@p1info.rssize).to be_kind_of(Integer)
     end
 
-    it "contains a start member and returns the expected value" do
+    it 'contains a start member and returns the expected value' do
       expect(@p1info).to respond_to(:start)
       expect(@p1info.start).to be_kind_of(Time)
     end
 
-    it "contains a time member and returns the expected value" do
+    it 'contains a time member and returns the expected value' do
       expect(@p1info).to respond_to(:time)
       expect(@p1info.time).to be_kind_of(Time)
     end
 
-    it "contains a cid member and returns the expected value" do
+    it 'contains a cid member and returns the expected value' do
       expect(@p1info).to respond_to(:cid)
-      expect(@p1info.cid).to be_kind_of(Fixnum)
+      expect(@p1info.cid).to be_kind_of(Integer)
     end
 
-    it "contains an argc member and returns the expected value" do
+    it 'contains an argc member and returns the expected value' do
       expect(@p1info).to respond_to(:argc)
-      expect(@p1info.argc).to be_kind_of(Fixnum)
+      expect(@p1info.argc).to be_kind_of(Integer)
       expect(@p1info.argc).to eql(@p1args.size + 1)
     end
 
-    it "contains an argv member and returns the expected value" do
+    it 'contains an argv member and returns the expected value' do
       expect(@p1info).to respond_to(:argv)
       expect(@p1info.argv).to be_kind_of(Integer)
     end
 
-    it "contains an envp member and returns the expected value" do
+    it 'contains an envp member and returns the expected value' do
       expect(@p1info).to respond_to(:envp)
       expect(@p1info.envp).to be_kind_of(Integer)
     end
 
-    it "contains an fname member and returns the expected value" do
+    it 'contains an fname member and returns the expected value' do
       expect(@p1info).to respond_to(:fname)
       expect(@p1info.fname).to be_kind_of(String)
     end
 
-    it "contains an fname member and returns the expected value" do
+    it 'contains an psargs member and returns the expected value' do
       expect(@p1info).to respond_to(:psargs)
       expect(@p1info.psargs).to be_kind_of(String)
     end
 
-    it "contains an lwpid member and returns the expected value" do
+    it 'contains an lwpid member and returns the expected value' do
       expect(@p1info).to respond_to(:lwpid)
       expect(@p1info.lwpid).to be_kind_of(Integer)
     end
 
-    it "contains a wchan member and returns the expected value" do
+    it 'contains a wchan member and returns the expected value' do
       expect(@p1info).to respond_to(:wchan)
       expect(@p1info.wchan).to be_kind_of(Integer)
     end
 
-    it "contains a wtype member and returns the expected value" do
+    it 'contains a wtype member and returns the expected value' do
       expect(@p1info).to respond_to(:wtype)
-      expect(@p1info.wchan).to be_kind_of(Fixnum)
+      expect(@p1info.wchan).to be_kind_of(Integer)
     end
 
-    it "contains a state member and returns the expected value" do
+    it 'contains a state member and returns the expected value' do
       expect(@p1info).to respond_to(:state)
-      expect(@p1info.state).to be_kind_of(Fixnum)
+      expect(@p1info.state).to be_kind_of(Integer)
     end
 
-    it "contains an sname member and returns the expected value" do
+    it 'contains an sname member and returns the expected value' do
       expect(@p1info).to respond_to(:sname)
       expect(@p1info.sname).to be_kind_of(String)
     end
 
-    it "contains a nice member and returns the expected value" do
+    it 'contains a nice member and returns the expected value' do
       expect(@p1info).to respond_to(:nice)
-      expect(@p1info.nice).to be_kind_of(Fixnum)
+      expect(@p1info.nice).to be_kind_of(Integer)
     end
 
-    it "contains a pri member and returns the expected value" do
+    it 'contains a pri member and returns the expected value' do
       expect(@p1info).to respond_to(:pri)
-      expect(@p1info.pri).to be_kind_of(Fixnum)
+      expect(@p1info.pri).to be_kind_of(Integer)
     end
 
-    it "contains a policy member and returns the expected value" do
+    it 'contains a policy member and returns the expected value' do
       expect(@p1info).to respond_to(:policy)
-      expect(@p1info.policy).to be_kind_of(Fixnum)
+      expect(@p1info.policy).to be_kind_of(Integer)
     end
 
-    it "contains a clname member and returns the expected value" do
+    it 'contains a clname member and returns the expected value' do
       expect(@p1info).to respond_to(:clname)
       expect(@p1info.clname).to be_kind_of(String)
     end
 
-    it "contains an onpro member and returns the expected value" do
+    it 'contains an onpro member and returns the expected value' do
       expect(@p1info).to respond_to(:onpro)
-      expect(@p1info.onpro).to be_kind_of(Fixnum)
+      expect(@p1info.onpro).to be_kind_of(Integer)
     end
 
-    it "contains a bindpro member and returns the expected value" do
+    it 'contains a bindpro member and returns the expected value' do
       expect(@p1info).to respond_to(:bindpro)
-      expect(@p1info.bindpro).to be_kind_of(Fixnum)
+      expect(@p1info.bindpro).to be_kind_of(Integer)
     end
 
-    it "contains a ptid member and returns the expected value" do
+    it 'contains a ptid member and returns the expected value' do
       expect(@p1info).to respond_to(:ptid)
-      expect(@p1info.ptid).to be_kind_of(Fixnum)
+      expect(@p1info.ptid).to be_kind_of(Integer)
     end
 
-    it "contains a comm member and returns the expected value" do
+    it 'contains a comm member and returns the expected value' do
       expect(@p1info).to respond_to(:comm)
       expect(@p1info.comm).to be_kind_of(String)
     end
 
-    it "contains a fd member and returns the expected value" do
+    it 'contains a fd member and returns the expected value' do
       expect(@p1info).to respond_to(:fd)
       expect(@p1info.fd).to be_kind_of(Array)
     end
 
-    it "contains a cmd_args member and returns the expected value" do
+    it 'contains a cmd_args member and returns the expected value' do
       expect(@p1info).to respond_to(:cmd_args)
       expect(@p1info.cmd_args).to be_kind_of(Array)
       expect(@p1info.cmd_args).to_eql(['ruby', @p1args].flatten)
@@ -276,7 +274,7 @@ describe Sys::ProcTable do
       expect(@p2info.cmd_args).to_eql(['ruby', @p2args].flatten)
     end
 
-    it "contains an environ member and returns the expected value" do
+    it 'contains an environ member and returns the expected value' do
       expect(@p1info).to respond_to(:environ)
       expect(@p1info.environ).to be_kind_of(Hash)
       expect(@p1info.environ).to eql(@myenv)
@@ -286,29 +284,29 @@ describe Sys::ProcTable do
       expect(@p2info.environ).to eql(@myenv)
     end
 
-    it "contains a cmdline member and returns the expected value" do
+    it 'contains a cmdline member and returns the expected value' do
       expect(@p1info).to respond_to(:cmdline)
       expect(@p1info.cmdline).to be_kind_of(String)
     end
 
-    it "contains a cwd member and returns the expected value" do
+    it 'contains a cwd member and returns the expected value' do
       expect(@p1info).to respond_to(:cwd)
       expect(@p1info.cwd).to be_kind_of(String) if @p1info.cwd
     end
 
-    it "contains a map member and returns the expected value" do
+    it 'contains a map member and returns the expected value' do
       expect(@p1info).to respond_to(:map)
       expect(@p1info.map).to be_kind_of(Array) if @p1info.map
     end
   end
 
-  context "Struct::ProcTableMapStruct" do
-    it "contains the expected members" do
+  context 'Struct::ProcTableMapStruct' do
+    it 'contains the expected members' do
       expect(@p1info.map).to be_kind_of(Array)
       expect(map_fields.sort).to eql(@p1info.map[0].members.sort)
     end
 
-    it "has members of the expected type" do
+    it 'has members of the expected type' do
       expect(@p1info.map).to be_kind_of(Array)
       p1info_map = @p1info.map