social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/watchr-0.7/specs.watchr

@@ -0,0 +1,37 @@
+# Run me with:
+#   $ watchr specs.watchr
+
+# --------------------------------------------------
+# Rules
+# --------------------------------------------------
+watch( '^test.*/test_.*\.rb'                 )  { |m| ruby  m[0] }
+watch( '^lib/(.*)\.rb'                       )  { |m| ruby "test/test_#{m[1]}.rb" }
+watch( '^lib/watchr/(.*)\.rb'                )  { |m| ruby "test/test_#{m[1]}.rb" }
+watch( '^lib/watchr/event_handlers/(.*)\.rb' )  { |m| ruby "test/event_handlers/test_#{m[1]}.rb" }
+watch( '^test/test_helper\.rb'               )  { ruby tests }
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+Signal.trap('QUIT') { ruby tests  } # Ctrl-\
+Signal.trap('INT' ) { abort("\n") } # Ctrl-C
+
+# --------------------------------------------------
+# Helpers
+# --------------------------------------------------
+def ruby(*paths)
+  run "ruby #{gem_opt} -I.:lib:test -e'%w( #{paths.flatten.join(' ')} ).each {|p| require p }'"
+end
+
+def tests
+  Dir['test/**/test_*.rb'] - ['test/test_helper.rb']
+end
+
+def run( cmd )
+  puts   cmd
+  system cmd
+end
+
+def gem_opt
+  defined?(Gem) ? "-rubygems" : ""
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/test/README

@@ -0,0 +1,11 @@
+
+To use local watchr executable for dev work:
+
+  $ ruby -rubygems -Ilib ./bin/watchr -d specs.watchr
+
+To force a specific handler:
+
+  $ HANDLER=protable watchr -d specs.watchr
+  $ HANDLER=unix watchr -d specs.watchr
+
+  (see Watchr.handler)

data/vendor/ruby/1.9.1/gems/watchr-0.7/test/event_handlers/test_base.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+
+class BaseEventHandlerTest < MiniTest::Unit::TestCase
+
+  class Handler
+    include Watchr::EventHandler::Base
+  end
+
+  def setup
+    @handler = Handler.new
+  end
+
+  test "api" do
+    assert_respond_to @handler, :notify
+    assert_respond_to @handler, :listen
+    assert_respond_to @handler, :refresh
+    assert_includes   @handler.class.ancestors, Observable
+  end
+
+  test "notifies observers" do
+    @handler.expects(:notify_observers).with('foo/bar', nil)
+    @handler.notify('foo/bar', nil)
+  end
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/test/event_handlers/test_darwin.rb

@@ -0,0 +1,111 @@
+require 'test/test_helper'
+
+if Watchr::HAVE_FSE
+
+class Watchr::EventHandler::Darwin
+  attr_accessor :paths
+
+  def start()   end #noop
+  def restart() end #noop
+
+  public :on_change, :registered_directories
+end
+
+class DarwinEventHandlerTest < MiniTest::Unit::TestCase
+  include Watchr
+
+  def tempfile(name)
+    file = Tempfile.new(name, @root.to_s)
+    Pathname(file.path)
+  ensure
+    file.close
+  end
+
+  def setup
+    @root = Pathname(Dir.mktmpdir("WATCHR_SPECS-"))
+
+    @now = Time.now
+    @handler = EventHandler::Darwin.new
+
+    @foo = tempfile('foo').expand_path
+    @bar = tempfile('bar').expand_path
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@root.to_s)
+  end
+
+  test "listening triggers listening state" do
+    @handler.expects(:start)
+    @handler.listen([])
+  end
+
+  test "listens for events on monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.paths, @foo
+    assert_includes @handler.paths, @bar
+  end
+
+  test "reattaches to new monitored files" do
+    @baz = tempfile('baz').expand_path
+    @bax = tempfile('bax').expand_path
+
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.paths, @foo
+    assert_includes @handler.paths, @bar
+
+    @handler.refresh [ @baz, @bax ]
+    assert_includes @handler.paths, @baz
+    assert_includes @handler.paths, @bax
+    refute_includes @handler.paths, @foo
+    refute_includes @handler.paths, @bar
+  end
+
+  ## event types
+
+  test "deleted file event" do
+    @foo.stubs(:exist?).returns(false)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.on_change [@root]
+  end
+
+  test "modified file event" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :modified)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  test "accessed file event" do
+    @foo.stubs(:atime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :accessed)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  test "changed file event" do
+    @foo.stubs(:ctime).returns(@now + 100)
+    @handler.expects(:notify).with(@foo, :changed)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.on_change [@root]
+  end
+
+  ## internal
+
+  test "registers directories" do
+    @handler.listen [ @foo, @bar ]
+
+    assert_equal @foo.dirname, @bar.dirname # make sure all tempfiles are in same dir
+    assert_equal 1, @handler.registered_directories.size
+    assert_includes @handler.registered_directories, @foo.dirname.to_s
+    assert_includes @handler.registered_directories, @bar.dirname.to_s
+  end
+end
+
+end  # if Watchr::HAVE_FSE
+

data/vendor/ruby/1.9.1/gems/watchr-0.7/test/event_handlers/test_portable.rb

@@ -0,0 +1,142 @@
+require 'test/test_helper'
+
+class Watchr::EventHandler::Portable
+  attr_accessor :monitored_paths
+end
+
+class PortableEventHandlerTest < MiniTest::Unit::TestCase
+  include Watchr
+
+  def setup
+    @handler = EventHandler::Portable.new
+    @handler.stubs(:loop)
+
+    @foo = Pathname('foo').expand_path
+    @bar = Pathname('bar').expand_path
+    @baz = Pathname('baz').expand_path
+    @bax = Pathname('bax').expand_path
+
+    @now = Time.now
+    [@foo, @bar, @baz, @bax].each do |path|
+      path.stubs(:mtime ).returns(@now - 100)
+      path.stubs(:atime ).returns(@now - 100)
+      path.stubs(:ctime ).returns(@now - 100)
+      path.stubs(:exist?).returns(true)
+    end
+  end
+
+  test "triggers listening state" do
+    @handler.expects(:loop)
+    @handler.listen([])
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.monitored_paths, @foo
+    assert_includes @handler.monitored_paths, @bar
+  end
+
+  test "doesn't trigger on start" do
+  end
+
+  ## event types
+
+  test "deleted file event" do
+    @foo.stubs(:exist?).returns(false)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.trigger
+  end
+
+  test "modified file event" do
+    @foo.stubs(:mtime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "accessed file event" do
+    @foo.stubs(:atime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :accessed)
+    @handler.trigger
+  end
+
+  test "changed file event" do
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :changed)
+    @handler.trigger
+  end
+
+  ## event type priorities
+
+  test "mtime > atime" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @foo.stubs(:atime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "mtime > ctime" do
+    @foo.stubs(:mtime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :modified)
+    @handler.trigger
+  end
+
+  test "atime > ctime" do
+    @foo.stubs(:atime).returns(@now + 100)
+    @foo.stubs(:ctime).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :accessed)
+    @handler.trigger
+  end
+
+  test "deleted > mtime" do
+    @foo.stubs(:exist?).returns(false)
+    @foo.stubs(:mtime ).returns(@now + 100)
+
+    @handler.listen [ @foo, @bar ]
+    @handler.expects(:notify).with(@foo, :deleted)
+    @handler.trigger
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen [ @foo, @bar ]
+    assert_includes @handler.monitored_paths, @foo
+    assert_includes @handler.monitored_paths, @bar
+
+    @handler.refresh [ @baz, @bax ]
+    assert_includes @handler.monitored_paths, @baz
+    assert_includes @handler.monitored_paths, @bax
+    refute_includes @handler.monitored_paths, @foo
+    refute_includes @handler.monitored_paths, @bar
+  end
+
+  test "retries on ENOENT errors" do
+    @oops = Pathname('oops').expand_path
+    @oops.stubs(:exist?).returns(true)
+    @oops.stubs(:mtime).raises(Errno::ENOENT).
+      then.returns(Time.now + 100)
+
+    @handler.listen [ @oops ]
+
+    @handler.expects(:notify).with(@oops, :modified)
+    @handler.trigger
+  end
+end

data/vendor/ruby/1.9.1/gems/watchr-0.7/test/event_handlers/test_unix.rb

@@ -0,0 +1,162 @@
+require 'test/test_helper'
+
+if Watchr::HAVE_REV
+
+class Watchr::EventHandler::Unix::SingleFileWatcher
+  public :type
+end
+
+class UnixEventHandlerTest < MiniTest::Unit::TestCase
+  include Watchr
+
+  SingleFileWatcher = EventHandler::Unix::SingleFileWatcher
+
+  def setup
+    @now = Time.now
+    pathname = Pathname.new('foo/bar')
+    pathname.stubs(:atime ).returns(@now)
+    pathname.stubs(:mtime ).returns(@now)
+    pathname.stubs(:ctime ).returns(@now)
+    pathname.stubs(:exist?).returns(true)
+    SingleFileWatcher.any_instance.stubs(:pathname).returns(pathname)
+
+    @loop    = Rev::Loop.default
+    @handler = EventHandler::Unix.new
+    @watcher = SingleFileWatcher.new('foo/bar')
+    @loop.stubs(:run)
+  end
+
+  def teardown
+    SingleFileWatcher.handler = nil
+    Rev::Loop.default.watchers.every.detach
+  end
+
+  test "triggers listening state" do
+    @loop.expects(:run)
+    @handler.listen([])
+  end
+
+  ## SingleFileWatcher
+
+  test "watcher pathname" do
+    assert_instance_of Pathname, @watcher.pathname
+    assert_equal @watcher.path, @watcher.pathname.to_s
+  end
+
+  test "stores reference times" do
+    @watcher.pathname.stubs(:atime).returns(:time)
+    @watcher.pathname.stubs(:mtime).returns(:time)
+    @watcher.pathname.stubs(:ctime).returns(:time)
+
+    @watcher.send(:update_reference_times)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_atime)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_mtime)
+    assert_equal :time, @watcher.instance_variable_get(:@reference_ctime)
+  end
+
+  test "stores initial reference times" do
+    SingleFileWatcher.any_instance.expects(:update_reference_times)
+    SingleFileWatcher.new('foo')
+  end
+
+  test "updates reference times on change" do
+    @watcher.expects(:update_reference_times)
+    @watcher.on_change
+  end
+
+  test "detects event type" do
+    trigger_event @watcher, @now, :atime
+    assert_equal :accessed, @watcher.type
+
+    trigger_event @watcher, @now, :mtime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :ctime
+    assert_equal :changed, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :mtime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :mtime, :ctime
+    assert_equal :modified, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :ctime
+    assert_equal :accessed, @watcher.type
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    assert_equal :modified, @watcher.type
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    assert_equal :deleted, @watcher.type
+  end
+
+  ## monitoring file events
+
+  test "listens for events on monitored files" do
+    @handler.listen %w( foo bar )
+    assert_equal 2, @loop.watchers.size
+    assert_equal %w( foo bar ).to_set, @loop.watchers.every.path.to_set
+    assert_equal [SingleFileWatcher], @loop.watchers.every.class.uniq
+  end
+
+  test "notifies observers on file event" do
+    @watcher.stubs(:path).returns('foo')
+    @handler.expects(:notify).with('foo', anything)
+    @watcher.on_change
+  end
+
+  test "notifies observers of event type" do
+    trigger_event @watcher, @now, :atime
+    @handler.expects(:notify).with('foo/bar', :accessed)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :mtime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :ctime
+    @handler.expects(:notify).with('foo/bar', :changed)
+    @watcher.on_change
+
+    trigger_event @watcher, @now, :atime, :mtime, :ctime
+    @handler.expects(:notify).with('foo/bar', :modified)
+    @watcher.on_change
+
+    @watcher.pathname.stubs(:exist?).returns(false)
+    @handler.expects(:notify).with('foo/bar', :deleted)
+    @watcher.on_change
+  end
+
+  ## on the fly updates of monitored files list
+
+  test "reattaches to new monitored files" do
+    @handler.listen %w( foo bar )
+    assert_equal 2, @loop.watchers.size
+    assert_includes @loop.watchers.every.path, 'foo'
+    assert_includes @loop.watchers.every.path, 'bar'
+
+    @handler.refresh %w( baz bax )
+    assert_equal 2, @loop.watchers.size
+    assert_includes @loop.watchers.every.path, 'baz'
+    assert_includes @loop.watchers.every.path, 'bax'
+    refute_includes @loop.watchers.every.path, 'foo'
+    refute_includes @loop.watchers.every.path, 'bar'
+  end
+
+  private
+
+  def trigger_event(watcher, now, *types)
+    watcher.pathname.stubs(:atime).returns(now)
+    watcher.pathname.stubs(:mtime).returns(now)
+    watcher.pathname.stubs(:ctime).returns(now)
+    watcher.instance_variable_set(:@reference_atime, now)
+    watcher.instance_variable_set(:@reference_mtime, now)
+    watcher.instance_variable_set(:@reference_ctime, now)
+
+    types.each do |type|
+      watcher.pathname.stubs(type).returns(now+10)
+    end
+  end
+end
+
+end  # if Watchr::HAVE_REV