social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/hooks/before_record.feature

@@ -1,172 +0,0 @@
-Feature: before_record hook
-
-  The `before_record` hook is called before a cassette is written to disk.
-  This can be used to modify the HTTP interaction before it is recorded.
-
-  Your block should accept up to 2 arguments.  The first argument will be
-  the HTTP interaction that is about to be written to disk.  The second
-  argument will be the current cassette.
-
-  You can also call `#ignore!` on the HTTP interaction to prevent VCR
-  from recording it.
-
-  If you don't your hook to apply to all cassettes, you can use tags for
-  this purpose.  Consider this code:
-
-      VCR.configure do |c|
-        c.before_record(:twitter) { ... } # modify the interactions somehow
-      end
-
-      VCR.use_cassette('cassette_1', :tag => :twitter) { ... }
-      VCR.use_cassette('cassette_2') { ... }
-
-  In this example, the hook would apply to the first cassette but not the
-  second cassette.
-
-  Scenario: Modify recorded response
-    Given a file named "before_record_example.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello Earth" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-
-        c.before_record do |i|
-          i.response.body.sub!('Earth', 'World')
-        end
-      end
-
-      VCR.use_cassette('recording_example') do
-        Net::HTTP.get_response('localhost', '/', 7777)
-      end
-      """
-    When I run `ruby before_record_example.rb`
-    Then the file "cassettes/recording_example.yml" should contain "Hello World"
-     And the file "cassettes/recording_example.yml" should not contain "Earth"
-
-  Scenario: Modify recorded response based on the cassette
-    Given a file named "before_record_example.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello Earth" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-
-        c.before_record do |interaction, cassette|
-          interaction.response.body << " (#{cassette.name})"
-        end
-      end
-
-      VCR.use_cassette('recording_example') do
-        Net::HTTP.get_response('localhost', '/', 7777)
-      end
-      """
-    When I run `ruby before_record_example.rb`
-    Then the file "cassettes/recording_example.yml" should contain "Hello Earth (recording_example)"
-
-  Scenario: Prevent recording by ignoring interaction in before_record hook
-    Given a file named "before_record_ignore.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello World" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.before_record { |i| i.ignore! }
-      end
-
-      VCR.use_cassette('recording_example') do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby before_record_ignore.rb`
-    Then it should pass with "Response: Hello World"
-    And the file "cassettes/recording_example.yml" should not exist
-
-  Scenario: Multiple hooks are run in order
-    Given a file named "multiple_hooks.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello World" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-
-        c.before_record { puts "In before_record hook 1" }
-        c.before_record { puts "In before_record hook 2" }
-      end
-
-      VCR.use_cassette('example', :record => :new_episodes) do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby multiple_hooks.rb`
-    Then it should pass with:
-      """
-      Response: Hello World
-      In before_record hook 1
-      In before_record hook 2
-      """
-
-  Scenario: Use tagging to apply hook to only certain cassettes
-    Given a file named "tagged_hooks.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello World" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-
-        c.before_record(:tag_1) do
-          puts "In before_record hook for tag_1"
-        end
-      end
-
-      [:tag_1, :tag_2, nil].each do |tag|
-        puts
-        puts "Using tag: #{tag.inspect}"
-
-        VCR.use_cassette('example', :record => :new_episodes, :tag => tag) do
-          response = Net::HTTP.get_response('localhost', '/', 7777)
-          puts "Response: #{response.body}"
-        end
-      end
-      """
-    When I run `ruby tagged_hooks.rb`
-    Then it should pass with:
-      """
-      Using tag: :tag_1
-      Response: Hello World
-      In before_record hook for tag_1
-
-      Using tag: :tag_2
-      Response: Hello World
-
-      Using tag: nil
-      Response: Hello World
-      """
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/http_libraries/em_http_request.feature

@@ -1,247 +0,0 @@
-@exclude-jruby @exclude-rbx
-Feature: EM HTTP Request
-
-  EM HTTP Request allows multiple simultaneous asynchronous requests.
-  (The other HTTP libraries are synchronous).  The scenarios below
-  demonstrate how VCR can be used with asynchronous em-http requests.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'em-http-request'
-
-      start_sinatra_app(:port => 7777) do
-        %w[ foo bar bazz ].each_with_index do |path, index|
-          get "/#{path}" do
-            sleep index * 0.1 # ensure the async callbacks are invoked in order
-            ARGV[0] + ' ' + path
-          end
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-
-  Scenario: multiple simultaneous HttpRequest objects
-    Given a file named "make_requests.rb" with:
-      """ruby
-      require 'vcr_setup'
-
-      VCR.use_cassette('em_http') do
-        EventMachine.run do
-          http_array = %w[ foo bar bazz ].map do |p|
-            EventMachine::HttpRequest.new("http://localhost:7777/#{p}").get
-          end
-
-          http_array.each do |http|
-            http.callback do
-              puts http.response
-
-              if http_array.all? { |h| h.response.to_s != '' }
-                EventMachine.stop
-              end
-            end
-          end
-        end
-      end
-      """
-    When I run `ruby make_requests.rb Hello`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-    And the file "cassettes/em_http.yml" should contain YAML like:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost:7777/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello foo
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello bar
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bazz
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Hello bazz
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-    When I run `ruby make_requests.rb Goodbye`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-
-  Scenario: MultiRequest
-    Given a file named "make_requests.rb" with:
-      """ruby
-      require 'vcr_setup'
-
-      VCR.use_cassette('em_http') do
-        EventMachine.run do
-          multi = EventMachine::MultiRequest.new
-
-          %w[ foo bar bazz ].each do |path|
-            multi.add(path, EventMachine::HttpRequest.new("http://localhost:7777/#{path}").get)
-          end
-
-          multi.callback do
-            responses = Hash[multi.responses[:callback]]
-
-            %w[ foo bar bazz ].each do |path|
-              puts responses[path].response
-            end
-
-            EventMachine.stop
-          end
-        end
-      end
-      """
-    When I run `ruby make_requests.rb Hello`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-    And the file "cassettes/em_http.yml" should contain YAML like:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost:7777/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello foo
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "9"
-          body: 
-            encoding: UTF-8
-            string: Hello bar
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://localhost:7777/bazz
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Hello bazz
-          http_version: 
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-    When I run `ruby make_requests.rb Goodbye`
-    Then the output should contain:
-      """
-      Hello foo
-      Hello bar
-      Hello bazz
-      """
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/http_libraries/net_http.feature

@@ -1,169 +0,0 @@
-Feature: Net::HTTP
-
-  There are many ways to use Net::HTTP.  The scenarios below provide regression
-  tests for some Net::HTTP APIs that have not worked properly with VCR and
-  FakeWeb or WebMock in the past (but have since been fixed).
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      if ARGV[0] == '--with-server'
-        start_sinatra_app(:port => 7777) do
-          get('/')  { 'VCR works with Net::HTTP gets!' }
-          post('/') { 'VCR works with Net::HTTP posts!' }
-        end
-      end
-
-      require 'vcr'
-      """
-
-  Scenario Outline: Calling #post on new Net::HTTP instance
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        puts Net::HTTP.new('localhost', 7777).post('/', '').body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP posts!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP posts!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP posts!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Return from yielded block
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      def perform_request
-        Net::HTTP.new('localhost', 7777).request(Net::HTTP::Get.new('/', {})) do |response|
-          return response
-        end
-      end
-
-      VCR.use_cassette('net_http') do
-        puts perform_request.body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Use Net::ReadAdapter to read body in fragments
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        body = ''
-
-        Net::HTTP.new('localhost', 7777).request_get('/') do |response|
-          response.read_body { |frag| body << frag }
-        end
-
-        puts body
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-  Scenario Outline: Use open-uri (which is built on top of Net::HTTP and uses a seldom-used Net::HTTP API)
-    Given a file named "vcr_net_http.rb" with:
-      """ruby
-      require 'open-uri'
-      require 'vcr_setup.rb'
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('net_http') do
-        puts open('http://localhost:7777/').read
-      end
-      """
-    When I run `ruby vcr_net_http.rb --with-server`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-    And the file "cassettes/net_http.yml" should contain "VCR works with Net::HTTP gets!"
-
-    When I run `ruby vcr_net_http.rb`
-    Then the output should contain "VCR works with Net::HTTP gets!"
-
-    Examples:
-      | hook_into |
-      | :fakeweb  |
-      | :webmock  |
-
-    Scenario Outline: Make an HTTPS request
-      Given a file named "vcr_https.rb" with:
-        """ruby
-        require 'vcr'
-
-        VCR.configure do |c|
-          c.hook_into <hook_into>
-          c.cassette_library_dir = 'cassettes'
-        end
-
-        uri = URI("https://gist.github.com/myronmarston/fb555cb593f3349d53af/raw/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist")
-
-        VCR.use_cassette('https') do
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          response = http.request_get(uri.path)
-
-          puts response.body
-        end
-        """
-      When I run `ruby vcr_https.rb`
-      Then the output should contain "VCR gist"
-      And the file "cassettes/https.yml" should contain "VCR gist"
-
-      When I modify the file "cassettes/https.yml" to replace "VCR gist" with "HTTPS replaying works"
-      And I run `ruby vcr_https.rb`
-      Then the output should contain "HTTPS replaying works"
-
-      Examples:
-        | hook_into |
-        | :fakeweb  |
-        | :webmock  |