solaris-patch 1.0.0 → 1.0.1

data/README.rdoc

@@ -9,32 +9,38 @@ Copyright:: Copyright (c) Martin Carpenter 2011
 The solaris-patch gem helps with the manipulation of SunOS and Solaris
 patches. 
 
- * Read (or write!) patchdiag.xref files.
- * Find latest version of a patch.
- * Find latest non-superseded version of a patch.
- * Download patchdiag.xref, patches, readmes from Oracle.
- * ...
+* Read (or write!) patchdiag.xref files.
+* Find latest version of a patch.
+* Find latest non-superseded version of a patch.
+* Download patchdiag.xref, patches, readmes from Oracle.
+* ...
 
 == Examples
 
 === Download a patch
 
     require 'solaris/patch'
-    Solaris::Patch.download_patch!('123456-78',
-                                   :to_file => '/tmp/123456-78.zip')
+    Solaris::Patch.download_patch!( '123456-78',
+                                    :to_file => '/tmp/123456-78.zip' )
 
 Alternatively:
 
     patch = Solaris::Patch.new( '123456-78' )
     patch.download_patch!( :to_dir => '/tmp' )
 
+=== Download a readme
+
+    require 'solaris/patch'
+    Solaris::Patch.download_readme!( '123456-78',
+                                     :to_file => '/tmp/123456-78.txt' )
+
 === Get the latest version of a patch
 
     require 'solaris/patch'
     Solaris::Patchdiag.open( '/tmp/patchdiag.xref' ).latest( '123456-01' )
     => "123456|12|..."
 
-=== Get the latest non-obsolete version of an possibly obsoleted patch
+=== Get the latest non-obsolete version of a possibly obsoleted patch
 
     require 'solaris/patch'
     Solaris::Patchdiag.open( '/tmp/patchdiag.xref' ).successor( '123456-01' )
@@ -48,11 +54,11 @@ Alternatively:
     patchdiag = Solaris::Patchdiag.new( '/tmp/patchdiag.xref' )
 
     # all sparc patches
-    patchdiag.all.select { |p| p.archs.include? 'sparc' }.inspect
+    patchdiag.select { |p| p.archs.include? 'sparc' }.inspect
     => [ "123456-78", ... ]
 
     # latest line added to patchdiag.xref
-    most_recent = patchdiag.all( :sort_by => :date, :order => ascending ).max
+    most_recent = patchdiag.sort_by( &:date ).last
     most_recent
     => "123456|78|..."
 
@@ -67,5 +73,5 @@ Alternatively:
 == Known issues
 
 Dates in patchdiag.xref are Mon/dd/yy format. This gem will break in
-2050 since it assumes year 50 and above is in the 20th Century.
+2050 since it assumes year 50 and above is in the 20th century.
 

data/lib/solaris/exception.rb

@@ -6,11 +6,6 @@ module Solaris
     # Superclass for all throwable exceptions.
     class Exception < ::Exception ; end
 
-    # Exception is raised by #find_successor when the patch whose
-    # successor is to be sought or the supposed successor to a patch
-    # does not exist in patchdiag.xref.
-    class NotFound < Exception ; end
-
     # Exception is raised when the terminal (non-obsolete) succesor
     # to a patch has been withdrawn (is bad).
     class BadSuccessor < Exception ; end
@@ -22,9 +17,18 @@ module Solaris
     # Raised if a patchdiag entry appears to have multiple successors.
     class MultipleSuccessors < Exception ; end
 
+    # Exception is raised by Patchdiag#successor when the patch whose
+    # successor is to be sought or the supposed successor to a patch
+    # does not exist in patchdiag.xref.
+    class NotFound < Exception ; end
+
     # Raised if one tries to determine the successor of a non-obsolete patch.
     class NotObsolete < Exception ; end
 
+    # Raised when seeking the successor to a patch in patchdiag.xref results
+    # in a loop.
+    class SuccessorLoop < Exception ; end
+
   end
 
 end # Solaris

data/lib/solaris/patchdiag.rb

@@ -12,24 +12,22 @@ module Solaris
     require 'solaris/patchdiag_entry'
     require 'solaris/util'
 
+    include Enumerable
+
     # Default patchdiag.xref file, as for Patch Check Advanced cache
     DEFAULT_XREF_FILE = '/var/tmp/patchdiag.xref'
 
     # URL of latest patchdiag.xref from Oracle.
     DEFAULT_XREF_URL = 'https://getupdates.oracle.com/reports/patchdiag.xref'
 
-    # An array containing all entries (of class PatchdiagEntry) read
-    # from the patchdiag.xref file.
-    attr_accessor :entries
-
     # Create a new patchdiag database object by reading the given
     # xref file (this may be a filename (string) or a fileish object
     # (File, StringIO)). If no xref file is given then the default
     # is read (/var/tmp/patchdiag.xref); this is the cache file used
     # by Patch Check Advanced (pca).
     def initialize(xref_file=DEFAULT_XREF_FILE)
-      xref_file = File.new( xref_file ) if xref_file.is_a?(String)
-      @entries = xref_file.
+      xref_file = File.new( xref_file ) if xref_file.is_a?( String )
+      @_entries = xref_file.
         readlines.
         reject { |line| line =~ /^#|^\s*$/ }. # discard comments, blanks
         map { |line| PatchdiagEntry.new( line ) }
@@ -44,8 +42,8 @@ module Solaris
       Util.download!( url, opts )
     end
 
-    # Open the given optional patchdiag xref file and yield to the optional
-    # block.
+    # Open the given optional patchdiag xref file and yield to the
+    # optional block.
     def Patchdiag.open(xref_file=DEFAULT_XREF_FILE, &blk)
       patchdiag = Patchdiag.new( xref_file )
       if block_given?
@@ -55,79 +53,113 @@ module Solaris
       end
     end
 
-    # Returns an array of Solaris::PatchdiagEntry from the patchdiag with the given
-    # patch number (a String like xxxxxx-yy or xxxxxx or a Solaris::Patch). Returns an
-    # empty array if no such patches can be found.
+    # Create and return a deep copy of this object.
+    def clone
+      Marshal.load( Marshal.dump( self ) )
+    end
+
+    # For Enumerator module: yields each Solaris::PatchdiagEntry in
+    # turn.
+    def each(&blk)
+      @_entries.each( &blk )
+    end
+
+    # Returns an array of Solaris::PatchdiagEntry from the
+    # patchdiag.xref with the given patch number (a String like
+    # xxxxxx-yy or xxxxxx or a Solaris::Patch), sorted by minor number.
+    # If both a major and minor number are supplied (xxxxxx-yy) then
+    # returned entries (normally only one) will match exactly. If only
+    # a major number (xxxxxx) is supplied then all entries with that
+    # major number are returned. Returns an empty array if no such
+    # patches can be found. This method overrides Enumerable#find.
     def find(patch)
       patch = Patch.new( patch.to_s )
       property = patch.minor ? :to_s : :major
       comparator = patch.send( property )
-      all.select { |pde| pde.patch.send( property ) == comparator }
+      entries.select { |pde| pde.patch.send( property ) == comparator }
     end
 
-    # Return the Solaris::PatchdiagEntry of the latest version of the given patch
-    # (a String like xxxxxx-yy or xxxxxx or a Solaris::Patch).
-    # Throws Solaris::Patch::NotFound if the patch cannot be found in patchdiag.xref.
+    # Strangely Enumerable module does not define Enumerable#last (although
+    # it does define Enumerable#first) so we define last here.
+    def last
+      entries.last
+    end
+
+    # Return the Solaris::PatchdiagEntry of the latest version of the
+    # given patch (a String like xxxxxx-yy or xxxxxx or a
+    # Solaris::Patch). Throws Solaris::Patch::NotFound if the patch
+    # cannot be found in patchdiag.xref.
     def latest(patch)
       major = Patch.new( patch.to_s ).major
       find( major ).max ||
-        raise( Solaris::Patch::NotFound, "Cannot find patch #{patch} in patchdiag.xref" )
+        raise( Solaris::Patch::NotFound,
+              "Cannot find patch #{patch} in patchdiag.xref" )
     end
 
-    # Return the Solaris::PatchdiagEntry of the latest non-obsolete successor
-    # of this patch. Throws Solaris::Patch::NotFound if the patch or any of its
-    # named successors cannot be found in patchdiag.xref.
-    def successor(patch)
-      patch = Patch.new( patch.to_s )
-      if ! patch.minor || ! entry = find( patch ).first
-        entry = latest( patch )
-      end
-      raise Solaris::Patch::NotFound,
-        "Cannot find patch #{patch} in patchdiag.xref" unless entry
-      if entry.obsolete?
-        succ = entry.successor # may raise
-        successor( succ )
-      elsif entry.bad?
-        raise BadSuccessor, "Terminal successor #{patch} is bad/withdrawn"
-      else
-        entry
-      end
+    # Returns a (deep) copy of +self+ with the entries sorted, takes an
+    # optional block. This method overrides Enumerable#sort. See also
+    # Solaris::Patchdiag#sort!.
+    def sort(&blk)
+      clone.sort!( &blk )
     end
 
-    # Return all patchdiag entries (PatchdiagEntry) defined in the patchdiag.xref.
-    # This method scans the entire patchdiag database so may be a little slow:
-    # callers are encouraged to cache or memoize their results.
-    def all(opts={})
-
-      # Defaults
-      order = :ascending
-      sort_by = :patch
-
-      # Parse options
-      opts.each do |key, value|
-        case key
-        when :sort_by
-          raise ArgumentError, "Invalid sort_by #{value.inspect}" unless [ :patch, :date ].include?( value )
-          sort_by = value
-        when :order
-          raise ArgumentError, "Invalid order #{value.inspect}" unless [ :ascending, :descending ].include?( value )
-          order = value
-        else
-          raise ArgumentError, "Unknown option key #{key.inspect}"
-        end
-      end
+    # Returns +self+ with the entries sorted in place, takes an optional
+    # block. See also Solaris::Patchdiag#sort.
+    def sort!(&blk)
+      # use @_entries since #entries returns a copy
+      @_entries.sort!( &blk )
+      self
+    end
 
-      # Compute the lambda for sorting.
-      if order == :ascending
-        boat_op = lambda { |x,y| x.send( sort_by ) <=> y.send( sort_by ) }
+    # Return an array of Solaris::Patch of the successors to the given
+    # patch terminating in the latest non-obsolete successor (where that
+    # exists).
+    #
+    # Throws Solaris::Patch::NotFound if the patch or any of its named
+    # successors cannot be found in patchdiag.xref, or if no later version
+    # of the patch exists.
+    #
+    # Throws Solaris::Patch::SuccessorLoop if the successor of a patch refers
+    # to a patch that has already been referenced (an ancestor).
+    #
+    # The ancestors parameter is a recursion accumulator and should not
+    # normally be assigned to by callers.
+    def successors(patch, ancestors=[])
+      patch = Patch.new( patch.to_s )
+      raise Solaris::Patch::SuccessorLoop,
+        "Loop detected for patch #{patch} with ancestors #{ancestors.inspect}" if ancestors.include?( patch )
+      ancestors << patch
+      if ! patch.minor # patch has no minor number
+        successors( latest( patch ).patch, ancestors )
+      elsif ! entry = find( patch ).last # explicit patch not found
+        latest_patch = latest( patch ).patch
+        raise Solaris::Patch::NotFound,
+          "Patch #{patch} not found and has no later version" if latest_patch.minor <= patch.minor
+        successors( latest_patch, ancestors )
       else
-        boat_op = lambda { |x,y| y.send( sort_by ) <=> x.send( sort_by ) }
+        if entry.obsolete?
+          succ = entry.successor
+          successors( succ, ancestors )
+        elsif entry.bad?
+          raise BadSuccessor, "Terminal successor #{patch} is bad/withdrawn"
+        else
+          ancestors
+        end
       end
+    end
 
-      # Sort and return.
-      @entries.sort { |x,y| boat_op.call( x, y ) }
+    # Return the Solaris::PatchdiagEntry of the latest non-obsolete successor
+    # of this patch. This is a convenience method for #successors.last.
+    def successor(patch)
+      latest( successors( patch ).last )
+    end
 
+    # Returns a string representation of the patchdiag.xref. All comments
+    # and blank lines are elided.
+    def to_s
+      entries.join("\n")
     end
+    alias to_str to_s
 
   end # Patchdiag
 

data/lib/solaris/patchdiag_entry.rb

@@ -18,7 +18,9 @@ module Solaris
     attr_accessor :archs
 
     # The bad field from the patchdiag xref database. Should be either 'B'
-    # or the empty string. See also PatchdiagEntry#bad?
+    # or the empty string. See also PatchdiagEntry#bad? (and
+    # PatchdiagEntry#y2k? since these flags share the same column in
+    # patchdiag.xref).
     attr_accessor :bad
 
     # The date of this patch (a Date object).
@@ -48,9 +50,15 @@ module Solaris
     # text field (string).
     attr_accessor :synopsis
 
+    # The year 2000 field from the patchdiag xref database. Should be either 'Y'
+    # or the empty string. See also PatchdiagEntry#y2k? (and
+    # PatchdiagEntry#bad? since these flags share the same column in
+    # patchdiag.xref).
+    attr_accessor :y2k
+
     def initialize(patchdiag_line)
-      fields = patchdiag_line.split('|')[0..10]
-      major, minor, date, @recommended, @security, @obsolete, @bad, @os, archs, pkgs, @synopsis = *fields
+      fields = patchdiag_line.split( '|', 11 )
+      major, minor, date, @recommended, @security, @obsolete, bad, @os, archs, pkgs, @synopsis = *fields
       @archs = archs.split( ';' )
       if date == ''
         year, month, day = 1970, 1, 1
@@ -60,9 +68,12 @@ module Solaris
         month = Date::ABBR_MONTHNAMES.index( month_s )
         day = day_s.to_i
       end
+      @bad = bad =~ /B/ ? 'B' : ' '
+      @y2k = bad =~ /Y/ ? 'Y' : ' '
       @date = Date.new( year, month, day )
       @patch = Patch.new( major, minor )
       @pkgs = pkgs.split( ';' )
+      @synopsis.chomp!
     end
 
     # Boolean, returns true if this patch is marked as "bad" in the patchdiag
@@ -123,10 +134,10 @@ module Solaris
       raise Solaris::Patch::NotObsolete,
         "Entry #{patch.inspect} not obsolete" unless obsolete?
 
-      # Fail on these two entries from 1999 since they are the only ones ever
-      # that are succeeded by two patches each
+      # Fail if this entry is obsoleted by two patches (currently 2011/05/04
+      # only 105716 and 105717)
       raise Solaris::Patch::MultipleSuccessors,
-        "More than one successor for entry #{patch.inspect}" if [ 105716, 105717 ].include?( self.major )
+        "More than one successor for entry #{patch.inspect}" if synopsis =~ /obsolete(d?) by\s*(:?)\s*(\d+(-\d+)?)\s+and\s+(\d+(-\d+)?)/i
 
       # See if we can find a successor
       if synopsis =~ /obsolete(d?) by\s*(:?)\s*(\d+(-\d+)?)/i
@@ -146,13 +157,18 @@ module Solaris
         @recommended,
         @security,
         @obsolete,
-        @bad,
+        @bad + @y2k,
         @os,
         join_semis( @archs ),
         join_semis( @pkgs ),
         @synopsis
       ].join('|')
     end
+    alias to_str to_s
+
+    # Boolean, returns true if this patch is marked as a year 2000 patch in the
+    # patchdiag xref database.
+    def y2k? ; @y2k == 'Y' end
 
     # Compare (by delegated comparison of patch versions, see Solaris::Patch#<=>).
     def <=>(other)
@@ -170,7 +186,7 @@ module Solaris
     end
 
     # Join an array of items with semicolons and append a trailing
-    # semicolon if the array is non-empty, otherwise return the 
+    # semicolon if the array is non-empty, otherwise return the
     # empty string. Used to format @archs and @pkgs for #to_s.
     def join_semis(a)
       a.empty? ? '' : a.join(';') + ';'

data/test/test_patchdiag.rb

@@ -8,7 +8,7 @@ class TestPatchdiag < Test::Unit::TestCase #:nodoc:
 
   def setup
     @empty_file = '/dev/null'
-    @patchdiag_fileish = StringIO.new(<<-EOF
+    @patchdiag_string = <<-EOF
 ## PATCHDIAG TOOL CROSS-REFERENCE FILE AS OF Feb/10/11 ##
 ##
 ## The content of this file has changed as of Jun/04/10. Due to the merging of
@@ -71,8 +71,14 @@ class TestPatchdiag < Test::Unit::TestCase #:nodoc:
 146444|01|Jan/27/11| | | |  |10_x86|i386;120012-14;142910-17;|SUNWnge:11.10.0,REV=2005.06.22.03.40;|SunOS 5.10_x86: nge patch
 800054|01|Mar/16/01| | |O|  |Unbundled|||Obsoleted by: 111346-01 Hardware/PROM: Sun Fire 3800/4800/4810/680
 100974|02|Mar/14/95| | | |  |Unbundled|sparc;|SPROsw:2.1.0;|SparcWorks 2.0.1: dbx jumbo patch
+654321|01|Jan/01/00| | |O|  |Unbundled|||Obsoleted by: 654321-02
+654321|02|Jan/01/00| | |O|  |Unbundled|||Obsoleted by: 654321-03
+654321|03|Jan/01/00| | |O|  |Unbundled|||Obsoleted by: 654321-01
+654322|01|Jan/01/00| | |O|  |Unbundled|||Obsoleted by: 654321-05
+115302|01|Jul/08/03| | |O| B|Unbundled|||WITHDRAWN PATCH Obsoleted by: 115302-02 Hardware/PROM: CP2060/CP20
 EOF
-                           )
+    @patchdiag_fileish = StringIO.new( @patchdiag_string )
+    @patchdiag_size = 56
     @patchdiag = Solaris::Patchdiag.open( @patchdiag_fileish )
   end
 
@@ -80,10 +86,12 @@ EOF
     @empty_file = nil
     @patchdiag = nil
     @patchdiag_fileish = nil
+    @patchdiag_string = nil
+    @patchdiag_size = nil
   end
 
   def test_new_by_fileish
-    assert_equal( 51, @patchdiag.entries.size )
+    assert_equal( @patchdiag_size, @patchdiag.entries.size )
   end
 
   def test_new_by_filename
@@ -93,7 +101,7 @@ EOF
     temp.close
     patchdiag = Solaris::Patchdiag.new( path )
     File.unlink( path )
-    assert_equal( 51, @patchdiag.entries.size )
+    assert_equal( @patchdiag_size, @patchdiag.entries.size )
   end
 
   def test_new_empty_file
@@ -103,24 +111,40 @@ EOF
     end
   end
 
-  def test_all
-    assert_equal( 51, @patchdiag.all.size )
+  def test_no_tailing_newline
+    s = StringIO.new('115302|01|Jul/08/03| | |O| B|Unbundled|||blah blah')
+    assert_equal( 1, Solaris::Patchdiag.new( s ).entries.size )
   end
 
-  def test_all_sort_by_date_order_ascending
-    all = @patchdiag.all( :sort_by => :date, :order => :ascending )
+  def test_clone
+    @cloned = @patchdiag.clone
+    assert_equal( @patchdiag.class, @cloned.class )
+    assert_equal( @patchdiag.entries.size, @cloned.entries.size )
+    assert_equal( @patchdiag.entries.first, @cloned.entries.first )
+    assert_not_equal( @patchdiag.object_id, @cloned.object_id )
+    @patchdiag.entries.zip( @cloned.entries ).each do |x,y|
+      assert_not_equal( x.object_id, y.object_id )
+    end
+  end
+
+  def test_entries
+    assert_equal( @patchdiag_size, @patchdiag.entries.size )
+  end
+
+  def test_sort_by_date_order_ascending
+    all = @patchdiag.sort_by( &:date )
     first = all.first.patch # oldest
     last = all.last.patch # newest
     assert_equal( Solaris::Patch.new( '100386-01' ), first )
     assert_equal( Solaris::Patch.new( '146443-01' ), last )
   end
 
-  def test_all_sort_by_patch_order_descending
-    all = @patchdiag.all( :sort_by => :patch, :order => :descending )
-    first = all.first.patch # largest
-    last = all.last.patch # smallest
-    assert_equal( Solaris::Patch.new( '800054-01' ), first )
-    assert_equal( Solaris::Patch.new( '100287-05' ), last )
+  def test_sort_by_patch_order_ascending
+    all = @patchdiag.sort
+    first = all.first.patch # smallest
+    last = all.last.patch # largest
+    assert_equal( Solaris::Patch.new( '800054-01' ), last )
+    assert_equal( Solaris::Patch.new( '100287-05' ), first )
   end
 
   def test_open_block
@@ -135,6 +159,34 @@ EOF
     assert_equal( Solaris::Patchdiag, @patchdiag.class )
   end
 
+  def test_bad
+    entry = @patchdiag.latest( '115302' )
+    assert_equal( true, entry.bad? )
+    entry = @patchdiag.latest( '654321-01' )
+    assert_equal( false, entry.bad? )
+  end
+
+  def test_recommended
+    entry = @patchdiag.latest( '146279-01' )
+    assert_equal( true, entry.recommended? )
+    entry = @patchdiag.latest( '654321-01' )
+    assert_equal( false, entry.recommended? )
+  end
+
+  def test_security
+    entry = @patchdiag.latest( '146279-01' )
+    assert_equal( true, entry.security? )
+    entry = @patchdiag.latest( '654321-01' )
+    assert_equal( false, entry.security? )
+  end
+
+  def test_obsolete
+    entry = @patchdiag.latest( '115302-01' )
+    assert_equal( true, entry.obsolete? )
+    entry = @patchdiag.latest( '100287-05' )
+    assert_equal( false, entry.obsolete? )
+  end
+
   def test_find
     assert_equal( [], @patchdiag.find( 123456 ) )
     assert_equal( [], @patchdiag.find( '123456' ) )
@@ -152,6 +204,10 @@ EOF
     assert_equal( '100791-04', @patchdiag.find( Solaris::Patch.new( '100791-04') ).first.patch.to_s )
   end
 
+  def test_last
+    assert_equal( '115302-01', @patchdiag.last.patch.to_s )
+  end
+
   def test_latest
     assert_raise( Solaris::Patch::NotFound ) do
       @patchdiag.latest( 123456 )
@@ -166,6 +222,24 @@ EOF
     assert_equal( '100791-05', @patchdiag.latest( Solaris::Patch.new( '100791-05' ) ).patch.to_s )
   end
 
+  def test_sort
+    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+    sorted = @patchdiag.sort
+    assert_equal( Solaris::Patchdiag, sorted.class )
+    assert_equal( '800054-01', sorted.entries.last.patch.to_s )
+    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+  end
+
+  def test_sort!
+    assert_equal( '115302-01', @patchdiag.entries.last.patch.to_s )
+    size = @patchdiag.entries.size
+    ret = @patchdiag.sort!
+    assert_equal( @patchdiag, ret )
+    assert_equal( size, @patchdiag.entries.size )
+    assert_equal( Solaris::Patchdiag, @patchdiag.class )
+    assert_equal( '800054-01', @patchdiag.entries.last.patch.to_s )
+  end
+
   def test_successor
     assert_raise( Solaris::Patch::NotFound ) do
       @patchdiag.latest( 123456 )
@@ -175,13 +249,33 @@ EOF
     assert_equal( '100287-05', @patchdiag.successor( '100287-05' ).patch.to_s )
     assert_equal( '100287-05', @patchdiag.successor( Solaris::Patch.new( '100287-05' ) ).patch.to_s )
     assert_equal( '100974-02', @patchdiag.successor( 100791 ).patch.to_s )
+    assert_raise( Solaris::Patch::NotFound ) do
+      @patchdiag.successor( 123456 )
+    end
     assert_raise( Solaris::Patch::NotFound ) do
       @patchdiag.successor( 100393 ) # successor 100394 not in patchdiag.xref
     end
+    assert_raise( Solaris::Patch::NotFound ) do
+      @patchdiag.successor( '654322-05' )
+    end
     assert_equal( '100807-04', @patchdiag.successor( '100807-01' ).patch.to_s )
     assert_raise( Solaris::Patch::InvalidSuccessor ) do
       @patchdiag.successor( '100807-03' ) # successor 100807-03 WITHDRAWN
     end
+    assert_raise( Solaris::Patch::SuccessorLoop ) do
+      @patchdiag.successor( 654321 )
+    end
+    assert_raise( Solaris::Patch::SuccessorLoop ) do
+      @patchdiag.successor( '654321-01' )
+    end
+    assert_raise( Solaris::Patch::NotFound ) do
+      @patchdiag.successor( 115302 )
+    end
+  end
+
+  def test_successors
+    assert_equal( %w{ 100791 100791-05 100974 100974-02 },
+                 @patchdiag.successors( 100791 ).map(&:to_s) )
   end
 
   def test_download!

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Martin Carpenter
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-03 00:00:00 +02:00
+date: 2011-05-30 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
         version: 1.0.0
   type: :runtime
   version_requirements: *id001
-description: Provides methods to deal with Solaris patchdiag.xref and patches, including parsing patchdiag.xref, downloads from Oracle (patch and readme), patch version comparison, and eg seeking the latest non-obsolete version of a patch
+description: Provides methods to deal with Solaris patchdiag.xref and patches, including parsing patchdiag.xref, downloads from Oracle (patch and readme), patch version comparison, and generic patchdiag.xref manipulations such as seeking the latest non-obsolete version of a patch
 email: mcarpenter@free.fr
 executables: []
 
@@ -45,7 +45,6 @@ extra_rdoc_files:
 files: 
 - lib/solaris/exception.rb
 - lib/solaris/patch.rb
-- lib/solaris/foo
 - lib/solaris/patchdiag_entry.rb
 - lib/solaris/util.rb
 - lib/solaris/patchdiag.rb

data/lib/solaris/foo

@@ -1,13 +0,0 @@
-#!/usr/bin/ruby
-
-require 'pp'
-
-def find(what=:all, opts={})
-  pp what
-  pp opts
-  puts
-end
-
-find
-find(:something, :foo=>:bar)
-find(:foo=>:bar)