cp-sparrow 0.0.12 → 0.0.14

data/lib/sparrow/request_http_message.rb

@@ -0,0 +1,22 @@
+module Sparrow
+  class RequestHttpMessage < HttpMessage
+    ##
+    # @return [Hash] The HTTP Headers
+    def headers_hash
+      env
+    end
+
+    ##
+    # @return [String] the request's path
+    def path
+      request.path || super
+    end
+
+    ##
+    # The HTTP Content Type Field
+    # @return [String] the HTTP Content Type
+    def content_type
+      request.content_type || super
+    end
+  end
+end

data/lib/sparrow/request_middleware.rb

@@ -1,5 +1,3 @@
-require 'sparrow/middleware'
-
 module Sparrow
   class RequestMiddleware < Middleware
     def convert(env)
@@ -9,21 +7,21 @@ module Sparrow
     end
 
     def content_type
-      my_content_type = request.content_type ||
-          last_env['CONTENT-TYPE'] ||
-          last_env['Content-Type'] ||
-          last_env['CONTENT_TYPE']
-
-      my_content_type.present? ? my_content_type : nil
+      http_message.content_type.presence
     end
 
     def strategy
-      if is_processable? && last_env[Strategies::FormHash::REQUEST_FORM_HASH_KEY]
-        Rails.logger.debug 'Choosing strategy FormHash' if defined? Rails
+      if steward.has_processable_http_message? &&
+          http_message.form_hash?
+        Sparrow.logger.debug 'Choosing strategy FormHash'
         Strategies::FormHash
       else
         super
       end
     end
+
+    def http_message
+      RequestHttpMessage.new(last_env)
+    end
   end
 end

data/lib/sparrow/response_http_message.rb

@@ -0,0 +1,49 @@
+module Sparrow
+  class ResponseHttpMessage < HttpMessage
+    ##
+    # @return [Integer] the HTTP Response Code status
+    attr_accessor :status
+
+    ##
+    # @return the HTTP response body
+    attr_accessor :body
+
+    ##
+    # @return the HTTP header after the middleware was called
+    attr_accessor :headers
+
+    ##
+    # The wrapped Response instance
+    # @return [Object] the response
+    def response
+      clazz = response_class
+      @response ||= if clazz.name == 'ActionDispatch::Response'
+                      clazz.new(status, headers_hash, body)
+                    else
+                      clazz.new(body, status, headers_hash)
+                    end
+    end
+
+    def path
+      super
+    end
+
+    def content_type
+      response.content_type.presence || super
+    end
+
+    private
+
+    def response_class
+      if defined?(Rails)
+        ActionDispatch::Response
+      else
+        ::Rack::Response
+      end
+    end
+
+    def headers_hash
+      @headers_hash ||= env.merge(headers)
+    end
+  end
+end

data/lib/sparrow/response_middleware.rb

@@ -1,44 +1,48 @@
-require 'active_support/core_ext/object/inclusion'
-require 'sparrow/middleware'
-require 'sparrow/strategies/json_format_strategies/json_format_strategy'
-
 module Sparrow
+  ##
+  # Handles the Response conversion
   class ResponseMiddleware < Middleware
+    ##
+    # This call ends the rack chain
+    # @param [Hash] env the Rack environment
+    # @return [Array<String, Hash, Array<String>>] the Rack return Array
     def call(env)
       @last_env                = env
-      @status, @headers, @body = @app.call(env)
+      @status, @headers, @body = app.call(env)
       [status, headers, converted_response_body]
     end
 
+    private
+
+    def steward
+      ResponseSteward.new(http_message,
+                          allowed_content_types:  Sparrow.configuration.allowed_content_types,
+                          allowed_accepts:        Sparrow.configuration.allowed_accepts,
+                          excluded_routes:        Sparrow.configuration.excluded_routes,
+                          ignored_response_codes: Sparrow.configuration.ignored_response_codes)
+    end
+
+
     def converted_response_body
+      # return the original body if we are not going to process it
+      return body unless steward.has_processable_http_message?
+
       response_body = Sparrow::Strategies::JsonFormatStrategy.convert(body)
 
-      # just pass the response if something went wrong inside the application
-      return response_body if unprocessable_status?
-
-      if response_body.present?
-        response_strategy = strategy.new(last_env, :response, response_body)
-        response_strategy.handle
-
-        if response_body.is_a?(Array) then
-          response_body
-        else
-          Array(response_strategy.json_body)
-        end
-      else
-        []
-      end
-    end
+      return [] if response_body.blank?
 
-    def unprocessable_status?
-      @status.in?(500..511) || @status == 404
+      @headers.delete 'Content-Length'
+      response_strategy = strategy.new(last_env, :response, response_body)
+      response_strategy.handle
+      Array(response_strategy.json_body)
     end
 
-    def content_type
-      headers['Content-Type'].split(';').first #||
-          # last_env['CONTENT-TYPE'] ||
-          # last_env['Content-Type'] ||
-          # last_env['CONTENT_TYPE']
+    def http_message
+      response_message         = ResponseHttpMessage.new(last_env)
+      response_message.status  = status
+      response_message.body    = body
+      response_message.headers = headers
+      response_message
     end
   end
 end

data/lib/sparrow/response_steward.rb

@@ -0,0 +1,13 @@
+module Sparrow
+  class ResponseSteward < Steward
+    def has_processable_http_message?
+      super && processable_status?
+    end
+
+    private
+
+    def processable_status?
+      !http_message.status.in?(ignored_response_codes)
+    end
+  end
+end

data/lib/sparrow/route_parser.rb

@@ -1,12 +1,16 @@
-require 'active_support/core_ext/string/starts_ends_with'
-require 'sparrow/path_normalizer'
-
 module Sparrow
+  ##
+  # Simple class the takes a list of routes and provides check methods
+  # to determine if a path is excluded (ignored) or not, i.e.
+  # the path is within the list as defined on initialization.
   class RouteParser
-    include PathNormalizer
-
     attr_accessor :excluded_routes
 
+    ##
+    # Create a new Routeparser.
+    # @param [Array<String, Regexp>] excluded_routes A list of routes (path)
+    #   that shall not be parsed.
+    #   Each route +must+ not start with a leading slash (/).
     def initialize(excluded_routes = Sparrow.configuration.excluded_routes)
       self.excluded_routes = excluded_routes.map do |route|
         if route.is_a?(Regexp)
@@ -17,10 +21,23 @@ module Sparrow
       end
     end
 
+    ##
+    # States if the given path is +not+ within the excluded_routes
+    #
+    # @param [String] path the path to be checked
+    # @return [Boolean] path allowed
+    # @see #exclude?
+    # @see #excluded_routes
     def allow?(path)
       not exclude?(path)
     end
 
+    ##
+    # States if the given path is within the excluded_routes, i.e. it may be
+    # ignored when parsing.
+    #
+    # @param [String] path the path to be checked
+    # @return [Boolean] is path excluded
     def exclude?(path)
       normalized_path = normalize_path(path)
       excluded_routes.each do |route|
@@ -28,5 +45,11 @@ module Sparrow
       end
       return false
     end
+
+    private
+    def normalize_path(path)
+      path[/./m] = '' if path.to_s.starts_with?('/')
+      path
+    end
   end
 end

data/lib/sparrow/steward.rb

@@ -0,0 +1,125 @@
+module Sparrow
+  ##
+  # Parses the http_mesage and provides information if it should be
+  # processed, i.e. if the content type or accept header is applicable
+  #
+  # @todo this class is requested to be removed by issue #7 in the feature and
+  # its internal will be moved to its counterparts such as HttpMessage itself.
+  # @version 0.0.16
+  class Steward
+    ##
+    # @return [HttpMessage] the wrapped http message object to be checked
+    attr_reader :http_message
+
+    ##
+    # @return [Array<String>]
+    # @see Sparrow::Configuration#allowed_accepts
+    attr_reader :allowed_accepts
+
+    ##
+    # @return [Array<String>]
+    # @see Sparrow::Configuration#allowed_content_types
+    attr_reader :allowed_content_types
+
+    ##
+    # @return [Array<String,Regexp>]
+    # @see Sparrow::Configuration#excluded_routes
+    attr_reader :excluded_routes
+
+    ##
+    # @return [Array<Integer>]
+    # @see Configuration#ignored_response_codes
+    attr_reader :ignored_response_codes
+
+    # @return [RouteParser] the route parser for the #excluded_routes
+    # @see RouteParser
+    # @see #exluded_routes
+    attr_reader :route_parser
+
+    ##
+    # Initialize the Steward with the HTTP message to check and the specific
+    # check options.
+    #
+    # @param options [Hash]
+    # @option options [HttpMessage] :http_message the message to be checked
+    # @option options [Array<String>] :allowed_accepts ([]) List of HTTP Accept
+    #   Header options
+    # @option options [Array<String>] :allowed_content_types ([])
+    #   List of HTTP Content Type Header options
+    # @option options [Array<String,Regexp>] :excluded_routes ([]) List of routes
+    #   (paths) to not process
+    #   (see Sparrow::Configuration#excluded_routes)
+    # @option options [Array<Integer>] ignored_response_codes ([])
+    #   (see Sparrow::Configuration#ignored_response_codes)
+    # @see RouteParser#excluded_routes
+    # @see Configuration
+    def initialize(http_message, options = {})
+      @http_message           = http_message
+      @allowed_accepts        = options.fetch(:allowed_accepts, [])
+      @allowed_content_types  = options.fetch(:allowed_content_types, [])
+      @excluded_routes        = options.fetch(:excluded_routes, [])
+      @ignored_response_codes = options.fetch(:ignored_response_codes, [])
+      @route_parser           = RouteParser.new(excluded_routes)
+    end
+
+    ##
+    # Checks the +http_message+ against any given criteria specified by the
+    # +options+ within the constructor
+    #
+    # @return [Boolean] processable message
+    def has_processable_http_message?
+      includes_route? &&
+          allowed_content_type? &&
+          allowed_accept_header?
+    end
+
+    private
+
+    ##
+    # @private
+    def includes_route?
+      route_parser.allow?(http_message.path)
+    end
+
+    ##
+    # @private
+    def allowed_content_type?
+      content_type = http_message.content_type
+      content_type_equals?(content_type) || content_type_matches?(content_type)
+    end
+
+    ##
+    # @private
+    def allowed_accept_header?
+      accept_header = http_message.accept
+
+      allowed_accepts.include?(nil) ||
+          accept_type_matches?(allowed_accepts, accept_header)
+    end
+
+    ##
+    # @private
+    def content_type_equals?(type)
+      allowed_content_types.include?(type)
+    end
+
+    ##
+    # @private
+    def content_type_matches?(type)
+      matches = allowed_content_types.map do |acceptable_content_type|
+        (acceptable_content_type &&
+            type.to_s.starts_with?(acceptable_content_type.to_s))
+      end
+
+      matches.any?
+    end
+
+    ##
+    # @private
+    def accept_type_matches?(accepted_headers, type)
+      accepted_headers.detect do |accept|
+        type.include?(accept)
+      end
+    end
+  end
+end

data/lib/sparrow/strategies.rb

@@ -0,0 +1,6 @@
+require 'sparrow/strategies/json_format_strategies'
+require 'sparrow/strategies/key_transformation'
+require 'sparrow/strategies/transform_params'
+require 'sparrow/strategies/form_hash'
+require 'sparrow/strategies/raw_input'
+require 'sparrow/strategies/ignore'

data/lib/sparrow/strategies/form_hash.rb

@@ -1,42 +1,58 @@
-require 'active_support/core_ext/object/blank'
-require 'sparrow/transformable'
-
 module Sparrow
   module Strategies
+    ##
+    # Handles Form Hash transformations, i.e. HTTP messages that contain form
+    # data
     class FormHash
-      REQUEST_FORM_HASH_KEY = 'rack.request.form_hash'
       include Transformable
 
-      attr_reader :env, :type
+      # @return [Hash] the Rack environment
+      # @see #initialize
+      attr_reader :env
+      # @return [Symbol] the HTTP message type. Either :request, or :response
+      # @see #initialize
+      attr_reader :type
 
+      ##
+      # Shortcut for handling a HTTP Message with this strategy.
       def self.handle(env, type)
         self.new(env, type).handle
       end
 
+      # Create a new FormHash Strategy
+      # @param [Hash] env the Rack environment
+      # @param [Symbol] type the HTTP message type. Must be either :request or
+      #  :response
+      # @param [Hash] params the HTTP message parameters to be transformed
+      #   if not already present in the env
       def initialize(env, type = :request, params = nil)
         @env    = env
         @params = params
         @type   = type
       end
 
+      ##
+      # Do the transformation
+      # @return [Hash] the converted JSON as a Hash representation
       def handle
         super
         handle_form_hash
       end
 
+      ##
+      # If given in the constructor, this simply returns the given params
+      # argument. Otherwise it will look in the #env for form hash data params
+      # @return  [Hash] the HTTP message params
+      # @see #initialize
       def params
-        @params || env[REQUEST_FORM_HASH_KEY]
+        @params || env[HttpMessage::FORM_HASH_KEY]
       end
 
       private
 
       def handle_form_hash
-        if params.present?
-          transformed_params = transform_params
-          @env[REQUEST_FORM_HASH_KEY] = transformed_params
-        end
+        env[HttpMessage::FORM_HASH_KEY] = transform_params if params.present?
       end
     end
   end
 end
-