sass 3.1.0 → 3.3.0

data/vendor/listen/README.md

@@ -0,0 +1,315 @@
+# Listen [![Build Status](https://secure.travis-ci.org/guard/listen.png?branch=master)](http://travis-ci.org/guard/listen)
+
+The Listen gem listens to file modifications and notifies you about the changes.
+
+## Features
+
+* Works everywhere!
+* Supports watching multiple directories from a single listener.
+* OS-specific adapters for Mac OS X 10.6+, Linux, *BSD and Windows.
+* Automatic fallback to polling if OS-specific adapter doesn't work.
+* Detects file modification, addition and removal.
+* Checksum comparison for modifications made under the same second.
+* Allows supplying regexp-patterns to ignore and filter paths for better results.
+* Tested on all Ruby environments via [travis-ci](http://travis-ci.org/guard/listen).
+
+## Install
+
+``` bash
+gem install listen
+```
+
+## Usage
+
+There are **two ways** to use Listen:
+
+1. Call `Listen.to` with either a single directory or multiple directories, then define the `change` callback in a block.
+2. Create a `listener` object and use it in an (ARel style) chainable way.
+
+Feel free to give your feeback via [Listen issues](https://github.com/guard/listen/issues)
+
+### Block API
+
+``` ruby
+# Listen to a single directory.
+Listen.to('dir/path/to/listen', :filter => /\.rb$/, :ignore => %r{ignored/path/}) do |modified, added, removed|
+  # ...
+end
+
+# Listen to multiple directories.
+Listen.to('dir/to/awesome_app', 'dir/to/other_app', :filter => /\.rb$/, :latency => 0.1) do |modified, added, removed|
+  # ...
+end
+```
+
+### "Object" API
+
+``` ruby
+listener = Listen.to('dir/path/to/listen')
+listener = listener.ignore(%r{^ignored/path/})
+listener = listener.filter(/\.rb$/)
+listener = listener.latency(0.5)
+listener = listener.force_polling(true)
+listener = listener.polling_fallback_message(false)
+listener = listener.change(&callback)
+listener.start # blocks execution!
+```
+
+### Chainable
+
+``` ruby
+Listen.to('dir/path/to/listen')
+      .ignore(%r{^ignored/path/})
+      .filter(/\.rb$/)
+      .latency(0.5)
+      .force_polling(true)
+      .polling_fallback_message('custom message')
+      .change(&callback)
+      .start # blocks execution!
+```
+
+### Pause/Unpause
+
+Listener can also easily be paused/unpaused:
+
+``` ruby
+listener = Listen.to('dir/path/to/listen')
+listener.start(false) # non-blocking mode
+listener.pause   # stop listening to changes
+listener.paused? # => true
+listener.unpause
+listener.stop
+```
+
+## Listening to changes on multiple directories
+
+The Listen gem provides the `MultiListener` class to watch multiple directories and
+handle their changes from a single listener:
+
+```ruby
+listener = Listen::MultiListener.new('app/css', 'app/js')
+listener.latency(0.5)
+
+# Configure the listener to your needs...
+
+listener.start # blocks execution!
+````
+
+For an easier access, the `Listen.to` method can also be used to create a multi-listener:
+
+``` ruby
+listener = Listen.to('app/css', 'app/js')
+                 .ignore(%r{^vendor/}) # both js/vendor and css/vendor will be ignored
+                 .change(&assets_callback)
+
+listener.start # blocks execution!
+```
+
+## Changes callback
+
+Changes to the listened-to directories gets reported back to the user in a callback.
+The registered callback gets invoked, when there are changes, with **three** parameters:
+`modified_paths`, `added_paths` and `removed_paths` in that particular order.
+
+You can register a callback in two ways. The first way is by passing a block when calling
+the `Listen.to` method or when initializing a listener object:
+
+```ruby
+Listen.to('path/to/app') do |modified, added, removed|
+  # This block will be called when there are changes.
+end
+
+# or ...
+
+listener = Listen::Listener.new('path/to/app') do |modified, added, removed|
+  # This block will be called when there are changes.
+end
+
+```
+
+The second way to register a callback is be calling the `change` method on any
+listener passing it a block:
+
+```ruby
+# Create a callback
+callback = Proc.new do |modified, added, removed|
+  # This proc will be called when there are changes.
+end
+
+listener = Listen.to('dir')
+listener.change(&callback) # convert the callback to a block and register it
+
+listener.start # blocks execution
+```
+
+### Paths in callbacks
+
+Listeners invoke callbacks passing them absolute paths by default:
+
+```ruby
+# Assume someone changes the 'style.css' file in '/home/user/app/css' after creating
+# the listener.
+Listen.to('/home/user/app/css') do |modified, added, removed|
+  modified.inspect # => ['/home/user/app/css/style.css']
+end
+```
+
+#### Relative paths in callbacks
+
+When creating a listener for a **single** path (more specifically a `Listen::Listener` instance),
+you can pass `:relative_paths => true` as an option to get relative paths in
+your callback:
+
+```ruby
+# Assume someone changes the 'style.css' file in '/home/user/app/css' after creating
+# the listener.
+Listen.to('/home/user/app/css', :relative_paths => true) do |modified, added, removed|
+  modified.inspect # => ['style.css']
+end
+```
+
+Passing the `:relative_paths => true` option won't work when listeneing to multiple
+directories:
+
+```ruby
+# Assume someone changes the 'style.css' file in '/home/user/app/css' after creating
+# the listener.
+Listen.to('/home/user/app/css', '/home/user/app/js', :relative_paths => true) do |modified, added, removed|
+  modified.inspect # => ['/home/user/app/css/style.css']
+end
+```
+
+## Options
+
+These options can be set through `Listen.to` params or via methods (see the "Object" API)
+
+```ruby
+:filter => /\.rb$/, /\.coffee$/                # Filter files to listen to via a regexps list.
+                                               # default: none
+
+:ignore => %r{app/CMake/}, /\.pid$/            # Ignore a list of paths (root directory or sub-dir)
+                                               # default: See DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in Listen::DirectoryRecord
+
+:latency => 0.5                                # Set the delay (**in seconds**) between checking for changes
+                                               # default: 0.25 sec (1.0 sec for polling)
+
+:relative_paths => true                        # Enable the use of relative paths in the callback.
+                                               # default: false
+
+:force_polling => true                         # Force the use of the polling adapter
+                                               # default: none
+
+:polling_fallback_message => 'custom message'  # Set a custom polling fallback message (or disable it with `false`)
+                                               # default: "WARNING: Listen fallen back to polling, learn more at https://github.com/guard/listen#fallback."
+```
+
+### The patterns for filtering and ignoring paths
+
+Just like the unix convention of beginning absolute paths with the
+directory-separator (forward slash `/` in unix) and with no prefix for relative paths,
+Listen doesn't prefix relative paths (to the watched directory) with a directory-separator.
+
+Therefore make sure _NOT_ to prefix your regexp-patterns for filtering or ignoring paths
+with a directory-separator, otherwise they won't work as expected.
+
+As an example: to ignore the `build` directory in a C-project, use `%r{build/}`
+and not `%r{/build/}`.
+
+Use `#filter!` and `#ignore!` methods to overwrites default patterns.
+
+### Non-blocking listening to changes
+
+Starting a listener blocks the current thread by default. That means any code after the
+`start` call won't be run until the listener is stopped (which needs to be done from another thread).
+
+For advanced usage there is an option to disable this behavior and have the listener start working
+in the background without blocking. To enable non-blocking listening the `start` method of
+the listener (be it `Listener` or `MultiListener`) needs to be called with `false` as a parameter.
+
+Here is an example of using a listener in the non-blocking mode:
+
+```ruby
+listener = Listen.to('dir/path/to/listen')
+listener.start(false) # doesn't block execution
+
+# Code here will run immediately after starting the listener
+
+```
+
+**note**: Using the `Listen.to` helper-method with a callback-block will always
+block execution. See the "Block API" section for an example.
+
+## Listen adapters
+
+The Listen gem has a set of adapters to notify it when there are changes.
+There are 3 OS-specific adapters to support Mac, Linux, *BSD and Windows. These adapters are fast
+as they use some system-calls to implement the notifying function.
+
+There is also a polling adapter which is a cross-platform adapter and it will
+work on any system. This adapter is unfortunately slower than the rest of the adapters.
+
+The Listen gem will choose the best and working adapter for your machine automatically. If you
+want to force the use of the polling adapter, either use the `:force_polling` option
+while initializing the listener or call the `force_polling` method on your listener
+before starting it.
+
+## Polling fallback
+
+When a OS-specific adapter doesn't work the Listen gem automatically falls back to the polling adapter.
+Here are some things you could try to avoid the polling fallback:
+
+* [Update your Dropbox client](http://www.dropbox.com/downloading) (if used).
+* Increase latency. (Please [open an issue](https://github.com/guard/listen/issues/new) if you think that default is too low.)
+* Move or rename the listened folder.
+* Update/reboot your OS.
+
+If your application keeps using the polling-adapter and you can't figure out why, feel free to [open an issue](https://github.com/guard/listen/issues/new) (and be sure to give all the details).
+
+## Development [![Dependency Status](https://gemnasium.com/guard/listen.png?branch=master)](https://gemnasium.com/guard/listen)
+
+* Documentation hosted at [RubyDoc](http://rubydoc.info/github/guard/listen/master/frames).
+* Source hosted at [GitHub](https://github.com/guard/listen).
+
+Pull requests are very welcome! Please try to follow these simple rules if applicable:
+
+* Please create a topic branch for every separate change you make.
+* Make sure your patches are well tested. All specs run with `rake spec:portability` must pass.
+* Update the [Yard](http://yardoc.org/) documentation.
+* Update the README.
+* Update the CHANGELOG for noteworthy changes.
+* Please **do not change** the version number.
+
+For questions please join us in our [Google group](http://groups.google.com/group/guard-dev) or on
+`#guard` (irc.freenode.net).
+
+## Acknowledgment
+
+* [Michael Kessler (netzpirat)][] for having written the [initial specs](https://github.com/guard/listen/commit/1e457b13b1bb8a25d2240428ce5ed488bafbed1f).
+* [Travis Tilley (ttilley)][] for this awesome work on [fssm][] & [rb-fsevent][].
+* [Nathan Weizenbaum (nex3)][] for [rb-inotify][], a thorough inotify wrapper.
+* [Mathieu Arnold (mat813)][] for [rb-kqueue][], a simple kqueue wrapper.
+* [stereobooster][] for [rb-fchange][], windows support wouldn't exist without him.
+* [Yehuda Katz (wycats)][] for [vigilo][], that has been a great source of inspiration.
+
+## Authors
+
+* [Thibaud Guillaume-Gentil][] ([@thibaudgg](http://twitter.com/thibaudgg))
+* [Maher Sallam][] ([@mahersalam](http://twitter.com/mahersalam))
+
+## Contributors
+
+[https://github.com/guard/listen/contributors](https://github.com/guard/listen/contributors)
+
+[Thibaud Guillaume-Gentil]: https://github.com/thibaudgg
+[Maher Sallam]: https://github.com/Maher4Ever
+[Michael Kessler (netzpirat)]: https://github.com/netzpirat
+[Travis Tilley (ttilley)]: https://github.com/ttilley
+[fssm]: https://github.com/ttilley/fssm
+[rb-fsevent]: https://github.com/thibaudgg/rb-fsevent
+[Mathieu Arnold (mat813)]: https://github.com/mat813
+[Nathan Weizenbaum (nex3)]: https://github.com/nex3
+[rb-inotify]: https://github.com/nex3/rb-inotify
+[stereobooster]: https://github.com/stereobooster
+[rb-fchange]: https://github.com/stereobooster/rb-fchange
+[Yehuda Katz (wycats)]: https://github.com/wycats
+[vigilo]: https://github.com/wycats/vigilo

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/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