sass 3.2.0.alpha.101 → 3.2.0.alpha.102

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

@@ -0,0 +1,66 @@
+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.
+    #
+    class Polling < Adapter
+
+      # Initialize the Adapter. See {Listen::Adapter#initialize} for more info.
+      #
+      def initialize(directories, options = {}, &callback)
+        @latency ||= DEFAULT_POLLING_LATENCY
+        super
+      end
+
+      # Start 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
+
+        @poll_thread = Thread.new { poll }
+        @poll_thread.join if blocking
+      end
+
+      # Stop the adapter.
+      #
+      def stop
+        @mutex.synchronize do
+          return if @stop == true
+          super
+        end
+
+        @poll_thread.join
+      end
+
+    private
+
+      # Poll listener directory for file system changes.
+      #
+      def poll
+        until @stop
+          sleep(0.1) && next if @paused
+
+          start = Time.now.to_f
+          @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
+end

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

@@ -0,0 +1,82 @@
+require 'set'
+
+module Listen
+  module Adapters
+
+    # Adapter implementation for Windows `fchange`.
+    #
+    class Windows < Adapter
+
+      # Initializes the Adapter. See {Listen::Adapter#initialize} for more info.
+      #
+      def initialize(directories, options = {}, &callback)
+        super
+        @worker = init_worker
+      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(true) }
+        @poll_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
+      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'] =~ /mswin|mingw/i
+
+        require 'rb-fchange'
+        true
+      rescue LoadError
+        false
+      end
+
+    private
+
+      # Initializes a FChange worker and adds a watcher for
+      # each directory passed to the adapter.
+      #
+      # @return [FChange::Notifier] initialized worker
+      #
+      def init_worker
+        worker = FChange::Notifier.new
+        @directories.each do |directory|
+          watcher = worker.watch(directory, :all_events, :recursive) do |event|
+            next if @paused
+            @mutex.synchronize do
+              @changed_dirs << File.expand_path(event.watcher.path)
+            end
+          end
+          worker.add_watcher(watcher)
+        end
+        worker
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,257 @@
+require 'set'
+require 'find'
+require 'pathname'
+require 'digest/sha1'
+
+module Listen
+
+  # The directory record stores information about
+  # a directory and keeps track of changes to
+  # the structure of its childs.
+  #
+  class DirectoryRecord
+    attr_reader :directory, :paths, :sha1_checksums
+
+    # Default paths' beginnings that doesn't get stored in the record
+    DEFAULT_IGNORED_PATHS = %w[.bundle .git .DS_Store log tmp vendor]
+
+    # Initializes a directory record.
+    #
+    # @option [String] directory the directory to keep track of
+    #
+    def initialize(directory)
+      @directory = directory
+      raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(@directory)
+
+      @ignored_paths  = Set.new(DEFAULT_IGNORED_PATHS)
+      @filters        = Set.new
+      @sha1_checksums = Hash.new
+    end
+
+    # Returns the ignored paths in the record
+    #
+    # @return [Array<String>] the ignored paths
+    #
+    def ignored_paths
+      @ignored_paths.to_a
+    end
+
+    # Returns the filters used in the record to know
+    # which paths should be stored.
+    #
+    # @return [Array<String>] the used filters
+    #
+    def filters
+      @filters.to_a
+    end
+
+    # Adds ignored path to the record.
+    #
+    # @example Ignore some paths
+    #   ignore ".git", ".svn"
+    #
+    # @param [String, Array<String>] paths a path or a list of paths to ignore
+    #
+    def ignore(*paths)
+      @ignored_paths.merge(paths)
+    end
+
+    # Adds file filters to the listener.
+    #
+    # @example Filter some files
+    #   ignore /\.txt$/, /.*\.zip/
+    #
+    # @param [Array<Regexp>] regexps a list of regexps file filters
+    #
+    # @return [Listen::Listener] the listener itself
+    #
+    def filter(*regexps)
+      @filters.merge(regexps)
+    end
+
+    # Returns whether a path should be ignored or not.
+    #
+    # @param [String] path the path to test.
+    #
+    # @return [Boolean]
+    #
+    def ignored?(path)
+      @ignored_paths.any? { |ignored_path| path =~ /#{ignored_path}$/ }
+    end
+
+    # Returns whether a path should be filtered or not.
+    #
+    # @param [String] path the path to test.
+    #
+    # @return [Boolean]
+    #
+    def filtered?(path)
+      @filters.empty? || @filters.any? { |filter| path =~ filter }
+    end
+
+    # Finds the paths that should be stored and adds them
+    # to the paths' hash.
+    #
+    def build
+      @paths = Hash.new { |h, k| h[k] = Hash.new }
+      important_paths { |path| insert_path(path) }
+      @updated_at = Time.now.to_i
+    end
+
+    # Detects changes in the passed directories, updates
+    # the record with the new changes and returns the changes
+    #
+    # @param [Array] directories the list of directories 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
+    #
+    # @return [Hash<Array>] the changes
+    #
+    def fetch_changes(directories, options = {})
+      @changes    = { :modified => [], :added => [], :removed => [] }
+      directories = directories.sort_by { |el| el.length }.reverse # diff sub-dir first
+      directories.each do |directory|
+        next unless directory[@directory] # Path is or inside directory
+        detect_modifications_and_removals(directory, options)
+        detect_additions(directory, options)
+      end
+      @updated_at = Time.now.to_i
+      @changes
+    end
+
+    private
+
+    # Detects modifications and removals recursively in a directory.
+    #
+    # @note Modifications detection begins by checking the modification time (mtime)
+    #   of files and then by checking content changes (using SHA1-checksum)
+    #   when the mtime of files is not changed.
+    #
+    # @param [String] directory the path to analyze
+    # @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
+    #
+    def detect_modifications_and_removals(directory, options = {})
+      @paths[directory].each do |basename, type|
+        path = File.join(directory, basename)
+
+        case 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
+        when 'File'
+          if File.exist?(path)
+            new_mtime = File.mtime(path).to_i
+            if @updated_at < new_mtime || (@updated_at == new_mtime && content_modified?(path))
+              @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
+      end
+    end
+
+    # Detects additions in a directory.
+    #
+    # @param [String] directory the path to analyze
+    # @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
+    #
+    def detect_additions(directory, options = {})
+      # Don't process removed directories
+      return unless File.exist?(directory)
+
+      Find.find(directory) do |path|
+        next if path == @directory
+
+        if File.directory?(path)
+          if ignored?(path) || (directory != path && (!options[:recursive] && existing_path?(path)))
+            Find.prune # Don't look any further into this directory.
+          else
+            insert_path(path)
+          end
+        elsif !ignored?(path) && filtered?(path) && !existing_path?(path)
+          if File.file?(path)
+            @changes[:added] << (options[:relative_paths] ? relative_to_base(path) : path)
+          end
+          insert_path(path)
+        end
+      end
+    end
+
+    # Returns whether or not a file's content has been modified by
+    # comparing the SHA1-checksum to a stored one.
+    #
+    # @param [String] path the file path
+    #
+    def content_modified?(path)
+      sha1_checksum = Digest::SHA1.file(path).to_s
+      if @sha1_checksums[path] != sha1_checksum
+        @sha1_checksums[path] = sha1_checksum
+        true
+      else
+        false
+      end
+    end
+
+    # Traverses the base directory looking for paths that should
+    # be stored; thus paths that are filters or not ignored.
+    #
+    # @yield [path] an important path
+    #
+    def important_paths
+      Find.find(@directory) do |path|
+        next if path == @directory
+
+        if File.directory?(path)
+          if ignored?(path)
+            Find.prune # Don't look any further into this directory.
+          else
+            yield(path)
+          end
+        elsif !ignored?(path) && filtered?(path)
+          yield(path)
+        end
+      end
+    end
+
+    # Inserts a path with its type (Dir or File) in paths hash.
+    #
+    # @param [String] path the path to insert in @paths.
+    #
+    def insert_path(path)
+      @paths[File.dirname(path)][File.basename(path)] = File.directory?(path) ? 'Dir' : 'File'
+    end
+
+    # Returns whether or not a path exists in the paths hash.
+    #
+    # @param [String] path the path to check
+    #
+    # @return [Boolean]
+    #
+    def existing_path?(path)
+      @paths[File.dirname(path)][File.basename(path)] != nil
+    end
+
+    # Converts an absolute path to a path that's relative to the base directory.
+    #
+    # @param [String] path the path to convert
+    #
+    # @return [String] the relative path
+    #
+    def relative_to_base(path)
+      path.sub(%r(^#{@directory}/?/), '')
+    end
+  end
+end

data/vendor/listen/lib/listen/listener.rb

@@ -0,0 +1,186 @@
+module Listen
+  class Listener
+    attr_reader :directory, :directory_record, :adapter
+
+    # The default value for using relative paths in the callback.
+    DEFAULT_TO_RELATIVE_PATHS = false
+
+    # Initializes the directory listener.
+    #
+    # @param [String] directory the directory 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] relative_paths whether or not to use relative-paths in the callback
+    # @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(directory, options = {}, &block)
+      @block              = block
+      @directory          = directory
+      @directory_record   = DirectoryRecord.new(directory)
+      @use_relative_paths = DEFAULT_TO_RELATIVE_PATHS
+
+      @use_relative_paths = options.delete(:relative_paths) if options[:relative_paths]
+      @directory_record.ignore(*options.delete(:ignore))    if options[:ignore]
+      @directory_record.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 }
+      @directory_record.build
+      t.join
+      @adapter.start(blocking)
+    end
+
+    # Stops the listener.
+    #
+    def stop
+      @adapter.stop
+    end
+
+    # Pauses the listener.
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def pause
+      @adapter.paused = true
+      self
+    end
+
+    # Unpauses the listener.
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def unpause
+      @directory_record.build
+      @adapter.paused = false
+      self
+    end
+
+    # Returns whether the listener is paused or not.
+    #
+    # @return [Boolean] adapter paused status
+    #
+    def paused?
+      !!@adapter && @adapter.paused == true
+    end
+
+    # Adds ignored paths to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#ignore)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def ignore(*paths)
+      @directory_record.ignore(*paths)
+      self
+    end
+
+    # Adds file filters to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#filter)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def filter(*regexps)
+      @directory_record.filter(*regexps)
+      self
+    end
+
+    # Sets the latency for the adapter. This is a helper method
+    # to simplify changing the latency directly from the listener.
+    #
+    # @example Wait 0.5 seconds each time before checking changes
+    #   latency 0.5
+    #
+    # @param [Float] seconds the amount of delay, in seconds
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def latency(seconds)
+      @adapter_options[:latency] = seconds
+      self
+    end
+
+    # Defines whether the use of the polling adapter
+    # should be forced or not.
+    #
+    # @example Forcing the use of the polling adapter
+    #   force_polling true
+    #
+    # @param [Boolean] value whether to force the polling adapter or not
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def force_polling(value)
+      @adapter_options[:force_polling] = value
+      self
+    end
+
+    # Defines a custom polling fallback message of disable it.
+    #
+    # @example Disabling the polling fallback message
+    #   polling_fallback_message false
+    #
+    # @param [String, Boolean] value to change polling fallback message or remove it
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def polling_fallback_message(value)
+      @adapter_options[:polling_fallback_message] = value
+      self
+    end
+
+    # Sets the callback that gets called on changes.
+    #
+    # @example Assign a callback to be called on changes
+    #   callback = lambda { |modified, added, removed| ... }
+    #   change &callback
+    #
+    # @param [Proc] block the callback proc
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def change(&block) # modified, added, removed
+      @block = block
+      self
+    end
+
+    # Runs the callback passing it the changes if there are any.
+    #
+    # @param (see Listen::DirectoryRecord#fetch_changes)
+    #
+    def on_change(directories, options = {})
+      changes = @directory_record.fetch_changes(directories, options.merge(
+        :relative_paths => @use_relative_paths
+      ))
+      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(@directory, @adapter_options, &callback)
+    end
+  end
+end