watchful 0.0.0.pre1

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg/*
+pkg

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2010, Kyle E. Mitchell (http://kemitchell.com)
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+Watchful
+========
+
+A shell script for busy web developers 
+
+What?
+-----
+
+Watchful is a lightweight tool that runs command line tools on updated files. It was built by a web developer who got seriously tired of managing a whole range of CLI minification, translation, and compression tools on his CSS and Javascript.
+
+You can think of Watchful as kind of recursive, specialized [Rake](http://rake.rubyforge.org/): you tell it which tools to run on which files, then fire it off in your current project directory and go back to your text editor. When you save a change to a relevant file under that directory, Watchful will run the proper tool on it. If you are on OS X and have [Growl](http://growl.info/) installed, you’ll get a notification.
+
+Where?
+------
+
+Watchful is currently hosted on [GitHub](http://github.com):
+
+[http://github.com/kemitchell/watchful](http://github.com/kemitchell/watchful)
+
+Please feel free to fork me!
+	
+Eventually, Watchful will be available as a Ruby Gem:
+	
+    sudo gem install watchful
+
+How?
+----
+
+All configuration is done in pure Ruby. Configurations are created by subclassing `Watchful::Configuration` in “watchful” files. An example follows:
+
+    require 'watchful/configuration'
+
+    class MyConfiguration < Watchful::Configuration
+    	
+    	description 'LESS CSS and YUI Compressor'
+    	
+    	# actions are applied in order, hence Less is defined before YUI
+    	
+    	action	:name => "Less CSS", 
+    			:in => ".less",				# The extension of files to use as input
+    			:out => ".css",				# Extension to replace the above for output files
+    			:command => "lessc %s %s",	# The command to create output files from input files
+    										# Currently the command is built using sprintf.
+    										# In the future all of the above will also take blocks.
+    										# For now, the first %s is the full input path,
+    										# and the second the full output path.
+    			:dependencies => ['less']	# If “less” isn’t found in PATH, this action will be disabled.
+    	
+    	action	:name => 'YUI Compressor',
+    			:in => '.css',
+    			:out => '.min.css',			# Notice that Watchful computers extensions differently than basename
+    										# Namely, the extension is anything in the file name from the
+    										# first period onward.
+    			:command => 'java -jar /usr/local/utils/yuicompressor-2.4.2.jar --type css --charset utf-8 %s -o %s',
+    			:dependencies => ['java', '/usr/local/utils/yuicompressor-2.4.2.jar']
+    										# Dependencies can be programs (e.g. “java”), or full file paths.
+    	
+    end
+
+When Watchful is started, it searches in the following locations (in the following order) for files called “watchful” and loads them:
+
+1. In the directory Watchful is told to monitor
+2. In the current user’s home directory
+
+If no such files are found, Watchful will use the default configuration, which searches your PATH for tools it recognizes. If your tool isn't listed in [http://github.com/kemitchell/watchful/blob/master/lib/watchful/defaultconfiguration.rb](defaultconfiguration.rb) and you would like it to be, please fork the project on github or send me a patch. I would be happy to include any tools with current stable or Beta releases.

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'rake'
+
+begin
+	require 'jeweler'
+	Jeweler::Tasks.new do |gem|
+		gem.name = "watchful"
+		gem.summary = 'Watchful, a tool for busy web devs'
+		gem.description = 'Applies intermediary tools to modified files'
+		gem.email = "kyleevanmitchell@gmail.com"
+		gem.homepage = "http://github.com/kemitchell/watchful"
+		gem.authors = ["KEM"]
+		gem.add_development_dependency "thoughtbot-shoulda"
+		gem.add_dependency('commandline')
+		gem.add_dependency('extensions')
+		gem.add_dependency('open4')
+		gem.rubyforge_project = 'watchful'
+	end
+	Jeweler::RubyforgeTasks.new do |rubyforge|
+		rubyforge.doc_task = 'watchful'
+	end
+rescue LoadError
+	puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Jeweler::RubyforgeTasks.new do |rf|
+	rf.doc_task = 'rdoc'
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+	test.libs << 'lib' << 'test'
+	test.pattern = 'test/**/*_test.rb'
+	test.verbose = true
+end
+
+begin
+	require 'rcov/rcovtask'
+	Rcov::RcovTask.new do |test|
+		test.libs << 'test'
+		test.pattern = 'test/**/*_test.rb'
+		test.verbose = true
+	end
+rescue LoadError
+	task :rcov do
+		abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+	end
+end
+
+task :test => :check_dependencies
+
+task :default => [:test, :build]
+
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+	if File.exist?('VERSION')
+		version = File.read('VERSION')
+	else
+		version = ""
+	end
+
+	rdoc.rdoc_dir = 'rdoc'
+	rdoc.title = "watchful #{version}"
+	rdoc.rdoc_files.include('README*')
+	rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0.pre1

data/bin/watchful

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require 'rubygems'
+require 'commandline'
+require 'watchful'
+
+begin
+	require 'growl' # OS X notifications
+rescue LoadError
+ 	HAVE_GROWL = false
+else
+	if (Growl.installed? rescue false)		
+		HAVE_GROWL = true
+	else
+		HAVE_GROWL = false
+	end
+end
+
+class App < CommandLine::Application
+	def initialize
+		version Watchful::version
+		author 'KEM'
+		copyright '2010, Kyle Mitchell'
+		short_description 'runs tools on updated files'
+		long_description <<-eos
+			A configurable deamon for running source code translation and minification tools–
+			such as CSS and Javascript minification tools and generators—on updated files.
+		eos
+		synopsis "[-dhv] path"
+		option :help
+		option :debug
+		option :version
+		option :names => %w{--use-default-configuration --default},
+			:opt_found => get_args,
+			:opt_description => 'Use the default configuration even if a local or user-level configuration is found.'
+		expected_args :path
+	end
+	def main
+		Watchful::Configuration.active_configuration = Watchful::DefaultConfiguration
+		# todo: check dependencies of actions of active configuration
+		
+		path = File.expand_path(args[0])
+		fail "No such directory: #{path} " unless File.directory? path
+		
+		Watchful::load_configuration(path, opt['--use-default-configuration'])
+		
+		# show the active config
+		debug "Config: " + Watchful::Configuration.active_configuration._description
+		
+		# list active actions
+		Watchful::Configuration.active_configuration.actions.each do |a|
+			debug "Action: \t#{a.name} (#{a.in} -> #{a.out})"
+		end
+		
+		puts "Watching #{Dir.pwd}..."
+		Watchful::watch_files(path)
+	end
+end

data/doc/DSL-Specification.rb

@@ -0,0 +1,51 @@
+
+# The name MyConfig should be accessible from the command line, e.g.
+# 	
+# 	watchful MyConfiguration
+# 
+# By default (without a named config) watchful should use:
+#
+# 	1)	The configuration found in Watchful.rb, which should search PATH
+#  		for known tools
+#
+#			or failing that
+#
+# 	2)	The default configuration in the gem
+#
+
+class MyConfiguration < Watchful::Configuration
+	
+	# hash style action description
+	
+	action	:name => 'CSS Minifier' # for messages
+			:in => ".css",
+			:out => ".min.css",
+			:command => "minify $IN $OUT", 
+			:dependencies => ['minify']
+			
+	# block style action description
+	
+	action 'CSS Minifier' do |a|
+		
+		# file matchers should also support blocks
+		
+		a.filter do |path|
+			true if /.+\.css/ =~ path
+		end
+		
+		# or regexps
+		
+		a.in = /.+\.css/
+		
+		# without $IN assume standard input
+		
+		a.command = 'minify -o $OUT' # => "cat $IN | minify -o $OUT"
+		
+		a.command = 'minify'	# => "cat $IN | minify > $OUT"
+								# => a.dependencies << 'minify'
+		
+		a.dependencies = ['minify']
+		
+	end
+	
+end

data/lib/watchful/action.rb

@@ -0,0 +1,78 @@
+require 'commandline' # for debug
+
+module Watchful
+	
+	class Action
+		
+		# todo: support blocks for @in, @out, and @command
+		
+		PROPERTIES = [:name, :dependencies, :command, :in, :out]
+		
+		PROPERTIES.each { |k| attr_accessor k }
+		
+		@enabled = true
+		def enabled?; @enabled ;end
+		
+		
+		def initialize(options = {})
+			
+			options[:dependencies] ||= []
+			
+			PROPERTIES.each do |key|
+				self.instance_variable_set('@' + key.to_s, options[key])
+			end
+			
+			@dependencies = [@dependencies] if @dependencies.kind_of? String
+			
+			raise "Dependencies option must be a string or array" if not @dependencies.kind_of? Array
+			
+			[@in, @out].each do |i|
+				@enabled = false unless i and i.instance_of? String and i.starts_with? '.'
+			end
+			
+			@enabled = @enabled && self.has_dependencies?
+			
+		end
+		
+		def has_dependencies?
+			return true if @dependencies.empty?
+			have_all = @dependencies.any? do |d|
+				(Action.have_command?(d)) || (File.exists?(File.expand_path(d)))
+			end
+			# todo: more detailed messages about missing dependencies
+			debug "Missing dependencies for action \"#{@name}\"" unless have_all
+			return have_all
+		end
+		
+		def command_string(input_path)
+			Kernel.sprintf(@command, input_path, self.output_path_for(input_path))
+		end
+		
+		# todo: better have_command?
+		def Action.have_command?(cmd)
+			raise 'Argument must be a string' if not cmd.kind_of? String
+			raise 'Argument cannot be an empty string' if cmd.empty?
+			
+			ENV['PATH'].split(':').each do |dir|
+				return true if File.exists?("#{dir}/#{cmd}")
+			end
+			false
+		end
+		
+		def output_path_for(source_path)
+			return File.dirname(source_path) + '/' + File.basename(source_path, @in) + @out
+		end
+		
+		# does the given path look like a path to which this action might write output?
+		def output_file?(path)
+			Watchful::compound_extension_of(path) == @in
+		end
+		
+		# does the given path look like a path to which this action could be applied?
+		def input_file?(path)
+			Watchful::compound_extension_of(path) == @in
+		end
+
+	end
+	
+end

data/lib/watchful/configuration.rb

@@ -0,0 +1,42 @@
+require 'watchful/action'
+
+module Watchful
+
+	class Configuration
+		
+		@@active_configuration = nil
+		
+		def self.active_configuration; @@active_configuration; end
+		def self.active_configuration=(x)
+			unless x.is_a? Class and x.ancestors.include? Watchful::Configuration
+				throw "Not a valid configuration class"
+			end
+			@@active_configuration = x
+		end
+		
+		class << self
+		
+			attr_reader :actions
+		
+			def description(s); @description = s; end
+			
+			def _description; @description; end
+		
+			def action(args)
+				# set the description in case the user doesn’t
+				@description ||= 'Custom Configuration'
+				
+				# set to active configuration
+				@@active_configuration = self
+				
+				# todo: support block-passing style
+				@actions ||= []
+				a = Watchful::Action.new(args)
+				@actions << a
+			end
+		
+		end
+		
+	end
+	
+end

data/lib/watchful/defaultconfiguration.rb

@@ -0,0 +1,34 @@
+require 'watchful/configuration'
+
+module Watchful
+	
+	class DefaultConfiguration < Configuration
+		
+		description "Default Configuration"
+		
+		# LESS CSS, if installed
+		
+		begin
+			gem "less"
+			action	:name => 'LESS CSS',
+					:in => '.less',
+					:out => '.css',
+					:command => 'lessc %s %s',
+					:dependencies => ['less']
+		rescue GEM::LoadError
+			# pass
+		end
+		
+		# SASS, if installed
+		
+		if Action.have_command? 'sass'
+			action	:name => 'SASS',
+					:in => '.sass',
+					:out => '.min.css',
+					:command => 'sass --style compressed %s %s',
+					:dependencies => 'sass'
+		end
+		
+	end
+		
+end

data/lib/watchful/paths.rb

@@ -0,0 +1,20 @@
+require 'extensions/string'
+
+module Watchful
+	
+	def self.younger_than(a, b)
+		if (not File.exists? a) or (not File.exists? b)
+			raise Exception, "cannot compare modification times of non-existant files"
+		end
+		return (File.stat(a).mtime > File.stat(b).mtime)
+	end
+
+	def self.compound_extension_of(str)
+		return nil if str.empty?
+		basename = File.basename(str)
+		periodpos = basename.index('.')
+		return nil if not periodpos or periodpos < 1
+		return basename[basename.index('.')..-1]
+	end
+	
+end

data/lib/watchful/watch.rb

@@ -0,0 +1,106 @@
+require 'find'
+require 'open4'
+require 'watchful/defaultconfiguration'
+require "commandline"
+
+module Watchful
+	
+	def self.each_source_file_in_dir(path = Dir.pwd)
+		Find.find(path) do |filepath|
+			next if FileTest.directory?(filepath)
+			yield(filepath)
+		end
+	end
+	
+	def self.check_for_interrupts
+		begin
+			sleep 1
+		rescue Interrupt
+			puts # new line
+			exit 0
+		end
+	end
+	
+	CONFIGURATION_FILE_NAME = 'watchful'
+	
+	def self.load_configuration(path, use_default = false)
+
+		# todo: more efficient loading of configurations
+		# todo: check that relative paths work on Windows
+		
+		local = File.expand_path("#{path}/#{CONFIGURATION_FILE_NAME}")
+		user = File.expand_path("~/#{CONFIGURATION_FILE_NAME}")
+		
+		if File.exists? local
+			debug "Loading #{local}"
+			load local
+		elsif File.exists? user
+			debug "Loading #{user}"
+			load user
+		end
+		
+	end
+	
+	@files_with_errors = Hash.new # {:path => '', :mtime => ### }
+	
+	def self.watch_files(path)
+		@output_file_extensions = Configuration.active_configuration.actions.collect do |a|
+			a.out
+		end
+		loop do
+			check_for_interrupts
+			each_source_file_in_dir(path) do |file_path|
+				extension = compound_extension_of(file_path)
+				
+				action = Configuration.active_configuration.actions.find { |a| a.input_file? file_path}
+				
+				next if action.nil?
+				
+				output_path = action.output_path_for(file_path)
+				
+				if (!File.exists?(output_path)) or younger_than(file_path, output_path)
+					error_mtime = @files_with_errors[file_path]
+					next if error_mtime && error_mtime >= File.stat(file_path).mtime
+					do_action(file_path, action)
+				end
+				
+			end
+		end
+	end
+	
+	def self.do_action(source_file, action)
+
+		puts "#{action.name}: #{source_file}"
+
+		command = action.command_string(source_file)
+		
+		debug "\t#{command}"
+		
+		proc_pid, proc_stdin, proc_stdout, proc_stderr = Open4::popen4(command)
+		proc_ignored, proc_status = Process::waitpid2(proc_pid)
+
+		error = proc_stderr.gets
+
+		if proc_status && !error
+			if HAVE_GROWL
+				growl = Growl.new
+		        growl.title = action.name
+		        growl.message = "#{source_file}"
+		        growl.run
+			end
+			@files_with_errors.delete(source_file)
+		else
+			$stderr.puts("ERROR -- #{action.name} -- #{source_file}")
+			$stderr.puts(error)
+			if HAVE_GROWL
+				growl = Growl.new
+		        growl.title = "ERROR: #{action.name}"
+		        growl.message = error
+		        growl.run
+			end
+			@files_with_errors[source_file] = File.stat(source_file).mtime
+		end
+		
+	end
+	
+end

data/lib/watchful.rb

@@ -0,0 +1,17 @@
+# Author::    K E Mitchell  (mailto:kyleevanmitchell@gmail.com)
+# License::   ISC License (http://www.isc.org/software/license)
+
+WATCHFUL_ROOT = File.expand_path(File.dirname(__FILE__))
+
+$:.unshift File.dirname(__FILE__)
+
+require 'watchful/paths'
+require 'watchful/watch'
+require 'watchful/action'
+require 'watchful/defaultconfiguration'
+
+module Watchful
+	def self.version
+		File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).strip
+	end
+end

data/test/action_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class WatchfulTest < Test::Unit::TestCase
+	
+	context 'Action class' do
+		
+		should 'throw an exception with incomplete constructor parameters' do
+			begin
+				Watchful::Action.new(:name => 'Incomplete Action')
+				flunk
+			rescue Exception
+				assert true
+			end
+		end
+		
+		should 'properly construct with a complete set of options' do
+			a = Watchful::Action.new(
+				:name => 'Test Action',
+				:dependencies => ['cat'], :command => 'cat %s %s',
+				:in => '.txt', :out => '.copy'
+			)
+			assert a.instance_of? Watchful::Action
+			assert_equal a.name, 'Test Action'
+		end
+		
+		should 'throw an exception when a non-string, non-array value is passed as dependencies' do
+			begin
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => Date.new, :command => 'cat %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				flunk
+			rescue Exception
+				assert true
+			end
+		end
+		
+		context 'output_path_for' do
+			
+			setup do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+			end
+			
+			should 'produce correct path' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.output_path_for('/tmp/test.txt'), '/tmp/test.copy'
+			end
+			
+			should 'produce correct path with complex extensions' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '.max.txt', :out => '.min.copy'
+				)
+				assert_equal a.output_path_for('/tmp/test.max.txt'), '/tmp/test.min.copy'
+			end
+			
+			should 'produce correct with blank output extension' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '', :out => '.copy'
+				)
+				assert_equal a.output_path_for('/tmp/test.txt'), '/tmp/test.txt.copy'
+			end
+			
+			should 'produce correct with blank source extension' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '.txt', :out => ''
+				)
+				assert_equal a.output_path_for('/tmp/test.txt'), '/tmp/test'
+			end
+			
+			should 'produce correct with blank extensions' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat'], :command => 'cat %s %s',
+					:in => '', :out => ''
+				)
+				assert_equal a.output_path_for('/tmp/test'), '/tmp/test'
+			end
+			
+		end
+		
+		context 'dependencies' do
+			
+			context 'have_command?' do
+				
+				should 'raise an exception for an empty string' do
+					begin
+						Watchful::Action.have_command?('')
+						flunk
+					rescue Exception
+						assert true
+					end
+				end
+				
+				should 'raise an exception for a non-string argument' do
+					begin
+						Watchful::Action.have_command?(nil)
+						flunk
+					rescue Exception
+						assert true
+					end
+				end
+				
+				should 'return false for missing commands' do
+					assert_equal Watchful::Action.have_command?('Y0CbR4CEP2XY'), false
+				end
+				
+				should 'return true for available commands' do
+					assert_equal Watchful::Action.have_command?('cat'), true
+				end
+				
+			end
+			
+			should 'confirm valid dependencies' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat', 'echo'], :command => 'cat %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, true
+			end
+			
+			should 'detect a missing binary dependency' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['Y0CbR4CEP2XY'], :command => 'Y0CbR4CEP2XY %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, false
+			end
+			
+			should 'confirm availability of no dependencies' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => nil, :command => '',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, true
+			end
+			
+		end
+		
+	end
+	
+end

data/test/configuration_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+require "watchful/configuration"
+
+class FirstTestConfiguration < Watchful::Configuration
+
+	action :name => 'Placeholder Action'
+
+end
+
+puts "FirstTestConfiguration is a Configuration?".kind_of? Watchful::Configuration
+
+class WatchfulTest < Test::Unit::TestCase
+	
+	context 'Configuration class' do
+		
+		context 'dependencies' do
+			
+			context 'have_command?' do
+				
+				should 'raise an exception for an empty string' do
+					begin
+						Watchful::Action.have_command?('')
+						flunk
+					rescue Exception
+						assert true
+					end
+				end
+				
+				should 'raise an exception for a non-string argument' do
+					begin
+						Watchful::Action.have_command?(nil)
+						flunk
+					rescue Exception
+						assert true
+					end
+				end
+				
+				should 'return false for missing commands' do
+					assert_equal Watchful::Action.have_command?('Y0CbR4CEP2XY'), false
+				end
+				
+				should 'return true for available commands' do
+					assert_equal Watchful::Action.have_command?('cat'), true
+				end
+				
+			end
+			
+			should 'confirm valid dependencies' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['cat', 'echo'], :command => 'cat %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, true
+			end
+			
+			should 'detect a missing binary dependency' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => ['Y0CbR4CEP2XY'], :command => 'Y0CbR4CEP2XY %s %s',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, false
+			end
+			
+			should 'confirm availability of no dependencies' do
+				a = Watchful::Action.new(
+					:name => 'Test Action',
+					:dependencies => nil, :command => '',
+					:in => '.txt', :out => '.copy'
+				)
+				assert_equal a.has_dependencies?, true
+			end
+			
+		end
+		
+	end
+	
+end

data/test/customconfiguration_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'fileutils'
+
+class WatchfulTest < Test::Unit::TestCase
+	
+	def setup
+		['/tmp/first', '/tmp/second'].each do |f|
+			FileUtils.touch(f)
+		end
+	end
+
+	class FirstTestConfiguration < Watchful::Configuration
+		action :name => 'Placeholder Action'
+	end
+	
+	should 'correctly compile list of actions' do
+		assert_equal FirstTestConfiguration.actions.length, 1
+	end
+	
+end

data/test/paths_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+require 'fileutils'
+
+class WatchfulTest < Test::Unit::TestCase
+	
+	def setup
+		['/tmp/first', '/tmp/second'].each do |f|
+			FileUtils.touch(f)
+		end
+	end
+	
+	context 'younger_than' do
+		
+		should 'correctly compare mtimes' do
+			
+			sleep 1
+			FileUtils.touch('/tmp/first')
+			assert Watchful.younger_than('/tmp/first', '/tmp/second')
+			
+			sleep 1
+			FileUtils.touch('/tmp/second')
+			assert Watchful.younger_than('/tmp/second', '/tmp/first')
+			
+		end
+		
+		should 'raise exception when comparing nonexistant files' do
+			begin
+				Watchful.younger_than('/tmp/does/not/exist', @files[1])
+				flunk
+			rescue Exception
+				assert true
+			end
+			begin
+				Watchful.younger_than(@files[0], '/tmp/does/not/exist')
+				flunk
+			rescue Exception
+				assert true
+			end
+		end
+		
+	end
+	
+	context 'compound_extension_of' do
+		
+		should "detect simple extensions" do
+			assert_equal Watchful.compound_extension_of('a_long_file_name.css'), '.css'
+		end
+		
+		should "detect compound extensions" do
+			assert_equal Watchful.compound_extension_of('test.min.css'), '.min.css'
+		end
+		
+		should "return nil for files without extensions" do
+			assert_nil Watchful.compound_extension_of('test_file')
+		end
+		
+		should 'return nil for files without basenames' do
+			assert_nil Watchful.compound_extension_of('.extension')
+		end
+		
+	end
+	
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+# todo: move to raw Test::Unit
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'watchful'
+
+class Test::Unit::Watchful
+end

data/watchful.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{watchful}
+  s.version = "0.0.0.pre1"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["KEM"]
+  s.date = %q{2010-04-22}
+  s.default_executable = %q{watchful}
+  s.description = %q{Applies intermediary tools to modified files}
+  s.email = %q{kyleevanmitchell@gmail.com}
+  s.executables = ["watchful"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bin/watchful",
+     "doc/DSL-Specification.rb",
+     "lib/watchful.rb",
+     "lib/watchful/action.rb",
+     "lib/watchful/configuration.rb",
+     "lib/watchful/defaultconfiguration.rb",
+     "lib/watchful/paths.rb",
+     "lib/watchful/watch.rb",
+     "test/action_test.rb",
+     "test/configuration_test.rb",
+     "test/customconfiguration_test.rb",
+     "test/paths_test.rb",
+     "test/test_helper.rb",
+     "watchful.gemspec"
+  ]
+  s.homepage = %q{http://github.com/kemitchell/watchful}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{watchful}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Watchful, a tool for busy web devs}
+  s.test_files = [
+    "test/action_test.rb",
+     "test/configuration_test.rb",
+     "test/customconfiguration_test.rb",
+     "test/paths_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_runtime_dependency(%q<commandline>, [">= 0"])
+      s.add_runtime_dependency(%q<extensions>, [">= 0"])
+      s.add_runtime_dependency(%q<open4>, [">= 0"])
+    else
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<commandline>, [">= 0"])
+      s.add_dependency(%q<extensions>, [">= 0"])
+      s.add_dependency(%q<open4>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<commandline>, [">= 0"])
+    s.add_dependency(%q<extensions>, [">= 0"])
+    s.add_dependency(%q<open4>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification 
+name: watchful
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 0
+  - pre1
+  version: 0.0.0.pre1
+platform: ruby
+authors: 
+- KEM
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-22 00:00:00 -05:00
+default_executable: watchful
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: commandline
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: extensions
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Applies intermediary tools to modified files
+email: kyleevanmitchell@gmail.com
+executables: 
+- watchful
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/watchful
+- doc/DSL-Specification.rb
+- lib/watchful.rb
+- lib/watchful/action.rb
+- lib/watchful/configuration.rb
+- lib/watchful/defaultconfiguration.rb
+- lib/watchful/paths.rb
+- lib/watchful/watch.rb
+- test/action_test.rb
+- test/configuration_test.rb
+- test/customconfiguration_test.rb
+- test/paths_test.rb
+- test/test_helper.rb
+- watchful.gemspec
+has_rdoc: true
+homepage: http://github.com/kemitchell/watchful
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: watchful
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Watchful, a tool for busy web devs
+test_files: 
+- test/action_test.rb
+- test/configuration_test.rb
+- test/customconfiguration_test.rb
+- test/paths_test.rb
+- test/test_helper.rb