sass 3.3.0.rc.1 → 3.3.0.rc.2

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

@@ -0,0 +1,85 @@
+module Listen
+  module Adapters
+
+    # Adapter implementation for Mac OS X `FSEvents`.
+    #
+    class Darwin < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'rb-fsevent', '~> 0.9'
+
+      LAST_SEPARATOR_REGEX = /\/$/
+
+      # 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 }
+
+        # The FSEvent worker needs sometime to startup. Turnstiles can't
+        # be used to wait for it as it runs in a loop.
+        # TODO: Find a better way to block until the worker starts.
+        sleep 0.1
+
+        @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
+        @worker_thread.join 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'] =~ /darwin(1.+)?$/i
+        super
+      end
+
+      private
+
+      # Initializes a FSEvent worker and adds a watcher for
+      # each directory passed to the adapter.
+      #
+      # @return [FSEvent] initialized worker
+      #
+      def init_worker
+        FSEvent.new.tap do |worker|
+          worker.watch(@directories.dup, :latency => @latency) do |changes|
+            next if @paused
+            @mutex.synchronize do
+              changes.each { |path| @changed_dirs << path.sub(LAST_SEPARATOR_REGEX, '') }
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,113 @@
+module Listen
+  module Adapters
+
+    # 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]
+
+      # The message to show when the limit of inotify watchers is not enough
+      #
+      INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+        Listen error: unable to monitor directories for changes.
+
+        Please head to https://github.com/guard/listen/wiki/Increasing-the-amount-of-inotify-watchers
+        for information on how to solve this issue.
+      EOS
+
+      # Initializes the Adapter. See {Listen::Adapter#initialize} for more info.
+      #
+      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
+
+      # Initializes a INotify worker and adds a watcher for
+      # each directory passed to the adapter.
+      #
+      # @return [INotify::Notifier] initialized worker
+      #
+      def init_worker
+        callback = lambda do |event|
+          if @paused || (
+            # Event on root directory
+            event.name == ""
+          ) || (
+            # INotify reports changes to files inside directories as events
+            # on the directories themselves too.
+            #
+            # @see http://linux.die.net/man/7/inotify
+            event.flags.include?(:isdir) and event.flags & [:close, :modify] != []
+          )
+            # Skip all of these!
+            next
+          end
+
+          @mutex.synchronize do
+            @changed_dirs << 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
+        end
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+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
+      extend DependencyManager
+
+      # 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
+          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,87 @@
+require 'set'
+
+module Listen
+  module Adapters
+
+    # Adapter implementation for Windows `wdm`.
+    #
+    class Windows < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'wdm', '~> 0.1'
+
+      # 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! }
+
+        # 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
+      end
+
+      # Stops the adapter.
+      #
+      def stop
+        @mutex.synchronize do
+          return if @stop == true
+          super
+        end
+
+        @worker.stop
+        @worker_thread.join 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'] =~ /mswin|mingw/i
+        super
+      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
+        callback = Proc.new do |change|
+          next if @paused
+          @mutex.synchronize do
+            @changed_dirs << File.dirname(change.path)
+          end
+        end
+
+        WDM::Monitor.new.tap do |worker|
+          @directories.each { |d| worker.watch_recursively(d, &callback) }
+        end
+      end
+
+    end
+
+  end
+end

data/vendor/listen/lib/listen/dependency_manager.rb

@@ -0,0 +1,126 @@
+require 'set'
+
+module Listen
+
+  # The dependency-manager offers a simple DSL which allows
+  # classes to declare their gem dependencies and load them when
+  # needed.
+  # It raises a user-friendly exception when the dependencies
+  # can't be loaded which has the install command in the message.
+  #
+  module DependencyManager
+
+    GEM_LOAD_MESSAGE = <<-EOS.gsub(/^ {6}/, '')
+      Missing dependency '%s' (version '%s')!
+    EOS
+
+    GEM_INSTALL_COMMAND = <<-EOS.gsub(/^ {6}/, '')
+      Please run the following to satisfy the dependency:
+        gem install --version '%s' %s
+    EOS
+
+    BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+      Please add the following to your Gemfile to satisfy the dependency:
+        gem '%s', '%s'
+    EOS
+
+    Dependency = Struct.new(:name, :version)
+
+    # The error raised when a dependency can't be loaded.
+    class Error < StandardError; end
+
+    # A list of all loaded dependencies in the dependency manager.
+    @_loaded_dependencies = Set.new
+
+    # class methods
+    class << self
+
+      # Initializes the extended class.
+      #
+      # @param [Class] the class for which some dependencies must be managed
+      #
+      def extended(base)
+        base.class_eval do
+          @_dependencies = Set.new
+        end
+      end
+
+      # Adds a loaded dependency to a list so that it doesn't have
+      # to be loaded again by another classes.
+      #
+      # @param [Dependency] dependency
+      #
+      def add_loaded(dependency)
+        @_loaded_dependencies << dependency
+      end
+
+      # Returns whether the dependency is alread loaded or not.
+      #
+      # @param [Dependency] dependency
+      # @return [Boolean]
+      #
+      def already_loaded?(dependency)
+        @_loaded_dependencies.include?(dependency)
+      end
+
+      # Clears the list of loaded dependencies.
+      #
+      def clear_loaded
+        @_loaded_dependencies.clear
+      end
+    end
+
+    # Registers a new dependency.
+    #
+    # @param [String] name the name of the gem
+    # @param [String] version the version of the gem
+    #
+    def dependency(name, version)
+      @_dependencies << Dependency.new(name, version)
+    end
+
+    # Loads the registered dependencies.
+    #
+    # @raise DependencyManager::Error if the dependency can't be loaded.
+    #
+    def load_depenencies
+      @_dependencies.each do |dependency|
+        begin
+          next if DependencyManager.already_loaded?(dependency)
+          gem(dependency.name, dependency.version)
+          require(dependency.name)
+          DependencyManager.add_loaded(dependency)
+          @_dependencies.delete(dependency)
+        rescue Gem::LoadError
+          args = [dependency.name, dependency.version]
+          command = if running_under_bundler?
+            BUNDLER_DECLARE_GEM % args
+          else
+            GEM_INSTALL_COMMAND % args.reverse
+          end
+          message = GEM_LOAD_MESSAGE % args
+
+          raise Error.new(message + command)
+        end
+      end
+    end
+
+    # Returns whether all the dependencies has been loaded or not.
+    #
+    # @return [Boolean]
+    #
+    def dependencies_loaded?
+      @_dependencies.empty?
+    end
+
+    private
+
+    # Returns whether we are running under bundler or not
+    #
+    # @return [Boolean]
+    #
+    def running_under_bundler?
+      !!(File.exists?('Gemfile') && ENV['BUNDLE_GEMFILE'])
+    end
+  end
+end