Attachment #247175 for bug #426183

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 426183
Collapse All | Expand All




		if(!cType) {
			return false;
		}
		return (cType.id === "application/octet-stream" || cType['extends'] === "application/octet-stream"); //$NON-NLS-0$ //$NON-NLS-1$ //$NON-NLS-2$
	}
	
	/**
	 * @name getFilenameContentType
	 * @description Return the best contentType match to the given filename or null if no match. Filename pattern checked first, then extension
	 * @param filename the filename to compare against contentTypes
	 * @param contentTypes the array of possible contentTypes to check
	 * @returns returns ContentType that is the best match or null
	 */
	function getFilenameContentType(/**String*/ filename, contentTypes) {
		function winner(best, other, filename, extension) {
			var nameMatch = other.filename.indexOf(filename) >= 0;
			var extMatch = contains(other.extension, extension.toLowerCase());
			if (nameMatch || extMatch) {
				if (!best || (nameMatch && contains(best.extension, extension.toLowerCase()))) {
					return other;
				}
			}
			return best;
		}
		if (typeof filename !== "string") { //$NON-NLS-0$
			return null;
		}
		
		var best = null;
		var current;
		
		var extStart = filename.indexOf('.'); //$NON-NLS-0$
		extStart++; // leading period not included in extension
		var extension = filename.substring(extStart).toLowerCase();
		
		// Check the most common cases, exact filename match or full extension match
		for (var i=0; i < contentTypes.length; i++) {
			current = contentTypes[i];
			if (current.filename.indexOf(filename) >= 0){
				best = current;
				break;
			}
			
			if (contains(current.extension, extension)){
				// A filename match is considered better than a perfect extension match
				best = current;
				continue;
			}
		}
		
		// Check the less common case where the filename contains periods (foo.bar.a.b check 'bar.a.b' then 'a.b' then 'b')
		if (!best){
			extStart = extension.indexOf('.'); //$NON-NLS-0$
			while (!best && extStart >= 0){
				extStart++; // leading period not included in extension
				extension = extension.substring(extStart);
				for (i=0; i < contentTypes.length; i++) {
					current = contentTypes[i];
					if (contains(current.extension, extension)){
						best = current;
						break;
					}
				}
				extStart = extension.indexOf('.'); //$NON-NLS-0$
			}
		}
		
		return best;		
	}

	function array(obj) {




			}, {
				id: 'orion/test3',
				name: 'Basic 3',
				filename: ['garbage', 'build.xml']
			}, {
				id: 'orion/test4',
				name: 'Basic 4',
				image: 'http://example.org/foo.png',
				imageClass: 'imageFoo'
			}, {
				id: 'orion/test5',
				name: 'Basic 5',
				extension: ['file.xml']
			}, {
				id: 'orion/test6',
				name: 'Basic 6',
				filename: ['exactfilematch', 'exactfilenamematch']
			} ];
		if (useServiceRegistry) {
			dataSource = serviceRegistry = new ServiceRegistry();

		getFileContentType: function() {
			this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {
				var fileMetadata1 = {
					Name: "zzzdoesnotmatchanythingzzz"
				},
				fileMetadata2 = {
					Name: "test.foo.xml"
				},
				fileMetadata3 = {
					Name: "test.file.txt"
				},
				fileMetadata4 = {
					Name: "build.xml"
				},
				fileMetadata5 = {
					Name: "test.file.xml"
				},
				fileMetadata6 = {
					Name: "exactfilenamematch"
				};
				
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata1), null, "No content type for unrecognized file");
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata2), basicTypes[2], "Extension match");
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata3), basicTypes[2], "Extension match");
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata4), basicTypes[3], "Filename match beats extension match");
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata5), basicTypes[5], "Filename match");
				assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata6), basicTypes[6], "Extension match takes longest extension");
			});
		},

		getFilenameContentType: function() {
			this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {
				assertContentTypesEqual(contentTypeService.getFilenameContentType("zzzdoesnotmatchanythingzzz"), null, "No content type for unrecognized file");
				assertContentTypesEqual(contentTypeService.getFilenameContentType("test.foo.xml"), basicTypes[2], "Extension match");
				assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.txt"), basicTypes[2], "Extension match");
				assertContentTypesEqual(contentTypeService.getFilenameContentType("build.xml"), basicTypes[3], "Filename match beats extension match");
				assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.xml"), basicTypes[5], "Filename match");
				assertContentTypesEqual(contentTypeService.getFilenameContentType("exactfilenamematch"), basicTypes[6], "Extension match takes longest extension");
			});
		},


Return to bug 426183

Lines 46-77 Link Here

(-)a/bundles/org.eclipse.orion.client.core/web/orion/contentTypes.js (-16 / +45 lines)
46	if(!cType) {	46	if(!cType) {
47	return false;	47	return false;
48	}	48	}
49	return (cType.id === "application/octet-stream" \|\| cType['extends'] === "application/octet-stream");	49	return (cType.id === "application/octet-stream" \|\| cType['extends'] === "application/octet-stream"); //$NON-NLS-0$ //$NON-NLS-1$ //$NON-NLS-2$
50	}	50	}
51		51
		52	/**
		53	* @name getFilenameContentType
		54	* @description Return the best contentType match to the given filename or null if no match. Filename pattern checked first, then extension
		55	* @param filename the filename to compare against contentTypes
		56	* @param contentTypes the array of possible contentTypes to check
		57	* @returns returns ContentType that is the best match or null
		58	*/
52	function getFilenameContentType(/*String/ filename, contentTypes) {	59	function getFilenameContentType(/*String/ filename, contentTypes) {
53	function winner(best, other, filename, extension) {
54	var nameMatch = other.filename.indexOf(filename) >= 0;
55	var extMatch = contains(other.extension, extension.toLowerCase());
56	if (nameMatch \|\| extMatch) {
57	if (!best \|\| (nameMatch && contains(best.extension, extension.toLowerCase()))) {
58	return other;
59	}
60	}
61	return best;
62	}
63	if (typeof filename !== "string") { //$NON-NLS-0$	60	if (typeof filename !== "string") { //$NON-NLS-0$
64	return null;	61	return null;
65	}	62	}
66	var extension = filename && filename.split(".").pop(); //$NON-NLS-0$	63
67	var best = null;	64	var best = null;
		65	var current;
		66
		67	var extStart = filename.indexOf('.'); //$NON-NLS-0$
		68	extStart++; // leading period not included in extension
		69	var extension = filename.substring(extStart).toLowerCase();
		70
		71	// Check the most common cases, exact filename match or full extension match
68	for (var i=0; i < contentTypes.length; i++) {	72	for (var i=0; i < contentTypes.length; i++) {
69	var type = contentTypes[i];	73	current = contentTypes[i];
70	if (winner(best, type, filename, extension) === type) {	74	if (current.filename.indexOf(filename) >= 0){
71	best = type;	75	best = current;
		76	break;
		77	}
		78
		79	if (contains(current.extension, extension)){
		80	// A filename match is considered better than a perfect extension match
		81	best = current;
		82	continue;
72	}	83	}
73	}	84	}
74	return best;	85
		86	// Check the less common case where the filename contains periods (foo.bar.a.b check 'bar.a.b' then 'a.b' then 'b')
		87	if (!best){
		88	extStart = extension.indexOf('.'); //$NON-NLS-0$
		89	while (!best && extStart >= 0){
		90	extStart++; // leading period not included in extension
		91	extension = extension.substring(extStart);
		92	for (i=0; i < contentTypes.length; i++) {
		93	current = contentTypes[i];
		94	if (contains(current.extension, extension)){
		95	best = current;
		96	break;
		97	}
		98	}
		99	extStart = extension.indexOf('.'); //$NON-NLS-0$
		100	}
		101	}
		102
		103	return best;
75	}	104	}
76		105
77	function array(obj) {	106	function array(obj) {

Lines 61-72 Link Here

(-)a/bundles/org.eclipse.orion.client.ui/web/js-tests/ui/contentTypes/contentTypesTests.js (-10 / +29 lines)
61	}, {	61	}, {
62	id: 'orion/test3',	62	id: 'orion/test3',
63	name: 'Basic 3',	63	name: 'Basic 3',
64	filename: ['build.xml']	64	filename: ['garbage', 'build.xml']
65	}, {	65	}, {
66	id: 'orion/test4',	66	id: 'orion/test4',
67	name: 'Basic 4',	67	name: 'Basic 4',
68	image: 'http://example.org/foo.png',	68	image: 'http://example.org/foo.png',
69	imageClass: 'imageFoo'	69	imageClass: 'imageFoo'
		70	}, {
		71	id: 'orion/test5',
		72	name: 'Basic 5',
		73	extension: ['file.xml']
		74	}, {
		75	id: 'orion/test6',
		76	name: 'Basic 6',
		77	filename: ['exactfilematch', 'exactfilenamematch']
70	} ];	78	} ];
71	if (useServiceRegistry) {	79	if (useServiceRegistry) {
72	dataSource = serviceRegistry = new ServiceRegistry();	80	dataSource = serviceRegistry = new ServiceRegistry();
Lines 122-151 Link Here
122	getFileContentType: function() {	130	getFileContentType: function() {
123	this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {	131	this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {
124	var fileMetadata1 = {	132	var fileMetadata1 = {
125	Name: "aaaaaaaaaaa"	133	Name: "zzzdoesnotmatchanythingzzz"
126	},	134	},
127	fileMetadata2 = {	135	fileMetadata2 = {
128	Name: "test.file.xml"	136	Name: "test.foo.xml"
129	},	137	},
130	fileMetadata3 = {	138	fileMetadata3 = {
131	Name: "test.file.txt"	139	Name: "test.file.txt"
132	},	140	},
133	fileMetadata4 = {	141	fileMetadata4 = {
134	Name: "build.xml"	142	Name: "build.xml"
		143	},
		144	fileMetadata5 = {
		145	Name: "test.file.xml"
		146	},
		147	fileMetadata6 = {
		148	Name: "exactfilenamematch"
135	};	149	};
		150
136	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata1), null, "No content type for unrecognized file");	151	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata1), null, "No content type for unrecognized file");
137	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata2), basicTypes[2]);	152	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata2), basicTypes[2], "Extension match");
138	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata3), basicTypes[2]);	153	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata3), basicTypes[2], "Extension match");
139	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata4), basicTypes[3], "filename match beats extension match");	154	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata4), basicTypes[3], "Filename match beats extension match");
		155	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata5), basicTypes[5], "Filename match");
		156	assertContentTypesEqual(contentTypeService.getFileContentType(fileMetadata6), basicTypes[6], "Extension match takes longest extension");
140	});	157	});
141	},	158	},
142		159
143	getFilenameContentType: function() {	160	getFilenameContentType: function() {
144	this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {	161	this.withTestData(function(serviceRegistry, contentTypeService, basicTypes) {
145	assertContentTypesEqual(contentTypeService.getFilenameContentType("aaaaaaa"), null, "No content type for unrecognized file");	162	assertContentTypesEqual(contentTypeService.getFilenameContentType("zzzdoesnotmatchanythingzzz"), null, "No content type for unrecognized file");
146	assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.xml"), basicTypes[2]);	163	assertContentTypesEqual(contentTypeService.getFilenameContentType("test.foo.xml"), basicTypes[2], "Extension match");
147	assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.txt"), basicTypes[2]);	164	assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.txt"), basicTypes[2], "Extension match");
148	assertContentTypesEqual(contentTypeService.getFilenameContentType("build.xml"), basicTypes[3], "filename match beats extension match");	165	assertContentTypesEqual(contentTypeService.getFilenameContentType("build.xml"), basicTypes[3], "Filename match beats extension match");
		166	assertContentTypesEqual(contentTypeService.getFilenameContentType("test.file.xml"), basicTypes[5], "Filename match");
		167	assertContentTypesEqual(contentTypeService.getFilenameContentType("exactfilenamematch"), basicTypes[6], "Extension match takes longest extension");
149	});	168	});
150	},	169	},
151		170