maid 0.1.0.beta1

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rspec/core/rake_task'
+require 'bundler'
+
+task :default => :spec
+
+Bundler::GemHelper.install_tasks
+
+Rake::RDocTask.new do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.main = 'README.rdoc'
+  rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb')  
+end
+
+RSpec::Core::RakeTask.new(:spec)

data/bin/maid

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'maid'
+
+Maid::App.start

data/lib/maid.rb

@@ -0,0 +1,31 @@
+module Maid
+  autoload :App, 'maid/app'
+  autoload :Maid, 'maid/maid'
+  autoload :Tools, 'maid/tools'
+  autoload :NumericExtensions, 'maid/numeric_extensions'
+  autoload :Rule, 'maid/rule'
+  autoload :VERSION, 'maid/version'
+
+  class << self
+    # Execute the block with the Maid instance set to <tt>instance</tt>.
+    def with_instance(instance)
+      @instance = instance
+      result = yield
+      @instance = nil
+      result
+    end
+
+    # Define rules for the Maid instance.
+    def rules(&block)
+      @instance.instance_eval(&block)
+    end
+  end
+end
+
+class Numeric
+  include Maid::NumericExtensions
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Maid::App.start
+end

data/lib/maid/app.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'thor'
+
+class Maid::App < Thor
+  default_task 'clean'
+
+  desc 'clean', 'Clean based on rules'
+  method_option :rules,  :type => :string,  :aliases => %w[-r]
+  method_option :noop,   :type => :boolean, :aliases => %w[-n --dry-run]
+  method_option :silent, :type => :boolean, :aliases => %w[-s]
+  def clean
+    maid = Maid::Maid.new(maid_options(options))
+    say "Logging actions to #{maid.log_path.inspect}" unless options.silent? || options.noop?
+    maid.clean
+  end
+
+  desc 'version', 'print version number'
+  def version
+    say Maid::VERSION
+  end
+
+  no_tasks do
+    def maid_options(options)
+      h = {}
+
+      if options['noop']
+        # You're testing, so a simple log goes to STDOUT and no actions are taken
+        h[:file_options] = {:noop => true}
+        h[:log_path] = STDOUT
+        h[:log_formatter] = lambda { |_, _, _, msg| "#{msg}\n" }
+      end
+
+      if options['rules']
+        h[:rules_path] = options['rules']
+      end
+
+      h
+    end
+  end
+end

data/lib/maid/maid.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+require 'logger'
+
+# Maid cleans up according to the given rules, logging what it does.
+class Maid::Maid
+  DEFAULTS = {
+    :progname   => 'Maid',
+    :log_path   => File.expand_path('~/.maid/maid.log'),
+    :rules_path => File.expand_path('~/.maid/rules.rb'),
+    :trash_path => File.expand_path('~/.Trash'),
+    :file_options => {:noop => true}, # for FileUtils
+  }.freeze
+
+  include ::Maid::Tools
+  attr_reader :file_options, :log_path, :rules, :rules_path, :trash_path
+
+  # Make a new Maid, setting up paths for the log and trash.
+  # 
+  # Sane defaults for a log and trash path are set for Mac OS X, but they can easily be overridden like so:
+  # 
+  #   Maid::Maid.new(:log_path => '/home/username/log/maid.log', :trash_path => '/home/username/.local/share/Trash/files/')
+  # 
+  def initialize(options = {})
+    options = DEFAULTS.merge(options.reject { |k, v| v.nil? })
+
+    @log_path = options[:log_path]
+    FileUtils.mkdir_p(File.dirname(@log_path)) unless @log_path.kind_of?(IO)
+    @logger = Logger.new(@log_path)
+    @logger.progname = options[:progname]
+    @logger.formatter = options[:log_formatter] if options[:log_formatter]
+
+    @rules_path = options[:rules_path]
+    @trash_path = options[:trash_path]
+    @file_options = options[:file_options]
+
+    @rules = []
+  end
+  
+  # Start cleaning, based on the rules defined at rules_path.
+  def clean
+    @logger.info 'Started'
+    add_rules(@rules_path)
+    follow_rules
+    @logger.info 'Finished'
+  end
+
+  # Add the rules at path.
+  def add_rules(path)
+    Maid.with_instance(self) do
+      # Using 'Kernel' here to help with testability
+      Kernel.require(path)
+    end
+  end
+
+  # Register a rule with a description and instructions (lambda function).
+  def rule(description, &instructions)
+    @rules << ::Maid::Rule.new(description, instructions)
+  end
+
+  # Follow all registered rules.
+  def follow_rules
+    @rules.each do |rule|
+      @logger.info("Rule: #{rule.description}")
+      rule.follow
+    end
+  end
+end

data/lib/maid/numeric_extensions.rb

@@ -0,0 +1,76 @@
+# From https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/numeric/time.rb, with some modifications since active_support ruins Logger by overriding its functionality.
+module Maid::NumericExtensions
+  # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+  #
+  # These methods use Time#advance for precise date calculations when using from_now, ago, etc.
+  # as well as adding or subtracting their results from a Time object. For example:
+  #
+  #   # equivalent to Time.now.advance(:months => 1)
+  #   1.month.from_now
+  #
+  #   # equivalent to Time.now.advance(:years => 2)
+  #   2.years.from_now
+  #
+  #   # equivalent to Time.now.advance(:months => 4, :years => 5)
+  #   (4.months + 5.years).from_now
+  #
+  # While these methods provide precise calculation when used as in the examples above, care
+  # should be taken to note that this is not true if the result of `months', `years', etc is
+  # converted before use:
+  #
+  #   # equivalent to 30.days.to_i.from_now
+  #   1.month.to_i.from_now
+  #
+  #   # equivalent to 365.25.days.to_f.from_now
+  #   1.year.to_f.from_now
+  #
+  # In such cases, Ruby's core
+  # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and
+  # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+  # date and time arithmetic
+  def seconds
+    self
+  end
+  alias :second :seconds
+
+  def minutes
+    self * 60
+  end
+  alias :minute :minutes
+
+  def hours
+    self * 3600
+  end
+  alias :hour :hours
+
+  def days
+    self * 24.hours
+  end
+  alias :day :days
+
+  def weeks
+    self * 7.days
+  end
+  alias :week :weeks
+
+  def fortnights
+    self * 2.weeks
+  end
+  alias :fortnight :fortnights
+
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
+
+  # Reads best with argument:  10.minutes.until(time)
+  alias :until :ago
+
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
+  end
+
+  # Reads best without arguments:  10.minutes.from_now
+  alias :from_now :since
+end

data/lib/maid/rule.rb

@@ -0,0 +1,6 @@
+class Maid::Rule < Struct.new(:description, :instructions)
+  # Follow the instructions of the rule.
+  def follow
+    instructions.call
+  end
+end

data/lib/maid/tools.rb

@@ -0,0 +1,119 @@
+require 'fileutils'
+require 'find'
+require 'time'
+
+# Collection of utility methods included in Maid::Maid (and thus available in the rules DSL).
+#
+# In general, all paths are automatically expanded (e.g. '~/Downloads/foo.zip' becomes '/home/username/Downloads/foo.zip').
+module Maid::Tools
+  # Move from <tt>from</tt> to <tt>to</tt>.
+  #
+  # The path is not moved if a file already exists at the destination with the same name.  A warning is logged instead.
+  #
+  # This method delegates to FileUtils.  The instance-level <tt>file_options</tt> hash is passed to control the <tt>:noop</tt> option.
+  #
+  #   move('~/Downloads/foo.zip', '~/Archive/Software/Mac OS X/')
+  def move(from, to)
+    from = File.expand_path(from)
+    to = File.expand_path(to)
+    target = File.join(to, File.basename(from))
+
+    unless File.exist?(target)
+      @logger.info "mv #{from.inspect} #{to.inspect}"
+      FileUtils.mv(from, to, @file_options)
+    else
+      @logger.warn "skipping #{from.inspect} because #{target.inspect} already exists"
+    end
+  end
+
+  # Move the given path to the trash (as set by <tt>trash_path</tt>).
+  #
+  # The path is moved if a file already exists in the trash with the same name.  However, the current date and time is appended to the filename.
+  #
+  #   trash('~/Downloads/foo.zip')
+  def trash(path)
+    target = File.join(@trash_path, File.basename(path))
+    safe_trash_path = File.join(@trash_path, "#{File.basename(path)} #{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}")
+
+    if File.exist?(target)
+      move(path, safe_trash_path)
+    else
+      move(path, @trash_path)
+    end
+  end
+
+  # Give all files matching the given glob.
+  #
+  # Delgates to Dir.
+  #
+  #   dir('~/Downloads/*.zip')
+  def dir(glob)
+    Dir[File.expand_path(glob)]
+  end
+
+  # Find matching files, akin to the Unix utility <tt>find</tt>.
+  #
+  # Delegates to Find.find.
+  #
+  #   find '~/Downloads/' do |path|
+  #     # ...
+  #   end
+  def find(path, &block)
+    Find.find(File.expand_path(path), &block)
+  end
+
+  # Run a shell command.
+  #
+  # Delegates to Kernel.`.  Made primarily for testing other commands.
+  def cmd(command) #:nodoc:
+    %x(#{command})
+  end
+
+  # Use Spotlight metadata to determine the site from which a file was downloaded.
+  #
+  #   downloaded_from('foo.zip') # => ['http://www.site.com/foo.zip', 'http://www.site.com/']
+  def downloaded_from(path)
+    raw = cmd("mdls -raw -name kMDItemWhereFroms #{path.inspect}")
+    clean = raw[1, raw.length - 2]
+    clean.split(/,\s+/).map { |s| t = s.strip; t[1, t.length - 2] }
+  end
+
+  # Use Spotlight metadata to determine audio length.
+  #
+  #   duration_s('foo.mp3') # => 235.705
+  def duration_s(path)
+    cmd("mdls -raw -name kMDItemDurationSeconds #{path.inspect}").to_f
+  end
+
+  # Use Spotlight to locate all files matching the given filename
+  #
+  #   locate('foo.zip') # => ['/a/foo.zip', '/b/foo.zip']
+  def locate(name)
+    cmd("mdfind -name #{name.inspect}").split("\n")
+  end
+
+  # Inspect the contents of a .zip file.
+  #
+  #   zipfile_contents('foo.zip') # => ['foo/foo.exe', 'foo/README.txt']
+  def zipfile_contents(path)
+    raw = cmd("unzip -Z1 #{path.inspect}")
+    raw.split("\n")
+  end
+
+  # Calculate disk usage of a given path.
+  #
+  #   disk_usage('foo.zip') # => 136
+  def disk_usage(path)
+    raw = cmd("du -s #{path.inspect}")
+    raw.split(/\s+/).first.to_i
+  end
+
+  # Pulls and pushes the given git repository.
+  #
+  #   git_piston('~/code/projectname')
+  def git_piston(path)
+    full_path = File.expand_path(path)
+    stdout = cmd("cd #{full_path.inspect} && git pull && git push 2>&1")
+    @logger.info "Fired piston on #{full_path.inspect}.  STDOUT:\n\n#{stdout}"
+  end
+end

data/lib/maid/version.rb

@@ -0,0 +1,3 @@
+module Maid
+  VERSION = "0.1.0.beta1"
+end

data/maid.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "maid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "maid"
+  s.version     = Maid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Benjamin Oakes"]
+  s.email       = ["hello@benjaminoakes.com"]
+  s.homepage    = "http://www.benjaminoakes.com/"
+  s.summary     = %q{Maid cleans up after you, based on rules you define.}
+  s.description = s.summary
+
+  s.rubyforge_project = "maid"
+
+  s.add_dependency('thor', '~> 0.14.6')
+  s.add_development_dependency('rspec', '~> 2.5.0')
+  s.add_development_dependency('timecop', '~> 0.3.5')
+  s.add_development_dependency('ZenTest', '~> 4.4.2')
+
+  s.files         = `git ls-files`.split("\n")
+  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"]
+end

data/spec/lib/maid/app_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Maid
+  describe App, '#clean' do
+    before :each do
+      @app = App.new
+      @app.stub!(:maid_options)
+      @app.stub!(:say)
+
+      @maid = mock('Maid')
+      @maid.stub!(:clean)
+      @maid.stub!(:log_path)
+      Maid.stub!(:new).and_return(@maid)
+    end
+
+    it 'should make a new Maid with the options' do
+      opts = {:foo => 'bar'}
+      @app.stub!(:maid_options).and_return(opts)
+      Maid.should_receive(:new).with(opts).and_return(@maid)
+      @app.clean
+    end
+
+    it 'should tell the Maid to clean' do
+      @maid.should_receive(:clean)
+      @app.clean
+    end
+  end
+
+  describe App, '#version' do
+    it 'should print out the gem version' do
+      app = App.new
+      app.should_receive(:say).with(VERSION)
+      app.version
+    end
+  end
+
+  describe App, '#maid_options' do
+    before :each do
+      @app = App.new
+    end
+
+    it 'should log to STDOUT for testing purposes when given noop' do
+      opts = @app.maid_options('noop' => true)
+      opts[:file_options][:noop].should be_true
+      opts[:log_path].should == STDOUT
+      opts[:log_formatter].call(nil, nil, nil, 'hello').should == "hello\n"
+    end
+
+    it 'should set the rules path when given rules' do
+      opts = @app.maid_options('rules' => 'maid_rules.rb')
+      opts[:rules_path].should match(/maid_rules.rb$/)
+    end
+  end
+end