sass 3.1.15 → 3.1.16

data/vendor/listen/lib/listen/multi_listener.rb

@@ -0,0 +1,121 @@
+module Listen
+  class MultiListener < Listener
+    attr_reader :directories, :directories_records, :adapter
+
+    # Initializes the multiple directories listener.
+    #
+    # @param [String] directories the directories to listen to
+    # @param [Hash] options the listen options
+    # @option options [String] ignore a list of paths to ignore
+    # @option options [Regexp] filter a list of regexps file filters
+    # @option options [Float] latency the delay between checking for changes in seconds
+    # @option options [Boolean] force_polling whether to force the polling adapter or not
+    # @option options [String, Boolean] polling_fallback_message to change polling fallback message or remove it
+    #
+    # @yield [modified, added, removed] the changed files
+    # @yieldparam [Array<String>] modified the list of modified files
+    # @yieldparam [Array<String>] added the list of added files
+    # @yieldparam [Array<String>] removed the list of removed files
+    #
+    def initialize(*args, &block)
+      options     = args.last.is_a?(Hash) ? args.pop : {}
+      directories = args
+
+      @block               = block
+      @directories         = directories
+      @directories_records = directories.map { |d| DirectoryRecord.new(d) }
+
+      ignore(*options.delete(:ignore)) if options[:ignore]
+      filter(*options.delete(:filter)) if options[:filter]
+
+      @adapter_options = options
+    end
+
+    # Starts the listener by initializing the adapter and building
+    # the directory record concurrently, then it starts the adapter to watch
+    # for changes.
+    #
+    # @param [Boolean] blocking whether or not to block the current thread after starting
+    #
+    def start(blocking = true)
+      t = Thread.new { @adapter = initialize_adapter }
+      @directories_records.each { |r| r.build }
+      t.join
+      @adapter.start(blocking)
+    end
+
+    # Unpauses the listener.
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def unpause
+      @directories_records.each { |r| r.build }
+      @adapter.paused = false
+      self
+    end
+
+    # Adds ignored paths to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#ignore)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def ignore(*paths)
+      @directories_records.each { |r| r.ignore(*paths) }
+      self
+    end
+
+    # Adds file filters to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#filter)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def filter(*regexps)
+      @directories_records.each { |r| r.filter(*regexps) }
+      self
+    end
+
+    # Runs the callback passing it the changes if there are any.
+    #
+    # @param (see Listen::DirectoryRecord#fetch_changes)
+    #
+    def on_change(directories_to_search, options = {})
+      changes = fetch_records_changes(directories_to_search, options)
+      unless changes.values.all? { |paths| paths.empty? }
+        @block.call(changes[:modified],changes[:added],changes[:removed])
+      end
+    end
+
+    private
+
+    # Initializes an adapter passing it the callback and adapters' options.
+    #
+    def initialize_adapter
+      callback = lambda { |changed_dirs, options| self.on_change(changed_dirs, options) }
+      Adapter.select_and_initialize(@directories, @adapter_options, &callback)
+    end
+
+    # Returns the sum of all the changes to the directories records
+    #
+    # @param (see Listen::DirectoryRecord#fetch_changes)
+    #
+    # @return [Hash] the changes
+    #
+    def fetch_records_changes(directories_to_search, options)
+      @directories_records.inject({}) do |h, r|
+        # directory records skips paths outside their range, so passing the
+        # whole `directories` array is not a problem.
+        record_changes = r.fetch_changes(directories_to_search, options.merge(:relative_paths => DEFAULT_TO_RELATIVE_PATHS))
+
+        if h.empty?
+          h.merge!(record_changes)
+        else
+          h.each { |k, v| h[k] += record_changes[k] }
+        end
+
+        h
+      end
+    end
+  end
+end

data/vendor/listen/lib/listen/turnstile.rb

@@ -0,0 +1,28 @@
+module Listen
+  # Allows two threads to wait on eachother.
+  #
+  # @note Only two threads can be used with this Turnstile
+  #   because of the current implementation.
+  class Turnstile
+
+    # Initialize the turnstile.
+    #
+    def initialize
+      # Until ruby offers semahpores, only queues can be used
+      # to implement a turnstile.
+      @q = Queue.new
+    end
+
+    # Blocks the current thread until a signal is received.
+    #
+    def wait
+      @q.pop if @q.num_waiting == 0
+    end
+
+    # Unblocks the waiting thread if there is one.
+    #
+    def signal
+      @q.push :dummy if @q.num_waiting == 1
+    end
+  end
+end

data/vendor/listen/lib/listen/version.rb

@@ -0,0 +1,3 @@
+module Listen
+  VERSION = '0.4.1'
+end

data/vendor/listen/listen.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'listen/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'listen'
+  s.version     = Listen::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Thibaud Guillaume-Gentil', 'Maher Sallam']
+  s.email       = ['thibaud@thibaud.me', 'maher@sallam.me']
+  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.required_rubygems_version = '>= 1.3.6'
+  s.rubyforge_project = 'listen'
+
+  s.add_dependency 'rb-fsevent', '~> 0.9.1'
+  s.add_dependency 'rb-inotify', '~> 0.8.8'
+  s.add_dependency 'rb-fchange', '~> 0.0.5'
+
+  s.add_development_dependency 'bundler'
+
+  s.files        = Dir.glob('{lib}/**/*') + %w[CHANGELOG.md LICENSE README.md]
+  s.require_path = 'lib'
+end

data/vendor/listen/spec/listen/adapter_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Listen::Adapter do
+  subject { described_class.new('dir') }
+
+  describe '#initialize' do
+    it 'sets the latency to the default one' do
+      subject.latency.should eq described_class::DEFAULT_LATENCY
+    end
+
+    it 'accepts a single directory to watch' do
+      described_class.new('dir').directories = %w{dir}
+    end
+
+    it 'accepts multiple directories to watch' do
+      described_class.new(%w{dir1 dir2}).directories.should eq %w{dir1 dir2}
+    end
+  end
+
+  describe ".select_and_initialize" do
+    before do
+      Listen::Adapters::Darwin.stub(:usable_and_works?) { false }
+      Listen::Adapters::Linux.stub(:usable_and_works?) { false }
+      Listen::Adapters::Windows.stub(:usable_and_works?) { false }
+    end
+
+    context "with no specific adapter usable" do
+      it "returns Listen::Adapters::Polling instance" do
+        Kernel.stub(:warn)
+        Listen::Adapters::Polling.should_receive(:new).with('dir', {})
+        described_class.select_and_initialize('dir')
+      end
+
+      it "warns with the default polling fallback message" do
+        Kernel.should_receive(:warn).with(Listen::Adapter::POLLING_FALLBACK_MESSAGE)
+        described_class.select_and_initialize('dir')
+      end
+
+      context "with custom polling_fallback_message option" do
+        it "warns with the custom polling fallback message" do
+          Kernel.should_receive(:warn).with('custom')
+          described_class.select_and_initialize('dir', :polling_fallback_message => 'custom')
+        end
+      end
+
+      context "with polling_fallback_message to false" do
+        it "doesn't warn with a polling fallback message" do
+          Kernel.should_not_receive(:warn)
+          described_class.select_and_initialize('dir', :polling_fallback_message => false)
+        end
+      end
+    end
+
+    context "on Mac OX >= 10.6" do
+      before { Listen::Adapters::Darwin.stub(:usable_and_works?) { true } }
+
+      it "uses Listen::Adapters::Darwin" do
+        Listen::Adapters::Darwin.should_receive(:new).with('dir', {})
+        described_class.select_and_initialize('dir')
+      end
+
+      context 'when the use of the polling adapter is forced' do
+        it 'uses Listen::Adapters::Polling' do
+          Listen::Adapters::Polling.should_receive(:new).with('dir', {})
+          described_class.select_and_initialize('dir', :force_polling => true)
+        end
+      end
+    end
+
+    context "on Linux" do
+      before { Listen::Adapters::Linux.stub(:usable_and_works?) { true } }
+
+      it "uses Listen::Adapters::Linux" do
+        Listen::Adapters::Linux.should_receive(:new).with('dir', {})
+        described_class.select_and_initialize('dir')
+      end
+
+      context 'when the use of the polling adapter is forced' do
+        it 'uses Listen::Adapters::Polling' do
+          Listen::Adapters::Polling.should_receive(:new).with('dir', {})
+          described_class.select_and_initialize('dir', :force_polling => true)
+        end
+      end
+    end
+
+    context "on Windows" do
+      before { Listen::Adapters::Windows.stub(:usable_and_works?) { true } }
+
+      it "uses Listen::Adapters::Windows" do
+        Listen::Adapters::Windows.should_receive(:new).with('dir', {})
+        described_class.select_and_initialize('dir')
+      end
+
+      context 'when the use of the polling adapter is forced' do
+        it 'uses Listen::Adapters::Polling' do
+          Listen::Adapters::Polling.should_receive(:new).with('dir', {})
+          described_class.select_and_initialize('dir', :force_polling => true)
+        end
+      end
+    end
+  end
+
+  [Listen::Adapters::Darwin, Listen::Adapters::Linux, Listen::Adapters::Windows].each do |adapter_class|
+    if adapter_class.usable?
+      describe '.usable_and_works?' do
+        it 'checks if the adapter is usable' do
+          adapter_class.stub(:works?)
+          adapter_class.should_receive(:usable?)
+          adapter_class.usable_and_works?('dir')
+        end
+
+        context 'with one directory' do
+          it 'tests if that directory actually work' do
+            fixtures do |path|
+              adapter_class.should_receive(:works?).with(path, anything).and_return(true)
+              adapter_class.usable_and_works?(path)
+            end
+          end
+        end
+
+        context 'with multiple directories' do
+          it 'tests if each directory passed does actually work' do
+            fixtures(3) do |path1, path2, path3|
+              adapter_class.should_receive(:works?).exactly(3).times.with do |path, options|
+                [path1, path2, path3].include? path
+              end.and_return(true)
+              adapter_class.usable_and_works?([path1, path2, path3])
+            end
+          end
+        end
+      end
+
+      describe '.works?' do
+        it 'does work' do
+          fixtures do |path|
+            adapter_class.works?(path).should be_true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/listen/spec/listen/adapters/darwin_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Listen::Adapters::Darwin do
+  if mac?
+    if Listen::Adapters::Darwin.usable?
+      it "is usable on Mac OS X >= 10.6" do
+        described_class.should be_usable
+      end
+
+      it_should_behave_like 'a filesystem adapter'
+      it_should_behave_like 'an adapter that call properly listener#on_change'
+    else
+      it "isn't usable on Mac OS X with #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}" do
+        described_class.should_not be_usable
+      end
+    end
+
+  end
+
+  if windows?
+    it "isn't usable on Windows" do
+      described_class.should_not be_usable
+    end
+  end
+
+  if linux?
+    it "isn't usable on Linux" do
+      described_class.should_not be_usable
+    end
+  end
+end

data/vendor/listen/spec/listen/adapters/linux_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Listen::Adapters::Linux do
+  if linux?
+    if Listen::Adapters::Linux.usable?
+      it "is usable on Linux" do
+        described_class.should be_usable
+      end
+
+      it_should_behave_like 'a filesystem adapter'
+      it_should_behave_like 'an adapter that call properly listener#on_change'
+    else
+      it "isn't usable on Linux with #{RbConfig::CONFIG['RUBY_INSTALL_NAME']}" do
+        described_class.should_not be_usable
+      end
+    end
+  end
+
+  if mac?
+    it "isn't usable on Mac OS X" do
+      described_class.should_not be_usable
+    end
+  end
+
+  if windows?
+    it "isn't usable on Windows" do
+      described_class.should_not be_usable
+    end
+  end
+end

data/vendor/listen/spec/listen/adapters/polling_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Listen::Adapters::Polling do
+  subject { described_class.new('dir') }
+
+  it_should_behave_like 'a filesystem adapter'
+
+  describe '#initialize' do
+    it 'sets the latency to the default polling one' do
+      subject.latency.should eq Listen::Adapters::DEFAULT_POLLING_LATENCY
+    end
+  end
+
+  describe '#poll' do
+    let(:listener) { mock(Listen::Listener) }
+    let(:callback) { lambda { |changed_dirs, options| @called = true; listener.on_change(changed_dirs, options) } }
+
+    after { subject.stop }
+
+    context 'with one directory to watch' do
+      subject { Listen::Adapters::Polling.new('dir', {}, &callback) }
+
+      it 'calls listener.on_change' do
+        listener.should_receive(:on_change).at_least(1).times.with(['dir'], :recursive => true)
+        subject.start(false)
+        subject.wait_for_callback
+      end
+
+      it 'calls listener.on_change continuously' do
+        subject.latency = 0.001
+        listener.should_receive(:on_change).at_least(10).times.with(['dir'], :recursive => true)
+        subject.start(false)
+        10.times { subject.wait_for_callback }
+      end
+
+      it "doesn't call listener.on_change if paused" do
+        subject.paused = true
+        subject.start(false)
+        subject.wait_for_callback
+        @called.should be_nil
+      end
+    end
+
+    context 'with multiple directories to watch' do
+      subject { Listen::Adapters::Polling.new(%w{dir1 dir2}, {}, &callback) }
+
+      it 'calls listener.on_change' do
+        listener.should_receive(:on_change).at_least(1).times.with(%w{dir1 dir2}, :recursive => true)
+        subject.start(false)
+        subject.wait_for_callback
+      end
+
+      it 'calls listener.on_change continuously' do
+        subject.latency = 0.001
+        listener.should_receive(:on_change).at_least(10).times.with(%w{dir1 dir2}, :recursive => true)
+        subject.start(false)
+        10.times { subject.wait_for_callback }
+      end
+
+      it "doesn't call listener.on_change if paused" do
+        subject.paused = true
+        subject.start(false)
+        subject.wait_for_callback
+        @called.should be_nil
+      end
+    end
+  end
+end