sass 3.3.0 → 3.4.0

data/vendor/listen/lib/listen/adapters/linux.rb

@@ -4,17 +4,12 @@ module Listen
     # Listener implementation for Linux `inotify`.
     #
     class Linux < Adapter
-      extend DependencyManager
-
-      # Declare the adapter's dependencies
-      dependency 'rb-inotify', '~> 0.9'
-
       # Watched inotify events
       #
       # @see http://www.tin.org/bin/man.cgi?section=7&topic=inotify
       # @see https://github.com/nex3/rb-inotify/blob/master/lib/rb-inotify/notifier.rb#L99-L177
       #
-      EVENTS = %w[recursive attrib create delete move close_write]
+      EVENTS = [:recursive, :attrib, :create, :delete, :move, :close_write]
 
       # The message to show when the limit of inotify watchers is not enough
       #
@@ -25,63 +20,31 @@ module Listen
         for information on how to solve this issue.
       EOS
 
-      # Initializes the Adapter. See {Listen::Adapter#initialize} for more info.
+      def self.target_os_regex; /linux/i; end
+      def self.adapter_gem; 'rb-inotify'; end
+
+      # Initializes the Adapter.
+      #
+      # @see Listen::Adapter#initialize
       #
       def initialize(directories, options = {}, &callback)
         super
-        @worker = init_worker
       rescue Errno::ENOSPC
         abort(INOTIFY_LIMIT_MESSAGE)
       end
 
-      # Starts the adapter.
-      #
-      # @param [Boolean] blocking whether or not to block the current thread after starting
-      #
-      def start(blocking = true)
-        @mutex.synchronize do
-          return if @stop == false
-          super
-        end
-
-        @worker_thread = Thread.new { @worker.run }
-        @poll_thread   = Thread.new { poll_changed_dirs } if @report_changes
-
-        @worker_thread.join if blocking
-      end
-
-      # Stops the adapter.
-      #
-      def stop
-        @mutex.synchronize do
-          return if @stop == true
-          super
-        end
-
-        @worker.stop
-        Thread.kill(@worker_thread) if @worker_thread
-        @poll_thread.join if @poll_thread
-      end
-
-      # Checks if the adapter is usable on the current OS.
-      #
-      # @return [Boolean] whether usable or not
-      #
-      def self.usable?
-        return false unless RbConfig::CONFIG['target_os'] =~ /linux/i
-        super
-      end
-
-    private
+      private
 
       # Initializes a INotify worker and adds a watcher for
       # each directory passed to the adapter.
       #
       # @return [INotify::Notifier] initialized worker
       #
-      def init_worker
+      # @see Listen::Adapter#initialize_worker
+      #
+      def initialize_worker
         callback = lambda do |event|
-          if @paused || (
+          if paused || (
             # Event on root directory
             event.name == ""
           ) || (
@@ -89,24 +52,29 @@ module Listen
             # on the directories themselves too.
             #
             # @see http://linux.die.net/man/7/inotify
-            event.flags.include?(:isdir) and event.flags & [:close, :modify] != []
+            event.flags.include?(:isdir) and (event.flags & [:close, :modify]).any?
           )
             # Skip all of these!
             next
           end
 
-          @mutex.synchronize do
-            @changed_dirs << File.dirname(event.absolute_name)
+          mutex.synchronize do
+            @changed_directories << File.dirname(event.absolute_name)
           end
         end
 
         INotify::Notifier.new.tap do |worker|
-          @directories.each do |directory|
-            worker.watch(directory, *EVENTS.map(&:to_sym), &callback)
-          end
+          directories.each { |dir| worker.watch(dir, *EVENTS, &callback) }
         end
       end
 
+      # Starts the worker in a new thread.
+      #
+      # @see Listen::Adapter#start_worker
+      #
+      def start_worker
+        @worker_thread = Thread.new { worker.run }
+      end
     end
 
   end

data/vendor/listen/lib/listen/adapters/polling.rb

@@ -1,66 +1,57 @@
 module Listen
   module Adapters
 
-    # The default delay between checking for changes.
     DEFAULT_POLLING_LATENCY = 1.0
 
     # Polling Adapter that works cross-platform and
     # has no dependencies. This is the adapter that
     # uses the most CPU processing power and has higher
-    # file IO that the other implementations.
+    # file IO than the other implementations.
     #
     class Polling < Adapter
-      extend DependencyManager
+      private
 
-      # Initialize the Adapter. See {Listen::Adapter#initialize} for more info.
+      # The default delay between checking for changes.
       #
-      def initialize(directories, options = {}, &callback)
-        @latency ||= DEFAULT_POLLING_LATENCY
-        super
+      # @see Listen::Adapter#default_latency
+      #
+      def default_latency
+        1.0
       end
 
-      # Start the adapter.
+      # The thread on which the main thread should wait
+      # when the adapter has been started in blocking mode.
       #
-      # @param [Boolean] blocking whether or not to block the current thread after starting
+      # @see Listen::Adapter#blocking_thread
       #
-      def start(blocking = true)
-        @mutex.synchronize do
-          return if @stop == false
-          super
-        end
-
-        @poll_thread = Thread.new { poll }
-        @poll_thread.join if blocking
+      def blocking_thread
+        poller_thread
       end
 
-      # Stop the adapter.
+      # @see Listen::Adapter#start_worker
       #
-      def stop
-        @mutex.synchronize do
-          return if @stop == true
-          super
-        end
-
-        @poll_thread.join
+      # @see Listen::Adapter#start_worker
+      #
+      def start_worker
+        # The polling adapter has no worker! Sad panda! :'(
       end
 
-    private
-
       # Poll listener directory for file system changes.
       #
-      def poll
-        until @stop
-          next if @paused
+      # @see Listen::Adapter#poll_changed_directories
+      #
+      def poll_changed_directories
+        until stopped
+          next if paused
 
           start = Time.now.to_f
-          @callback.call(@directories.dup, :recursive => true)
-          @turnstile.signal
-          nap_time = @latency - (Time.now.to_f - start)
+          callback.call(directories.dup, :recursive => true)
+          turnstile.signal
+          nap_time = latency - (Time.now.to_f - start)
           sleep(nap_time) if nap_time > 0
         end
       rescue Interrupt
       end
-
     end
 
   end

data/vendor/listen/lib/listen/adapters/windows.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'rubygems'
 
 module Listen
   module Adapters
@@ -6,81 +7,84 @@ module Listen
     # Adapter implementation for Windows `wdm`.
     #
     class Windows < Adapter
-      extend DependencyManager
 
-      # Declare the adapter's dependencies
-      dependency 'wdm', '~> 0.1'
+      BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+        Please add the following to your Gemfile to avoid polling for changes:
+          require 'rbconfig'
+          gem 'wdm', '>= 0.1.0' if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+      EOS
 
-      # Initializes the Adapter. See {Listen::Adapter#initialize} for more info.
+      def self.target_os_regex; /mswin|mingw/i; end
+      def self.adapter_gem; 'wdm'; end
+
+      # Checks if the adapter is usable on target OS.
       #
-      def initialize(directories, options = {}, &callback)
-        super
-        @worker = init_worker
+      # @return [Boolean] whether usable or not
+      #
+      def self.usable?
+        super if mri? && at_least_ruby_1_9?
       end
 
-      # Starts the adapter.
+      # Load the adapter gem
       #
-      # @param [Boolean] blocking whether or not to block the current thread after starting
+      # @return [Boolean] whether required or not
       #
-      def start(blocking = true)
-        @mutex.synchronize do
-          return if @stop == false
-          super
-        end
-
-        @worker_thread = Thread.new { @worker.run! }
-
-        # Wait for the worker to start. This is needed to avoid a deadlock
-        # when stopping immediately after starting.
-        sleep 0.1
-
-        @poll_thread = Thread.new { poll_changed_dirs } if @report_changes
-
-        @worker_thread.join if blocking
+      def self.load_dependent_adapter
+        super
+      rescue Gem::LoadError
+        Kernel.warn BUNDLER_DECLARE_GEM
       end
 
-      # Stops the adapter.
-      #
-      def stop
-        @mutex.synchronize do
-          return if @stop == true
-          super
-        end
+      private
 
-        @worker.stop
-        @worker_thread.join if @worker_thread
-        @poll_thread.join if @poll_thread
+      # Checks if Ruby engine is MRI.
+      #
+      # @return [Boolean]
+      #
+      def self.mri?
+        defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
       end
 
-      # Checks if the adapter is usable on the current OS.
+      # Checks if Ruby engine is MRI.
       #
-      # @return [Boolean] whether usable or not
+      # @return [Boolean]
       #
-      def self.usable?
-        return false unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
-        super
+      def self.at_least_ruby_1_9?
+        Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('1.9.2')
       end
 
-    private
-
       # Initializes a WDM monitor and adds a watcher for
       # each directory passed to the adapter.
       #
       # @return [WDM::Monitor] initialized worker
       #
-      def init_worker
+      # @see Listen::Adapter#initialize_worker
+      #
+      def initialize_worker
         callback = Proc.new do |change|
-          next if @paused
-          @mutex.synchronize do
-            @changed_dirs << File.dirname(change.path)
+          next if paused
+
+          mutex.synchronize do
+            @changed_directories << File.dirname(change.path)
           end
         end
 
         WDM::Monitor.new.tap do |worker|
-          @directories.each { |d| worker.watch_recursively(d, &callback) }
+          directories.each { |dir| worker.watch_recursively(dir, &callback) }
         end
       end
 
+      # Start the worker in a new thread and sleep 0.1 second.
+      #
+      # @see Listen::Adapter#start_worker
+      #
+      def start_worker
+        @worker_thread = Thread.new { worker.run! }
+        # Wait for the worker to start. This is needed to avoid a deadlock
+        # when stopping immediately after starting.
+        sleep 0.1
+      end
+
     end
 
   end

data/vendor/listen/lib/listen/directory_record.rb

@@ -11,8 +11,10 @@ module Listen
   class DirectoryRecord
     attr_reader :directory, :paths, :sha1_checksums
 
-    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn log tmp vendor]
+    # The default list of directories that get ignored by the listener.
+    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn bundle log tmp vendor]
 
+    # The default list of files that get ignored by the listener.
     DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store]
 
     # Defines the used precision based on the type of mtime returned by the
@@ -56,15 +58,14 @@ module Listen
     def initialize(directory)
       raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(directory)
 
-      @directory          = directory
-      @ignoring_patterns  = Set.new
-      @filtering_patterns = Set.new
-      @sha1_checksums     = Hash.new
+      @directory, @sha1_checksums = File.expand_path(directory), Hash.new
+      @ignoring_patterns, @filtering_patterns = Set.new, Set.new
 
       @ignoring_patterns.merge(DirectoryRecord.generate_default_ignoring_patterns)
     end
 
-    # Returns the ignoring patterns in the record
+    # Returns the ignoring patterns in the record to know
+    # which paths should be ignored.
     #
     # @return [Array<Regexp>] the ignoring patterns
     #
@@ -72,7 +73,7 @@ module Listen
       @ignoring_patterns.to_a
     end
 
-    # Returns the filtering patterns used in the record to know
+    # Returns the filtering patterns in the record to know
     # which paths should be stored.
     #
     # @return [Array<Regexp>] the filtering patterns
@@ -86,10 +87,10 @@ module Listen
     # @example Ignore some paths
     #   ignore %r{^ignored/path/}, /man/
     #
-    # @param [Regexp] regexp a pattern for ignoring paths
+    # @param [Regexp] regexps a list of patterns for ignoring paths
     #
     def ignore(*regexps)
-      @ignoring_patterns.merge(regexps)
+      @ignoring_patterns.merge(regexps).reject! { |r| r.nil? }
     end
 
     # Replaces ignoring patterns in the record.
@@ -97,37 +98,37 @@ module Listen
     # @example Ignore only these paths
     #   ignore! %r{^ignored/path/}, /man/
     #
-    # @param [Regexp] regexp a pattern for ignoring paths
+    # @param [Regexp] regexps a list of patterns for ignoring paths
     #
     def ignore!(*regexps)
-      @ignoring_patterns.replace(regexps)
+      @ignoring_patterns.replace(regexps).reject! { |r| r.nil? }
     end
 
-    # Adds filtering patterns to the listener.
+    # Adds filtering patterns to the record.
     #
     # @example Filter some files
-    #   ignore /\.txt$/, /.*\.zip/
+    #   filter /\.txt$/, /.*\.zip/
     #
-    # @param [Regexp] regexp a pattern for filtering paths
+    # @param [Regexp] regexps a list of patterns for filtering files
     #
     def filter(*regexps)
-      @filtering_patterns.merge(regexps)
+      @filtering_patterns.merge(regexps).reject! { |r| r.nil? }
     end
 
-    # Replaces filtering patterns in the listener.
+    # Replaces filtering patterns in the record.
     #
     # @example Filter only these files
-    #   ignore /\.txt$/, /.*\.zip/
+    #   filter! /\.txt$/, /.*\.zip/
     #
-    # @param [Regexp] regexp a pattern for filtering paths
+    # @param [Regexp] regexps a list of patterns for filtering files
     #
     def filter!(*regexps)
-      @filtering_patterns.replace(regexps)
+      @filtering_patterns.replace(regexps).reject! { |r| r.nil? }
     end
 
     # Returns whether a path should be ignored or not.
     #
-    # @param [String] path the path to test.
+    # @param [String] path the path to test
     #
     # @return [Boolean]
     #
@@ -138,7 +139,7 @@ module Listen
 
     # Returns whether a path should be filtered or not.
     #
-    # @param [String] path the path to test.
+    # @param [String] path the path to test
     #
     # @return [Boolean]
     #
@@ -159,9 +160,9 @@ module Listen
     end
 
     # Detects changes in the passed directories, updates
-    # the record with the new changes and returns the changes
+    # the record with the new changes and returns the changes.
     #
-    # @param [Array] directories the list of directories scan for changes
+    # @param [Array] directories the list of directories to scan for changes
     # @param [Hash] options
     # @option options [Boolean] recursive scan all sub-directories recursively
     # @option options [Boolean] relative_paths whether or not to use relative paths for changes
@@ -174,6 +175,7 @@ module Listen
 
       directories.each do |directory|
         next unless directory[@directory] # Path is or inside directory
+
         detect_modifications_and_removals(directory, options)
         detect_additions(directory, options)
       end
@@ -188,9 +190,15 @@ module Listen
     # @return [String] the relative path
     #
     def relative_to_base(path)
-      return nil unless path[@directory]
-      path = path.force_encoding("BINARY") if path.respond_to?(:force_encoding)
-      path.sub(%r{^#{Regexp.quote(@directory)}#{File::SEPARATOR}?}, '')
+      path = path.dup
+      regexp = "\\A#{Regexp.quote directory}(#{File::SEPARATOR}|\\z)"
+      if path.respond_to?(:force_encoding)
+        path.force_encoding("BINARY")
+        regexp.force_encoding("BINARY")
+      end
+      if path.sub!(Regexp.new(regexp), '')
+        path
+      end
     end
 
     private
@@ -207,43 +215,69 @@ module Listen
     # @option options [Boolean] relative_paths whether or not to use relative paths for changes
     #
     def detect_modifications_and_removals(directory, options = {})
-      @paths[directory].each do |basename, meta_data|
+      paths[directory].each do |basename, meta_data|
         path = File.join(directory, basename)
-
         case meta_data.type
         when 'Dir'
-          if File.directory?(path)
-            detect_modifications_and_removals(path, options) if options[:recursive]
-          else
-            detect_modifications_and_removals(path, { :recursive => true }.merge(options))
-            @paths[directory].delete(basename)
-            @paths.delete("#{directory}/#{basename}")
-          end
+          detect_modification_or_removal_for_dir(path, options)
         when 'File'
-          if File.exist?(path)
-            new_mtime = mtime_of(path)
+          detect_modification_or_removal_for_file(path, meta_data, options)
+        end
+      end
+    end
 
-            # First check if we are in the same second (to update checksums)
-            # before checking the time difference
-            if (meta_data.mtime.to_i == new_mtime.to_i && content_modified?(path)) || meta_data.mtime < new_mtime
-              # Update the sha1 checksum of the file
-              insert_sha1_checksum(path)
+    def detect_modification_or_removal_for_dir(path, options)
 
-              # Update the meta data of the file
-              meta_data.mtime = new_mtime
-              @paths[directory][basename] = meta_data
+      # Directory still exists
+      if File.directory?(path)
+        detect_modifications_and_removals(path, options) if options[:recursive]
 
-              @changes[:modified] << (options[:relative_paths] ? relative_to_base(path) : path)
-            end
-          else
-            @paths[directory].delete(basename)
-            @sha1_checksums.delete(path)
-            @changes[:removed] << (options[:relative_paths] ? relative_to_base(path) : path)
-          end
-        end
+      # Directory has been removed
+      else
+        detect_modifications_and_removals(path, options)
+        @paths[File.dirname(path)].delete(File.basename(path))
+        @paths.delete("#{File.dirname(path)}/#{File.basename(path)}")
+      end
+    end
+
+    def detect_modification_or_removal_for_file(path, meta_data, options)
+      # File still exists
+      if File.exist?(path)
+        detect_modification(path, meta_data, options)
+
+      # File has been removed
+      else
+        removal_detected(path, meta_data, options)
+      end
+    end
+
+    def detect_modification(path, meta_data, options)
+      new_mtime = mtime_of(path)
+
+      # First check if we are in the same second (to update checksums)
+      # before checking the time difference
+      if (meta_data.mtime.to_i == new_mtime.to_i && content_modified?(path)) || meta_data.mtime < new_mtime
+        modification_detected(path, meta_data, new_mtime, options)
       end
     end
 
+    def modification_detected(path, meta_data, new_mtime, options)
+      # Update the sha1 checksum of the file
+      update_sha1_checksum(path)
+
+      # Update the meta data of the file
+      meta_data.mtime = new_mtime
+      @paths[File.dirname(path)][File.basename(path)] = meta_data
+
+      @changes[:modified] << (options[:relative_paths] ? relative_to_base(path) : path)
+    end
+
+    def removal_detected(path, meta_data, options)
+      @paths[File.dirname(path)].delete(File.basename(path))
+      @sha1_checksums.delete(path)
+      @changes[:removed] << (options[:relative_paths] ? relative_to_base(path) : path)
+    end
+
     # Detects additions in a directory.
     #
     # @param [String] directory the path to analyze
@@ -283,9 +317,10 @@ module Listen
     # @param [String] path the file path
     #
     def content_modified?(path)
+      return false unless File.ftype(path) == 'file'
       @sha1_checksum = sha1_checksum(path)
-      if @sha1_checksums[path] == @sha1_checksum || !@sha1_checksums.key?(path)
-        insert_sha1_checksum(path)
+      if sha1_checksums[path] == @sha1_checksum || !sha1_checksums.key?(path)
+        update_sha1_checksum(path)
         false
       else
         true
@@ -296,7 +331,7 @@ module Listen
     #
     # @param [String] path the SHA1-checksum path to insert in @sha1_checksums.
     #
-    def insert_sha1_checksum(path)
+    def update_sha1_checksum(path)
       if @sha1_checksum ||= sha1_checksum(path)
         @sha1_checksums[path] = @sha1_checksum
         @sha1_checksum = nil
@@ -309,18 +344,18 @@ module Listen
     #
     def sha1_checksum(path)
       Digest::SHA1.file(path).to_s
-    rescue Errno::EACCES, Errno::ENOENT, Errno::ENXIO, Errno::EOPNOTSUPP
+    rescue
       nil
     end
 
     # Traverses the base directory looking for paths that should
-    # be stored; thus paths that are filters or not ignored.
+    # be stored; thus paths that are filtered or not ignored.
     #
     # @yield [path] an important path
     #
     def important_paths
-      Find.find(@directory) do |path|
-        next if path == @directory
+      Find.find(directory) do |path|
+        next if path == directory
 
         if File.directory?(path)
           # Add a trailing slash to directories when checking if a directory is
@@ -355,7 +390,7 @@ module Listen
     # @return [Boolean]
     #
     def existing_path?(path)
-      @paths[File.dirname(path)][File.basename(path)] != nil
+      paths[File.dirname(path)][File.basename(path)] != nil
     end
 
     # Returns the modification time of a file based on the precision defined by the system