filemonitor 0.0.2 → 0.0.4

data/CHANGELOG

@@ -0,0 +1,30 @@
+=== 0.0.4 2010-02-17
+* Major Enhancements/Fixes
+  * Automatically appends watched list with new files when they are detected if the watch that was added is a directory 
+  * Removes deleted files from the watched files by default when that file is deleted, initiate the FileMonitor with :persistent=>true to override the new behavior.
+
+=== 0.0.3 2009-09-24
+* Major Enhancements:
+  * Accept regexp filter when adding files:   fm.add(path, regexp=/.*/, &block)
+* Minor changes
+  * Change this file from History.txt to CHANGELOG
+  * Remove unused options hash from the process method
+  * Remove script/generate script/console, script/destroy & Rakefile from gem
+  * Fixup filemonitor.gemspec to work for github gem creation
+
+=== 0.0.2 2009-09-24
+
+* Major Enhancements:
+  * Various API Changes!
+  * RSpec Testing!  Oh yah!
+  * RDocs! Oh yah!
+  * Reduced I/O load: Updated method of saving old file state. Changes are not 
+    detectable if changed within 1 second of prior digest. If this is a problem 
+    for anyone, I can make a md5 digest of the file optional.
+  * Handle duplicates file entries by overwriting the old with the new
+  * Add start / stop & halt methods for handling spawns
+
+=== 0.0.1 2009-09-15
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -1,14 +1,11 @@
-History.txt
+CHANGELOG
 Manifest.txt
 README.markdown
-Rakefile
 lib/FileMonitor.rb
 lib/FileMonitor/store.rb
-script/console
-script/destroy
-script/generate
 spec/FileMonitor_spec.rb
 spec/MonitoredItem_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
 tasks/rspec.rake
+tasks/rdoc.rake

data/README.markdown

@@ -1,30 +1,71 @@
 # FileMonitor
-* http://github.com/joshaven/FileMonitor
-* Joshaven Potter: <yourtech@gmail.com>
+Calls a Proc when a watched file is changed.
 
+* Documentation:   http://filemonitor.rubyforge.org/rdoc
+* Code Repository: http://github.com/joshaven/FileMonitor
+* Joshaven Potter: yourtech@gmail.com
 
-## DESCRIPTION
+## Notice
+This project has only been tested on posix compatible systems, sorry for you windows users.  If you get this
+to run under windows, let me know and I'll release a windows compatible version.
 
-Watches the file system for changes.  
+## Installation
+    gem install filemonitor  # you may need to run:  sudo gem install filemonitor
 
-## Notice
-This project has only been tested on posix compatible systems, sorry for
-you windows users.  If you get this to run under windows, let me know and I'll release a windows compatible version.
+## Examples
+In the following examples, the block passed will be executed when the file changes.  These examples only 
+echo strings but I am sure you'll find something more useful to do in the callback proc.
 
-## Usage
     require 'filemonitor'
-    file_spy = FileMonitor.new
-    # Add one or more files or directories with a callback block
-    file_spy.add(Dir.pwd) do |i|
-      # This callback will be executed in the context of a single file, even if you added a directory
-      puts "you probably should handle the change in #{i.file}"
+    
+    # Example 1: Generate a FileMonitor subprocess with one command:
+    fm = FileMonitor.when_modified(Dir.pwd, "/path/to/other/file.rb") do |watched_item| 
+      puts "Change detected in #{watched_item.path} "
     end
-    # run a background process that watches for changed files... which is cloesed along with the parent process.
-    file_spy.spawn 
     
+    # thats it... if you want to stop the subprocess, issue:   fm.stop
+    
+    # Example 2: Generate a manually run FileMonitor:
+    file_spy = FileMonitor.new {|f| puts "Default proc called because #{f.path} changed."}
+    file_spy.add(Dir.pwd) do |f|
+      puts "Monitored Item's proc called because #{f.path} changed."
+    end
+    
+    file_spy.process   # This will look for changes one time... call this again when you want to find changes.
+    # if you want to launch a background process then do file_spy.spawn or its alias: file_spy.start
 
-## License
+### Context Examples
+Both the FileMonitor.new method and a FileMonitor instance fm.add method can accept a block with 0 to 2 arities.
+See Also the api docs: <http://filemonitor.rubyforge.org/rdoc>
 
+This block is working in the context in which it was created:
+
+    changes = false
+    fm.add(Dir.pwd) {changes = true}  # The 'changes' variable will be set to true when a change is detected
+    fm.process
+    respond_to_file_changes if changes
+    
+This block is working in the context created and is aware of the watched file instance 'f'.  The watched file will 
+respond to :path, :callback, & :digest and is an instance of: MonitoredItems::Store
+
+    changed_ruby_files = []
+    fm.add(Dir.pwd, /\.rb$/) do |f|     # Adds all .rb files recursively starting with the working directory
+      changed_ruby_files << f.path      # The changed_ruby_files will contain the path of the changed files. 
+    end
+    fm.process
+    handel_changes(changed_ruby_files)  # Do somehting with the changed files
+    changed_ruby_files = []             # Cleanup changes so the array doesn't keep growing
+    
+    
+This block is working in the context created and is aware of the watched_file instance 'f' as well as the 
+file_monitor instance 'fm'.  The fm object can be acted on within the block the same way it is outside the block, 
+an example use of this may be to add all files in a folder when a file is changed...
+
+    fm.add(Dir.pwd) do |f, fm| 
+      fm.add(APP_ROOT) if f.path == (APP_ROOT + Manifest.txt)   # Start watching any new files when added to to the manifest.txt file.
+    end
+
+## License
 (The MIT License)
 
 Copyright (c) 2009 Joshaven Potter

data/lib/FileMonitor.rb

@@ -1,6 +1,5 @@
-require File.dirname(__FILE__) + '/FileMonitor/store'
+require ::File.dirname(__FILE__) + '/FileMonitor/store'
 require 'find' # needed for the :files_recursive method
-
 # Purpose:
 # Watches the file system for changes
 #
@@ -25,11 +24,11 @@ require 'find' # needed for the :files_recursive method
 #   # Alternatively you can do all of the above in one line:
 #   FileMonitor.when_modified(Dir.pwd, "/path/to/other/file.rb") do |watched_item| ... end
 class FileMonitor
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
   attr_accessor :callback, :pid, :watched
   # The new method may be called with an optional callback which must be a block 
   # either do...end or {...}.
-  # The block may consiste of upto arguments ie {|watched_item, monitored|}, in which case, the
+  # The block may consist of upto two arguments ie {|watched_item, monitored|}, in which case, the
   # watched_item is an instance of FileMonitor::Store and monitored is the FileMonitor instances self.
   #
   # The first argument of the block, 'watched_item' in this case, will respond to: (:path, :modified & :callback).
@@ -37,21 +36,22 @@ class FileMonitor
   # 
   # Example:
   #   FileMonitor.new do |watched_item|
-  #     puts "I am watched this file: #{watched_item.path}"
-  #     puts "When I find a change I will call watched_item.callback"
+  #     puts "My file name & path is: #{watched_item.path}"
+  #     puts "When I find a change I will call watched_item.callback which displays this text."
   #   end
   #
   #   FileMonitor.new do |watched_item, monitored|
-  #
-  #     # add files from a file that is a list of files to watch... Note: There
+  #     # Add files from a file that is a list of files to watch... Note: There
   #     IO.readlines(watched_item.path).each {|file| monitored << file } if watched_item.path == '/path/to/file/watchme.list'
-  #
-  #     # clear watchme.list so we won't add all watch files every time the file changes
-  #     open(watched_item) { |f| puts '' }
+  #     # Clear watchme.list so we won't add all watch files every time the file changes
+  #     open(watched_item) { |f| puts "This is the callback that is run..." }
   #   end
-  def initialize(&callback)
+  def initialize(options={}, &callback)
+    @options=options
+    # @options[:persistent] ||= false
     @watched = []
-    @callback = callback unless callback.nil?
+    @callback = callback if callback.is_a? Proc
+    @options[:rescan_directories] ||= true
   end
   
   # Returns a spawned FileMonitor instance.  The independent process automatically calls the given
@@ -71,7 +71,8 @@ class FileMonitor
   
   # The add method accepts a directory path or file path and optional callback.  If a directory path is given all files in that 
   # path are recursively added.  If a callback is given then that proc will be called when a change is detected on that file or 
-  # group of files.  If no proc is given via the add method then the object callback is called.
+  # group of files.  If no proc is given via the add method then the object callback is called.  If a regexp is given as the 
+  # second argument only files matching the regexp will be monitored.
   #
   # Example:
   #   fm = FileMonitor.new do |path|
@@ -81,18 +82,25 @@ class FileMonitor
   #   # The following will run the default callback when changes are found in the /tmp folder:
   #   fm.add '/tmp'
   #
-  #   # The following will run its own callback on changed files in the /home folder:
-  #   fm.add '/home' do |path|
+  #   # The following will run the given callback on any files ending in 'txt' in the /home folder when changed:
+  #   fm.add('/home', /txt$/) do |path|
   #     puts "A users file has changed: #{path}"
   #   end
-  def add(path, &callback)
-    if File.file? path
-      index = index_of(path) || @watched.size
-      @watched[index] = MonitoredItems::Store.new({:path=>File.expand_path(path), :callback=>callback, :digest=>digest(path)})
+  def add(path, regexp_file_filter=/.*/, &callback)
+    callback = @callback unless callback.is_a? Proc
+    # path = ::File.expand_path(path)
+    if ::File.file?(path) && regexp_file_filter === ::File.split(path).last
+      # Bail out if the file is already being watched.
+      return true if index_of(path) 
+      index = @watched.size
+      @watched[index] = MonitoredItems::Store.new({:path=>::File.expand_path(path), :callback=>callback, :digest=>digest(path)})
       return true
-    elsif File.directory? path
-      files_recursive(path).each {|f| add(f, &callback) }
+    elsif ::File.directory? path
+      files_recursive(path, regexp_file_filter, &callback).each do |f| 
+        add f, regexp_file_filter, &callback
+      end
       return true
+    else
     end
     false
   end
@@ -106,8 +114,8 @@ class FileMonitor
   #
   #   # The following will run the default callback when changes are found in the /tmp folder:
   #   fm << '/tmp'
-  def <<(path)
-    add path
+  def <<(path, regexp_file_filter=/.*/)
+    add path, regexp_file_filter
   end
 
   # Itterates watched files and runs callbacks when changes are detected.  This is the semi-automatic way to run the FileMonitor.
@@ -117,13 +125,21 @@ class FileMonitor
   #   fm = FileMonitor.new() {|watched_item| changed_files = watched_item.path}
   #   fm << '/tmp'
   #   fm.process   # this will look for changes in any watched items only once... call this when you want to look for changes.
-  def process(options={})
+  def process
+    scan_directories if @options[:rescan_directories]
+
     @watched.each do |i|
-      key = digest(i.path)
-      # i.digest =  key if i.digest.nil?  # skip first change detection, its always unknown on first run
+      # Unless the persistant option is set, this will remove watched file if it has been removed
+      # if the file still exists then it will be processed regardless of the persistent option.
+      unless @options[:persistent] || ::File.exists?(i.path) 
+        @watched.delete(i)
+      else
+        key = digest(i.path)
+        # i.digest =  key if i.digest.nil?  # skip first change detection, its always unknown on first run
       
-      unless i.digest == key
-        respond_to_change(i, key, options) 
+        unless i.digest == key
+          respond_to_change(i, key) 
+        end
       end
     end
   end
@@ -186,17 +202,17 @@ class FileMonitor
   #   fm << @app_root + '/lib'
   #   fm.spawn        # and now its doing its job... 
   def spawn(interval = 1)
-    if pid.nil? 
+    if @pid.nil? 
       @pid = fork {monitor interval}
       Process.detach(pid)
       
       Kernel.at_exit do
         # sends the kill command unless the pid is not found on the system
-        Process.kill('HUP', pid) if process_running?
-        pid = nil
+        Process.kill('HUP', @pid) if process_running?
+        @pid = nil
       end
     end
-    pid
+    @pid
   end
   alias_method :start, :spawn
   # Stops a spawned FileMonitor instance.  The FileMonitor will finish the the currnet iteration and exit gracefully.  See Also: Halt
@@ -209,9 +225,9 @@ class FileMonitor
     # Send user defined signal USR1 to process.  This is trapped in spauned processes and tells the process to Ctrl+C
     # The user defined signial is sent as a safty percausion because the process id is not tracked through a pid file
     # nor compared with the running command.  The FileMonitor spaun will respond to the USR1 signal by exiting properly.*
-    if Fixnum === pid
-      Process.kill('USR1', pid)
-      Process.wait pid
+    if Fixnum === @pid
+      Process.kill('USR1', @pid)
+      Process.wait @pid
     end
   end
   
@@ -222,12 +238,15 @@ class FileMonitor
   #   fm.spawn        # and now its doing its job... 
   #   fm.stop
   def halt()
-    if Fixnum === pid
-      Process.kill('USR2', pid)
-      Process.wait pid
+    if Fixnum === @pid
+      Process.kill('USR2', @pid)
+      Process.wait @pid
     end
   end
   
+  def directories #:nodoc:
+    @directories ||= []
+  end
 private
   # Returns true or false
   def process_running?
@@ -235,11 +254,11 @@ private
   end
 
   # Call callback and update digest with given key.
-  def respond_to_change(item, key, options)
+  def respond_to_change(item, key)
     if Proc === item.callback     # Use watched instance callback if possible.
-      call item.callback, item, self, options
+      call item.callback, item, self
     elsif Proc === self.callback  # Use object level callback if possible.
-      call self.callback, item, self, options
+      call self.callback, item, self
     end
     item.digest(key)
   end
@@ -263,7 +282,7 @@ private
   # Returns a string representation of the file state.
   def digest(file)
     begin
-      File.mtime(file).to_f
+      ::File.mtime(file).to_f
     rescue Errno::ENOENT
       nil
     end
@@ -272,12 +291,13 @@ private
   # Returns an array of all files in dirname recursively.  Accepts an optional file name regexp filter.
   # The following will find files ending in ".rb" recursively beginning in the working dir:
   #   files_recursive Dir.pwd, /\.rb$/
-  def files_recursive(dirname, file_name_regexp=/.*/)
+  def files_recursive(dirname, file_name_regexp=/.*/, &callback)
     paths = []
     
     Find.find(dirname) do |path|
       if FileTest.directory?(path)
-        Find.prune if File.basename(path)[0] == ?. # Don't look any further into directies beginning with a dot.
+        directories <<  MonitoredItems::Store.new({:path => ::File.expand_path(path), :file_name_regexp => file_name_regexp, :callback=>callback})
+        ::Find.prune if ::File.basename(path)[0] == ?. # Don't look any further into directies beginning with a dot.
       else
         paths << path if file_name_regexp === path # Amend the return array if the file found matches the regexp
       end
@@ -285,4 +305,19 @@ private
     
     return paths
   end
+  
+  # Attempts to add all files in all watched directories that match the watching filter, the add method is responcibale 
+  # for managing duplicates.
+  def scan_directories
+    self.directories.each do |dir|
+      ::Dir.new(dir.path).each do |file|
+        unless file == '.' || file == '..'
+          if dir.file_name_regexp===file
+            puts dir.callback.class
+            add ::File.join(dir.path, file), dir.file_name_regexp, &dir.callback
+          end
+        end
+      end
+    end
+  end
 end

data/lib/FileMonitor/store.rb

@@ -2,7 +2,6 @@ module MonitoredItems #:nodoc:
   class Nothing #:nodoc:
   end
   
-  
   # A Store object is much like a hash but instead of getting an setting keys you get and set instance variables.
   # The following examples are using methods used by the FileMonitor object, however the store object is not limited to these methods.
   #
@@ -23,7 +22,7 @@ module MonitoredItems #:nodoc:
     def initialize(hsh = {})
       hsh.map {|k,v| self.send(k, v)} if Hash === hsh
     end
-    
+
     # Gets or sets instance variables based upon the methods called.
     def method_missing(mth, arg=Nothing)
       # append the @ symbol and remove the equal symbol (if exists):

data/spec/FileMonitor_spec.rb

@@ -1,12 +1,10 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 
-# Time to add your specs!
-# http://rspec.info/
 describe "FileMonitor" do
   before :all do
     @app_root = File.expand_path(File.dirname(__FILE__)+"/..")
   end
-
+  
   it 'should be able to instantize' do
     fm = FileMonitor.new
     FileMonitor.should === fm
@@ -53,56 +51,65 @@ describe "FileMonitor" do
     fm = FileMonitor.new &proc1
     (fm << @app_root + '/lib/FileMonitor.rb').should be_true  # Should add single file
     (fm.add @app_root + '/lib/FileMonitor/store.rb', &proc2).should be_true  # Should add single file
-    fm.watched.first.callback.should be_nil
+    fm.watched.first.callback.should == proc1
     fm.watched.last.callback.should == proc2
-    fm.watched.last.callback.should_not == proc1
   end
   
-  it 'should overwrite existing file watches with successive additions' do
+  it 'should not duplicate files' do
     fm = FileMonitor.new
-    fm.watched.size.should == 0
-    (fm << @app_root + '/lib/FileMonitor.rb').should be_true  # Should add single file
-    (fm << @app_root + '/lib/FileMonitor.rb').should be_true  # Should add single file
+    filename = @app_root + '/lib/FileMonitor.rb'
+  
+    3.times do
+      fm << filename
+    end
     fm.watched.size.should == 1
-  end
+  end  
   
   it 'should spawn processes' do
     fm = FileMonitor.new
+    @app_root = "/Users/joshaven/projects/FileMonitor"
+  
     fm << @app_root + '/lib'
     pid = fm.spawn
     pid.should_not == Process.pid
-    `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should == [pid.to_s, Process.pid.to_s]
+    `ps -p #{fm.spawn} -o 'pid ppid'`.split().should == ["PID", "PPID", pid.to_s, Process.pid.to_s]
+    fm.stop
   end
-
+  
   it 'should stop spawn' do
     fm = FileMonitor.new
     fm << @app_root + '/lib'
     pid = fm.spawn
-    `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should == [pid.to_s, Process.pid.to_s]
+    sleep 1
+    # `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should == [pid.to_s, Process.pid.to_s]
+    `ps -p #{fm.spawn} -o 'pid ppid'`.split().should == ["PID", "PPID", pid.to_s, Process.pid.to_s]
     t=Time.now
     fm.stop
     puts "Time to stop: #{Time.now-t}"
-    `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should be_empty
+    `ps -p #{fm.spawn} -o 'pid ppid'`.split().should == ["PID", "PPID"]
   end
   
   it 'should halt spawn' do
     fm = FileMonitor.new
     fm << @app_root + '/lib'
     pid = fm.spawn
-    `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should == [pid.to_s, Process.pid.to_s]
+    sleep 1
+    # `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should == [pid.to_s, Process.pid.to_s]
+    `ps -p #{fm.spawn} -o 'pid ppid'`.split().should == ["PID", "PPID", pid.to_s, Process.pid.to_s]
     t=Time.now
     fm.halt
     puts "Time to halt: #{Time.now-t}"
-    `ps -p #{fm.spawn} -o 'pid ppid'|grep ^[0-9]`.split().should be_empty
+    `ps -p #{fm.spawn} -o 'pid ppid'`.split().should == ["PID", "PPID"]
   end
-
+  
   it 'should setup & spawn using the when_modified class method' do
     fm = FileMonitor.when_modified(Dir.pwd, "/path/to/other/file.rb") {|watched_item| true}
     fm.callback.arity.should == 1
     fm.pid.should > 1
     fm.pid.should == fm.spawn
+    fm.stop
   end
-
+  
   it 'should run callback on change' do
     changed_files = nil
     filename = @app_root + '/spec/temp.txt'
@@ -159,14 +166,119 @@ describe "FileMonitor" do
     File.delete filename
   end
   
+  it 'should not remove a file from the watch list if set to persistent when the file is deleted' do
+    changed_files = []
+    filename = @app_root + '/spec/temp.txt'
+    File.open(filename, 'w') {|f| f.write('Hello World') }
+  
+    fm = FileMonitor.new({:persistent => true}) {|watched_item| changed_files << watched_item.path}
+    fm << filename
+  
+    File.delete filename
+    File.exists?(filename).should be_false
+    fm.process.should be_true
+    fm.watched.size.should == 1
+    fm.watched.first.path.should == filename
+  end
+  
+  it 'should remove a file from the watch list if not set to persistent when the file is deleted' do
+    changed_files = []
+    filename1 = @app_root + '/spec/temp1.txt'
+    filename2 = @app_root + '/spec/temp2.txt'
+    File.open(filename1, 'w') {|f| f.write('Hello World 1') }
+    File.open(filename2, 'w') {|f| f.write('Hello World 2') }
+  
+    fm = FileMonitor.new() {|watched_item| changed_files << watched_item.path}
+    fm << filename1
+    fm << filename2
+  
+    fm.watched.size.should == 2
+    File.delete filename2
+    File.exists?(filename2).should be_false
+    fm.process.should be_true
+    fm.watched.size.should == 1
+    fm.watched.first.path.should == filename1
+    File.delete filename1
+  end
+  
   it 'should handel missing files without throwing errors' do
     filename = @app_root + '/spec/temp.txt'
     File.open(filename, 'w') {|f| f.write('hello') }
-    fm = FileMonitor.new() {true}
+    fm = FileMonitor.new(:persistent => true) {true}
     fm << filename
     fm.process
     File.delete(filename)
     fm.process
     fm.watched.first.digest.should be_nil
   end
+  
+  it 'should be able to use a filter when specifying files' do
+    fm = FileMonitor.new() {|watched_item| changed_files = watched_item.path}
+    fm.add(@app_root, /\.rb$/) {|f| puts "Change found in: #{f.path}"}
+    fm.watched.each do |i|
+      File.split(i.path).last.should =~ /\.rb$/
+    end
+  end
+  
+  it 'should add new files when they are created if FileMonitor is watching a directory' do
+    fm = FileMonitor.new
+    # Create a test directory and watch it
+    testing_dir = @app_root + '/spec/testing'
+    filename = testing_dir + '/temp.txt'
+    File.delete filename if File.exists?(filename)
+  
+    Dir.mkdir testing_dir unless File.directory? testing_dir
+    fm << testing_dir
+  
+    fm.watched.should be_empty
+  
+    File.open(filename, 'w') {|f| f.write('hello') }
+  
+    # The new file should be watched after the fm.process has run
+    fm.process
+    fm.watched.should_not be_empty
+  
+    # Cleanup
+    File.delete filename
+    Dir.delete testing_dir
+  end
+  
+  it 'should not crawl through directories when a file is specified' do
+    fm = FileMonitor.new
+    fm.add(File.join(@app_root, 'CHANGELOG'))
+    fm.directories.should be_empty  
+  end
+
+  it 'should crawl through directories looking for files when a directory is specified' do
+    fm = FileMonitor.new
+    fm.add(@app_root, /.*\.rb/)
+    fm.directories.size.should > 5  
+  end
+  
+  it 'should not loose the regexp filter when storing watched directories' do
+    fm = FileMonitor.new
+    fm.add(@app_root, /.*\.rb/)
+    fm.directories.each {|d| d.file_name_regexp.should == /.*\.rb/}
+  end
+  
+  it 'should not have inflating directories' do
+    fm = FileMonitor.new
+    fm.add(@app_root, /.*\.rb/)
+    start = fm.directories.size
+    fm.process
+    fm.directories.size.should == start
+  end
+  
+  it 'should not loose callbacks' do
+    puts "<br />Starting should not loose callbacks test<br /><br />"
+    callback = Proc.new {return "hello from callback"}
+    fm = FileMonitor.new &callback
+    
+    fm.add @app_root, /.*\.rb/
+    
+    fm.directories.size.should > 1
+    fm.directories.each {|dir| dir.callback.should == callback}
+    fm.watched.size.should > 1
+    fm.watched.each {|file| file.callback.should == callback}
+  end
 end

data/tasks/rdoc.rake

@@ -0,0 +1,9 @@
+require 'rake/rdoctask'
+require 'rdiscount'
+
+Rake::RDocTask.new('rdoc') do |t|
+  t.rdoc_files.include('README.markdown', 'lib/**/*.rb')
+  t.main = 'README.markdown'
+  t.title = "FileMonitor API Documentation"
+  t.rdoc_dir = 'doc'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: filemonitor
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors: 
 - Joshaven Potter
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-24 00:00:00 -04:00
+date: 2010-02-20 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.3.3
     version: 
-description: Watches the file system for changes.
+description: ""
 email: 
 - yourtech@gmail.com
 executables: []
@@ -30,31 +30,26 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- History.txt
 - Manifest.txt
 files: 
-- History.txt
+- CHANGELOG
 - Manifest.txt
 - README.markdown
-- Rakefile
 - lib/FileMonitor.rb
 - lib/FileMonitor/store.rb
-- script/console
-- script/destroy
-- script/generate
 - spec/FileMonitor_spec.rb
 - spec/MonitoredItem_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - tasks/rspec.rake
+- tasks/rdoc.rake
 has_rdoc: true
-homepage: http://github.com/joshaven/FileMonitor
+homepage: http://github.com/joshaven/FileMonitor/
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --main
-- README.markdown
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -75,6 +70,6 @@ rubyforge_project: filemonitor
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Watches the file system for changes.
+summary: Calls a Proc when a watched file is changed.
 test_files: []
 

data/History.txt

@@ -1,16 +0,0 @@
-=== 0.0.2 2009-09-15
-
-* Major Enhancements:
-  * Various API Changes!
-  * RSpec Testing!  Oh yah!
-  * RDocs! Oh yah!
-  * Reduced I/O load: Updated method of saving old file state. Changes are not 
-    detectable if changed within 1 second of prior digest. If this is a problem 
-    for anyone, I can make a md5 digest of the file optional.
-  * Handle duplicates file entries by overwriting the old with the new
-  * Add start / stop & halt methods for handling spawns
-
-=== 0.0.1 2009-09-15
-
-* 1 major enhancement:
-  * Initial release

data/Rakefile

@@ -1,25 +0,0 @@
-require 'rubygems'
-gem 'hoe', '>= 2.1.0'
-require 'hoe'
-require 'fileutils'
-require './lib/FileMonitor'
-
-Hoe.plugin :newgem
-# Hoe.plugin :website
-# Hoe.plugin :cucumberfeatures
-
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.spec 'filemonitor' do
-  self.developer 'Joshaven Potter', 'yourtech@gmail.com'
-  self.rubyforge_name       = self.name # TODO this is default value
-  # self.extra_deps         = [['activesupport','>= 2.0.2']]
-  self.readme_file = "README.markdown"
-end
-
-require 'newgem/tasks'
-Dir['tasks/**/*.rake'].each { |t| load t }
-
-# TODO - want other tests/tasks run by default? Add them to the list
-# remove_task :default
-# task :default => [:spec, :features]

data/script/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-
-libs =  " -r irb/completion"
-# Perhaps use a console_lib to store any extra methods I may want available in the cosole
-# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/FileMonitor.rb'}"
-puts "Loading FileMonitor gem"
-exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/destroy'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/generate'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Generate.new.run(ARGV)