songkick-transport 1.2.0 → 1.9.0

data/lib/songkick/transport/headers.rb

@@ -1,21 +1,21 @@
 module Songkick
   module Transport
-    
+
     class Headers
       include Enumerable
-      
+
       def self.new(hash)
         return hash if self === hash
         super
       end
-      
+
       def self.normalize(header_name)
         header_name.
             gsub(/^HTTP_/, '').gsub('_', '-').
             downcase.
             gsub(/(^|-)([a-z])/) { $1 + $2.upcase }
       end
-      
+
       def initialize(hash = {})
         @hash = {}
         hash.each do |key, value|
@@ -23,30 +23,35 @@ module Songkick
           @hash[self.class.normalize(key)] = value
         end
       end
-      
+
       def each(&block)
         @hash.each(&block)
       end
-      
+
       def [](header_name)
         @hash[self.class.normalize(header_name)]
       end
-      
+
       def []=(header_name, value)
         @hash[self.class.normalize(header_name)] = value
       end
-      
+
       def merge(hash)
         headers = self.class.new(to_hash)
         hash.each { |k,v| headers[k] = v }
         headers
       end
-      
+
       def to_hash
         @hash.dup
       end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        to_hash == other.to_hash
+      end
     end
-    
+
   end
 end
 

data/lib/songkick/transport/html_report.html.erb

@@ -55,6 +55,7 @@
 
       #transport-report td.data-footer {
         font-weight: bold;
+        padding-bottom: 10px;
       }
 
       #transport-report td.data-ms {
@@ -109,7 +110,7 @@
             <tr>
               <td class="data-verb"><%= request.verb.upcase %></td>
               <td class="data-path">
-                <% if request.verb == "GET" %>
+                <% if request.verb.upcase == "GET" %>
                   <% nice_params = (request.params.any? ? "?#{request.params.to_a.sort_by {|x,_| x.to_s}.map {|k,v| "#{k}=#{v}"}.join("&") }": "no params") %>
                   <% path = request.path + nice_params  %>
                   <% uri = request.endpoint + path %>
@@ -127,7 +128,10 @@
             </tr>
             <% already[uri] = true %>
           <% end %>
-          <tr><td></td><td></td><td class="data-footer data-ms"><%= hash[:total_duration] %> ms</td></tr>
+          <tr>
+            <td colspan="2" class="data-footer"><%= hash[:requests].size %> request(s)</td>
+            <td class="data-footer data-ms"><%= hash[:total_duration] %> ms</td>
+          </tr>
         </table>
 
         <% end %>

data/lib/songkick/transport/httparty.rb

@@ -2,50 +2,45 @@ require 'httparty'
 
 module Songkick
   module Transport
-    
+
     class HttParty
       def self.new(host, options = {})
-        klass = options[:adapter] || Class.new(Adapter)
-        klass.base_uri(host)
-        klass.default_timeout(options[:timeout] || DEFAULT_TIMEOUT)
-        klass.format(options[:format] || DEFAULT_FORMAT)
-        
-        transport = klass.new
-        transport.user_agent = options[:user_agent]
-        transport.user_error_codes =
-          options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
-        transport
+        adapter_class = options.delete(:adapter) || Adapter
+        adapter_class.base_uri(host)
+        adapter_class.format(options[:format] || DEFAULT_FORMAT)
+        adapter_class.default_timeout(options[:timeout] || DEFAULT_TIMEOUT)
+        adapter_class.new(host, options)
       end
-      
+
       class Adapter < Base
         include HTTParty
-        
+
         def endpoint
           self.class.base_uri
         end
-        
+
         def execute_request(req)
           timeout = req.timeout || self.class.default_options[:timeout]
-          
+
           response = if req.use_body?
             self.class.__send__(req.verb, req.path, :body => req.body, :headers => req.headers, :timeout => timeout)
           else
             self.class.__send__(req.verb, req.url, :headers => req.headers, :timeout => timeout)
           end
-          
+
           process(req, response.code, response.headers, response.parsed_response)
-        
+
         rescue SocketError => error
           logger.warn "Could not connect to host: #{self.class.base_uri}"
           raise ConnectionFailedError, req
-        
+
         rescue Timeout::Error => error
           logger.warn "Request timed out: #{req}"
           raise Transport::TimeoutError, req
 
         rescue UpstreamError => error
           raise error
-        
+
         rescue Object => error
           if error.class.name =~ /json/i or error.message =~ /json/i
             logger.warn("Request returned invalid JSON: #{req}")
@@ -57,7 +52,6 @@ module Songkick
         end
       end
     end
-    
+
   end
 end
-

data/lib/songkick/transport/rack_test.rb

@@ -3,52 +3,37 @@ require 'timeout'
 
 module Songkick
   module Transport
-    
+
     class RackTest < Base
       class Client
         attr_reader :app
         include Rack::Test::Methods
-        
+
         def initialize(app)
           @app = app
         end
       end
-      
+
       def initialize(app, options = {})
-        @app     = app
-        @timeout = options[:timeout] || DEFAULT_TIMEOUT
-        @user_error_codes = options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
+        super(nil, options)
+        @app = app
       end
-      
-      HTTP_VERBS.each do |verb|
-        class_eval %{
-          def #{verb}(path, params = {}, head = {}, timeout = nil)
-            client  = Client.new(@app)
-            start   = Time.now
-            request = Request.new(@app, '#{verb}', path, params, headers.merge(head), timeout)
-            result  = nil
-            
-            Timeout.timeout(timeout || @timeout) do
-              request.headers.each { |key, value| client.header(key, value) }
-              response = client.#{verb}(path, params)
-              request.response = process("\#{path}, \#{params.inspect}", response.status, response.headers, response.body)
-              Reporting.record(request)
-              request.response
-            end
-
-          rescue UpstreamError => error
-            request.error = error
-            Reporting.record(request)
-            raise error
-          
-          rescue Object => error
-            logger.warn(error.message)
-            raise UpstreamError, request
-          end
-        }
+
+      def endpoint
+        @app
       end
+
+      def execute_request(req)
+        client = Client.new(@app)
+
+        Timeout.timeout(req.timeout || @timeout) do
+          req.headers.each { |key, value| client.header(key, value) }
+          response = client.__send__(req.verb, req.path, req.params)
+          process(req, response.status, response.headers, response.body)
+        end
+      end
+
     end
-    
+
   end
 end
-

data/lib/songkick/transport/reporting.rb

@@ -27,7 +27,7 @@ module Songkick
         response = request.response
         duration = (Time.now.to_f - request.start_time.to_f) * 1000
         logger.info "Response status: #{response.status}, duration: #{duration.ceil}ms"
-        logger.debug "Response data: #{response.data.inspect}"
+        logger.debug { "Response data: #{response.data.inspect}" }
       end
 
       def self.logger
@@ -67,4 +67,3 @@ module Songkick
 
   end
 end
-

data/lib/songkick/transport/request.rb

@@ -1,6 +1,6 @@
 module Songkick
   module Transport
-    
+
     class Request
       attr_reader :endpoint,
                   :verb,
@@ -10,9 +10,9 @@ module Songkick
                   :start_time,
                   :response,
                   :error
-      
+
       alias :http_method :verb
-      
+
       def initialize(endpoint, verb, path, params, headers = {}, timeout = DEFAULT_TIMEOUT)
         @endpoint   = endpoint
         @verb       = verb.to_s.downcase
@@ -22,39 +22,39 @@ module Songkick
         @timeout    = timeout
         @start_time = start_time || Time.now
         @multipart  = Serialization.multipart?(params)
-        
+
         if use_body?
           @headers['Content-Type'] ||= @multipart ? multipart_request[:content_type] : FORM_ENCODING
         end
       end
-      
+
       def response=(response)
         @response = response
         @end_time = Time.now
       end
-      
+
       def error=(error)
         @error = error
         @end_time = Time.now
       end
-      
+
       def duration
         return nil unless @end_time
         (@end_time.to_f - @start_time.to_f) * 1000
       end
-      
+
       def headers
         @headers.to_hash
       end
-      
+
       def use_body?
         USE_BODY.include?(@verb)
       end
-      
+
       def multipart?
         @multipart
       end
-      
+
       def body
         return nil unless use_body?
         if @multipart
@@ -63,16 +63,16 @@ module Songkick
           Serialization.build_query_string(params)
         end
       end
-      
+
       def url
         Serialization.build_url(@verb, @endpoint, @path, @params)
       end
-      
+
       def to_s
         url = String === @endpoint ?
               Serialization.build_url(@verb, @endpoint, @path, @params, true) :
               @endpoint.to_s
-        
+
         command = "#{@verb.upcase} '#{url}'"
         @headers.each do |key, value|
           value = Serialization::SANITIZED_VALUE if Serialization.sanitize?(key)
@@ -83,15 +83,14 @@ module Songkick
         command << " -d '#{query}'"
         command
       end
-      
+
     private
-      
+
       def multipart_request
         return nil unless @multipart
         @multipart_request ||= Serialization.serialize_multipart(params)
       end
     end
-    
+
   end
 end
-

data/lib/songkick/transport/response.rb

@@ -1,6 +1,6 @@
 module Songkick
   module Transport
-    
+
     class Response
       def self.process(request, status, headers, body, user_error_codes=409)
         case status.to_i
@@ -23,26 +23,25 @@ module Songkick
         content_type = (content_type || '').split(/\s*;\s*/).first
         Transport.parser_for(content_type).parse(body)
       end
-      
+
       attr_reader :body, :data, :headers, :status
-      
+
       def initialize(status, headers, body)
         @body    = body
         @data    = Response.parse(body, headers['Content-Type'])
         @headers = Headers.new(headers)
         @status  = status.to_i
       end
-      
+
       def errors
         data && data['errors']
       end
-    
+
       class OK        < Response ; end
       class Created   < Response ; end
       class NoContent < Response ; end
       class UserError < Response ; end
     end
-    
+
   end
 end
-

data/lib/songkick/transport/service.rb

@@ -1,6 +1,34 @@
 module Songkick
   module Transport
     class Service
+      DEFAULT_TIMEOUT = 10
+      DEFAULT_TRANSPORT = Songkick::Transport::Curb
+
+      def self.ancestor
+        warn "DEPRECATED: calling ancestor on #{self}"
+        self.ancestors.select { |a| a.respond_to?(:get_user_agent) }[1]
+      end
+
+      def self.stub_transport(stub)
+        warn "DEPRECATED: calling stub_transport on #{self}"
+        @stub_transport = stub
+      end
+
+      def self.extra_headers
+        warn "DEPRECATED: calling extra_headers on #{self}"
+        get_with_headers
+      end
+
+      def self.this_extra_headers
+        warn "DEPRECATED: calling this_extra_headers on #{self}"
+        @with_headers || {}
+      end
+
+      def self.parent_service
+        superclass if superclass <= Songkick::Transport::Service
+      end
+      private_class_method :parent_service
+
       def self.endpoint(name)
         @endpoint_name = name.to_s
       end
@@ -17,8 +45,8 @@ module Songkick
         @transport_layer = value
       end
 
-      def self.stub_transport(stub)
-        @stub_transport = stub
+      def self.transport_layer_options(value)
+        @transport_layer_options = value
       end
 
       def self.set_endpoints(hash)
@@ -28,20 +56,16 @@ module Songkick
         @endpoints = hash
       end
 
-      def self.ancestor
-        self.ancestors.select {|a| a.respond_to?(:get_user_agent)}[1]
-      end
-
       def self.get_endpoint_name
-        @endpoint_name || (ancestor && ancestor.get_endpoint_name)
+        @endpoint_name || (parent_service && parent_service.get_endpoint_name)
       end
 
       def self.get_timeout
-        @timeout || (ancestor && ancestor.get_timeout) || 10
+        @timeout || (parent_service && parent_service.get_timeout) || DEFAULT_TIMEOUT
       end
 
       def self.get_user_agent
-        @user_agent || (ancestor && ancestor.get_user_agent)
+        @user_agent || (parent_service && parent_service.get_user_agent)
       end
 
       def self.get_endpoints
@@ -49,11 +73,19 @@ module Songkick
       end
 
       def self.get_transport_layer
-        @transport_layer || (ancestor && ancestor.get_transport_layer) || Songkick::Transport::Curb
+        @transport_layer || (parent_service && parent_service.get_transport_layer) || DEFAULT_TRANSPORT
+      end
+
+      def self.get_transport_layer_options
+        ((parent_service && parent_service.get_transport_layer_options) || {}).merge(@transport_layer_options || {})
       end
 
       def self.get_stub_transport
-        @stub_transport || (ancestor && ancestor.get_stub_transport) || nil
+        @stub_transport || (parent_service && parent_service.get_stub_transport) || nil
+      end
+
+      def self.get_with_headers
+        ((parent_service && parent_service.get_with_headers) || {}).merge(@with_headers || {})
       end
 
       def self.new_transport
@@ -66,12 +98,17 @@ module Songkick
         unless user_agent = get_user_agent
           raise "no user agent specified for #{self}, call user_agent 'foo' inside #{self} or on Songkick::Transport::Service"
         end
-        get_stub_transport || get_transport_layer.new(endpoint, :user_agent => user_agent, 
-                                                                :timeout    => get_timeout)
+        get_stub_transport || get_transport_layer.new(endpoint, { :user_agent => user_agent, :timeout => get_timeout }.merge(get_transport_layer_options))
+      end
+
+      def self.with_headers(headers)
+        @with_headers = headers
       end
 
       def http
-        @http ||= self.class.new_transport
+        r = (@http ||= self.class.new_transport)
+        r.with_headers(self.class.get_with_headers) if !self.class.get_with_headers.empty?
+        r
       end
 
       def stub_transport(http)