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

data/REVISION

@@ -1 +1 @@
-9e96a841ad39832b13e529e22ae8bdfc1e74ce13
+05235ac9be0f69c6449fef65485e0707c24d7235

data/Rakefile

@@ -115,9 +115,9 @@ task :submodules do
   if File.exist?(File.dirname(__FILE__) + "/.git")
     sh %{git submodule sync}
     sh %{git submodule update --init}
-  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/fssm/lib")
+  elsif !File.exist?(File.dirname(__FILE__) + "/vendor/listen/lib")
     warn <<WARN
-WARNING: vendor/fssm doesn't exist, and this isn't a git repository so
+WARNING: vendor/listen doesn't exist, and this isn't a git repository so
 I can't get it automatically!
 WARN
   end

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.101
+3.2.0.alpha.102

data/lib/sass/plugin/compiler.rb

@@ -5,6 +5,7 @@ require 'sass'
 require 'sass/callbacks'
 require 'sass/plugin/configuration'
 require 'sass/plugin/staleness_checker'
+require 'sass/plugin/listener'
 
 module Sass::Plugin
 
@@ -218,10 +219,10 @@ module Sass::Plugin
     #
     # Before the watching starts in earnest, `watch` calls \{#update\_stylesheets}.
     #
-    # Note that `watch` uses the [FSSM](http://github.com/ttilley/fssm) library
+    # Note that `watch` uses the [Listen](http://github.com/guard/listen) library
     # to monitor the filesystem for changes.
-    # FSSM isn't loaded until `watch` is run.
-    # The version of FSSM distributed with Sass is loaded by default,
+    # Listen isn't loaded until `watch` is run.
+    # The version of Listen distributed with Sass is loaded by default,
     # but if another version has already been loaded that will be used instead.
     #
     # @param individual_files [Array<(String, String)>]
@@ -234,15 +235,15 @@ module Sass::Plugin
       update_stylesheets(individual_files)
 
       begin
-        require 'fssm'
+        require 'listen'
       rescue LoadError => e
-        dir = Sass::Util.scope("vendor/fssm/lib")
+        dir = Sass::Util.scope("vendor/listen/lib")
         if $LOAD_PATH.include?(dir)
           e.message << "\n" <<
             if File.exists?(scope(".git"))
               'Run "git submodule update --init" to get the recommended version.'
             else
-              'Run "gem install fssm" to get it.'
+              'Run "gem install listen" to get it.'
             end
           raise e
         else
@@ -251,59 +252,51 @@ module Sass::Plugin
         end
       end
 
-      unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
-        # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
-        # but it also isn't smart enough to switch to polling itself.
-        require 'fssm/backends/polling'
-        Sass::Util.silence_warnings do
-          FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
-        end
-      end
-
       # TODO: Keep better track of what depends on what
       # so we don't have to run a global update every time anything changes.
-      FSSM.monitor do |mon|
+      Sass::Plugin::Listener.new do |l|
         template_location_array.each do |template_location, css_location|
-          mon.path template_location do |path|
-            path.glob '**/*.s[ac]ss'
-
-            path.update do |base, relative|
+          l.directory(template_location, {
+              :modified => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_modified File.join(base, relative)
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.create do |base, relative|
+            :added => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_created File.join(base, relative)
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.delete do |base, relative|
+            :removed => lambda do |base, relative|
+              next if relative !~ /\.s[ac]ss$/
               run_template_deleted File.join(base, relative)
               css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
               try_delete_css css
               update_stylesheets(individual_files)
             end
-          end
+          })
         end
 
         individual_files.each do |template, css|
-          mon.file template do |path|
-            path.update do
+          l.file(template, {
+            :modified => lambda do
               run_template_modified template
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.create do
+            :added => lambda do
               run_template_created template
               update_stylesheets(individual_files)
-            end
+            end,
 
-            path.delete do
+            :removed => lambda do
               run_template_deleted template
               try_delete_css css
               update_stylesheets(individual_files)
             end
-          end
+          })
         end
       end
     end

data/lib/sass/plugin/listener.rb

@@ -0,0 +1,59 @@
+# A wrapper around the Listen gem. Adds support for listening to individual
+# files, as well as a somewhat cleaner event dispatch API.
+#
+# @private
+class Sass::Plugin::Listener
+  def initialize
+    @directories = {}
+    yield self
+    begin
+      start!
+    rescue Exception => e
+      raise e unless e.is_a?(Interrupt)
+    end
+  end
+
+  def directory(path, events)
+    (@directories[path] ||= []) << events
+  end
+
+  def file(path, events)
+    file_base = File.basename(path)
+    directory(File.dirname(path), {
+        :modified => file_event_fn(events[:modified], file_base),
+        :added => file_event_fn(events[:added], file_base),
+        :removed => file_event_fn(events[:removed], file_base)
+      })
+  end
+
+  def start!
+    listener = Listen::MultiListener.new(*@directories.keys) do |modified, added, removed|
+      modified = modified.group_by {|path| File.dirname(path)}
+      added = added.group_by {|path| File.dirname(path)}
+      removed = removed.group_by {|path| File.dirname(path)}
+
+      @directories.each do |dir, events|
+        events.each do |e|
+          run_events(modified[dir], e[:modified], dir)
+          run_events(added[dir], e[:added], dir)
+          run_events(removed[dir], e[:removed], dir)
+        end
+      end
+    end.start
+  end
+
+  private
+
+  def file_event_fn(event, file_base)
+    lambda do |dir, base|
+      next unless event
+      next unless base == file_base
+      event.call
+    end
+  end
+
+  def run_events(paths, event, path)
+    return if paths.nil? || event.nil?
+    paths.each {|p| event[File.dirname(p), File.basename(p)]}
+  end
+end

data/lib/sass/script/lexer.rb

@@ -293,7 +293,7 @@ MESSAGE
       end
 
       def special_fun
-        return unless str1 = scan(/((-[\w-]+-)?calc|expression|progid:[a-z\.]*)\(/i)
+        return unless str1 = scan(/((-[\w-]+-)?(calc|element)|expression|progid:[a-z\.]*)\(/i)
         str2, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
         c = str2.count("\n")
         old_line = @line

data/lib/sass/script/list.rb

@@ -46,6 +46,7 @@ module Sass::Script
 
     # @see Node#to_sass
     def to_sass(opts = {})
+      return "()" if value.empty?
       precedence = Sass::Script::Parser.precedence_of(separator)
       value.map do |v|
         if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence

data/test/sass/conversion_test.rb

@@ -1515,6 +1515,16 @@ SCSS
   end
 
 
+  ## Regression Tests
+
+  def test_empty_lists
+    assert_renders(<<SASS, <<SCSS)
+$foo: ()
+SASS
+$foo: ();
+SCSS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/scss/css_test.rb

@@ -412,6 +412,15 @@ foo {
 SCSS
   end
 
+  def test_element_function
+    assert_parses <<SCSS
+foo {
+  a: -moz-element(#foo);
+  b: -webkit-element(#foo);
+  b: -foobar-element(#foo); }
+SCSS
+  end
+
   def test_unary_ops
     assert_equal <<CSS, render(<<SCSS)
 foo {

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

@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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