joshaven-filemonitor 0.0.3

data/CHANGELOG

@@ -0,0 +1,25 @@
+=== 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

@@ -0,0 +1,11 @@
+CHANGELOG
+Manifest.txt
+README.markdown
+lib/FileMonitor.rb
+lib/FileMonitor/store.rb
+spec/FileMonitor_spec.rb
+spec/MonitoredItem_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake
+tasks/rdoc.rake

data/README.markdown

@@ -0,0 +1,90 @@
+# FileMonitor
+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
+
+## 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.
+
+## Installation
+    gem install filemonitor  # you may need to run:  sudo gem install filemonitor
+
+## 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.
+
+    require 'filemonitor'
+    
+    # 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
+    
+    # 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
+
+### 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
+
+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/lib/FileMonitor.rb

@@ -0,0 +1,288 @@
+require File.dirname(__FILE__) + '/FileMonitor/store'
+require 'find' # needed for the :files_recursive method
+# Purpose:
+# Watches the file system for changes
+#
+# Usage:
+#
+#   require 'filemonitor'
+#
+#   # Create a FileMonitor instance and assign the callback to the entire object.
+#   # In the following example, "watched_item" is a MonitoredItems::Store, see the new
+#   # method for a better example of working in your block.
+#   file_spy = FileMonitor.new do |watched_item| ... end
+#
+#   # Any files in the working directory (Dir.pwd) and its sub-directories will
+#   #  be watched for changes.  If a change is found the callback assigned above 
+#   #  will be enacted.
+#   file_spy << Dir.pwd
+#   file_spy << "/path/to/other/file.rb"
+#
+#   # launch an independent process to do the monitoring:
+#   file_spy.spawn
+#
+#   # 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.3'
+  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
+  # 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).
+  # The second argument of the block, 'monitored' in this case, will respond any FileMonitor method.
+  # 
+  # 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"
+  #   end
+  #
+  #   FileMonitor.new do |watched_item, monitored|
+  #
+  #     # 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 '' }
+  #   end
+  def initialize(&callback)
+    @watched = []
+    @callback = callback unless callback.nil?
+  end
+  
+  # Returns a spawned FileMonitor instance.  The independent process automatically calls the given
+  # callback when changes are found.
+  #
+  # Example:
+  #   fm = FileMonitor.when_modified(Dir.pwd, "/path/to/other/file.rb") {|watched_item, file_monitor| ... }
+  #   fm.pid            # => 23994
+  #   fm.callback.nil?  # => false
+  #   fm.watched.size   # => 28
+  def self.when_modified(*paths, &callback)
+    fm = FileMonitor.new &callback
+    paths.each {|path| fm << path}
+    fm.spawn
+    return fm
+  end
+  
+  # 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.  If a regexp is given as the 
+  # second argument only files matching the regexp will be monitored.
+  #
+  # Example:
+  #   fm = FileMonitor.new do |path|
+  #     puts "Detected a change on #{path}"
+  #   end
+  #
+  #   # The following will run the default callback when changes are found in the /tmp folder:
+  #   fm.add '/tmp'
+  #
+  #   # 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, regexp_file_filter=/.*/, &callback)
+    if File.file?(path) && regexp_file_filter === File.split(path).last
+      index = index_of(path) || @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, regexp_file_filter, &callback) }
+      return true
+    end
+    false
+  end
+  
+  # The '<<' method works the same way as the 'add' method but does not support a callback.
+  #
+  # Example:
+  #   fm = FileMonitor.new do |path|
+  #     puts "Detected a change on #{path}"
+  #   end
+  #
+  #   # The following will run the default callback when changes are found in the /tmp folder:
+  #   fm << '/tmp'
+  def <<(path)
+    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.
+  #
+  # Example:
+  #   changed_files = []
+  #   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
+    @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 i.digest == key
+        respond_to_change(i, key) 
+      end
+    end
+  end
+
+  # Runs an endless loop watching for changes.  It will sleep for the given interval between looking for changes.  This method
+  # is intended to be run in a subprocess or threaded environment.  The spawn method calls this method and takes care of
+  # the forking and pid management for you.
+  #
+  # Example:
+  #   fm = FileMonitor.new
+  #   fm << '/tmp'
+  #   fm.monitor
+  #   puts "will not get here unless a signal is sent to the process which interrupts the loop."
+  def monitor(interval = 1)
+    trap("INT") do 
+      puts "  FileMonitor was interrupted by Control-C... exiting gracefully"
+      # exit
+      @shutdown = true
+    end
+    
+    trap("USR1") do
+      puts "  FileMonitor was asked nicely to stop."
+      @shutdown = true
+      pid = nil
+    end
+
+    trap("USR2") do
+      puts "  FileMonitor was halted."
+      pid = nil
+      exit
+    end
+
+    
+    while true
+      exit if @shutdown
+      process
+      sleep interval unless @shutdown
+    end
+  end
+
+  # Returns index of watched item or false if non existant.
+  #
+  # Example:
+  #  fm = FileMonitor.new
+  #  fm << '/tmp/first.txt'
+  #  fm << '/tmp/second.txt'
+  #  fm.index_of '/tmp/first.txt'   # => 0
+  #  fm.index_of '/tmp/first.txt'   # => 1
+  #  fm.index_of '/tmp/woops.txt'   # => false
+  def index_of(path)
+    watched.each_with_index {|watched,i| return i if watched.path == path}
+    false
+  end
+
+  # Spauns a child process that is looking for changes at every given interval.  
+  # The interval is in seconds and defaults to 1 second.
+  #
+  # Example:
+  #   fm = FileMonitor.new {|watched_item| puts 'do something when file is changed'}
+  #   fm << @app_root + '/lib'
+  #   fm.spawn        # and now its doing its job... 
+  def spawn(interval = 1)
+    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
+      end
+    end
+    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
+  #
+  # Example:
+  #   fm = FileMonitor.new {|watched_item| puts 'do something when file is changed'}
+  #   fm.spawn        # and now its doing its job...
+  #   fm.stop
+  def stop()
+    # 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
+    end
+  end
+  
+  # Halts a spawned FileMonitor Instance.  The current iteration will be halted in its tracks.  See Also: stop
+  #
+  # Example:
+  #   fm = FileMonitor.new {|watched_item| puts 'do something when file is changed'}
+  #   fm.spawn        # and now its doing its job... 
+  #   fm.stop
+  def halt()
+    if Fixnum === pid
+      Process.kill('USR2', pid)
+      Process.wait pid
+    end
+  end
+  
+private
+  # Returns true or false
+  def process_running?
+    pid ? !`ps -p #{pid}|grep ^[0-9]`.split().empty? : false
+  end
+
+  # Call callback and update digest with given key.
+  def respond_to_change(item, key)
+    if Proc === item.callback     # Use watched instance callback if possible.
+      call item.callback, item, self
+    elsif Proc === self.callback  # Use object level callback if possible.
+      call self.callback, item, self
+    end
+    item.digest(key)
+  end
+
+  # Calls a proc with no more then the needed arguments.  This avoids an error when
+  # calling a proc with two arguments when the proc only handels one argument.
+  def call(proc, *args)
+    if proc.arity > 0
+      proc.call(*args[0..(proc.arity-1)])
+    else
+      proc.call
+    end
+  end
+
+  # Returns new digest if changed or false if unchanged.
+  def changed?(item)
+    d = digest(item.path)         # get current digets
+    d == item.digest ? false : d  # return new digest or false if unchanged
+  end
+
+  # Returns a string representation of the file state.
+  def digest(file)
+    begin
+      File.mtime(file).to_f
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+
+  # 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=/.*/)
+    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.
+      else
+        paths << path if file_name_regexp === path # Amend the return array if the file found matches the regexp
+      end
+    end
+    
+    return paths
+  end
+end

data/lib/FileMonitor/store.rb

@@ -0,0 +1,45 @@
+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.
+  #
+  # Example:
+  #
+  #   s = MonitoredItems::Store.new
+  #   s.path = '/tmp'                       # => "/tmp"
+  #   s.callback Proc.new {'Hello World'}   # => #<Proc:0x0000000100317508@(irb):18>
+  #   s.callback.call                       # => "Hello World"
+  #   s.path                                # => "/tmp"
+  #
+  #   # OR send a hash when initializing the store
+  #   i = MonitoredItems::Store.new({:path => '/tmp'})
+  #   i.path          #=> "/tmp"  
+  class Store 
+    # Supports initialization with a hash of methods & values.  It makes no difference if 
+    # the keys of the hash are strings or symbols, but they are case sensitive.
+    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):
+      mth = "@#{mth}".chomp('=').to_sym
+      # get or set instnace variable
+      arg == Nothing ? self.instance_variable_get(mth) : self.instance_variable_set(mth, arg)
+    end
+    
+    # Return Hash representation of Store object
+    def to_h
+      Hash[*self.instance_variables.collect {|m| [m.slice(1..-1).to_sym, self.instance_variable_get(m)] }.flatten]
+    end
+
+    # Return inspection of hash representation of Store object
+    def to_s
+      self.to_h.inspect
+    end
+  end
+end

data/spec/FileMonitor_spec.rb

@@ -0,0 +1,180 @@
+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
+  end
+  
+  it 'should support adding files' do
+    fm = FileMonitor.new
+    fm.watched.size.should == 0
+    (fm << @app_root + '/lib/FileMonitor.rb').should be_true  # Should add single file using the '<<' method
+    fm.watched.size.should == 1
+    (fm.add @app_root + '/lib/FileMonitor/store.rb').should be_true  # Should add single file using the 'add' method
+    fm.watched.size.should == 2
+  end
+  
+  it 'should add files recursively when given a directory as a path' do
+    fm = FileMonitor.new
+    fm.watched.size.should == 0
+    fm.add(@app_root + '/lib').should be_true  # Should add single file
+    fm.watched.size.should > 1
+  end
+  
+  it 'should respond to index_of' do
+    fm = FileMonitor.new
+    fm.add(@app_root + '/lib').should be_true  # Should add single file
+    fm.watched.size.should > 1
+    fm.index_of(@app_root + '/lib/FileMonitor.rb').should < fm.index_of(@app_root + '/lib/FileMonitor/store.rb')
+    fm.index_of(@app_root + '/lib/not_here.txt').should be_false
+  end
+  
+  it 'should support a FileMonitor object level callback' do
+    fm = FileMonitor.new {true}
+    fm.callback.arity.should == -1
+    
+    fm = FileMonitor.new {|watched_item| true}
+    fm.callback.arity.should == 1
+    
+    fm = FileMonitor.new {|watched_item, file_monitor| true}
+    fm.callback.arity.should == 2
+  end
+  
+  it 'should support adding files with individual callbacks' do
+    proc1 = Proc.new {return "hello from proc 1"}
+    proc2 = Proc.new {return "hello from proc 2"}
+    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.last.callback.should == proc2
+    fm.watched.last.callback.should_not == proc1
+  end
+  
+  it 'should overwrite existing file watches with successive additions' 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
+    fm.watched.size.should == 1
+  end
+  
+  it 'should spawn processes' do
+    fm = FileMonitor.new
+    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]
+  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]
+    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
+  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]
+    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
+  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
+  end
+  
+  it 'should run callback on change' do
+    changed_files = nil
+    filename = @app_root + '/spec/temp.txt'
+    File.open(filename, 'w') {|f| f.write('hello') }
+    
+    fm = FileMonitor.new() {|watched_item| changed_files = watched_item.path}
+    fm << filename
+    
+    original = fm.watched.first.digest
+    sleep 1
+    File.open(filename, 'w') {|f| f.write('hello world') }
+    fm.process
+    fm.watched.first.digest.should_not == original
+    File.delete filename
+  end
+  
+  it 'should use item callback if possible, otherwise object callback' do
+    @global_callback = []
+    @files_callback = []
+    file1 = @app_root + '/spec/temp1.txt'
+    file2 = @app_root + '/spec/temp2.txt'
+    file3 = @app_root + '/spec/temp3.txt'
+    
+    [file1,file2,file3].each {|file| File.open(file, 'w') {|f| f.write('hello') }}
+    
+    fm = FileMonitor.new() {|watched_item| @global_callback << watched_item.path }
+    fm << file1
+    fm.add(file2) {|watched_item| @files_callback << watched_item.path }
+    fm << file3
+    
+    sleep 1
+    [file1,file2,file3].each {|file| File.open(file, 'w') {|f| f.write('Hello World') }}
+    fm.process
+    
+    @global_callback.should == [file1,file3]
+    @files_callback.should == [file2]
+    [file1,file2,file3].each {|file| File.delete(file)}
+  end
+  
+  it 'should have access to local, FileMonitor & Store contexts' do
+    filename = @app_root + '/spec/temp.txt'
+    File.open(filename, 'w') {|f| f.write('hello') }
+    
+    fm = FileMonitor.new() do |watched_item, file_monitor| 
+      MonitoredItems::Store.should === watched_item
+      Spec::Example::ExampleGroup::Subclass_1.should === self
+      FileMonitor.should === file_monitor
+    end
+    fm << filename
+    sleep 1
+    File.open(filename, 'w') {|f| f.write('hello world') }
+    fm.process
+    
+    File.delete filename
+  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 << 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
+end

data/spec/MonitoredItem_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "FileMonitor::Store" do
+  before :all do
+    @item = MonitoredItems::Store.new
+  end
+  
+  it "should store data and be accessable via mehtod() calls" do
+    pth = Dir.pwd
+    @item.file(pth).should == pth
+    @item.file.should == pth
+  end
+  
+  it "should store data and be accessable via mehtod()= calls" do
+    pth = Dir.pwd
+    (@item.file = pth).should == pth
+    @item.file.should == pth
+  end
+  
+  it 'should store keys as methods & values as data when initialized a hash' do
+    i = MonitoredItems::Store.new({'string' => true, :symbol => true, :path => Dir.pwd})
+    i.string.should be_true
+    i.symbol.should be_true
+    i.path.should == Dir.pwd
+  end
+  
+  it 'should know how to to_h' do
+    @item = MonitoredItems::Store.new
+    @item.test true
+    @item.hello = 'world'
+    @item.to_h.should == {:test => true, :hello => 'world'}
+  end
+  
+  it 'should know how to to_s' do
+    @item = MonitoredItems::Store.new
+    @item.test true
+    @item.hello = 'world'
+    @item.to_s.should == '{:test=>true, :hello=>"world"}'
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'FileMonitor'

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

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: joshaven-filemonitor
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Joshaven Potter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: ""
+email: 
+- yourtech@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- CHANGELOG
+- Manifest.txt
+- README.markdown
+- lib/FileMonitor.rb
+- lib/FileMonitor/store.rb
+- spec/FileMonitor_spec.rb
+- spec/MonitoredItem_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+- tasks/rdoc.rake
+has_rdoc: false
+homepage: http://filemonitor.rubyforge.org/
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: filemonitor
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Calls a Proc when a watched file is changed.
+test_files: []
+