framed_rails 0.1.0

data/vendor/gems/excon-0.45.3/lib/excon/errors.rb

@@ -0,0 +1,155 @@
+module Excon
+  module Errors
+
+    class Error < StandardError; end
+    class StubNotFound < StandardError; end
+    class InvalidStub < StandardError; end
+
+    class SocketError < Error
+      attr_reader :socket_error
+
+      def initialize(socket_error=Excon::Error.new)
+        if socket_error.message =~ /certificate verify failed/
+          super("Unable to verify certificate, please set `Excon.defaults[:ssl_ca_path] = path_to_certs`, `ENV['SSL_CERT_DIR'] = path_to_certs`, `Excon.defaults[:ssl_ca_file] = path_to_file`, `ENV['SSL_CERT_FILE'] = path_to_file`, `Excon.defaults[:ssl_verify_callback] = callback` (see OpenSSL::SSL::SSLContext#verify_callback), or `Excon.defaults[:ssl_verify_peer] = false` (less secure).")
+        else
+          super("#{socket_error.message} (#{socket_error.class})")
+        end
+        set_backtrace(socket_error.backtrace)
+        @socket_error = socket_error
+      end
+    end
+
+    class Timeout < Error; end
+
+    class ResponseParseError < Error; end
+
+    class ProxyParseError < Error; end
+
+    class ProxyConnectionError < Error; end
+
+    class HTTPStatusError < Error
+      attr_reader :request, :response
+
+      def initialize(msg, request = nil, response = nil)
+        super(msg)
+        @request = request
+        @response = response
+      end
+    end
+
+    # HTTP Error classes
+    class Informational < HTTPStatusError; end
+    class Success < HTTPStatusError; end
+    class Redirection < HTTPStatusError; end
+    class ClientError < HTTPStatusError; end
+    class ServerError < HTTPStatusError; end
+
+    class Continue < Informational; end                       # 100
+    class SwitchingProtocols < Informational; end             # 101
+    class OK < Success; end                                   # 200
+    class Created < Success; end                              # 201
+    class Accepted < Success; end                             # 202
+    class NonAuthoritativeInformation < Success; end          # 203
+    class NoContent < Success; end                            # 204
+    class ResetContent < Success; end                         # 205
+    class PartialContent < Success; end                       # 206
+    class MultipleChoices < Redirection; end                  # 300
+    class MovedPermanently < Redirection; end                 # 301
+    class Found < Redirection; end                            # 302
+    class SeeOther < Redirection; end                         # 303
+    class NotModified < Redirection; end                      # 304
+    class UseProxy < Redirection; end                         # 305
+    class TemporaryRedirect < Redirection; end                # 307
+    class BadRequest < ClientError; end                       # 400
+    class Unauthorized < ClientError; end                     # 401
+    class PaymentRequired < ClientError; end                  # 402
+    class Forbidden < ClientError; end                        # 403
+    class NotFound < ClientError; end                         # 404
+    class MethodNotAllowed < ClientError; end                 # 405
+    class NotAcceptable < ClientError; end                    # 406
+    class ProxyAuthenticationRequired < ClientError; end      # 407
+    class RequestTimeout < ClientError; end                   # 408
+    class Conflict < ClientError; end                         # 409
+    class Gone < ClientError; end                             # 410
+    class LengthRequired < ClientError; end                   # 411
+    class PreconditionFailed < ClientError; end               # 412
+    class RequestEntityTooLarge < ClientError; end            # 413
+    class RequestURITooLong < ClientError; end                # 414
+    class UnsupportedMediaType < ClientError; end             # 415
+    class RequestedRangeNotSatisfiable < ClientError; end     # 416
+    class ExpectationFailed < ClientError; end                # 417
+    class UnprocessableEntity < ClientError; end              # 422
+    class TooManyRequests < ClientError; end                  # 429
+    class InternalServerError < ServerError; end              # 500
+    class NotImplemented < ServerError; end                   # 501
+    class BadGateway < ServerError; end                       # 502
+    class ServiceUnavailable < ServerError; end               # 503
+    class GatewayTimeout < ServerError; end                   # 504
+
+    # Messages for nicer exceptions, from rfc2616
+    def self.status_error(request, response)
+      @errors ||= {
+        100 => [Excon::Errors::Continue, 'Continue'],
+        101 => [Excon::Errors::SwitchingProtocols, 'Switching Protocols'],
+        200 => [Excon::Errors::OK, 'OK'],
+        201 => [Excon::Errors::Created, 'Created'],
+        202 => [Excon::Errors::Accepted, 'Accepted'],
+        203 => [Excon::Errors::NonAuthoritativeInformation, 'Non-Authoritative Information'],
+        204 => [Excon::Errors::NoContent, 'No Content'],
+        205 => [Excon::Errors::ResetContent, 'Reset Content'],
+        206 => [Excon::Errors::PartialContent, 'Partial Content'],
+        300 => [Excon::Errors::MultipleChoices, 'Multiple Choices'],
+        301 => [Excon::Errors::MovedPermanently, 'Moved Permanently'],
+        302 => [Excon::Errors::Found, 'Found'],
+        303 => [Excon::Errors::SeeOther, 'See Other'],
+        304 => [Excon::Errors::NotModified, 'Not Modified'],
+        305 => [Excon::Errors::UseProxy, 'Use Proxy'],
+        307 => [Excon::Errors::TemporaryRedirect, 'Temporary Redirect'],
+        400 => [Excon::Errors::BadRequest, 'Bad Request'],
+        401 => [Excon::Errors::Unauthorized, 'Unauthorized'],
+        402 => [Excon::Errors::PaymentRequired, 'Payment Required'],
+        403 => [Excon::Errors::Forbidden, 'Forbidden'],
+        404 => [Excon::Errors::NotFound, 'Not Found'],
+        405 => [Excon::Errors::MethodNotAllowed, 'Method Not Allowed'],
+        406 => [Excon::Errors::NotAcceptable, 'Not Acceptable'],
+        407 => [Excon::Errors::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
+        408 => [Excon::Errors::RequestTimeout, 'Request Timeout'],
+        409 => [Excon::Errors::Conflict, 'Conflict'],
+        410 => [Excon::Errors::Gone, 'Gone'],
+        411 => [Excon::Errors::LengthRequired, 'Length Required'],
+        412 => [Excon::Errors::PreconditionFailed, 'Precondition Failed'],
+        413 => [Excon::Errors::RequestEntityTooLarge, 'Request Entity Too Large'],
+        414 => [Excon::Errors::RequestURITooLong, 'Request-URI Too Long'],
+        415 => [Excon::Errors::UnsupportedMediaType, 'Unsupported Media Type'],
+        416 => [Excon::Errors::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
+        417 => [Excon::Errors::ExpectationFailed, 'Expectation Failed'],
+        422 => [Excon::Errors::UnprocessableEntity, 'Unprocessable Entity'],
+        429 => [Excon::Errors::TooManyRequests, 'Too Many Requests'],
+        500 => [Excon::Errors::InternalServerError, 'InternalServerError'],
+        501 => [Excon::Errors::NotImplemented, 'Not Implemented'],
+        502 => [Excon::Errors::BadGateway, 'Bad Gateway'],
+        503 => [Excon::Errors::ServiceUnavailable, 'Service Unavailable'],
+        504 => [Excon::Errors::GatewayTimeout, 'Gateway Timeout']
+      }
+
+      error_class, error_message = @errors[response[:status]] || [Excon::Errors::HTTPStatusError, 'Unknown']
+
+      message = StringIO.new
+      message.puts("Expected(#{request[:expects].inspect}) <=> Actual(#{response[:status]} #{error_message})")
+
+      if request[:debug_request]
+        message.puts('excon.error.request')
+        Excon::PrettyPrinter.pp(message, request)
+      end
+
+      if request[:debug_response]
+        message.puts('excon.error.response')
+        Excon::PrettyPrinter.pp(message, response.data)
+      end
+
+      message.rewind
+      error_class.new(message.read, request, response)
+    end
+
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/extensions/uri.rb

@@ -0,0 +1,33 @@
+# TODO: Remove this monkey patch once ruby 1.9.3+ is the minimum supported version.
+#
+# This patch backports URI#hostname to ruby 1.9.2 and older.
+# URI#hostname is used for IPv6 support in Excon.
+#
+# URI#hostname was added in stdlib in v1_9_3_0 in this commit:
+#   https://github.com/ruby/ruby/commit/5fd45a4b79dd26f9e7b6dc41142912df911e4d7d
+#
+# Addressable::URI is also an URI parser accepted in some parts of Excon.
+# Addressable::URI#hostname was added in addressable-2.3.5+ in this commit:
+#   https://github.com/sporkmonger/addressable/commit/1b94abbec1f914d5f707c92a10efbb9e69aab65e
+#
+# Users who want to use Addressable::URI to parse URIs must upgrade to 2.3.5 or newer.
+require 'uri'
+unless URI("http://foo/bar").respond_to?(:hostname)
+  module URI
+    class Generic
+      # extract the host part of the URI and unwrap brackets for IPv6 addresses.
+      #
+      # This method is same as URI::Generic#host except
+      # brackets for IPv6 (and future IP) addresses are removed.
+      #
+      # u = URI("http://[::1]/bar")
+      # p u.hostname      #=> "::1"
+      # p u.host          #=> "[::1]"
+      #
+      def hostname
+        v = self.host
+        /\A\[(.*)\]\z/ =~ v ? $1 : v
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/headers.rb

@@ -0,0 +1,83 @@
+module Excon
+  class Headers < Hash
+
+    SENTINEL = {}
+
+    alias_method :raw_writer, :[]=
+    alias_method :raw_reader, :[]
+    if SENTINEL.respond_to?(:assoc)
+      alias_method :raw_assoc, :assoc
+    end
+    alias_method :raw_delete, :delete
+    alias_method :raw_fetch, :fetch
+    alias_method :raw_has_key?, :has_key?
+    alias_method :raw_include?, :include?
+    alias_method :raw_key?, :key?
+    alias_method :raw_member?, :member?
+    alias_method :raw_merge, :merge
+    alias_method :raw_merge!, :merge!
+    alias_method :raw_rehash, :rehash
+    alias_method :raw_store, :store
+    alias_method :raw_values_at, :values_at
+
+    def initialize
+      @downcased = {}
+    end
+
+    def [](key)
+      @downcased[key.to_s.downcase]
+    end
+
+    alias_method :[]=, :store
+    def []=(key, value)
+      raw_writer(key, value)
+      @downcased[key.to_s.downcase] = value
+    end
+
+    if SENTINEL.respond_to? :assoc
+      def assoc(obj)
+        @downcased.assoc(obj.downcase)
+      end
+    end
+
+    def delete(key, &proc)
+      raw_delete(key, &proc)
+      @downcased.delete(key.to_s.downcase, &proc)
+    end
+
+    def fetch(key, default = nil, &proc)
+      if proc
+        @downcased.fetch(key.to_s.downcase, &proc)
+      else
+        @downcased.fetch(key.to_s.downcase, default)
+      end
+    end
+
+    alias_method :has_key?, :key?
+    alias_method :has_key?, :member?
+    def has_key?(key)
+      raw_key?(key) || @downcased.has_key?(key.to_s.downcase)
+    end
+
+    def merge(other_hash)
+      self.dup.merge!(other_hash)
+    end
+
+    def merge!(other_hash)
+      other_hash.each do |key, value|
+        self[key] = value
+      end
+      raw_merge!(other_hash)
+    end
+
+    def rehash
+      @downcased.rehash
+      raw_rehash
+    end
+
+    def values_at(*keys)
+      @downcased.values_at(*keys.map {|key| key.to_s.downcase})
+    end
+
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/base.rb

@@ -0,0 +1,24 @@
+module Excon
+  module Middleware
+    class Base
+      def initialize(stack)
+        @stack = stack
+      end
+
+      def error_call(datum)
+        # do stuff
+        @stack.error_call(datum)
+      end
+
+      def request_call(datum)
+        # do stuff
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        @stack.response_call(datum)
+        # do stuff
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/decompress.rb

@@ -0,0 +1,35 @@
+module Excon
+  module Middleware
+    class Decompress < Excon::Middleware::Base
+      def request_call(datum)
+        unless datum.has_key?(:response_block)
+          key = datum[:headers].keys.detect {|k| k.to_s.casecmp('Accept-Encoding') == 0 } || 'Accept-Encoding'
+          if datum[:headers][key].to_s.empty?
+            datum[:headers][key] = 'deflate, gzip'
+          end
+        end
+        @stack.request_call(datum)
+      end
+
+      def response_call(datum)
+        unless datum.has_key?(:response_block)
+          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Encoding') == 0 }
+            encodings = Utils.split_header_value(datum[:response][:headers][key])
+            if encoding = encodings.last
+              if encoding.casecmp('deflate') == 0
+                # assume inflate omits header
+                datum[:response][:body] = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(datum[:response][:body])
+                encodings.pop
+              elsif encoding.casecmp('gzip') == 0 || encoding.casecmp('x-gzip') == 0
+                datum[:response][:body] = Zlib::GzipReader.new(StringIO.new(datum[:response][:body])).read
+                encodings.pop
+              end
+              datum[:response][:headers][key] = encodings.join(', ')
+            end
+          end
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/escape_path.rb

@@ -0,0 +1,11 @@
+module Excon
+  module Middleware
+    class EscapePath < Excon::Middleware::Base
+      def request_call(datum)
+        # make sure path is encoded, prevent double encoding
+        datum[:path] = Excon::Utils.escape_uri(Excon::Utils.unescape_uri(datum[:path]))
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/expects.rb

@@ -0,0 +1,18 @@
+module Excon
+  module Middleware
+    class Expects < Excon::Middleware::Base
+      def response_call(datum)
+        if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
+          raise(
+            Excon::Errors.status_error(
+              datum.reject {|key,value| key == :response},
+              Excon::Response.new(datum[:response])
+            )
+          )
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/idempotent.rb

@@ -0,0 +1,33 @@
+module Excon
+  module Middleware
+    class Idempotent < Excon::Middleware::Base
+      def error_call(datum)
+        if datum[:idempotent]
+          if datum.has_key?(:request_block)
+            if datum[:request_block].respond_to?(:rewind)
+              datum[:request_block].rewind
+            else
+              Excon.display_warning('Excon requests with a :request_block must implement #rewind in order to be :idempotent.')
+              datum[:idempotent] = false
+            end
+          end
+          if datum.has_key?(:pipeline)
+            Excon.display_warning("Excon requests can not be :idempotent when pipelining.")
+            datum[:idempotent] = false
+          end
+        end
+
+        if datum[:idempotent] && [Excon::Errors::Timeout, Excon::Errors::SocketError,
+            Excon::Errors::HTTPStatusError].any? {|ex| datum[:error].kind_of?(ex) } && datum[:retries_remaining] > 1
+          # reduces remaining retries, reset connection, and restart request_call
+          datum[:retries_remaining] -= 1
+          connection = datum.delete(:connection)
+          datum.reject! {|key, _| !Excon::VALID_REQUEST_KEYS.include?(key) }
+          connection.request(datum)
+        else
+          @stack.error_call(datum)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/instrumentor.rb

@@ -0,0 +1,34 @@
+module Excon
+  module Middleware
+    class Instrumentor < Excon::Middleware::Base
+      def error_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.error", :error => datum[:error])
+        end
+        @stack.error_call(datum)
+      end
+
+      def request_call(datum)
+        if datum.has_key?(:instrumentor)
+          if datum[:retries_remaining] < datum[:retry_limit]
+            event_name = "#{datum[:instrumentor_name]}.retry"
+          else
+            event_name = "#{datum[:instrumentor_name]}.request"
+          end
+          datum[:instrumentor].instrument(event_name, datum) do
+            @stack.request_call(datum)
+          end
+        else
+          @stack.request_call(datum)
+        end
+      end
+
+      def response_call(datum)
+        if datum.has_key?(:instrumentor)
+          datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", datum[:response])
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/mock.rb

@@ -0,0 +1,51 @@
+module Excon
+  module Middleware
+    class Mock < Excon::Middleware::Base
+      def request_call(datum)
+        if datum[:mock]
+          # convert File/Tempfile body to string before matching:
+          if datum[:body].respond_to?(:read)
+           if datum[:body].respond_to?(:binmode)
+             datum[:body].binmode
+           end
+           if datum[:body].respond_to?(:rewind)
+             datum[:body].rewind
+           end
+           datum[:body] = datum[:body].read
+          elsif !datum[:body].nil? && !datum[:body].is_a?(String)
+            raise Excon::Errors::InvalidStub.new("Request body should be a string or an IO object. #{datum[:body].class} provided")
+          end
+
+          if stub = Excon.stub_for(datum)
+            datum[:response] = {
+              :body       => '',
+              :headers    => {},
+              :status     => 200,
+              :remote_ip  => '127.0.0.1'
+            }
+
+            stub_datum = case stub.last
+            when Proc
+              stub.last.call(datum)
+            else
+              stub.last
+            end
+
+            datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
+            if stub_datum.has_key?(:headers)
+              datum[:response][:headers].merge!(stub_datum[:headers])
+            end
+          else
+            # if we reach here no stubs matched
+            message = StringIO.new
+            message.puts('no stubs matched')
+            Excon::PrettyPrinter.pp(message, datum)
+            raise(Excon::Errors::StubNotFound.new(message.string))
+          end
+        end
+
+        @stack.request_call(datum)
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/redirect_follower.rb

@@ -0,0 +1,56 @@
+module Excon
+  module Middleware
+    class RedirectFollower < Excon::Middleware::Base
+      def response_call(datum)
+        if datum.has_key?(:response)
+          case datum[:response][:status]
+          when 301, 302, 303, 307, 308
+            uri_parser = datum[:uri_parser] || Excon.defaults[:uri_parser]
+            _, location = datum[:response][:headers].detect do |key, value|
+              key.casecmp('Location') == 0
+            end
+            uri = uri_parser.parse(location)
+
+            # delete old/redirect response
+            response = datum.delete(:response)
+
+            params = datum.dup
+            params.delete(:connection)
+            params.delete(:password)
+            params.delete(:stack)
+            params.delete(:user)
+
+            if [301, 302, 303].include?(response[:status])
+              params[:method] = :get
+              params.delete(:body)
+              params[:headers].delete('Content-Length')
+            end
+            params[:headers] = datum[:headers].dup
+            params[:headers].delete('Authorization')
+            params[:headers].delete('Proxy-Connection')
+            params[:headers].delete('Proxy-Authorization')
+            params[:headers].delete('Host')
+            params.merge!(
+              :scheme     => uri.scheme || datum[:scheme],
+              :host       => uri.host   || datum[:host],
+              :hostname   => uri.hostname || datum[:hostname],
+              :port       => uri.port   || datum[:port],
+              :path       => uri.path,
+              :query      => uri.query
+            )
+
+            params.merge!(:user => Utils.unescape_uri(uri.user)) if uri.user
+            params.merge!(:password => Utils.unescape_uri(uri.password)) if uri.password
+
+            response = Excon::Connection.new(params).request
+            datum.merge!({:response => response.data})
+          else
+            @stack.response_call(datum)
+          end
+        else
+          @stack.response_call(datum)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/middlewares/response_parser.rb

@@ -0,0 +1,12 @@
+module Excon
+  module Middleware
+    class ResponseParser < Excon::Middleware::Base
+      def response_call(datum)
+        unless datum.has_key?(:response)
+          datum = Excon::Response.parse(datum[:connection].send(:socket), datum)
+        end
+        @stack.response_call(datum)
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/pretty_printer.rb

@@ -0,0 +1,45 @@
+module Excon
+  class PrettyPrinter
+    def self.pp(io, datum, indent=0)
+      datum = datum.dup
+
+      # reduce duplication/noise of output
+      unless datum.is_a?(Excon::Headers)
+        datum.delete(:connection)
+        datum.delete(:stack)
+
+        if datum.has_key?(:headers) && datum[:headers].has_key?('Authorization')
+          datum[:headers] = datum[:headers].dup
+          datum[:headers]['Authorization'] = REDACTED
+        end
+
+        if datum.has_key?(:password)
+          datum[:password] = REDACTED
+        end
+      end
+
+      indent += 2
+      max_key_length = datum.keys.map {|key| key.inspect.length}.max
+      datum.keys.sort_by {|key| key.to_s}.each do |key|
+        value = datum[key]
+        io.write("#{' ' * indent}#{key.inspect.ljust(max_key_length)} => ")
+        case value
+        when Array
+          io.puts("[")
+          value.each do |v|
+            io.puts("#{' ' * indent}  #{v.inspect}")
+          end
+          io.write("#{' ' * indent}]")
+        when Hash
+          io.puts("{")
+          self.pp(io, value, indent)
+          io.write("#{' ' * indent}}")
+        else
+          io.write("#{value.inspect}")
+        end
+        io.puts
+      end
+      indent -= 2
+    end
+  end
+end