sys-cpu 1.0.1 → 1.0.4

data/lib/sys/linux/sys/cpu.rb

@@ -1,53 +1,53 @@
+# frozen_string_literal: true
+
 ##########################################################
 # linux.rb (sys-cpu) - pure Ruby version for Linux
 ##########################################################
-module Sys
 
+# The Sys module is a namespace only.
+module Sys
   # :stopdoc:
 
-  private
-
-  cpu_file   = "/proc/cpuinfo"
-  cpu_hash   = {}
+  cpu_file  = '/proc/cpuinfo'
+  cpu_hash  = {}
   CPU_ARRAY = []
 
+  private_constant :CPU_ARRAY
+
   # Parse the info out of the /proc/cpuinfo file
-  IO.foreach(cpu_file){ |line|
+  File.foreach(cpu_file) do |line|
     line.strip!
     next if line.empty?
 
-    key, val = line.split(":")
+    key, val = line.split(':')
     key.strip!
-    key.gsub!(/\s+/,"_")
+    key.gsub!(/\s+/, '_')
     key.downcase!
     val.strip! if val
 
-    if cpu_hash.has_key?(key)
+    if cpu_hash.key?(key)
       CPU_ARRAY.push(cpu_hash.dup)
       cpu_hash.clear
     end
 
     # Turn yes/no attributes into booleans
-    if val == 'yes'
-      val = true
-    elsif val == 'no'
-      val = false
-    end
+    val = true if val == 'yes'
+    val = false if val == 'no'
 
     cpu_hash[key] = val
-  }
+  end
 
   CPU_ARRAY.push(cpu_hash)
 
-  public
-
   # :startdoc:
 
+  # The CPU class encapsulates information about physical CPUs on your system.
   class CPU
-
     # :stopdoc:
 
-    CPUStruct = Struct.new("CPUStruct", *CPU_ARRAY.first.keys)
+    CPUStruct = Struct.new('CPUStruct', *CPU_ARRAY.first.keys)
+
+    private_constant :CPUStruct
 
     # :startdoc:
 
@@ -58,15 +58,15 @@ module Sys
     #
     def self.processors
       array = []
-      CPU_ARRAY.each{ |hash|
+      CPU_ARRAY.each do |hash|
         struct = CPUStruct.new
-        struct.members.each{ |m| struct.send("#{m}=", hash["#{m}"]) }
+        struct.members.each{ |m| struct.send("#{m}=", hash[m.to_s]) }
         if block_given?
           yield struct
         else
           array << struct
         end
-      }
+      end
       array unless block_given?
     end
 
@@ -80,12 +80,10 @@ module Sys
     #
     def self.architecture
       case CPU_ARRAY.first['cpu_family']
-      when '3'
-        "x86"
-      when '6'
-        "x86_64"
-      else
-        nil
+        when '3'
+          'x86'
+        when '6'
+          'x86_64'
       end
     end
 
@@ -101,28 +99,30 @@ module Sys
       CPU_ARRAY.first['cpu_mhz'].to_f.round
     end
 
-    private
-
     # Create singleton methods for each of the attributes.
     #
-    def self.method_missing(id, arg=0)
-      raise NoMethodError, "'#{id}'" unless CPU_ARRAY[arg].has_key?(id.to_s)
+    def self.method_missing(id, arg = 0)
+      raise NoMethodError, "'#{id}'" unless CPU_ARRAY[arg].key?(id.to_s)
       rv = CPU_ARRAY[arg][id.to_s]
       if rv.nil?
-        id = id.to_s + "?"
+        id = "#{id}?"
         rv = CPU_ARRAY[arg][id]
       end
       rv
     end
 
-    public
+    def self.respond_to_missing?(method, _private_methods = false)
+      CPU_ARRAY.first.keys.include?(method.to_s)
+    end
+
+    private_class_method :method_missing
 
     # Returns a 3 element Array corresponding to the 1, 5 and 15 minute
     # load average for the system.
     #
     def self.load_avg
-      load_avg_file = "/proc/loadavg"
-      IO.readlines(load_avg_file).first.split[0..2].map{ |e| e.to_f }
+      load_avg_file = '/proc/loadavg'
+      File.readlines(load_avg_file).first.split[0..2].map(&:to_f)
     end
 
     # Returns a hash of arrays that contains an array of the following
@@ -142,24 +142,24 @@ module Sys
     # Note that older kernels may not necessarily include some of these fields.
     #
     def self.cpu_stats
-      cpu_stat_file = "/proc/stat"
+      cpu_stat_file = '/proc/stat'
       hash = {} # Hash needed for multi-cpu systems
 
-      lines = IO.readlines(cpu_stat_file)
+      lines = File.readlines(cpu_stat_file)
 
-      lines.each_with_index{ |line, i|
+      lines.each_with_index do |line, i|
         array = line.split
-        break unless array[0] =~ /cpu/   # 'cpu' entries always on top
+        break unless array[0] =~ /cpu/ # 'cpu' entries always on top
 
         # Some machines list a 'cpu' and a 'cpu0'. In this case only
         # return values for the numbered cpu entry.
-        if lines[i].split[0] == "cpu" && lines[i+1].split[0] =~ /cpu\d/
+        if lines[i].split[0] == 'cpu' && lines[i + 1].split[0] =~ /cpu\d/
           next
         end
 
-        vals = array[1..-1].map{ |e| e = e.to_i / 100 } # 100 jiffies/sec.
+        vals = array[1..-1].map{ |e| e.to_i / 100 } # 100 jiffies/sec.
         hash[array[0]] = vals
-      }
+      end
 
       hash
     end

data/lib/sys/unix/sys/cpu.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require 'ffi'
 require 'rbconfig'
 
+# The Sys module is a name space only.
 module Sys
+  # The CPU class encapsulates information about the physical CPU's on your system.
   class CPU
     extend FFI::Library
     ffi_lib FFI::Library::LIBC
@@ -43,7 +47,7 @@ module Sys
     begin
       attach_function(
         :sysctl,
-        [:pointer, :uint, :pointer, :pointer, :pointer, :size_t],
+        %i[pointer uint pointer pointer pointer size_t],
         :int
       )
       private_class_method :sysctl
@@ -54,7 +58,7 @@ module Sys
     begin
       attach_function(
         :sysctlbyname,
-        [:string, :pointer, :pointer, :pointer, :size_t],
+        %i[string pointer pointer pointer size_t],
         :int
       )
       private_class_method :sysctlbyname
@@ -64,10 +68,10 @@ module Sys
 
     # Solaris
     begin
-      attach_function :getloadavg, [:pointer, :int], :int
-      attach_function :processor_info, [:int, :pointer], :int
+      attach_function :getloadavg, %i[pointer int], :int
+      attach_function :processor_info, %i[int pointer], :int
       attach_function :sysconf, [:int], :long
-      attach_function :sysinfo, [:int, :pointer, :long], :int
+      attach_function :sysinfo, %i[int pointer long], :int
 
       private_class_method :getloadavg
       private_class_method :processor_info
@@ -95,7 +99,7 @@ module Sys
         buf = 0.chr * 257
 
         if sysinfo(SI_ARCHITECTURE, buf, buf.size) < 0
-          raise Error, "sysinfo function failed"
+          raise Error, 'sysinfo function failed'
         end
 
         buf.strip
@@ -105,14 +109,8 @@ module Sys
 
         size.write_int(optr.size)
 
-        if RbConfig::CONFIG['host_os'] =~ /darwin/i
-          name = 'hw.machine'
-        else
-          name = 'hw.machine_arch'
-        end
-
-        if sysctlbyname(name, optr, size, nil, 0) < 0
-          raise Error, "sysctlbyname function failed"
+        if sysctlbyname('hw.machine_arch', optr, size, nil, 0) < 0
+          raise Error, 'sysctlbyname function failed'
         end
 
         optr.read_string
@@ -125,7 +123,7 @@ module Sys
         size.write_int(buf.size)
 
         if sysctl(mib, 2, buf, size, nil, 0) < 0
-          raise Error, "sysctl function failed"
+          raise Error, 'sysctl function failed'
         end
 
         buf.strip
@@ -144,7 +142,7 @@ module Sys
         size.write_long(optr.size)
 
         if sysctlbyname('hw.ncpu', optr, size, nil, 0) < 0
-          raise Error, "sysctlbyname failed"
+          raise Error, 'sysctlbyname failed'
         end
 
         optr.read_long
@@ -152,7 +150,7 @@ module Sys
         num = sysconf(SC_NPROCESSORS_ONLN)
 
         if num < 0
-          raise Error, "sysconf function failed"
+          raise Error, 'sysconf function failed'
         end
 
         num
@@ -165,10 +163,10 @@ module Sys
         size.write_int(buf.size)
 
         if sysctl(mib, 2, buf, size, nil, 0) < 0
-          raise Error, "sysctl function failed"
+          raise Error, 'sysctl function failed'
         end
 
-        buf.strip.unpack("C").first
+        buf.strip.unpack1('C')
       end
     end
 
@@ -186,70 +184,44 @@ module Sys
         size.write_int(buf.size)
 
         if sysctl(mib, 2, buf, size, nil, 0) < 0
-          raise Error, "sysctl function failed"
+          raise Error, 'sysctl function failed'
         end
-
-        buf.strip
       else
         buf = 0.chr * 257
 
         if sysinfo(SI_MACHINE, buf, buf.size) < 0
-          raise Error, "sysinfo function failed"
+          raise Error, 'sysinfo function failed'
         end
-
-        buf.strip
       end
+
+      buf.strip
     end
 
     # Returns a string indicating the cpu model.
     #
     def self.model
-      if RbConfig::CONFIG['host_os'] =~ /darwin/i
-        ptr  = FFI::MemoryPointer.new(:long)
-        size = FFI::MemoryPointer.new(:size_t)
+      if respond_to?(:sysctl, true)
+        buf  = 0.chr * 64
+        mib  = FFI::MemoryPointer.new(:int, 2)
+        size = FFI::MemoryPointer.new(:long, 1)
 
-        size.write_long(ptr.size)
+        mib.write_array_of_int([CTL_HW, HW_MODEL])
+        size.write_int(buf.size)
 
-        if sysctlbyname("hw.cputype", ptr, size, nil, 0) < 0
-          raise "sysctlbyname function failed"
+        if sysctl(mib, 2, buf, size, nil, 0) < 0
+          raise Error, 'sysctl function failed'
         end
 
-        case ptr.read_long
-          when  CPU_TYPE_X86, CPU_TYPE_X86_64
-            "Intel"
-          when CPU_TYPE_SPARC
-            "Sparc"
-          when CPU_TYPE_POWERPC, CPU_TYPE_POWERPC64
-            "PowerPC"
-          else
-            "Unknown"
-        end
+        buf.strip
       else
-        if respond_to?(:sysctl, true)
-          buf  = 0.chr * 64
-          mib  = FFI::MemoryPointer.new(:int, 2)
-          size = FFI::MemoryPointer.new(:long, 1)
-
-          mib.write_array_of_int([CTL_HW, HW_MODEL])
-          size.write_int(buf.size)
-
-          if sysctl(mib, 2, buf, size, nil, 0) < 0
-            raise Error, "sysctl function failed"
-          end
-
-          buf.strip
-        else
-          pinfo = ProcInfo.new
-
-          # Some systems start at 0, some at 1
-          if processor_info(0, pinfo) < 0
-            if processor_info(1, pinfo) < 0
-              raise Error, "process_info function failed"
-            end
-          end
+        pinfo = ProcInfo.new
 
-          pinfo[:pi_processor_type].to_s
+        # Some systems start at 0, some at 1
+        if processor_info(0, pinfo) < 0 && processor_info(1, pinfo) < 0
+          raise Error, 'processor_info function failed'
         end
+
+        pinfo[:pi_processor_type].to_s
       end
     end
 
@@ -269,14 +241,10 @@ module Sys
         end
 
         if sysctlbyname(name, optr, size, nil, 0) < 0
-          raise Error, "sysctlbyname failed"
+          raise Error, 'sysctlbyname failed'
         end
 
-        if RbConfig::CONFIG['host_os'] =~ /darwin/i
-          optr.read_long / 1000000
-        else
-          optr.read_long
-        end
+        optr.read_long
       elsif respond_to?(:sysctl, true)
         buf  = 0.chr * 16
         mib  = FFI::MemoryPointer.new(:int, 2)
@@ -286,18 +254,16 @@ module Sys
         size.write_int(buf.size)
 
         if sysctl(mib, 2, buf, size, nil, 0) < 0
-          raise Error, "sysctl function failed"
+          raise Error, 'sysctl function failed'
         end
 
-        buf.unpack("I*").first / 1000000
+        buf.unpack1('I*') / 1_000_000
       else
         pinfo = ProcInfo.new
 
         # Some systems start at 0, some at 1
-        if processor_info(0, pinfo) < 0
-          if processor_info(1, pinfo) < 0
-            raise Error, "process_info function failed"
-          end
+        if processor_info(0, pinfo) < 0 && processor_info(1, pinfo) < 0
+          raise Error, 'processor_info function failed'
         end
 
         pinfo[:pi_clock].to_i
@@ -308,15 +274,10 @@ module Sys
     # average.
     #
     def self.load_avg
-      if respond_to?(:getloadavg, true)
-        loadavg = FFI::MemoryPointer.new(:double, 3)
-
-        if getloadavg(loadavg, loadavg.size) < 0
-          raise Error, "getloadavg function failed"
-        end
-
-        loadavg.get_array_of_double(0, 3)
-      end
+      return unless respond_to?(:getloadavg, true)
+      loadavg = FFI::MemoryPointer.new(:double, 3)
+      raise Error, 'getloadavg function failed' if getloadavg(loadavg, loadavg.size) < 0
+      loadavg.get_array_of_double(0, 3)
     end
 
     # Returns the floating point processor type.
@@ -328,10 +289,9 @@ module Sys
 
       pinfo = ProcInfo.new
 
-      if processor_info(0, pinfo) < 0
-        if processor_info(1, pinfo) < 0
-          raise Error, "process_info function failed"
-        end
+      # Some start at 0, some start at 1
+      if processor_info(0, pinfo) < 0 && processor_info(1, pinfo) < 0
+        raise Error, 'processor_info function failed'
       end
 
       pinfo[:pi_fputypes].to_s
@@ -348,24 +308,24 @@ module Sys
       pinfo = ProcInfo.new
 
       if processor_info(num, pinfo) < 0
-        raise Error, "process_info function failed"
+        raise Error, 'processor_info function failed'
       end
 
       case pinfo[:pi_state].to_i
         when P_ONLINE
-          "online"
+          'online'
         when P_OFFLINE
-          "offline"
+          'offline'
         when P_POWEROFF
-          "poweroff"
+          'poweroff'
         when P_FAULTED
-          "faulted"
+          'faulted'
         when P_NOINTR
-          "nointr"
+          'nointr'
         when P_SPARE
-          "spare"
+          'spare'
         else
-          "unknown"
+          'unknown'
       end
     end
   end