lmsensors 0.1.0

data/lib/lmsensors/features/alarm.rb

@@ -0,0 +1,38 @@
+# lib/lmsensors/features/alarm.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default formatting proc for ALARM types
+    FMT_ALARM = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      # Don't need to return unit, as it is proc for this feature type
+      out.delete(:unit)
+      
+      # Format the outputs
+      feature.subfs.map do |k, v|
+        # Only check is alarm is enabled.
+        # The other option SSF_INTRUDE_BEEP
+        # is not formatted in the normal sensor program
+        if v[:subtype] == SSF_INTRUDE_ALARM then
+          out[k] = unit.call(v[:value]) end
+      end # End value mapper for alarm
+      out
+    end # End default alarm formatter
+    
+    ##
+    # The Alarm class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_INTRUSION type.
+    class Alarm < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_ALARM end
+    end # End Alarm class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/beep.rb

@@ -0,0 +1,33 @@
+# lib/lmsensors/features/beep.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default formatting proc for BEEP types
+    FMT_BEEP = lambda do |feature|
+      unit = feature.unit
+      out = feature.feature
+      # Don't need to return unit, as it is proc for this feature type
+      out.delete(:unit)
+      
+      # Format the outputs
+      feature.subfs.map do |k, v|
+        out[k] = unit.call(v[:value])
+      end # End value mapper for beep
+      out
+    end # End default beep formatter
+    
+    ##
+    # The Beep class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_BEEP_ENABLE type.
+    class Beep < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_BEEP end
+    end # End Beep class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/current.rb

@@ -0,0 +1,69 @@
+# lib/lmsensors/features/current.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default current formatting proc
+    FMT_CURR = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      tmp = { input: nil, max: nil }
+      
+      # Format the outputs
+      # Strip each, in case the unit is empty
+      feature.subfs.values.map do |v|
+        case v[:subtype]
+        when SSF_CURR_INPUT
+          tmp[:input] = v[:value]
+          out[:input] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_CURR_MAX
+          if v[:value] != 0 then
+            tmp[:max] = v[:value]
+            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_CURR_CRIT
+          if v[:value] != 0 then
+            tmp[:crit] = v[:value]
+            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_CURR_MIN
+          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
+        end
+      end # End value mapper for fan
+      
+      # Set the check symbols
+      # Symbol for input, symbol for limit
+      syi, syl = :input, :max
+      
+      # Calculate the percentage of current max
+      # :percent is against max, for current
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent] = "#{perc}%".strip
+      end # Only if both are present
+      
+      syl = :crit
+      
+      # Calculate the percentage of current crit
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent_crit] = "#{perc}%".strip
+      end # Only if both are present
+      out
+    end # End current proc
+    
+    ##
+    # The Current class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_CURR type.
+    class Current < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_CURR end
+    end # End Current class
+  end # end Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/fan.rb

@@ -0,0 +1,52 @@
+# lib/lmsensors/featureseatures/fan.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default formatting proc for
+    # the X_FAN subtype.
+    FMT_FAN = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      tmp = { input: nil, max: nil }
+      
+      # Format the outputs
+      # Strip each, in case the unit is empty
+      feature.subfs.values.map do |v|
+        case v[:subtype]
+        when SSF_FAN_INPUT
+          tmp[:input] = v[:value]
+          out[:input] = "#{v[:value]} #{unit}".strip
+        when SSF_FAN_MAX
+          tmp[:max] = v[:value]
+          out[:max] = "#{v[:value]} #{unit}".strip
+        when SSF_FAN_MIN
+          out[:min] = "#{v[:value]} #{unit}".strip
+        end
+      end # End value mapper for fan
+      
+      # Calculate the percentage of max speed of fan
+      if tmp[:max] and tmp[:input] then
+        perc = ((tmp[:input].to_f / tmp[:max]) * 100).round(2)
+        out[:percent] = "#{perc}%".strip
+      end # Only if both are present
+      out
+    end # End default fan formatter
+    
+    ##
+    # The Fan class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_FAN type.
+    class Fan < LmSensors::Feature::GenFeature
+      ##
+      # Override the default formatter
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_FAN end
+    end # End Fan class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/humidity.rb

@@ -0,0 +1,35 @@
+# lib/lmsensors/features/voltage.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default humidity formatting proc.
+    # 
+    # I cannot test this on any of my systems,
+    # so it might need to be overridden.
+    FMT_HUMIDITY = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      
+      # Format the outputs
+      feature.subfs.map do |k, v|
+        out[k] = "#{v[:value].round(2)}#{unit}"
+      end # End value mapper for humidity
+      out
+    end # End humidity proc
+    
+    ##
+    # The Humidity class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_HUMIDITY type.
+    class Humidity < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_HUMIDITY end
+    end # End Humidity class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/power.rb

@@ -0,0 +1,80 @@
+# lib/lmsensors/features/power.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default power formatting proc
+    FMT_POWER = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      tmp = { input: nil, max: nil }
+      
+      # Format the outputs
+      # Strip each, in case the unit is empty
+      feature.subfs.values.map do |v|
+        case v[:subtype]
+        when SSF_POWER_INPUT
+          out[:input] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_POWER_AVG
+          tmp[:average] = v[:value]
+          out[:average] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_POWER_MAX
+          tmp[:max] = v[:value]
+          out[:max] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_POWER_CRIT
+          tmp[:crit] = v[:value]
+          out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_POWER_CAP
+          tmp[:cap] = v[:value]
+          out[:cap] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_POWER_MIN
+          out[:min] = "#{v[:value].round(2)} #{unit}".strip
+        end
+      end # End value mapper for fan
+      
+      # Set the check symbols
+      # Symbol for input, symbol for limit
+      syi, syl = :average, :cap
+      
+      # Calculate the percentage of power cap
+      # :percent is against cap for power, and it is
+      # in respect to :average, not :input, as not all
+      # sensors will use input for power.
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent] = "#{perc}%".strip
+      end # Only if both are present
+      
+      syl = :max
+      
+      # Calculate the percentage of power max
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent_max] = "#{perc}%".strip
+      end # Only if both are present
+      
+      syl = :crit
+      
+      # Calculate the percentage of power crit
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent_crit] = "#{perc}%".strip
+      end # Only if both are present
+      out
+    end # End power proc
+    
+    ##
+    # The Power class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_POWER type.
+    class Power < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_POWER end
+    end # End Power class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/temp.rb

@@ -0,0 +1,69 @@
+# lib/lmsensors/features/temp.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default temperature formatting proc
+    FMT_TEMP = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      tmp = { input: nil, max: nil }
+      
+      # Format the outputs
+      # Strip each, in case the unit is empty
+      feature.subfs.values.map do |v|
+        case v[:subtype]
+        when SSF_TEMP_INPUT
+          tmp[:input] = v[:value]
+          out[:input] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_TEMP_MAX
+          if v[:value] != 0 then
+            tmp[:max] = v[:value]
+            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_TEMP_CRIT
+          if v[:value] != 0 then
+            tmp[:crit] = v[:value]
+            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_TEMP_MIN
+          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
+        end
+      end # End value mapper for fan
+      
+      # Set the check symbols
+      # Symbol for input, symbol for limit
+      syi, syl = :input, :max
+      
+      # Calculate the percentage of voltage max
+      # :percent is against max, for voltage
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent] = "#{perc}%".strip
+      end # Only if both are present
+      
+      syl = :crit
+      
+      # Calculate the percentage of voltage crit
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent_crit] = "#{perc}%".strip
+      end # Only if both are present
+      out
+    end # End temp proc
+    
+    ##
+    # The Temp class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_TEMP type.
+    class Temp < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_TEMP end
+    end # End Temp class
+  end # End Feature append
+end # End LmSensors inclusion

data/lib/lmsensors/features/voltage.rb

@@ -0,0 +1,69 @@
+# lib/lmsensors/features/voltage.rb
+
+# Make sure to include the constants
+require_relative "../lm_constants"
+require_relative "./abs_feature"
+
+# :nodoc: Append to the main module
+module LmSensors
+  # :nodoc: Append to the Feature module
+  module Feature
+    ##
+    # Default voltage formatting proc
+    FMT_VOLTAGE = lambda do |feature|
+      # Formatted structure
+      unit = feature.unit
+      out = feature.feature
+      tmp = { input: nil, max: nil }
+      
+      # Format the outputs
+      # Strip each, in case the unit is empty
+      feature.subfs.values.map do |v|
+        case v[:subtype]
+        when SSF_IN_INPUT
+          tmp[:input] = v[:value]
+          out[:input] = "#{v[:value].round(2)} #{unit}".strip
+        when SSF_IN_MAX
+          if v[:value] != 0 then
+            tmp[:max] = v[:value]
+            out[:max] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_IN_CRIT
+          if v[:value] != 0 then
+            tmp[:crit] = v[:value]
+            out[:crit] = "#{v[:value].round(2)} #{unit}".strip
+          end
+        when SSF_IN_MIN
+          if v[:value] != 0 then out[:min] = "#{v[:value].round(2)} #{unit}".strip end
+        end
+      end # End value mapper for fan
+      
+      # Set the check symbols
+      # Symbol for input, symbol for limit
+      syi, syl = :input, :max
+      
+      # Calculate the percentage of voltage max
+      # :percent is against max, for voltage
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent] = "#{perc}%".strip
+      end # Only if both are present
+      
+      syl = :crit
+      
+      # Calculate the percentage of voltage crit
+      if tmp[syl] and tmp[syi] then
+        perc = ((tmp[syi].to_f / tmp[syl]) * 100).round(2)
+        out[:percent_crit] = "#{perc}%".strip
+      end # Only if both are present
+      out
+    end # End voltage proc
+    
+    ##
+    # The Voltage class is appended to the LmSensors module
+    # to handle analytic post-processing of the FEATURE_IN type.
+    class Voltage  < LmSensors::Feature::GenFeature
+      def def_fmt() @default_formatter = LmSensors::Feature::FMT_VOLTAGE end
+    end # End Voltage class
+  end # End Feature append
+end # End LmSensors inclusion