backup_organizer 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  # - jruby-18mode # JRuby in 1.8 mode
+  # - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in backup_organizer.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => "--color --format doc" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Thorben Schröder
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.md

@@ -0,0 +1,73 @@
+# BackupOrganizer [![Build Status](https://secure.travis-ci.org/walski/backup_organizer.png)](http://travis-ci.org/walski/backup_organizer)
+
+This gem helps you to keep your backups organized and to let the density of kept files to fade out over time.
+
+The rules of how you want your backups organized are described in a Pattern like this:
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'backup_organizer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install backup_organizer
+
+## Usage
+
+### Scenario
+* You are doing daily backups.
+* The goal is to have a script that you can run daily and that ensures, that
+  * all the backups of the last 30 days are kept
+  * one file per month for the last year is kept
+  * one file per year is kept forever
+  * all other files are deleted
+
+### Solution
+
+#### How it looks like
+
+```ruby
+# Load ActiveSupport to make date wrangling a bit more convenient
+require 'rubygems'
+require 'active_support/core_ext'
+
+# Define the pattern
+BackupOrganizer.organize('/basepath/to/your/backups') do |files|
+  files.stored_in('daily').if {|file| file.age < 30.days}
+
+  files.stored_in('monthly').if do |file|
+    file.age < 1.year && 
+    file.most_recent_in_its_month?
+  end
+
+  files.stored_in('yearly').if {|file| file.most_recent_in_its_year?}
+end
+````
+
+#### What it does
+
+Given that pattern you should drop all your backups in ``/basepath/to/your/backups/daily``. The organizer then does the following:
+
+1. Move all files in ``/basepath/to/your/backups/daily`` which
+  * are not created in the current month
+  
+    to ``/basepath/to/your/backups/monthly``
+  
+2. Move all files in ``/basepath/to/your/backups/monthly`` which
+  * are not created in the current year
+  * are among all the files created in the same month **not** most recent file
+  
+    to ``/basepath/to/your/backups/yearly``
+  
+3. **Delete** (as this is the last rule) all files in ``/basepath/to/your/backups/monthly`` which
+  * are among all the files created in the same year **not** the most recent file
+  
+#### What else?
+
+If you run the script make sure at least the ``/basepath/to/your/backups`` directory exists, the BackupOrganizer will take care of getting everything else in place.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/backup_organizer.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/backup_organizer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Thorben Schröder"]
+  gem.email         = ["stillepost@gmail.com"]
+  gem.description   = %q{Organizes backup files in folders in patterns that can be defined by the user.}
+  gem.summary       = %q{If backups should only be kept around for a certain time and be stored sparsely (weekly, monthly, yearly, whatever) after that backup_organizer can do that for you.}
+  gem.homepage      = "http://github.com/walski/backup_organizer"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "backup_organizer"
+  gem.require_paths = ["lib"]
+  gem.version       = BackupOrganizer::VERSION
+
+  gem.add_development_dependency 'rspec', '>= 2'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'ruby_gntp'
+end

data/lib/backup_organizer.rb

@@ -0,0 +1,22 @@
+require "backup_organizer/version"
+require "backup_organizer/file_age"
+require "backup_organizer/extensions/file_extensions"
+require "backup_organizer/error/base_error"
+Dir[File.expand_path('../backup_organizer/error/**/*.rb', __FILE__)].each {|f| require f}
+require "backup_organizer/file_utils"
+require "backup_organizer/rule"
+require "backup_organizer/pattern"
+require "backup_organizer/configuration"
+require "backup_organizer/setup"
+require "backup_organizer/file_mover"
+
+module BackupOrganizer
+  def self.organize(path)
+    pattern = Pattern.new do |files|
+      yield files
+    end
+    configuration = Configuration.new(:path => path, :pattern => pattern)
+    Setup.create_structure(configuration)
+    configuration.move_all_files
+  end
+end

data/lib/backup_organizer/configuration.rb

@@ -0,0 +1,25 @@
+require "backup_organizer/file_mover"
+
+module BackupOrganizer
+  class Configuration
+    attr_reader :path, :pattern
+    def initialize(options)
+      @path, @pattern = options[:path], options[:pattern]
+
+      raise Error::ConfigurationError.new('No path set') unless @path
+      raise Error::ConfigurationError.new('No pattern set') unless @path
+    end
+
+    def directories
+      pattern.directories.map {|directory| File.expand_path("./#{directory}", @path)}
+    end
+
+    def move_all_files
+      sources = directories
+      destinations = (directories << :delete)[1..-1]
+      sources.each_with_index do |source, i|
+        FileMover.move_files(source, @pattern.rules[i], destinations[i])
+      end
+    end
+  end
+end

data/lib/backup_organizer/error/base_error.rb

@@ -0,0 +1,6 @@
+module BackupOrganizer
+  module Error
+    class BaseError < StandardError
+    end
+  end
+end

data/lib/backup_organizer/error/configuration_error.rb

@@ -0,0 +1,8 @@
+require "backup_organizer/error/error_with_custom_message"
+
+module BackupOrganizer
+  module Error
+    class ConfigurationError < ErrorWithCustomMessage
+    end
+  end
+end

data/lib/backup_organizer/error/error_with_custom_message.rb

@@ -0,0 +1,11 @@
+module BackupOrganizer
+  module Error
+    class ErrorWithCustomMessage < BaseError
+      attr_reader :message
+
+      def initialize(message)
+        @message = message
+      end
+    end
+  end
+end

data/lib/backup_organizer/error/invalid_path_error.rb

@@ -0,0 +1,6 @@
+module BackupOrganizer
+  module Error
+    class InvalidPathError < BaseError
+    end
+  end
+end

data/lib/backup_organizer/error/setup_error.rb

@@ -0,0 +1,8 @@
+require "backup_organizer/error/error_with_custom_message"
+
+module BackupOrganizer
+  module Error
+    class SetupError < ErrorWithCustomMessage
+    end
+  end
+end

data/lib/backup_organizer/extensions/file_extensions.rb

@@ -0,0 +1,66 @@
+require "backup_organizer/file_age"
+require 'backup_organizer/file_utils'
+
+module BackupOrganizer
+  module Extensions
+    module FileExtensions
+      def age
+        FileAge.new(BackupOrganizer::FileUtils.age_of(self))
+      end
+
+      def most_recent_in_its_hour?
+        mtime     = BackupOrganizer::FileUtils.mtime(self)
+        hour      = Time.local(mtime.year, mtime.month, mtime.day, mtime.hour)
+        one_hour  = 60 * 60
+
+        most_recent_in?(hour...(hour + one_hour))
+      end
+
+      def most_recent_in_its_day?
+        mtime     = BackupOrganizer::FileUtils.mtime(self)
+        midnight  = Time.local(mtime.year, mtime.month, mtime.day)
+        one_day   = 24 * 60 * 60
+
+        most_recent_in?(midnight...(midnight + one_day))
+      end
+
+      def most_recent_in_its_week?
+        mtime     = BackupOrganizer::FileUtils.mtime(self)
+        midnight  = Time.local(mtime.year, mtime.month, mtime.day)
+        one_day   = 24 * 60 * 60
+        monday    = midnight - ((midnight.wday - 1) * one_day)
+        monday = monday - (7 * one_day) if midnight.wday == 0
+
+        most_recent_in?(monday...(monday + (7 * one_day)))
+      end
+
+      def most_recent_in_its_month?
+        mtime      = BackupOrganizer::FileUtils.mtime(self)
+        this_month = Time.local(mtime.year, mtime.month, 1)
+        mtime      = this_month + 32.days
+        next_month = Time.local(mtime.year, mtime.month, 1)
+
+        most_recent_in?(this_month...next_month)
+      end
+
+      def most_recent_in_its_year?
+        mtime     = BackupOrganizer::FileUtils.mtime(self)
+        this_year = Time.local(mtime.year, 1, 1)
+        next_year = Time.local(this_year.year + 1, 1, 1)
+
+        most_recent_in?(this_year...next_year)
+      end
+      
+      protected
+      def most_recent_in?(period)
+        dir = File.dirname(self)
+
+        files_in_dir = Dir[File.expand_path('./*', dir)]
+        method = Range.instance_methods.include?(:cover?) ? :cover? : :include?
+        files_this_month = files_in_dir.select {|f| period.send(method, FileUtils.mtime(f))}
+
+        self == files_this_month.sort {|a,b| File.mtime(a) <=> File.mtime(b)}.last
+      end
+    end
+  end
+end

data/lib/backup_organizer/file_age.rb

@@ -0,0 +1,31 @@
+module BackupOrganizer
+  class BasicObject #:nodoc:
+    instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
+  end unless defined?(BasicObject)
+
+  class FileAge < BasicObject
+    include ::Comparable
+
+    def initialize(age)
+      @age = age
+    end
+
+    def <=>(b)
+      b = b.to_f if b.respond_to?(:to_f)
+      @age.<=>(b)
+    end
+
+    def respond_to?(method)
+      @age.respond_to?(method)
+    end
+
+    def is_a?(klass)
+      FileAge == klass || @age.is_a?(klass)
+    end
+    alias :kind_of? :is_a?
+
+    def method_missing(name, *attrs)
+      @age.send(name, *attrs)
+    end
+  end
+end

data/lib/backup_organizer/file_mover.rb

@@ -0,0 +1,18 @@
+require 'backup_organizer/file_utils'
+
+module BackupOrganizer
+  class FileMover
+    def self.move_files(source, rule, destination)
+      Dir[File.expand_path('./*', source)].each do |file|
+        move_file(file, rule, destination)
+      end
+    end
+
+    def self.move_file(file, rule, destination)
+      return if rule.applies_for?(file)
+      return FileUtils.rm_rf(file) if destination == :delete
+
+      FileUtils.mv(file, destination)
+    end
+  end
+end

data/lib/backup_organizer/file_utils.rb

@@ -0,0 +1,27 @@
+module BackupOrganizer
+  class FileUtils
+    def self.mv(from, to)
+      ::FileUtils.mv(from, to)
+    end
+
+    def self.rm_rf(path)
+      ::FileUtils.rm_rf(path)
+    end
+
+    def self.touch(path)
+      ::FileUtils.touch(path)
+    end
+
+    def self.mkdir(path)
+      Dir.mkdir(path)
+    end
+
+    def self.age_of(path)
+      Time.now - mtime(path)
+    end
+
+    def self.mtime(path)
+      File.mtime(path)
+    end
+  end
+end

data/lib/backup_organizer/pattern.rb

@@ -0,0 +1,21 @@
+module BackupOrganizer
+  class Pattern
+    def initialize
+      yield self
+    end
+
+    def stored_in(directory)
+      rule = Rule.new(directory)
+      rules << rule
+      rule
+    end
+
+    def directories
+      rules.map &:directory
+    end
+
+    def rules
+      @rules ||= []
+    end
+  end
+end

data/lib/backup_organizer/rule.rb

@@ -0,0 +1,20 @@
+module BackupOrganizer
+  class Rule
+    def initialize(directory)
+      @directory = directory
+    end
+
+    def if(&rule)
+      @rule = rule
+    end
+
+    def applies_for?(file)
+      file.extend(Extensions::FileExtensions)
+      @rule.call(file)
+    end
+
+    def directory
+      @directory
+    end
+  end
+end

data/lib/backup_organizer/setup.rb

@@ -0,0 +1,16 @@
+require 'backup_organizer/file_utils'
+
+module BackupOrganizer
+  class Setup
+    def self.create_structure(configuration)
+      @configuration = configuration
+      raise Error::InvalidPathError unless File.exist?(@configuration.path) && File.directory?(@configuration.path)
+
+      @configuration.directories.each do |necessary_directory|
+        next if File.directory?(necessary_directory)
+        raise Error::SetupError.new('`#{necessary_directory}` should be a directory but is a file.') if File.exist?(necessary_directory)
+        BackupOrganizer::FileUtils.mkdir(necessary_directory)
+      end
+    end
+  end
+end

data/lib/backup_organizer/version.rb

@@ -0,0 +1,3 @@
+module BackupOrganizer
+  VERSION = "0.0.1"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe BackupOrganizer::Configuration do
+  it "returns the full path to all the directories of it's pattern" do
+    path = Tempdir.new
+    pattern = mock(BackupOrganizer::Pattern, :directories => %w{daily weekly yearly})
+    configuration = BackupOrganizer::Configuration.new(:path => path, :pattern => pattern)
+    configuration.directories.should eq pattern.directories.map {|d| File.expand_path("./#{d}", path)}
+  end
+
+  it "runs the file mover for all rules/destinations" do
+    path = Tempdir.new
+    rule1 = mock(BackupOrganizer::Rule, :path => 'daily')
+    rule2 = mock(BackupOrganizer::Rule, :path => 'weekly')
+    rule3 = mock(BackupOrganizer::Rule, :path => 'yearly')
+    pattern = mock(BackupOrganizer::Pattern, :directories => %w{daily weekly yearly}, :rules => [rule1, rule2, rule3])
+    configuration = BackupOrganizer::Configuration.new(:path => path, :pattern => pattern)
+
+    BackupOrganizer::FileMover.should_receive(:move_files).with(File.expand_path("./#{rule1.path}", path), rule1, File.expand_path("./#{rule2.path}", path)).ordered
+    BackupOrganizer::FileMover.should_receive(:move_files).with(File.expand_path("./#{rule2.path}", path), rule2, File.expand_path("./#{rule3.path}", path)).ordered
+    BackupOrganizer::FileMover.should_receive(:move_files).with(File.expand_path("./#{rule3.path}", path), rule3, :delete).ordered
+
+    configuration.move_all_files
+  end
+end

data/spec/extensions/file_extensions_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+def check_expectations(expectations, method)
+  dir = Tempdir.new
+  files = []
+
+  # Create all the files first
+  expectations.each do |date, expectation|
+    path = temp_file_at(date, dir).extend(BackupOrganizer::Extensions::FileExtensions)
+    files << [date, path, expectation]
+  end
+
+  # Check for the expectations
+  files.each do |date, path, expectation|
+    path.send(method).should be(expectation), "File with mtime of #{date} should return #{expectation} to #{method} but didn't"
+  end
+end
+
+describe BackupOrganizer::Extensions::FileExtensions do
+  it "can tell a file's age" do
+    file = '/tmp/some/path'
+    file.extend BackupOrganizer::Extensions::FileExtensions
+    BackupOrganizer::FileUtils.should_receive(:age_of).with(file).and_return(1.234)
+    age = file.age
+    age.kind_of?(BackupOrganizer::FileAge).should be true
+    age.should eq 1.234
+  end
+
+  it "can tell if a file is the most recent one in the same hour of it's last modification (mtime)" do
+    time = Time.now
+
+    first_of_this_hour = Time.local(time.year, time.month, time.day, time.hour)
+    last_of_last_hours = first_of_this_hour - 1
+    mid_of_this_hour   = first_of_this_hour + 30.minutes
+    first_of_next_hour = first_of_this_hour + 1.hour
+    
+    expectations = {
+      first_of_this_hour => false,
+      last_of_last_hours => true,
+      mid_of_this_hour => true,
+      first_of_next_hour => true
+    }
+
+    check_expectations(expectations, :most_recent_in_its_hour?)
+  end
+
+  it "can tell if a file is the most recent one in the same day of it's last modification (mtime)" do
+    time = Time.now
+
+    midnight = Time.local(time.year, time.month, time.day)
+    
+    first_of_this_day  = midnight
+    last_of_last_day   = first_of_this_day - 1
+    mid_of_this_day    = first_of_this_day + 12.hours
+    first_of_next_day  = first_of_this_day + 24.hours
+    
+    expectations = {
+      first_of_this_day => false,
+      last_of_last_day => true,
+      mid_of_this_day => true,
+      first_of_next_day => true
+    }
+
+    check_expectations(expectations, :most_recent_in_its_day?)
+  end
+
+  it "can tell if a file is the most recent one in the same week of it's last modification (mtime)" do
+    time = Time.now
+
+    midnight = Time.local(time.year, time.month, time.day)
+    first_of_this_week  = midnight - (midnight.wday - 1).days
+    first_of_this_week -= 7.days if midnight.wday == 0
+    last_of_last_week   = first_of_this_week - 1
+    mid_of_this_week    = first_of_this_week + 3.days
+    first_of_next_week  = first_of_this_week + 7.days
+    
+    expectations = {
+      first_of_this_week => false,
+      last_of_last_week => true,
+      mid_of_this_week => true,
+      first_of_next_week => true
+    }
+
+    check_expectations(expectations, :most_recent_in_its_week?)
+  end
+
+  it "can tell if a file is the most recent one in the same month of it's last modification (mtime)" do
+    time = Time.now
+
+    first_of_this_month = Time.local(time.year, time.month, 1)
+    last_of_last_month  = first_of_this_month - 1
+    mid_of_this_month   = first_of_this_month + 15.days
+    next_month          = (first_of_this_month + 32.days)
+    first_of_next_month = Time.local(next_month.year, next_month.month, 1)
+    
+    expectations = {
+      first_of_this_month => false,
+      last_of_last_month => true,
+      mid_of_this_month => true,
+      first_of_next_month => true
+    }
+
+    check_expectations(expectations, :most_recent_in_its_month?)
+  end
+
+  it "can tell if a file is the most recent one in the same year of it's last modification (mtime)" do
+    time = Time.now
+
+    first_of_this_year = Time.local(time.year, 1, 1)
+    last_of_last_year  = first_of_this_year - 1    
+    mid_of_this_year   = first_of_this_year + 180.days
+    first_of_next_year = Time.local(first_of_this_year.year + 1, 1, 1)
+    
+    expectations = {
+      first_of_this_year => false,
+      last_of_last_year => true,
+      mid_of_this_year => true,
+      first_of_next_year => true
+    }
+
+    check_expectations(expectations, :most_recent_in_its_year?)
+  end
+end

data/spec/file_age_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe BackupOrganizer::FileAge do
+  it "can be compared with Time" do
+    age = BackupOrganizer::FileAge.new(Time.now - 2.days)
+    age.should < (Time.now - 1.day)
+    age.should_not > (Time.now - 1.day)
+    age.should > (Time.now - 3.days)
+    age.should_not < (Time.now - 3.days)
+  end
+end

data/spec/file_mover_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe BackupOrganizer::FileMover do
+  describe "moving a single file to a destination" do
+    before do
+      @destination = Tempdir.new
+      @path = Tempfile.new('backup_organizer_file').path
+      @expected_path = File.expand_path("./#{File.basename(@path)}", @destination)
+      File.exist?(@path).should be true
+      File.exist?(@expected_path).should be false
+    end
+
+    it "is not carried out when the rule applies" do
+      rule = mock(BackupOrganizer::Rule, :applies_for? => true)
+      BackupOrganizer::FileMover.move_file(@path, rule, @destination)
+      File.exist?(@path).should be true
+      File.exist?(@expected_path).should be false
+    end
+
+    it "is carried out when the does not rule applies" do
+      rule = mock(BackupOrganizer::Rule, :applies_for? => false)
+      BackupOrganizer::FileMover.move_file(@path, rule, @destination)
+      File.exist?(@path).should be false
+      File.exist?(@expected_path).should be true
+    end
+
+    it "deletes the file if the destination is :delete" do
+      rule = mock(BackupOrganizer::Rule, :applies_for? => false)
+      BackupOrganizer::FileMover.move_file(@path, rule, :delete)
+      File.exist?(@path).should be false
+      File.exist?(@expected_path).should be false
+    end
+  end
+  
+  it "moves all files in a directory that match a rule" do
+    directory = Tempdir.new
+    %w{some test-1 files with different-1 looks}.each {|f| BackupOrganizer::FileUtils.touch(File.expand_path("./#{f}", directory))}
+    rule = mock(BackupOrganizer::Rule)
+    def rule.applies_for?(file)
+      file !~ /-1$/
+    end
+    destination = Tempdir.new
+
+    BackupOrganizer::FileMover.move_files(directory, rule, destination)
+
+    File.exist?(File.expand_path("./some", directory)       ).should be true
+    File.exist?(File.expand_path("./files", directory)      ).should be true
+    File.exist?(File.expand_path("./with", directory)       ).should be true
+    File.exist?(File.expand_path("./looks", directory)      ).should be true
+    File.exist?(File.expand_path("./test-1", directory)     ).should be false
+    File.exist?(File.expand_path("./different-1", directory)).should be false
+
+    File.exist?(File.expand_path("./some", destination)       ).should be false
+    File.exist?(File.expand_path("./files", destination)      ).should be false
+    File.exist?(File.expand_path("./with", destination)       ).should be false
+    File.exist?(File.expand_path("./looks", destination)      ).should be false
+    File.exist?(File.expand_path("./test-1", destination)     ).should be true
+    File.exist?(File.expand_path("./different-1", destination)).should be true
+  end
+end

data/spec/file_utils_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe BackupOrganizer::FileUtils do
+  it "knows the age of a file" do
+    path = temp_file_at(Time.now - 3.days)
+    BackupOrganizer::FileUtils.age_of(path).should be_within(1).of(3.days)
+    path = temp_file_at(Time.now - 99.days)
+    BackupOrganizer::FileUtils.age_of(path).should be_within(1).of(99.days)
+    path = temp_file_at(Time.now - 17.years)
+    BackupOrganizer::FileUtils.age_of(path).should be_within(1).of(17.years)
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'find'
+
+def include_files(dir_name, actual, expected, expectation)
+  expected.each do |file|
+    basename = File.basename(file)
+    actual.include?(basename).should be(expectation), "#{dir_name} should#{expectation ? '' : ' not'} include #{basename} but does #{expectation ? 'not' : ''}."
+  end
+end
+
+describe "integration of the whole system" do
+  before do
+    @now = Time.local(Time.now.year, 12, 30) 
+    Time.stub(:now).and_return(@now)
+
+    @base_path = Tempdir.new
+    @daily_destination   = File.expand_path("./daily", @base_path)
+    @monthly_destination = File.expand_path("./monthly", @base_path)
+    @yearly_destination  = File.expand_path("./yearly", @base_path)
+    BackupOrganizer::FileUtils.mkdir(@daily_destination)
+    BackupOrganizer::FileUtils.mkdir(@yearly_destination)
+
+    @file_01_day_ago             = temp_file_at(Time.now - 1.day + 2,                         @daily_destination)
+    @file_04_days_ago            = temp_file_at(Time.now - 10.days + 2,                       @yearly_destination)
+    @file_10_days_ago            = temp_file_at(Time.now - 10.days + 2,                       @daily_destination)
+    @file_30_days_ago            = temp_file_at(Time.now - 30.days + 2,                       @daily_destination)
+    @file_31_days_ago            = temp_file_at(Time.now - 31.days + 2,                       @daily_destination)
+    @file_02_month_ago           = temp_file_at(Time.now - 60.days + 2,                       @daily_destination)
+    @file_02_month_and_a_bit_ago = temp_file_at(Time.now - 65.days + 2,                       @daily_destination)
+    @file_06_month_ago           = temp_file_at(Time.now - 180.days + 2,                      @daily_destination)
+    @file_07_month_ago           = temp_file_at(Time.now - 240.days + 2,                      @yearly_destination)
+    @file_365_days_ago           = temp_file_at(Time.now - 365.days + 2,                      @daily_destination)
+    @file_366_days_ago           = temp_file_at(Time.now - 366.days + 2,                      @daily_destination)
+    time_366_days_ago = Time.now - 366.days                                               
+    @file_a_year_and_a_bit_ago   = temp_file_at(Time.local(time_366_days_ago.year, 1, 1) + 2, @daily_destination)
+    @file_three_years_ago        = temp_file_at(Time.now - 3.years + 2,                       @yearly_destination)
+    @file_ten_years_ago          = temp_file_at(Time.now - 10.years + 2,                      @yearly_destination)
+  end
+
+  after do
+    Time.unstub(:now)
+    BackupOrganizer::FileUtils.rm_rf @base_path
+  end
+
+  it "works fine" do
+    BackupOrganizer.organize(@base_path) do |files|
+      files.stored_in('daily').if {|file| file.age < 30.days}
+
+      files.stored_in('monthly').if do |file|
+        file.age < 1.year && 
+        file.most_recent_in_its_month?
+      end
+
+      files.stored_in('yearly').if {|file| file.most_recent_in_its_year?}
+    end
+
+    expected_in_daily = [
+       @file_01_day_ago,
+       @file_10_days_ago,
+       @file_30_days_ago
+    ]
+    
+    expected_in_monthly = [
+      @file_31_days_ago,
+      @file_02_month_ago,
+      @file_06_month_ago,
+      @file_365_days_ago
+    ]
+
+    expected_in_yearly = [
+      @file_04_days_ago,
+      @file_366_days_ago,
+      @file_three_years_ago,
+      @file_ten_years_ago
+    ]
+
+    expected_deleted = [
+      @file_07_month_ago,
+      @file_a_year_and_a_bit_ago,      
+      @file_02_month_and_a_bit_ago
+    ]
+
+    dailies   = files_in(File.expand_path('./daily', @base_path))
+    monthlies = files_in(File.expand_path('./monthly', @base_path))
+    yearlies  = files_in(File.expand_path('./yearly', @base_path))
+
+    include_files(:dailies, dailies, expected_in_daily, true)
+    include_files(:dailies, dailies, expected_in_monthly + expected_in_yearly + expected_deleted, false)
+
+    include_files(:monthlies, monthlies, expected_in_monthly, true)
+    include_files(:monthlies, monthlies, expected_in_daily + expected_in_yearly + expected_deleted, false)
+
+    include_files(:yearlies, yearlies, expected_in_yearly, true)
+    include_files(:yearlies, yearlies, expected_in_daily + expected_in_monthly + expected_deleted, false)
+  end
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe BackupOrganizer::Pattern do
+  subject {
+    BackupOrganizer::Pattern.new do |files|
+      files.stored_in('daily' ).if {|f| true}
+      files.stored_in('weekly').if {|f| true}
+      files.stored_in('yearly').if {|f| true}
+    end
+  }
+
+  it "can list all directories it needs" do
+    subject.directories.should eq %w{daily weekly yearly}
+  end
+end

data/spec/rule_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe BackupOrganizer::Rule do
+  subject {BackupOrganizer::Rule.new('/tmp/dir')}
+
+  it "knows it's directory" do
+    subject.directory.should eq '/tmp/dir'
+  end
+
+  it "can tell if the rule apply to a certain file" do
+    subject.if {|f| f.applies}
+
+    file = mock(File, :applies => false)
+    subject.applies_for?(file).should be false
+
+    file = mock(File, :applies => true)
+    subject.applies_for?(file).should be true
+  end
+
+  it "mixes the FileExtensions in to each yielded path" do
+    subject.if{|f| (class << f; self; end).included_modules.include?(BackupOrganizer::Extensions::FileExtensions).should be true}
+    file = mock(File, :applies => true)
+    subject.applies_for?(file)
+  end
+end

data/spec/setup_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe BackupOrganizer::Setup do
+  before do
+    path = Tempdir.new
+    @configuration = mock(BackupOrganizer::Configuration, :path => path, :directories => %w{daily weekly yearly}.map {|e| File.expand_path("./#{e}", path)})
+  end
+
+  describe "creating the structure" do
+    describe "raises an error when" do
+      it "the path is not a directory" do
+        file = Tempfile.new('backup_organizer_fake_dir')
+        path = file.path
+        @configuration.stub(:path).and_return(path)
+        file.unlink
+        lambda {
+          BackupOrganizer::Setup.create_structure(@configuration)
+        }.should raise_error(BackupOrganizer::Error::InvalidPathError)
+      end
+
+      it "the path is a file" do
+        file = Tempfile.new('backup_organizer_fake_dir')
+        path = file.path
+        @configuration.stub(:path).and_return(path)
+        lambda {
+          BackupOrganizer::Setup.create_structure(@configuration)
+        }.should raise_error(BackupOrganizer::Error::InvalidPathError)
+        file.unlink
+      end
+    end
+
+    it "results in having all the needed directories present" do
+      BackupOrganizer::Setup.create_structure(@configuration)
+      @configuration.directories.each do |necessary_directory|
+        File.directory?(necessary_directory).should be true
+      end
+    end
+
+    it "leaves an existing structure intact" do
+      BackupOrganizer::Setup.create_structure(@configuration)
+      files = %w{some test files}
+      require 'backup_organizer/file_utils'
+      @configuration.directories.each do |directory|
+        files.each do |file|
+          BackupOrganizer::FileUtils.touch(File.expand_path("./#{file}", directory))
+        end
+      end
+
+      BackupOrganizer::Setup.create_structure(@configuration)
+
+      @configuration.directories.each do |directory|
+        files.each do |file|
+          File.exist?(File.expand_path("./#{file}", directory)).should be true
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+Bundler.require
+
+require 'backup_organizer'
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+end

data/spec/support/helpers.rb

@@ -0,0 +1,43 @@
+def temp_file_at(time, destination = nil)
+  path = Tempfile.new('backup_organizer_integration_spec').path
+  File.utime(time, time, path)
+  if destination
+    BackupOrganizer::FileUtils.mv path, destination
+    File.expand_path("./#{File.basename(path)}", destination)
+  else
+    path
+  end
+end
+
+def files_in(path)
+  path = "#{File.expand_path('./', path)}/"
+  files = []
+  Find.find(path) {|file| files << file.gsub(/^#{Regexp.escape(path)}/, '')}
+  files.select {|e| !e.empty?}
+end
+
+class Fixnum
+  def minutes
+    self * 60
+  end
+  alias minute minutes
+  
+  def hours
+    self * 60.minutes
+  end
+  alias hour hours
+  
+  def days
+    self * 24.hours
+  end
+  alias day days
+
+  def years
+    self * 365.days
+  end
+  alias year years
+
+  def ago
+    Time.now - self
+  end
+end

data/spec/support/temp_dir.rb

@@ -0,0 +1,12 @@
+require 'tempfile'
+require 'backup_organizer/file_utils'
+
+class Tempdir
+  def self.new
+    file = Tempfile.new("backup_spec_temp_dir")
+    path = file.path
+    file.unlink
+    BackupOrganizer::FileUtils.mkdir(path)
+    path
+  end
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification 
+name: backup_organizer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Thorben Schr\xC3\xB6der"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-24 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ruby_gntp
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Organizes backup files in folders in patterns that can be defined by the user.
+email: 
+- stillepost@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- backup_organizer.gemspec
+- lib/backup_organizer.rb
+- lib/backup_organizer/configuration.rb
+- lib/backup_organizer/error/base_error.rb
+- lib/backup_organizer/error/configuration_error.rb
+- lib/backup_organizer/error/error_with_custom_message.rb
+- lib/backup_organizer/error/invalid_path_error.rb
+- lib/backup_organizer/error/setup_error.rb
+- lib/backup_organizer/extensions/file_extensions.rb
+- lib/backup_organizer/file_age.rb
+- lib/backup_organizer/file_mover.rb
+- lib/backup_organizer/file_utils.rb
+- lib/backup_organizer/pattern.rb
+- lib/backup_organizer/rule.rb
+- lib/backup_organizer/setup.rb
+- lib/backup_organizer/version.rb
+- spec/configuration_spec.rb
+- spec/extensions/file_extensions_spec.rb
+- spec/file_age_spec.rb
+- spec/file_mover_spec.rb
+- spec/file_utils_spec.rb
+- spec/integration_spec.rb
+- spec/pattern_spec.rb
+- spec/rule_spec.rb
+- spec/setup_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- spec/support/temp_dir.rb
+homepage: http://github.com/walski/backup_organizer
+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: If backups should only be kept around for a certain time and be stored sparsely (weekly, monthly, yearly, whatever) after that backup_organizer can do that for you.
+test_files: 
+- spec/configuration_spec.rb
+- spec/extensions/file_extensions_spec.rb
+- spec/file_age_spec.rb
+- spec/file_mover_spec.rb
+- spec/file_utils_spec.rb
+- spec/integration_spec.rb
+- spec/pattern_spec.rb
+- spec/rule_spec.rb
+- spec/setup_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- spec/support/temp_dir.rb