sys-proctable 1.2.6 → 1.3.0

data/spec/sys_proctable_windows_spec.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 ############################################################################
 # sys_proctable_windows_spec.rb
 #
 # Test suite for the sys-proctable library for MS Windows. This should be
-# run via the 'rake test' task.
+# run via the 'rake spec' task.
 ############################################################################
-require 'rspec'
-require 'sys-proctable'
+require 'spec_helper'
 require 'socket'
-require_relative 'sys_proctable_all_spec'
 
-describe Sys::ProcTable do
+RSpec.describe Sys::ProcTable, :windows do
   let(:hostname) { Socket.gethostname }
   let(:fields) {
     %w[
@@ -60,258 +60,258 @@ describe Sys::ProcTable do
      ]
   }
 
-  context "fields" do
-    it "responds to a fields method" do
+  context 'fields' 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 "ps" do
-    it "accepts an optional host" do
-      expect{ described_class.ps(host: hostname) }.to_not raise_error
+  context 'ps' do
+    it 'accepts an optional host' do
+      expect{ described_class.ps(:host => hostname) }.not_to raise_error
     end
 
-    it "ignores unused options" do
-      expect{ described_class.ps(:smaps => false) }.to_not raise_error
+    it 'ignores unused options' do
+      expect{ described_class.ps(:smaps => false) }.not_to raise_error
     end
   end
 
-  context "ProcTable::Struct members" do
-    subject { described_class.ps.first }
+  context 'ProcTable::Struct members' do
+    subject(:process){ described_class.ps.first }
 
-    it "has a write_transfer_count struct member with the expected data type" do
-      expect(subject).to respond_to(:write_transfer_count)
-      expect(subject.write_transfer_count).to be_kind_of(Integer)
+    it 'has a write_transfer_count struct member with the expected data type' do
+      expect(process).to respond_to(:write_transfer_count)
+      expect(process.write_transfer_count).to be_kind_of(Integer)
     end
 
-    it "has a write_operation_count struct member with the expected data type" do
-      expect(subject).to respond_to(:write_operation_count)
-      expect(subject.write_operation_count).to be_kind_of(Integer)
+    it 'has a write_operation_count struct member with the expected data type' do
+      expect(process).to respond_to(:write_operation_count)
+      expect(process.write_operation_count).to be_kind_of(Integer)
     end
 
-    it "has a working_set_size struct member with the expected data type" do
-      expect(subject).to respond_to(:working_set_size)
-      expect(subject.working_set_size).to be_kind_of(Integer)
+    it 'has a working_set_size struct member with the expected data type' do
+      expect(process).to respond_to(:working_set_size)
+      expect(process.working_set_size).to be_kind_of(Integer)
     end
 
-    it "has a windows_version struct member with the expected data type" do
-      expect(subject).to respond_to(:windows_version)
-      expect(subject.windows_version).to be_kind_of(String)
+    it 'has a windows_version struct member with the expected data type' do
+      expect(process).to respond_to(:windows_version)
+      expect(process.windows_version).to be_kind_of(String)
     end
 
-    it "has a virtual_size struct member with the expected data type" do
-      expect(subject).to respond_to(:virtual_size)
-      expect(subject.virtual_size).to be_kind_of(Integer)
+    it 'has a virtual_size struct member with the expected data type' do
+      expect(process).to respond_to(:virtual_size)
+      expect(process.virtual_size).to be_kind_of(Integer)
     end
 
-    it "has a user_mode_time struct member with the expected data type" do
-      expect(subject).to respond_to(:user_mode_time)
-      expect(subject.user_mode_time).to be_kind_of(Integer)
+    it 'has a user_mode_time struct member with the expected data type' do
+      expect(process).to respond_to(:user_mode_time)
+      expect(process.user_mode_time).to be_kind_of(Integer)
     end
 
-    it "has a thread_count struct member with the expected data type" do
-      expect(subject).to respond_to(:thread_count)
-      expect(subject.thread_count).to be_kind_of(Integer)
+    it 'has a thread_count struct member with the expected data type' do
+      expect(process).to respond_to(:thread_count)
+      expect(process.thread_count).to be_kind_of(Integer)
     end
 
-    it "has a termination_date struct member with the expected data type" do
-      expect(subject).to respond_to(:termination_date)
-      expect(subject.termination_date).to be_kind_of(Date) if subject.termination_date
+    it 'has a termination_date struct member with the expected data type' do
+      expect(process).to respond_to(:termination_date)
+      expect(process.termination_date).to be_kind_of(Date) if process.termination_date
     end
 
-    it "has a status struct member with the expected data type" do
-      expect(subject).to respond_to(:status)
-      expect(subject.status).to be_nil # Always nil according to MSDN
+    it 'has a status struct member with the expected data type' do
+      expect(process).to respond_to(:status)
+      expect(process.status).to be_nil # Always nil according to MSDN
     end
 
-    it "has a session_id struct member with the expected data type" do
-      expect(subject).to respond_to(:session_id)
-      expect(subject.session_id).to be_kind_of(Integer)
+    it 'has a session_id struct member with the expected data type' do
+      expect(process).to respond_to(:session_id)
+      expect(process.session_id).to be_kind_of(Integer)
     end
 
-    it "has a read_transfer_count struct member with the expected data type" do
-      expect(subject).to respond_to(:read_transfer_count)
-      expect(subject.read_transfer_count).to be_kind_of(Integer)
+    it 'has a read_transfer_count struct member with the expected data type' do
+      expect(process).to respond_to(:read_transfer_count)
+      expect(process.read_transfer_count).to be_kind_of(Integer)
     end
 
-    it "has a read_operation_count struct member with the expected data type" do
-      expect(subject).to respond_to(:read_operation_count)
-      expect(subject.read_operation_count).to be_kind_of(Integer)
+    it 'has a read_operation_count struct member with the expected data type' do
+      expect(process).to respond_to(:read_operation_count)
+      expect(process.read_operation_count).to be_kind_of(Integer)
     end
 
-    it "has a quota_peak_paged_pool_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:quota_peak_paged_pool_usage)
-      expect(subject.quota_peak_paged_pool_usage).to be_kind_of(Integer)
+    it 'has a quota_peak_paged_pool_usage struct member with the expected data type' do
+      expect(process).to respond_to(:quota_peak_paged_pool_usage)
+      expect(process.quota_peak_paged_pool_usage).to be_kind_of(Integer)
     end
 
-    it "has a quota_peak_non_paged_pool_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:quota_peak_non_paged_pool_usage)
-      expect(subject.quota_peak_non_paged_pool_usage).to be_kind_of(Integer)
+    it 'has a quota_peak_non_paged_pool_usage struct member with the expected data type' do
+      expect(process).to respond_to(:quota_peak_non_paged_pool_usage)
+      expect(process.quota_peak_non_paged_pool_usage).to be_kind_of(Integer)
     end
 
-    it "has a quota_paged_pool_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:quota_paged_pool_usage)
-      expect(subject.quota_paged_pool_usage).to be_kind_of(Integer)
+    it 'has a quota_paged_pool_usage struct member with the expected data type' do
+      expect(process).to respond_to(:quota_paged_pool_usage)
+      expect(process.quota_paged_pool_usage).to be_kind_of(Integer)
     end
 
-    it "has a quota_non_paged_pool_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:quota_non_paged_pool_usage)
-      expect(subject.quota_non_paged_pool_usage).to be_kind_of(Integer)
+    it 'has a quota_non_paged_pool_usage struct member with the expected data type' do
+      expect(process).to respond_to(:quota_non_paged_pool_usage)
+      expect(process.quota_non_paged_pool_usage).to be_kind_of(Integer)
     end
 
-    it "has a pid struct member with the expected data type" do
-      expect(subject).to respond_to(:pid)
-      expect(subject.pid).to be_kind_of(Integer)
+    it 'has a pid struct member with the expected data type' do
+      expect(process).to respond_to(:pid)
+      expect(process.pid).to be_kind_of(Integer)
     end
 
-    it "has a private_page_count struct member with the expected data type" do
-      expect(subject).to respond_to(:private_page_count)
-      expect(subject.private_page_count).to be_kind_of(Integer)
+    it 'has a private_page_count struct member with the expected data type' do
+      expect(process).to respond_to(:private_page_count)
+      expect(process.private_page_count).to be_kind_of(Integer)
     end
 
-    it "has a priority struct member with the expected data type" do
-      expect(subject).to respond_to(:priority)
-      expect(subject.priority).to be_kind_of(Integer)
+    it 'has a priority struct member with the expected data type' do
+      expect(process).to respond_to(:priority)
+      expect(process.priority).to be_kind_of(Integer)
     end
 
-    it "has a peak_working_set_size struct member with the expected data type" do
-      expect(subject).to respond_to(:peak_working_set_size)
-      expect(subject.peak_working_set_size).to be_kind_of(Integer)
+    it 'has a peak_working_set_size struct member with the expected data type' do
+      expect(process).to respond_to(:peak_working_set_size)
+      expect(process.peak_working_set_size).to be_kind_of(Integer)
     end
 
-    it "has a peak_virtual_size struct member with the expected data type" do
-      expect(subject).to respond_to(:peak_virtual_size)
-      expect(subject.peak_virtual_size).to be_kind_of(Integer)
+    it 'has a peak_virtual_size struct member with the expected data type' do
+      expect(process).to respond_to(:peak_virtual_size)
+      expect(process.peak_virtual_size).to be_kind_of(Integer)
     end
 
-    it "has a peak_page_file_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:peak_page_file_usage)
-      expect(subject.peak_page_file_usage).to be_kind_of(Integer)
+    it 'has a peak_page_file_usage struct member with the expected data type' do
+      expect(process).to respond_to(:peak_page_file_usage)
+      expect(process.peak_page_file_usage).to be_kind_of(Integer)
     end
 
-    it "has a ppid struct member with the expected data type" do
-      expect(subject).to respond_to(:ppid)
-      expect(subject.ppid).to be_kind_of(Integer)
+    it 'has a ppid struct member with the expected data type' do
+      expect(process).to respond_to(:ppid)
+      expect(process.ppid).to be_kind_of(Integer)
     end
 
-    it "has a page_file_usage struct member with the expected data type" do
-      expect(subject).to respond_to(:page_file_usage)
-      expect(subject.page_file_usage).to be_kind_of(Integer)
+    it 'has a page_file_usage struct member with the expected data type' do
+      expect(process).to respond_to(:page_file_usage)
+      expect(process.page_file_usage).to be_kind_of(Integer)
     end
 
-    it "has a page_faults struct member with the expected data type" do
-      expect(subject).to respond_to(:page_faults)
-      expect(subject.page_faults).to be_kind_of(Integer)
+    it 'has a page_faults struct member with the expected data type' do
+      expect(process).to respond_to(:page_faults)
+      expect(process.page_faults).to be_kind_of(Integer)
     end
 
-    it "has a other_transfer_count struct member with the expected data type" do
-      expect(subject).to respond_to(:other_transfer_count)
-      expect(subject.other_transfer_count).to be_kind_of(Integer)
+    it 'has a other_transfer_count struct member with the expected data type' do
+      expect(process).to respond_to(:other_transfer_count)
+      expect(process.other_transfer_count).to be_kind_of(Integer)
     end
 
-    it "has a other_operation_count struct member with the expected data type" do
-      expect(subject).to respond_to(:other_operation_count)
-      expect(subject.other_operation_count).to be_kind_of(Integer)
+    it 'has a other_operation_count struct member with the expected data type' do
+      expect(process).to respond_to(:other_operation_count)
+      expect(process.other_operation_count).to be_kind_of(Integer)
     end
 
-    it "has a os_name struct member with the expected data type" do
-      expect(subject).to respond_to(:os_name)
-      expect(subject.os_name).to be_kind_of(String)
+    it 'has a os_name struct member with the expected data type' do
+      expect(process).to respond_to(:os_name)
+      expect(process.os_name).to be_kind_of(String)
     end
 
-    it "has a os_creation_class_name struct member with the expected data type" do
-      expect(subject).to respond_to(:os_creation_class_name)
-      expect(subject.os_creation_class_name).to be_kind_of(String)
+    it 'has a os_creation_class_name struct member with the expected data type' do
+      expect(process).to respond_to(:os_creation_class_name)
+      expect(process.os_creation_class_name).to be_kind_of(String)
     end
 
-    it "has a name struct member with the expected data type" do
-      expect(subject).to respond_to(:name)
-      expect(subject.name).to be_kind_of(String)
+    it 'has a name struct member with the expected data type' do
+      expect(process).to respond_to(:name)
+      expect(process.name).to be_kind_of(String)
     end
 
-    it "has a minimum_working_set_size struct member with the expected data type" do
-      expect(subject).to respond_to(:minimum_working_set_size)
-      expect(subject.minimum_working_set_size).to be_kind_of(Integer) if subject.minimum_working_set_size
+    it 'has a minimum_working_set_size struct member with the expected data type' do
+      expect(process).to respond_to(:minimum_working_set_size)
+      expect(process.minimum_working_set_size).to be_kind_of(Integer) if process.minimum_working_set_size
     end
 
-    it "has a maximum_working_set_size struct member with the expected data type" do
-      expect(subject).to respond_to(:maximum_working_set_size)
-      expect(subject.maximum_working_set_size).to be_kind_of(Integer) if subject.maximum_working_set_size
+    it 'has a maximum_working_set_size struct member with the expected data type' do
+      expect(process).to respond_to(:maximum_working_set_size)
+      expect(process.maximum_working_set_size).to be_kind_of(Integer) if process.maximum_working_set_size
     end
 
-    it "has a kernel_mode_time struct member with the expected data type" do
-      expect(subject).to respond_to(:kernel_mode_time)
-      expect(subject.kernel_mode_time).to be_kind_of(Integer)
+    it 'has a kernel_mode_time struct member with the expected data type' do
+      expect(process).to respond_to(:kernel_mode_time)
+      expect(process.kernel_mode_time).to be_kind_of(Integer)
     end
 
-    it "has a install_date struct member with the expected data type" do
-      expect(subject).to respond_to(:install_date)
-      expect(subject.install_date).to be_kind_of(Date) if subject.install_date
+    it 'has a install_date struct member with the expected data type' do
+      expect(process).to respond_to(:install_date)
+      expect(process.install_date).to be_kind_of(Date) if process.install_date
     end
 
-    it "has a handle_count struct member with the expected data type" do
-      expect(subject).to respond_to(:handle_count)
-      expect(subject.handle_count).to be_kind_of(Integer)
+    it 'has a handle_count struct member with the expected data type' do
+      expect(process).to respond_to(:handle_count)
+      expect(process.handle_count).to be_kind_of(Integer)
     end
 
-    it "has a handle struct member with the expected data type" do
-      expect(subject).to respond_to(:handle)
-      expect(subject.handle).to be_kind_of(String)
+    it 'has a handle struct member with the expected data type' do
+      expect(process).to respond_to(:handle)
+      expect(process.handle).to be_kind_of(String)
     end
 
-    it "has a execution_state struct member with the expected data type" do
-      expect(subject).to respond_to(:execution_state)
-      expect(subject.execution_state).to be_nil
+    it 'has a execution_state struct member with the expected data type' do
+      expect(process).to respond_to(:execution_state)
+      expect(process.execution_state).to be_nil
     end
 
-    it "has a executable_path struct member with the expected data type" do
-      expect(subject).to respond_to(:executable_path)
-      expect(subject.executable_path).to be_kind_of(String) if subject.executable_path
+    it 'has a executable_path struct member with the expected data type' do
+      expect(process).to respond_to(:executable_path)
+      expect(process.executable_path).to be_kind_of(String) if process.executable_path
     end
 
-    it "has a description struct member with the expected data type" do
-      expect(subject).to respond_to(:description)
-      expect(subject.description).to be_kind_of(String)
+    it 'has a description struct member with the expected data type' do
+      expect(process).to respond_to(:description)
+      expect(process.description).to be_kind_of(String)
     end
 
-    it "has a cs_name struct member with the expected data type" do
-      expect(subject).to respond_to(:cs_name)
-      expect(subject.cs_name).to be_kind_of(String)
+    it 'has a cs_name struct member with the expected data type' do
+      expect(process).to respond_to(:cs_name)
+      expect(process.cs_name).to be_kind_of(String)
     end
 
-    it "has a cs_creation_class_name struct member with the expected data type" do
-      expect(subject).to respond_to(:cs_creation_class_name)
-      expect(subject.cs_creation_class_name).to be_kind_of(String)
+    it 'has a cs_creation_class_name struct member with the expected data type' do
+      expect(process).to respond_to(:cs_creation_class_name)
+      expect(process.cs_creation_class_name).to be_kind_of(String)
     end
 
-    it "has a creation_date struct member with the expected data type" do
-      expect(subject).to respond_to(:creation_date)
-      expect(subject.creation_date).to be_kind_of(Date) if subject.creation_date
+    it 'has a creation_date struct member with the expected data type' do
+      expect(process).to respond_to(:creation_date)
+      expect(process.creation_date).to be_kind_of(Date) if process.creation_date
     end
 
-    it "has a creation_class_name struct member with the expected data type" do
-      expect(subject).to respond_to(:creation_class_name)
-      expect(subject.creation_class_name).to be_kind_of(String)
+    it 'has a creation_class_name struct member with the expected data type' do
+      expect(process).to respond_to(:creation_class_name)
+      expect(process.creation_class_name).to be_kind_of(String)
     end
 
-    it "has a comm struct member with the expected data type" do
-      expect(subject).to respond_to(:comm)
-      expect(subject.comm).to be_kind_of(String)
+    it 'has a comm struct member with the expected data type' do
+      expect(process).to respond_to(:comm)
+      expect(process.comm).to be_kind_of(String)
     end
 
-    it "has a cmdline struct member with the expected data type" do
-      expect(subject).to respond_to(:cmdline)
-      expect(subject.cmdline).to be_kind_of(String) if subject.cmdline
+    it 'has a cmdline struct member with the expected data type' do
+      expect(process).to respond_to(:cmdline)
+      expect(process.cmdline).to be_kind_of(String) if process.cmdline
     end
 
-    it "has a caption struct member with the expected data type" do
-      expect(subject).to respond_to(:caption)
-      expect(subject.caption).to be_kind_of(String)
+    it 'has a caption struct member with the expected data type' do
+      expect(process).to respond_to(:caption)
+      expect(process.caption).to be_kind_of(String)
     end
   end
 end

data/spec/sys_top_spec.rb

@@ -3,49 +3,48 @@
 #
 # Test suite for the sys-top library that is included with this distribution.
 ##############################################################################
-require 'rspec'
-require 'sys/top'
+require 'spec_helper'
 
-describe Sys::Top do
-  context "constants" do
-    it "sets the version to the expected value" do
+RSpec.describe Sys::Top do
+  context 'constants' do
+    it 'sets the version to the expected value' do
       expect(Sys::Top::VERSION).to eql('1.0.5')
     end
   end
 
-  context "top" do
-    it "defines a top method" do
-      expect(described_class).to respond_to(:top) 
+  context 'top' do
+    it 'defines a top method' do
+      expect(described_class).to respond_to(:top)
     end
 
-    it "returns an array" do
+    it 'returns an array' do
       expect(described_class.top).to be_kind_of(Array)
     end
 
-    it "works with no arguments" do
-      expect{ described_class.top }.to_not raise_error
+    it 'works with no arguments' do
+      expect{ described_class.top }.not_to raise_error
     end
 
-    it "accepts a maximum of two arguments" do
+    it 'accepts a maximum of two arguments' do
       expect{ described_class.top(1, 'foo', 2) }.to raise_error(ArgumentError)
     end
 
-    it "accepts optional arguments" do
-      expect{ described_class.top(5) }.to_not raise_error
-      expect{ described_class.top(5, 'cmdline') }.to_not raise_error
+    it 'accepts optional arguments' do
+      expect{ described_class.top(5) }.not_to raise_error
+      expect{ described_class.top(5, 'cmdline') }.not_to raise_error
     end
 
-    it "returns the expected results with no arguments" do
-      expect(described_class.top.size).to eql(10)
+    it 'returns the expected results with no arguments' do
+      expect(described_class.top.size).to be(10)
       expect(described_class.top.first).to be_kind_of(Struct::ProcTableStruct)
     end
 
-    it "returns the expected result with a size argument" do
-      expect(described_class.top(5).size).to eql(5)
+    it 'returns the expected result with a size argument' do
+      expect(described_class.top(5).size).to be(5)
     end
 
-    it "returns the expected result with a size and sort_by argument" do
-      expect(described_class.top(5, :cmdline).size).to eql(5)
+    it 'returns the expected result with a size and sort_by argument' do
+      expect(described_class.top(5, :cmdline).size).to be(5)
     end
   end
 end

data/sys-proctable.gemspec

@@ -1,41 +1,33 @@
 require 'rubygems'
+require_relative 'lib/sys/proctable/version'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-proctable'
-  spec.version    = '1.2.6'
+  spec.version    = Sys::ProcTable::VERSION
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Apache-2.0'
   spec.email      = 'djberg96@gmail.com'
   spec.homepage   = 'http://github.com/djberg96/sys-proctable'
   spec.summary    = 'An interface for providing process table information'
-  spec.test_files = FileList['spec/**/*.rb']
+  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.test_files = Dir['spec/*.rb']
   spec.cert_chain = ['certs/djberg96_pub.pem']
    
-  spec.files = FileList[
-    "benchmarks/**/*.rb",
-    "examples/**/*.rb",
-    "lib/**/*.rb",
-    'CHANGES.rdoc',
-    'LICENSE',
-    'MANIFEST.rdoc',
-    'Rakefile',
-    'README.md',
-    'sys-proctable.gemspec'
-  ]
-
-  spec.extra_rdoc_files = ['CHANGES.rdoc', 'README.md', 'MANIFEST.rdoc']
-
-  spec.add_dependency('ffi')
-  spec.add_development_dependency('rspec')
+  spec.add_dependency('ffi', '~> 1.1')
+  spec.add_development_dependency('rspec', '~> 3.9')
   spec.add_development_dependency('rake')
+  spec.add_development_dependency('rubocop')
+  spec.add_development_dependency('rubocop-rspec')
+  spec.add_development_dependency('mkmf-lite')
 
   spec.metadata = {
-    'homepage_uri'      => 'https://github.com/djberg96/sys-proctable',
-    'bug_tracker_uri'   => 'https://github.com/djberg96/sys-proctable/issues',
-    'changelog_uri'     => 'https://github.com/djberg96/sys-proctable/blob/master/CHANGES.rdoc',
-    'documentation_uri' => 'https://github.com/djberg96/sys-proctable/wiki',
-    'source_code_uri'   => 'https://github.com/djberg96/sys-proctable',
-    'wiki_uri'          => 'https://github.com/djberg96/sys-proctable/wiki'
+    'homepage_uri'          => 'https://github.com/djberg96/sys-proctable',
+    'bug_tracker_uri'       => 'https://github.com/djberg96/sys-proctable/issues',
+    'changelog_uri'         => 'https://github.com/djberg96/sys-proctable/blob/main/CHANGES.md',
+    'documentation_uri'     => 'https://github.com/djberg96/sys-proctable/wiki',
+    'source_code_uri'       => 'https://github.com/djberg96/sys-proctable',
+    'wiki_uri'              => 'https://github.com/djberg96/sys-proctable/wiki',
+    'rubygems_mfa_required' => 'true'
   }
 
   spec.description = <<-EOF