social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/lib/vcr/deprecations.rb

@@ -1,108 +0,0 @@
-module VCR
-  # @deprecated Use #configure instead.
-  # @see #configure
-  def config
-    warn "WARNING: `VCR.config` is deprecated.  Use VCR.configure instead."
-    configure { |c| yield c }
-  end
-
-  # @private
-  def self.const_missing(const)
-    return super unless const == :Config
-    warn "WARNING: `VCR::Config` is deprecated.  Use VCR.configuration instead."
-    configuration
-  end
-
-  # @private
-  def Cassette.const_missing(const)
-    return super unless const == :MissingERBVariableError
-    warn "WARNING: `VCR::Cassette::MissingERBVariableError` is deprecated.  Use `VCR::Errors::MissingERBVariableError` instead."
-    Errors::MissingERBVariableError
-  end
-
-  class Configuration
-    # @deprecated Use #hook_into instead.
-    # @see #hook_into
-    def stub_with(*adapters)
-      warn "WARNING: `VCR.configure { |c| c.stub_with ... }` is deprecated. Use `VCR.configure { |c| c.hook_into ... }` instead."
-      hook_into(*adapters)
-    end
-  end
-
-  # @private
-  module Deprecations
-    module Middleware
-      # @private
-      module Faraday
-        def initialize(*args)
-          if block_given?
-            Kernel.warn "WARNING: Passing a block to `VCR::Middleware::Faraday` is deprecated. \n" +
-                        "As of VCR 2.0, you need to wrap faraday requests in VCR.use_cassette, just like with any other library hook."
-          end
-        end
-      end
-    end
-  end
-
-  module RSpec
-    # Contains macro methods to assist with VCR usage. These methods are
-    # intended to be used directly in an RSpec example group. To make these
-    # available in your RSpec example groups, extend the module in an individual
-    # example group, or configure RSpec to extend the module in all example groups.
-    #
-    # @example
-    #   RSpec.configure do |c|
-    #     c.extend VCR::RSpec::Macros
-    #   end
-    #
-    module Macros
-      def self.extended(base)
-        Kernel.warn "WARNING: VCR::RSpec::Macros is deprecated. Use RSpec metadata options instead `:vcr => vcr_options`"
-      end
-
-      # Sets up a `before` and `after` hook that will insert and eject a
-      # cassette, respectively.
-      #
-      # @example
-      #   describe "Some API Client" do
-      #     use_vcr_cassette "some_api", :record => :new_episodes
-      #   end
-      #
-      # @param [(optional) String] name the cassette name; it will be inferred by the example
-      #  group descriptions if not given.
-      # @param [(optional) Hash] options the cassette options
-      # @deprecated Use RSpec metadata options
-      def use_vcr_cassette(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        name    = args.first || infer_cassette_name
-
-        before(:each) do
-          VCR.insert_cassette(name, options)
-        end
-
-        after(:each) do
-          VCR.eject_cassette
-        end
-      end
-
-      private
-
-      def infer_cassette_name
-        # RSpec 1 exposes #description_parts; use that if its available
-        return description_parts.join("/") if respond_to?(:description_parts)
-
-        # Otherwise use RSpec 2 metadata...
-        group_descriptions = []
-        klass = self
-
-        while klass.respond_to?(:metadata) && klass.metadata
-          group_descriptions << klass.metadata[:example_group][:description]
-          klass = klass.superclass
-        end
-
-        group_descriptions.compact.reverse.join('/')
-      end
-    end
-  end
-end
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/lib/vcr/errors.rb

@@ -1,266 +0,0 @@
-module VCR
-  # Namespace for VCR errors.
-  module Errors
-    # Base class for all VCR errors.
-    class Error                     < StandardError; end
-
-    # Error raised when VCR is turned off while a cassette is in use.
-    # @see VCR#turn_off!
-    # @see VCR#turned_off
-    class CassetteInUseError        < Error; end
-
-    # Error raised when a VCR cassette is inserted while VCR is turned off.
-    # @see VCR#insert_cassette
-    # @see VCR#use_cassette
-    class TurnedOffError            < Error; end
-
-    # Error raised when an cassette ERB template is rendered and a
-    # variable is missing.
-    # @see VCR#insert_cassette
-    # @see VCR#use_cassette
-    class MissingERBVariableError   < Error; end
-
-    # Error raised when the version of one of the libraries that VCR hooks into
-    # is too low for VCR to support.
-    # @see VCR::Configuration#hook_into
-    class LibraryVersionTooLowError < Error; end
-
-    # Error raised when a request matcher is requested that is not registered.
-    class UnregisteredMatcherError  < Error; end
-
-    # Error raised when a VCR 1.x cassette is used with VCR 2.
-    class InvalidCassetteFormatError < Error; end
-
-    # Error raised when an `around_http_request` hook is used improperly.
-    # @see VCR::Configuration#around_http_request
-    class AroundHTTPRequestHookError < Error; end
-
-    # Error raised when you attempt to use a VCR feature that is not
-    # supported on your ruby interpreter.
-    # @see VCR::Configuration#around_http_request
-    class NotSupportedError          < Error; end
-
-    # Error raised when you ask VCR to decode a compressed response
-    # body but the content encoding isn't one of the known ones.
-    # @see VCR::Response#decompress
-    class UnknownContentEncodingError < Error; end
-
-    # Error raised when you eject a cassette before all previously
-    # recorded HTTP interactions are played back.
-    # @note Only applicable when :allow_episode_skipping is false.
-    # @see VCR::HTTPInteractionList#assert_no_unused_interactions!
-    class UnusedHTTPInteractionError < Error; end
-
-    # Error raised when an HTTP request is made that VCR is unable to handle.
-    # @note VCR will raise this to force you to do something about the
-    #  HTTP request. The idea is that you want to handle _every_ HTTP
-    #  request in your test suite. The error message will give you
-    #  suggestions for how to deal with the request.
-    class UnhandledHTTPRequestError < Error
-      # The HTTP request.
-      attr_reader :request
-
-      # Constructs the error.
-      #
-      # @param [VCR::Request] request the unhandled request.
-      def initialize(request)
-        @request = request
-        super construct_message
-      end
-
-    private
-
-      def relish_version_slug
-        @relish_version_slug ||= VCR.version.gsub(/\W/, '-')
-      end
-
-      def construct_message
-        ["", "", "=" * 80,
-         "An HTTP request has been made that VCR does not know how to handle:",
-         "#{request_description}\n",
-         cassette_description,
-         formatted_suggestions,
-         "=" * 80, "", ""].join("\n")
-      end
-
-      def request_description
-        lines = []
-
-        lines << "  #{request.method.to_s.upcase} #{request.uri}"
-
-        if match_request_on_body?
-          lines << "  Body: #{request.body}"
-        end
-
-        lines.join("\n")
-      end
-
-      def match_request_on_body?
-        current_matchers.include?(:body)
-      end
-
-      def current_matchers
-        if VCR.current_cassette
-          VCR.current_cassette.match_requests_on
-        else
-          VCR.configuration.default_cassette_options[:match_requests_on]
-        end
-      end
-
-      def cassette_description
-        if cassette = VCR.current_cassette
-          ["VCR is currently using the following cassette:",
-           "  - #{cassette.file}",
-           "  - :record => #{cassette.record_mode.inspect}",
-           "  - :match_requests_on => #{cassette.match_requests_on.inspect}\n",
-           "Under the current configuration VCR can not find a suitable HTTP interaction",
-           "to replay and is prevented from recording new requests. There are a few ways",
-           "you can deal with this:\n"].join("\n")
-        else
-          ["There is currently no cassette in use. There are a few ways",
-           "you can configure VCR to handle this request:\n"].join("\n")
-        end
-      end
-
-      def formatted_suggestions
-        formatted_points, formatted_foot_notes = [], []
-
-        suggestions.each_with_index do |suggestion, index|
-          bullet_point, foot_note = suggestion.first, suggestion.last
-          formatted_points << format_bullet_point(bullet_point, index)
-          formatted_foot_notes << format_foot_note(foot_note, index)
-        end
-
-        [
-          formatted_points.join("\n"),
-          formatted_foot_notes.join("\n")
-        ].join("\n\n")
-      end
-
-      def format_bullet_point(lines, index)
-        lines.first.insert(0, "  * ")
-        lines.last << " [#{index + 1}]."
-        lines.join("\n    ")
-      end
-
-      def format_foot_note(url, index)
-        "[#{index + 1}] #{url % relish_version_slug}"
-      end
-
-      # List of suggestions for how to configure VCR to handle the request.
-      ALL_SUGGESTIONS = {
-        :use_new_episodes => [
-          ["You can use the :new_episodes record mode to allow VCR to",
-           "record this new request to the existing cassette"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/record-modes/new-episodes"
-        ],
-
-        :delete_cassette_for_once => [
-          ["The current record mode (:once) does not allow new requests to be recorded",
-           "to a previously recorded cassette. You can delete the cassette file and re-run",
-           "your tests to allow the cassette to be recorded with this request"],
-           "https://www.relishapp.com/vcr/vcr/v/%s/docs/record-modes/once"
-        ],
-
-        :deal_with_none => [
-          ["The current record mode (:none) does not allow requests to be recorded. You",
-           "can temporarily change the record mode to :once, delete the cassette file ",
-           "and re-run your tests to allow the cassette to be recorded with this request"],
-           "https://www.relishapp.com/vcr/vcr/v/%s/docs/record-modes/none"
-        ],
-
-        :use_a_cassette => [
-          ["If you want VCR to record this request and play it back during future test",
-           "runs, you should wrap your test (or this portion of your test) in a",
-           "`VCR.use_cassette` block"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/getting-started"
-        ],
-
-        :allow_http_connections_when_no_cassette => [
-          ["If you only want VCR to handle requests made while a cassette is in use,",
-           "configure `allow_http_connections_when_no_cassette = true`. VCR will",
-           "ignore this request since it is made when there is no cassette"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/configuration/allow-http-connections-when-no-cassette"
-        ],
-
-        :ignore_request => [
-          ["If you want VCR to ignore this request (and others like it), you can",
-           "set an `ignore_request` callback"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/configuration/ignore-request"
-        ],
-
-        :allow_playback_repeats => [
-          ["The cassette contains an HTTP interaction that matches this request,",
-           "but it has already been played back. If you wish to allow a single HTTP",
-           "interaction to be played back multiple times, set the `:allow_playback_repeats`",
-           "cassette option"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/request-matching/playback-repeats"
-        ],
-
-        :match_requests_on => [
-          ["The cassette contains %s not been",
-           "played back. If your request is non-deterministic, you may need to",
-           "change your :match_requests_on cassette option to be more lenient",
-           "or use a custom request matcher to allow it to match"],
-           "https://www.relishapp.com/vcr/vcr/v/%s/docs/request-matching"
-        ],
-
-        :try_debug_logger => [
-          ["If you're surprised VCR is raising this error",
-           "and want insight about how VCR attempted to handle the request,",
-           "you can use the debug_logger configuration option to log more details"],
-          "https://www.relishapp.com/vcr/vcr/v/%s/docs/configuration/debug-logging"
-        ]
-      }
-
-      def suggestion_for(key)
-        bullet_point_lines, url = ALL_SUGGESTIONS[key]
-        bullet_point_lines = bullet_point_lines.map(&:dup)
-        url = url.dup
-        [bullet_point_lines, url]
-      end
-
-      def suggestions
-        return no_cassette_suggestions unless cassette = VCR.current_cassette
-
-        [:try_debug_logger, :use_new_episodes, :ignore_request].tap do |suggestions|
-          suggestions.push(*record_mode_suggestion)
-          suggestions << :allow_playback_repeats if cassette.http_interactions.has_used_interaction_matching?(request)
-          suggestions.map! { |k| suggestion_for(k) }
-          suggestions.push(*match_requests_on_suggestion)
-        end
-      end
-
-      def no_cassette_suggestions
-        [:try_debug_logger, :use_a_cassette, :allow_http_connections_when_no_cassette, :ignore_request].map do |key|
-          suggestion_for(key)
-        end
-      end
-
-      def record_mode_suggestion
-        case VCR.current_cassette.record_mode
-        when :none then [:deal_with_none]
-        when :once then [:delete_cassette_for_once]
-        else []
-        end
-      end
-
-      def match_requests_on_suggestion
-        num_remaining_interactions = VCR.current_cassette.http_interactions.remaining_unused_interaction_count
-        return [] if num_remaining_interactions.zero?
-
-        interaction_description = if num_remaining_interactions == 1
-          "1 HTTP interaction that has"
-        else
-          "#{num_remaining_interactions} HTTP interactions that have"
-        end
-
-        description_lines, link = suggestion_for(:match_requests_on)
-        description_lines[0] = description_lines[0] % interaction_description
-        [[description_lines, link]]
-      end
-
-    end
-  end
-end
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/lib/vcr/extensions/net_http_response.rb

@@ -1,36 +0,0 @@
-module VCR
-  # @private
-  module Net
-    # A Net::HTTP response that has already been read raises an IOError when #read_body
-    # is called with a destination string or block.
-    #
-    # This causes a problem when VCR records a response--it reads the body before yielding
-    # the response, and if the code that is consuming the HTTP requests uses #read_body, it
-    # can cause an error.
-    #
-    # This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
-    # after it has aleady been read.  This attemps to preserve the behavior of
-    # #read_body, acting just as if it had never been read.
-    # @private
-    module HTTPResponse
-      def self.extended(response)
-        response.instance_variable_set(:@__read_body_previously_called, false)
-      end
-
-      def read_body(dest = nil, &block)
-        return super if @__read_body_previously_called
-        return @body if dest.nil? && block.nil?
-        raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
-
-        if @body
-          dest ||= ::Net::ReadAdapter.new(block)
-          dest << @body
-          @body = dest
-        end
-      ensure
-        # allow subsequent calls to #read_body to proceed as normal, without our hack...
-        @__read_body_previously_called = true
-      end
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/lib/vcr/library_hooks.rb

@@ -1,18 +0,0 @@
-module VCR
-  # @private
-  class LibraryHooks
-    attr_accessor :exclusive_hook
-
-    def disabled?(hook)
-      ![nil, hook].include?(exclusive_hook)
-    end
-
-    def exclusively_enabled(hook)
-      self.exclusive_hook = hook
-      yield
-    ensure
-      self.exclusive_hook = nil
-    end
-  end
-end
-

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/lib/vcr/library_hooks/excon.rb

@@ -1,27 +0,0 @@
-require 'vcr/middleware/excon'
-
-module VCR
-  class LibraryHooks
-    module Excon
-      # @private
-      def self.configure_middleware
-        middlewares = ::Excon.defaults[:middlewares]
-
-        middlewares << VCR::Middleware::Excon::Request
-        response_parser_index = middlewares.index(::Excon::Middleware::ResponseParser)
-        middlewares.insert(response_parser_index + 1, VCR::Middleware::Excon::Response)
-      end
-
-      configure_middleware
-    end
-  end
-end
-
-VCR.configuration.after_library_hooks_loaded do
-  # ensure WebMock's Excon adapter does not conflict with us here
-  # (i.e. to double record requests or whatever).
-  if defined?(WebMock::HttpLibAdapters::ExconAdapter)
-    WebMock::HttpLibAdapters::ExconAdapter.disable!
-  end
-end
-