solaris-contents 1.0.0

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright 2012 Martin Carpenter. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY Martin Carpenter ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Martin Carpenter OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the
+authors and should not be interpreted as representing official policies, either expressed
+or implied, of Martin Carpenter.
+

data/README.rdoc

@@ -0,0 +1,84 @@
+
+= solaris-contents
+
+Author:: Martin Carpenter
+Email:: mcarpenter@free.fr
+Copyright:: Copyright (c) Martin Carpenter 2011
+
+
+== About
+
+The solaris-contents gem helps with the manipulation of SunOS and Solaris
+contents entries for SysV packages. Note that the manual page contents(4)
+states that this interface is declared as unstable although practically
+speaking this is unlikely to be an issue.
+
+     As    shown    above,    the    interface    stability    of
+     /var/sadm/install/contents  is Unstable (see attributes(5)).
+     It is common practice to use this file in a read-only manner
+     to  determine which files belong to which packages installed
+     on a system. While this  file  has  been  present  for  many
+     releases  of  the  Solaris operating system, it might not be
+     present in future  releases.  The  fully  supported  way  to
+     obtain  information  from  the installed package database is
+     through pkgchk(1M). It is highly recommended  that  you  use
+     pkgchk rather than relying on the contents file.
+
+This prescient comment is coming true: Solaris 11 moves to a new packaging
+format (IPS) and although contents(4) remains on the system and in the
+manual pages it appears to be unused.
+
+This gem only handles "new style" contents entries. In extensive testing
+we have not seen any old style entries (these are lines that do not
+begin with a forward slash, /).
+
+See Errata below from where Oracle's specification in contents(4)
+differs from reality.
+
+== Examples
+
+=== Read and interpret contents(4)
+
+    require 'solaris/contents'
+
+    Solaris::Contents.read.each do |c|
+      puts c
+      puts c.ftype
+      puts c.path
+      puts c.rpath
+      puts c.install_path
+      puts c.packages.inspect
+    end
+      => /bin=./usr/bin s none SUNWcsr
+         s
+         /bin
+         /usr/bin
+	 none
+	 [ "SUNWcsr" ]
+         ...
+
+== Errata
+
+Testing against a corpus of ~150 contents files revealed the following
+discrepancies from the specification in the manual pages for contents(4)
+and pkgmap(4).
+
+=== Multiple packages per entry
+
+Multiple packages are only explicitly stated for ftype d in contents(4).
+Numerous counterexamples.
+
+=== Installation class name length
+
+pkgmap(4) states that the class name should be "no longer than 12 
+characters". Counterexample: "pkcs11confbase".
+
+=== Comments
+pkgadd(1M) writes comments to the tail of the contents file:
+
+    # Last modified by pkgadd for SMClintl package
+    # Tue Sep 20 21:57:16 2011
+
+If the Solaris::Contents#from_line constructor is fed a line like this
+(or a blank line) then it will return nil.
+

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rubygems/package_task'
+
+desc 'Default task (package)'
+task :default => [:package]
+
+Rake::TestTask.new( 'test' )
+
+SPECFILE = 'solaris-contents.gemspec'
+if File.exist?( SPECFILE )
+  spec = eval( File.read( SPECFILE ) )
+  Gem::PackageTask.new( spec ).define
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'solaris-contents'
+  rdoc.options << '--charset' << 'utf-8' << '--main' << 'README.rdoc'
+  rdoc.options << '--all'
+  rdoc.rdoc_files.include( 'README.rdoc' )
+  rdoc.rdoc_files.include( FileList[ 'lib/**/*' ] )
+  rdoc.rdoc_files.include( FileList[ 'test/**/*' ] )
+end
+

data/lib/solaris.rb

@@ -0,0 +1,8 @@
+
+# Namespace for child classes.
+module Solaris
+
+  require 'solaris/contents'
+
+end # Solaris
+

data/lib/solaris/contents.rb

@@ -0,0 +1,268 @@
+
+require 'etc'
+
+require 'solaris/contents/pkg'
+
+module Solaris
+
+  # Class to represent Solaris package file contents.
+  # A contents line contains information regarding file
+  # type, location, ownership, permisions.
+  #
+  # See Solaris' contents(4) man-page for information on
+  # attributes.
+  class Contents
+
+    # The file type of the contents entry: one of the symbols
+    # :b, :c, :d, :e, :f, :v, :x, :l, :s.
+    attr_accessor :ftype
+
+    # The installation class of the file.
+    attr_accessor :install_class
+
+    # The path of the file.
+    attr_accessor :path
+
+    # The relative path for a linked file.
+    attr_accessor :rpath
+
+    # The major mode (integer), for device files (ftype :b or :c).
+    attr_accessor :major
+
+    # The minor mode (integer), for device files (ftype :b or :c).
+    attr_accessor :minor
+
+    # The mode of the file, as an integer. This is usually presented
+    # as an octal number.
+    attr_accessor :mode
+
+    # The file user (string).
+    attr_accessor :owner
+
+    # The file's group (string).
+    attr_accessor :group
+
+    # The file modification time (seconds from the start of 1970).
+    attr_accessor :mtime
+
+    # Array of package names to which this file belongs.
+    attr_accessor :packages
+
+    # The size of the file in bytes.
+    attr_accessor :size
+
+    # The size of the file in bytes modulo 65535. (See Contents#sum).
+    attr_accessor :sum
+
+    # Install class to use if not specified.
+    DEFAULT_INSTALL_CLASS = 'none'
+
+    # Default system contents(4) path.
+    DEFAULT_CONTENTS_PATH = '/var/sadm/install/contents'
+
+    # Regular expression for filetype.
+    RE_FTYPE = '([bcdefvxls])'
+
+    # Regular expression for install class.
+    # Solaris documentation states that this parameter is at most 12 characters
+    # but there are counterexamples in the wild from Sun/Oracle's own hand
+    # (eg class "pkcs11confbase").
+    RE_INSTALL_CLASS = '(\w+)'
+
+    # Regular expression for path.
+    RE_PATH = '(\S+)'
+
+    # Regular expression for major device mode.
+    RE_MAJOR = '(\d+)'
+
+    # Regular expression for minor device mode.
+    RE_MINOR = '(\d+)'
+
+    # Regular expression for octal file mode.
+    RE_MODE = '([0-7]{4})'
+
+    # Regular expression for file modification time.
+    RE_MTIME = '(\d+)'
+
+    # Regular expression for user name.
+    RE_OWNER = '(\S+)'
+
+    # Regular expression for group name.
+    RE_GROUP = '(\S+)'
+
+    # Regular expression for a package.
+    RE_PACKAGE = '(\S+)'
+
+    # Regular expression for file size.
+    RE_SIZE = '(\d+)'
+
+    # Regular expression for file sum.
+    RE_SUM = '(\d+)'
+
+    # Create a Contents object from a line from a contents(4) file. If line
+    # is empty or a comment (starts with a hash character) then return nil.
+    def self.from_line(line)
+      return nil if line.empty? || line =~ /^#/
+      ftype = $2.to_sym if line =~ /^#{RE_PATH} #{RE_FTYPE} /
+      re = case ftype
+           when :s, :l
+             /^#{RE_PATH}=#{RE_PATH} #{ftype} #{RE_INSTALL_CLASS} (#{RE_PACKAGE}( #{RE_PACKAGE})*)$/
+           when :d
+             /^#{RE_PATH} #{ftype} #{RE_INSTALL_CLASS} #{RE_MODE} #{RE_OWNER} #{RE_GROUP} (#{RE_PACKAGE}( #{RE_PACKAGE})*)$/
+           when :x
+             /^#{RE_PATH} #{ftype} #{RE_INSTALL_CLASS} #{RE_MODE} #{RE_OWNER} #{RE_GROUP} #{RE_PACKAGE}$/
+           when :b, :c
+             /^#{RE_PATH} #{ftype} #{RE_INSTALL_CLASS} #{RE_MAJOR} #{RE_MINOR} #{RE_MODE} #{RE_OWNER} #{RE_GROUP} #{RE_PACKAGE}$/
+           when :f, :v, :e
+             /^#{RE_PATH} #{ftype} #{RE_INSTALL_CLASS} #{RE_MODE} #{RE_OWNER} #{RE_GROUP} #{RE_SIZE} #{RE_SUM} #{RE_MTIME} (#{RE_PACKAGE}( #{RE_PACKAGE})*)$/
+           else
+             raise ArgumentError, "Unknown filetype in line #{line.inspect}"
+           end
+      if line =~ re
+        contents = self.new
+        contents.ftype = ftype
+        contents.path = $1
+        case ftype
+        when :s, :l
+          contents.rpath = $2
+          contents.install_class = $3
+          contents.packages = $4.split( /\s+/ ).map { |pkg| Pkg.new(pkg) }
+        when :d, :x
+          contents.install_class = $2
+          contents.mode = $3.to_i( 8 )
+          contents.owner = $4
+          contents.group = $5
+          contents.packages = $6.split( /\s+/ ).map { |pkg| Pkg.new(pkg) }
+        when :b, :c
+          contents.install_class = $2
+          contents.major = $3.to_i
+          contents.minor = $4.to_i
+          contents.mode = $5.to_i( 8 )
+          contents.owner = $6
+          contents.group = $7
+          contents.packages = $8.split( /\s+/ ).map { |pkg| Pkg.new(pkg) }
+        when :f, :v, :e
+          contents.install_class = $2
+          contents.mode = $3.to_i( 8 )
+          contents.owner = $4
+          contents.group =$5
+          contents.size = $6.to_i
+          contents.sum = $7.to_i
+          contents.mtime = $8.to_i
+          contents.packages = $9.split( /\s+/ ).map { |pkg| Pkg.new(pkg) }
+        end
+      else
+        raise ArgumentError, "Could not parse line #{line.inspect}"
+      end
+      contents
+    end
+
+    # Create a Contents entry from the file at the +path+ on the local
+    # filesystem.
+    #
+    # If +actual+ is provided then this is the path that is used for the
+    # object's pathname property although all other properties are
+    # created from the +path+ argument. The process must be able to
+    # stat(2) the file at +path+ to determine these properties.
+    def self.from_path(path, actual=nil)
+      contents = self.new
+      # Use #lstat since we are always interested in the link source,
+      # not the target.
+      stat = File.lstat( path )
+      raise RuntimeError, 'Unknown file type' if stat.ftype == 'unknown'
+      # Stat returns "link" for symlink, not "symlink"
+      contents.ftype = stat.symlink? ? :s : stat.ftype[0].to_sym
+      case contents.ftype
+      when :f
+        contents.sum = sum( path )
+        contents.size = stat.size
+        contents.mtime = stat.mtime.to_i
+      when :s
+        contents.rpath = File.realpath( path )
+      when :b, :c
+        contents.major = stat.dev_major
+        contents.minor = stat.dev_minor
+      when :d
+        #
+      else
+        raise RuntimeError, "Unknown ftype #{contents.ftype.inspect}"
+      end
+      contents.path = actual || path
+      contents.install_class = DEFAULT_INSTALL_CLASS
+      contents.mode = stat.mode & 07777
+      contents.owner = Etc.getpwuid( stat.uid ).name
+      contents.group = Etc.getgrgid( stat.gid ).name
+      contents
+    end
+
+    # Read a contents(4) file (default /var/sadm/install/contents)
+    # and return an array of package contents entries.
+    def self.read(path=DEFAULT_CONTENTS_PATH)
+      File.open( path ).lines.map do |line|
+        from_line( line )
+      end.compact
+    end
+
+    # Return the sum of the byte values of the file, modulo 65535. This is 
+    # the value returned by Solaris' sum(1) (NB. not cksum(1) or sum(1B)).
+    # This is a weak checksum and should not be used for security purposes.
+    def self.sum(io_or_string)
+      io_or_string.each_byte.inject { |r, v| ( r + v ) & 0xffff }
+    end
+
+    # Create a new contents(4) object.
+    def initialize
+      @packages = []
+    end
+
+    # Return nil if no package has been specified for this contents entry.
+    # If only one package has been specified for this contents entry
+    # (all cases except, possibly, directory) then return that package.
+    # Otherwise throw a RuntimeError.
+    def package
+      raise RuntimeError, 'Ambiguous: contains more than one package' if @packages.size > 1
+      @packages[0]
+    end
+
+    # Convert the object to a contents(4) line (string).
+    def to_s
+      case @ftype
+      when :b, :c
+        [ @path, @ftype, @install_class, @major, @minor, mode_s, @owner, @group ] + @packages
+      when :d
+        [ @path, @ftype, @install_class, mode_s, @owner, @group ] + @packages
+      when :x
+        [ @path, @ftype, @install_class, mode_s, @owner, @group ] + @packages
+      when :e, :f, :v
+        [ @path, @ftype, @install_class, mode_s, @owner, @group, @size, @sum, @mtime ] + @packages
+      when :l, :s
+        [ "#{@path}=#{@rpath}", @ftype, @install_class ] + @packages
+      else
+        raise RuntimeError, "Unknown ftype #{@ftype.inspect}"
+      end.join( ' ' )
+    end
+
+    # Returns true if the object is a valid contents specification, false
+    # otherwise.
+    def valid?
+      begin
+        self.class.from_line( to_s )
+      rescue ArgumentError, RuntimeError
+        false
+      else
+        true
+      end
+
+    end
+
+    private
+
+    # Convert the file mode to a 4-digit octal string.
+    def mode_s
+      '%04o' % @mode
+    end
+
+  end # Contents
+
+end # Solaris
+

data/lib/solaris/contents/pkg.rb

@@ -0,0 +1,71 @@
+
+module Solaris
+
+  class Contents
+
+    # Class to represent a package in the contents(4) file. Package
+    # names may be prefixed with a single character (and passed to
+    # the constructor). The semantics of that single character are
+    # not publicly supported but are described in
+    # usr/src/cmd/svr4pkg/hdrs/libinst.h:
+    #    #define INST_RDY    '+' /* entry is ready to installf -f */
+    #    #define RM_RDY      '-' /* entry is ready for removef -f */
+    #    #define NOT_FND     '!' /* entry (or part of entry) was not found */
+    #    #define SERVED_FILE '%' /* using the file server's RO partition */
+    #    #define STAT_NEXT   '@' /* this is awaiting eptstat */
+    #    #define DUP_ENTRY   '#' /* there's a duplicate of this */
+    #    #define CONFIRM_CONT    '*' /* need to confirm contents */
+    #    #define CONFIRM_ATTR    '~' /* need to confirm attributes */
+    #    #define ENTRY_OK    '\0'    /* entry is a confirmed file */
+    class Pkg
+
+      # The name of this package, without status indicator.
+      attr_accessor :name
+
+      # The status if this package as a symbol (see STATUS_BY_SYM).
+      attr_accessor :status
+
+      # Hash to map status symbols to their string representation.
+      STATUS_BY_SYM = {
+        :inst_rdy => '+',
+        :rm_rdy => '-',
+        :not_fnd => '!',
+        :served_file => '%',
+        :stat_next => '@',
+        :dup_entry => '#',
+        :confirm_cont => '*',
+        :confirm_attr => '~',
+        :entry_ok => ''
+      }
+
+      # Hash to map status strings to their symbolic representation.
+      STATUS_BY_STR = STATUS_BY_SYM.invert
+
+      def initialize(pkg)
+        # Use #chr for ruby 1.8 compatibility
+        status_char = pkg[0].chr
+        if STATUS_BY_STR.keys.include?(status_char)
+          @name = pkg[1..-1]
+          @status = STATUS_BY_STR[status_char]
+        else
+          @name = pkg
+          @status = :entry_ok
+        end
+      end
+
+      def to_s
+        STATUS_BY_SYM[@status] + @name
+      end
+
+      STATUS_BY_SYM.keys.each do |key|
+        define_method("#{key}?") do
+          @status == key
+        end
+      end
+
+    end # Pkg
+
+  end # Contents
+
+end # Solaris
+

data/test/test_contents.rb

@@ -0,0 +1,205 @@
+
+require 'stringio'
+require 'test/unit'
+
+require 'solaris/contents'
+
+# Unit tests for Solaris::Contents.
+class TestContents < Test::Unit::TestCase #:nodoc:
+
+  def test_sum_from_string
+    assert_equal( 64, Solaris::Contents.sum( '@' ) )
+    assert_equal( 128, Solaris::Contents.sum( '@@' ) )
+    assert_equal( 64_000, Solaris::Contents.sum( '@' * 1_000 ) )
+    assert_equal( 65_472, Solaris::Contents.sum( '@' * 1_023 ) )
+    assert_equal( 0, Solaris::Contents.sum( '@' * 1_024 ) )
+    assert_equal( 64, Solaris::Contents.sum( '@' * 1_025 ) )
+  end
+
+  def test_sum_from_io
+    assert_equal( 97, Solaris::Contents.sum( StringIO.new( 'a' ) ) )
+    assert_equal( 194, Solaris::Contents.sum( StringIO.new( 'aa' ) ) )
+  end
+
+  def test_block_device
+    skip 'No block device example found'
+  end
+
+  def test_character_device
+    line = '/devices/pseudo/arp@0:arp c none 44 0 0666 root sys SUNWcsd'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :c, contents.ftype )
+    assert_equal( '/devices/pseudo/arp@0:arp', contents.path )
+    assert_equal( nil, contents.rpath )
+    assert_equal( 'none', contents.install_class )
+    assert_equal( 438, contents.mode )
+    assert_equal( 44, contents.major )
+    assert_equal( 0, contents.minor )
+    assert_equal( nil, contents.mtime )
+    assert_equal( 'root', contents.owner )
+    assert_equal( 'sys', contents.group )
+    assert_equal( 'SUNWcsd', contents.package.to_s )
+    assert_equal( %w{ SUNWcsd }, contents.packages.map(&:to_s) )
+    assert_equal( nil, contents.size )
+    assert_equal( nil, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_directory
+    line = '/dev d none 0755 root sys SUNWcsr SUNWcsd'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :d, contents.ftype )
+    assert_equal( '/dev', contents.path )
+    assert_equal( nil, contents.rpath )
+    assert_equal( 'none', contents.install_class )
+    assert_equal( 493, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( nil, contents.mtime )
+    assert_equal( 'root', contents.owner )
+    assert_equal( 'sys', contents.group )
+    assert_raise RuntimeError do
+      contents.package
+    end
+    assert_equal( %w{ SUNWcsr SUNWcsd }, contents.packages.map(&:to_s) )
+    assert_equal( nil, contents.size )
+    assert_equal( nil, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_editable
+    line = '/etc/passwd e passwd 0644 root sys 580 48299 1077177419 SUNWcsr'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :e, contents.ftype )
+    assert_equal( '/etc/passwd', contents.path )
+    assert_equal( nil, contents.rpath )
+    assert_equal( 'passwd', contents.install_class )
+    assert_equal( 420, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( 1077177419, contents.mtime )
+    assert_equal( 'root', contents.owner )
+    assert_equal( 'sys', contents.group )
+    assert_equal( %w{ SUNWcsr }, contents.packages.map(&:to_s) )
+    assert_equal( 'SUNWcsr', contents.package.to_s )
+    assert_equal( 580, contents.size )
+    assert_equal( 48299, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_file
+    line = '/boot/grub/bin/grub f none 0555 root sys 378124 54144 1281112186 SUNWgrub'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :f, contents.ftype )
+    assert_equal( '/boot/grub/bin/grub', contents.path )
+    assert_equal( nil, contents.rpath )
+    assert_equal( 'none', contents.install_class )
+    assert_equal( 365, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( 1281112186, contents.mtime )
+    assert_equal( 'root', contents.owner )
+    assert_equal( 'sys', contents.group )
+    assert_equal( %w{ SUNWgrub }, contents.packages.map(&:to_s) )
+    assert_equal( 'SUNWgrub', contents.package.to_s )
+    assert_equal( 378124, contents.size )
+    assert_equal( 54144, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_link
+    line = '/etc/crypto/certs/SUNWObjectCA=../../../etc/certs/SUNWObjectCA l none SUNWcsr'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :l, contents.ftype )
+    assert_equal( '/etc/crypto/certs/SUNWObjectCA', contents.path )
+    assert_equal( '../../../etc/certs/SUNWObjectCA', contents.rpath )
+    assert_equal( 'none', contents.install_class )
+    assert_equal( nil, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( nil, contents.mtime )
+    assert_equal( nil, contents.owner )
+    assert_equal( nil, contents.group )
+    assert_equal( 'SUNWcsr', contents.package.to_s )
+    assert_equal( %w{ SUNWcsr }, contents.packages.map(&:to_s) )
+    assert_equal( nil, contents.size )
+    assert_equal( nil, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_symlink
+    line = '/bin=./usr/bin s none SUNWcsr'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :s, contents.ftype )
+    assert_equal( '/bin', contents.path )
+    assert_equal( './usr/bin', contents.rpath )
+    assert_equal( 'none', contents.install_class )
+    assert_equal( nil, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( nil, contents.mtime )
+    assert_equal( nil, contents.owner )
+    assert_equal( nil, contents.group )
+    assert_equal( %w{ SUNWcsr }, contents.packages.map(&:to_s) )
+    assert_equal( nil, contents.size )
+    assert_equal( nil, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_volatile
+    line = '/boot/x86.miniroot-safe v failsafe 0644 root sys 65 5585 1279140915 SUNWcsd'
+    contents = Solaris::Contents.from_line( line )
+    assert_equal( :v, contents.ftype )
+    assert_equal( '/boot/x86.miniroot-safe', contents.path )
+    assert_equal( nil, contents.rpath )
+    assert_equal( 'failsafe', contents.install_class )
+    assert_equal( 420, contents.mode )
+    assert_equal( nil, contents.major )
+    assert_equal( nil, contents.minor )
+    assert_equal( 1279140915, contents.mtime )
+    assert_equal( 'root', contents.owner )
+    assert_equal( 'sys', contents.group )
+    assert_equal( 'SUNWcsd', contents.package.to_s )
+    assert_equal( %w{ SUNWcsd }, contents.packages.map(&:to_s) )
+    assert_equal( 65, contents.size )
+    assert_equal( 5585, contents.sum )
+    assert_equal( line, contents.to_s )
+    assert( contents.valid? )
+  end
+
+  def test_exclusive
+    skip 'No exclusive example found'
+  end
+
+  def test_unknown_ftype
+    line = '/boot/grub/bin/grub Z none 0555 root sys 378124 54144 1281112186 SUNWgrub'
+    assert_raise ArgumentError do
+      Solaris::Contents.from_line( line )
+    end
+  end
+
+  def test_unparseable_line
+    line = '/boot/grub/bin/grub f nonsense'
+    assert_raise ArgumentError do
+      Solaris::Contents.from_line( line )
+    end
+  end
+
+  def test_valid
+    line = '/boot/grub/bin/grub f none 0555 root sys 378124 54144 1281112186 SUNWgrub'
+    proto = Solaris::Contents.from_line( line )
+    assert( proto.valid? )
+    proto.ftype = :invalid
+    assert( ! proto.valid? )
+    proto.ftype = :f
+    assert( proto.valid? )
+  end
+
+end
+

data/test/test_pkg.rb

@@ -0,0 +1,82 @@
+
+require 'test/unit'
+
+require 'solaris/contents'
+
+# Unit tests for Solaris::Contents::Pkg.
+class TestPkg < Test::Unit::TestCase #:nodoc:
+
+  def test_inst_rdy
+    pkg = Solaris::Contents::Pkg.new( '+mypackage' )
+    assert_equal( :inst_rdy, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '+mypackage', pkg.to_s )
+    assert( pkg.inst_rdy? )
+  end
+
+  def test_rm_rdy
+    pkg = Solaris::Contents::Pkg.new( '-mypackage' )
+    assert_equal( :rm_rdy, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '-mypackage', pkg.to_s )
+    assert( pkg.rm_rdy? )
+  end
+
+  def test_not_fnd
+    pkg = Solaris::Contents::Pkg.new( '!mypackage' )
+    assert_equal( :not_fnd, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '!mypackage', pkg.to_s )
+    assert( pkg.not_fnd? )
+  end
+
+  def test_served_file
+    pkg = Solaris::Contents::Pkg.new( '%mypackage' )
+    assert_equal( :served_file, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '%mypackage', pkg.to_s )
+    assert( pkg.served_file? )
+  end
+
+  def test_stat_next
+    pkg = Solaris::Contents::Pkg.new( '@mypackage' )
+    assert_equal( :stat_next, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '@mypackage', pkg.to_s )
+    assert( pkg.stat_next? )
+  end
+
+  def test_dup_entry
+    pkg = Solaris::Contents::Pkg.new( '#mypackage' )
+    assert_equal( :dup_entry, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '#mypackage', pkg.to_s )
+    assert( pkg.dup_entry? )
+  end
+
+  def test_confirm_cont
+    pkg = Solaris::Contents::Pkg.new( '*mypackage' )
+    assert_equal( :confirm_cont, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '*mypackage', pkg.to_s )
+    assert( pkg.confirm_cont? )
+  end
+
+  def test_confirm_attr
+    pkg = Solaris::Contents::Pkg.new( '~mypackage' )
+    assert_equal( :confirm_attr, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( '~mypackage', pkg.to_s )
+    assert( pkg.confirm_attr? )
+  end
+
+  def test_entry_ok
+    pkg = Solaris::Contents::Pkg.new( 'mypackage' )
+    assert_equal( :entry_ok, pkg.status )
+    assert_equal( 'mypackage', pkg.name )
+    assert_equal( 'mypackage', pkg.to_s )
+    assert( pkg.entry_ok? )
+  end
+
+end
+

data/test/test_solaris.rb

@@ -0,0 +1,22 @@
+
+require 'test/unit'
+
+require 'solaris'
+
+# Unit tests for top level require.
+class TestSolaris < Test::Unit::TestCase #:nodoc:
+
+  def test_solaris
+    assert_nothing_raised { Solaris }
+  end
+
+  def test_solaris_contents
+    assert_nothing_raised { Solaris::Contents }
+  end
+
+  def test_solaris_contents
+    assert_nothing_raised { Solaris::Contents::Pkg }
+  end
+
+end
+

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: solaris-contents
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Martin Carpenter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-15 00:00:00.000000000 Z
+dependencies: []
+description: Parse and write Solaris package contents records
+email: mcarpenter@free.fr
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- Rakefile
+- README.rdoc
+files:
+- lib/solaris/contents.rb
+- lib/solaris/contents/pkg.rb
+- lib/solaris.rb
+- test/test_pkg.rb
+- test/test_contents.rb
+- test/test_solaris.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+homepage: http://mcarpenter.org/projects/solaris-contents
+licenses:
+- BSD
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Parse and write Solaris package contents records
+test_files:
+- test/test_pkg.rb
+- test/test_contents.rb
+- test/test_solaris.rb