filewatch 0.6.6 → 0.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5838846b40579f933b08efa2679143c4d6c3a653
-  data.tar.gz: a0e819627f6fdb49a4aaceeac7e8393596772205
+  metadata.gz: 3c7e0e544aadf722674dd85b5ba0441dce6ecfc4
+  data.tar.gz: 4f6d362df8d9d5f105bcbf12f576e0cf8db69966
 SHA512:
-  metadata.gz: 27da5e65f6aeb55e0cb1b2633c9dc2e8eac7d585d16c9efbc2002e1e01df2260a502d8586783d73beefc9b2dc6a8f70945101592c78eafa221e62e20328b1d14
-  data.tar.gz: 916bfe75bc6b4f1805159ca004497c5a3ca68960f953b2f607fc9469aca77c525e04654c64bd39b612b63b42b684e99722a29277af28e27f2aa48bd9380048c4
+  metadata.gz: 5fa00a10ea8b093e6484aabbd9f653a7d2f06b97dafdcf2a2f2795f750cf2c3f0d8c13b19f2c41809e5284ed44316e7b448eda1499f7c9b817309a53a34d33c9
+  data.tar.gz: 0c8f460f91f9830deb1b096c22facc1106ea99a73ec297ad41384787bfa29f5302760696411d6b2c3517bb9b3eaa226343a0895ac78eb298ee1a04309b16a51a

data/lib/filewatch/tail.rb

@@ -155,7 +155,7 @@ module FileWatch
           @logger.debug? && @logger.debug("#{path}: initial create, no sincedb, seeking to beginning of file")
           @files[path].sysseek(0, IO::SEEK_SET)
           @sincedb[sincedb_record_uid] = 0
-        else 
+        else
           # seek to end
           @logger.debug? && @logger.debug("#{path}: initial create, no sincedb, seeking to end #{stat.size}")
           @files[path].sysseek(stat.size, IO::SEEK_SET)
@@ -229,7 +229,7 @@ module FileWatch
     private
     def _sincedb_write
       path = @opts[:sincedb_path]
-      if File.device?(path)
+      if @iswindows || File.device?(path)
         IO.write(path, serialize_sincedb, 0)
       else
         File.atomic_write(path) {|file| file.write(serialize_sincedb) }
@@ -237,11 +237,31 @@ module FileWatch
     end # def _sincedb_write
 
     public
+    # quit is a sort-of finalizer,
+    # it should be called for clean up
+    # before the instance is disposed of.
     def quit
       _sincedb_write
       @watch.quit
+      @files.each {|path, file| file.close }
+      @files.clear
     end # def quit
 
+    public
+    # close_file(path) is to be used by external code
+    # when it knows that it is completely done with a file.
+    # Other files or folders may still be being watched.
+    # Caution, once unwatched, a file can't be watched again
+    # unless a new instance of this class begins watching again.
+    # The sysadmin should rename, move or delete the file.
+    def close_file(path)
+      @watch.unwatch(path)
+      file = @files.delete(path)
+      return if file.nil?
+      _sincedb_write
+      file.close
+    end
+
     private
     def serialize_sincedb
       @sincedb.map do |inode, pos|

data/lib/filewatch/watch.rb

@@ -19,6 +19,12 @@ module FileWatch
       @watching = []
       @exclude = []
       @files = Hash.new { |h, k| h[k] = Hash.new }
+      @unwatched = Hash.new
+      # we need to be threadsafe about the mutation
+      # of the above 2 ivars because the public
+      # methods each, discover, watch and unwatch
+      # can be called from different threads.
+      @lock = Mutex.new
     end # def initialize
 
     public
@@ -33,19 +39,37 @@ module FileWatch
 
     public
     def watch(path)
-      if ! @watching.member?(path)
-        @watching << path
-        _discover_file(path, true)
+      synchronized do
+        if !@watching.member?(path)
+          @watching << path
+          _discover_file(path, true)
+        end
       end
-
       return true
     end # def watch
 
+    def unwatch(path)
+      synchronized do
+        result = false
+        if @watching.delete(path)
+          _globbed_files(path).each do |file|
+            deleted = @files.delete(file)
+            @unwatched[file] = deleted if deleted
+          end
+          result = true
+        else
+          result = @files.delete(path)
+          @unwatched[path] = result if result
+        end
+        return !!result
+      end
+    end
+
     public
     def inode(path,stat)
       if @iswindows
         fileId = Winhelper.GetWindowsUniqueFileIdentifier(path)
-        inode = [fileId, stat.dev_major, stat.dev_minor]
+        inode = [fileId, 0, 0] # dev_* doesn't make sense on Windows
       else
         inode = [stat.ino.to_s, stat.dev_major, stat.dev_minor]
       end
@@ -60,52 +84,56 @@ module FileWatch
     #   :delete - file is deleted
     public
     def each(&block)
-      # Send any creates.
-      @files.keys.each do |path|
-        if ! @files[path][:create_sent]
-          if @files[path][:initial]
-            yield(:create_initial, path)
-          else
-            yield(:create, path)
+      synchronized do
+        # Send any creates.
+        @files.keys.each do |path|
+          if ! @files[path][:create_sent]
+            if @files[path][:initial]
+              yield(:create_initial, path)
+            else
+              yield(:create, path)
+            end
+            @files[path][:create_sent] = true
           end
-          @files[path][:create_sent] = true
         end
-      end
 
-      @files.keys.each do |path|
-        begin
-          stat = File::Stat.new(path)
-        rescue Errno::ENOENT
-          # file has gone away or we can't read it anymore.
-          @files.delete(path)
-          @logger.debug? && @logger.debug("#{path}: stat failed (#{$!}), deleting from @files")
-          yield(:delete, path)
-          next
-        end
+        @files.keys.each do |path|
+          begin
+            stat = File::Stat.new(path)
+          rescue Errno::ENOENT
+            # file has gone away or we can't read it anymore.
+            @files.delete(path)
+            @logger.debug? && @logger.debug("#{path}: stat failed (#{$!}), deleting from @files")
+            yield(:delete, path)
+            next
+          end
 
-        inode = inode(path,stat)
-        if inode != @files[path][:inode]
-          @logger.debug? && @logger.debug("#{path}: old inode was #{@files[path][:inode].inspect}, new is #{inode.inspect}")
-          yield(:delete, path)
-          yield(:create, path)
-        elsif stat.size < @files[path][:size]
-          @logger.debug? && @logger.debug("#{path}: file rolled, new size is #{stat.size}, old size #{@files[path][:size]}")
-          yield(:delete, path)
-          yield(:create, path)
-        elsif stat.size > @files[path][:size]
-          @logger.debug? && @logger.debug("#{path}: file grew, old size #{@files[path][:size]}, new size #{stat.size}")
-          yield(:modify, path)
-        end
+          inode = inode(path,stat)
+          if inode != @files[path][:inode]
+            @logger.debug? && @logger.debug("#{path}: old inode was #{@files[path][:inode].inspect}, new is #{inode.inspect}")
+            yield(:delete, path)
+            yield(:create, path)
+          elsif stat.size < @files[path][:size]
+            @logger.debug? && @logger.debug("#{path}: file rolled, new size is #{stat.size}, old size #{@files[path][:size]}")
+            yield(:delete, path)
+            yield(:create, path)
+          elsif stat.size > @files[path][:size]
+            @logger.debug? && @logger.debug("#{path}: file grew, old size #{@files[path][:size]}, new size #{stat.size}")
+            yield(:modify, path)
+          end
 
-        @files[path][:size] = stat.size
-        @files[path][:inode] = inode
-      end # @files.keys.each
+          @files[path][:size] = stat.size
+          @files[path][:inode] = inode
+        end # @files.keys.each
+      end
     end # def each
 
     public
     def discover
-      @watching.each do |path|
-        _discover_file(path)
+      synchronized do
+        @watching.each do |path|
+          _discover_file(path)
+        end
       end
     end
 
@@ -128,14 +156,9 @@ module FileWatch
 
     private
     def _discover_file(path, initial=false)
-      globbed_dirs = Dir.glob(path)
-      @logger.debug? && @logger.debug("_discover_file_glob: #{path}: glob is: #{globbed_dirs}")
-      if globbed_dirs.empty? && File.file?(path)
-        globbed_dirs = [path]
-        @logger.debug? && @logger.debug("_discover_file_glob: #{path}: glob is: #{globbed_dirs} because glob did not work")
-      end
-      globbed_dirs.each do |file|
+      _globbed_files(path).each do |file|
         next if @files.member?(file)
+        next if @unwatched.member?(file)
         next unless File.file?(file)
 
         @logger.debug? && @logger.debug("_discover_file: #{path}: new: #{file} (exclude is #{@exclude.inspect})")
@@ -161,6 +184,23 @@ module FileWatch
       end
     end # def _discover_file
 
+    private
+    def _globbed_files(path)
+      globbed_dirs = Dir.glob(path)
+      @logger.debug? && @logger.debug("_globbed_files: #{path}: glob is: #{globbed_dirs}")
+      if globbed_dirs.empty? && File.file?(path)
+        globbed_dirs = [path]
+        @logger.debug? && @logger.debug("_globbed_files: #{path}: glob is: #{globbed_dirs} because glob did not work")
+      end
+      # return Enumerator
+      globbed_dirs.to_enum
+    end
+
+    private
+    def synchronized(&block)
+      @lock.synchronize { block.call }
+    end
+
     public
     def quit
       @quit = true

data/spec/buftok_spec.rb

@@ -0,0 +1,18 @@
+require 'filewatch/buftok'
+
+describe FileWatch::BufferedTokenizer do
+
+  context "when using the default delimiter" do
+    it "splits the lines correctly" do
+      expect(subject.extract("hello\nworld\n")).to eq ["hello", "world"]
+    end
+  end
+
+  context "when passing a custom delimiter" do
+    subject { FileWatch::BufferedTokenizer.new("\r\n") }
+
+    it "splits the lines correctly" do
+      expect(subject.extract("hello\r\nworld\r\n")).to eq ["hello", "world"]
+    end
+  end
+end

data/spec/tail_spec.rb

@@ -0,0 +1,232 @@
+require 'filewatch/tail'
+require 'stud/temporary'
+require "rbconfig"
+
+describe FileWatch::Tail do
+  before(:all) do
+    @thread_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+
+  after(:all) do
+    Thread.abort_on_exception = @thread_abort
+  end
+
+  let(:file_path) { f = Stud::Temporary.pathname }
+  let(:sincedb_path) { Stud::Temporary.pathname }
+
+  before :each do
+    Thread.new(subject) { sleep 0.5; subject.quit } # force the subscribe loop to exit
+  end
+
+  context "when watching a new file" do
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning, :stat_interval => 0) }
+
+    before :each do
+      subject.tail(file_path)
+      File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+    end
+
+    it "reads new lines off the file" do
+      expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"])
+    end
+  end
+
+  context "when watching a file" do
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning, :stat_interval => 0) }
+
+    before :each do
+      File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+      subject.tail(file_path)
+    end
+
+    it "reads new lines off the file" do
+      expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"])
+    end
+
+  end
+
+  context "when watching a CRLF file" do
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path,
+                                  :start_new_files_at => :beginning,
+                                  :delimiter => "\r\n") }
+
+    before :each do
+      File.open(file_path, "wb") { |file|  file.write("line1\r\nline2\r\n") }
+      subject.tail(file_path)
+    end
+
+    it "reads new lines off the file" do
+      expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"])
+    end
+  end
+
+  context "when a file is deleted" do
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning) }
+
+    before :each do
+      File.open(file_path, "w") { |file|  file.write("line1\nline2\n") }
+      subject.tail(file_path)
+      File.unlink file_path
+    end
+
+    it "should not raise exception" do
+      Thread.new(subject) { sleep 0.1; subject.quit } # force the subscribe loop to exit
+      expect { subject.subscribe {|p,l| } }.to_not raise_exception
+    end
+  end
+
+  describe "sincedb" do
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning, :stat_interval => 0) }
+
+    before :each do
+      File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+      subject.tail(file_path)
+    end
+
+    context "when reading a new file" do
+      it "updates sincedb after subscribe" do
+        subject.subscribe {|_,_|  }
+        stat = File::Stat.new(file_path)
+        sincedb_id = subject.sincedb_record_uid(file_path,stat).join(' ')
+        expect(File.read(sincedb_path)).to eq("#{sincedb_id} #{stat.size}\n")
+      end
+    end
+
+    context "when restarting tail" do
+      before :each do
+        subject.subscribe {|_,_| }
+        sleep 0.6 # wait for tail.quit
+        subject.tail(file_path) # re-tail file
+        File.open(file_path, "ab") { |file| file.write("line3\nline4\n") }
+        Thread.new(subject) { sleep 0.5; subject.quit }
+      end
+
+      it "picks off from where it stopped" do
+        expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line3"], [file_path, "line4"])
+      end
+
+      it "updates on tail.quit" do
+        subject.subscribe {|_,_| }
+        stat = File::Stat.new(file_path)
+        sincedb_id = subject.sincedb_record_uid(file_path,stat).join(' ')
+        expect(File.read(sincedb_path)).to eq("#{sincedb_id} #{stat.size}\n")
+      end
+    end
+  end
+
+  context "ingesting files bigger than 32k" do
+    let(:lineA) { "a" * 12000 }
+    let(:lineB) { "b" * 25000 }
+    let(:lineC) { "c" * 8000 }
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning) }
+
+    before :each do
+      IO.write(file_path, "#{lineA}\n#{lineB}\n#{lineC}\n")
+    end
+
+    context "when restarting after stopping at the first line" do
+
+      let(:new_subject) { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning) }
+
+      before :each do
+        subject.tail(file_path)
+        subject.subscribe {|f, l| break if @test; @test = 1}
+        subject.sincedb_write
+        subject.quit
+        Thread.new(new_subject) { sleep 0.5; new_subject.quit } # force the subscribe loop to exit
+      end
+
+      it "should store in sincedb the position up until the first string" do
+        device, dev_major, dev_minor, pos = *IO.read(sincedb_path).split(" ").map {|n| n.to_i }
+        expect(pos).to eq(12001) # string.bytesize + "\n".bytesize
+      end
+
+      it "should read the second and third lines entirely" do
+        new_subject.tail(file_path) # re-tail file
+        expect { |b| new_subject.subscribe(&b) }.to yield_successive_args([file_path, lineB], [file_path, lineC])
+      end
+    end
+  end
+
+  context "when watching a directory" do
+
+    let(:directory) { Stud::Temporary.directory }
+    let(:file_path) { File.join(directory, "1.log") }
+
+    subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning, :stat_interval => 0) }
+
+    before :each do
+      File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+      subject.tail(File.join(directory, "*"))
+    end
+
+    after :each do
+      FileUtils.rm_rf(directory)
+    end
+
+    it "reads new lines from the beginning" do
+      expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"])
+    end
+
+    context "when a file is renamed" do
+
+      before :each do
+        expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"])
+        File.rename(file_path, file_path + ".bak")
+      end
+
+      it "should not re-read the file" do
+        Thread.new(subject) { |s| sleep 1; s.quit }
+        expect { |b| subject.subscribe(&b) }.not_to yield_control
+      end
+    end
+
+    let(:new_file_path) { File.join(directory, "2.log") }
+
+    context "when a new file is later added to the directory" do
+      # Note tests in this context rely on FileWatch::Watch reading
+      # file 1.log first then 2.log and that depends on how Dir.glob is implemented
+      # in different rubies on different operating systems
+      before do
+        File.open(new_file_path, "wb") { |file|  file.write("line2.1\nline2.2\n") }
+      end
+
+      it "reads new lines from the beginning for all files" do
+        expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"],
+                                                                        [new_file_path, "line2.1"], [new_file_path, "line2.2"])
+      end
+
+      context "and when the sincedb path is not given" do
+        subject { FileWatch::Tail.new(:start_new_files_at => :beginning, :stat_interval => 0) }
+
+        it "reads new lines from the beginning for all files" do
+          expect { |b| subject.subscribe(&b) }.to yield_successive_args([file_path, "line1"], [file_path, "line2"],
+                                                                        [new_file_path, "line2.1"], [new_file_path, "line2.2"])
+        end
+      end
+    end
+  end
+
+  if RbConfig::CONFIG['host_os'] !~ /mswin|mingw|cygwin/
+    context "when quiting" do
+      subject { FileWatch::Tail.new(:sincedb_path => sincedb_path, :start_new_files_at => :beginning, :stat_interval => 0) }
+
+      before :each do
+        subject.tail(file_path)
+        File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+      end
+
+      it "closes the file handles" do
+        buffer = []
+        subject.subscribe do |path, line|
+          buffer.push([path, line])
+        end
+        subject.sincedb_write
+        subject.quit
+        lsof = `lsof -p #{Process.pid} | grep #{file_path}`
+        expect(lsof).to be_empty
+      end
+    end
+  end
+end

data/spec/watch_spec.rb

@@ -0,0 +1,120 @@
+require 'filewatch/watch'
+require 'stud/temporary'
+
+describe FileWatch::Watch do
+  before(:all) do
+    @thread_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+
+  after(:all) do
+    Thread.abort_on_exception = @thread_abort
+  end
+
+  let(:directory) { Stud::Temporary.directory }
+  let(:file_path) { File.join(directory, "1.log") }
+  let(:loggr)     { double("loggr", :debug? => true) }
+  let(:results)   { [] }
+  let(:quit_proc) do
+    lambda do
+      Thread.new do
+        sleep 1
+        subject.quit
+      end
+    end
+  end
+  let(:subscribe_proc) do
+    lambda do
+      subject.subscribe(0.1, 4) do |event, path|
+        results.push([event, path])
+      end
+    end
+  end
+  let(:write_lines_1_and_2_proc) do
+    lambda do
+      File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+    end
+  end
+
+  subject { FileWatch::Watch.new(:logger => loggr) }
+
+  before do
+    allow(loggr).to receive(:debug)
+  end
+
+  after do
+    FileUtils.rm_rf(directory)
+  end
+
+  context "when watching a directory with files" do
+    it "yields create_initial and one modify file events" do
+      write_lines_1_and_2_proc.call
+      subject.watch(File.join(directory, "*"))
+      quit_proc.call
+      subscribe_proc.call
+      expect(results).to eq([[:create_initial, file_path], [:modify, file_path]])
+    end
+  end
+
+  context "when watching a directory without files and one is added" do
+    it "yields create and one modify file events" do
+      subject.watch(File.join(directory, "*"))
+      write_lines_1_and_2_proc.call
+
+      quit_proc.call
+      subscribe_proc.call
+
+      expect(results).to eq([[:create, file_path], [:modify, file_path]])
+    end
+  end
+
+  context "when watching a directory with files and data is appended" do
+    let(:write_lines_3_and_4_proc) do
+      lambda do
+        Thread.new do
+          sleep 0.5
+          File.open(file_path, "ab") { |file|  file.write("line3\nline4\n") }
+        end
+      end
+    end
+
+    it "yields create_initial and two modified file events" do
+      write_lines_1_and_2_proc.call
+      subject.watch(File.join(directory, "*"))
+
+      write_lines_3_and_4_proc.call # asynchronous
+
+      quit_proc.call
+      subscribe_proc.call
+
+      expect(results).to eq([[:create_initial, file_path], [:modify, file_path], [:modify, file_path]])
+    end
+  end
+
+  context "when unwatching a file and data is appended" do
+    let(:write_lines_3_and_4_proc) do
+      lambda do
+        Thread.new do
+          sleep 0.2
+          results.clear
+          subject.unwatch(file_path)
+          sleep 0.2
+          File.open(file_path, "ab") { |file|  file.write("line3\nline4\n") }
+        end
+      end
+    end
+
+    it "does not yield events after unwatching" do
+      write_lines_1_and_2_proc.call
+      subject.watch(File.join(directory, "*"))
+
+      write_lines_3_and_4_proc.call # asynchronous
+
+      quit_proc.call
+      subscribe_proc.call
+
+      expect(results).to eq([])
+    end
+  end
+
+end

data/spec/winhelper_spec.rb

@@ -0,0 +1,22 @@
+require "stud/temporary"
+require "fileutils"
+
+if Gem.win_platform?
+  require "lib/filewatch/winhelper"
+
+  describe Winhelper do
+    let(:path) { Stud::Temporary.file.path }
+
+    after do
+      FileUtils.rm_rf(path)
+    end
+
+    it "return a unique file identifier" do
+      volume_serial, file_index_low, file_index_high = Winhelper.GetWindowsUniqueFileIdentifier(path).split("").map(&:to_i)
+
+      expect(volume_serial).not_to eq(0)
+      expect(file_index_low).not_to eq(0)
+      expect(file_index_high).not_to eq(0)
+    end
+  end
+end

metadata

@@ -1,31 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: filewatch
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.6.7
 platform: ruby
 authors:
 - Jordan Sissel
 - Pete Fritchman
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: stud
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  name: stud
-  prerelease: false
   type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Watch files and directories in ruby. Also supports tailing and glob file patterns.
+description: Watch files and directories in ruby. Also supports tailing and glob file
+  patterns.
 email:
 - jls@semicomplete.com
 - petef@databits.net
@@ -41,6 +42,10 @@ files:
 - lib/filewatch/tail.rb
 - lib/filewatch/watch.rb
 - lib/filewatch/winhelper.rb
+- spec/buftok_spec.rb
+- spec/tail_spec.rb
+- spec/watch_spec.rb
+- spec/winhelper_spec.rb
 - test/filewatch/tail.rb
 - test/globtail/Makefile
 - test/globtail/framework.sh
@@ -67,25 +72,25 @@ files:
 homepage: https://github.com/jordansissel/ruby-filewatch
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project:
-rubygems_version: 2.4.8
-signing_key:
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
 specification_version: 4
 summary: filewatch - file watching for ruby
 test_files: []