logrotate 1.1.0 → 1.2.0

data/History.txt

@@ -1,3 +1,6 @@
+=== 1.2.0 / 2009-10-21
+* Included the rotation of directories.
+
 === 1.1.0 / 2008-08-20
 * Enhanced the rotate file methods to return status information
   regarding the rotation: the newly rotated file, the list of rotated

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Designing Patterns
+Copyright (c) 2008-2009 Designing Patterns
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Manifest.txt

@@ -1,6 +1,6 @@
-Manifest.txt
-LICENSE
 History.txt
+LICENSE
+Manifest.txt
 README.txt
 Rakefile
 lib/logrotate.rb

data/README.txt

@@ -2,8 +2,8 @@ Object
 
 == DESCRIPTION:
 
-This package is a library of methods that perform log rotation.  The
-log rotate methods allow the caller to specify options (via
+This package is a library of methods that perform log rotation on files and 
+directories.  The log rotate methods allow the caller to specify options (via
 parameters) such as how many rotated files to keep, what type of
 extension to place on the rotated file (date or a simple count), and
 whether to zip the rotated files.  Live log files (currently being
@@ -15,6 +15,10 @@ This package was inspired by the need to have a library version of the
 unix logrotate tool.  The unix logrotate tool requires the user to
 specify options in a config file, and is usually invoked through cron.
 
+Directories can be rotated with this library.  However, the gzip option
+does not work with directories.  In this case, please zip/tar the directory
+in question before invoking this library.
+
 == PROBLEMS:
 
 None (known).
@@ -22,75 +26,6 @@ None (known).
 == SYNOPSIS:
 Here are some sample invocations of the library.
 
-Rotate a log file with simple extensions: .1, .2, etc, keep 3 rotated
-files around (.1 .. .3), and gzip the rotated files (.1.gz, .. .3.gz): 
-======<tt>examples/rotate_count.rb</tt>:
- #!/usr/bin/env ruby
- 
- require 'fileutils'
- require 'rubygems'
- require 'logrotate'
- 
- options = {
-   :count => 2,
-   :gzip => true
- }
- 
- 1.upto(3) do |iteration|
-   
-   FileUtils.touch("/tmp/erwin.dat")
-   result = LogRotate.rotate_file("/tmp/erwin.dat", options)
-   
-   print "=================================================\n"
-   print "Iteration \##{iteration}\n"
-   print "=================================================\n"
-   print result, "\n"
- end
- 
- # clean up all files created by this example
- FileUtils.rm_f(Dir.glob('/tmp/erwin.dat.*'))
-
-======<tt>Output</tt>:
- =================================================
- Iteration #1
- =================================================
- Rotated Files And Counts:
-    file -> /tmp/erwin.dat.1.gz, index -> 1
- Rotated Files: 
-    /tmp/erwin.dat.1.gz
- Deleted Files:
- New Rotated File: 
-    /tmp/erwin.dat.1.gz
- 
- =================================================
- Iteration #2
- =================================================
- Rotated Files And Counts:
-    file -> /tmp/erwin.dat.1.gz, index -> 1
-    file -> /tmp/erwin.dat.2.gz, index -> 2
- Rotated Files: 
-    /tmp/erwin.dat.1.gz
-    /tmp/erwin.dat.2.gz
- Deleted Files:
- New Rotated File: 
-    /tmp/erwin.dat.1.gz
- 
- =================================================
- Iteration #3
- =================================================
- Rotated Files And Counts:
-    file -> /tmp/erwin.dat.1.gz, index -> 1
-    file -> /tmp/erwin.dat.2.gz, index -> 2
- Rotated Files: 
-    /tmp/erwin.dat.1.gz
-    /tmp/erwin.dat.2.gz
- Deleted Files:
-    /tmp/erwin.dat.2.gz
- New Rotated File: 
-    /tmp/erwin.dat.1.gz
- 
-
-
 Rotate a log file with date/time extensions.
 ======<tt>examples/rotate_date_time.rb</tt>:
  #!/usr/bin/env/ruby
@@ -199,6 +134,75 @@ files to a specified directory:
  FileUtils.rm_rf("/tmp/archives")
 
 
+Rotate a log file with simple extensions: .1, .2, etc, keep 3 rotated
+files around (.1 .. .3), and gzip the rotated files (.1.gz, .. .3.gz): 
+======<tt>examples/rotate_count.rb</tt>:
+ #!/usr/bin/env ruby
+ 
+ require 'fileutils'
+ require 'rubygems'
+ require 'logrotate'
+ 
+ options = {
+   :count => 2,
+   :gzip => true
+ }
+ 
+ 1.upto(3) do |iteration|
+   
+   FileUtils.touch("/tmp/erwin.dat")
+   result = LogRotate.rotate_file("/tmp/erwin.dat", options)
+   
+   print "=================================================\n"
+   print "Iteration \##{iteration}\n"
+   print "=================================================\n"
+   print result, "\n"
+ end
+ 
+ # clean up all files created by this example
+ FileUtils.rm_f(Dir.glob('/tmp/erwin.dat.*'))
+
+======<tt>Output</tt>:
+ =================================================
+ Iteration #1
+ =================================================
+ Rotated Files And Counts:
+    file -> /tmp/erwin.dat.1.gz, index -> 1
+ Rotated Files: 
+    /tmp/erwin.dat.1.gz
+ Deleted Files:
+ New Rotated File: 
+    /tmp/erwin.dat.1.gz
+ 
+ =================================================
+ Iteration #2
+ =================================================
+ Rotated Files And Counts:
+    file -> /tmp/erwin.dat.1.gz, index -> 1
+    file -> /tmp/erwin.dat.2.gz, index -> 2
+ Rotated Files: 
+    /tmp/erwin.dat.1.gz
+    /tmp/erwin.dat.2.gz
+ Deleted Files:
+ New Rotated File: 
+    /tmp/erwin.dat.1.gz
+ 
+ =================================================
+ Iteration #3
+ =================================================
+ Rotated Files And Counts:
+    file -> /tmp/erwin.dat.1.gz, index -> 1
+    file -> /tmp/erwin.dat.2.gz, index -> 2
+ Rotated Files: 
+    /tmp/erwin.dat.1.gz
+    /tmp/erwin.dat.2.gz
+ Deleted Files:
+    /tmp/erwin.dat.2.gz
+ New Rotated File: 
+    /tmp/erwin.dat.1.gz
+ 
+
+
 Rotate a log file that is currently being written to by a live
 process.  After the file is rotated, notify the live process to reopen
 its log file.  
@@ -230,7 +234,8 @@ its log file.
 
 == REQUIREMENTS:
 
-Hoe is required but only for running the tests.
+* Hoe is required but only for running the tests.
+* The unix command line tool tar is required if directories are to be rotated and zipped.
 
 == INSTALL:
 
@@ -240,6 +245,7 @@ Hoe is required but only for running the tests.
 === Designing Patterns
 * Homepage: http://www.designingpatterns.com
 * Blogs: http://blogs.designingpatterns.com
+* Twitter: http://www.twitter.com/TonyDesignP
 
 == SUPPORT:
 Please post questions, concerns, or requests for enhancement to the forums on
@@ -260,7 +266,7 @@ distribution.
 
 This  package is licensed with an MIT license:
 
-Copyright (c) 2008 Designing Patterns
+Copyright (c) 2008-2009 Designing Patterns
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -2,8 +2,11 @@
 require 'rubygems'
 require 'hoe'
 
-Hoe.new('logrotate', "1.1.0") do |p|
-  p.remote_rdoc_dir = ''
+PROJECT_NAME = 'logrotate'
+
+Hoe.spec(PROJECT_NAME) do |p|
+  p.url = "http://#{PROJECT_NAME}.rubyforge.org"
+  p.version = "1.2.0"
   p.developer('DesigningPatterns', 'technical.inquiries@designingpatterns.com')
 end
 

data/lib/logrotate/impl.rb

@@ -2,6 +2,8 @@
 
 require 'zlib'
 require 'date'
+require 'fileutils'
+
 require 'logrotate/rotateinfo'
 
 module LogRotate
@@ -249,6 +251,15 @@ module LogRotate
       # error checking
       if (!File.exist?(file)) then raise "File does not exist: #{file}." end
       if (!File.readable?(file)) then raise "File is not readable: #{file}." end
+
+      is_directory = File.directory?(file)
+      if (is_directory && options[:gzip])
+        raise ArgumentError, "The gzip option is not supported for directories."
+      end
+      
+      if (options[:directory])
+        FileUtils.mkdir_p(options[:directory])
+      end
       
       if (options[:pre_rotate]) 
         options[:pre_rotate].call() 
@@ -308,7 +319,7 @@ module LogRotate
       
       deleted_files = deleted_files_and_dates.map { |entry| entry[:file] }
       if (deleted_files_and_dates.length() > 0)
-        File.unlink(*deleted_files)
+        FileUtils.rm_r(deleted_files)
       end
       
       # Rename the original file.
@@ -347,7 +358,7 @@ module LogRotate
                                                                              count,
                                                                              new_rotated_file)
       deleted_files = deleted_files_and_counts.map {|entry| entry[:file] }
-      File.unlink(*deleted_files)
+      FileUtils.rm_r(deleted_files)
       
       rotated_files_and_counts = rotated_files_and_counts - deleted_files_and_counts
       
@@ -396,7 +407,7 @@ module LogRotate
       rescue => error
         raise "Unable to zip file: #{file}. Error: #{error}\n"
       end
-      File.unlink(file)
+      FileUtils.rm_r(file)
       
       return gzip_file
     end

data/lib/logrotate/logrotate.rb

@@ -10,7 +10,8 @@ require 'logrotate/rotateinfo'
 module LogRotate
 
   # 
-  # ====Description: This method rotates the given files.  
+  # ====Description: 
+  # This method rotates the given files and/or directories.
   # 
   # ====Parameters:
   # [file(s)]
@@ -33,7 +34,7 @@ module LogRotate
   
   # 
   # ====Description: 
-  # This method rotates the given file(s).  
+  # This method rotates the given file or directory.  
   # 
   # There are 2 types of extensions that can be used: the default
   # extension which is an integer value (".1", ".2", ..), and a
@@ -45,6 +46,9 @@ module LogRotate
   # succeeds, the method will return normally, and an instance will be
   # returned with information about the rotated files.
   # 
+  # Note: If a directory is passed in to be rotated, the gzip option
+  # does not apply / can not be used.  In this case, please tar the 
+  # directory and then call rotate_file on the tar'ed file.
   # ====Parameters:
   # [file]
   #      The file to be rotated.
@@ -68,7 +72,8 @@ module LogRotate
   # +post_rotate+:: A +Proc+ to be executed after the rotation is finished,
   #                 and before the newly rotated file is zipped.
   # +gzip+:: Whether the newly rotated file should be gzipped.  Possible 
-  #          values are: +true+, +false+.
+  #          values are: +true+, +false+.  Note: This option can not be
+  #          used on directories.
   #
   # To see the default values of these options, see the DEFAULT_
   # constants in LogRotate::Impl.

data/lib/logrotate/rotateinfo.rb

@@ -61,22 +61,22 @@ module LogRotate
     
     def to_s()
       os = StringIO.new
-      os.print "Rotated Files And Dates:\n"
+      os.print "Rotated Files/Directories And Dates:\n"
       @rotated_files_and_dates.each do |element|
         os.print "   file -> ", element[:file], ", date_time -> ", element[:date_time], "\n"
       end
       
-      os.print "Rotated Files: \n"
+      os.print "Rotated Files/Directories: \n"
       if (@rotated_files.length() > 0)
         os.print "   ", @rotated_files.join("\n   "), "\n"
       end
       
-      os.print "Deleted Files:\n"
+      os.print "Deleted Files/Directories:\n"
       if (@deleted_files.length() > 0)
         os.print "   ", @deleted_files.join("\n   "), "\n"
       end
       
-      os.print "New Rotated File: \n"
+      os.print "Newly Rotated File/Directory: \n"
       os.print "   ", @new_rotated_file, "\n"
       
       return os.string()
@@ -140,22 +140,22 @@ module LogRotate
 
     def to_s()
       os = StringIO.new
-      os.print "Rotated Files And Counts:\n"
+      os.print "Rotated Files/Directories And Counts:\n"
       @rotated_files_and_counts.each do |element|
         os.print "   file -> ", element[:file], ", index -> ", element[:index], "\n"
       end
       
-      os.print "Rotated Files: \n"
+      os.print "Rotated Files/Directories: \n"
       if (@rotated_files.length() > 0)
         os.print "   ", @rotated_files.join("\n   "), "\n"
       end
       
-      os.print "Deleted Files:\n"
+      os.print "Deleted Files/Directories:\n"
       if (@deleted_files.length() > 0)
         os.print "   ", @deleted_files.join("\n   "), "\n"
       end
       
-      os.print "New Rotated File: \n"
+      os.print "Newly Rotated File/Directory: \n"
       os.print "   ", @new_rotated_file, "\n"
       
       return os.string()

data/test/test_logrotate.rb

@@ -5,8 +5,13 @@ require 'logrotate/impl'
 require 'logrotate/rotateinfo'
 
 require 'fileutils'
-
 require 'test/unit'
+require 'English'
+
+require 'rubygems'
+require 'assertions'
+
+print $LOAD_PATH.join("\n")
 
 class LogRotateTest < Test::Unit::TestCase
   TEMP_DIR = "./temp"
@@ -19,59 +24,207 @@ class LogRotateTest < Test::Unit::TestCase
     FileUtils::rm_r(TEMP_DIR, :force => true)
   end
 
-  def test_rotate_integer_extension()
-    rotate_integer_extension(3, 10, gzip = false)
-    rotate_integer_extension(3, 10, gzip = true)
+  def test_rotate_directory_and_gzip_error()
+    dir = "#{TEMP_DIR}/sample"
+    FileUtils.mkdir_p(dir)
+    
+    options = {:gzip => true }
+    assert_raise_message("The gzip option is not supported for directories.", ArgumentError) do
+      result = LogRotate.rotate_file(dir, options)
+    end
+  end
+  
+  def test_rotate_file_integer_extension()
+    output_dirs = [ nil, "#{TEMP_DIR}/archives" ]
 
-    output_dir = "#{TEMP_DIR}/archives"
-    rotate_integer_extension(3, 10, gzip = false, output_dir)
-    rotate_integer_extension(3, 10, gzip = true, output_dir)
+    output_dirs.each do |output_dir|
+      rotate_file_integer_extension(3, 10, gzip = false, output_dir)
+      rotate_file_integer_extension(3, 10, gzip = true, output_dir)
+    end
+  end
+  
+  def test_rotate_directory_integer_extension()
+    output_dirs = [ nil, "#{TEMP_DIR}/archives" ]
+    
+    output_dirs.each do |output_dir|
+      rotate_directory_integer_extension(3, 10, output_dir)
+    end
   end
 
-  def test_rotate_date_extension()
+  def test_rotate_file_date_extension()
     date_time_format = "%F"
+    output_dirs = [ nil, "#{TEMP_DIR}/archives" ]
+
+    output_dirs.each do |output_dir|
+      rotate_file_date_extension(3, 10, gzip = false, output_dir)
+      rotate_file_date_extension(3, 10, gzip = true, output_dir)
+      rotate_file_date_extension(3, 10, gzip = true, output_dir, date_time_format)
+    end
+  end
+  
+  def test_rotate_directory_date_extension()
+    output_dirs = [ nil, "#{TEMP_DIR}/archives" ]
     
-    output_dir = nil
-    rotate_date_extension(3, 10, gzip = false)
-    rotate_date_extension(3, 10, gzip = true)
-    rotate_date_extension(3, 10, gzip = true, output_dir, date_time_format)
+    output_dirs.each do |output_dir|
+      rotate_directory_date_extension(1, 5, output_dir)
+      rotate_directory_date_extension(3, 10, output_dir)
+    end
+  end
+  
+  def resolve_output_dir(source_dir, output_dir)
+    if (is_output_dir = output_dir != nil)
+    else
+      output_dir = source_dir
+    end
     
-    output_dir = "#{TEMP_DIR}/archives"
-    rotate_date_extension(3, 10, gzip = false, output_dir)
-    rotate_date_extension(3, 10, gzip = true, output_dir)
-    rotate_date_extension(3, 10, gzip = true, output_dir, date_time_format)
+    return is_output_dir, output_dir
   end
 
-  def get_expected_results_integer_extension(iteration, base_name, count, gzip, output_dir)
+  def rotate_directory_integer_extension(count, rotations, output_dir = nil)
+
+    source_dir = "#{TEMP_DIR}"
+    Dir.mkdir(source_dir)
+    
+    # The directory we will be rotating
+    base_name = "folder"
+    directory = File.join(source_dir, base_name)
+    
+    # The file we will be seeding the directory with
+    file_base = "file.dat"
+    file = "#{directory}/#{file_base}"
+    
+    is_output_dir, output_dir = resolve_output_dir(source_dir, output_dir)
+    
+    #rotate the file rotations times
+    1.upto(rotations) do |iteration|
+      data = rotations - iteration + 1
+
+      Dir.mkdir(directory)
+      
+      File.open(file, "w") do |file_stream|
+        file_stream.write("#{data}")
+      end
+      
+      options = {:count => count}
+      if (is_output_dir) then options[:directory] = output_dir end
+      
+      result = LogRotate.rotate_file(directory, options)
+      
+      expected_result = get_expected_results_integer_extension(iteration, base_name, count, false, output_dir, true)
+      assert_equal(expected_result, result)
+    end
+    
+    #verify there are count rotated files.
+    entries = Dir.glob("#{output_dir}/*").map {|entry| File.split(entry)[1]}
+    assert_equal(entries.length, count)
+    
+    # verify the names of the remaining directories
+    expected = (1..count).map { |i| "#{base_name}.#{i}" }
+    assert_equal(entries.sort, expected)
+
+    #verify the contents of the remaining directories.
+    (1..count).each do |i|
+      rotated_directory = "#{output_dir}/#{base_name}.#{i}"
+      assert_equal(IO.read("#{rotated_directory}/#{file_base}"), i.to_s())
+    end
+
+    teardown()
+  end
+  
+  
+  def rotate_directory_date_extension(count, rotations, output_dir = nil, 
+                                      date_time_format = LogRotate::Impl::DEFAULT_DATE_TIME_FORMAT)
+    source_dir = "#{TEMP_DIR}"
+    Dir.mkdir(source_dir)
+    
+    # The directory we will be rotating
+    base_name = "folder"
+    directory = File.join(source_dir, base_name)
+    
+    # The file we will be seeding the directory with
+    file_base = "file.dat"
+    file = "#{directory}/#{file_base}"
+    
+    is_output_dir, output_dir = resolve_output_dir(source_dir, output_dir)
+    
+    #rotate the directory
+    now = DateTime.now
+    date_times = (0..(rotations - 1)).map { |i| now + i }
+    
+    1.upto(rotations) do |iteration|
+      index = iteration - 1
+      date_time = date_times[index]
+      
+      Dir.mkdir(directory)
+
+      File.open(file, "w") do |file_stream|
+        file_stream.write(date_time.strftime(date_time_format))
+      end
+      
+      options = { :date_time_ext => true, :date_time => date_time, :count => count }
+      if (is_output_dir) then options[:directory] = output_dir end
+      if date_time_format then options[:date_time_format] = date_time_format end
+      
+      result = LogRotate.rotate_file(directory, options)
+      
+      expected_result = get_expected_result_date_extension(iteration, base_name, date_times, count, 
+                                                           date_time_format, false, output_dir, true)
+      assert_equal(expected_result, result)
+    end
+    
+    #verify there are count rotated files.
+    entries = Dir.glob("#{output_dir}/*").map {|entry| File.split(entry)[1]}
+    assert_equal(count, entries.length)
+    
+    #verify the correctness of the file names
+    date_times.slice!(0, date_times.length - count)
+    expected = date_times.map do |date_time| 
+      "#{base_name}.#{date_time.strftime(date_time_format)}"
+    end
+    
+    assert_equal(expected, entries.sort)
+    
+    # verify the contents of the zipped/unzipped directories
+    date_times.each do |date_time|
+      rotated_directory = "#{output_dir}/#{base_name}.#{date_time.strftime(date_time_format)}"
+      assert_equal(IO.read("#{rotated_directory}/#{file_base}"), "#{date_time.strftime(date_time_format)}")
+    end
+
+    teardown()
+  end
+
+  def assert_exec(command)
+    system(command)
+    assert_equal($CHILD_STATUS.exitstatus, 0, "Command (#{command}) Failed! Exit Status: #{$CHILD_STATUS.inspect}")
+  end
+  
+  def get_expected_results_integer_extension(iteration, base_name, count, gzip, output_dir, is_directory)
     expected_result = LogRotate::RotateInfoIntegerExtension.new(nil, nil, nil, nil)
     expected_result.rotated_files_and_counts = []
+
+    gzip_extension = gzip ? (is_directory ? ".tar.gz" : ".gz") : ""
     
     1.upto(iteration > count ? count : iteration) do |i|
-      rotated_file = "#{output_dir}/#{base_name}.#{i}" + (gzip ? ".gz" : "")
+      rotated_file = "#{output_dir}/#{base_name}.#{i}" + gzip_extension
       expected_result.rotated_files_and_counts.push({ :index => i, :file => rotated_file })
     end
     
     expected_result.rotated_files = expected_result.rotated_files_and_counts.map { |entry| entry[:file] }
-    expected_result.deleted_files = iteration > count ? [ "#{output_dir}/#{base_name}.#{count}" + (gzip ? ".gz" : "") ] : []
-    expected_result.new_rotated_file = "#{output_dir}/#{base_name}.1" + (gzip ? ".gz" : "")
+    expected_result.deleted_files = iteration > count ? [ "#{output_dir}/#{base_name}.#{count}" + gzip_extension ] : []
+    expected_result.new_rotated_file = "#{output_dir}/#{base_name}.1" + gzip_extension
 
     return expected_result
   end
   
-  def rotate_integer_extension(count, rotations, gzip, output_dir = nil)
+  def rotate_file_integer_extension(count, rotations, gzip, output_dir = nil)
     source_dir = "#{TEMP_DIR}"
+    Dir.mkdir(source_dir)
+
+    # The file we will be rotating
     base_name = "file.dat"
     file = File.join(source_dir, base_name)
-    Dir.mkdir(source_dir)
-    
-    is_output_dir = false
-    if (output_dir) then 
-      Dir.mkdir(output_dir)
-      is_output_dir = true
-    else
-      output_dir = source_dir
-    end
     
+    is_output_dir, output_dir = resolve_output_dir(source_dir, output_dir)    
     manipulate_garbage_files(output_dir, base_name, :insert)
 
     #rotate the file rotations times
@@ -87,7 +240,7 @@ class LogRotateTest < Test::Unit::TestCase
       
       result = LogRotate.rotate_file(file, options)
       
-      expected_result = get_expected_results_integer_extension(iteration, base_name, count, gzip, output_dir)
+      expected_result = get_expected_results_integer_extension(iteration, base_name, count, gzip, output_dir, false)
       assert_equal(expected_result, result)
     end
     
@@ -116,6 +269,8 @@ class LogRotateTest < Test::Unit::TestCase
   end
 
   def manipulate_garbage_files(dir, base_name, operation)
+    FileUtils.mkdir_p(dir)
+
     bogus_extensions = [ ".back", ".back123", ".2008-10-04foo", ".123x" ]
     
     bogus_extensions.each do |bogus_extension|
@@ -131,8 +286,10 @@ class LogRotateTest < Test::Unit::TestCase
     end
   end
 
-  def get_expected_result_date_extension(iteration, base_name, date_times, count, date_time_format, gzip, output_dir)
+  def get_expected_result_date_extension(iteration, base_name, date_times, count, date_time_format, gzip, output_dir, is_directory)
     index = iteration - 1
+    gzip_extension = gzip ? (is_directory ? ".tar.gz" : ".gz") : ""
+
 
     expected_result = LogRotate::RotateInfoDateExtension.new(nil, nil, nil, nil)
     expected_result.rotated_files_and_dates = []
@@ -141,7 +298,7 @@ class LogRotateTest < Test::Unit::TestCase
     index.downto(oldest_existing_date_index) do |i|
       str_date_time = date_times[i].strftime(date_time_format)
       reconstructed_date_time = DateTime.strptime(str_date_time, date_time_format)
-      rotated_file = "#{output_dir}/#{base_name}.#{str_date_time}" + (gzip ? ".gz" : "")
+      rotated_file = "#{output_dir}/#{base_name}.#{str_date_time}" + gzip_extension
       
       expected_result.rotated_files_and_dates.push({ :date_time => reconstructed_date_time, 
                                                      :file => rotated_file })
@@ -151,34 +308,28 @@ class LogRotateTest < Test::Unit::TestCase
     
     if (iteration > count)
       str_date_time = date_times[index - count].strftime(date_time_format)
-      expected_result.deleted_files = [ "#{output_dir}/#{base_name}.#{str_date_time}" + (gzip ? ".gz" : "") ]
+      expected_result.deleted_files = [ "#{output_dir}/#{base_name}.#{str_date_time}" + gzip_extension ]
     else
       expected_result.deleted_files = []
     end
     
     str_date_time = date_times[index].strftime(date_time_format)
-    expected_result.new_rotated_file = "#{output_dir}/#{base_name}.#{str_date_time}" + (gzip ? ".gz" : "")
-
+    expected_result.new_rotated_file = "#{output_dir}/#{base_name}.#{str_date_time}" + gzip_extension
+    
     return expected_result
   end
   
-  def rotate_date_extension(count, rotations, gzip, 
+  def rotate_file_date_extension(count, rotations, gzip, 
                             output_dir = nil, 
                             date_time_format = LogRotate::Impl::DEFAULT_DATE_TIME_FORMAT)
     
     source_dir = "#{TEMP_DIR}"
+    Dir.mkdir(source_dir)
+    
     base_name = "file.dat"
     file = File.join(source_dir, base_name)
-    Dir.mkdir(source_dir)
     
-    is_output_dir = false
-    if (output_dir) then 
-      Dir.mkdir(output_dir)
-      is_output_dir = true
-    else
-      output_dir = source_dir
-    end
-
+    is_output_dir, output_dir = resolve_output_dir(source_dir, output_dir)    
     manipulate_garbage_files(output_dir, base_name, :insert)
     
     #rotate the file
@@ -201,7 +352,7 @@ class LogRotateTest < Test::Unit::TestCase
       result = LogRotate.rotate_file(file, options)
       
       expected_result = get_expected_result_date_extension(iteration, base_name, date_times, count, 
-                                                           date_time_format, gzip, output_dir)
+                                                           date_time_format, gzip, output_dir, false)
       assert_equal(expected_result, result)
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: logrotate
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - DesigningPatterns
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-27 00:00:00 -04:00
+date: 2009-10-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,9 +20,25 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: 2.3.3
     version: 
-description: This package is a library of methods that perform log rotation.  The log rotate methods allow the caller to specify options (via parameters) such as how many rotated files to keep, what type of extension to place on the rotated file (date or a simple count), and whether to zip the rotated files.  Live log files (currently being written to by a live process) can be rotated as well.  The post_rotate option is useful in that context, as it can be used to send a HUP signal to notify the live process to reopen its log file.  This package was inspired by the need to have a library version of the unix logrotate tool.  The unix logrotate tool requires the user to specify options in a config file, and is usually invoked through cron.
+description: |-
+  This package is a library of methods that perform log rotation on files and 
+  directories.  The log rotate methods allow the caller to specify options (via
+  parameters) such as how many rotated files to keep, what type of
+  extension to place on the rotated file (date or a simple count), and
+  whether to zip the rotated files.  Live log files (currently being
+  written to by a live process) can be rotated as well.  The post_rotate
+  option is useful in that context, as it can be used to send a HUP
+  signal to notify the live process to reopen its log file.
+  
+  This package was inspired by the need to have a library version of the
+  unix logrotate tool.  The unix logrotate tool requires the user to
+  specify options in a config file, and is usually invoked through cron.
+  
+  Directories can be rotated with this library.  However, the gzip option
+  does not work with directories.  In this case, please zip/tar the directory
+  in question before invoking this library.
 email: 
 - technical.inquiries@designingpatterns.com
 executables: []
@@ -30,13 +46,13 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- Manifest.txt
 - History.txt
+- Manifest.txt
 - README.txt
 files: 
-- Manifest.txt
-- LICENSE
 - History.txt
+- LICENSE
+- Manifest.txt
 - README.txt
 - Rakefile
 - lib/logrotate.rb
@@ -45,7 +61,9 @@ files:
 - lib/logrotate/rotateinfo.rb
 - test/test_logrotate.rb
 has_rdoc: true
-homepage: This package is a library of methods that perform log rotation.  The
+homepage: http://logrotate.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -67,9 +85,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: logrotate
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
-summary: This package is a library of methods that perform log rotation
+specification_version: 3
+summary: This package is a library of methods that perform log rotation on files and  directories
 test_files: 
 - test/test_logrotate.rb