social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/persistence.feature

@@ -1,63 +0,0 @@
-Feature: Cassette Persistence
-
-  By default, cassettes will be persisted to the file system. However, you
-  can easily configure VCR to persist the cassettes to a database, a key-value
-  store, or anywhere you like.
-
-  To use something besides the file system, you must provide an object
-  that provides a hash-like interface:
-
-    * `persister[name]` should return the content previously persisted for the
-      given cassette name.
-    * `persister[name] = content` should persist the content for the
-      given cassette name.
-
-  Register this object with VCR, and then you can configure all cassettes
-  to use it (using the `default_cassette_options`) or just some cassettes
-  to use it (by passing it as an option to individual cassettes).
-
-  Scenario: Persist cassettes in Redis
-    Given the redis DB has no data
-      And a file named "use_redis.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello" }
-        end
-      end
-
-      require 'redis'
-
-      class RedisCassettePersister
-        def initialize(redis)
-          @redis = redis
-        end
-
-        def [](name)
-          @redis.get(name)
-        end
-
-        def []=(name, content)
-          @redis.set(name, content)
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_persisters[:redis] = RedisCassettePersister.new(Redis.connect)
-        c.default_cassette_options = { :persist_with => :redis }
-      end
-
-      VCR.use_cassette("redis_example") do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby use_redis.rb --with-server`
-    Then it should pass with "Hello"
-     And the value stored at the redis key "redis_example.yml" should include "Hello"
-
-    When I run `ruby use_redis.rb`
-    Then it should pass with "Hello"

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/cassettes/update_content_length_header.feature

@@ -1,112 +0,0 @@
-Feature: Update content_length header
-
-  When the `:update_content_length_header` option is set to a truthy value,
-  VCR will ensure that the `Content-Length` header will have the correct
-  value.  This is useful in several situations:
-
-    - When you manually edit the cassette file and change the resonse body
-      length.  You can use this option so you don't have to manually calculate
-      and update the body length.
-    - When you use ERB, the response body length may vary.  This will ensure
-      it is always correct.
-    - Syck, the default YAML engine for ruby 1.8 (and 1.9, unless you compile
-      it to use Psych), has a bug where it sometimes will remove some
-      whitespace strings when you serialize them.  This may cause the
-      `Content-Length` header to have the wrong value.
-
-  This is especially important when you use a client that checks the
-  `Content-Length` header.  Mechanize, for example, will raise an `EOFError`
-  when the header value does not match the actual body length.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "11"
-          body: 
-            encoding: UTF-8
-            string: Hello <modified>
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "common_stuff.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-
-      def make_request_and_print_results
-        response = Net::HTTP.get_response('example.com', '/')
-        puts "Body length: #{response.body.length}"
-        puts "Header value: #{response['Content-Length']}"
-      end
-      """
-
-  Scenario: Default :update_content_length_header setting
-    Given a file named "default.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example') do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby default.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => false
-    Given a file named "false.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => false) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby false.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => true
-    Given a file named "true.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => true) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby true.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 16
-      """
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/configuration/allow_http_connections_when_no_cassette.feature

@@ -1,52 +0,0 @@
-Feature: Allow HTTP connections when no cassette
-
-  Usually, HTTP requests made when no cassette is inserted will [result in an
-  error](../cassettes/error-for-http-request-made-when-no-cassette-is-in-use).
-  You can set the `allow_http_connections_when_no_cassette` configuration option
-  to true to allow requests, if you do not want to use VCR for everything.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.allow_http_connections_when_no_cassette = true
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-    And the directory "vcr/cassettes" does not exist
-
-  Scenario: Allow HTTP connections when no cassette
-    Given a file named "no_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      puts "Response: " + Net::HTTP.get_response('localhost', '/', 7777).body
-      """
-    When I run `ruby no_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-
-  Scenario: Cassettes record and replay as normal
-    Given a file named "record_replay_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('localhost') do
-        puts "Response: " + Net::HTTP.get_response('localhost', '/', 7777).body
-      end
-      """
-    When I run `ruby record_replay_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-    And the file "cassettes/localhost.yml" should contain "Hello"
-
-    When I run `ruby record_replay_cassette.rb`
-    Then the output should contain "Response: Hello"
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/configuration/cassette_library_dir.feature

@@ -1,31 +0,0 @@
-Feature: cassette_library_dir
-
-  The `cassette_library_dir` configuration option sets a directory
-  where VCR saves each cassette.
-
-  Note: When using Rails, avoid using the `test/fixtures` directory 
-  to store the cassettes. Rails treats any YAML file in the fixtures 
-  directory as an ActiveRecord fixture.
-  This will cause an `ActiveRecord::Fixture::FormatError` to be raised.
-
-  Scenario: cassette_library_dir
-    Given a file named "cassette_library_dir.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'vcr/cassettes'
-        c.hook_into :webmock
-      end
-
-      VCR.use_cassette('localhost') do
-        Net::HTTP.get_response('localhost', '/', 7777)
-      end
-      """
-     And the directory "vcr/cassettes" does not exist
-    When I run `ruby cassette_library_dir.rb`
-    Then the file "vcr/cassettes/localhost.yml" should exist

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/configuration/debug_logging.feature

@@ -1,52 +0,0 @@
-@exclude-18
-Feature: Debug Logging
-
-  Use the `debug_logger` option to set an IO-like object that VCR will log
-  debug output to. This is a useful way to troubleshoot what VCR is doing.
-
-  The debug logger must respond to `#puts`.
-
-  Scenario: Use the debug logger for troubleshooting
-    Given a file named "debug_logger.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.debug_logger = File.open(ARGV.first, 'w')
-      end
-
-      VCR.use_cassette('example') do
-        Net::HTTP.get_response(URI("http://localhost:7777/"))
-      end
-      """
-    When I run `ruby debug_logger.rb record.log --with-server`
-    Then the file "record.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :uri], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :uri] and 0 interaction(s): {  }
-      [webmock] Identified request type (recordable) for [get http://localhost:7777/]
-      [Cassette: 'example'] Recorded HTTP interaction [get http://localhost:7777/] => [200 "Hello World"]
-
-      """
-    When I run `ruby debug_logger.rb playback.log`
-    Then the file "playback.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :uri], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :uri] and 1 interaction(s): { [get http://localhost:7777/] => [200 "Hello World"] }
-        [Cassette: 'example'] Checking if [get http://localhost:7777/] matches [get http://localhost:7777/] using [:method, :uri]
-          [Cassette: 'example'] method (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-          [Cassette: 'example'] uri (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-        [Cassette: 'example'] Found matching interaction for [get http://localhost:7777/] at index 0: [200 "Hello World"]
-      [webmock] Identified request type (stubbed_by_vcr) for [get http://localhost:7777/]
-
-      """

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/configuration/default_cassette_options.feature

@@ -1,100 +0,0 @@
-Feature: default_cassette_options
-
-  The `default_cassette_options` configuration option takes a hash
-  that provides defaults for each cassette you use.  Any cassette
-  can override the defaults as well as set additional options.
-
-  The `:match_requests_on` option defaults to `[:method, :uri]` when
-  it has not been set.
-
-  The `:record` option defaults to `:once` when it has not been set.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.default_cassette_options = { :record => :new_episodes, :erb => true }
-
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-
-  Scenario: cassettes get default values from configured `default_cassette_options`
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: new_episodes
-      ERB: true
-      """
-
-  Scenario: `:match_requests_on` defaults to `[:method, :uri]` when it has not been set
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Match Requests On: #{VCR.current_cassette.match_requests_on.inspect}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Match Requests On: [:method, :uri]"
-
-  Scenario: `:record` defaults to `:once` when it has not been set
-    Given a file named "default_record_mode.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        puts "Record mode: #{VCR.current_cassette.record_mode.inspect}"
-      end
-      """
-    When I run `ruby default_record_mode.rb`
-    Then the output should contain "Record mode: :once"
-
-  Scenario: cassettes can set their own options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :re_record_interval => 10000) do
-        puts "Re-record Interval: #{VCR.current_cassette.re_record_interval}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Re-record Interval: 10000"
-
-  Scenario: cassettes can override default options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :record => :none, :erb => false) do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: none
-      ERB: false
-      """

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/features/configuration/filter_sensitive_data.feature

@@ -1,152 +0,0 @@
-Feature: Filter sensitive data
-
-  Note: this config option is also available as `define_cassette_placeholder`
-  to reflect the fact that it is useful for more than just sensitive data.
-
-  The `filter_sensitive_data` configuration option can be used to prevent
-  sensitive data from being written to your cassette files.  This may be
-  important if you commit your cassettes files to source control and do
-  not want your sensitive data exposed.  Pass the following arguments to
-  `filter_sensitive_data`:
-
-    - A substitution string.  This is the string that will be written to
-      the cassettte file as a placeholder.  It should be unique and you
-      may want to wrap it in special characters like `{ }` or `< >`.
-    - A symbol specifying a tag (optional).  If a tag is given, the
-      filtering will only be applied to cassettes with the given tag.
-    - A block.  The block should return the sensitive text that you want
-      replaced with the substitution string.  If your block accepts an
-      argument, the HTTP interaction will be yielded so that you can
-      dynamically specify the sensitive text based on the interaction
-      (see the last scenario for an example of this).
-
-  When the interactions are replayed, the sensitive text will replace the
-  substitution string so that the interaction will be identical to what was
-  originally recorded.
-
-  You can specify as many filterings as you want.
-
-  Scenario: Multiple filterings
-    Given a file named "filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<GREETING>') { 'Hello' }
-        c.filter_sensitive_data('<LOCATION>') { 'World' }
-      end
-
-      VCR.use_cassette('filtering') do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby filtering.rb --with-server`
-    Then the output should contain "Response: Hello World"
-     And the file "cassettes/filtering.yml" should contain "<GREETING> <LOCATION>"
-     And the file "cassettes/filtering.yml" should not contain "Hello"
-     And the file "cassettes/filtering.yml" should not contain "World"
-
-    When I run `ruby filtering.rb`
-    Then the output should contain "Hello World"
-
-  Scenario: Filter tagged cassettes
-    Given a file named "tagged_filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        response_count = 0
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World #{response_count += 1 }" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<LOCATION>', :my_tag) { 'World' }
-      end
-
-      VCR.use_cassette('tagged', :tag => :my_tag) do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Tagged Response: #{response.body}"
-      end
-
-      VCR.use_cassette('untagged', :record => :new_episodes) do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Untagged Response: #{response.body}"
-      end
-      """
-    When I run `ruby tagged_filtering.rb --with-server`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-     And the file "cassettes/tagged.yml" should contain "Hello <LOCATION> 1"
-     And the file "cassettes/untagged.yml" should contain "Hello World 2"
-
-    When I run `ruby tagged_filtering.rb`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-
-  Scenario: Filter dynamic data based on yielded HTTP interaction
-    Given a file named "dynamic_filtering.rb" with:
-      """ruby
-      include_http_adapter_for('net/http')
-
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          helpers do
-            def request_header_for(header_key_fragment)
-              key = env.keys.find { |k| k =~ /#{header_key_fragment}/i }
-              env[key]
-            end
-          end
-
-          get('/') { "#{request_header_for('username')}/#{request_header_for('password')}" }
-        end
-      end
-
-      require 'vcr'
-
-      USER_PASSWORDS = {
-        'john.doe' => 'monkey',
-        'jane.doe' => 'cheetah'
-      }
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<PASSWORD>') do |interaction|
-          USER_PASSWORDS[interaction.request.headers['X-Http-Username'].first]
-        end
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, :uri, :headers]) do
-        puts "Response: " + response_body_for(
-          :get, 'http://localhost:7777/', nil,
-          'X-Http-Username' => 'john.doe',
-          'X-Http-Password' => USER_PASSWORDS['john.doe']
-        )
-      end
-      """
-    When I run `ruby dynamic_filtering.rb --with-server`
-    Then the output should contain "john.doe/monkey"
-    And the file "cassettes/example.yml" should contain "john.doe/<PASSWORD>"
-    And the file "cassettes/example.yml" should contain a YAML fragment like:
-      """
-      X-Http-Password:
-      - <PASSWORD>
-      """
-
-    When I run `ruby dynamic_filtering.rb`
-    Then the output should contain "john.doe/monkey"