social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/vcr_spec.rb

@@ -0,0 +1,349 @@
+require 'spec_helper'
+
+describe VCR do
+  def insert_cassette(name = :cassette_test)
+    VCR.insert_cassette(name)
+  end
+
+  describe '.insert_cassette' do
+    it 'creates a new cassette' do
+      expect(insert_cassette).to be_instance_of(VCR::Cassette)
+    end
+
+    it 'takes over as the #current_cassette' do
+      orig_cassette = VCR.current_cassette
+      new_cassette = insert_cassette
+      expect(new_cassette).not_to eq(orig_cassette)
+      expect(VCR.current_cassette).to eq(new_cassette)
+    end
+
+    it 'raises an error if the stack of inserted cassettes already contains a cassette with the same name' do
+      insert_cassette(:foo)
+      expect {
+        insert_cassette(:foo)
+      }.to raise_error(/There is already a cassette with the same name/)
+    end
+  end
+
+  describe '.eject_cassette' do
+    it 'ejects the current cassette' do
+      cassette = insert_cassette
+      expect(cassette).to receive(:eject)
+      VCR.eject_cassette
+    end
+
+    it 'forwards the given options to `Cassette#eject`' do
+      cassette = insert_cassette
+      expect(cassette).to receive(:eject).with(:some => :options)
+      VCR.eject_cassette(:some => :options)
+    end
+
+    it 'returns the ejected cassette' do
+      cassette = insert_cassette
+      expect(VCR.eject_cassette).to eq(cassette)
+    end
+
+    it 'returns the #current_cassette to the previous one' do
+      cassette1, cassette2 = insert_cassette(:foo1), insert_cassette(:foo2)
+      expect { VCR.eject_cassette }.to change(VCR, :current_cassette).from(cassette2).to(cassette1)
+    end
+
+    it 'keeps the cassette as the current one until after #eject has finished' do
+      cassette = insert_cassette
+      current = nil
+      allow(cassette).to receive(:eject) { current = VCR.current_cassette }
+
+      VCR.eject_cassette
+
+      expect(current).to be(cassette)
+      expect(VCR.current_cassette).not_to be(cassette)
+    end
+
+    it 'properly pops the cassette off the stack even if an error occurs' do
+      cassette = insert_cassette
+      allow(cassette).to receive(:eject) { raise "boom" }
+      expect { VCR.eject_cassette }.to raise_error("boom")
+      expect(VCR.current_cassette).to be_nil
+    end
+  end
+
+  describe '.use_cassette' do
+    it 'inserts a new cassette' do
+      new_cassette = VCR::Cassette.new(:use_cassette_test)
+      expect(VCR).to receive(:insert_cassette).and_return(new_cassette)
+      VCR.use_cassette(:cassette_test) { }
+    end
+
+    it 'yields' do
+      yielded = false
+      VCR.use_cassette(:cassette_test, &lambda { yielded = true })
+      expect(yielded).to be true
+    end
+
+    it 'yields the cassette instance if the block expects an argument' do
+      VCR.use_cassette('name', :record => :new_episodes, &lambda do |cassette|
+        expect(cassette).to equal(VCR.current_cassette)
+      end)
+    end
+
+    it 'yields the cassette instance if the block expects a variable number of args' do
+      VCR.use_cassette('name', :record => :new_episodes) do |*args|
+        expect(args.size).to eq(1)
+        expect(args.first).to equal(VCR.current_cassette)
+      end
+    end
+
+    it 'ejects the cassette' do
+      expect(VCR).to receive(:eject_cassette)
+      VCR.use_cassette(:cassette_test) { }
+    end
+
+    it 'ejects the cassette even if there is an error' do
+      expect(VCR).to receive(:eject_cassette)
+      expect { VCR.use_cassette(:cassette_test) { raise StandardError } }.to raise_error
+    end
+
+    it 'does not eject a cassette if there was an error inserting it' do
+      expect(VCR).to receive(:insert_cassette).and_raise(StandardError.new('Boom!'))
+      expect(VCR).not_to receive(:eject_cassette)
+      expect { VCR.use_cassette(:test) { } }.to raise_error(StandardError, 'Boom!')
+    end
+
+    it 'raises a helpful error if no block is given' do
+      expect {
+        VCR.use_cassette(:test)
+      }.to raise_error(/requires a block/)
+    end
+  end
+
+  describe '.http_interactions' do
+    it 'returns the current_cassette.http_interactions when there is a current cassette' do
+      cassette = VCR.insert_cassette("a cassette")
+      expect(VCR.http_interactions).to be(cassette.http_interactions)
+    end
+
+    it 'returns a null list when there is no current cassette' do
+      expect(VCR.current_cassette).to be_nil
+      expect(VCR.http_interactions).to be(VCR::Cassette::HTTPInteractionList::NullList)
+    end
+  end
+
+  describe '.real_http_connections_allowed?' do
+    context 'when a cassette is inserted' do
+      it 'returns true if the cassette is recording' do
+        VCR.insert_cassette('foo', :record => :all)
+        expect(VCR.current_cassette).to be_recording
+        expect(VCR.real_http_connections_allowed?).to be true
+      end
+
+      it 'returns false if the cassette is not recording' do
+        VCR.insert_cassette('foo', :record => :none)
+        expect(VCR.current_cassette).not_to be_recording
+        expect(VCR.real_http_connections_allowed?).to be false
+      end
+    end
+
+    context 'when no cassette is inserted' do
+      before(:each) do
+        expect(VCR.current_cassette).to be_nil
+      end
+
+      it 'returns true if the allow_http_connections_when_no_cassette option is set to true' do
+        expect(VCR).to be_turned_on
+        VCR.configure { |c| c.allow_http_connections_when_no_cassette = true }
+        expect(VCR.real_http_connections_allowed?).to be true
+      end
+
+      it 'returns true if VCR is turned off' do
+        VCR.turn_off!
+        VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
+        expect(VCR.real_http_connections_allowed?).to be true
+      end
+
+      it 'returns false if the allow_http_connections_when_no_cassette option is set to false and VCR is turned on' do
+        expect(VCR).to be_turned_on
+        VCR.configure { |c| c.allow_http_connections_when_no_cassette = false }
+        expect(VCR.real_http_connections_allowed?).to be false
+      end
+    end
+  end
+
+  describe '.request_matchers' do
+    it 'always returns the same memoized request matcher registry instance' do
+      expect(VCR.request_matchers).to be_a(VCR::RequestMatcherRegistry)
+      expect(VCR.request_matchers).to be(VCR.request_matchers)
+    end
+  end
+
+  describe '.request_ignorer' do
+    it 'always returns the same memoized request ignorer instance' do
+      expect(VCR.request_ignorer).to be_a(VCR::RequestIgnorer)
+      expect(VCR.request_ignorer).to be(VCR.request_ignorer)
+    end
+  end
+
+  describe '.library_hooks' do
+    it 'always returns the same memoized LibraryHooks instance' do
+      expect(VCR.library_hooks).to be_a(VCR::LibraryHooks)
+      expect(VCR.library_hooks).to be(VCR.library_hooks)
+    end
+  end
+
+  describe '.cassette_serializers' do
+    it 'always returns the same memoized cassette serializers instance' do
+      expect(VCR.cassette_serializers).to be_a(VCR::Cassette::Serializers)
+      expect(VCR.cassette_serializers).to be(VCR.cassette_serializers)
+    end
+  end
+
+  describe ".cassette_persisters" do
+    it "always returns the same memoized Cassette::Persisters instance" do
+      expect(VCR.cassette_persisters).to be_a(VCR::Cassette::Persisters)
+      expect(VCR.cassette_persisters).to be(VCR.cassette_persisters)
+    end
+  end
+
+  describe '.configuration' do
+    it 'returns the configuration object' do
+      expect(VCR.configuration).to be_a(VCR::Configuration)
+    end
+
+    it 'memoizes the instance' do
+      expect(VCR.configuration).to be(VCR.configuration)
+    end
+  end
+
+  describe '.configure' do
+    it 'yields the configuration object' do
+      yielded_object = nil
+      VCR.configure do |obj|
+        yielded_object = obj
+      end
+      expect(yielded_object).to eq(VCR.configuration)
+    end
+  end
+
+  describe '.cucumber_tags' do
+    it 'yields a cucumber tags object' do
+      yielded_object = nil
+      VCR.cucumber_tags do |obj|
+        yielded_object = obj
+      end
+      expect(yielded_object).to be_instance_of(VCR::CucumberTags)
+    end
+  end
+
+  describe '.record_http_interaction' do
+    before(:each) { allow(VCR).to receive(:current_cassette).and_return(current_cassette) }
+    let(:interaction) { double(:request => double) }
+
+    context 'when there is not a current cassette' do
+      let(:current_cassette) { nil }
+
+      it 'does not record a request' do
+        # we can't set a message expectation on nil, but there is no place to record it to...
+        # this mostly tests that there is no error.
+        VCR.record_http_interaction(interaction)
+      end
+    end
+
+    context 'when there is a current cassette' do
+      let(:current_cassette) { double('current cassette') }
+
+      it 'records the request when it should not be ignored' do
+        allow(VCR.request_ignorer).to receive(:ignore?).with(interaction.request).and_return(false)
+        expect(current_cassette).to receive(:record_http_interaction).with(interaction)
+        VCR.record_http_interaction(interaction)
+      end
+
+      it 'does not record the request when it should be ignored' do
+        allow(VCR.request_ignorer).to receive(:ignore?).with(interaction.request).and_return(true)
+        expect(current_cassette).not_to receive(:record_http_interaction)
+        VCR.record_http_interaction(interaction)
+      end
+    end
+  end
+
+  describe '.turn_off!' do
+    it 'indicates it is turned off' do
+      VCR.turn_off!
+      expect(VCR).not_to be_turned_on
+    end
+
+    it 'raises an error if a cassette is in use' do
+      VCR.insert_cassette('foo')
+      expect {
+        VCR.turn_off!
+      }.to raise_error(VCR::CassetteInUseError, /foo/)
+    end
+
+    it 'causes an error to be raised if you insert a cassette while VCR is turned off' do
+      VCR.turn_off!
+      expect {
+        VCR.insert_cassette('foo')
+      }.to raise_error(VCR::TurnedOffError)
+    end
+
+    it 'raises an ArgumentError when given an invalid option' do
+      expect {
+        VCR.turn_off!(:invalid_option => true)
+      }.to raise_error(ArgumentError)
+    end
+
+    context 'when `:ignore_cassettes => true` is passed' do
+      before(:each) { VCR.turn_off!(:ignore_cassettes => true) }
+
+      it 'ignores cassette insertions' do
+        VCR.insert_cassette('foo')
+        expect(VCR.current_cassette).to be_nil
+      end
+
+      it 'still runs a block passed to use_cassette' do
+        yielded = false
+
+        VCR.use_cassette('foo') do
+          yielded = true
+          expect(VCR.current_cassette).to be_nil
+        end
+
+        expect(yielded).to be true
+      end
+    end
+  end
+
+  describe '.turn_on!' do
+    before(:each) { VCR.turn_off! }
+
+    it 'indicates it is turned on' do
+      VCR.turn_on!
+      expect(VCR).to be_turned_on
+    end
+  end
+
+  describe '.turned_off' do
+    it 'yields with VCR turned off' do
+      expect(VCR).to be_turned_on
+      yielded = false
+
+      VCR.turned_off do
+        yielded = true
+        expect(VCR).not_to be_turned_on
+      end
+
+      expect(yielded).to eq(true)
+      expect(VCR).to be_turned_on
+    end
+
+    it 'passes options through to .turn_off!' do
+      expect(VCR).to receive(:turn_off!).with(:ignore_cassettes => true)
+      VCR.turned_off(:ignore_cassettes => true) { }
+    end
+  end
+
+  describe '.turned_on?' do
+    it 'is on by default' do
+      VCR.send(:initialize_ivars) # clear internal state
+      expect(VCR).to be_turned_on
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/vcr.gemspec

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "vcr/version"
+
+Gem::Specification.new do |s|
+  s.name = "vcr"
+  s.homepage = "https://github.com/vcr/vcr"
+  s.license = "MIT"
+  s.authors = ["Myron Marston"]
+  s.summary = "Record your test suite's HTTP interactions and replay them during future test runs for fast, deterministic, accurate tests."
+  s.description = "VCR provides a simple API to record and replay your test suite's HTTP interactions.  It works with a variety of HTTP client libraries, HTTP stubbing libraries and testing frameworks."
+  s.email = "myron.marston@gmail.com"
+  s.require_path = "lib"
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {spec,features}/*`.split("\n")
+
+  s.version = VCR.version
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.8.7'
+  s.required_rubygems_version = '>= 1.3.5'
+
+  # Development dependencies are listed in the Gemfile.
+end
+

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

@@ -0,0 +1,6 @@
+doc/
+pkg/
+bk/
+.wiki
+.yardoc
+*.gem

data/vendor/ruby/1.9.1/gems/watchr-0.7/History.txt

@@ -0,0 +1,32 @@
+
+=== v0.5.7
+
+* Added manifest.watchr script
+* Unix handler supports :deleted event type
+* Unix handler supports :accessed (atime), :modified (mtime) and :changed
+  (ctime) event types (thanks gzuki[http://github.com/gzuki] for initial work)
+
+
+=== v0.5.6
+
+* Rev gem optional in development (thanks TwP[http://github.com/TwP])
+* Allow gems to bundle .watchr scripts (thanks foca[http://github.com/foca])
+
+    gemname/lib/gemname.watchr
+
+  is now automatically picked up with
+
+    $ watchr gemname.watchr
+
+* Look for script in path
+* debug msg when rev not found on *nix
+* rake task for cross interpreter testing
+
+
+=== v0.5.5
+
+* Rev gem is optional. Fixes issue #1
+  Install Rev to automatically get evented handler on *nix
+
+    gem install rev
+

data/vendor/ruby/1.9.1/gems/watchr-0.7/LICENSE

@@ -0,0 +1,19 @@
+Copyright © 2009 Martin Aumont (mynyml)
+
+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/ruby/1.9.1/gems/watchr-0.7/README.md

@@ -0,0 +1,119 @@
+Summary
+-------
+
+Agile development tool that monitors a directory tree, and triggers a user
+defined action whenever an observed file is modified. Its most typical use is
+continuous testing, and as such it is a more flexible alternative to autotest.
+
+Features
+--------
+
+watchr is:
+
+* Simple to use
+* Highly flexible
+* Evented               ( Listens for filesystem events with native c libs )
+* Portable              ( Linux, \*BSD, OSX, Solaris, Windows )
+* Fast                  ( Immediately reacts to file changes )
+
+Most importantly it allows running tests in an environment that is **agnostic** to:
+
+* Web frameworks        ( rails, merb, sinatra, camping, invisible, ... )
+* Test frameworks       ( test/unit, minitest, rspec, test/spec, expectations, ... )
+* Ruby interpreters     ( ruby1.8, ruby1.9, MRI, JRuby, Rubinius, ... )
+* Package frameworks    ( rubygems, rip, ... )
+
+Usage
+-----
+
+On the command line,
+
+    $ watchr path/to/script.file
+
+will monitor files in the current directory tree, and react to events on those
+files in accordance with the script.
+
+Scripts
+-------
+
+The script contains a set of simple rules that map observed files to an action.
+Its DSL is a single method: `watch(pattern, &action)`
+
+    watch( 'a regexp pattern matching paths to observe' )  {|match_data_object| command_to_run }
+
+So for example,
+
+    watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+
+will match any test file and run it whenever it is saved.
+
+A continuous testing script for a basic project could be
+
+    watch( 'test/test_.*\.rb' )  {|md| system("ruby #{md[0]}") }
+    watch( 'lib/(.*)\.rb' )      {|md| system("ruby test/test_#{md[1]}.rb") }
+
+which, in addition to running any saved test file as above, will also run a
+lib file's associated test. This mimics the equivalent autotest behaviour.
+
+It's easy to see why watchr is so flexible, since the whole command is custom.
+The above actions could just as easily call "jruby", "ruby --rubygems", "ruby
+-Ilib", "specrb", "rbx", ... or any combination of these. For the sake of
+comparison, autotest runs with:
+
+    $ /usr/bin/ruby1.8 -I.:lib:test -rubygems -e "%w[test/unit test/test_helper.rb test/test_watchr.rb].each { |f| require f }"
+
+locking the environment into ruby1.8, rubygems and test/unit for all tests.
+
+And remember the scripts are pure ruby, so feel free to add methods,
+`Signal#trap` calls, etc. Updates to script files are picked up on the fly (no
+need to restart watchr) so experimenting is painless.
+
+The [wiki][5] has more details and examples.  You might also want to take a
+look at watchr's own scripts, [specs.watchr][1], [docs.watchr][2] and
+[gem.watchr][3], to get you started.
+
+Install
+-------
+
+    gem install watchr
+
+If you're on Linux/BSD and have the [rev][4] gem installed, Watchr will detect
+it and use it automatically. This will make Watchr evented.
+
+    gem install rev
+
+You can get the same evented behaviour on OS X by installing
+[ruby-fsevent][10].
+
+    gem install ruby-fsevent
+
+See Also
+--------
+
+* [redgreen][6]:   Standalone redgreen eye candy for test results, ala autotest.
+* [phocus][7]:     Run focused tests when running the whole file/suite is unnecessary.
+* [autowatchr][8]: Provides some autotest-like behavior for watchr
+* [nestor][9]:     Continuous testing server for Rails
+
+Links
+-----
+
+* code:  <http://github.com/mynyml/watchr>
+* docs:  <http://yardoc.org/docs/mynyml-watchr/file:README.rdoc>
+* wiki:  <http://wiki.github.com/mynyml/watchr>
+* bugs:  <http://github.com/mynyml/watchr/issues>
+
+
+
+
+[1]:  http://github.com/mynyml/watchr/blob/master/specs.watchr
+[2]:  http://github.com/mynyml/watchr/blob/master/docs.watchr
+[3]:  http://github.com/mynyml/watchr/blob/master/gem.watchr
+[4]:  http://github.com/tarcieri/rev/
+[5]:  http://wiki.github.com/mynyml/watchr
+[6]:  http://github.com/mynyml/redgreen
+[7]:  http://github.com/mynyml/phocus
+[8]:  http://github.com/viking/autowatchr
+[9]:  http://github.com/francois/nestor
+[10]: http://github.com/sandro/ruby-fsevent
+