haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/vendor/fssm/spec/count_down_latch.rb

@@ -1,151 +0,0 @@
-#!/usr/bin/env ruby
-# coding: utf-8
-
-require 'thread'
-
-class CountDownLatch
-  attr_reader :count
-
-  def initialize(to)
-    @count = to.to_i
-    raise ArgumentError, "cannot count down from negative integer" unless @count >= 0
-    @lock      = Mutex.new
-    @condition = ConditionVariable.new
-  end
-
-  def count_down
-    @lock.synchronize do
-      @count -= 1 if @count > 0
-      @condition.broadcast if @count == 0
-    end
-  end
-
-  def wait
-    @lock.synchronize do
-      @condition.wait(@lock) while @count > 0
-    end
-  end
-end
-
-if $0 == __FILE__
-  require 'test/unit'
-
-  class CountDownLatchTest < Test::Unit::TestCase
-    def test_requires_positive_count
-      assert_raise(ArgumentError) { CountDownLatch.new(-1) }
-    end
-
-    def test_basic_latch_usage
-      latch = CountDownLatch.new(1)
-      name  = "foo"
-      Thread.new do
-        name = "bar"
-        latch.count_down
-      end
-      latch.wait
-      assert_equal(0, latch.count)
-      assert_equal("bar", name)
-    end
-
-    def test_basic_latch_usage_inverted
-      latch = CountDownLatch.new(1)
-      name  = "foo"
-      Thread.new do
-        latch.wait
-        assert_equal(0, latch.count)
-        assert_equal("bar", name)
-      end
-      name = "bar"
-      latch.count_down
-    end
-
-    def test_count_down_from_zero_skips_wait
-      latch = CountDownLatch.new(0)
-      latch.wait
-      assert_equal(0, latch.count)
-    end
-
-    def test_count_down_twice_with_thread
-      latch = CountDownLatch.new(2)
-      name  = "foo"
-      Thread.new do
-        latch.count_down
-        name = "bar"
-        latch.count_down
-      end
-      latch.wait
-      assert_equal(0, latch.count)
-      assert_equal("bar", name)
-    end
-
-    def test_count_down_twice_with_two_parallel_threads
-      latch = CountDownLatch.new(2)
-      name  = "foo"
-      Thread.new { latch.count_down }
-      Thread.new do
-        name = "bar"
-        latch.count_down
-      end
-      latch.wait
-      assert_equal(0, latch.count)
-      assert_equal("bar", name)
-    end
-
-    def test_count_down_twice_with_two_chained_threads
-      latch = CountDownLatch.new(2)
-      name  = "foo"
-      Thread.new do
-        latch.count_down
-        Thread.new do
-          name = "bar"
-          latch.count_down
-        end
-      end
-      latch.wait
-      assert_equal(0, latch.count)
-      assert_equal("bar", name)
-    end
-
-    def test_count_down_with_multiple_waiters
-      proceed_latch = CountDownLatch.new(2)
-      check_latch   = CountDownLatch.new(2)
-      results       = {}
-      Thread.new do
-        proceed_latch.wait
-        results[:first] = 1
-        check_latch.count_down
-      end
-      Thread.new do
-        proceed_latch.wait
-        results[:second] = 2
-        check_latch.count_down
-      end
-      assert_equal({}, results)
-      proceed_latch.count_down
-      proceed_latch.count_down
-      check_latch.wait
-      assert_equal(0, proceed_latch.count)
-      assert_equal(0, check_latch.count)
-      assert_equal({:first => 1, :second => 2}, results)
-    end
-
-    def test_interleaved_latches
-      change_1_latch = CountDownLatch.new(1)
-      check_latch    = CountDownLatch.new(1)
-      change_2_latch = CountDownLatch.new(1)
-      name           = "foo"
-      Thread.new do
-        name = "bar"
-        change_1_latch.count_down
-        check_latch.wait
-        name = "man"
-        change_2_latch.count_down
-      end
-      change_1_latch.wait
-      assert_equal("bar", name)
-      check_latch.count_down
-      change_2_latch.wait
-      assert_equal("man", name)
-    end
-  end
-end

data/vendor/sass/vendor/fssm/spec/monitor_spec.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-
-require 'count_down_latch'
-require 'fileutils'
-require 'tempfile'
-
-module FSSM::MonitorSpecHelpers
-  def create_tmp_dir
-    @tmp_dir = FSSM::Pathname.for(Dir.mktmpdir).realpath.to_s
-    FileUtils.cp_r File.join(File.dirname(__FILE__), 'root'), @tmp_dir
-    # Because git does not track empty directories, create one ourselves.
-    FileUtils.mkdir_p @tmp_dir + '/root/yawn'
-    @tmp_dir
-  end
-
-  def remove_tmp_dir
-    FileUtils.remove_entry @tmp_dir
-  end
-
-  def create_handler(type, latch)
-    lambda do |*args|
-      @handler_results[type] << args
-      latch.count_down
-    end
-  end
-
-  def run_monitor(num_events_to_expect=0, options={})
-    event_latch      = CountDownLatch.new(num_events_to_expect)
-    @handler_results = Hash.new { |hash, key| hash[key] = [] }
-    thread           = Thread.new do
-      monitor = FSSM::Monitor.new(options)
-      monitor.path(@tmp_dir) do |p|
-        p.create(&create_handler(:create, event_latch))
-        p.update(&create_handler(:update, event_latch))
-        p.delete(&create_handler(:delete, event_latch))
-      end
-      monitor.run
-    end
-    sleep 1 # give time for monitor to start up
-    yield if block_given?
-    event_latch.wait
-    thread.kill
-  end
-end
-
-describe "The File System State Monitor" do
-  describe "monitor" do
-    include FSSM::MonitorSpecHelpers
-
-    before do
-      create_tmp_dir
-    end
-
-    after do
-      remove_tmp_dir
-    end
-
-    describe "with default options" do
-      it "should call create callback upon file creation" do
-        run_monitor(1) do
-          file = @tmp_dir + "/newfile.rb"
-          File.exists?(file).should be_false
-          FileUtils.touch file
-        end
-        @handler_results[:create].should == [[@tmp_dir, 'newfile.rb']]
-      end
-
-      it "should call update callback upon file modification" do
-        run_monitor(1) do
-          FileUtils.touch @tmp_dir + '/root/file.rb'
-        end
-        @handler_results[:update].should == [[@tmp_dir, 'root/file.rb']]
-      end
-
-      it "should call delete callback upon file deletion" do
-        run_monitor(1) do
-          FileUtils.rm @tmp_dir + "/root/file.rb"
-        end
-        @handler_results[:delete].should == [[@tmp_dir, 'root/file.rb']]
-      end
-
-      it "should call create and delete callbacks upon file renaming in the same directory" do
-        run_monitor(2) do
-          FileUtils.mv @tmp_dir + "/root/file.rb", @tmp_dir + "/root/old_file.rb"
-        end
-        @handler_results[:create].should == [[@tmp_dir, 'root/old_file.rb']]
-        @handler_results[:delete].should == [[@tmp_dir, 'root/file.rb']]
-        @handler_results[:update].should == []
-      end
-
-      it "should call create and delete callbacks upon file moving to another directory" do
-        run_monitor(2) do
-          FileUtils.mv @tmp_dir + "/root/file.rb", @tmp_dir + "/old_file.rb"
-        end
-        @handler_results[:create].should == [[@tmp_dir, 'old_file.rb']]
-        @handler_results[:delete].should == [[@tmp_dir, 'root/file.rb']]
-        @handler_results[:update].should == []
-      end
-
-      it "should not call callbacks upon directory operations" do
-        run_monitor do
-          FileUtils.mkdir @tmp_dir + "/another_yawn"
-          FileUtils.rmdir @tmp_dir + "/root/yawn"
-        end
-        @handler_results[:create].should == []
-        @handler_results[:delete].should == []
-      end
-    end
-
-    describe "when configured to consider files and directories" do
-      it "should call create callback upon directory creation" do
-        run_monitor(1, :directories => true) do
-          FileUtils.mkdir @tmp_dir + "/another_yawn"
-        end
-        @handler_results[:create].should include([@tmp_dir, 'another_yawn', :directory])
-      end
-
-      it "should call delete callback upon directory deletion" do
-        run_monitor(1, :directories => true) do
-          FileUtils.rmdir @tmp_dir + "/root/yawn"
-        end
-        @handler_results[:delete].should include([@tmp_dir, 'root/yawn', :directory])
-      end
-
-      it "should call create, update, and delete callbacks upon directory renaming in the same directory" do
-        run_monitor(3, :directories => true) do
-          FileUtils.mv @tmp_dir + "/root/yawn", @tmp_dir + "/root/old_yawn"
-        end
-        @handler_results[:create].should include([@tmp_dir, 'root/old_yawn', :directory])
-        @handler_results[:delete].should include([@tmp_dir, 'root/yawn', :directory])
-        @handler_results[:update].should include([@tmp_dir, 'root', :directory])
-      end
-
-      it "should call create, update, and delete callbacks upon directory moving to another directory" do
-        run_monitor(3, :directories => true) do
-          FileUtils.mv @tmp_dir + "/root/yawn", @tmp_dir + "/old_yawn"
-        end
-        @handler_results[:create].should include([@tmp_dir, 'old_yawn', :directory])
-        @handler_results[:delete].should include([@tmp_dir, 'root/yawn', :directory])
-        @handler_results[:update].should include([@tmp_dir, 'root', :directory])
-      end
-
-      it "should call create, update, and delete callbacks upon file renaming in the same directory" do
-        run_monitor(3, :directories => true) do
-          FileUtils.mv @tmp_dir + "/root/file.rb", @tmp_dir + "/root/old_file.rb"
-        end
-        @handler_results[:create].should include([@tmp_dir, 'root/old_file.rb', :file])
-        @handler_results[:delete].should include([@tmp_dir, 'root/file.rb', :file])
-        @handler_results[:update].should include([@tmp_dir, 'root', :directory])
-      end
-
-      it "should call create, update, and delete callbacks upon file moving to another directory" do
-        run_monitor(3, :directories => true) do
-          FileUtils.mv @tmp_dir + "/root/file.rb", @tmp_dir + "/old_file.rb"
-        end
-        @handler_results[:create].should include([@tmp_dir, 'old_file.rb', :file])
-        @handler_results[:delete].should include([@tmp_dir, 'root/file.rb', :file])
-        @handler_results[:update].should include([@tmp_dir, 'root', :directory])
-      end
-
-      it "should call delete callbacks upon directory structure deletion, in reverse order" do
-        expected_delete_events = [
-            ['root/yawn', :directory],
-            ['root/moo/cow.txt', :file],
-            ['root/moo', :directory],
-            ['root/file.yml', :file],
-            ['root/file.rb', :file],
-            ['root/file.css', :file],
-            ['root/duck/quack.txt', :file],
-            ['root/duck', :directory],
-            ['root', :directory]
-        ]
-        run_monitor(expected_delete_events.size, :directories => true) do
-          FileUtils.rm_rf @tmp_dir + '/.'
-        end
-        @handler_results[:create].should == []
-        @handler_results[:delete].should == expected_delete_events.map { |(file, type)| [@tmp_dir, file, type] }
-        @handler_results[:update].should == []
-      end
-
-      it "should call create callbacks upon directory structure creation, in order" do
-        expected_create_events = [
-            ['new_root', :directory],
-            ['new_root/duck', :directory],
-            ['new_root/duck/quack.txt', :file],
-            ['new_root/file.css', :file],
-            ['new_root/file.rb', :file],
-            ['new_root/file.yml', :file],
-            ['new_root/moo', :directory],
-            ['new_root/moo/cow.txt', :file],
-            ['new_root/yawn', :directory]
-        ]
-        run_monitor(expected_create_events.size, :directories => true) do
-          FileUtils.cp_r @tmp_dir + '/root/.', @tmp_dir + '/new_root'
-        end
-        @handler_results[:create].should == expected_create_events.map { |(file, type)| [@tmp_dir, file, type] }
-        @handler_results[:delete].should == []
-        @handler_results[:update].should == []
-      end
-    end
-  end
-end

data/vendor/sass/vendor/fssm/spec/path_spec.rb

@@ -1,96 +0,0 @@
-require "spec_helper"
-
-describe "The File System State Monitor" do
-  describe "paths" do
-    it "should accept a valid filesystem directory" do
-      lambda { FSSM::Path.new("#{@watch_root}") }.should_not raise_error
-    end
-
-    it "should not accept an invalid filesystem directory" do
-      lambda { FSSM::Path.new('/does/not/exist/kthxbye') }.should raise_error
-    end
-
-    it "should default the path to the current directory" do
-      path = FSSM::Path.new
-      here = Pathname.new('.').realpath
-
-      "#{here}".should == "#{path}"
-    end
-
-    it "should accept an optional glob array parameter" do
-      path = FSSM::Path.new('.', ['**/*.yml'])
-      path.glob.should == ['**/*.yml']
-    end
-
-    it "should accept an optional glob string parameter" do
-      path = FSSM::Path.new('.', '**/*.yml')
-      path.glob.should == ['**/*.yml']
-    end
-
-    it "should accept an optional option parameter" do
-      lambda { FSSM::Path.new('.', '**/*.yml', :foo => :bar) }.should_not raise_error
-    end
-
-    it "should default the glob to ['**/*']" do
-      path = FSSM::Path.new
-      path.glob.should == ['**/*']
-    end
-
-    it "should accept a callback for update events" do
-      path     = FSSM::Path.new
-      callback = lambda { |base, relative| return true }
-      path.update(&callback)
-      (path.update).should == callback
-    end
-
-    it "should accept a callback for delete events" do
-      path     = FSSM::Path.new
-      callback = lambda { |base, relative| return true }
-      path.delete(&callback)
-      (path.delete).should == callback
-    end
-
-    it "should accept a callback for create events" do
-      path     = FSSM::Path.new
-      callback = lambda { |base, relative| return true }
-      path.create(&callback)
-      (path.create).should == callback
-    end
-
-    it "should accept a configuration block" do
-      path = FSSM::Path.new "#{@watch_root}" do
-        glob '**/*.yml'
-        update { |base, relative| 'success' }
-        delete { |base, relative| 'success' }
-        create { |base, relative| 'success' }
-      end
-
-      "#{path}".should == "#{@watch_root}"
-      path.glob.should == ['**/*.yml']
-      path.update.should be_a_kind_of(Proc)
-      path.delete.should be_a_kind_of(Proc)
-      path.create.should be_a_kind_of(Proc)
-      path.update.call('', '').should == 'success'
-      path.delete.call('', '').should == 'success'
-      path.create.call('', '').should == 'success'
-    end
-
-    it "should pass file type to callbacks as the third argument if :directories option is used" do
-      path = FSSM::Path.new "#{@watch_root}", nil, :directories => true do
-        glob '**/*.yml'
-        update { |base, relative, type| [base, relative, type] }
-        delete { |base, relative, type| [base, relative, type] }
-        create { |base, relative, type| [base, relative, type] }
-      end
-
-      "#{path}".should == "#{@watch_root}"
-      path.glob.should == ['**/*.yml']
-      path.update.should be_a_kind_of(Proc)
-      path.delete.should be_a_kind_of(Proc)
-      path.create.should be_a_kind_of(Proc)
-      path.update.call('b', 'r', 't').should == ['b', 'r', 't']
-      path.delete.call('b', 'r', 't').should == ['b', 'r', 't']
-      path.create.call('b', 'r', 't').should == ['b', 'r', 't']
-    end
-  end
-end