/**

* Apache License

* Version 2.0, January 2004

* http://www.apache.org/licenses/

*

* TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

*

* 1. Definitions.

*

* "License" shall mean the terms and conditions for use, reproduction,

* and distribution as defined by Sections 1 through 9 of this document.

*

* "Licensor" shall mean the copyright owner or entity authorized by

* the copyright owner that is granting the License.

*

* "Legal Entity" shall mean the union of the acting entity and all

* other entities that control, are controlled by, or are under common

* control with that entity. For the purposes of this definition,

* "control" means (i) the power, direct or indirect, to cause the

* direction or management of such entity, whether by contract or

* otherwise, or (ii) ownership of fifty percent (50%) or more of the

* outstanding shares, or (iii) beneficial ownership of such entity.

*

* "You" (or "Your") shall mean an individual or Legal Entity

* exercising permissions granted by this License.

*

* "Source" form shall mean the preferred form for making modifications,

* including but not limited to software source code, documentation

* source, and configuration files.

*

* "Object" form shall mean any form resulting from mechanical

* transformation or translation of a Source form, including but

* not limited to compiled object code, generated documentation,

* and conversions to other media types.

*

* "Work" shall mean the work of authorship, whether in Source or

* Object form, made available under the License, as indicated by a

* copyright notice that is included in or attached to the work

* (an example is provided in the Appendix below).

*

* "Derivative Works" shall mean any work, whether in Source or Object

* form, that is based on (or derived from) the Work and for which the

* editorial revisions, annotations, elaborations, or other modifications

* represent, as a whole, an original work of authorship. For the purposes

* of this License, Derivative Works shall not include works that remain

* separable from, or merely link (or bind by name) to the interfaces of,

* the Work and Derivative Works thereof.

*

* "Contribution" shall mean any work of authorship, including

* the original version of the Work and any modifications or additions

* to that Work or Derivative Works thereof, that is intentionally

* submitted to Licensor for inclusion in the Work by the copyright owner

* or by an individual or Legal Entity authorized to submit on behalf of

* the copyright owner. For the purposes of this definition, "submitted"

* means any form of electronic, verbal, or written communication sent

* to the Licensor or its representatives, including but not limited to

* communication on electronic mailing lists, source code control systems,

* and issue tracking systems that are managed by, or on behalf of, the

* Licensor for the purpose of discussing and improving the Work, but

* excluding communication that is conspicuously marked or otherwise

* designated in writing by the copyright owner as "Not a Contribution."

*

* "Contributor" shall mean Licensor and any individual or Legal Entity

* on behalf of whom a Contribution has been received by Licensor and

* subsequently incorporated within the Work.

*

* 2. Grant of Copyright License. Subject to the terms and conditions of

* this License, each Contributor hereby grants to You a perpetual,

* worldwide, non-exclusive, no-charge, royalty-free, irrevocable

* copyright license to reproduce, prepare Derivative Works of,

* publicly display, publicly perform, sublicense, and distribute the

* Work and such Derivative Works in Source or Object form.

*

* 3. Grant of Patent License. Subject to the terms and conditions of

* this License, each Contributor hereby grants to You a perpetual,

* worldwide, non-exclusive, no-charge, royalty-free, irrevocable

* (except as stated in this section) patent license to make, have made,

* use, offer to sell, sell, import, and otherwise transfer the Work,

* where such license applies only to those patent claims licensable

* by such Contributor that are necessarily infringed by their

* Contribution(s) alone or by combination of their Contribution(s)

* with the Work to which such Contribution(s) was submitted. If You

* institute patent litigation against any entity (including a

* cross-claim or counterclaim in a lawsuit) alleging that the Work

* or a Contribution incorporated within the Work constitutes direct

* or contributory patent infringement, then any patent licenses

* granted to You under this License for that Work shall terminate

* as of the date such litigation is filed.

*

* 4. Redistribution. You may reproduce and distribute copies of the

* Work or Derivative Works thereof in any medium, with or without

* modifications, and in Source or Object form, provided that You

* meet the following conditions:

*

* (a) You must give any other recipients of the Work or

* Derivative Works a copy of this License; and

*

* (b) You must cause any modified files to carry prominent notices

* stating that You changed the files; and

*

* (c) You must retain, in the Source form of any Derivative Works

* that You distribute, all copyright, patent, trademark, and

* attribution notices from the Source form of the Work,

* excluding those notices that do not pertain to any part of

* the Derivative Works; and

*

* (d) If the Work includes a "NOTICE" text file as part of its

* distribution, then any Derivative Works that You distribute must

* include a readable copy of the attribution notices contained

* within such NOTICE file, excluding those notices that do not

* pertain to any part of the Derivative Works, in at least one

* of the following places: within a NOTICE text file distributed

* as part of the Derivative Works; within the Source form or

* documentation, if provided along with the Derivative Works; or,

* within a display generated by the Derivative Works, if and

* wherever such third-party notices normally appear. The contents

* of the NOTICE file are for informational purposes only and

* do not modify the License. You may add Your own attribution

* notices within Derivative Works that You distribute, alongside

* or as an addendum to the NOTICE text from the Work, provided

* that such additional attribution notices cannot be construed

* as modifying the License.

*

* You may add Your own copyright statement to Your modifications and

* may provide additional or different license terms and conditions

* for use, reproduction, or distribution of Your modifications, or

* for any such Derivative Works as a whole, provided Your use,

* reproduction, and distribution of the Work otherwise complies with

* the conditions stated in this License.

*

* 5. Submission of Contributions. Unless You explicitly state otherwise,

* any Contribution intentionally submitted for inclusion in the Work

* by You to the Licensor shall be under the terms and conditions of

* this License, without any additional terms or conditions.

* Notwithstanding the above, nothing herein shall supersede or modify

* the terms of any separate license agreement you may have executed

* with Licensor regarding such Contributions.

*

* 6. Trademarks. This License does not grant permission to use the trade

* names, trademarks, service marks, or product names of the Licensor,

* except as required for reasonable and customary use in describing the

* origin of the Work and reproducing the content of the NOTICE file.

*

* 7. Disclaimer of Warranty. Unless required by applicable law or

* agreed to in writing, Licensor provides the Work (and each

* Contributor provides its Contributions) on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

* implied, including, without limitation, any warranties or conditions

* of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

* PARTICULAR PURPOSE. You are solely responsible for determining the

* appropriateness of using or redistributing the Work and assume any

* risks associated with Your exercise of permissions under this License.

*

* 8. Limitation of Liability. In no event and under no legal theory,

* whether in tort (including negligence), contract, or otherwise,

* unless required by applicable law (such as deliberate and grossly

* negligent acts) or agreed to in writing, shall any Contributor be

* liable to You for damages, including any direct, indirect, special,

* incidental, or consequential damages of any character arising as a

* result of this License or out of the use or inability to use the

* Work (including but not limited to damages for loss of goodwill,

* work stoppage, computer failure or malfunction, or any and all

* other commercial damages or losses), even if such Contributor

* has been advised of the possibility of such damages.

*

* 9. Accepting Warranty or Additional Liability. While redistributing

* the Work or Derivative Works thereof, You may choose to offer,

* and charge a fee for, acceptance of support, warranty, indemnity,

* or other liability obligations and/or rights consistent with this

* License. However, in accepting such obligations, You may act only

* on Your own behalf and on Your sole responsibility, not on behalf

* of any other Contributor, and only if You agree to indemnify,

* defend, and hold each Contributor harmless for any liability

* incurred by, or claims asserted against, such Contributor by reason

* of your accepting any such warranty or additional liability.

*

* END OF TERMS AND CONDITIONS

*

* APPENDIX: How to apply the Apache License to your work.

*

* To apply the Apache License to your work, attach the following

* boilerplate notice, with the fields enclosed by brackets "{}"

* replaced with your own identifying information. (Don't include

* the brackets!) The text should be enclosed in the appropriate

* comment syntax for the file format. We also recommend that a

* file or class name and description of purpose be included on the

* same "printed page" as the copyright notice for easier

* identification within third-party archives.

*

* Copyright 2014 Edgar Espina

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package org.jooby;

import static com.google.common.base.Preconditions.checkArgument;

import static java.util.Objects.requireNonNull;

import java.io.File;

import java.nio.file.Path;

import java.util.ArrayList;

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.concurrent.ConcurrentHashMap;

import com.google.common.collect.ImmutableList;

import com.google.common.collect.ImmutableMap;

import com.typesafe.config.Config;

import com.typesafe.config.ConfigFactory;

/**

* An immutable implementation of HTTP media types (a.k.a mime types).

*

* @author edgar

* @since 0.1.0

*/

public class MediaType implements Comparable<MediaType> {

/**

* A media type matcher.

*

* @see MediaType#matcher(org.jooby.MediaType)

* @see MediaType#matcher(java.util.List)

*/

public static class Matcher {

/**

* The source of media types.

*/

private Iterable<MediaType> acceptable;

/**

* Creates a new {@link Matcher}.

*

* @param acceptable The source to compare with.

*/

Matcher(final Iterable<MediaType> acceptable) {

this.acceptable = acceptable;

}

/**

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* matches(text/html) // true through text/html

* matches(application/json) // true through {@literal *}/{@literal *}

* </pre>

*

* @param candidate A candidate media type. Required.

* @return True if the matcher matches the given media type.

*/

public boolean matches(final MediaType candidate) {

return doFirst(ImmutableList.of(candidate)).isPresent();

}

/**

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* matches(text/html) // true through text/html

* matches(application/json) // true through {@literal *}/{@literal *}

* </pre>

*

* @param candidates One ore more candidates media type. Required.

* @return True if the matcher matches the given media type.

*/

public boolean matches(final List<MediaType> candidates) {

return filter(candidates).size() > 0;

}

/**

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* first(text/html) // returns text/html

* first(application/json) // returns application/json

* </pre>

*

* @param candidate A candidate media type. Required.

* @return A first most relevant media type or an empty optional.

*/

public Optional<MediaType> first(final MediaType candidate) {

return first(ImmutableList.of(candidate));

}

/**

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* first(text/html) // returns text/html

* first(application/json) // returns application/json

* </pre>

*

* @param candidates One ore more candidates media type. Required.

* @return A first most relevant media type or an empty optional.

*/

public Optional<MediaType> first(final List<MediaType> candidates) {

return doFirst(candidates);

}

/**

* Filter the accepted types and keep the most specifics media types.

*

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* filter(text/html) // returns text/html

* first(application/json) // returns application/json

* filter(text/html, application/json) // returns text/html and application/json

* </pre>

*

* @param types A types to filter

* @return Filtered types that matches the given types ordered from more specific to less

* specific.

*/

public List<MediaType> filter(final List<MediaType> types) {

checkArgument(types != null && types.size() > 0, "Media types are required");

ImmutableList.Builder<MediaType> result = ImmutableList.builder();

final List<MediaType> sortedTypes;

if (types.size() == 1) {

sortedTypes = ImmutableList.of(types.get(0));

} else {

sortedTypes = new ArrayList<>(types);

Collections.sort(sortedTypes);

}

for (MediaType accept : acceptable) {

for (MediaType candidate : sortedTypes) {

if (accept.matches(candidate)) {

result.add(candidate);

}

}

}

return result.build();

}

/**

* Given:

*

* <pre>

* text/html, application/xhtml; {@literal *}/{@literal *}

* </pre>

*

* <pre>

* first(text/html) -> returns text/html

* first(application/json) -> returns application/json

* </pre>

*

* @param candidates One ore more candidates media type. Required.

* @return A first most relevant media type or an empty optional.

*/

private Optional<MediaType> doFirst(final List<MediaType> candidates) {

List<MediaType> result = filter(candidates);

return result.size() == 0 ? Optional.empty() : Optional.of(result.get(0));

}

}

/**

* Default parameters.

*/

private static final Map<String, String> DEFAULT_PARAMS = ImmutableMap.of("q", "1");

/**

* A JSON media type.

*/

public static final MediaType json = new MediaType("application", "json");

private static final MediaType jsonLike = new MediaType("application", "*+json");

/**

* Any text media type.

*/

public static final MediaType text = new MediaType("text", "*");

/**

* Text plain media type.

*/

public static final MediaType plain = new MediaType("text", "plain");

/**

* Stylesheet media type.

*/

public static final MediaType css = new MediaType("text", "css");

/**

* Javascript media types.

*/

public static final MediaType js = new MediaType("application", "javascript");

/**

* HTML media type.

*/

public static final MediaType html = new MediaType("text", "html");

/**

* The default binary media type.

*/

public static final MediaType octetstream = new MediaType("application", "octet-stream");

/**

* Any media type.

*/

public static final MediaType all = new MediaType("*", "*");

/** Any media type. */

public static final List<MediaType> ALL = ImmutableList.of(MediaType.all);

/** Form multipart-data media type. */

public static final MediaType multipart = new MediaType("multipart", "form-data");

/** Form url encoded. */

public static final MediaType form = new MediaType("application", "x-www-form-urlencoded");

/** Xml media type. */

public static final MediaType xml = new MediaType("application", "xml");

/** Server sent event type. */

public static final MediaType sse = new MediaType("text", "event-stream");

/** Xml like media type. */

private static final MediaType xmlLike = new MediaType("application", "*+xml");

/**

* Track the type of this media type.

*/

private final String type;

/**

* Track the subtype of this media type.

*/

private final String subtype;

/**

* Track the media type parameters.

*/

private final Map<String, String> params;

/**

* True for wild-card types.

*/

private final boolean wildcardType;

/**

* True for wild-card sub-types.

*/

private final boolean wildcardSubtype;

/** Name . */

private String name;

private int hc;

/**

* Alias for most used types.

*/

private static final ConcurrentHashMap<String, List<MediaType>> cache = new ConcurrentHashMap<>();

static {

cache.put("html", ImmutableList.of(html));

cache.put("json", ImmutableList.of(json));

cache.put("css", ImmutableList.of(css));

cache.put("js", ImmutableList.of(js));

cache.put("octetstream", ImmutableList.of(octetstream));

cache.put("form", ImmutableList.of(form));

cache.put("multipart", ImmutableList.of(multipart));

cache.put("xml", ImmutableList.of(xml));

cache.put("plain", ImmutableList.of(plain));

cache.put("*", ALL);

}

static final Config types = ConfigFactory

.parseResources("mime.properties")

.withFallback(ConfigFactory.parseResources(MediaType.class, "mime.properties"));

/**

* Creates a new {@link MediaType}.

*

* @param type The primary type. Required.

* @param subtype The secondary type. Required.

* @param parameters The parameters. Required.

*/

private MediaType(final String type, final String subtype, final Map<String, String> parameters) {

this.type = requireNonNull(type, "A mime type is required.");

this.subtype = requireNonNull(subtype, "A mime subtype is required.");

this.params = ImmutableMap.copyOf(requireNonNull(parameters, "Parameters are required."));

this.wildcardType = "*".equals(type);

this.wildcardSubtype = "*".equals(subtype);

this.name = type + "/" + subtype;

hc = 31 + name.hashCode();

hc = 31 * hc + params.hashCode();

}

/**

* Creates a new {@link MediaType}.

*

* @param type The primary type. Required.

* @param subtype The secondary type. Required.

*/

private MediaType(final String type, final String subtype) {

this(type, subtype, DEFAULT_PARAMS);

}

/**

* @return The quality of this media type. Default is: 1.

*/

public float quality() {

return Float.valueOf(params.get("q"));

}

/**

* @return The primary media type.

*/

public String type() {

return type;

}

public Map<String, String> params() {

return params;

}

/**

* @return The secondary media type.

*/

public String subtype() {

return subtype;

}

/**

* @return The qualified type {@link #type()}/{@link #subtype()}.

*/

public String name() {

return name;

}

/**

* @return True, if this type is a well-known text type.

*/

public boolean isText() {

if (this.wildcardType) {

return false;

}

if (this == text || text.matches(this)) {

return true;

}

if (this == js || js.matches(this)) {

return true;

}

if (jsonLike.matches(this)) {

return true;

}

if (xmlLike.matches(this)) {

return true;

}

if (this.type.equals("application") && this.subtype.equals("hocon")) {

return true;

}

return false;

}

@Override

public int compareTo(final MediaType that) {

requireNonNull(that, "A media type is required.");

if (this == that) {

return 0;

}

if (this.wildcardType && !that.wildcardType) {

return 1;

}

if (that.wildcardType && !this.wildcardType) {

return -1;

}

if (this.wildcardSubtype && !that.wildcardSubtype) {

return 1;

}

if (that.wildcardSubtype && !this.wildcardSubtype) {

return -1;

}

if (!this.type().equals(that.type())) {

return 0;

}

int q = Float.compare(that.quality(), this.quality());

if (q != 0) {

return q;

}

// param size

int paramsSize1 = this.params.size();

int paramsSize2 = that.params.size();

return (paramsSize2 < paramsSize1 ? -1 : (paramsSize2 == paramsSize1 ? 0 : 1));

}

/**

* @param that A media type to compare to.

* @return True, if the given media type matches the current one.

*/

public boolean matches(final MediaType that) {

requireNonNull(that, "A media type is required.");

if (this == that || this.wildcardType || that.wildcardType) {

// same or */*

return true;

}

if (type.equals(that.type)) {

if (subtype.equals(that.subtype) || this.wildcardSubtype || that.wildcardSubtype) {

return true;

}

if (subtype.startsWith("*+")) {

return that.subtype.endsWith(subtype.substring(2));

}

if (subtype.startsWith("*")) {

return that.subtype.endsWith(subtype.substring(1));

}

}

return false;

}

/**

* @return True for <code>* / *</code>.

*/

public boolean isAny() {

return this.wildcardType && this.wildcardSubtype;

}

@Override

public boolean equals(final Object obj) {

if (obj == this) {

return true;

}

if (obj instanceof MediaType) {

MediaType that = (MediaType) obj;

return type.equals(that.type) && subtype.equals(that.subtype) && params.equals(that.params);

}

return false;

}

@Override

public int hashCode() {

return hc;

}

@Override

public final String toString() {

return name;

}

/**

* Convert a media type expressed as String into a {@link MediaType}.

*

* @param type A media type to parse.

* @return An immutable {@link MediaType}.

* @throws Err.BadMediaType For bad media types.

*/

public static MediaType valueOf(final String type) throws Err.BadMediaType {

return parse(type).get(0);

}

private static List<MediaType> parseInternal(final String value) {

String[] types = value.split(",");

@SuppressWarnings("serial")

List<MediaType> result = new ArrayList<>(types.length);

for (String type : types) {

String[] parts = type.trim().split(";");

if (parts[0].equals("*")) {

// odd and ugly media type

result.add(all);

} else {

String[] typeAndSubtype = parts[0].split("/");

if (typeAndSubtype.length != 2) {

throw new Err.BadMediaType(value);

}

String stype = typeAndSubtype[0].trim();

String subtype = typeAndSubtype[1].trim();

if ("*".equals(stype) && !"*".equals(subtype)) {

throw new Err.BadMediaType(value);

}

Map<String, String> parameters = DEFAULT_PARAMS;

if (parts.length > 1) {

parameters = new LinkedHashMap<>(DEFAULT_PARAMS);

for (int i = 1; i < parts.length; i++) {

String[] parameter = parts[i].split("=");

if (parameter.length > 1) {

parameters.put(parameter[0].trim(), parameter[1].trim().toLowerCase());

}

}

}

result.add(new MediaType(stype, subtype, parameters));

}

}

if (result.size() > 1) {

Collections.sort(result);

}

return result;

}

/**

* Convert one or more media types expressed as String into a {@link MediaType}.

*

* @param types Media types to parse.

* @return An list of immutable {@link MediaType}.

* @throws Err.BadMediaType For bad media types.

*/

public static List<MediaType> valueOf(final String... types) throws Err.BadMediaType {

requireNonNull(types, "Types are required.");

List<MediaType> result = new ArrayList<>();

for (String type : types) {

result.add(valueOf(type));

}

return result;

}

/**

* Convert a string separated by comma into one or more {@link MediaType}.

*

* @param value The string separated by commas.

* @return One ore more {@link MediaType}.

* @throws Err.BadMediaType For bad media types.

*/

public static List<MediaType> parse(final String value) throws Err.BadMediaType {

return cache.computeIfAbsent(value, MediaType::parseInternal);

}

/**

* Produces a matcher for the given media type.

*

* @param acceptable The acceptable/target media type.

* @return A media type matcher.

*/

public static Matcher matcher(final MediaType acceptable) {

return matcher(ImmutableList.of(acceptable));

}

/**

* Produces a matcher for the given media types.

*

* @param acceptable The acceptable/target media types.

* @return A media type matcher.

*/

public static Matcher matcher(final List<MediaType> acceptable) {

requireNonNull(acceptable, "Acceptables media types are required.");

return new Matcher(acceptable);

}

/**

* Get a {@link MediaType} for a file.

*

* @param file A candidate file.

* @return A {@link MediaType} or {@link MediaType#octetstream} for unknown file extensions.

*/

public static Optional<MediaType> byFile(final File file) {

requireNonNull(file, "A file is required.");

return byPath(file.getName());

}

/**

* Get a {@link MediaType} for a file path.

*

* @param path A candidate file path.

* @return A {@link MediaType} or empty optional for unknown file extensions.

*/

public static Optional<MediaType> byPath(final Path path) {

requireNonNull(path, "A path is required.");

return byPath(path.toString());

}

/**

* Get a {@link MediaType} for a file path.

*

* @param path A candidate file path: like <code>myfile.js</code> or <code>/js/myfile.js</code>.

* @return A {@link MediaType} or empty optional for unknown file extensions.

*/

public static Optional<MediaType> byPath(final String path) {

requireNonNull(path, "A path is required.");

int idx = path.lastIndexOf('.');

if (idx != -1) {

String ext = path.substring(idx + 1);

return byExtension(ext);

}

return Optional.empty();

}

/**

* Get a {@link MediaType} for a file extension.

*

* @param ext A file extension, like <code>js</code> or <code>css</code>.

* @return A {@link MediaType} or empty optional for unknown file extensions.

*/

public static Optional<MediaType> byExtension(final String ext) {

requireNonNull(ext, "An ext is required.");

String key = "mime." + ext;

if (types.hasPath(key)) {

return Optional.of(MediaType.valueOf(types.getString("mime." + ext)));

}

return Optional.empty();

}

}