Ripped out support for JSONP.

Author: joliver

contracts_structs.go

@@ -79,21 +79,6 @@ type SerializeResult struct {
 func (this *SerializeResult) SetContent(value interface{}) { this.Content = value }
 func (this *SerializeResult) Result() interface{}          { return this }
 
-// JSONPResult provides the ability render a JSON-P result to the response.
-type JSONPResult struct {
-	// StatusCode, if provided, use this value, otherwise HTTP 200.
-	StatusCode int
-
-	// ContentType, if provided, use this value.
-	ContentType string
-
-	// Headers, if provided, are added to the response
-	Headers map[string][]string
-
-	// Content, if provided, use this value, otherwise no content will be written to the response stream.
-	Content interface{}
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // InputError represents some kind of problem with the calling HTTP request.

writers.go

@@ -64,11 +64,6 @@ func (this *defaultWriter) write(response http.ResponseWriter, request *http.Req
 	case SerializeResult:
 		this.responseStatus(this.writeSerializeResult(response, request, &typed))
 
-	case *JSONPResult:
-		this.responseStatus(this.writeJSONPResult(response, request, typed))
-	case JSONPResult:
-		this.responseStatus(this.writeJSONPResult(response, request, &typed))
-
 	case string:
 		this.responseStatus(this.writeStringResult(response, typed))
 	case []byte:
@@ -164,60 +159,6 @@ func (this *defaultWriter) loadSerializer(acceptTypes []string) Serializer {
 
 	return this.defaultSerializer
 }
-func (this *defaultWriter) writeJSONPResult(response http.ResponseWriter, request *http.Request, typed *JSONPResult) (err error) {
-	callbackFunction := parseJSONPCallbackQueryStringParameter(request.URL.RawQuery)
-
-	contentType := typed.ContentType
-	if len(contentType) == 0 {
-		contentType = mimeTypeApplicationJavascriptUTF8
-	}
-
-	headers := response.Header()
-	for key, values := range typed.Headers {
-		headers[key] = values
-	}
-
-	this.writeHeader(response, typed.StatusCode, contentType, "", true)
-
-	_, _ = io.WriteString(response, callbackFunction)
-	_, _ = io.WriteString(response, "(")
-	serializer := this.loadSerializer(headerAcceptTypeJavascript)
-	err = serializer.Serialize(response, typed.Content) // serializes an extra line break
-	_, _ = io.WriteString(response, ")")
-
-	return err
-}
-func parseJSONPCallbackQueryStringParameter(query string) string {
-	var key, value string
-	for len(query) > 0 {
-		key = query
-
-		if i := strings.Index(key, "&"); i >= 0 {
-			key, query = key[:i], key[i+1:]
-		} else {
-			query = ""
-		}
-
-		if i := strings.Index(key, "="); i >= 0 {
-			key, value = key[:i], key[i+1:]
-		}
-
-		if key == defaultJSONPCallbackParameter {
-			return sanitizeJSONPCallbackValue(value)
-		}
-	}
-
-	return defaultJSONPCallbackName
-}
-func sanitizeJSONPCallbackValue(raw string) string {
-	for _, item := range raw {
-		if (item < 'a' || item > 'z') && (item < 'A' || item > 'Z') && (item < '0' || item > '9') && (item != '_') {
-			return defaultJSONPCallbackName
-		}
-	}
-
-	return raw
-}
 
 func (this *defaultWriter) writeStringResult(response http.ResponseWriter, typed string) (err error) {
 	this.monitor.NativeResult()

writers_test.go

@@ -90,11 +90,6 @@ func TestWrite(t *testing.T) {
 			Accept:       "application/xml;q=0.8", // simplify and use correct serializer
 			HTTPResponse: HTTPResponse{StatusCode: 200, ContentType: []string{"application/xml; charset=utf-8"}, Body: string(xmlPrefix) + "{body}"}},
 
-		{Input: &JSONPResult{StatusCode: 201, ContentType: "", Content: "body"},
-			HTTPResponse: HTTPResponse{StatusCode: 201, ContentType: []string{"application/javascript; charset=utf-8"}, Body: "callback({body})"}},
-		{Input: JSONPResult{StatusCode: 201, ContentType: "", Content: "body"},
-			HTTPResponse: HTTPResponse{StatusCode: 201, ContentType: []string{"application/javascript; charset=utf-8"}, Body: "callback({body})"}},
-
 		{Input: 42, // use serializer for unknown type
 			HTTPResponse: HTTPResponse{StatusCode: 200, ContentType: []string{"application/json; charset=utf-8"}, Body: "{42}"}},
 	}
@@ -150,7 +145,6 @@ func TestSerializeResultWriteHTTPHeaders(t *testing.T) {
 	assertHTTPHeaders(t, TextResult{Headers: headers})
 	assertHTTPHeaders(t, BinaryResult{Headers: headers})
 	assertHTTPHeaders(t, StreamResult{Headers: headers})
-	assertHTTPHeaders(t, JSONPResult{Headers: headers})
 }
 func assertHTTPHeaders(t *testing.T, result interface{}) {
 	response := recordResponse(result, "application/json")
@@ -168,24 +162,6 @@ type HTTPResponse struct {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-func TestJSONPCallbackQueryStringParsing(t *testing.T) {
-	assertJSONPQueryStringCallback(t, "callback=jsonCallback", "jsonCallback")                           // simple
-	assertJSONPQueryStringCallback(t, "key=&callback=jsonCallback", "jsonCallback")                      // multiple keys
-	assertJSONPQueryStringCallback(t, "key=value&callback=jsonCallback", "jsonCallback")                 // multiple keys and values
-	assertJSONPQueryStringCallback(t, "key=&=value&callback=jsonCallback&other=stuff", "jsonCallback")   // blank keys and values
-	assertJSONPQueryStringCallback(t, "callback=_json_Callback_0123456789", "_json_Callback_0123456789") // complex callback name
-	assertJSONPQueryStringCallback(t, "key=&=value&other=stuff", "callback")                             // doesn't exist, use default
-	assertJSONPQueryStringCallback(t, "callback=malicious!", "callback")                                 // malicious
-	assertJSONPQueryStringCallback(t, "callback=<malicious>", "callback")                                // malicious
-	assertJSONPQueryStringCallback(t, "callback=alert('malicious');", "callback")                        // malicious
-
-}
-func assertJSONPQueryStringCallback(t *testing.T, raw, callback string) {
-	Assert(t).That(parseJSONPCallbackQueryStringParameter(raw)).Equals(callback)
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 type FakeHTTPHandlerResult struct {
 	response http.ResponseWriter
 	request  *http.Request