sass 3.1.16 → 3.1.17

data/test/sass/script_test.rb

@@ -21,13 +21,13 @@ class SassScriptTest < Test::Unit::TestCase
   include Sass::Script
 
   def test_color_checks_input
-    assert_raise_message(ArgumentError, "Blue value must be between 0 and 255") {Color.new([1, 2, -1])}
-    assert_raise_message(ArgumentError, "Red value must be between 0 and 255") {Color.new([256, 2, 3])}
+    assert_raise_message(ArgumentError, "Blue value -1 must be between 0 and 255") {Color.new([1, 2, -1])}
+    assert_raise_message(ArgumentError, "Red value 256 must be between 0 and 255") {Color.new([256, 2, 3])}
   end
 
   def test_color_checks_rgba_input
-    assert_raise_message(ArgumentError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
-    assert_raise_message(ArgumentError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
+    assert_raise_message(ArgumentError, "Alpha channel 1.1 must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
+    assert_raise_message(ArgumentError, "Alpha channel -0.1 must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
   end
 
   def test_string_escapes

data/test/sass/scss/scss_test.rb

@@ -830,6 +830,16 @@ $zzz: zzz;
 SCSS
   end
 
+  def test_selector_interpolation_at_attr_end
+    assert_equal <<CSS, render(<<SCSS)
+[foo=zzz] {
+  a: b; }
+CSS
+$zzz: zzz;
+[foo=\#{$zzz}] { a: b; }
+SCSS
+  end
+
   def test_selector_interpolation_at_dashes
     assert_equal <<CSS, render(<<SCSS)
 div {

data/vendor/listen/CHANGELOG.md

@@ -1,8 +1,23 @@
+## 0.4.2 - May 1, 2012
+
+### Bug fixes
+
+- [#21](https://github.com/guard/listen/issues/21): Issues when listening to changes in relative paths. (reported by [@akerbos][], fixed by [@Maher4Ever][])
+- [#27](https://github.com/guard/listen/issues/27): Wrong reports for files modifications. (reported by [@cobychapple][], fixed by [@Maher4Ever][])
+- Fix segmentation fault when profiling on Windows. ([@Maher4Ever][])
+- Fix redundant watchers on Windows. ([@Maher4Ever][])
+
+### Improvements
+
+- [#17](https://github.com/guard/listen/issues/17): Use regexp-patterns with the `ignore` method instead of supplying paths. (reported by [@fny][], added by [@Maher4Ever][])
+- Speed improvement when listening to changes in directories with ignored paths. ([@Maher4Ever][])
+- Added `.rbx` and `.svn` to ignored directories. ([@Maher4Ever][])
+
 ## 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][])
+- [#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
 
@@ -70,3 +85,6 @@
 [@thibaudgg]: https://github.com/thibaudgg
 [@Maher4Ever]: https://github.com/Maher4Ever
 [@daemonza]: https://github.com/daemonza
+[@akerbos]: https://github.com/akerbos
+[@fny]: https://github.com/fny
+[@cobychapple]: https://github.com/cobychapple

data/vendor/listen/README.md

@@ -10,7 +10,7 @@ The Listen gem listens to file modifications and notifies you about the changes.
 * 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.
+* 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
@@ -26,18 +26,18 @@ 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)
+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: '/ignored/path') do |modified, added, removed|
+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|
+Listen.to('dir/to/awesome_app', 'dir/to/other_app', filter: /\.rb$/, latency: 0.1) do |modified, added, removed|
   # ...
 end
 ```
@@ -46,8 +46,8 @@ end
 
 ``` ruby
 listener = Listen.to('dir/path/to/listen')
-listener = listener.ignore('/ignored/path')
-listener = listener.filter(/.*\.rb/)
+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)
@@ -59,8 +59,8 @@ listener.start # blocks execution!
 
 ``` ruby
 Listen.to('dir/path/to/listen')
-      .ignore('/ignored/path')
-      .filter(/.*\.rb/)
+      .ignore(%r{^ignored/path/})
+      .filter(/\.rb$/)
       .latency(0.5)
       .force_polling(true)
       .polling_fallback_message('custom message')
@@ -99,7 +99,7 @@ For an easier access, the `Listen.to` method can also be used to create a multi-
 
 ``` ruby
 listener = Listen.to('app/css', 'app/js')
-                 .ignore('vendor') # both js/vendor and css/vendor will be ignored
+                 .ignore(%r{^vendor/}) # both js/vendor and css/vendor will be ignored
                  .change(&assets_callback)
 
 listener.start # blocks execution!
@@ -184,11 +184,11 @@ end
 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.
+: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'
+: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.1 sec (1.0 sec for polling)
@@ -200,6 +200,18 @@ These options can be set through `Listen.to` params or via methods (see the "Obj
                                                # 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/}`.
+
 ### Non-blocking listening to changes
 
 Starting a listener blocks the current thread by default. That means any code after the

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

@@ -63,17 +63,16 @@ module Listen
       # @return [FChange::Notifier] initialized worker
       #
       def init_worker
-        worker = FChange::Notifier.new
-        @directories.each do |directory|
-          watcher = worker.watch(directory, :all_events, :recursive) do |event|
-            next if @paused
-            @mutex.synchronize do
-              @changed_dirs << File.expand_path(event.watcher.path)
+        FChange::Notifier.new.tap do |worker|
+          @directories.each do |directory|
+            worker.watch(directory, :all_events, :recursive) do |event|
+              next if @paused
+              @mutex.synchronize do
+                @changed_dirs << File.expand_path(event.watcher.path)
+              end
             end
           end
-          worker.add_watcher(watcher)
         end
-        worker
       end
 
     end

data/vendor/listen/lib/listen/directory_record.rb

@@ -1,6 +1,5 @@
 require 'set'
 require 'find'
-require 'pathname'
 require 'digest/sha1'
 
 module Listen
@@ -12,61 +11,85 @@ module Listen
   class DirectoryRecord
     attr_reader :directory, :paths, :sha1_checksums
 
-    # Default paths' beginnings that doesn't get stored in the record
-    DEFAULT_IGNORED_PATHS = %w[.bundle .git .DS_Store log tmp vendor]
+    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn log tmp vendor]
+
+    DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store]
+
+    # Class methods
+    #
+    class << self
+
+      # Creates the ignoring patterns from the default ignored
+      # directories and extensions. It memoizes the generated patterns
+      # to avoid unnecessary computation.
+      #
+      def generate_default_ignoring_patterns
+        @@default_ignoring_patterns ||= Array.new.tap do |default_patterns|
+          # Add directories
+          ignored_directories = DEFAULT_IGNORED_DIRECTORIES.map { |d| Regexp.escape(d) }
+          default_patterns << %r{^(?:#{ignored_directories.join('|')})/}
+
+          # Add extensions
+          ignored_extensions = DEFAULT_IGNORED_EXTENSIONS.map { |e| Regexp.escape(e) }
+          default_patterns << %r{(?:#{ignored_extensions.join('|')})$}
+        end
+      end
+    end
 
     # Initializes a directory record.
     #
     # @option [String] directory the directory to keep track of
     #
     def initialize(directory)
-      @directory = directory
-      raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(@directory)
+      raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(directory)
 
-      @ignored_paths  = Set.new(DEFAULT_IGNORED_PATHS)
-      @filters        = Set.new
-      @sha1_checksums = Hash.new
+      @directory          = directory
+      @ignoring_patterns  = Set.new
+      @filtering_patterns = Set.new
+      @sha1_checksums     = Hash.new
+
+      @ignoring_patterns.merge(DirectoryRecord.generate_default_ignoring_patterns)
     end
 
-    # Returns the ignored paths in the record
+    # Returns the ignoring patterns in the record
     #
-    # @return [Array<String>] the ignored paths
+    # @return [Array<Regexp>] the ignoring patterns
     #
-    def ignored_paths
-      @ignored_paths.to_a
+    def ignoring_patterns
+      @ignoring_patterns.to_a
     end
 
-    # Returns the filters used in the record to know
+    # Returns the filtering patterns used in the record to know
     # which paths should be stored.
     #
-    # @return [Array<String>] the used filters
+    # @return [Array<Regexp>] the filtering patterns
     #
-    def filters
-      @filters.to_a
+    def filtering_patterns
+      @filtering_patterns.to_a
     end
 
-    # Adds ignored path to the record.
+    # Adds ignoring patterns to the record.
     #
     # @example Ignore some paths
     #   ignore ".git", ".svn"
     #
-    # @param [String, Array<String>] paths a path or a list of paths to ignore
+    # @param [Regexp] regexp a pattern for ignoring paths
     #
-    def ignore(*paths)
-      @ignored_paths.merge(paths)
+    def ignore(*regexps)
+      @ignoring_patterns.merge(regexps)
     end
 
-    # Adds file filters to the listener.
+    # Adds filtering patterns to the listener.
     #
     # @example Filter some files
     #   ignore /\.txt$/, /.*\.zip/
     #
-    # @param [Array<Regexp>] regexps a list of regexps file filters
+    # @param [Regexp] regexp a pattern for filtering paths
     #
     # @return [Listen::Listener] the listener itself
     #
     def filter(*regexps)
-      @filters.merge(regexps)
+      @filtering_patterns.merge(regexps)
     end
 
     # Returns whether a path should be ignored or not.
@@ -76,7 +99,8 @@ module Listen
     # @return [Boolean]
     #
     def ignored?(path)
-      @ignored_paths.any? { |ignored_path| path =~ /#{ignored_path}$/ }
+      path = relative_to_base(path)
+      @ignoring_patterns.any? { |pattern| pattern =~ path }
     end
 
     # Returns whether a path should be filtered or not.
@@ -86,7 +110,11 @@ module Listen
     # @return [Boolean]
     #
     def filtered?(path)
-      @filters.empty? || @filters.any? { |filter| path =~ filter }
+      # When no filtering patterns are set, ALL files are stored.
+      return true if @filtering_patterns.empty?
+
+      path = relative_to_base(path)
+      @filtering_patterns.any? { |pattern| pattern =~ path }
     end
 
     # Finds the paths that should be stored and adds them
@@ -111,15 +139,27 @@ module Listen
     def fetch_changes(directories, options = {})
       @changes    = { :modified => [], :added => [], :removed => [] }
       directories = directories.sort_by { |el| el.length }.reverse # diff sub-dir first
+      update_time = Time.now.to_i
       directories.each do |directory|
         next unless directory[@directory] # Path is or inside directory
         detect_modifications_and_removals(directory, options)
         detect_additions(directory, options)
       end
-      @updated_at = Time.now.to_i
+      @updated_at = update_time
       @changes
     end
 
+    # Converts an absolute path to a path that's relative to the base directory.
+    #
+    # @param [String] path the path to convert
+    #
+    # @return [String] the relative path
+    #
+    def relative_to_base(path)
+      return nil unless path[@directory]
+      path.sub(%r{^#{@directory}#{File::SEPARATOR}?}, '')
+    end
+
     private
 
     # Detects modifications and removals recursively in a directory.
@@ -176,7 +216,9 @@ module Listen
         next if path == @directory
 
         if File.directory?(path)
-          if ignored?(path) || (directory != path && (!options[:recursive] && existing_path?(path)))
+          # Add a trailing slash to directories when checking if a directory is
+          # ignored to optimize finding them as Find.find doesn't.
+          if ignored?(path + File::SEPARATOR) || (directory != path && (!options[:recursive] && existing_path?(path)))
             Find.prune # Don't look any further into this directory.
           else
             insert_path(path)
@@ -215,7 +257,9 @@ module Listen
         next if path == @directory
 
         if File.directory?(path)
-          if ignored?(path)
+          # Add a trailing slash to directories when checking if a directory is
+          # ignored to optimize finding them as Find.find doesn't.
+          if ignored?(path + File::SEPARATOR)
             Find.prune # Don't look any further into this directory.
           else
             yield(path)
@@ -243,15 +287,5 @@ module Listen
     def existing_path?(path)
       @paths[File.dirname(path)][File.basename(path)] != nil
     end
-
-    # Converts an absolute path to a path that's relative to the base directory.
-    #
-    # @param [String] path the path to convert
-    #
-    # @return [String] the relative path
-    #
-    def relative_to_base(path)
-      path.sub(%r(^#{@directory}/?/), '')
-    end
   end
 end

data/vendor/listen/lib/listen/listener.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module Listen
   class Listener
     attr_reader :directory, :directory_record, :adapter
@@ -9,8 +11,8 @@ module Listen
     #
     # @param [String] directory the directory to listen to
     # @param [Hash] options the listen options
-    # @option options [String] ignore a list of paths to ignore
-    # @option options [Regexp] filter a list of regexps file filters
+    # @option options [Regexp] ignore a pattern for ignoring paths
+    # @option options [Regexp] filter a pattern for filtering paths
     # @option options [Float] latency the delay between checking for changes in seconds
     # @option options [Boolean] relative_paths whether or not to use relative-paths in the callback
     # @option options [Boolean] force_polling whether to force the polling adapter or not
@@ -23,8 +25,8 @@ module Listen
     #
     def initialize(directory, options = {}, &block)
       @block              = block
-      @directory          = directory
-      @directory_record   = DirectoryRecord.new(directory)
+      @directory          = Pathname.new(directory).realpath.to_s
+      @directory_record   = DirectoryRecord.new(@directory)
       @use_relative_paths = DEFAULT_TO_RELATIVE_PATHS
 
       @use_relative_paths = options.delete(:relative_paths) if options[:relative_paths]
@@ -41,8 +43,8 @@ module Listen
     # @param [Boolean] blocking whether or not to block the current thread after starting
     #
     def start(blocking = true)
-      t = Thread.new { @adapter = initialize_adapter }
-      @directory_record.build
+      t = Thread.new { @directory_record.build }
+      @adapter = initialize_adapter
       t.join
       @adapter.start(blocking)
     end
@@ -80,18 +82,18 @@ module Listen
       !!@adapter && @adapter.paused == true
     end
 
-    # Adds ignored paths to the listener.
+    # Adds ignoring patterns to the listener.
     #
     # @param (see Listen::DirectoryRecord#ignore)
     #
     # @return [Listen::Listener] the listener
     #
-    def ignore(*paths)
-      @directory_record.ignore(*paths)
+    def ignore(*regexps)
+      @directory_record.ignore(*regexps)
       self
     end
 
-    # Adds file filters to the listener.
+    # Adds filtering patterns to the listener.
     #
     # @param (see Listen::DirectoryRecord#filter)
     #

data/vendor/listen/lib/listen/multi_listener.rb

@@ -6,8 +6,8 @@ module Listen
     #
     # @param [String] directories the directories to listen to
     # @param [Hash] options the listen options
-    # @option options [String] ignore a list of paths to ignore
-    # @option options [Regexp] filter a list of regexps file filters
+    # @option options [Regexp] ignore a pattern for ignoring paths
+    # @option options [Regexp] filter a pattern for filtering paths
     # @option options [Float] latency the delay between checking for changes in seconds
     # @option options [Boolean] force_polling whether to force the polling adapter or not
     # @option options [String, Boolean] polling_fallback_message to change polling fallback message or remove it
@@ -22,8 +22,8 @@ module Listen
       directories = args
 
       @block               = block
-      @directories         = directories
-      @directories_records = directories.map { |d| DirectoryRecord.new(d) }
+      @directories         = directories.map  { |d| Pathname.new(d).realpath.to_s }
+      @directories_records = @directories.map { |d| DirectoryRecord.new(d) }
 
       ignore(*options.delete(:ignore)) if options[:ignore]
       filter(*options.delete(:filter)) if options[:filter]
@@ -38,8 +38,8 @@ module Listen
     # @param [Boolean] blocking whether or not to block the current thread after starting
     #
     def start(blocking = true)
-      t = Thread.new { @adapter = initialize_adapter }
-      @directories_records.each { |r| r.build }
+      t = Thread.new { @directories_records.each { |r| r.build } }
+      @adapter = initialize_adapter
       t.join
       @adapter.start(blocking)
     end