filemonitor 0.0.1 → 0.0.2

data/History.txt

@@ -1,4 +1,16 @@
+=== 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
+  * Initial release

data/Manifest.txt

@@ -3,10 +3,12 @@ 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

data/README.markdown

@@ -5,7 +5,11 @@
 
 ## DESCRIPTION
 
-Watches the file system for changes.
+Watches the file system for changes.  
+
+## 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.
 
 ## Usage
     require 'filemonitor'

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/lib/FileMonitor.rb

@@ -1,111 +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 'file_monitor'
-# > file_spy = FileMonitor.new
-# > file_spy.add(Dir.pwd) do |i|
-# >   puts "you probably should handle the change in #{i.file}"
-# > end
-# > file_spy.spawn
-
-require 'digest/md5'
-
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-  
-module HashAccess
-  def method_missing(mth, *args)
-    return args.empty? ? self[mth] : self[mth.to_s.chomp('=').to_sym]=args.first
-  end
-end
-
+#
+#   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.1'
-  attr_accessor :spawns
-  def initialize()
+  VERSION = '0.0.2'
+  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
-
-  def add(item, &callback)
-    if File.file? item
-      h = {:file=>File.expand_path(item), :callback=>callback}
-      h.extend(HashAccess)
-      @watched << h
-    elsif File.directory? item
-      files_recursive(item).each {|f| add(f, &callback) }
+  
+  # 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.
+  #
+  # 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 its own callback on changed files in the /home folder:
+  #   fm.add '/home' 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)})
+      return true
+    elsif File.directory? path
+      files_recursive(path).each {|f| add(f, &callback) }
+      return true
     end
+    false
   end
-
-  def changes?
-    return first_changed
+  
+  # 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
   end
 
-  def process
-    # itterates watched files and runs callbacks when changes are detected.
+  # 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(options={})
     @watched.each do |i|
-      key = digest(i.file)
-      i.digest = key if i.digest.nil?  # skip first change detection, its always unknown on first run
-      update(i, key) unless i.digest == key
+      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) 
+      end
     end
   end
 
-  def watching
-    # Returns an Array of files being watched
-    @watched
-  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 
-      STDERR.puts "  Interrupted by Control-C"
-      exit 2
+      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
+      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 @spawns.nil? 
-      @spawns = fork {monitor interval}
-      Process.detach(@spawns)
+    if pid.nil? 
+      @pid = fork {monitor interval}
+      Process.detach(pid)
+      
       Kernel.at_exit do
-        Process.kill('HUP', @spawns)
-        @spawns = nil
+        # sends the kill command unless the pid is not found on the system
+        Process.kill('HUP', pid) if process_running?
+        pid = nil
       end
-      true
-    else
-      @spawns
     end
-    @spawns ||= []
+    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
-  def update(item, key)
-    item.callback.call(item) unless item.callback.nil?
-    item.digest= key
+  # Returns true or false
+  def process_running?
+    pid ? !`ps -p #{pid}|grep ^[0-9]`.split().empty? : false
   end
 
-  def first_changed
-    # returns first changed item or false
-    @watched.each {|i| return i if changed? i}
-    false
+  # Call callback and update digest with given key.
+  def respond_to_change(item, key, options)
+    if Proc === item.callback     # Use watched instance callback if possible.
+      call item.callback, item, self, options
+    elsif Proc === self.callback  # Use object level callback if possible.
+      call self.callback, item, self, options
+    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)
-    # returns md5 if changed, returns false when not changed
-    md5 = digest(item.file) 
-    md5 == item.digest ? false : md5
+    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)
-    # returns the md5 of a file
-    Digest::MD5.hexdigest( File.read(file) )
+    begin
+      File.mtime(file).to_f
+    rescue Errno::ENOENT
+      nil
+    end
   end
 
-  def files_recursive(dirname)
-    # return an array of files from this (dirname) point forth.
-    Dir["#{dirname}/**/**"].collect {|f| f if File.file? f }.compact
+  # 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/spec/FileMonitor_spec.rb

@@ -2,10 +2,171 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 
 # Time to add your specs!
 # http://rspec.info/
-describe "Place your specs here" do
+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 "find this spec in spec directory" do
-    # violated "Be sure to write your specs"
+  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
   
-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
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: filemonitor
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Joshaven Potter
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-15 00:00:00 -04:00
+date: 2009-09-24 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,10 +38,12 @@ files:
 - 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