sass 3.1.15 → 3.1.16

data/vendor/listen/CHANGELOG.md

@@ -0,0 +1,72 @@
+## 0.4.1 - April 15, 2012
+
+### Bug fixes
+
+- [#18](https://github.com/guard/listen/issues/18): Listener crashes when removing directories with nested paths (reported by [@daemonza][], fixed by [@Maher4Ever][])
+
+## 0.4.0 - April 9, 2012
+
+### New features
+
+- Add `wait_for_callback` method to all adapters. ([@Maher4Ever][])
+- Add `Listen::MultiListener` class to listen to multiple directories at once. ([@Maher4Ever][])
+- Allow passing multiple directories to the `Listen.to` method. ([@Maher4Ever][])
+- Add `blocking` option to `Listen#start` which can be used to disable blocking the current thread upon starting. ([@Maher4Ever][])
+- Use absolute-paths in callbacks by default instead of relative-paths. ([@Maher4Ever][])
+- Add `relative_paths` option to `Listen::Listener` to retain the old functionality. ([@Maher4Ever][])
+
+### Improvements
+
+- Encapsulate thread spawning in the linux-adapter. ([@Maher4Ever][])
+- Encapsulate thread spawning in the darwin-adapter. ([@Maher4Ever][] with [@scottdavis][] help)
+- Encapsulate thread spawning in the windows-adapter. ([@Maher4Ever][])
+- Fix linux-adapter bug where Listen would report file-modification events on the parent-directory. ([@Maher4Ever][])
+
+### Removals
+
+- Remove `wait_until_listening` as adapters doesn't need to run inside threads anymore ([@Maher4Ever][])
+
+## 0.3.3 - March 6, 2012
+
+### Improvements
+
+- Improve pause/unpause. ([@thibaudgg][])
+
+## 0.3.2 - March 4, 2012
+
+### New features
+
+- Add pause/unpause listener's methods. ([@thibaudgg][])
+
+## 0.3.1 - February 22, 2012
+
+### Bug fix
+
+- [#9](https://github.com/guard/listen/issues/9): Ignore doesn't seem to work. (reported by [@markiz][], fixed by [@thibaudgg][])
+
+## 0.3.0 - February 21, 2012
+
+### New features
+
+- Add automatic fallback to polling if system adapter doesn't work (like a DropBox folder). ([@thibaudgg][])
+- Add latency and force_polling options. ([@Maher4Ever][])
+
+## 0.2.0 - February 13, 2012
+
+### New features
+
+- Add checksum comparaison support for detecting consecutive file modifications made during the same second. ([@thibaudgg][])
+- Add rb-fchange support. ([@thibaudgg][])
+- Add rb-inotify support. ([@thibaudgg][] with [@Maher4Ever][] help)
+- Add rb-fsevent support. ([@thibaudgg][])
+- Add non-recursive diff with multiple directories support. ([@thibaudgg][])
+- Ignore .DS_Store by default. ([@thibaudgg][])
+
+## 0.1.0 - January 28, 2012
+
+- First version with only a polling adapter and basic features set (ignore & filter). ([@thibaudgg][])
+
+[@markiz]: https://github.com/markiz
+[@thibaudgg]: https://github.com/thibaudgg
+[@Maher4Ever]: https://github.com/Maher4Ever
+[@daemonza]: https://github.com/daemonza

data/vendor/listen/Gemfile

@@ -0,0 +1,35 @@
+source :rubygems
+
+gemspec
+
+gem 'rake'
+
+group :development do
+  platform :ruby do
+    gem 'rb-readline'
+  end
+
+  require 'rbconfig'
+  case RbConfig::CONFIG['target_os']
+  when /darwin/i
+    # gem 'ruby_gntp',  '~> 0.3.4', :require => false
+    gem 'growl', :require => false
+  when /linux/i
+    gem 'libnotify',  '~> 0.7.1', :require => false
+  when /mswin|mingw/i
+    gem 'win32console', :require => false
+    gem 'rb-notifu', '>= 0.0.4', :require => false
+  end
+
+  gem 'guard',       '~> 1.0.0'
+  gem 'guard-rspec', '~> 0.7.0'
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'pry'
+
+  gem 'vagrant'
+end
+
+group :test do
+  gem 'rspec', '~> 2.9.0'
+end

data/vendor/listen/Guardfile

@@ -0,0 +1,8 @@
+guard :rspec, :all_on_start => false, :all_after_pass => false, :cli => '--fail-fast --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})                { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/support/adapter_helper.rb')  { "spec/listen/adapters" }
+  watch('spec/support/listener_helper.rb') { "spec/listen/listener_spec.rb" }
+  watch('spec/support/fixtures_helper.rb') { "spec" }
+  watch('spec/spec_helper.rb')             { "spec" }
+end

data/vendor/{fssm → listen}/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Travis Tilley
+Copyright (c) 2012 Thibaud Guillaume-Gentil
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/vendor/listen/README.md

@@ -0,0 +1,297 @@
+# 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 and Windows.
+* Automatic fallback to polling if OS-specific adapter doesn't work.
+* Detects files modification, addidation and removal.
+* Checksum comparaison for modifications made under the same second.
+* Allows ignoring paths and supplying filters 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/listener/issues)
+
+### Block API
+
+``` ruby
+# Listen to a single directory.
+Listen.to('dir/path/to/listen', filter: /.*\.rb/, ignore: '/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('/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('/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('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 => 'path1', 'path2'                    # Ignore a list of paths (root directory or sub-dir)
+                                               # default: '.bundle', '.git', '.DS_Store', 'log', 'tmp', 'vendor'
+
+:latency => 0.5                                # Set the delay (**in seconds**) between checking for changes
+                                               # default: 0.1 sec (1.0 sec for polling)
+
+: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."
+```
+
+### 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 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.
+
+<a name="fallback"/>
+## 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.
+* [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
+[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