cleaner 0.0.1 → 0.0.3

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+coverage
+.rvmrc

data/.rspec

@@ -0,0 +1 @@
+--format documentation

data/Gemfile

@@ -1,4 +1,8 @@
 source "http://rubygems.org"
 
+gem "fakefs", :git => "git://github.com/wijet/fakefs.git"
+gem "guard", :git => "git://github.com/guard/guard.git"
+gem "guard-rspec", :git => "git://github.com/guard/guard-rspec.git"
+
 # Specify your gem's dependencies in cleaner.gemspec
 gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+guard 'rspec', :version => 2, :cli => '--color --format documentation' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/cleaner/(.+)\.rb$})  { |m| "spec/cleaner/#{m[1]}_spec.rb" }
+  watch(%r{^lib/cleaner/actions/(.+)\.rb$}) { |m| "spec/cleaner/actions/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{spec/helpers/.*\.rb})  { "spec" }
+  watch('lib/cleaner.rb') { "rspec" }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mariusz Pietrzyk
+
+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,65 @@
+# Cleaner
+---
+
+Tool for automatic management of directories on your disk with simple DSL.
+
+## Installation
+
+    $ gem install cleaner
+
+## Example configuration file
+
+```ruby
+manage '~/Downloads' do
+  # Move avi's and audio files to right places
+  move :avi, :to => '~/Movies/inbox'
+  move %w(mp3 ogg), :to => '~/Music/inbox'
+
+  # Remove zip files if file without zip extension exists (uncompressed files)
+  delete :zip, :if => proc { |file| File.exists?(file.path_without_ext) }
+
+  # Move all VAT invoices to a special place
+  move :pdf, :if => proc { |file| file.name =~ /VAT/ }, :to => '~/Documents/invoices'
+
+  # You've probably installed it already
+  delete :dmg, :after => 10.hours
+
+  # Delete everything older than 1 month.
+  # Was here for so long? Doesn't deserve to exist!
+  delete :after => 1.month
+end
+```
+
+## Usage
+
+Generate sample configuration file (~/.cleaner.rb)
+
+    $ cleaner init
+
+Run cleaner in the background. By default it will run every 1 hour.
+
+	$ cleaner start
+
+You can specify cleaning interval with "rails like" syntax: 20.minutes, 4.hours, 1.day
+
+	$ cleaner start 4.hours
+
+Stop cleaner daemon
+
+	$ cleaner stop
+
+## Contributions
+
+To fetch & test the library for development, do:
+
+    $ git clone https://github.com/wijet/cleaner
+    $ cd cleaner
+    $ bundle
+    $ bundle exec rspec
+
+If you wont to contribute, please:
+
+  * Fork the project.
+  * Make your feature addition or bug fix.
+  * Add tests for it. This is important so I don't break it in a future version unintentionally.
+  * Send me a pull request on Github.

data/bin/cleaner

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "cleaner"
+require "cleaner/cli"
+Cleaner::CLI.start

data/cleaner.gemspec

@@ -7,9 +7,12 @@ Gem::Specification.new do |s|
   s.version     = Cleaner::VERSION
   s.authors     = ["Mariusz Pietrzyk"]
   s.email       = ["wijet@wijet.pl"]
-  s.homepage    = ""
-  s.summary     = %q{Write a gem summary}
-  s.description = %q{Write a gem description}
+  s.homepage    = "http://github.com/wijet/cleaner"
+  s.summary     = %q{Tool for cleaning up your directories with friendly DSL}
+  s.description = <<desc
+  Cleaner is a small tool which helps you keep your directories clean.
+  With simple DSL you define set of rules, which are then periodically executed against specified directory.
+desc
 
   s.rubyforge_project = "cleaner"
 
@@ -17,4 +20,16 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport", "2.3.14"
+  s.add_dependency "filelist"
+  s.add_dependency "thor"
+  s.add_dependency "daemons"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "timecop"
+  if RUBY_PLATFORM =~ /darwin/
+    s.add_development_dependency "rb-fsevent"
+    s.add_development_dependency "ruby_gntp"
+  end
 end

data/examples/cleaner.rb

@@ -0,0 +1,18 @@
+manage '~/Downloads' do
+  # Move avi's and audio files to right places
+  # move :avi, :to => '~/Movies/inbox'
+  # move %w(mp3 ogg), :to => '~/Music/inbox'
+
+  # Remove zip files if file without zip extension exists (uncompressed files)
+  # delete :zip, :if => proc { |file| File.exists?(file.path_without_ext) }
+
+  # Move all VAT invoices to a special place
+  # move :pdf, :if => proc { |file| file.name =~ /VAT/ }, :to => '~/Documents/invoices'
+
+  # You've probably installed it already
+  # delete :dmg, :after => 10.hours
+
+  # Delete everything older than 1 month.
+  # Was here for so long? Doesn't deserve to exist!
+  # delete :after => 1.month
+end

data/lib/cleaner.rb

@@ -1,5 +1,12 @@
-require "cleaner/version"
+require "active_support/all"
+require "filelist"
 
-module Cleaner
-  # Your code goes here...
-end
+require "cleaner/action"
+require "cleaner/actions/delete"
+require "cleaner/actions/move"
+require "cleaner/actions/copy"
+require "cleaner/file_extension"
+require "cleaner/directory"
+require "cleaner/runner"
+require "cleaner/file_filter"
+require "cleaner/version"

data/lib/cleaner/action.rb

@@ -0,0 +1,17 @@
+module Cleaner
+  class Action
+    attr_reader :files, :options
+
+    def initialize(files, options = {})
+      @files = files
+      @options = options
+    end
+
+    def execute
+      raise NotImplementedException.new("#execute should be implemented in your Action class")
+    end
+
+    class UnknownActionException < Exception; end
+    class NotImplementedException < Exception; end
+  end
+end

data/lib/cleaner/actions/copy.rb

@@ -0,0 +1,13 @@
+require 'fileutils'
+
+module Cleaner
+  module Actions
+    class Copy < Action
+      def execute
+        dest = File.expand_path(options[:to])
+        FileUtils.mkdir_p(dest)
+        FileUtils.cp_r(files, dest)
+      end
+    end
+  end
+end

data/lib/cleaner/actions/delete.rb

@@ -0,0 +1,9 @@
+module Cleaner
+  module Actions
+    class Delete < Action
+      def execute
+        FileUtils.rm(files)
+      end
+    end
+  end
+end

data/lib/cleaner/actions/move.rb

@@ -0,0 +1,11 @@
+module Cleaner
+  module Actions
+    class Move < Action
+      def execute
+        dest = File.expand_path(options[:to])
+        FileUtils.mkdir_p(dest)
+        files.each { |src| FileUtils.mv(src, dest) }
+      end
+    end
+  end
+end

data/lib/cleaner/cli.rb

@@ -0,0 +1,75 @@
+require "thor"
+require "daemons"
+
+module Cleaner
+  class CLI < Thor
+    include Thor::Actions
+    attr_reader :interval
+    source_root("#{File.dirname(__FILE__)}/../../examples")
+
+    desc 'init', 'Create sample config file in ~/.cleaner.rb'
+    def init
+      copy_file "cleaner.rb", "~/.cleaner.rb"
+    end
+
+    desc 'start [INTERVAL]', %q{
+      Start cleaner in background. It cleans directories every 1 hour
+    }
+    def start(interval = "1.hour")
+      @interval = eval(interval)
+      daemon.start
+    end
+
+    desc 'stop', 'Stop cleaner in background'
+    def stop
+      daemon.stop
+    end
+
+    desc 'cleanup', 'Run cleaner ad hoc'
+    def cleanup
+      run_cleaner
+    end
+
+    no_tasks do
+      def daemon
+        group = Daemons::ApplicationGroup.new('cleaner', daemon_options)
+        group.new_application(daemon_options)
+      end
+
+      def daemon_options
+       {
+         :mode     => :proc,
+         :proc     => runner_proc,
+         :dir_mode => :normal,
+         :dir      => "/tmp"
+       }
+      end
+
+      def runner_proc
+        Proc.new do
+          loop do
+            run_cleaner
+            sleep interval
+          end
+        end
+      end
+
+      def run_cleaner
+        cleaner = Cleaner::Runner.new(load_rules)
+        cleaner.start
+      end
+
+      def load_rules
+        File.read(config_file_path)
+      rescue Errno::ENOENT
+        say "Config file #{config_file_path} doesn't exist", :red
+        say "Generate sample config using `cleaner init`", :green
+        exit 1
+      end
+
+      def config_file_path
+        File.expand_path("~/.cleaner.rb")
+      end
+    end
+  end
+end

data/lib/cleaner/directory.rb

@@ -0,0 +1,35 @@
+module Cleaner
+  class Directory
+    attr_reader :path, :block
+
+    def initialize(path, block)
+      @path = path
+      @block = block
+    end
+
+    def clean
+      instance_eval(&block)
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      action_class = construct_action_class(method)
+      # FIXME: refactor this argument parsing
+      options = args.last.is_a?(Hash) ? args.last : {}
+      options = options.merge(
+        :pattern => args.first.is_a?(Hash) ? nil : args.first,
+        :path => path
+      )
+      filter = FileFilter.new(options)
+      action = action_class.new(filter.filterize, options)
+      action.execute
+    end
+
+    def construct_action_class(method)
+      Cleaner::Actions::const_get(method.to_s.capitalize)
+    rescue NameError => e
+      raise Action::UnknownActionException.new("Action '#{method}' is unknown")
+    end
+  end
+end

data/lib/cleaner/file_extension.rb

@@ -0,0 +1,15 @@
+module Cleaner
+  # Provides helper methods for File object which is passed to conditions.
+  # With this module we can write file.name insted of File.basename(file)
+  #
+  module FileExtension
+    def name
+      File.basename(path)
+    end
+
+    def path_without_ext
+      pathname = Pathname.new(path)
+      pathname.sub_ext("").to_s
+    end
+  end
+end

data/lib/cleaner/file_filter.rb

@@ -0,0 +1,58 @@
+module Cleaner
+  class FileFilter
+    CONDITIONS = [:after, :if]
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+      @pattern = options[:pattern]
+    end
+
+    def filterize
+      paths = filter_by_name
+      conditions_provided? ? filter_by_conditions(paths) : paths
+    end
+
+    def search_pattern
+      case @pattern
+        when NilClass; "#{path}/*"
+        when String; "#{path}/#{@pattern}"
+        when Symbol; "#{path}/*.#{@pattern}"
+        when Array; @pattern.map { |ext| "#{path}/*.#{ext}" }
+      end
+    end
+
+    protected
+
+    def filter_by_conditions(paths)
+      paths.select do |path|
+        after_condition?(path) && if_condition?(path)
+      end
+    end
+
+    def conditions_provided?
+      options.keys.any? { |c| CONDITIONS.include?(c) }
+    end
+
+    def after_condition?(path)
+      return true unless options.has_key?(:after)
+      File.ctime(path) < options[:after].ago
+    end
+
+    def if_condition?(path)
+      return true unless options.has_key?(:if)
+      file = File.new(path)
+      file.extend(FileExtension)
+      options[:if].call(file)
+    end
+
+    def path
+      File.expand_path(options[:path])
+    end
+
+    def filter_by_name
+      FileList[search_pattern]
+    end
+  end
+end

data/lib/cleaner/runner.rb

@@ -0,0 +1,21 @@
+module Cleaner
+  class Runner
+    attr_reader :rules, :directories
+
+    def initialize(rules)
+      @rules = rules
+      @directories = []
+    end
+
+    def start
+      instance_eval(rules)
+      directories.each(&:clean)
+    end
+
+    protected
+
+    def manage(path, &block)
+      @directories << Directory.new(path, block)
+    end
+  end
+end

data/lib/cleaner/version.rb

@@ -1,3 +1,3 @@
 module Cleaner
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/spec/cleaner/action_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Cleaner::Action do
+  let(:files) { %w(file1 file2) }
+  let(:options) { {:to => '~/foo'} }
+  let(:action) { Cleaner::Action.new(files, options) }
+
+  describe "being initialized" do
+    it "should have files" do
+      action.files.should be(files)
+    end
+
+    it "should have options" do
+      action.options.should be(options)
+    end
+  end
+
+  describe "#execute" do
+    it "should raise exception" do
+      lambda {
+        action.execute
+      }.should raise_error(Cleaner::Action::NotImplementedException,
+        "#execute should be implemented in your Action class")
+    end
+  end
+end

data/spec/cleaner/actions/copy_spec.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Cleaner::Actions::Copy do
+  before do
+    example_dir '/foo' do
+      %w(a.zip c.zip).each { |name| touch name }
+      touch 'b.txt', :content => 'btext'
+    end
+
+    example_dir '/foo/bar' do
+      touch 'barfile', :content => 'bartext'
+    end
+
+    Dir.chdir('/foo')
+  end
+
+  let(:copy) { Cleaner::Actions::Copy.new(%w(b.txt bar), :to => "/somewhere/dest") }
+
+  context "destination doesn't exist" do
+    it "should create it" do
+      File.exists?("/somewhere/dest").should be_false
+      copy.execute
+      File.exists?("/somewhere/dest").should be_true
+    end
+  end
+
+  it "should copy files to destination" do
+    copy.execute
+    File.read("/somewhere/dest/b.txt").should == "btext"
+  end
+
+  it "should copy directories to destination" do
+    copy.execute
+    File.read("/somewhere/dest/bar/barfile").should == "bartext"
+  end
+
+  it "should leave source files" do
+    copy.execute
+    File.read("/foo/b.txt").should == "btext"
+    File.read("/foo/bar/barfile").should == "bartext"
+  end
+end

data/spec/cleaner/actions/delete_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Cleaner::Actions::Delete do
+  before do
+    example_dir '/foo' do
+      %w(a.zip b.txt c.zip).each { |name| touch name }
+      example_dir '/foo/bar'
+    end
+    Dir.chdir('/foo')
+  end
+
+  let(:delete) { Cleaner::Actions::Delete.new(%w(a.zip c.zip bar)) }
+
+  it "should delete given files and directories" do
+    delete.execute
+    File.exists?('a.zip').should be_false
+    File.exists?('c.zip').should be_false
+    File.exists?('bar').should be_false
+  end
+
+  it "should leave other files" do
+    delete.execute
+    File.exists?('b.txt').should be_true
+  end
+end

data/spec/cleaner/actions/move_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Cleaner::Actions::Move do
+  before do
+    example_dir '/foo' do
+      %w(a.zip b.txt).each { |name| touch name }
+    end
+    Dir.chdir('/foo')
+  end
+
+  let(:move) { Cleaner::Actions::Move.new(%w(a.zip), :to => "~/zip-files") }
+
+  context "destination dir doesn't exist" do
+    it "should create it" do
+      move.execute
+      File.exists?(File.expand_path("~/zip-files")).should be_true
+    end
+  end
+
+  it "should move files" do
+    move.execute
+    File.exists?("a.zip").should be_false
+    File.exists?(File.expand_path("~/zip-files/a.zip")).should be_true
+  end
+
+  it "should leave other files" do
+    move.execute
+    File.exists?("b.txt").should be_true
+  end
+end

data/spec/cleaner/cli_spec.rb

@@ -0,0 +1,115 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "cleaner/cli"
+
+describe Cleaner::CLI do
+  let(:rules) { "manage('~/Downloads') {}" }
+  let(:cli) { Cleaner::CLI.new }
+  before do
+    @home_path = File.expand_path("~")
+    @config_path = File.join(@home_path, ".cleaner.rb")
+    FileUtils.mkdir_p(@home_path)
+    File.open(@config_path, "w") do |file|
+      file << "manage('~/Downloads') {}"
+    end
+    @app = mock(:start => nil)
+  end
+
+  describe "#init" do
+    it "should copy sample config to ~/.cleaner.rb" do
+      cli.should_receive("copy_file").with("cleaner.rb", "~/.cleaner.rb")
+      cli.init
+    end
+  end
+
+  describe "#start" do
+    before do
+      cli.stub(:daemon).and_return(@app)
+    end
+
+    it "should invoke start on daemon" do
+      @app.should_receive(:start)
+      cli.should_receive(:daemon).and_return(@app)
+      cli.start
+    end
+
+    it "should assign and eval time interval" do
+      cli.start
+      cli.interval.should == 1.hour
+    end
+
+    it "should accept custom interval" do
+      cli.start("20.minutes")
+      cli.interval.should == 20.minutes
+    end
+  end
+
+  describe "#stop" do
+    it "should invoke stop on daemon" do
+      @app.should_receive(:stop)
+      cli.should_receive(:daemon).and_return(@app)
+      cli.stop
+    end
+  end
+
+  describe "#cleanup" do
+    it "should invoke run_cleaner" do
+      cli.should_receive(:run_cleaner)
+      cli.cleanup
+    end
+  end
+
+  describe "#run_cleaner" do
+    before do
+      @runner = mock(:start => nil)
+      Cleaner::Runner.stub(:new).and_return(@runner)
+    end
+
+    it "should initialize runner with rules" do
+      Cleaner::Runner.should_receive(:new).with(rules)
+      cli.run_cleaner
+    end
+
+    it "should start the runner" do
+      @runner.should_receive(:start)
+      cli.run_cleaner
+    end
+  end
+
+  describe "#daemon" do
+    it "should construct daemon application" do
+      proc = Proc.new {}
+      cli.stub(:runner_proc).and_return(proc)
+      group = mock
+      options = {:mode => :proc, :proc => proc, :dir_mode => :normal, :dir => "/tmp"}
+      group.should_receive(:new_application).with(options)
+      Daemons::ApplicationGroup.should_receive(:new).with('cleaner', options).and_return(group)
+      cli.daemon
+    end
+  end
+
+  describe "#load_rules" do
+    it "should load config file" do
+      cli.load_rules.should == rules
+    end
+
+    context "on missing file" do
+      before do
+        FileUtils.rm_rf(@config_path)
+        $stdout.stub(:puts)
+      end
+
+      it "should display error message" do
+        $stdout.should_receive(:puts).with("\e[31mConfig file #{@config_path} doesn't exist\e[0m")
+        lambda {
+          cli.load_rules
+        }.should raise_error(SystemExit)
+      end
+
+      it "should exit with 1" do
+        lambda {
+          cli.load_rules
+        }.should raise_error { |error| error.status.should be(1) }
+      end
+    end
+  end
+end

data/spec/cleaner/directory_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Cleaner::Directory do
+  let(:block) do
+    Proc.new do
+      delete :dmg, :after => 10.days
+      delete :download
+      delete :after => 100.days
+    end
+  end
+
+  let(:directory) { Cleaner::Directory.new('~/downloads', block)}
+
+  describe "being initialize" do
+    it "should have path" do
+      directory.path.should == '~/downloads'
+    end
+
+    it "should have block" do
+      directory.block.should == block
+    end
+  end
+
+  describe "#clean" do
+    it "should eval block in its own context" do
+      block = Proc.new {}
+      directory = Cleaner::Directory.new('~/downloads', block)
+      directory.should_receive(:instance_eval).with(&block)
+      directory.clean
+    end
+  end
+
+  describe "#method_missing" do
+    before do
+      @filter = mock(:filterize => %w(file1))
+      Cleaner::FileFilter.stub(:new).and_return(@filter)
+      @action = mock(:execute => true)
+      Cleaner::Actions::Delete.stub(:new).and_return(@action)
+    end
+
+    context "on unknown action" do
+      it "should raise Action::UnknownActionException" do
+        lambda {
+          block = Proc.new { fooooo :txt }
+          directory = Cleaner::Directory.new('~/downloads', block)
+          directory.clean
+        }.should raise_error(Cleaner::Action::UnknownActionException, "Action 'fooooo' is unknown")
+      end
+    end
+
+    it "should initialize FileFilter object" do
+      Cleaner::FileFilter.should_receive(:new).with(
+        :pattern => :dmg,
+        :path => '~/downloads',
+        :after => 10.days
+      )
+      directory.clean
+    end
+
+    it "should initialize action class with files and options" do
+      Cleaner::Actions::Delete.should_receive(:new).with(%w(file1),
+        :pattern => :dmg,
+        :path => '~/downloads',
+        :after => 10.days
+      )
+      directory.clean
+    end
+
+    context "when no pattern is given" do
+      it "should initialize action with nil as pattern" do
+        Cleaner::Actions::Delete.should_receive(:new).with(%w(file1),
+          :pattern => nil,
+          :path => '~/downloads',
+          :after => 100.days
+        )
+        directory.clean
+      end
+    end
+
+    it "should execute action" do
+      @action.should_receive(:execute)
+      directory.clean
+    end
+  end
+end

data/spec/cleaner/file_extension_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Cleaner::FileExtension do
+  before do
+    example_dir '/foo' do
+      touch 'bar.txt'
+    end
+  end
+
+  let(:file) { File.new("/foo/bar.txt").extend(Cleaner::FileExtension) }
+
+  describe "#name" do
+    it "should return file name" do
+      file.name.should == "bar.txt"
+    end
+  end
+
+  describe "#path_without_ext" do
+    it "should return file path name without file extension" do
+      file.path_without_ext.should == "/foo/bar"
+    end
+  end
+end

data/spec/cleaner/file_filter_spec.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Cleaner::FileFilter do
+  before do
+    example_dir '/foo' do
+      touch 'b-0.zip', :mtime => 10.days.ago
+      touch 'b-1.zip', :ctime => 2.days.ago
+      touch 'cc.txt', :ctime => 3.days.ago
+    end
+  end
+
+  def filter(options = {})
+    options = {:path => '/foo', :pattern => :zip}.merge(options)
+    Cleaner::FileFilter.new(options)
+  end
+
+  describe "being initialize" do
+    it "should have options" do
+      filter.options.should == {:path => '/foo', :pattern => :zip}
+    end
+  end
+
+  describe "#filterize" do
+    it "should return files filtered by name" do
+      filter.filterize.should == %w(/foo/b-0.zip /foo/b-1.zip)
+    end
+
+    it "should return files filtered by :after condition (using change time)" do
+      filter(:after => 1.day).filterize.should == %w(/foo/b-1.zip)
+    end
+
+    it "should return files filtered by :if option" do
+      filter(
+        :if => proc { |file| file.name =~ /\w\w\.txt$/ },
+        :pattern => nil
+      ).filterize.should == %w(/foo/cc.txt)
+    end
+
+    it "should return files filtered by two conditions :if and :after" do
+      filter(
+        :after => 1.day,
+        :if => proc { |file| file.name =~ /c/ },
+        :pattern => nil
+      ).filterize.should == %w(/foo/cc.txt)
+    end
+  end
+
+  describe "#search_pattern" do
+    context "when nil given" do
+      it "should use '*' as filename pattern" do
+        filter = Cleaner::FileFilter.new(:path => '/some', :pattern => nil)
+        filter.search_pattern.should == '/some/*'
+      end
+    end
+
+    context "when symbol given" do
+      it "should be used as file extension" do
+        filter.search_pattern.should == '/foo/*.zip'
+      end
+    end
+
+    context "when string given" do
+      it "should be used as filename pattern" do
+        filter = Cleaner::FileFilter.new(:path => '/some', :pattern => 'foo.*')
+        filter.search_pattern.should == '/some/foo.*'
+      end
+    end
+
+    context "when Array given" do
+      it "should use every element as file extension pattern" do
+        filter = Cleaner::FileFilter.new(:path => '/some', :pattern => %w(pdf doc))
+        filter.search_pattern.should == %w(/some/*.pdf /some/*.doc)
+      end
+    end
+  end
+end

data/spec/cleaner/integration_spec.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe "Cleaner: integration spec" do
+  let(:config) do %q{
+    manage '~/Downloads' do
+      delete :if => proc { |file| file.name =~ /secret-\d\.txt/ }
+      move :avi, :to => '~/Movies'
+      delete :zip, :if => proc { |file| File.exists?(file.path_without_ext) }
+      delete :dmg, :after => 5.days
+      delete %w(rar gz)
+      delete :after => 1.month
+    end
+
+    manage '/foo/bar' do
+      copy %w(pdf), :to => '~/Documents'
+      delete "abc.*"
+    end
+  }
+  end
+
+  let(:runner) { Cleaner::Runner.new(config) }
+
+  before do
+    example_dir '~/Downloads' do
+      touch 'Firefox99.dmg', :ctime => 7.days.ago
+      touch 'growl.dmg', :ctime => 2.days.ago
+      touch 'something-old', :ctime => 2.months.ago
+      touch 'lol-cat.avi'
+      touch 'something.rar'
+      touch 'another-thing.gz'
+      touch 'thing.dmg.zip'
+      touch 'thing.dmg'
+      touch 'thing2.zip'
+      2.times do |i|
+        touch "important-#{i}.doc"
+        touch "secret-#{i}.txt"
+      end
+    end
+
+    example_dir '/foo/bar' do
+      %w(abc.txt abc.mp3 ddd.doc doc.pdf).each { |name| touch name }
+    end
+
+    runner.start
+  end
+
+  context "~/Downloads directory" do
+    before { Dir.chdir("~/Downloads") }
+
+    it "should delete :dmg files older than 5 days" do
+      File.exists?("Firefox99.dmg").should be_false
+    end
+
+    it "should leave :dmg files younger than 5 days" do
+      File.exists?("growl.dmg").should be_true
+    end
+
+    it "should leave :doc files" do
+      File.exists?("important-0.doc").should be_true
+      File.exists?("important-1.doc").should be_true
+    end
+
+    it "should delete everything that is older than 1 month" do
+      File.exists?("something-old").should be_false
+    end
+
+    it "should move :avi files to ~/Movies" do
+      file = File.expand_path("~/Movies/lol-cat.avi")
+      File.exists?(file).should be_true
+      File.exists?("lol-cat.avi").should be_false
+    end
+
+    it "shoud remove rar and gz files given as Array of extensions" do
+      File.exists?("something.rar").should be_false
+      File.exists?("another-thing.gz").should be_false
+    end
+
+    it "should delete files by :if condition" do
+      File.exists?("secret-1.txt").should be_false
+      File.exists?("secret-2.txt").should be_false
+    end
+
+    it "should delete zip archives if uncompressed file exist" do
+      # File thing.dmg exists
+      File.exists?("thing.dmg.zip").should be_false
+      # File thing2 doesn't exist
+      File.exists?("thing2.zip").should be_true
+    end
+  end
+
+  context "/foo/bar directory" do
+    before { Dir.chdir("/foo/bar") }
+
+    it "should delete all files maching abc.*" do
+      File.exists?("abc.txt").should be_false
+      File.exists?("abc.mp3").should be_false
+    end
+
+    it "should leave not matching abc.*" do
+      File.exists?("ddd.doc").should be_true
+    end
+
+    it "should copy file to destination" do
+      File.exists?(File.expand_path("~/Documents/doc.pdf")).should be_true
+    end
+  end
+end

data/spec/cleaner/runner_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Cleaner::Runner do
+  let(:rules) do
+    "manage '~/Downloads' do
+     end"
+  end
+  let(:runner) { Cleaner::Runner.new(rules) }
+
+  describe "being initialize" do
+    it "should have rules" do
+      runner.rules.should == rules
+    end
+  end
+
+  describe "#start" do
+    it "should instance eval rules" do
+      runner.should_receive(:instance_eval).with(rules)
+      runner.start
+    end
+
+    it "should run #clean on all directories" do
+      directory = mock
+      directory.should_receive(:clean)
+      runner.stub(:directories).and_return([directory])
+      runner.start
+    end
+  end
+
+  describe "#manage" do
+    it "should initialize new directory" do
+      runner.start
+      directory = runner.directories.first
+      directory.path.should == "~/Downloads"
+    end
+  end
+end

data/spec/helpers/example_dir_helper.rb

@@ -0,0 +1,20 @@
+require 'timecop'
+
+module ExampleDirHelper
+  def example_dir(name, &block)
+    path = File.expand_path(name)
+    FileUtils.mkdir_p(path)
+    Dir.chdir(path) { block.call } if block
+  end
+
+  def touch(name, options = {})
+    options[:mtime] ||= Time.now
+    options[:atime] ||= Time.now
+    options[:ctime] ||= Time.now
+    Timecop.freeze(options[:ctime]) do
+      FileUtils.touch(name)
+    end
+    File.utime(options[:atime], options[:mtime], name)
+    File.open(name, "w") { |f| f << options[:content] } if options[:content]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+SimpleCov.start
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'fakefs/spec_helpers'
+require 'helpers/example_dir_helper'
+require 'cleaner'
+
+RSpec.configure do |config|
+  config.include FakeFS::SpecHelpers
+  config.include ExampleDirHelper
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cleaner
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,151 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-27 00:00:00.000000000Z
-dependencies: []
-description: Write a gem description
+date: 2012-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70196097750240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 2.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: *70196097750240
+- !ruby/object:Gem::Dependency
+  name: filelist
+  requirement: &70196097749820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70196097749820
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70196097749360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70196097749360
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: &70196097748940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70196097748940
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70196097748520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70196097748520
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70196097748100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70196097748100
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70196097747680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70196097747680
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: &70196097747220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70196097747220
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  requirement: &70196097746800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70196097746800
+description: ! "  Cleaner is a small tool which helps you keep your directories clean.\n
+  \ With simple DSL you define set of rules, which are then periodically executed
+  against specified directory.\n"
 email:
 - wijet@wijet.pl
-executables: []
+executables:
+- cleaner
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
+- Guardfile
+- LICENSE
+- README.md
 - Rakefile
+- bin/cleaner
 - cleaner.gemspec
+- examples/cleaner.rb
 - lib/cleaner.rb
+- lib/cleaner/action.rb
+- lib/cleaner/actions/copy.rb
+- lib/cleaner/actions/delete.rb
+- lib/cleaner/actions/move.rb
+- lib/cleaner/cli.rb
+- lib/cleaner/directory.rb
+- lib/cleaner/file_extension.rb
+- lib/cleaner/file_filter.rb
+- lib/cleaner/runner.rb
 - lib/cleaner/version.rb
-homepage: ''
+- spec/cleaner/action_spec.rb
+- spec/cleaner/actions/copy_spec.rb
+- spec/cleaner/actions/delete_spec.rb
+- spec/cleaner/actions/move_spec.rb
+- spec/cleaner/cli_spec.rb
+- spec/cleaner/directory_spec.rb
+- spec/cleaner/file_extension_spec.rb
+- spec/cleaner/file_filter_spec.rb
+- spec/cleaner/integration_spec.rb
+- spec/cleaner/runner_spec.rb
+- spec/helpers/example_dir_helper.rb
+- spec/spec_helper.rb
+homepage: http://github.com/wijet/cleaner
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -47,5 +176,17 @@ rubyforge_project: cleaner
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Write a gem summary
-test_files: []
+summary: Tool for cleaning up your directories with friendly DSL
+test_files:
+- spec/cleaner/action_spec.rb
+- spec/cleaner/actions/copy_spec.rb
+- spec/cleaner/actions/delete_spec.rb
+- spec/cleaner/actions/move_spec.rb
+- spec/cleaner/cli_spec.rb
+- spec/cleaner/directory_spec.rb
+- spec/cleaner/file_extension_spec.rb
+- spec/cleaner/file_filter_spec.rb
+- spec/cleaner/integration_spec.rb
+- spec/cleaner/runner_spec.rb
+- spec/helpers/example_dir_helper.rb
+- spec/spec_helper.rb