geoffreywiseman-prune 1.1.0

data/README.mdown

@@ -0,0 +1,24 @@
+# Prune:  Deleting and archiving files by date
+
+We have some nightly processes that archive information that we'd like to retain, either for reference or
+for possible restoration.  In order to keep space usage somewhat reasonable, we'd like to prune some of
+those files as they get older.  Prune satisfies that need.
+
+Prune is written as a Ruby library with an optional command-line interface and a wrapping shell script.
+
+## Usage
+
+Although prune has a command-line interface, at the moment the retention policy which determines what to
+do with each of the files (retain, remove, archive) and how to take action (archiving files by month in
+a .tar.gz) is basically hard-coded for our current needs, although it's easy to change.
+
+To invoke prune:
+
+	bin/prune <folder>
+
+To get help on the various command-line options:
+
+	bin/prune --help
+
+In the long run, I expect this will be packaged as a gem and have the retention policy externalized
+where it can be configured for your own needs.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rspec/core/rake_task'
+require 'rspec'
+require 'rubygems'
+require 'rubygems/package_task'
+
+CLEAN.include( 'coverage', 'pkg' )
+
+desc '"spec" (run RSpec)'
+task :default => :spec
+
+desc "Run RSpec on spec/*"
+RSpec::Core::RakeTask.new
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec,/gems/,/rubygems/', '--text-report']
+end
+
+spec = Gem::Specification.new do |spec|
+  spec.name = 'geoffreywiseman-prune'
+  spec.version = '1.1.0'
+  spec.date = '2011-09-09'
+  spec.summary = 'Prunes files from a folder based on a retention policy, often time-based.'
+  spec.description = 'Prune is meant to analyze a folder full of files, run them against a retention policy and decide which to keep, which to remove and which to archive. It is extensible and embeddable.'
+  spec.author = 'Geoffrey Wiseman'
+  spec.email = 'geoffrey.wiseman@codiform.com'
+  spec.homepage = 'http://geoffreywiseman.github.com/prune'
+  spec.executables << 'prune'
+  
+  spec.files = Dir['{lib,spec}/**/*.rb', 'bin/*', 'Rakefile', 'README.mdown', 'UNLICENSE']
+end
+
+Gem::PackageTask.new( spec ) do |pkg|
+  pkg.need_tar_gz = true
+  pkg.need_zip = true
+end
+
+# Rake::PackageTask.new( "prune", "1.1.0" ) do |p|
+#   p.need_tar_gz = true
+#   p.need_zip = true
+#   p.package_files.include( '{bin,lib,spec}/**/*', 'Rakefile', 'README.mdown', 'UNLICENSE' )
+# end

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/bin/prune

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# Include the 'Lib' dir in the Load Path
+# $LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'prune'
+Prune::CommandLineInterface.parse_and_run

data/lib/prune.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+
+require 'prune/cli'
+require 'prune/archiver'
+require 'prune/pruner'
+require 'prune/retention'
+require 'prune/grouper'
+require 'prune/category'
+

data/lib/prune/archiver.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'optparse'
+require 'date'
+require 'zlib'
+require 'archive/tar/minitar'
+include Archive::Tar
+
+module Prune
+  class Archiver
+    attr_reader :destination
+
+    def initialize( destination, source, verbose )
+      @source = source
+      @verbose = verbose
+      @destination = destination || get_default_dir
+    end
+
+    def get_default_dir
+      absolute = File.expand_path @source
+      path = File.dirname absolute
+      name = File.basename absolute
+      File.join( path, "#{name}-archives" )
+    end
+
+    def make_destination_dir
+      begin
+        Dir.mkdir @destination unless File.exists? @destination
+      rescue SystemCallError
+        raise IOError, "Archive folder #{@destination} does not exist and cannot be created."
+      end
+    end
+
+    def archive( group_name, files )
+      make_destination_dir
+      archive_path = File.join( @destination, "archive-#{group_name}.tar.gz")
+      paths = files.map { |file| File.join( @source, file ) }
+
+      if File.exists?( archive_path ) then
+        puts "Archive file #{archive_path} exists." if @verbose
+        Dir.mktmpdir do |tmp_dir|
+          puts "Created temporary directory #{tmp_dir} to extract contents of existing archive file." if @verbose
+          tgz = Zlib::GzipReader.new( File.open( archive_path, 'rb' ) )
+          Minitar.unpack( tgz, tmp_dir )
+          extracted_paths = Dir.entries( tmp_dir ).map { |tmpfile| File.join( tmp_dir, tmpfile ) }.reject { |path| File.directory? path }
+          combined_paths = extracted_paths + paths
+          tgz = Zlib::GzipWriter.new( File.open( archive_path, 'wb' ) )
+          Minitar.pack( combined_paths, tgz )
+          puts "Added #{files.size} file(s) to #{archive_path} archive already containing #{extracted_paths.size} file(s)." if @verbose
+        end
+      else
+        tgz = Zlib::GzipWriter.new( File.open( archive_path, 'wb' ) )
+        Minitar.pack( paths, tgz )
+        puts "Compressed #{files.size} file(s) into #{archive_path} archive." if @verbose
+      end
+
+      File.delete( *paths )
+      puts "Removing #{files.size} source files that have been archived." if @verbose
+    end
+  end
+end

data/lib/prune/category.rb

@@ -0,0 +1,30 @@
+class Category
+  attr_accessor :action, :description
+  
+  def initialize( description, action, quiet = false, predicate = Proc.new { |x| true } )
+    @description = description
+    @action = action
+    @predicate = predicate
+    @quiet = quiet
+  end
+  
+  def requires_prompt?
+    case @action
+    when :remove
+      true
+    when :archive
+      true
+    else
+      false
+    end
+  end
+  
+  def includes?( filename )
+    @predicate.call filename
+  end
+  
+  def quiet?
+    @quiet
+  end
+  
+end

data/lib/prune/cli.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'optparse'
+require 'date'
+require 'zlib'
+require 'archive/tar/minitar'
+include Archive::Tar
+
+module Prune
+  VERSION = [1,0,0]
+
+  class CommandLineInterface
+
+    DEFAULT_OPTIONS = { :verbose => false, :did_work => false, :dry_run => false, :prompt => true, :archive => true }
+
+    def self.parse_and_run
+      options = DEFAULT_OPTIONS.dup
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: prune [options] folder"
+        opts.on( "-v", "--verbose", "Prints much more frequently during execution about what it's doing." ) { options[:verbose] = true }
+        opts.on( "-d", "--dry-run", "Categorizes files, but does not take any actions on them." ) { options[:dry_run] = true }
+        opts.on( "-f", "--force", "--no-prompt", "Will take action without asking permissions; useful for automation." ) { options[:prompt] = false }
+        opts.on( "-a", "--archive-folder FOLDER", "The folder in which archives should be stored; defaults to <folder>/../<folder-name>-archives." ) { |path| options[:archive_path] = path }
+        opts.on( "--no-archive", "Don't perform archival; typically if the files you're pruning are already compressed." ) { options[:archive] = false }
+        opts.on_tail( "--version", "Displays version information." ) do
+          options[:did_work] = true
+          print "Prune #{VERSION.join('.')}, by Geoffrey Wiseman."
+        end
+        opts.on_tail( "-?", "--help", "Shows quick help about using prune." ) do
+          options[:did_work] = true
+          puts opts
+        end
+      end
+
+      begin
+        parser.parse!
+
+        if ARGV.size != 1 then
+          print parser.help unless options[:did_work]
+        else
+          Pruner.new( options ).prune( ARGV.first )
+        end
+      rescue OptionParser::ParseError
+        $stderr.print "Error: " + $! + "\n"
+      end
+
+    end
+  end
+
+end

data/lib/prune/default_retention.rb

@@ -0,0 +1,36 @@
+preprocess do |file|
+  file.modified_time = File.mtime( file.name )
+
+  modified_date = Date.parse modified_time.to_s
+  file.days_since_modified = Date.today - modified_date
+  file.months_since_modified = ( Date.today.year - modified_date.year ) * 12 + (Date.today.month - modified_date.month)
+end
+
+category "Ignoring directories" do
+  match { |file| File.directory?(file.name) }
+  ignore
+  quiet
+end
+
+category "Retaining Files from the Last Two Weeks" do
+  match do |file|
+    file.days_since_modified <= 14
+  end
+  retain
+end
+
+category "Retaining 'Friday' files Older than Two Weeks" do
+  match { |file| file.modified_time.wday == 5 && file.months_since_modified < 2 && file.days_since_modified > 14 }
+  retain
+end
+
+category "Removing 'Non-Friday' files Older than Two Weeks" do
+  match { |file| file.modified_time.wday != 5 && file.days_since_modified > 14 }
+  remove 
+end
+
+category "Archiving Files Older than Two Months" do 
+  match { |file| file.modified_time.wday == 5 && file.months_since_modified >= 2 }
+  archive
+end
+

data/lib/prune/grouper.rb

@@ -0,0 +1,27 @@
+module Prune
+  class Grouper
+
+    def initialize( archiver )
+      @groups = Hash.new{ |h,k| h[k] = [] }
+      @archiver = archiver
+    end
+
+    def group( folder_name, files )
+      files.each do |file|
+        mtime = File.mtime( File.join( folder_name, file ) )
+        month_name = Date::ABBR_MONTHNAMES[ mtime.month ]
+        group_name = "#{month_name}-#{mtime.year}"
+        @groups[ group_name ] << file
+      end
+      return self
+    end
+
+    def archive
+      @groups.each_pair do |month,files|
+        @archiver.archive( month, files )
+      end
+      sizes = @groups.values.map { |x| x.size }.join( ', ' )
+      "#{@groups.size} archive(s) created (#{sizes} file(s), respectively)"
+    end
+  end
+end

data/lib/prune/pruner.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'optparse'
+require 'date'
+require 'zlib'
+require 'archive/tar/minitar'
+include Archive::Tar
+
+module Prune
+
+  class Pruner
+    attr_reader :categories
+    attr_reader :options
+
+    def initialize( options )
+      @options = options
+      @categories = Hash.new { |h,k| h[k] = [] } # initialize new keys with an empty array
+      @analyzed_count = 0
+    end
+
+    def prune( folder_name )
+      return print( "ERROR: Cannot find folder: #{folder_name}\n" ) unless File.exists? folder_name
+      return puts( "ERROR: #{folder_name} is not a folder" ) unless File.directory? folder_name
+      policy = RetentionPolicy.new folder_name
+      return puts( "ERROR: Retention policy contains no categories." ) if policy.categories.empty?
+      policy.categories.each { |cat| @categories[cat] = Array.new } # retain category order
+      analyze folder_name, policy
+      execute_prune( folder_name, policy ) unless @options[:dry_run]
+    end
+
+    def analyze( folder_name, policy )
+      print "Analyzing '#{folder_name}':\n"
+      files = Dir.entries( folder_name ).sort_by { |f| test(?M, File.join( folder_name, f ) ) }
+      files.each do |file|
+        analyze_file( policy, file )
+      end
+      print "\n" if @options[:verbose]
+
+      display_categories policy
+      print "\t#{@analyzed_count} file(s) analyzed\n"
+    end
+
+    def execute_prune( folder_name, policy )
+      begin
+        if should_prompt?( policy ) && !prompt then
+          puts "Not proceeding; no actions taken."
+        else
+          take_all_actions( folder_name, policy )
+        end
+      rescue IOError
+        $stderr.print "ERROR: #{$!}\n"
+      end
+    end
+
+    def should_prompt?( policy )
+      @options[:prompt] && actions_require_prompt( policy )
+    end
+
+    def actions_require_prompt( policy )
+      @categories.keys.any? { |category| category.requires_prompt? }
+    end
+
+    def prompt
+      print "Proceed? [y/N]: "
+      response = STDIN.gets.chomp.strip.downcase
+      ['y','yes','true'].include? response
+    end
+
+    def take_all_actions( folder_name, policy )
+      actions = 0
+      @categories.each_pair do |category,files|
+        action = category.action
+        result = take_action( action, folder_name, files )
+        if !result.nil? then
+          puts result
+          actions += 1
+        end
+      end
+      print "No actions necessary.\n" if actions == 0
+    end
+
+    def take_action( action, folder_name, files )
+      case action
+      when :remove
+        paths = files.map { |file| File.join folder_name, file }
+        begin
+          File.delete *paths
+          "#{files.size} file(s) deleted"
+        rescue
+          raise IOError, "Could not remove file(s): #{$!}"
+        end
+      when :archive
+        if @options[:archive] then
+          archiver = Archiver.new( @options[:archive_path], folder_name, @options[:verbose] )
+          grouper = Grouper.new( archiver )
+          grouper.group( folder_name, files );
+          grouper.archive
+        else
+          "Archive option disabled. Archive(s) not created."
+        end
+      end
+    end
+
+    def display_categories( policy )
+      @categories.each_pair do |category,files|
+        if !category.quiet? || @options[:verbose] then 
+          print "\t#{category.description}:\n\t\t"
+          puts files.join( "\n\t\t")
+        end
+      end
+    end
+
+    def analyze_file( policy, file )
+      category = policy.categorize( file )
+      @categories[ category ] << file unless category.nil?
+      @analyzed_count += 1
+    end
+  end
+
+end

data/lib/prune/retention.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/ruby
+require 'rubygems'
+require 'date'
+require 'pathname'
+
+module Prune
+
+  class RetentionPolicy
+    
+    attr_accessor :categories
+    
+    def initialize( folder_name )
+      @folder_name = folder_name
+      @today = Date.today
+      @categories = Array.new
+      @default_category = Category.new "Unmatched Files", :retain, true
+      instance_eval *get_retention_dsl( folder_name )
+    end
+    
+    def categorize( file_name )
+      file_context = FileContext.new( @folder_name, file_name, @preprocessor )
+      @categories.find { |cat| cat.includes? file_context } || @default_category
+    end
+    
+    def get_retention_dsl( folder_name )
+      get_dsl( folder_name, '.prune' ) || get_dsl( File.dirname(__FILE__), 'default_retention.rb', 'core retention policy' )
+    end
+    
+    def get_dsl( dsl_folder, dsl_file, human_name=nil )
+      dsl = File.join( dsl_folder, dsl_file )
+      human_name = Pathname.new( dsl ).cleanpath.to_s if human_name.nil?
+      if File.exists?( dsl ) then
+        puts "Loading retention policy from: #{human_name}"
+        return File.read( dsl ), dsl_file
+      else
+        return nil
+      end
+    end
+    
+    def category( description, &block )
+      builder = CategoryBuilder.new( description )
+      builder.instance_eval &block
+      @categories << builder.build
+    end
+    
+    def preprocess( &block )
+      @preprocessor = Proc.new &block
+    end
+    
+  end
+  
+  class CategoryBuilder
+    
+    def initialize( description )
+      @description = description
+      @quiet = false
+    end
+    
+    def build
+      if @predicate.nil? then
+        raise "Category #{@description} has no predicate defined."
+      elsif @action.nil? then
+        raise "Category #{@description} has no action defined."
+      end
+      Category.new( @description, @action, @quiet, @predicate )
+    end
+    
+    def match( &block )
+      @predicate = Proc.new &block
+    end
+    
+    def ignore
+      @action = :ignore
+    end
+    
+    def retain
+      @action = :retain
+    end
+    
+    def archive
+      @action = :archive
+    end
+    
+    def remove
+      @action = :remove
+    end
+    
+    def quiet
+      @quiet = true
+    end
+    
+  end
+  
+  class FileContext
+    attr_accessor :name
+    
+    def initialize( path, filename, preprocessor )
+      @name = File.join( path, filename )
+      @attributes = Hash.new
+      instance_eval &preprocessor unless preprocessor.nil?
+    end
+    
+    # def responds_to?( symbol )
+    #   symbol.to_s.end_with? '=' || @attributes.has_key? symbol
+    # end
+    # 
+    def method_missing( symbol, *arguments )
+      if symbol.to_s =~ /(.+)=/ && arguments.size == 1 then
+        @attributes[ $1.to_sym ] = arguments.first
+      elsif @attributes.has_key?( symbol ) && arguments.empty? then
+        @attributes[ symbol ]
+      else
+        super symbol, arguments
+      end
+    end
+    
+  end
+  
+end

data/spec/archiver_spec.rb

@@ -0,0 +1,103 @@
+require 'prune/archiver'
+require 'tmpdir'
+require 'rspec'
+
+describe Prune::Archiver do
+  SOURCE='/mysql'
+
+  describe "with a #{SOURCE} source" do
+    DESTINATION = '/mysql-archives'
+
+    subject { Prune::Archiver.new( nil, '/mysql', true ) }
+
+    it "should have #{DESTINATION} destination" do
+      subject.destination.should eq( DESTINATION )
+    end
+
+    it "should create #{DESTINATION} if does not exist" do
+      File.stub( :exists? ).with( DESTINATION ) { false }
+      Dir.should_receive( :mkdir ).with( DESTINATION )
+      subject.make_destination_dir
+    end
+
+    it "should not attempt to create #{DESTINATION} if it exists" do
+      File.stub( :exists? ).with( DESTINATION ) { true }
+      Dir.should_not_receive( :mkdir )
+      subject.make_destination_dir
+    end
+
+    context "for May 2011" do
+      ARCHIVE_FILE="#{DESTINATION}/archive-May-2011.tar.gz"
+
+      it "should write new archive file in #{DESTINATION} if none exists" do
+
+        # Destination Exists
+        File.stub( :exists? ).with( DESTINATION ) { true }
+
+        # Archive File Exists
+        File.stub( :exists? ).with( ARCHIVE_FILE ) { false }
+
+        # Create Zip File
+        archive_file = double "file"
+        gz = double "GzipWriter"
+        paths = [ "/mysql/a", "/mysql/b", "/mysql/c" ]
+        File.stub( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
+        Zlib::GzipWriter.stub( :new ) { gz }
+        Minitar.should_receive( :pack ).with( paths, gz )
+        File.should_receive( :delete ).with( *paths )
+
+        subject.archive "May-2011", ["a", "b", "c"]
+      end
+
+      it "should add to existing archive file if it exists" do
+
+        # Destination Exists
+        File.stub( :exists? ).with( DESTINATION ) { true }
+
+        # Archive File Exists
+        File.stub( :exists? ).with( ARCHIVE_FILE ) { true }
+
+        # Should Create Temp Dir
+        tmpdir = "/tmp"
+        Dir.stub( :mktmpdir ).and_yield( tmpdir )
+
+        # Should Extract Contents
+        archive_file = double "archive file"
+        File.stub( :open ).with( ARCHIVE_FILE, 'rb' ) { archive_file }
+        gzr = double "GzipReader"
+        Zlib::GzipReader.stub( :new ) { gzr }
+        Minitar.should_receive( :unpack ).with( gzr, tmpdir )
+        Dir.should_receive( :entries ).with( tmpdir ) { ["c", "d"] }
+        extracted_paths = [ "/tmp/c", "/tmp/d" ]
+        extracted_paths.each { |path| File.stub( :directory? ).with( path ).and_return( false ) }
+
+        # Should Create Final Archive
+        File.stub( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
+        gzw = double "GzipWriter"
+        Zlib::GzipWriter.stub( :new ) { gzw }
+        original_paths = [ "/mysql/a", "/mysql/b" ]
+        combined_paths = extracted_paths + original_paths
+        Minitar.should_receive( :pack ).with( combined_paths, gzw )
+
+        # Delete Files
+        File.should_receive( :delete ).with( *original_paths )
+
+        # Go
+        subject.archive "May-2011", ["a", "b"]
+
+      end
+
+    end
+
+    context "and a /mysql/archives destination" do
+      subject { Prune::Archiver.new( '/mysql/archives', '/mysql', true ) }
+
+      it "should use the explicit destination" do
+        subject.destination.should eq( '/mysql/archives' )
+      end
+
+    end
+
+  end
+
+end

data/spec/cli_spec.rb

@@ -0,0 +1,205 @@
+require 'prune/cli'
+require 'prune/pruner'
+require 'spec_helper'
+require 'rspec'
+
+describe Prune::CommandLineInterface do
+  USAGE_TEXT = /Usage: prune \[options\] folder/
+  ARCHIVE_PATH = "/prune/fake/archive-path"
+
+  before(:each) do
+    @messages = []
+    $stdout.stub( :write ) { |message| @messages << message  }
+
+    @pruner = double( "pruner" )
+  end
+
+  describe "with no arguments" do
+
+    it "should print help" do
+      ARGV.clear
+      Prune::CommandLineInterface::parse_and_run
+      @messages.should include_match( USAGE_TEXT )
+    end
+
+  end
+
+  describe "with a path argument" do
+    PATH = "/prune/fake/path"
+
+    before(:each) do
+      ARGV.clear.push( PATH )
+      @pruner.stub(:prune)
+    end
+
+    it "should call prune with path" do
+      Prune::Pruner.stub( :new ) { @pruner }
+      @pruner.should_receive( :prune ).with( PATH )
+      Prune::CommandLineInterface::parse_and_run
+    end
+
+    it "should create pruner with defaults" do
+      Prune::Pruner.stub( :new ).with( Prune::CommandLineInterface::DEFAULT_OPTIONS ) { @pruner }
+      Prune::CommandLineInterface::parse_and_run
+    end
+
+    describe "and a -v argument" do
+      it "should set verbose option" do
+        assert_arg_to_option( "-v", :verbose => true )
+      end
+    end
+
+    describe "and a --verbose argument" do
+      it "should set verbose option" do
+        assert_arg_to_option( "--verbose", :verbose => true )
+      end
+    end
+
+    describe "and a -d argument" do
+      it "should set the dry-run option" do
+        assert_arg_to_option( "-d", :dry_run => true )
+      end
+    end
+
+    describe "and a --dry-run argument" do
+      it "should set the dry-run option" do
+        assert_arg_to_option( "--dry-run", :dry_run => true )
+      end
+    end
+
+    describe "and a -f argument" do
+      it "should set the prompt option to false" do
+        assert_arg_to_option "-f", :prompt => false
+      end
+    end
+
+    describe "and a --force argument" do
+      it "should set the prompt option to false" do
+        assert_arg_to_option "--force", :prompt => false
+      end
+    end
+
+    describe "and a --no-prompt argument" do
+      it "should set the prompt option to false" do
+        assert_arg_to_option "--no-prompt", :prompt => false
+      end
+    end
+
+    describe "and a -a argument" do
+      before(:each) do
+        ARGV.push "-a"
+      end
+
+      describe "with no folder name" do
+        it "should print a parsing error" do
+          $stderr.stub( :print ) { |message| @messages << message  }
+          Prune::CommandLineInterface::parse_and_run
+          @messages.should include_match( /missing argument: -a/ )
+        end
+      end
+
+      describe "with a folder name" do
+        it "should set the archive_path option to the folder" do
+          assert_arg_to_option ARCHIVE_PATH, :archive_path => ARCHIVE_PATH
+        end
+      end
+    end
+
+    describe "and a --archive-folder argument" do
+      before(:each) do
+        ARGV.push "--archive-folder"
+      end
+
+      describe "with no folder name" do
+        it "should print a parsing error" do
+          $stderr.stub( :print ) { |message| @messages << message  }
+          Prune::CommandLineInterface::parse_and_run
+          @messages.should include_match( /missing argument: --archive-folder/ )
+        end
+      end
+
+      describe "with a folder name" do
+        it "should set the archive_path option to the folder" do
+          assert_arg_to_option ARCHIVE_PATH, :archive_path => ARCHIVE_PATH
+        end
+      end
+    end
+
+    describe "and a -? argument" do
+
+      before(:each) do
+        ARGV.push "-?"
+      end
+
+      it "should print help" do
+        Prune::CommandLineInterface::parse_and_run
+        @messages.should include_match( USAGE_TEXT )
+      end
+
+      it "should not invoke prune" do
+        @pruner.should_not_receive( :prune )
+        Prune::CommandLineInterface::parse_and_run
+      end
+
+    end
+
+    describe "and a --help argument" do
+
+      before(:each) do
+        ARGV.push "--help"
+      end
+
+      it "should print help" do
+        Prune::CommandLineInterface::parse_and_run
+        @messages.should include_match( USAGE_TEXT )
+      end
+
+      it "should not invoke prune" do
+        @pruner.should_not_receive( :prune )
+        Prune::CommandLineInterface::parse_and_run
+      end
+
+    end
+
+    describe "and an unknown argument" do
+      it "should print a parsing error" do
+        ARGV.push "--unknown-argument"
+        $stderr.stub( :print ) { |message| @messages << message  }
+        Prune::CommandLineInterface::parse_and_run
+        @messages.should include_match( /invalid option/ )
+      end
+    end
+
+    describe "and a --version argument" do
+      before(:each) do
+        ARGV.push "--version"
+      end
+
+      it "should print version number" do
+          $stderr.stub( :print ) { |message| @messages << message  }
+          Prune::CommandLineInterface::parse_and_run
+          @messages.should include_match( /Prune 1.0.0/ )
+      end
+
+      it "should not invoke prune" do
+        @pruner.should_not_receive( :prune )
+        Prune::CommandLineInterface::parse_and_run
+      end
+
+    end
+
+    describe "and a --no-archive argument" do
+      it "should set the archive option to false" do
+        assert_arg_to_option "--no-archive", :archive=>false
+      end
+    end
+
+    def assert_arg_to_option( arg, *options )
+      Prune::Pruner.should_receive( :new ).with( hash_including( *options ) ).and_return( @pruner )
+      ARGV.push( arg )
+      Prune::CommandLineInterface::parse_and_run
+    end
+
+  end
+
+end

data/spec/grouper_spec.rb

@@ -0,0 +1,63 @@
+require 'prune/grouper'
+require 'prune/retention'
+require 'spec_helper'
+require 'rspec'
+
+describe "Prune::Grouper" do
+
+  GROUP_PATH = '/example/prune/folder'
+  before( :each ) do
+     @archiver = double( "Archiver" )
+     @grouper = Prune::Grouper.new( @archiver )
+  end
+
+  context "w/o files" do
+
+    it "should not archive" do
+      @archiver.should_not_receive( :archive )
+      @grouper.group( GROUP_PATH, [] ).archive
+    end
+
+  end
+
+  context "with files" do
+
+    it "should archive files" do
+      files = mock_files( Date.new(2011,01,01) )
+      @archiver.should_receive( :archive )
+      @grouper.group( GROUP_PATH, files ).archive
+    end
+
+    it "should specify month and year" do
+      files = mock_files( Date.new(2008,03,01) )
+      @archiver.should_receive( :archive ).with( "Mar-2008", files )
+      @grouper.group( GROUP_PATH, files ).archive
+    end
+
+    it "should combine files with same month/year" do
+      files = mock_files( Date.new(2008,03,01), Date.new(2008,03,02) )
+      @archiver.should_receive( :archive ).with( "Mar-2008", files )
+      @grouper.group( GROUP_PATH, files ).archive
+    end
+
+    it "should not combine files with same month, different year" do
+      files = mock_files( Date.new(2008,03,01), Date.new(2009,03,01) )
+      @archiver.should_receive( :archive ).with( "Mar-2008", [files.first] )
+      @archiver.should_receive( :archive ).with( "Mar-2009", [files.last] )
+      @grouper.group( GROUP_PATH, files ).archive
+    end
+
+  end
+
+  def mock_files( *dates )
+    files = []
+    dates.map do |item|
+      month_name = Date::ABBR_MONTHNAMES[item.month]
+      file_name = "file-#{month_name}-#{item.year}.sql"
+      File.stub( :mtime ).with( "#{GROUP_PATH}/#{file_name}" ) { item }
+      files << file_name
+    end
+    return files;
+  end
+
+end

data/spec/pruner_spec.rb

@@ -0,0 +1,206 @@
+require 'prune'
+require 'spec_helper'
+require 'rspec'
+
+describe Prune::Pruner do
+
+  PRUNE_PATH = '/example/prune/folder'
+  subject { Prune::Pruner.new Hash.new }
+
+  before( :each ) do
+    @retention_policy = double( "RetentionPolicy" )
+    @retention_policy.stub( :categories ) { [ Category.new( "Unmatched Files", :retain, true ) ] }
+    Prune::RetentionPolicy.stub( :new ) { @retention_policy }
+  end
+
+  context "w/o prompt" do
+    before( :each ) do
+      subject.options[:prompt]=false
+    end
+
+    it "should not attempt to process folder that does not exist" do
+      File.stub( :exists? ).with( PRUNE_PATH ) { false }
+      Dir.should_not_receive( :foreach )
+      $stdout.should_receive( :write ).with( /ERROR: Cannot find folder/ )
+      subject.prune( PRUNE_PATH )
+    end
+
+    context "with no files" do
+
+      before( :each ) do
+        stub_files
+        stub_messages
+        subject.prune PRUNE_PATH
+      end
+
+      it "should not invoke the retention policy" do
+        @retention_policy.should_not_receive( :categorize )
+      end
+
+      it "should print 'Analyzing #{PRUNE_PATH}'" do
+        @messages.should include("Analyzing '#{PRUNE_PATH}':\n")
+      end
+
+      it "should say no action was required" do
+        @messages.should include("No actions necessary.\n")
+      end
+
+      it "should say no files were analyzed" do
+        @messages.should include_match( /0 file\(s\) analyzed/ )
+      end
+
+    end
+
+    context "with three files" do
+      ONE_DAY = 86400
+
+      before( :each ) do
+        stub_files "beta.txt" => Time.now - ONE_DAY, "alpha.txt" => Time.now - 3*ONE_DAY, "gamma.txt" => Time.now
+        stub_messages
+      end
+
+      it "should categorize each file in modified order" do
+        @retention_policy.should_receive( :categorize ).with( 'alpha.txt' ).ordered
+        @retention_policy.should_receive( :categorize ).with( 'beta.txt' ).ordered
+        @retention_policy.should_receive( :categorize ).with( 'gamma.txt' ).ordered
+        subject.prune PRUNE_PATH
+      end
+
+      it "should say three files were analyzed" do
+        @retention_policy.as_null_object
+        subject.prune PRUNE_PATH
+        @messages.should include_match( /3 file\(s\) analyzed/ )
+      end
+
+    end
+
+    context "with file categorized as :remove" do
+      it "should delete file" do
+        filename = 'delete-me.txt'
+        stub_files filename
+        
+        category = double( category )
+        category.stub( :description ) { "Old" }
+        category.stub( :action ) { :remove }
+        category.stub( :quiet? ) { false }
+        
+        @retention_policy.should_receive( :categorize ).with( filename ) { category }
+        File.should_receive( :delete ).with( File.join( PRUNE_PATH, filename ) )
+        subject.prune PRUNE_PATH
+      end
+    end
+
+    context "with files categorized as :archive" do
+      let!(:files) { [ 'one.tar.gz', 'two.tar.gz', 'three.tar.gz' ] }
+
+      before do
+        subject.options[:archive] = true
+        stub_files files
+      end
+
+      it "should archive files in groups" do
+        category = double( "category" )
+        @retention_policy.stub( :categorize ) { category }
+        category.stub( :action ) { :archive }
+        category.stub( :description ) { "Ancient" }
+        category.stub( :quiet? ) { false }
+        
+        grouper = double( "Grouper" )
+        Prune::Grouper.stub( :new ) { grouper }
+        grouper.should_receive( :group ).with( PRUNE_PATH, files )
+        grouper.should_receive( :archive ) { "2 Archives created." }
+
+        subject.prune PRUNE_PATH
+      end
+    end
+
+  end
+
+  describe "Confirmation Prompt" do
+    before( :each ) do
+      subject.options[:prompt]=false
+    end
+
+    it "should interpret 'Y' as true" do
+      expect_prompt_with_response( "Y\n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret 'Y ' as true" do
+      expect_prompt_with_response("Y \n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret ' Y' as true" do
+      expect_prompt_with_response(" Y\n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret ' Y ' as true" do
+      expect_prompt_with_response(" Y \n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret 'y' as true" do
+      expect_prompt_with_response("y\n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret 'yes' as true" do
+      expect_prompt_with_response("yes\n")
+      subject.prompt.should be_true
+    end
+
+    it "should interpret 'no' as false" do
+      expect_prompt_with_response("no\n")
+      subject.prompt.should be_false
+    end
+
+    it "should interpret 'n' as false" do
+      expect_prompt_with_response("n\n")
+      subject.prompt.should be_false
+    end
+
+    it "should interpret 'N' as false" do
+      expect_prompt_with_response("N\n")
+      subject.prompt.should be_false
+    end
+
+    it "should interpret 'q' as false" do
+      expect_prompt_with_response("q\n")
+      subject.prompt.should be_false
+    end
+
+    def expect_prompt_with_response( response )
+      $stdout.should_receive( :write ).with( /Proceed?/ )
+      STDIN.stub(:gets) { response }
+    end
+
+  end
+
+  def stub_files( files = nil )
+    File.stub( :exists? ).with( PRUNE_PATH ) { true }
+    File.stub( :directory? ).with( PRUNE_PATH ) { true }
+    case files
+    when nil
+      Dir.stub( :entries ).with( PRUNE_PATH ) { Array.new }
+    when String
+      subject.stub(:test).with( ?M, File.join( PRUNE_PATH, files ) ) { Time.now }
+      Dir.stub( :entries ).with( PRUNE_PATH ) { [ files ] }
+    when Array
+      files.each_index { |index| subject.stub(:test).with( ?M, File.join( PRUNE_PATH, files[index] ) ) { index }  }
+      Dir.stub( :entries ).with( PRUNE_PATH ) { files }
+    when Hash
+      files.each_key { |key| subject.stub(:test).with( ?M, File.join( PRUNE_PATH, key ) ) { files[key] } }
+      Dir.stub( :entries ).with( PRUNE_PATH ) { files.keys }
+    else
+      raise "Don't know how to stub files for #{files.class}"
+    end
+  end
+
+  def stub_messages
+    @messages = []
+    $stdout.stub( :write ) { |message| @messages << message  }
+  end
+
+end

data/spec/retention_spec.rb

@@ -0,0 +1,147 @@
+require 'prune/retention'
+require 'prune/category'
+require 'rspec'
+require 'spec/spec_helper'
+
+DAY = 24 * 60 * 60
+
+describe Prune::RetentionPolicy do
+
+  SOURCE_DIR = "source_path"
+  SOURCE_FILE = "source_file"
+  SOURCE_PATH = "#{SOURCE_DIR}/#{SOURCE_FILE}"
+
+  subject { Prune::RetentionPolicy.new SOURCE_DIR }
+
+  describe "default retention policy" do
+    
+    it "should return categories in dsl order" do
+      cats = subject.categories
+      cats.shift.description.should include( "Ignoring directories" )
+      cats.shift.description.should include( "from the Last Two Weeks" )
+      cats.shift.description.should include( "Retaining 'Friday'" )
+      cats.shift.description.should include( "Removing 'Non-Friday'" )
+      cats.shift.description.should include( "Archiving" )
+      cats.should be_empty
+    end
+  
+    describe "analyzing a directory" do
+      let( :dircat ) do
+        File.stub( :directory? ).with( SOURCE_PATH ) { true }
+        File.stub( :mtime ).with( SOURCE_PATH ) { Time.now }
+        subject.categorize( SOURCE_FILE )
+      end
+      
+      
+      it "should be categorized as 'Ignoring directories'" do
+        dircat.description.should eq( "Ignoring directories" )
+      end
+
+      it "should invoke action :ignore" do
+        dircat.action.should eq( :ignore )
+      end
+    end
+
+    describe "analyzing a file" do
+
+      describe "created yesterday" do
+        
+        let( :yestercat ) do
+          File.stub( :directory? ).with( SOURCE_PATH ) { false }
+          File.stub( :mtime ).with( SOURCE_PATH ) { Time.now - DAY }
+          subject.categorize( SOURCE_FILE )
+        end
+
+        it "should be categorized as '... Last Two Weeks'" do
+          yestercat.description.should include( 'Last Two Weeks' )
+        end
+
+        it "should invoke action :retain" do
+          yestercat.action.should eq( :retain )
+        end
+      end
+
+      describe "created three weeks ago, wednesday" do
+
+        let( :weeksago ) do
+          File.stub( :directory? ).with( SOURCE_PATH ) { false }
+          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Wed' ) }
+          subject.categorize( SOURCE_FILE )
+        end
+
+        it "should be described as 'Older than Two Weeks' and 'Non-Friday'" do
+          weeksago.description.should include 'Non-Friday'
+          weeksago.description.should include 'Older than Two Weeks'
+        end
+
+        it "should invoke action :remove" do
+          weeksago.action.should eq( :remove )
+        end
+
+      end
+
+      describe "created three weeks ago, friday" do
+
+        let( :weeksagofriday ) do
+          File.stub( :directory? ).with( SOURCE_PATH ) { false }
+          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Fri' ) }
+          subject.categorize( SOURCE_FILE )
+        end
+
+        it "should be described as 'Friday files', 'Older than Two Weeks'" do
+          weeksagofriday.description.should include( "'Friday' files" )
+          weeksagofriday.description.should include( 'Older than Two Weeks' )
+        end
+
+        it "should invoke action :remove" do
+          weeksagofriday.action.should eq( :retain )
+        end
+
+      end
+
+      describe "created three months ago, friday" do
+
+        let( :oldfriday ) do
+          File.stub( :directory? ).with( SOURCE_PATH ) { false }
+          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Fri' ) }
+          subject.categorize( SOURCE_FILE )
+        end
+
+        it "should be described as 'Older than Two Months'" do
+          oldfriday.description.should include( 'Older than Two Months' )
+        end
+
+        it "should invoke action :archive" do
+          oldfriday.action.should eq( :archive )
+        end
+
+      end
+
+      describe "created three months ago, wednesday" do
+
+        let( :oldwednesday ) do
+          File.stub( :directory? ).with( SOURCE_PATH ) { false }
+          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Wed' ) }
+          subject.categorize( SOURCE_FILE )
+        end
+
+        it "should be described as 'Non-Friday files', 'Older than Two Weeks'" do
+          oldwednesday.description.should include( "'Non-Friday' files" )
+          oldwednesday.description.should include( "Older than Two Weeks" )
+        end
+
+        it "should invoke action :remove" do
+          oldwednesday.action.should eq( :remove )
+        end
+
+      end
+    end
+  end
+
+end
+
+def weeks_ago( weeks, weekday )
+  sub_weeks = Time.now - ( DAY * 7 * weeks )
+  weekday_adjustment = Time.now.wday - Date::ABBR_DAYNAMES.index( weekday )
+  sub_weeks - ( weekday_adjustment * DAY )
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :include_match do |expected|
+  match do |actual|
+     !actual.grep( expected ).empty?
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: geoffreywiseman-prune
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Geoffrey Wiseman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-09 00:00:00 Z
+dependencies: []
+
+description: Prune is meant to analyze a folder full of files, run them against a retention policy and decide which to keep, which to remove and which to archive. It is extensible and embeddable.
+email: geoffrey.wiseman@codiform.com
+executables: 
+- prune
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/prune/archiver.rb
+- lib/prune/category.rb
+- lib/prune/cli.rb
+- lib/prune/default_retention.rb
+- lib/prune/grouper.rb
+- lib/prune/pruner.rb
+- lib/prune/retention.rb
+- lib/prune.rb
+- spec/archiver_spec.rb
+- spec/cli_spec.rb
+- spec/grouper_spec.rb
+- spec/pruner_spec.rb
+- spec/retention_spec.rb
+- spec/spec_helper.rb
+- bin/prune
+- Rakefile
+- README.mdown
+- UNLICENSE
+homepage: http://geoffreywiseman.github.com/prune
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Prunes files from a folder based on a retention policy, often time-based.
+test_files: []
+