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

data/vendor/listen/Rakefile

@@ -0,0 +1,47 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+require 'rbconfig'
+namespace(:spec) do
+  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/i
+    desc "Run all specs on multiple ruby versions (requires pik)"
+    task(:portability) do
+      %w[187 192 161].each do |version|
+         system "cmd /c echo -----------#{version}------------ & " +
+           "pik use #{version} & " +
+           "bundle install & " +
+           "bundle exec rspec spec"
+      end
+    end
+  else
+    desc "Run all specs on multiple ruby versions (requires rvm)"
+    task(:portability) do
+      travis_config_file = File.expand_path("../.travis.yml", __FILE__)
+      begin
+        travis_options ||= YAML::load_file(travis_config_file)
+      rescue => ex
+        puts "Travis config file '#{travis_config_file}' could not be found: #{ex.message}"
+        return
+      end
+
+      travis_options['rvm'].each do |version|
+        system <<-BASH
+          bash -c 'source ~/.rvm/scripts/rvm;
+                   rvm #{version};
+                   ruby_version_string_size=`ruby -v | wc -m`
+                   echo;
+                   for ((c=1; c<$ruby_version_string_size; c++)); do echo -n "="; done
+                   echo;
+                   echo "`ruby -v`";
+                   for ((c=1; c<$ruby_version_string_size; c++)); do echo -n "="; done
+                   echo;
+                   RBXOPT="-Xrbc.db" bundle install;
+                   RBXOPT="-Xrbc.db" bundle exec rspec spec -f doc 2>&1;'
+        BASH
+      end
+    end
+  end
+end

data/vendor/listen/Vagrantfile

@@ -0,0 +1,96 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant::Config.run do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "lucid32"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  # config.vm.box_url = "http://domain.com/path/to/above.box"
+
+  # Boot with a GUI so you can see the screen. (Default is headless)
+  # config.vm.boot_mode = :gui
+
+  # Assign this VM to a host-only network IP, allowing you to access it
+  # via the IP. Host-only networks can talk to the host machine as well as
+  # any other machines on the same network, but cannot be accessed (through this
+  # network interface) by any external networks.
+  # config.vm.network :hostonly, "33.33.33.10"
+
+  # Assign this VM to a bridged network, allowing you to connect directly to a
+  # network using the host's network device. This makes the VM appear as another
+  # physical device on your network.
+  # config.vm.network :bridged
+
+  # Forward a port from the guest to the host, which allows for outside
+  # computers to access the VM, whereas host only networking does not.
+  # config.vm.forward_port 80, 8080
+
+  # Share an additional folder to the guest VM. The first argument is
+  # an identifier, the second is the path on the guest to mount the
+  # folder, and the third is the path on the host to the actual folder.
+  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file lucid32.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "lucid32.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path (relative
+  # to this Vagrantfile), and adding some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "cookbooks"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # IF you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/vendor/listen/lib/listen.rb

@@ -0,0 +1,40 @@
+module Listen
+
+  autoload :Turnstile,         'listen/turnstile'
+  autoload :Listener,          'listen/listener'
+  autoload :MultiListener,     'listen/multi_listener'
+  autoload :DirectoryRecord,   'listen/directory_record'
+  autoload :DependencyManager, 'listen/dependency_manager'
+  autoload :Adapter,           'listen/adapter'
+
+  module Adapters
+    autoload :Darwin,  'listen/adapters/darwin'
+    autoload :Linux,   'listen/adapters/linux'
+    autoload :BSD,     'listen/adapters/bsd'
+    autoload :Windows, 'listen/adapters/windows'
+    autoload :Polling, 'listen/adapters/polling'
+  end
+
+  # Listens to filesystem modifications on a either single directory or multiple directories.
+  #
+  # @param (see Listen::Listener#new)
+  # @param (see Listen::MultiListener#new)
+  #
+  # @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
+  #
+  # @return [Listen::Listener] the file listener if no block given
+  #
+  def self.to(*args, &block)
+    listener = if args.length == 1 || ! args[1].is_a?(String)
+      Listener.new(*args, &block)
+    else
+      MultiListener.new(*args, &block)
+    end
+
+    block ? listener.start : listener
+  end
+
+end

data/vendor/listen/lib/listen/adapter.rb

@@ -0,0 +1,214 @@
+require 'rbconfig'
+require 'thread'
+require 'set'
+require 'fileutils'
+
+module Listen
+  class Adapter
+    attr_accessor :directories, :latency, :paused
+
+    # The default delay between checking for changes.
+    DEFAULT_LATENCY = 0.25
+
+    # The default warning message when there is a missing dependency.
+    MISSING_DEPENDENCY_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+      For a better performance, it's recommended that you satisfy the missing dependency.
+    EOS
+
+    # The default warning message when falling back to polling adapter.
+    POLLING_FALLBACK_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+      Listen will be polling changes. Learn more at https://github.com/guard/listen#polling-fallback.
+    EOS
+
+    # Selects the appropriate adapter implementation for the
+    # current OS and initializes it.
+    #
+    # @param [String, Array<String>] directories the directories to watch
+    # @param [Hash] options the adapter options
+    # @option options [Boolean] force_polling to force polling or not
+    # @option options [String, Boolean] polling_fallback_message to change polling fallback message or remove it
+    # @option options [Float] latency the delay between checking for changes in seconds
+    #
+    # @yield [changed_dirs, options] callback Callback called when a change happens
+    # @yieldparam [Array<String>] changed_dirs the changed directories
+    # @yieldparam [Hash] options callback options (like :recursive => true)
+    #
+    # @return [Listen::Adapter] the chosen adapter
+    #
+    def self.select_and_initialize(directories, options = {}, &callback)
+      return Adapters::Polling.new(directories, options, &callback) if options.delete(:force_polling)
+
+      warning = ''
+
+      begin
+        if Adapters::Darwin.usable_and_works?(directories, options)
+          return Adapters::Darwin.new(directories, options, &callback)
+        elsif Adapters::Linux.usable_and_works?(directories, options)
+          return Adapters::Linux.new(directories, options, &callback)
+        elsif Adapters::BSD.usable_and_works?(directories, options)
+          return Adapters::BSD.new(directories, options, &callback)
+        elsif Adapters::Windows.usable_and_works?(directories, options)
+          return Adapters::Windows.new(directories, options, &callback)
+        end
+      rescue DependencyManager::Error => e
+        warning += e.message + "\n" + MISSING_DEPENDENCY_MESSAGE
+      end
+
+      unless options[:polling_fallback_message] == false
+        warning += options[:polling_fallback_message] || POLLING_FALLBACK_MESSAGE
+        Kernel.warn "[Listen warning]:\n" + warning.gsub(/^(.*)/, '  \1')
+      end
+
+      Adapters::Polling.new(directories, options, &callback)
+    end
+
+    # Initializes the adapter.
+    #
+    # @param [String, Array<String>] directories the directories to watch
+    # @param [Hash] options the adapter options
+    # @option options [Float] latency the delay between checking for changes in seconds
+    # @option options [Boolean] report_changes whether or not to automatically report changes (run the callback)
+    #
+    # @yield [changed_dirs, options] callback Callback called when a change happens
+    # @yieldparam [Array<String>] changed_dirs the changed directories
+    # @yieldparam [Hash] options callback options (like :recursive => true)
+    #
+    # @return [Listen::Adapter] the adapter
+    #
+    def initialize(directories, options = {}, &callback)
+      @directories  = Array(directories)
+      @callback     = callback
+      @paused       = false
+      @mutex        = Mutex.new
+      @changed_dirs = Set.new
+      @turnstile    = Turnstile.new
+      @latency    ||= DEFAULT_LATENCY
+      @latency      = options[:latency] if options[:latency]
+      @report_changes = options[:report_changes].nil? ? true : options[:report_changes]
+    end
+
+    # Starts the adapter.
+    #
+    # @param [Boolean] blocking whether or not to block the current thread after starting
+    #
+    def start(blocking = true)
+      @stop = false
+    end
+
+    # Stops the adapter.
+    #
+    def stop
+      @stop = true
+      @turnstile.signal # ensure no thread is blocked
+    end
+
+    # Returns whether the adapter is statred or not
+    #
+    # @return [Boolean] whether the adapter is started or not
+    #
+    def started?
+      @stop.nil? ? false : !@stop
+    end
+
+    # Blocks the main thread until the poll thread
+    # runs the callback.
+    #
+    def wait_for_callback
+      @turnstile.wait unless @paused
+    end
+
+    # Blocks the main thread until N changes are
+    # detected.
+    #
+    def wait_for_changes(goal = 0)
+      changes = 0
+
+      loop do
+        @mutex.synchronize { changes = @changed_dirs.size }
+
+        return if @paused || @stop
+        return if changes >= goal
+
+        sleep(@latency)
+      end
+    end
+
+    # Checks if the adapter is usable on the current OS.
+    #
+    # @return [Boolean] whether usable or not
+    #
+    def self.usable?
+      load_depenencies
+      dependencies_loaded?
+    end
+
+    # Checks if the adapter is usable and works on the current OS.
+    #
+    # @param [String, Array<String>] directories the directories to watch
+    # @param [Hash] options the adapter options
+    # @option options [Float] latency the delay between checking for changes in seconds
+    #
+    # @return [Boolean] whether usable and work or not
+    #
+    def self.usable_and_works?(directories, options = {})
+      usable? && Array(directories).all? { |d| works?(d, options) }
+    end
+
+    # Runs a tests to determine if the adapter can actually pick up
+    # changes in a given directory and returns the result.
+    #
+    # @note This test takes some time depending the adapter latency.
+    #
+    # @param [String, Pathname] directory the directory to watch
+    # @param [Hash] options the adapter options
+    # @option options [Float] latency the delay between checking for changes in seconds
+    #
+    # @return [Boolean] whether the adapter works or not
+    #
+    def self.works?(directory, options = {})
+      work = false
+      test_file = "#{directory}/.listen_test"
+      callback = lambda { |*| work = true }
+      adapter  = self.new(directory, options, &callback)
+      adapter.start(false)
+
+      FileUtils.touch(test_file)
+
+      t = Thread.new { sleep(adapter.latency * 5); adapter.stop }
+
+      adapter.wait_for_callback
+      work
+    ensure
+      Thread.kill(t) if t
+      FileUtils.rm(test_file) if File.exists?(test_file)
+      adapter.stop if adapter && adapter.started?
+    end
+
+    # Runs the callback and passes it the changes if there are any.
+    #
+    def report_changes
+      changed_dirs = nil
+
+      @mutex.synchronize do
+        return if @changed_dirs.empty?
+        changed_dirs = @changed_dirs.to_a
+        @changed_dirs.clear
+      end
+
+      @callback.call(changed_dirs, {})
+      @turnstile.signal
+    end
+
+    private
+
+    # Polls changed directories and reports them back
+    # when there are changes.
+    #
+    def poll_changed_dirs
+      until @stop
+        sleep(@latency)
+        report_changes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Listen
+  module Adapters
+
+    # Listener implementation for BSD's `kqueue`.
+    #
+    class BSD < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'rb-kqueue', '~> 0.2'
+
+      # Watched kqueue events
+      #
+      # @see http://www.freebsd.org/cgi/man.cgi?query=kqueue
+      # @see https://github.com/nex3/rb-kqueue/blob/master/lib/rb-kqueue/queue.rb
+      #
+      EVENTS = [ :delete, :write, :extend, :attrib, :link, :rename, :revoke ]
+
+      # Initializes the Adapter. See {Listen::Adapter#initialize} for
+      # more info.
+      #
+      def initialize(directories, options = {}, &callback)
+        super
+        @kqueue = init_kqueue
+      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
+
+        @kqueue_thread = Thread.new do
+          until @stop
+            @kqueue.poll
+            sleep(@latency)
+          end
+        end
+        @poll_thread   = Thread.new { poll_changed_dirs } if @report_changes
+
+        @kqueue_thread.join if blocking
+      end
+
+      # Stops the adapter.
+      #
+      def stop
+        @mutex.synchronize do
+          return if @stop == true
+          super
+        end
+
+        @kqueue.stop
+        Thread.kill(@kqueue_thread) if @kqueue_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'] =~ /freebsd/i
+        super
+      end
+
+      private
+
+      # Initializes a kqueue Queue and adds a watcher for each files in
+      # the directories passed to the adapter.
+      #
+      # @return [INotify::Notifier] initialized kqueue
+      #
+      def init_kqueue
+        require 'find'
+
+        callback = lambda do |event|
+          path = event.watcher.path
+          @mutex.synchronize do
+            # kqueue watches everything, but Listen only needs the
+            # directory where stuffs happens.
+            @changed_dirs << (File.directory?(path) ? path : File.dirname(path))
+
+            # If it is a directory, and it has a write flag, it means a
+            # file has been added so find out which and deal with it.
+            # No need to check for removed file, kqueue will forget them
+            # when the vfs does..
+            if File.directory?(path) && !(event.flags & [:write]).empty?
+              queue = event.watcher.queue
+              Find.find(path) do |file|
+                unless queue.watchers.detect {|k,v| v.path == file.to_s}
+                  queue.watch_file(file, *EVENTS, &callback)
+                end
+              end
+            end
+          end
+        end
+
+        KQueue::Queue.new.tap do |queue|
+          @directories.each do |directory|
+            Find.find(directory) do |path|
+              queue.watch_file(path, *EVENTS, &callback)
+            end
+          end
+        end
+      end
+    end
+  end
+end