brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/sass-3.4.22/vendor/listen/spec/listen/listener_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+describe Listen::Listener do
+  let(:adapter)             { double(Listen::Adapter, :start => true).as_null_object }
+  let(:watched_directories) { [File.dirname(__FILE__), File.expand_path('../..', __FILE__)] }
+
+  before do
+    Listen::Adapter.stub(:select_and_initialize) { adapter }
+    # Don't build a record of the files inside the base directory.
+    Listen::DirectoryRecord.any_instance.stub(:build)
+    Kernel.stub(:warn)
+  end
+  subject { described_class.new(watched_directories) }
+
+  it_should_behave_like 'a listener to changes on a file-system'
+
+  describe '#initialize' do
+    context 'listening to a single directory' do
+      let(:watched_directory)   { File.dirname(__FILE__) }
+      let(:watched_directories) { nil }
+      subject { described_class.new(watched_directory) }
+
+      it 'sets the directories' do
+        subject.directories.should eq [watched_directory]
+      end
+
+      context 'with no options' do
+        it 'sets the option for using relative paths in the callback to false' do
+          subject.instance_variable_get(:@use_relative_paths).should eq false
+        end
+      end
+
+      context 'with :relative_paths => false' do
+        it 'sets the option for using relative paths in the callback to false' do
+          listener = described_class.new(watched_directory, :relative_paths => false)
+          listener.instance_variable_get(:@use_relative_paths).should eq false
+        end
+      end
+
+      context 'with :relative_paths => true' do
+        it 'sets the option for using relative paths in the callback to true' do
+          listener = described_class.new(watched_directory, :relative_paths => true)
+          listener.instance_variable_get(:@use_relative_paths).should eq true
+        end
+      end
+    end
+
+    context 'listening to multiple directories' do
+      subject { described_class.new(watched_directories) }
+
+      it 'sets the directories' do
+        subject.directories.should eq watched_directories
+      end
+
+      context 'with no options' do
+        it 'sets the option for using relative paths in the callback to false' do
+          subject.instance_variable_get(:@use_relative_paths).should eq false
+        end
+      end
+
+      context 'with :relative_paths => false' do
+        it 'sets the option for using relative paths in the callback to false' do
+          listener = described_class.new(watched_directories, :relative_paths => false)
+          listener.instance_variable_get(:@use_relative_paths).should eq false
+        end
+      end
+
+      context 'with :relative_paths => true' do
+        it 'warns' do
+          Kernel.should_receive(:warn).with("[Listen warning]: #{Listen::Listener::RELATIVE_PATHS_WITH_MULTIPLE_DIRECTORIES_WARNING_MESSAGE}")
+          listener = described_class.new(watched_directories, :relative_paths => true)
+        end
+
+        it 'sets the option for using relative paths in the callback to false' do
+          listener = described_class.new(watched_directories, :relative_paths => true)
+          listener.instance_variable_get(:@use_relative_paths).should eq false
+        end
+      end
+    end
+
+    context 'with a directory' do
+      let(:watched_directory)   { File.dirname(__FILE__) }
+      it 'converts the passed path into an absolute path - #21' do
+        described_class.new(File.join(watched_directory, '..')).directories.should eq [File.expand_path('..', watched_directory)]
+      end
+    end
+
+    context 'with custom options' do
+      let(:watched_directory)   { File.dirname(__FILE__) }
+      let(:adapter_class) { double('adapter class') }
+
+      let(:options) do
+        {
+          :ignore => /\.ssh/, :filter => [/.*\.rb/, /.*\.md/],
+          :latency => 0.5, :force_polling => true, :relative_paths => true,
+          :force_adapter => adapter_class
+        }
+      end
+      subject { described_class.new(watched_directory, options) }
+
+      it 'passes the custom ignored paths to the directory record' do
+        subject.directories_records.each do |directory_record|
+          directory_record.ignoring_patterns.should include /\.ssh/
+        end
+      end
+
+      it 'passes the custom filters to the directory record' do
+        subject.directories_records.each do |directory_record|
+          directory_record.filtering_patterns.should =~  [/.*\.rb/,/.*\.md/]
+        end
+      end
+
+      it 'sets adapter_options' do
+        subject.instance_variable_get(:@adapter_options).should eq(:latency => 0.5, :force_polling => true, :force_adapter => adapter_class)
+      end
+    end
+  end
+
+  describe '#start' do
+    it 'selects and initializes an adapter' do
+      Listen::Adapter.should_receive(:select_and_initialize).with(watched_directories, {}) { adapter }
+      subject.start
+    end
+
+    it 'builds the directory record' do
+      subject.directories_records.each do |directory_record|
+        directory_record.should_receive(:build)
+      end
+      subject.start
+    end
+  end
+
+  context 'with a started listener' do
+    before do
+      subject.stub(:initialize_adapter) { adapter }
+      subject.start
+    end
+
+    describe '#unpause' do
+      it 'rebuilds the directory record' do
+        subject.directories_records.each do |directory_record|
+          directory_record.should_receive(:build)
+        end
+        subject.unpause
+      end
+    end
+  end
+
+  describe '#ignore'do
+    it 'delegates the work to the directory record' do
+      subject.directories_records.each do |directory_record|
+        directory_record.should_receive(:ignore).with 'some_directory'
+      end
+      subject.ignore 'some_directory'
+    end
+  end
+
+  describe '#ignore!'do
+    it 'delegates the work to the directory record' do
+      subject.directories_records.each do |directory_record|
+        directory_record.should_receive(:ignore!).with 'some_directory'
+      end
+      subject.ignore! 'some_directory'
+    end
+  end
+
+  describe '#filter' do
+    it 'delegates the work to the directory record' do
+      subject.directories_records.each do |directory_record|
+        directory_record.should_receive(:filter).with /\.txt$/
+      end
+      subject.filter /\.txt$/
+    end
+  end
+
+  describe '#filter!' do
+    it 'delegates the work to the directory record' do
+      subject.directories_records.each do |directory_record|
+        directory_record.should_receive(:filter!).with /\.txt$/
+      end
+      subject.filter! /\.txt$/
+    end
+  end
+
+  describe '#on_change' do
+    let(:directories) { %w{dir1 dir2 dir3} }
+    let(:changes)     { {:modified => [], :added => [], :removed => []} }
+    let(:callback)    { Proc.new { @called = true } }
+
+    before do
+      @called = false
+      subject.stub(:fetch_records_changes => changes)
+    end
+
+    it 'fetches the changes of all directories records' do
+      subject.unstub(:fetch_records_changes)
+
+      subject.directories_records.each do |record|
+        record.should_receive(:fetch_changes).with(directories, an_instance_of(Hash)).and_return(changes)
+      end
+      subject.on_change(directories)
+    end
+
+    context "with a callback raising an exception" do
+      let(:callback) { Proc.new { raise 'foo' } }
+
+      before do
+        subject.change(&callback)
+        subject.stub(:fetch_records_changes => { :modified => ['foo'], :added => [], :removed => [] } )
+      end
+
+      it "stops the adapter and warns" do
+        Kernel.should_receive(:warn).with("[Listen warning]: Change block raise an execption: foo")
+        Kernel.should_receive(:warn).with(/^Backtrace:.*/)
+        subject.on_change(directories)
+      end
+
+    end
+
+    context 'with no changes to report' do
+      if RUBY_VERSION[/^1.8/]
+        it 'does not run the callback' do
+            subject.change(&callback)
+            subject.on_change(directories)
+            @called.should be_false
+        end
+      else
+        it 'does not run the callback' do
+          callback.should_not_receive(:call)
+          subject.change(&callback)
+          subject.on_change(directories)
+        end
+      end
+    end
+
+    context 'with changes to report' do
+      let(:changes) do
+        {
+          :modified => %w{path1}, :added => [], :removed => %w{path2}
+        }
+      end
+
+      if RUBY_VERSION[/^1.8/]
+        it 'runs the callback passing it the changes' do
+          subject.change(&callback)
+          subject.on_change(directories)
+          @called.should be_true
+        end
+      else
+        it 'runs the callback passing it the changes' do
+          callback.should_receive(:call).with(changes[:modified], changes[:added], changes[:removed])
+          subject.change(&callback)
+          subject.on_change(directories)
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/vendor/listen/spec/listen/turnstile_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+def run_in_two_threads(proc1, proc2)
+  t1 = Thread.new &proc1
+  sleep test_latency # t1 must run before t2
+  t2 = Thread.new { proc2.call; Thread.kill t1 }
+  t2.join(test_latency * 2)
+ensure
+  Thread.kill t1 if t1
+  Thread.kill t2 if t2
+end
+
+describe Listen::Turnstile do
+  before { @called = false }
+
+  describe '#wait' do
+    context 'without a signal' do
+      it 'blocks one thread indefinitely' do
+        run_in_two_threads lambda {
+          subject.wait
+          @called = true
+        }, lambda {
+          sleep test_latency
+        }
+        @called.should be_false
+      end
+    end
+
+    context 'with a signal' do
+      it 'blocks one thread until it recieves a signal from another thread' do
+        run_in_two_threads lambda {
+          subject.wait
+          @called = true
+        }, lambda {
+          subject.signal
+          sleep test_latency
+        }
+        @called.should be_true
+      end
+    end
+  end
+
+  describe '#signal' do
+    context 'without a wait-call before' do
+      it 'does nothing' do
+        run_in_two_threads lambda {
+          subject.signal
+          @called = true
+        }, lambda {
+          sleep test_latency
+        }
+        @called.should be_true
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/vendor/listen/spec/listen_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Listen do
+  describe '#to' do
+    let(:listener)       { double(Listen::Listener) }
+    let(:listener_class) { Listen::Listener }
+    before { listener_class.stub(:new => listener) }
+
+    context 'with one path to listen to' do
+      context 'without options' do
+        it 'creates an instance of Listener' do
+          listener_class.should_receive(:new).with('/path')
+          described_class.to('/path')
+        end
+      end
+
+      context 'with options' do
+        it 'creates an instance of Listener with the passed params' do
+          listener_class.should_receive(:new).with('/path', :filter => '**/*')
+          described_class.to('/path', :filter => '**/*')
+        end
+      end
+
+      context 'without a block' do
+        it 'returns the listener' do
+          described_class.to('/path', :filter => '**/*').should eq listener
+        end
+      end
+
+      context 'with a block' do
+        it 'starts the listener after creating it' do
+          listener.should_receive(:start)
+          described_class.to('/path', :filter => '**/*') { |modified, added, removed| }
+        end
+      end
+    end
+
+    context 'with multiple paths to listen to' do
+      context 'without options' do
+        it 'creates an instance of Listener' do
+          listener_class.should_receive(:new).with('path1', 'path2')
+          described_class.to('path1', 'path2')
+        end
+      end
+
+      context 'with options' do
+        it 'creates an instance of Listener with the passed params' do
+          listener_class.should_receive(:new).with('path1', 'path2', :filter => '**/*')
+          described_class.to('path1', 'path2', :filter => '**/*')
+        end
+      end
+
+      context 'without a block' do
+        it 'returns a Listener instance created with the passed params' do
+          described_class.to('path1', 'path2', :filter => '**/*').should eq listener
+        end
+      end
+
+      context 'with a block' do
+        it 'starts a Listener instance after creating it with the passed params' do
+          listener.should_receive(:start)
+          described_class.to('path1', 'path2', :filter => '**/*') { |modified, added, removed| }
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/vendor/listen/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'coveralls'
+Coveralls.wear!
+
+require 'listen'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.order = :random
+  config.filter_run :focus => true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run_excluding :broken => true
+  config.fail_fast = true
+end
+
+def test_latency
+  0.1
+end
+
+# Crash loud in tests!
+Thread.abort_on_exception = true

data/bundle/ruby/2.3.0/gems/sass-3.4.22/vendor/listen/spec/support/adapter_helper.rb

@@ -0,0 +1,666 @@
+# Adapter watch
+#
+# @param [Listen::Listener] listener the adapter listener
+# @param [String] path the path to watch
+#
+def watch(listener, expected_changes, *paths)
+  sleep 0.05 # allow file/creation to be done (!)
+
+  callback = lambda do |changed_directories, options|
+    @called = true
+    listener.on_change(changed_directories)
+  end
+  @adapter = Listen::Adapter.select_and_initialize(paths, { :latency => test_latency }, &callback)
+  @adapter.stub(:start_poller) { nil }
+
+  forced_stop = false
+  prevent_deadlock = lambda do
+    sleep(10)
+    puts 'Forcing stop'
+    @adapter.stop
+    forced_stop = true
+  end
+
+  @adapter.start
+
+  yield
+
+  t = Thread.new(&prevent_deadlock)
+  @adapter.wait_for_changes(expected_changes)
+
+  unless forced_stop
+    Thread.kill(t)
+    @adapter.report_changes
+  end
+ensure
+  unless forced_stop
+    Thread.kill(t) if t
+    @adapter.stop
+  end
+end
+
+shared_examples_for 'a filesystem adapter' do
+  subject { described_class.new(File.dirname(__FILE__), &Proc.new {}) }
+
+  describe '#start' do
+    before { Kernel.stub(:warn) }
+    after { subject.stop }
+
+    it 'do not block the current thread after starting the workers' do
+      @called = false
+      t = Thread.new { subject.start; @called = true }
+      sleep(test_latency * 3)
+      Thread.kill(t) if t
+      @called.should be_true
+    end
+
+    context 'with the blocking hash option set to false' do
+      subject { described_class.new(File.dirname(__FILE__), { :blocking => false }, &Proc.new {}) }
+
+      it 'does not block the current thread after starting the workers' do
+        @called = false
+        t = Thread.new { subject.start; @called = true }
+        sleep(test_latency * 3)
+        Thread.kill(t) if t
+        @called.should be_true
+      end
+    end
+  end
+
+  describe '#start!' do
+    before { Kernel.stub(:warn) }
+    after { subject.stop }
+
+    it 'blocks the current thread after starting the workers' do
+      @called = false
+      t = Thread.new { subject.start!; @called = true }
+      sleep(test_latency * 3)
+      Thread.kill(t) if t
+      @called.should be_false
+    end
+
+    context 'with the blocking hash option set to false' do
+      subject { described_class.new(File.dirname(__FILE__), { :blocking => true }, &Proc.new {}) }
+
+      it 'blocks the current thread after starting the workers' do
+        @called = false
+        t = Thread.new { subject.start!; @called = true }
+        sleep(test_latency * 3)
+        Thread.kill(t) if t
+        @called.should be_false
+      end
+    end
+  end
+
+  describe '#started?' do
+    context 'with a new adapter' do
+      it 'returns false' do
+        subject.should_not be_started
+      end
+    end
+
+    context 'with a stopped adapter' do
+      before { subject.start; subject.stop }
+
+      it 'returns false' do
+        subject.should_not be_started
+      end
+    end
+
+    context 'with a started adapter' do
+      before { subject.start }
+      after  { subject.stop }
+
+      it 'returns true' do
+        subject.should be_started
+      end
+    end
+  end
+end
+
+shared_examples_for 'an adapter that call properly listener#on_change' do |*args|
+  options = (args.first && args.first.is_a?(Hash)) ? args.first : {}
+  let(:listener) { double(Listen::Listener) }
+  before { described_class.stub(:works?) { true } }
+
+  context 'single file operations' do
+    context 'when a file is created' do
+      it 'detects the added file' do
+        fixtures do |path|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path)
+          end
+
+          watch(listener, 1, path) do
+            touch 'new_file.rb'
+          end
+        end
+      end
+
+      context 'given a symlink', :unless => windows? do
+        it 'detects the added file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch 'new_file.rb'
+
+            watch(listener, 1, path) do
+              ln_s 'new_file.rb', 'new_file_symlink.rb'
+            end
+          end
+        end
+      end
+
+      context 'given a new created directory' do
+        it 'detects the added file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path, "#{path}/a_directory")
+            end
+
+            watch(listener, 2, path) do
+              mkdir 'a_directory'
+              # Needed for INotify, because of :recursive rb-inotify custom flag?
+              sleep 0.05
+              touch 'a_directory/new_file.rb'
+            end
+          end
+        end
+      end
+
+      context 'given an existing directory' do
+        it 'detects the added file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory")
+            end
+
+            mkdir 'a_directory'
+
+            watch(listener, 1, path) do
+              touch 'a_directory/new_file.rb'
+            end
+          end
+        end
+      end
+
+      context 'given a directory with subdirectories' do
+        it 'detects the added file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory/subdirectory")
+            end
+
+            mkdir_p 'a_directory/subdirectory'
+
+            watch(listener, 1, path) do
+              touch 'a_directory/subdirectory/new_file.rb'
+            end
+          end
+        end
+      end
+    end
+
+    context 'when a file is modified' do
+      it 'detects the modified file' do
+        fixtures do |path|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path)
+          end
+
+          touch 'existing_file.txt'
+
+          watch(listener, 1, path) do
+            touch 'existing_file.txt'
+          end
+        end
+      end
+
+      context 'given a symlink', :unless => windows? do
+        it 'detects the modified file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch 'existing_file.rb'
+            ln_s  'existing_file.rb', 'existing_file_symlink.rb'
+
+            watch(listener, 1, path) do
+              touch 'existing_file.rb'
+            end
+          end
+        end
+      end
+
+      context 'given a hidden file' do
+        it 'detects the modified file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch '.hidden'
+
+            watch(listener, 1, path) do
+              touch '.hidden'
+            end
+          end
+        end
+      end
+
+      context 'given a file mode change', :unless => windows? do
+        it 'does not detect the mode change' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch 'run.rb'
+
+            watch(listener, 1, path) do
+              chmod 0777, 'run.rb'
+            end
+          end
+        end
+      end
+
+      context 'given an existing directory' do
+        it 'detects the modified file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory")
+            end
+
+            mkdir 'a_directory'
+            touch 'a_directory/existing_file.txt'
+
+            watch(listener, 1, path) do
+              touch 'a_directory/existing_file.txt'
+            end
+          end
+        end
+      end
+
+      context 'given a directory with subdirectories' do
+        it 'detects the modified file' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory/subdirectory")
+            end
+
+            mkdir_p 'a_directory/subdirectory'
+            touch   'a_directory/subdirectory/existing_file.txt'
+
+            watch(listener, 1, path) do
+              touch 'a_directory/subdirectory/new_file.rb'
+            end
+          end
+        end
+      end
+    end
+
+    context 'when a file is moved' do
+      it 'detects the file move' do
+        fixtures do |path|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path)
+          end
+
+          touch 'move_me.txt'
+
+          watch(listener, 1, path) do
+            mv 'move_me.txt', 'new_name.txt'
+          end
+        end
+      end
+
+      context 'given a symlink', :unless => windows? do
+        it 'detects the file move' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch 'move_me.rb'
+            ln_s  'move_me.rb', 'move_me_symlink.rb'
+
+            watch(listener, 1, path) do
+              mv 'move_me_symlink.rb', 'new_symlink.rb'
+            end
+          end
+        end
+      end
+
+      context 'given an existing directory' do
+        it 'detects the file move into the directory' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path, "#{path}/a_directory")
+            end
+
+            mkdir 'a_directory'
+            touch 'move_me.txt'
+
+            watch(listener, 2, path) do
+              mv 'move_me.txt', 'a_directory/move_me.txt'
+            end
+          end
+        end
+
+        it 'detects a file move out of the directory' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path, "#{path}/a_directory")
+            end
+
+            mkdir 'a_directory'
+            touch 'a_directory/move_me.txt'
+
+            watch(listener, 2, path) do
+              mv 'a_directory/move_me.txt', 'i_am_here.txt'
+            end
+          end
+        end
+
+        it 'detects a file move between two directories' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/from_directory", "#{path}/to_directory")
+            end
+
+            mkdir 'from_directory'
+            touch 'from_directory/move_me.txt'
+            mkdir 'to_directory'
+
+            watch(listener, 2, path) do
+              mv 'from_directory/move_me.txt', 'to_directory/move_me.txt'
+            end
+          end
+        end
+      end
+
+      context 'given a directory with subdirectories' do
+        it 'detects files movements between subdirectories' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory/subdirectory", "#{path}/b_directory/subdirectory")
+            end
+
+            mkdir_p 'a_directory/subdirectory'
+            mkdir_p 'b_directory/subdirectory'
+            touch   'a_directory/subdirectory/move_me.txt'
+
+            watch(listener, 2, path) do
+              mv 'a_directory/subdirectory/move_me.txt', 'b_directory/subdirectory'
+            end
+          end
+        end
+      end
+    end
+
+    context 'when a file is deleted' do
+      it 'detects the file removal' do
+        fixtures do |path|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path)
+          end
+
+          touch 'unnecessary.txt'
+
+          watch(listener, 1, path) do
+            rm 'unnecessary.txt'
+          end
+        end
+      end
+
+      context 'given a symlink', :unless => windows? do
+        it 'detects the file removal' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include(path)
+            end
+
+            touch 'unnecessary.rb'
+            ln_s  'unnecessary.rb', 'unnecessary_symlink.rb'
+
+            watch(listener, 1, path) do
+              rm 'unnecessary_symlink.rb'
+            end
+          end
+        end
+      end
+
+      context 'given an existing directory' do
+        it 'detects the file removal' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory")
+            end
+
+            mkdir 'a_directory'
+            touch 'a_directory/do_not_use.rb'
+
+            watch(listener, 1, path) do
+              rm 'a_directory/do_not_use.rb'
+            end
+          end
+        end
+      end
+
+      context 'given a directory with subdirectories' do
+        it 'detects the file removal' do
+          fixtures do |path|
+            listener.should_receive(:on_change).once.with do |array|
+              array.should include("#{path}/a_directory/subdirectory")
+            end
+
+            mkdir_p 'a_directory/subdirectory'
+            touch   'a_directory/subdirectory/do_not_use.rb'
+
+            watch(listener, 1, path) do
+              rm 'a_directory/subdirectory/do_not_use.rb'
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'multiple file operations' do
+    it 'detects the added files' do
+      fixtures do |path|
+        listener.should_receive(:on_change).once.with do |array|
+          array.should include(path, "#{path}/a_directory")
+        end
+
+        watch(listener, 2, path) do
+          touch 'a_file.rb'
+          touch 'b_file.rb'
+          mkdir 'a_directory'
+          # Needed for INotify, because of :recursive rb-inotify custom flag?
+          # Also needed for the osx adapter
+          sleep 0.05
+          touch 'a_directory/a_file.rb'
+          touch 'a_directory/b_file.rb'
+        end
+      end
+    end
+
+    it 'detects the modified files' do
+      fixtures do |path|
+        listener.should_receive(:on_change).once.with do |array|
+          array.should include(path, "#{path}/a_directory")
+        end
+
+        touch 'a_file.rb'
+        touch 'b_file.rb'
+        mkdir 'a_directory'
+        touch 'a_directory/a_file.rb'
+        touch 'a_directory/b_file.rb'
+
+        watch(listener, 2, path) do
+          touch 'b_file.rb'
+          touch 'a_directory/a_file.rb'
+        end
+      end
+    end
+
+    it 'detects the removed files' do
+      fixtures do |path|
+        listener.should_receive(:on_change).once.with do |array|
+          array.should include(path, "#{path}/a_directory")
+        end
+
+        touch 'a_file.rb'
+        touch 'b_file.rb'
+        mkdir 'a_directory'
+        touch 'a_directory/a_file.rb'
+        touch 'a_directory/b_file.rb'
+
+        watch(listener, 2, path) do
+          rm 'b_file.rb'
+          rm 'a_directory/a_file.rb'
+        end
+      end
+    end
+  end
+
+  context 'single directory operations' do
+    it 'detects a moved directory' do
+      fixtures do |path|
+        listener.should_receive(:on_change).once.with do |array|
+          array.should include(path)
+        end
+
+        mkdir 'a_directory'
+        touch 'a_directory/a_file.rb'
+        touch 'a_directory/b_file.rb'
+
+        watch(listener, 1, path) do
+          mv 'a_directory', 'renamed'
+        end
+      end
+    end
+
+    it 'detects a removed directory' do
+      fixtures do |path|
+        listener.should_receive(:on_change).once.with do |array|
+          array.should include(path, "#{path}/a_directory")
+        end
+
+        mkdir 'a_directory'
+        touch 'a_directory/a_file.rb'
+        touch 'a_directory/b_file.rb'
+
+        watch(listener, 2, path) do
+          rm_rf 'a_directory'
+        end
+      end
+    end
+  end
+
+  context "paused adapter" do
+    context 'when a file is created' do
+      it "doesn't detects the added file" do
+        fixtures do |path|
+          watch(listener, 1, path) do # The expected changes param is set to one!
+            @adapter.paused = true
+            touch 'new_file.rb'
+          end
+          @called.should be_nil
+        end
+      end
+    end
+  end
+
+  context "when multiple directories are listened to" do
+    context 'when files are added to one of multiple directories' do
+      it 'detects added files' do
+        fixtures(2) do |path1, path2|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path2)
+          end
+
+          watch(listener, 1, path1, path2) do
+            touch "#{path2}/new_file.rb"
+          end
+        end
+      end
+    end
+
+    context 'when files are added to multiple directories' do
+      it 'detects added files' do
+        fixtures(2) do |path1, path2|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path1, path2)
+          end
+
+          watch(listener, 2, path1, path2) do
+            touch "#{path1}/new_file.rb"
+            touch "#{path2}/new_file.rb"
+          end
+        end
+      end
+    end
+
+    context 'given a new and an existing directory on multiple directories' do
+      it 'detects the added file' do
+        fixtures(2) do |path1, path2|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path2, "#{path1}/a_directory", "#{path2}/b_directory")
+          end
+
+          mkdir "#{path1}/a_directory"
+
+          watch(listener, 3, path1, path2) do
+            mkdir "#{path2}/b_directory"
+            # Needed for INotify
+            sleep 0.05
+            touch "#{path1}/a_directory/new_file.rb"
+            touch "#{path2}/b_directory/new_file.rb"
+          end
+        end
+      end
+    end
+
+    context 'when a file is moved between the multiple watched directories' do
+      it 'detects the movements of the file' do
+        fixtures(3) do |path1, path2, path3|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include("#{path1}/from_directory", path2, "#{path3}/to_directory")
+          end
+
+          mkdir "#{path1}/from_directory"
+          touch "#{path1}/from_directory/move_me.txt"
+          mkdir "#{path3}/to_directory"
+
+          watch(listener, 3, path1, path2, path3) do
+            mv "#{path1}/from_directory/move_me.txt", "#{path2}/move_me.txt"
+            mv "#{path2}/move_me.txt", "#{path3}/to_directory/move_me.txt"
+          end
+        end
+      end
+    end
+
+    context 'when files are deleted from the multiple watched directories' do
+      it 'detects the files removal' do
+        fixtures(2) do |path1, path2|
+          listener.should_receive(:on_change).once.with do |array|
+            array.should include(path1, path2)
+          end
+
+          touch "#{path1}/unnecessary.txt"
+          touch "#{path2}/unnecessary.txt"
+
+          watch(listener, 2, path1, path2) do
+            rm "#{path1}/unnecessary.txt"
+            rm "#{path2}/unnecessary.txt"
+          end
+        end
+      end
+    end
+  end
+end