listen 2.7.4 → 2.7.5

data/lib/listen/directory.rb

@@ -15,7 +15,9 @@ module Listen
         when 'File'
           _async_change(entry_path, options.merge(type: 'File'))
         when 'Dir'
-          _async_change(entry_path, options.merge(type: 'Dir')) if _recursive_scan?(entry_path)
+          if _recursive_scan?(entry_path)
+            _async_change(entry_path, options.merge(type: 'Dir'))
+          end
         end
       end
     end
@@ -23,8 +25,8 @@ module Listen
     private
 
     def _update_record
-      if ::Dir.exists?(path)
-        _record.async.set_path(path, { type: 'Dir'})
+      if ::Dir.exist?(path)
+        _record.async.set_path(path,  type: 'Dir')
       else
         _record.async.unset_path(path)
       end
@@ -35,9 +37,9 @@ module Listen
     end
 
     def _entries
-      return {} unless ::Dir.exists?(path)
+      return {} unless ::Dir.exist?(path)
 
-      entries = ::Dir.entries(path) - %w[. ..]
+      entries = ::Dir.entries(path) - %w(. ..)
       entries = entries.map { |entry| [entry, type: _entry_type(entry)] }
       Hash[*entries.flatten]
     end
@@ -65,7 +67,7 @@ module Listen
     end
 
     def _recursive_scan?(path)
-      !::Dir.exists?(path) || options[:recursive]
+      !::Dir.exist?(path) || options[:recursive]
     end
 
     def _async_change(entry_path, options)

data/lib/listen/listener.rb

@@ -3,14 +3,13 @@ require 'listen/adapter'
 require 'listen/change'
 require 'listen/record'
 require 'listen/silencer'
+require 'English'
 
 module Listen
   class Listener
     attr_accessor :options, :directories, :paused, :changes, :block, :stopping
     attr_accessor :registry, :supervisor
 
-    RELATIVE_PATHS_WITH_MULTIPLE_DIRECTORIES_WARNING_MESSAGE = "The relative_paths option doesn't work when listening to multiple diretories."
-
     # Initializes the directories listener.
     #
     # @param [String] directory the directories to listen to
@@ -78,7 +77,10 @@ module Listen
       @paused == false && @stopping == false
     end
 
-    # Adds ignore patterns to the existing one (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer)
+    # Adds ignore patterns to the existing one
+    #
+    # @see DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in
+    #   Listen::Silencer)
     #
     # @param [Regexp, Array<Regexp>] new ignoring patterns.
     #
@@ -87,7 +89,10 @@ module Listen
       registry[:silencer] = Silencer.new(self)
     end
 
-    # Overwrites ignore patterns (See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::Silencer)
+    # Overwrites ignore patterns
+    #
+    # @see DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in
+    #   Listen::Silencer)
     #
     # @param [Regexp, Array<Regexp>] new ignoring patterns.
     #
@@ -118,7 +123,12 @@ module Listen
 
     def _init_debug
       if options[:debug] || ENV['LISTEN_GEM_DEBUGGING'] =~ /true|1/i
-        Celluloid.logger.level = Logger::INFO
+        if RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/
+          Celluloid.logger.level = Logger::INFO
+        else
+          # BSDs silently fail ;;(
+          Celluloid.logger.level = Logger::DEBUG
+        end
       else
         Celluloid.logger.level = Logger::FATAL
       end
@@ -161,21 +171,16 @@ module Listen
     end
 
     def _smoosh_changes(changes)
-      if _local_fs?
+      if registry[:adapter].class.local_fs?
         cookies = changes.group_by { |x| x[:cookie] }
         _squash_changes(_reinterpret_related_changes(cookies))
       else
         smooshed = { modified: [], added: [], removed: [] }
-        changes.each { |h| type = h.keys.first; smooshed[type] << h[type].to_s }
-        smooshed.each { |_, v| v.uniq! }
-        smooshed
+        changes.map(&:first).each { |type, path| smooshed[type] << path.to_s }
+        smooshed.tap { |s| s.each { |_, v| v.uniq! } }
       end
     end
 
-    def _local_fs?
-      !registry[:adapter].is_a?(Adapter::TCP)
-    end
-
     def _squash_changes(changes)
       actions = changes.group_by(&:last).map do |path, action_list|
         [_logical_action_for(path, action_list.map(&:first)), path.to_s]
@@ -194,7 +199,7 @@ module Listen
       actions << :added if actions.delete(:moved_to)
       actions << :removed if actions.delete(:moved_from)
 
-      modified = actions.find { |x| x == :modified }
+      modified = actions.detect { |x| x == :modified }
       _calculate_add_remove_difference(actions, path, modified)
     end
 
@@ -220,14 +225,15 @@ module Listen
     # editor rename() call (e.g. Kate and Sublime)
     def _reinterpret_related_changes(cookies)
       table = { moved_to: :added, moved_from: :removed }
-      cookies.map do |cookie, changes|
+      cookies.map do |_, changes|
         file = _detect_possible_editor_save(changes)
         if file
           [[:modified, file]]
         else
-          changes.map(&:first).reject do |type, path|
+          not_silenced = changes.map(&:first).reject do |_, path|
             _silenced?(path)
-          end.map { |type, path| [table.fetch(type, type), path] }
+          end
+          not_silenced.map { |type, path| [table.fetch(type, type), path] }
         end
       end.flatten(1)
     end
@@ -235,9 +241,9 @@ module Listen
     def _detect_possible_editor_save(changes)
       return unless changes.size == 2
 
-      from, to = changes.sort { |x,y| x.keys.first <=> y.keys.first }
+      from, to = changes.sort { |x, y| x.keys.first <=> y.keys.first }
       from, to = from[:moved_from], to[:moved_to]
-      return unless from and to
+      return unless from && to
 
       # Expect an ignored moved_from and non-ignored moved_to
       # to qualify as an "editor modify"

data/lib/listen/record.rb

@@ -10,7 +10,8 @@ module Listen
     end
 
     def set_path(path, data)
-      @paths[::File.dirname(path)][::File.basename(path)] = file_data(path).merge(data)
+      new_data = file_data(path).merge(data)
+      @paths[::File.dirname(path)][::File.basename(path)] = new_data
     end
 
     def unset_path(path)
@@ -28,7 +29,8 @@ module Listen
     def build
       @paths = _init_paths
       listener.directories.each do |path|
-        listener.registry[:change_pool].change(path, type: 'Dir', recursive: true, silence: true)
+        options = { type: 'Dir', recursive: true, silence: true }
+        listener.registry[:change_pool].change(path, options)
       end
     end
 

data/lib/listen/silencer.rb

@@ -3,11 +3,33 @@ module Listen
     include Celluloid
 
     # The default list of directories that get ignored.
-    DEFAULT_IGNORED_DIRECTORIES = %w[.bundle .git .hg .rbx .svn bundle log tmp vendor/ruby vendor/bundle]
+    DEFAULT_IGNORED_DIRECTORIES = %r{^(?:
+      \.git
+      | \.svn
+      | \.hg
+      | \.rbx
+      | \.bundle
+      | bundle
+      | vendor/bundle
+      | log
+      | tmp
+      |vendor/ruby
+    )(/|$)}x
 
     # The default list of files that get ignored.
-    KATE_TEMP_FILES = /\..*[a-z]\d+\.new/
-    DEFAULT_IGNORED_EXTENSIONS  = %w(.DS_Store .tmp ~) + [KATE_TEMP_FILES]
+    DEFAULT_IGNORED_EXTENSIONS  = %r{(?:
+      # Kate's tmp/swp files
+      \..*\d+\.new
+      | \.kate-swp
+
+      # Gedit tmp files
+      | \.goutputstream-.{6}
+
+      # other files
+      | \.DS_Store
+      | \.tmp
+      | ~
+    )$}x
 
     attr_accessor :listener, :only_patterns, :ignore_patterns
 
@@ -20,11 +42,18 @@ module Listen
     def silenced?(path, type = 'Unknown')
       silenced = false
 
+      relative_path = _relative_path(path)
+
       if only_patterns && type == 'File'
-        silenced = !only_patterns.any? { |pattern| _relative_path(path) =~ pattern }
+        silenced = !only_patterns.any? { |pattern| relative_path =~ pattern }
       end
 
-      silenced ||= ignore_patterns.any? { |pattern| _relative_path(path) =~ pattern }
+      silenced || ignore_patterns.any? { |pattern| relative_path =~ pattern }
+    end
+
+    def match(args)
+      path, type = args.first
+      silenced?(path, type)
     end
 
     private
@@ -36,33 +65,34 @@ module Listen
     end
 
     def _init_ignore_patterns
-      @ignore_patterns = []
-      @ignore_patterns << _default_ignore_patterns unless listener.options[:ignore!]
-      @ignore_patterns << listener.options[:ignore] << listener.options[:ignore!]
-      @ignore_patterns.compact!
-      @ignore_patterns.flatten!
-    end
+      options = listener.options
 
-    def _default_ignore_patterns
-      [_default_ignored_directories_patterns, _default_ignored_extensions_patterns]
-    end
+      patterns = []
+      unless options[:ignore!]
+        patterns << DEFAULT_IGNORED_DIRECTORIES
+        patterns << DEFAULT_IGNORED_EXTENSIONS
+      end
 
-    def _default_ignored_directories_patterns
-      ignored_directories = DEFAULT_IGNORED_DIRECTORIES.map { |d| Regexp.escape(d) }
-      %r{^(?:#{ignored_directories.join('|')})(/|$)}
-    end
+      patterns << options[:ignore]
+      patterns << options[:ignore!]
 
-    def _default_ignored_extensions_patterns
-      ignored_extensions = DEFAULT_IGNORED_EXTENSIONS.map do
-        |e| e.is_a?(Regexp) ? e : Regexp.escape(e)
-      end
+      patterns.compact!
+      patterns.flatten!
 
-      %r{(?:#{ignored_extensions.join('|')})$}
+      @ignore_patterns = patterns
     end
 
     def _relative_path(path)
-      relative_paths = listener.directories.map { |dir| path.relative_path_from(dir).to_s }
-      relative_paths.detect { |path| !path.start_with?('../') }
+      relative_paths = listener.directories.map do |dir|
+        begin
+          path.relative_path_from(dir).to_s
+        rescue ArgumentError
+          # Windows raises errors across drives, e.g. when 'C:/' and 'E:/dir'
+          # So, here's a Dirty hack to fool the detect() below..
+          '../'
+        end
+      end
+      relative_paths.detect { |rel_path| !rel_path.start_with?('../') }
     end
   end
 end

data/lib/listen/tcp.rb

@@ -0,0 +1,9 @@
+begin
+  require 'celluloid/io'
+rescue LoadError
+  Kernel.fail 'TCP forwarding requires Celluloid::IO to be present. ' \
+              "Please install or add as a dependency: gem 'celluloid-io'"
+end
+
+require 'listen/adapter/tcp'
+require 'listen/tcp/listener'

data/lib/listen/tcp/broadcaster.rb

@@ -65,8 +65,6 @@ module Listen
       def handle_connection(socket)
         @sockets << socket
       end
-
     end
-
   end
 end

data/lib/listen/tcp/listener.rb

@@ -4,7 +4,6 @@ require 'listen/tcp/message'
 module Listen
   module TCP
     class Listener < Listen::Listener
-
       DEFAULT_HOST = 'localhost'
 
       attr_reader :host, :mode, :port
@@ -43,18 +42,24 @@ module Listen
       # Hook to broadcast changes over TCP
       def block
         if broadcaster?
-          Proc.new { |modified, added, removed|
+          proc do |modified, added, removed|
 
             # Honour paused and stopped states
             next if @paused || @stopping
 
-            # Broadcast changes as a hash (see Listen::Adapter::TCP#handle_message)
-            message = Message.new(modified: modified, added: added, removed: removed)
+            # Broadcast changes as a hash
+            #
+            # @see Listen::Adapter::TCP#handle_message
+            message = Message.new(
+              modified: modified,
+              added: added,
+              removed: removed)
+
             registry[:broadcaster].async.broadcast(message.payload)
 
             # Invoke the original callback block
             @block.call(modified, added, removed) if @block
-          }
+          end
         else
           super
         end
@@ -74,7 +79,8 @@ module Listen
       #
       def mode=(mode)
         unless [:broadcaster, :recipient].include? mode
-          raise ArgumentError, 'TCP::Listener requires mode to be either :broadcaster or :recipient'
+          fail ArgumentError, 'TCP::Listener requires mode to be either'\
+            ' :broadcaster or :recipient'
         end
         @mode = mode
       end
@@ -85,7 +91,7 @@ module Listen
       #
       def target=(target)
         unless target
-          raise ArgumentError, 'TCP::Listener requires target to be given'
+          fail ArgumentError, 'TCP::Listener requires target to be given'
         end
 
         @host = DEFAULT_HOST if recipient?
@@ -97,7 +103,6 @@ module Listen
           @port = @port.to_i
         end
       end
-
     end
   end
 end

data/lib/listen/tcp/message.rb

@@ -3,7 +3,6 @@ require 'json'
 module Listen
   module TCP
     class Message
-
       attr_reader :body, :object, :payload, :size
 
       HEADER_SIZE    = 4
@@ -46,7 +45,6 @@ module Listen
           end
         end
       end
-
     end
   end
 end

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.7.4'
+  VERSION = '2.7.5'
 end

data/listen.gemspec

@@ -11,21 +11,22 @@ Gem::Specification.new do |s|
   s.email       = 'thibaud@thibaud.gg'
   s.homepage    = 'https://github.com/guard/listen'
   s.summary     = 'Listen to file modifications'
-  s.description = 'The Listen gem listens to file modifications and notifies you about the changes. Works everywhere!'
+  s.description = 'The Listen gem listens to file modifications and '\
+    'notifies you about the changes. Works everywhere!'
 
   s.files        = `git ls-files`.split($/)
   s.test_files   = s.files.grep(%r{^spec/})
   s.executable   = 'listen'
   s.require_path = 'lib'
 
-  s.required_ruby_version = ">= 1.9.3"
+  s.required_ruby_version = '>= 1.9.3'
 
   s.add_dependency 'celluloid',  '>= 0.15.2'
-  s.add_dependency 'celluloid-io', '>= 0.15.0'
   s.add_dependency 'rb-fsevent', '>= 0.9.3'
   s.add_dependency 'rb-inotify', '>= 0.9'
 
   s.add_development_dependency 'bundler', '>= 1.3.5'
+  s.add_development_dependency 'celluloid-io', '>= 0.15.0'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '~> 2.14'
   s.add_development_dependency 'rspec-retry'

data/spec/acceptance/listen_spec.rb

@@ -1,29 +1,35 @@
 # encoding: UTF-8
 require 'spec_helper'
 
-describe "Listen" do
-  let(:options) { { } }
-  let(:callback) { ->(modified, added, removed) {
-    add_changes(:modified, modified)
-    add_changes(:added, added)
-    add_changes(:removed, removed)
-  } }
+describe 'Listen' do
+  let(:options) { {} }
+
+  let(:callback) do
+    lambda do |modified, added, removed|
+      add_changes(:modified, modified)
+      add_changes(:added, added)
+      add_changes(:removed, removed)
+    end
+  end
+
   let(:listener) { @listener }
-  before {
+  before do
     @listener = setup_listener(options, callback)
     @listener.start
-  }
+  end
+
   after { listener.stop }
 
-  context "with one listen dir" do
+  context 'with one listen dir' do
     let(:paths) { Pathname.new(Dir.pwd) }
-    around { |example| fixtures { |path| example.run } }
+    around { |example| fixtures { example.run } }
 
-    context "with change block raising" do
-      let(:callback) { ->(x,y,z) { raise 'foo' } }
+    context 'with change block raising' do
+      let(:callback) { ->(_, _, _) { fail 'foo' } }
 
-      it "warns the backtrace" do
-        expect(Kernel).to receive(:warn).with("[Listen warning]: Change block raised an exception: foo")
+      it 'warns the backtrace' do
+        expect(Kernel).to receive(:warn).
+          with('[Listen warning]: Change block raised an exception: foo')
         expect(Kernel).to receive(:warn).with(/^Backtrace:.*/)
         listen { touch 'file.rb' }
       end
@@ -33,203 +39,278 @@ describe "Listen" do
       context "force_polling option to #{polling}" do
         let(:options) { { force_polling: polling, latency: 0.1 } }
 
-        context "nothing in listen dir" do
-          it "listens to file addition" do
-            expect(listen {
+        context 'nothing in listen dir' do
+          it 'listens to file addition' do
+            expect(listen do
               touch 'file.rb'
-            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['file.rb'], removed: [])
           end
 
-          it "listens to multiple files addition" do
-            expect(listen {
+          it 'listens to multiple files addition' do
+            result = listen do
               touch 'file1.rb'
               touch 'file2.rb'
-            }).to eq({ modified: [], added: ['file1.rb', 'file2.rb'], removed: [] })
+            end
+
+            expect(result).to eq(modified: [],
+                                 added: %w(file1.rb file2.rb),
+                                 removed: [])
           end
 
-          it "listens to file moved inside" do
+          it 'listens to file moved inside' do
             touch '../file.rb'
-            expect(listen {
+            expect(listen do
               mv '../file.rb', 'file.rb'
-            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['file.rb'], removed: [])
           end
         end
 
-        context "file in listen dir" do
-          around { |example| touch 'file.rb'; example.run }
+        context 'file in listen dir' do
+          around do |example|
+            touch 'file.rb'
+            example.run
+          end
 
-          it "listens to file touch" do
-            expect(listen {
+          it 'listens to file touch' do
+            expect(listen do
               touch 'file.rb'
-            }).to eq({ modified: ['file.rb'], added: [], removed: [] })
+            end).to eq(modified: ['file.rb'], added: [], removed: [])
           end
 
-          it "listens to file modification" do
-            expect(listen {
+          it 'listens to file modification' do
+            expect(listen do
               open('file.rb', 'w') { |f| f.write('foo') }
-            }).to eq({ modified: ['file.rb'], added: [], removed: [] })
+            end).to eq(modified: ['file.rb'], added: [], removed: [])
           end
 
-          it "listens to file modification and wait" do
-            expect(listen {
+          it 'listens to file modification and wait' do
+            expect(listen do
               open('file.rb', 'w') { |f| f.write('foo') }
               sleep 0.5
-            }).to eq({ modified: ['file.rb'], added: [], removed: [] })
+            end).to eq(modified: ['file.rb'], added: [], removed: [])
           end
 
-          it "listens to file echo" do
-            expect(listen {
+          it 'listens to file echo' do
+            expect(listen do
               `echo  foo > #{Dir.pwd}/file.rb`
-            }).to eq({ modified: ['file.rb'], added: [], removed: [] })
+            end).to eq(modified: ['file.rb'], added: [], removed: [])
           end
 
-          it "listens to file removal" do
-            expect(listen {
+          it 'listens to file removal' do
+            expect(listen do
               rm 'file.rb'
-            }).to eq({ modified: [], added: [], removed: ['file.rb'] })
+            end).to eq(modified: [], added: [], removed: ['file.rb'])
           end
 
-          it "listens to file moved out" do
-            expect(listen {
+          it 'listens to file moved out' do
+            expect(listen do
               mv 'file.rb', '../file.rb'
-            }).to eq({ modified: [], added: [], removed: ['file.rb'] })
+            end).to eq(modified: [], added: [], removed: ['file.rb'])
           end
 
-          it "listens to file mode change" do
-            expect(listen {
+          it 'listens to file mode change' do
+            expect(listen do
               chmod 0777, 'file.rb'
-            }).to eq({ modified: ['file.rb'], added: [], removed: [] })
+            end).to eq(modified: ['file.rb'], added: [], removed: [])
           end
         end
 
-        context "hidden file in listen dir" do
-          around { |example| touch '.hidden'; example.run }
+        context 'hidden file in listen dir' do
+          around do |example|
+            touch '.hidden'
+            example.run
+          end
 
-          it "listens to file touch" do
-            expect(listen {
+          it 'listens to file touch' do
+            expect(listen do
               touch '.hidden'
-            }).to eq({ modified: ['.hidden'], added: [], removed: [] })
+            end).to eq(modified: ['.hidden'], added: [], removed: [])
           end
         end
 
-        context "dir in listen dir" do
-          around { |example| mkdir_p 'dir'; example.run }
+        context 'dir in listen dir' do
+          around do |example|
+            mkdir_p 'dir'
+            example.run
+          end
 
-          it "listens to file touch" do
-            expect(listen {
+          it 'listens to file touch' do
+            expect(listen do
               touch 'dir/file.rb'
-            }).to eq({ modified: [], added: ['dir/file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['dir/file.rb'], removed: [])
           end
         end
 
-        context "dir with file in listen dir" do
-          around { |example| mkdir_p 'dir'; touch 'dir/file.rb'; example.run }
+        context 'dir with file in listen dir' do
+          around do |example|
+            mkdir_p 'dir'
+            touch 'dir/file.rb'
+            example.run
+          end
+
+          it 'listens to file move' do
+            expected = { modified: [],
+                         added: %w(file.rb),
+                         removed: %w(dir/file.rb)
+            }
 
-          it "listens to file move" do
-            expect(listen {
+            expect(listen do
               mv 'dir/file.rb', 'file.rb'
-            }).to eq({ modified: [], added: ['file.rb'], removed: ['dir/file.rb'] })
+            end).to eq expected
           end
         end
 
-        context "two dirs with files in listen dir" do
-          around { |example|
-            mkdir_p 'dir1'; touch 'dir1/file1.rb'
-            mkdir_p 'dir2'; touch 'dir2/file2.rb'
-            example.run }
+        context 'two dirs with files in listen dir' do
+          around do |example|
+            mkdir_p 'dir1'
+            touch 'dir1/file1.rb'
+            mkdir_p 'dir2'
+            touch 'dir2/file2.rb'
+            example.run
+          end
+
+          it 'listens to multiple file moves' do
+            expected = {
+              modified: [],
+              added: ['dir1/file2.rb', 'dir2/file1.rb'],
+              removed: ['dir1/file1.rb', 'dir2/file2.rb']
+            }
 
-          it "listens to multiple file moves" do
-            expect(listen {
+            expect(listen do
               mv 'dir1/file1.rb', 'dir2/file1.rb'
               mv 'dir2/file2.rb', 'dir1/file2.rb'
-            }).to eq({ modified: [], added: ['dir1/file2.rb', 'dir2/file1.rb'], removed: ['dir1/file1.rb', 'dir2/file2.rb'] })
+            end).to eq expected
           end
 
-          it "listens to dir move" do
-            expect(listen {
+          it 'listens to dir move' do
+            expected = { modified: [],
+                         added: ['dir2/dir1/file1.rb'],
+                         removed: ['dir1/file1.rb'] }
+
+            expect(listen do
               mv 'dir1', 'dir2/'
-            }).to eq({ modified: [], added: ['dir2/dir1/file1.rb'], removed: ['dir1/file1.rb'] })
+            end).to eq expected
           end
         end
 
-        context "default ignored dir with file in listen dir" do
-          around { |example| mkdir_p '.bundle'; touch '.bundle/file.rb'; example.run }
+        context 'default ignored dir with file in listen dir' do
+          around do |example|
+            mkdir_p '.bundle'
+            touch '.bundle/file.rb'
+            example.run
+          end
+
           let(:options) { { force_polling: polling, latency: 0.1 } }
 
           it "doesn't listen to file touch" do
-            expect(listen {
+            expect(listen do
               touch '.bundle/file.rb'
-            }).to eq({ modified: [], added: [], removed: [] })
+            end).to eq(modified: [], added: [], removed: [])
           end
         end
 
-        context "ignored dir with file in listen dir" do
-          around { |example| mkdir_p 'ignored_dir'; touch 'ignored_dir/file.rb'; example.run }
-          let(:options) { { force_polling: polling, latency: 0.1, ignore: /ignored_dir/ } }
+        context 'ignored dir with file in listen dir' do
+          around do |example|
+            mkdir_p 'ignored_dir'
+            touch 'ignored_dir/file.rb'
+            example.run
+          end
+
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              ignore: /ignored_dir/ }
+          end
 
           it "doesn't listen to file touch" do
-            expect(listen {
+            expect(listen do
               touch 'ignored_dir/file.rb'
-            }).to eq({ modified: [], added: [], removed: [] })
+            end).to eq(modified: [], added: [], removed: [])
           end
         end
 
-        context "with ignored file in listen dir" do
-          around { |example| touch 'file.rb'; example.run }
-          let(:options) { { force_polling: polling, latency: 0.1, ignore: /\.rb$/ } }
+        context 'with ignored file in listen dir' do
+          around do |example|
+            touch 'file.rb'
+            example.run
+          end
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              ignore: /\.rb$/ }
+          end
 
           it "doesn't listen to file touch" do
-            expect(listen {
+            expect(listen do
               touch 'file.rb'
-            }).to eq({ modified: [], added: [], removed: [] })
+            end).to eq(modified: [], added: [], removed: [])
           end
         end
 
-        context "with only option" do
-          let(:options) { { force_polling: polling, latency: 0.1, only: /\.rb$/ } }
+        context 'with only option' do
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              only: /\.rb$/ }
+          end
 
-          it "listens only to file touch matching with only patterns" do
-            expect(listen {
+          it 'listens only to file touch matching with only patterns' do
+            expect(listen do
               touch 'file.rb'
               touch 'file.txt'
-            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['file.rb'], removed: [])
           end
         end
 
-        context "with ignore and only option" do
-          let(:options) { { force_polling: polling, latency: 0.1, ignore: /bar\.rb$/, only: /\.rb$/ } }
+        context 'with ignore and only option' do
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              ignore: /bar\.rb$/, only: /\.rb$/ }
+          end
 
-          it "listens only to file touch matching with only patterns" do
-            expect(listen {
+          it 'listens only to file touch matching with only patterns' do
+            expect(listen do
               touch 'file.rb'
               touch 'bar.rb'
               touch 'file.txt'
-            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['file.rb'], removed: [])
           end
         end
 
-        describe "#ignore" do
-          around { |example| touch 'file.rb'; example.run }
-          let(:options) { { force_polling: polling, latency: 0.1, ignore: /\.rb$/ } }
+        describe '#ignore' do
+          around do |example|
+            touch 'file.rb'
+            example.run
+          end
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              ignore: /\.rb$/ }
+          end
 
-          it "overwrites existing patterns" do
-            expect(listen {
+          it 'overwrites existing patterns' do
+            expect(listen do
               listener.ignore(/\.txt/)
               touch 'file.rb'
               touch 'file.txt'
-            }).to eq({ modified: [], added: [], removed: [] })
+            end).to eq(modified: [], added: [], removed: [])
           end
         end
 
-        describe "#ignore!" do
-          let(:options) { { force_polling: polling, latency: 0.1, ignore: /\.rb$/ } }
+        describe '#ignore!' do
+          let(:options) do
+            { force_polling: polling,
+              latency: 0.1,
+              ignore: /\.rb$/ }
+          end
 
-          it "overwrites existing patterns" do
-            expect(listen {
+          it 'overwrites existing patterns' do
+            expect(listen do
               listener.ignore!(/\.txt/)
               touch 'file.rb'
               touch 'file.txt'
-            }).to eq({ modified: [], added: ['file.rb'], removed: [] })
+            end).to eq(modified: [], added: ['file.rb'], removed: [])
           end
         end
       end