sys-cpu 1.0.3 → 1.0.6

data/spec/sys_cpu_bsd_spec.rb

@@ -1,94 +1,113 @@
+# frozen_string_literal: true
+
 #############################################################
-# test_sys_cpu_bsd.rb
+# sys_cpu_bsd_spec.rb
 #
-# The test case for sys-cpu on BSD flavors, including OS X.
+# Specs for sys-cpu on BSD flavors, including OS X.
 #############################################################
 require 'sys/cpu'
 require 'spec_helper'
 
 RSpec.describe Sys::CPU, :bsd => true do
-  example "architecture method basic functionality" do
-    expect(Sys::CPU).to respond_to(:architecture)
-    expect{ Sys::CPU.architecture }.not_to raise_error
+  example 'architecture method basic functionality' do
+    expect(described_class).to respond_to(:architecture)
+    expect{ described_class.architecture }.not_to raise_error
+  end
+
+  example 'architecture method returns a sane value' do
+    expect(described_class.architecture).to be_kind_of(String)
+    expect(described_class.architecture.size).to be > 0
   end
 
-  example "architecture method returns a sane value" do
-    expect(Sys::CPU.architecture).to be_kind_of(String)
-    expect(Sys::CPU.architecture.size).to be > 0
+  example 'architecture method does not accept any arguments' do
+    expect{ described_class.architecture(0) }.to raise_error(ArgumentError)
   end
 
-  example "architecture method does not accept any arguments" do
-    expect{ Sys::CPU.architecture(0) }.to raise_error(ArgumentError)
+  example 'freq method basic functionality' do
+    expect(described_class).to respond_to(:freq)
+    expect{ described_class.freq }.not_to raise_error
   end
 
-  example "freq method basic functionality" do
-    expect(Sys::CPU).to respond_to(:freq)
-    expect{ Sys::CPU.freq }.not_to raise_error
+  example 'freq method returns expected value' do
+    expect(described_class.freq).to be_kind_of(Integer)
+    expect(described_class.freq).to be > 0
   end
 
-  example "freq method returns expected value" do
-    expect(Sys::CPU.freq).to be_kind_of(Integer)
-    expect(Sys::CPU.freq).to be > 0
+  example 'freq method does not accept any arguments' do
+    expect{ described_class.freq(0) }.to raise_error(ArgumentError)
   end
 
-  example "freq method does not accept any arguments" do
-    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  example 'load_avg method basic functionality' do
+    expect(described_class).to respond_to(:load_avg)
+    expect{ described_class.load_avg }.not_to raise_error
   end
 
-  example "load_avg method basic functionality" do
-    expect(Sys::CPU).to respond_to(:load_avg)
-    expect{ Sys::CPU.load_avg }.not_to raise_error
+  example 'load_avg returns the expected results' do
+    expect(described_class.load_avg).to be_kind_of(Array)
+    expect(described_class.load_avg.length).to eq(3)
+    expect(described_class.load_avg[0]).to be_kind_of(Float)
   end
 
-  example "load_avg returns the expected results" do
-    expect(Sys::CPU.load_avg).to be_kind_of(Array)
-    expect(Sys::CPU.load_avg.length).to eq(3)
-    expect(Sys::CPU.load_avg[0]).to be_kind_of(Float)
+  example 'load_avg does not accept any arguments' do
+    expect{ described_class.load_avg(0) }.to raise_error(ArgumentError)
   end
 
-  example "load_avg does not accept any arguments" do
-    expect{ Sys::CPU.load_avg(0) }.to raise_error(ArgumentError)
+  example 'machine method basic functionality' do
+    expect(described_class).to respond_to(:machine)
+    expect{ described_class.machine }.not_to raise_error
   end
 
-  example "machine method basic functionality" do
-    expect(Sys::CPU).to respond_to(:machine)
-    expect{ Sys::CPU.machine }.not_to raise_error
+  example 'machine method returns sane value' do
+    expect(described_class.machine).to be_kind_of(String)
+    expect(described_class.machine.size).to be > 0
   end
 
-  example "machine method returns sane value" do
-    expect(Sys::CPU.machine).to be_kind_of(String)
-    expect(Sys::CPU.machine.size).to be > 0
+  example 'machine method does not accept any arguments' do
+    expect{ described_class.machine(0) }.to raise_error(ArgumentError)
   end
 
-  example "machine method does not accept any arguments" do
-    expect{ Sys::CPU.machine(0) }.to raise_error(ArgumentError)
+  example 'model method basic functionality' do
+    expect(described_class).to respond_to(:model)
+    expect{ described_class.model }.not_to raise_error
   end
 
-  example "model method basic functionality" do
-    expect(Sys::CPU).to respond_to(:model)
-    expect{ Sys::CPU.model }.not_to raise_error
+  example 'model method returns sane value' do
+    expect(described_class.model).to be_kind_of(String)
+    expect(described_class.model.length).to be > 0
   end
 
-  example "model method returns sane value" do
-    expect(Sys::CPU.model).to be_kind_of(String)
-    expect(Sys::CPU.model.length).to be > 0
+  example 'model method does not accept any arguments' do
+    expect{ described_class.model(0) }.to raise_error(ArgumentError)
   end
 
-  example "model method does not accept any arguments" do
-    expect{ Sys::CPU.model(0) }.to raise_error(ArgumentError)
+  example 'num_cpu method basic functionality' do
+    expect(described_class).to respond_to(:num_cpu)
+    expect{ described_class.num_cpu }.not_to raise_error
   end
 
-  example "num_cpu method basic functionality" do
-    expect(Sys::CPU).to respond_to(:num_cpu)
-    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  example 'num_cpu method returns expected value' do
+    expect(described_class.num_cpu).to be_kind_of(Integer)
+    expect(described_class.num_cpu).to be > 0
   end
 
-  example "num_cpu method returns expected value" do
-    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
-    expect(Sys::CPU.num_cpu).to be > 0
+  example 'num_cpu method does not accept any arguments' do
+    expect{ described_class.num_cpu(0) }.to raise_error(ArgumentError)
   end
 
-  example "num_cpu method does not accept any arguments" do
-    expect{ Sys::CPU.num_cpu(0) }.to raise_error(ArgumentError)
+  context "ffi methods and constants are private" do
+    example "ffi constants are private" do
+      constants = described_class.constants
+      expect(constants).not_to include(:CTL_HW)
+      expect(constants).not_to include(:CPU_TYPE_X86)
+      expect(constants).not_to include(:CPU_TYPE_X86_64)
+      expect(constants).not_to include(:HW_MACHINE)
+      expect(constants).not_to include(:ClockInfo)
+    end
+
+    example "ffi methods are private" do
+      methods = described_class.methods(false)
+      expect(methods).not_to include(:sysctl)
+      expect(methods).not_to include(:sysctlbyname)
+    end
   end
 end

data/spec/sys_cpu_hpux_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #####################################################################
 # sys_cpu_hpux_spec.rb
 #
@@ -8,43 +10,46 @@ require 'sys/cpu'
 require 'spec_helper'
 
 RSpec.describe Sys::CPU, :hpux => true do
-  example "cpu_freq" do
-    expect(Sys::CPU).to respond_to(:freq)
-    expect{ Sys::CPU.freq }.not_to raise_error
-    expect{ Sys::CPU.freq(0) }.not_to raise_error
-    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  example 'cpu_freq' do
+    expect(described_class).to respond_to(:freq)
+    expect{ described_class.freq }.not_to raise_error
+    expect{ described_class.freq(0) }.not_to raise_error
+    expect(described_class.freq).to be_kind_of(Integer)
+  end
+
+  example 'num_cpu' do
+    expect(described_class).to respond_to(:num_cpu)
+    expect{ described_class.num_cpu }.not_to raise_error
+    expect(described_class.num_cpu).to be_kind_of(Integer)
   end
 
-  example "num_cpu" do
-    expect(Sys::CPU).to respond_to(:num_cpu)
-    expect{ Sys::CPU.num_cpu }.not_to raise_error
-    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  example 'num_active_cpu' do
+    expect(described_class).to respond_to(:num_active_cpu)
+    expect{ described_class.num_active_cpu }.not_to raise_error
+    expect(described_class.num_active_cpu).to be_kind_of(Integer)
   end
 
-  example "num_active_cpu" do
-    expect(Sys::CPU).to respond_to(:num_active_cpu)
-    expect{ Sys::CPU.num_active_cpu }.not_to raise_error
-    expect(Sys::CPU.num_active_cpu).to be_kind_of(Integer)
+  example 'cpu_architecture' do
+    expect(described_class).to respond_to(:architecture)
+    expect{ described_class.architecture }.not_to raise_error
+    expect(described_class.architecture).to be_kind_of(String)
   end
 
-  example "cpu_architecture" do
-    expect(Sys::CPU).to respond_to(:architecture)
-    expect{ Sys::CPU.architecture }.not_to raise_error
-    expect(Sys::CPU.architecture).to be_kind_of(String)
+  example 'load_avg basic sanity check' do
+    expect(described_class).to respond_to(:load_avg)
+    expect{ described_class.load_avg }.not_to raise_error
   end
 
-  example "load_avg sanity check" do
-    expect(Sys::CPU).to respond_to(:load_avg)
-    expect{ Sys::CPU.load_avg }.not_to raise_error
-    expect{ Sys::CPU.load_avg(0) }.not_to raise_error
-    expect{ Sys::CPU.load_avg{ |e| }.not_to raise_error }
-    expect{ Sys::CPU.load_avg(0){ }.to raise_error(ArgumentError) }
+  example 'load_avg with arguments and/or block sanity check' do
+    expect{ described_class.load_avg(0) }.not_to raise_error
+    expect{ described_class.load_avg{} }.not_to raise_error
+    expect{ described_class.load_avg(0){} }.to raise_error(ArgumentError)
   end
 
-  example "load_avg expected results" do
-    expect(Sys::CPU.load_avg).to be_kind_of(Array)
-    expect(Sys::CPU.load_avg(0)).to be_kind_of(Array)
-    expect(Sys::CPU.load_avg.length).to eq(3)
-    expect(Sys::CPU.load_avg(0).length).to eq(3)
+  example 'load_avg expected results' do
+    expect(described_class.load_avg).to be_kind_of(Array)
+    expect(described_class.load_avg(0)).to be_kind_of(Array)
+    expect(described_class.load_avg.length).to eq(3)
+    expect(described_class.load_avg(0).length).to eq(3)
   end
 end

data/spec/sys_cpu_linux_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ###########################################################
 # sys_cpu_linux_spec.rb
 #
@@ -8,46 +10,50 @@ require 'sys/cpu'
 require 'spec_helper'
 
 RSpec.describe Sys::CPU, :linux => true do
-  example "dynamic methods are defined as expected" do
-    expect{
-      Sys::CPU.processors{ |cs|
+  example 'dynamic methods are defined as expected' do
+    expect do
+      described_class.processors do |cs|
         cs.members.each{ |m| cs[m].to_s }
-      }
-    }.not_to raise_error
+      end
+    end.not_to raise_error
+  end
+
+  example 'load average works as expected' do
+    expect{ described_class.load_avg }.not_to raise_error
+    expect(described_class.load_avg.length).to eq(3)
   end
 
-  example "load average works as expected" do
-    expect{ Sys::CPU.load_avg }.not_to raise_error
-    expect(Sys::CPU.load_avg.length).to eq(3)
+  example 'cpu_stats works as expected' do
+    expect{ described_class.cpu_stats }.not_to raise_error
+    expect(described_class.cpu_stats).to be_kind_of(Hash)
+    expect(described_class.cpu_stats['cpu0'].length).to be >= 4
   end
 
-  example "cpu_stats works as expected" do
-    expect{ Sys::CPU.cpu_stats }.not_to raise_error
-    expect(Sys::CPU.cpu_stats).to be_kind_of(Hash)
-    expect(Sys::CPU.cpu_stats['cpu0'].length).to be >= 4
+  example 'architecture works as expected' do
+    expect{ described_class.architecture }.not_to raise_error
+    expect(described_class.architecture).to be_kind_of(String)
   end
 
-  example "architecture works as expected" do
-    expect{ Sys::CPU.architecture }.not_to raise_error
-    expect(Sys::CPU.architecture).to be_kind_of(String)
+  example 'model works as expected' do
+    expect{ described_class.model }.not_to raise_error
+    expect(described_class.model).to be_kind_of(String)
   end
 
-  example "model works as expected" do
-    expect{ Sys::CPU.model }.not_to raise_error
-    expect(Sys::CPU.model).to be_kind_of(String)
+  example 'freq works as expected' do
+    expect{ described_class.freq }.not_to raise_error
+    expect(described_class.freq).to be_kind_of(Numeric)
   end
 
-  example "freq works as expected" do
-    expect{ Sys::CPU.freq }.not_to raise_error
-    expect(Sys::CPU.freq).to be_kind_of(Numeric)
+  example 'num_cpu works as expected' do
+    expect{ described_class.num_cpu }.not_to raise_error
+    expect(described_class.num_cpu).to be_kind_of(Numeric)
   end
 
-  example "num_cpu works as expected" do
-    expect{ Sys::CPU.num_cpu }.not_to raise_error
-    expect(Sys::CPU.num_cpu).to be_kind_of(Numeric)
+  example 'bogus methods are not picked up by method_missing' do
+    expect{ described_class.bogus }.to raise_error(NoMethodError)
   end
 
-  example "bogus methods are not picked up by method_missing" do
-    expect{Sys::CPU.bogus }.to raise_error(NoMethodError)
+  example 'constructor is private' do
+    expect{ described_class.new }.to raise_error(NoMethodError)
   end
 end

data/spec/{sys_cpu_spec.rb → sys_cpu_shared.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #######################################################################
 # sys_cpu_spec.rb
 #
@@ -7,12 +9,16 @@
 require 'sys/cpu'
 require 'rspec'
 
-RSpec.describe Sys::CPU::VERSION do
-  example "version number is set to the expected value" do
-    expect(Sys::CPU::VERSION).to eq('1.0.3')
+RSpec.shared_examples Sys::CPU do
+  example 'version number is set to the expected value' do
+    expect(Sys::CPU::VERSION).to eq('1.0.6')
   end
 
-  example "version number is frozen" do
+  example 'version number is frozen' do
     expect(Sys::CPU::VERSION).to be_frozen
   end
+
+  example 'constructor is private' do
+    expect{ described_class.new }.to raise_error(NoMethodError)
+  end
 end

data/spec/sys_cpu_sunos_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ###########################################################
 # sys_cpu_sunos_spec.rb
 #
@@ -8,73 +10,73 @@ require 'sys/cpu'
 require 'spec_helper'
 
 RSpec.describe Sys::CPU, :sunos => true do
-  example "freq method basic functionality" do
-    expect(Sys::CPU).to respond_to(:freq)
-    expect{ Sys::CPU.freq }.not_to raise_error
+  example 'freq method basic functionality' do
+    expect(described_class).to respond_to(:freq)
+    expect{ described_class.freq }.not_to raise_error
   end
 
-  example "freq method does not accept any arguments" do
-    expect{ Sys::CPU.freq(0) }.to raise_error(ArgumentError)
+  example 'freq method does not accept any arguments' do
+    expect{ described_class.freq(0) }.to raise_error(ArgumentError)
   end
 
-  example "freq method returns a sane value" do
-    expect(Sys::CPU.freq).to be_kind_of(Integer)
-    expect(Sys::CPU.freq).to be > 100
+  example 'freq method returns a sane value' do
+    expect(described_class.freq).to be_kind_of(Integer)
+    expect(described_class.freq).to be > 100
   end
 
-  example "fpu_type basic functionality" do
-    expect(Sys::CPU).to respond_to(:fpu_type)
-    expect{ Sys::CPU.fpu_type }.not_to raise_error
+  example 'fpu_type basic functionality' do
+    expect(described_class).to respond_to(:fpu_type)
+    expect{ described_class.fpu_type }.not_to raise_error
   end
 
-  example "fpu_type returns a sane value" do
-    expect(Sys::CPU.fpu_type).to be_kind_of(String)
-    expect(Sys::CPU.fpu_type).not_to be_empty
+  example 'fpu_type returns a sane value' do
+    expect(described_class.fpu_type).to be_kind_of(String)
+    expect(described_class.fpu_type).not_to be_empty
   end
 
-  example "load_avg basic functionality" do
-    expect(Sys::CPU).to respond_to(:load_avg)
-    expect{ Sys::CPU.load_avg }.not_to raise_error
+  example 'load_avg basic functionality' do
+    expect(described_class).to respond_to(:load_avg)
+    expect{ described_class.load_avg }.not_to raise_error
   end
 
-  example "load_avg method returns the expected values" do
-    expect(Sys::CPU.load_avg).to be_kind_of(Array)
-    expect(Sys::CPU.load_avg.length).to eq(3)
-    expect(Sys::CPU.load_avg.first).to be_kind_of(Float)
+  example 'load_avg method returns the expected values' do
+    expect(described_class.load_avg).to be_kind_of(Array)
+    expect(described_class.load_avg.length).to eq(3)
+    expect(described_class.load_avg.first).to be_kind_of(Float)
   end
 
-  example "model method basic functionality" do
-    expect(Sys::CPU).to respond_to(:model)
-    expect{ Sys::CPU.model }.not_to raise_error
+  example 'model method basic functionality' do
+    expect(described_class).to respond_to(:model)
+    expect{ described_class.model }.not_to raise_error
   end
 
-  example "model method returns a sane value" do
-    expect(Sys::CPU.model).to be_kind_of(String)
-    expect(Sys::CPU.model).not_to be_empty
+  example 'model method returns a sane value' do
+    expect(described_class.model).to be_kind_of(String)
+    expect(described_class.model).not_to be_empty
   end
 
-  example "num_cpu method basic functionalty" do
-    expect(Sys::CPU).to respond_to(:num_cpu)
-    expect{ Sys::CPU.num_cpu }.not_to raise_error
+  example 'num_cpu method basic functionalty' do
+    expect(described_class).to respond_to(:num_cpu)
+    expect{ described_class.num_cpu }.not_to raise_error
   end
 
-  example "num_cpu method returns a sane value" do
-    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
-    expect(Sys::CPU.num_cpu).to be > 0
+  example 'num_cpu method returns a sane value' do
+    expect(described_class.num_cpu).to be_kind_of(Integer)
+    expect(described_class.num_cpu).to be > 0
   end
 
-  example "state basic functionality" do
-    expect(Sys::CPU).to respond_to(:state)
-    expect{ Sys::CPU.state }.not_to raise_error
+  example 'state basic functionality' do
+    expect(described_class).to respond_to(:state)
+    expect{ described_class.state }.not_to raise_error
   end
 
-  example "state method accepts one optional argument" do
-    expect{ Sys::CPU.state(0) }.not_to raise_error
-    expect{ Sys::CPU.state(0,0) }.to raise_error(ArgumentError)
+  example 'state method accepts one optional argument' do
+    expect{ described_class.state(0) }.not_to raise_error
+    expect{ described_class.state(0, 0) }.to raise_error(ArgumentError)
   end
 
-  example "state method returns a sane value" do
-    expect(Sys::CPU.state(0)).to be_kind_of(String)
-    expect(Sys::CPU.state.empty?).to be false
+  example 'state method returns a sane value' do
+    expect(described_class.state(0)).to be_kind_of(String)
+    expect(described_class.state.empty?).to be false
   end
 end

data/spec/sys_cpu_windows_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ######################################################################
 # sys_cpu_windows_spec.rb
 #
@@ -11,51 +13,54 @@ require 'socket'
 RSpec.describe Sys::CPU, :windows => true do
   let(:host) { Socket.gethostname }
 
-  example "architecture" do
-    expect(Sys::CPU).to respond_to(:architecture)
-    expect{ Sys::CPU.architecture }.not_to raise_error
-    expect{ Sys::CPU.architecture(host) }.not_to raise_error
-    expect(Sys::CPU.architecture).to be_kind_of(String)
+  example 'architecture' do
+    expect(described_class).to respond_to(:architecture)
+    expect{ described_class.architecture }.not_to raise_error
+    expect{ described_class.architecture(host) }.not_to raise_error
+    expect(described_class.architecture).to be_kind_of(String)
+  end
+
+  example 'freq basic functionality' do
+    expect(described_class).to respond_to(:freq)
+    expect{ described_class.freq }.not_to raise_error
+    expect(described_class.freq).to be_kind_of(Integer)
   end
 
-  example "freq" do
-    expect(Sys::CPU).to respond_to(:freq)
-    expect{ Sys::CPU.freq }.not_to raise_error
-    expect{ Sys::CPU.freq(0) }.not_to raise_error
-    expect{ Sys::CPU.freq(0, host) }.not_to raise_error
-    expect(Sys::CPU.freq).to be_kind_of(Integer)
+  example 'freq with arguments' do
+    expect{ described_class.freq(0) }.not_to raise_error
+    expect{ described_class.freq(0, host) }.not_to raise_error
   end
 
-  example "model" do
-    expect(Sys::CPU).to respond_to(:model)
-    expect{ Sys::CPU.model }.not_to raise_error
-    expect{ Sys::CPU.model(host) }.not_to raise_error
-    expect(Sys::CPU.model).to be_kind_of(String)
+  example 'model' do
+    expect(described_class).to respond_to(:model)
+    expect{ described_class.model }.not_to raise_error
+    expect{ described_class.model(host) }.not_to raise_error
+    expect(described_class.model).to be_kind_of(String)
   end
 
-  example "num_cpu" do
-    expect(Sys::CPU).to respond_to(:num_cpu)
-    expect{ Sys::CPU.num_cpu }.not_to raise_error
-    expect{ Sys::CPU.num_cpu(host) }.not_to raise_error
-    expect(Sys::CPU.num_cpu).to be_kind_of(Integer)
+  example 'num_cpu' do
+    expect(described_class).to respond_to(:num_cpu)
+    expect{ described_class.num_cpu }.not_to raise_error
+    expect{ described_class.num_cpu(host) }.not_to raise_error
+    expect(described_class.num_cpu).to be_kind_of(Integer)
   end
 
-  example "cpu_type" do
-    expect(Sys::CPU).to respond_to(:cpu_type)
-    expect{ Sys::CPU.cpu_type }.not_to raise_error
-    expect{ Sys::CPU.cpu_type(host) }.not_to raise_error
-    expect(Sys::CPU.cpu_type).to be_kind_of(String)
+  example 'cpu_type' do
+    expect(described_class).to respond_to(:cpu_type)
+    expect{ described_class.cpu_type }.not_to raise_error
+    expect{ described_class.cpu_type(host) }.not_to raise_error
+    expect(described_class.cpu_type).to be_kind_of(String)
   end
 
-  example "load_avg" do
-    expect(Sys::CPU).to respond_to(:load_avg)
-    expect{ Sys::CPU.load_avg }.not_to raise_error
-    expect{ Sys::CPU.load_avg(0, host) }.not_to raise_error
-    expect(Sys::CPU.load_avg).to be_kind_of(Integer)
+  example 'load_avg' do
+    expect(described_class).to respond_to(:load_avg)
+    expect{ described_class.load_avg }.not_to raise_error
+    expect{ described_class.load_avg(0, host) }.not_to raise_error
+    expect(described_class.load_avg).to be_kind_of(Integer).or be_kind_of(NilClass)
   end
 
-  example "processors" do
-    expect(Sys::CPU).to respond_to(:processors)
-    expect{ Sys::CPU.processors{}.not_to raise_error }
+  example 'processors' do
+    expect(described_class).to respond_to(:processors)
+    expect{ described_class.processors{} }.not_to raise_error
   end
 end

data/sys-cpu.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'sys-cpu'
-  spec.version    = '1.0.3'
+  spec.version    = '1.0.6'
   spec.author     = 'Daniel J. Berger'
   spec.email      = 'djberg96@gmail.com'
   spec.license    = 'Apache-2.0'
@@ -12,23 +12,24 @@ Gem::Specification.new do |spec|
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
   spec.cert_chain = ['certs/djberg96_pub.pem']
 
-  spec.extra_rdoc_files = Dir['*.rdoc']
-
   # The ffi dependency is only relevent for the Unix version. Given the
   # ubiquity of ffi these days, I felt a bogus dependency on ffi for Windows
   # and Linux was worth the tradeoff of not having to create 3 separate gems.
   spec.add_dependency('ffi', '~> 1.1')
 
   spec.add_development_dependency('rake')
+  spec.add_development_dependency('rubocop')
   spec.add_development_dependency('rspec', '~> 3.9')
+  spec.add_development_dependency('rubocop-rspec')
 
   spec.metadata = {
-    'homepage_uri'      => 'https://github.com/djberg96/sys-cpu',
-    'bug_tracker_uri'   => 'https://github.com/djberg96/sys-cpu/issues',
-    'changelog_uri'     => 'https://github.com/djberg96/sys-cpu/blob/ffi/CHANGES.md',
-    'documentation_uri' => 'https://github.com/djberg96/sys-cpu/wiki',
-    'source_code_uri'   => 'https://github.com/djberg96/sys-cpu',
-    'wiki_uri'          => 'https://github.com/djberg96/sys-cpu/wiki'
+    'homepage_uri'          => 'https://github.com/djberg96/sys-cpu',
+    'bug_tracker_uri'       => 'https://github.com/djberg96/sys-cpu/issues',
+    'changelog_uri'         => 'https://github.com/djberg96/sys-cpu/blob/main/CHANGES.md',
+    'documentation_uri'     => 'https://github.com/djberg96/sys-cpu/wiki',
+    'source_code_uri'       => 'https://github.com/djberg96/sys-cpu',
+    'wiki_uri'              => 'https://github.com/djberg96/sys-cpu/wiki',
+    'rubygems_mfa_required' => 'true'
   }
 
   spec.description = <<-EOF