facter 1.6.1 → 1.6.2

data/lib/facter/util/memory.rb

@@ -3,83 +3,83 @@
 ##
 
 module Facter::Memory
-    require 'thread'
+  require 'thread'
 
-    def self.meminfo_number(tag)
-        memsize = ""
-        Thread::exclusive do
-            size, scale = [0, ""]
-            File.readlines("/proc/meminfo").each do |l|
-                size, scale = [$1.to_f, $2] if l =~ /^#{tag}:\s+(\d+)\s+(\S+)/
-                # MemoryFree == memfree + cached + buffers
-                #  (assume scales are all the same as memfree)
-                if tag == "MemFree" &&
-                    l =~ /^(?:Buffers|Cached):\s+(\d+)\s+(?:\S+)/
-                    size += $1.to_f
-                end
-            end
-            memsize = scale_number(size, scale)
+  def self.meminfo_number(tag)
+    memsize = ""
+    Thread::exclusive do
+      size, scale = [0, ""]
+      File.readlines("/proc/meminfo").each do |l|
+        size, scale = [$1.to_f, $2] if l =~ /^#{tag}:\s+(\d+)\s+(\S+)/
+        # MemoryFree == memfree + cached + buffers
+        #  (assume scales are all the same as memfree)
+        if tag == "MemFree" &&
+          l =~ /^(?:Buffers|Cached):\s+(\d+)\s+(?:\S+)/
+          size += $1.to_f
         end
-
-        memsize
+      end
+      memsize = scale_number(size, scale)
     end
 
-    def self.scale_number(size, multiplier)
-        suffixes = ['', 'kB', 'MB', 'GB', 'TB']
+    memsize
+  end
 
-        s = suffixes.shift
-        while s != multiplier
-            s = suffixes.shift
-        end
+  def self.scale_number(size, multiplier)
+    suffixes = ['', 'kB', 'MB', 'GB', 'TB']
 
-        while size > 1024.0
-            size /= 1024.0
-            s = suffixes.shift
-        end
+    s = suffixes.shift
+    while s != multiplier
+      s = suffixes.shift
+    end
 
-        return "%.2f %s" % [size, s]
+    while size > 1024.0
+      size /= 1024.0
+      s = suffixes.shift
     end
 
-    def self.vmstat_find_free_memory()
-        row = Facter::Util::Resolution.exec('vmstat').split("\n")[-1]
-        if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
-            Facter.add("MemoryFree") do
-                memfree = $1
-                setcode do
-                    Facter::Memory.scale_number(memfree.to_f, "kB")
-                end
-            end
+    return "%.2f %s" % [size, s]
+  end
+
+  def self.vmstat_find_free_memory()
+    row = Facter::Util::Resolution.exec('vmstat').split("\n")[-1]
+    if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
+      Facter.add("MemoryFree") do
+        memfree = $1
+        setcode do
+          Facter::Memory.scale_number(memfree.to_f, "kB")
         end
+      end
     end
+  end
 
-    # Darwin had to be different. It's generally opaque with how much RAM it is
-    # using, and this figure could be improved upon too I fear.
-    # Parses the output of "vm_stat", takes the pages free & pages speculative
-    # and multiples that by the page size (also given in output). Ties in with
-    # what activity monitor outputs for free memory.
-    def self.vmstat_darwin_find_free_memory()
+  # Darwin had to be different. It's generally opaque with how much RAM it is
+  # using, and this figure could be improved upon too I fear.
+  # Parses the output of "vm_stat", takes the pages free & pages speculative
+  # and multiples that by the page size (also given in output). Ties in with
+  # what activity monitor outputs for free memory.
+  def self.vmstat_darwin_find_free_memory()
 
-        memfree = 0
-        pagesize = 0
-        memspecfree = 0
+    memfree = 0
+    pagesize = 0
+    memspecfree = 0
 
-        vmstats = Facter::Util::Resolution.exec('vm_stat')
-        vmstats.each_line do |vmline|
-          case
-            when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
-              pagesize = $1.to_i
-            when vmline =~ /^Pages\sfree:\s+(\d+)\./
-              memfree = $1.to_i
-            when vmline =~ /^Pages\sspeculative:\s+(\d+)\./
-              memspecfree = $1.to_i
-          end
-        end
+    vmstats = Facter::Util::Resolution.exec('vm_stat')
+    vmstats.each_line do |vmline|
+      case
+      when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
+        pagesize = $1.to_i
+      when vmline =~ /^Pages\sfree:\s+(\d+)\./
+        memfree = $1.to_i
+      when vmline =~ /^Pages\sspeculative:\s+(\d+)\./
+        memspecfree = $1.to_i
+      end
+    end
 
-        freemem = ( memfree + memspecfree ) * pagesize
-        Facter.add("MemoryFree") do
-          setcode do
-            Facter::Memory.scale_number(freemem.to_f, "")
-          end
-        end
+    freemem = ( memfree + memspecfree ) * pagesize
+    Facter.add("MemoryFree") do
+      setcode do
+        Facter::Memory.scale_number(freemem.to_f, "")
+      end
     end
+  end
 end

data/lib/facter/util/netmask.rb

@@ -1,40 +1,40 @@
 module Facter::NetMask
-    def self.get_netmask
-        netmask = nil;
-        ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
+  def self.get_netmask
+    netmask = nil;
+    ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
 
-        ops = nil
-        case Facter.value(:kernel)
-        when 'Linux'
-            ops = {
-                :ifconfig => '/sbin/ifconfig',
-                :regex => %r{\s+ inet\saddr: #{Facter.ipaddress} .*? Mask: (#{ipregex})}x,
-                :munge => nil,
-            }
-        when 'SunOS'
-            ops = {
-                :ifconfig => '/usr/sbin/ifconfig -a',
-                :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s (\w{8})}x,
-                :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
-            }
-        when 'FreeBSD','NetBSD','OpenBSD', 'Darwin', 'GNU/kFreeBSD'
-            ops = {
-                :ifconfig => '/sbin/ifconfig -a',
-                :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s 0x(\w{8})}x,
-                :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
-            }
-        end
+    ops = nil
+    case Facter.value(:kernel)
+    when 'Linux'
+      ops = {
+        :ifconfig => '/sbin/ifconfig',
+        :regex => %r{\s+ inet\saddr: #{Facter.ipaddress} .*? Mask: (#{ipregex})}x,
+        :munge => nil,
+      }
+    when 'SunOS'
+      ops = {
+        :ifconfig => '/usr/sbin/ifconfig -a',
+        :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s (\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    when 'FreeBSD','NetBSD','OpenBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
+      ops = {
+        :ifconfig => '/sbin/ifconfig -a',
+        :regex => %r{\s+ inet \s #{Facter.ipaddress} \s netmask \s 0x(\w{8})}x,
+        :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+      }
+    end
 
-        %x{#{ops[:ifconfig]}}.split(/\n/).collect do |line|
-            matches = line.match(ops[:regex])
-            if !matches.nil?
-                if ops[:munge].nil?
-                    netmask = matches[1]
-                else
-                    netmask = ops[:munge].call(matches[1])
-                end
-            end
+    %x{#{ops[:ifconfig]}}.split(/\n/).collect do |line|
+      matches = line.match(ops[:regex])
+      if !matches.nil?
+        if ops[:munge].nil?
+          netmask = matches[1]
+        else
+          netmask = ops[:munge].call(matches[1])
         end
-        netmask
+      end
     end
+    netmask
+  end
 end

data/lib/facter/util/plist.rb

@@ -18,7 +18,7 @@ require 'facter/util/plist/generator'
 require 'facter/util/plist/parser'
 
 module Plist
-    VERSION = '3.0.0'
+  VERSION = '3.0.0'
 end
 
 # $Id: plist.rb 1781 2006-10-16 01:01:35Z luke $

data/lib/facter/util/plist/generator.rb

@@ -1,228 +1,228 @@
 #--###########################################################
-# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
-# Patrick May <patrick@hexane.org>                           #
-#                                                            #
-# Distributed under the MIT license.                         #
+# Copyright 2006, Ben Bleything <ben@bleything.net> and    #
+# Patrick May <patrick@hexane.org>               #
+#                              #
+# Distributed under the MIT license.             #
 ##############################################################
 #++
 # See Plist::Emit.
 module Plist
-    # === Create a plist
-    # You can dump an object to a plist in one of two ways:
+  # === Create a plist
+  # You can dump an object to a plist in one of two ways:
+  #
+  # * <tt>Plist::Emit.dump(obj)</tt>
+  # * <tt>obj.to_plist</tt>
+  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+  #
+  # The following Ruby classes are converted into native plist types:
+  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+  #
+  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+  module Emit
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+    def to_plist(envelope = true)
+      return Plist::Emit.dump(self, envelope)
+    end
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+    def save_plist(filename)
+      Plist::Emit.save_plist(self, filename)
+    end
+
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
     #
-    # * <tt>Plist::Emit.dump(obj)</tt>
-    # * <tt>obj.to_plist</tt>
-    #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
     #
-    # The following Ruby classes are converted into native plist types:
-    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
-    # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
-    # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
-    # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
     #
-    # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
-    module Emit
-        # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
-        def to_plist(envelope = true)
-            return Plist::Emit.dump(self, envelope)
-        end
-
-        # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
-        def save_plist(filename)
-            Plist::Emit.save_plist(self, filename)
-        end
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    def self.dump(obj, envelope = true)
+      output = plist_node(obj)
 
-        # The following Ruby classes are converted into native plist types:
-        #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
-        #
-        # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
-        #
-        # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
-        #
-        # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
-        def self.dump(obj, envelope = true)
-            output = plist_node(obj)
+      output = wrap(output) if envelope
 
-            output = wrap(output) if envelope
+      return output
+    end
 
-            return output
-        end
+    # Writes the serialized object's plist to the specified filename.
+    def self.save_plist(obj, filename)
+      File.open(filename, 'wb') do |f|
+        f.write(obj.to_plist)
+      end
+    end
 
-        # Writes the serialized object's plist to the specified filename.
-        def self.save_plist(obj, filename)
-            File.open(filename, 'wb') do |f|
-                f.write(obj.to_plist)
+    private
+    def self.plist_node(element)
+      output = ''
+
+      if element.respond_to? :to_plist_node
+        output << element.to_plist_node
+      else
+        case element
+        when Array
+          if element.empty?
+            output << "<array/>\n"
+          else
+            output << tag('array') {
+              element.collect {|e| plist_node(e)}
+            }
+          end
+        when Hash
+          if element.empty?
+            output << "<dict/>\n"
+          else
+            inner_tags = []
+
+            element.keys.sort.each do |k|
+              v = element[k]
+              inner_tags << tag('key', CGI::escapeHTML(k.to_s))
+              inner_tags << plist_node(v)
             end
+
+            output << tag('dict') {
+              inner_tags
+            }
+          end
+        when true, false
+          output << "<#{element}/>\n"
+        when Time
+          output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when Date # also catches DateTime
+          output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
+        when String, Symbol, Fixnum, Bignum, Integer, Float
+          output << tag(element_type(element), CGI::escapeHTML(element.to_s))
+        when IO, StringIO
+          element.rewind
+          contents = element.read
+          # note that apple plists are wrapped at a different length then
+          # what ruby's base64 wraps by default.
+          # I used #encode64 instead of #b64encode (which allows a length arg)
+          # because b64encode is b0rked and ignores the length arg.
+          data = "\n"
+          Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data)
+        else
+          output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
+          data = "\n"
+          Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
+          output << tag('data', data )
         end
+      end
 
-        private
-        def self.plist_node(element)
-            output = ''
-
-            if element.respond_to? :to_plist_node
-                output << element.to_plist_node
-            else
-                case element
-                when Array
-                    if element.empty?
-                        output << "<array/>\n"
-                    else
-                        output << tag('array') {
-                            element.collect {|e| plist_node(e)}
-                        }
-                    end
-                when Hash
-                    if element.empty?
-                        output << "<dict/>\n"
-                    else
-                        inner_tags = []
-
-                        element.keys.sort.each do |k|
-                            v = element[k]
-                            inner_tags << tag('key', CGI::escapeHTML(k.to_s))
-                            inner_tags << plist_node(v)
-                        end
-
-                        output << tag('dict') {
-                            inner_tags
-                        }
-                    end
-                when true, false
-                    output << "<#{element}/>\n"
-                when Time
-                    output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
-                when Date # also catches DateTime
-                    output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
-                when String, Symbol, Fixnum, Bignum, Integer, Float
-                    output << tag(element_type(element), CGI::escapeHTML(element.to_s))
-                when IO, StringIO
-                    element.rewind
-                    contents = element.read
-                    # note that apple plists are wrapped at a different length then
-                    # what ruby's base64 wraps by default.
-                    # I used #encode64 instead of #b64encode (which allows a length arg)
-                    # because b64encode is b0rked and ignores the length arg.
-                    data = "\n"
-                    Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
-                    output << tag('data', data)
-                else
-                    output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
-                    data = "\n"
-                    Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
-                    output << tag('data', data )
-                end
-            end
+      return output
+    end
 
-            return output
-        end
+    def self.comment(content)
+      return "<!-- #{content} -->\n"
+    end
 
-        def self.comment(content)
-            return "<!-- #{content} -->\n"
-        end
+    def self.tag(type, contents = '', &block)
+      out = nil
 
-        def self.tag(type, contents = '', &block)
-            out = nil
+      if block_given?
+        out = IndentedString.new
+        out << "<#{type}>"
+        out.raise_indent
 
-            if block_given?
-                out = IndentedString.new
-                out << "<#{type}>"
-                out.raise_indent
+        out << block.call
 
-                out << block.call
+        out.lower_indent
+        out << "</#{type}>"
+      else
+        out = "<#{type}>#{contents.to_s}</#{type}>\n"
+      end
 
-                out.lower_indent
-                out << "</#{type}>"
-            else
-                out = "<#{type}>#{contents.to_s}</#{type}>\n"
-            end
+      return out.to_s
+    end
 
-            return out.to_s
-        end
+    def self.wrap(contents)
+      output = ''
 
-        def self.wrap(contents)
-            output = ''
+      output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+      output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
+      output << '<plist version="1.0">' + "\n"
 
-            output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
-            output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
-            output << '<plist version="1.0">' + "\n"
+      output << contents
 
-            output << contents
+      output << '</plist>' + "\n"
 
-            output << '</plist>' + "\n"
+      return output
+    end
 
-            return output
-        end
+    def self.element_type(item)
+      return case item
+      when String, Symbol;      'string'
+      when Fixnum, Bignum, Integer; 'integer'
+      when Float;           'real'
+      else
+        raise "Don't know about this data type... something must be wrong!"
+      end
+    end
 
-        def self.element_type(item)
-            return case item
-                   when String, Symbol;          'string'
-                   when Fixnum, Bignum, Integer; 'integer'
-                   when Float;                   'real'
-                   else
-                       raise "Don't know about this data type... something must be wrong!"
-                   end
-        end
+    private
 
-        private
+    class IndentedString #:nodoc:
+      attr_accessor :indent_string
 
-        class IndentedString #:nodoc:
-            attr_accessor :indent_string
+      @@indent_level = 0
 
-            @@indent_level = 0
+      def initialize(str = "\t")
+        @indent_string = str
+        @contents = ''
+      end
 
-            def initialize(str = "\t")
-                @indent_string = str
-                @contents = ''
-            end
+      def to_s
+        return @contents
+      end
 
-            def to_s
-                return @contents
-            end
+      def raise_indent
+        @@indent_level += 1
+      end
 
-            def raise_indent
-                @@indent_level += 1
-            end
+      def lower_indent
+        @@indent_level -= 1 if @@indent_level > 0
+      end
 
-            def lower_indent
-                @@indent_level -= 1 if @@indent_level > 0
-            end
+      def <<(val)
+        if val.is_a? Array
+          val.each do |f|
+            self << f
+          end
+        else
+          # if it's already indented, don't bother indenting further
+          unless val =~ /\A#{@indent_string}/
+            indent = @indent_string * @@indent_level
 
-            def <<(val)
-                if val.is_a? Array
-                    val.each do |f|
-                        self << f
-                    end
-                else
-                    # if it's already indented, don't bother indenting further
-                    unless val =~ /\A#{@indent_string}/
-                        indent = @indent_string * @@indent_level
-
-                        @contents << val.gsub(/^/, indent)
-                    else
-                        @contents << val
-                    end
-
-                    # it already has a newline, don't add another
-                    @contents << "\n" unless val =~ /\n$/
-                end
-            end
+            @contents << val.gsub(/^/, indent)
+          else
+            @contents << val
+          end
+
+          # it already has a newline, don't add another
+          @contents << "\n" unless val =~ /\n$/
         end
+      end
     end
+  end
 end
 
 # we need to add this so sorting hash keys works properly
 class Symbol #:nodoc:
-    def <=> (other)
-        self.to_s <=> other.to_s
-    end
+  def <=> (other)
+    self.to_s <=> other.to_s
+  end
 end
 
 class Array #:nodoc:
-    include Plist::Emit
+  include Plist::Emit
 end
 
 class Hash #:nodoc:
-    include Plist::Emit
+  include Plist::Emit
 end
 
 # $Id: generator.rb 1781 2006-10-16 01:01:35Z luke $