Refactoring

src/wappalyzer.js

@@ -234,7 +234,7 @@ var wappalyzer = (function() {
 		 */
 		analyze: function(hostname, url, data) {
 			var
-				app, confirmMatch, type,
+				app,
 				apps = {};
 
 			w.log('w.analyze');
@@ -259,50 +259,22 @@ var wappalyzer = (function() {
 			for ( app in w.apps ) {
 				apps[app] = w.detected[url] && w.detected[url][app] ? w.detected[url][app] : new Application(app);
 
-				for ( type in w.apps[app] ) {
+				if ( url ) {
-					confirmMatch = function(pattern, value, key) {
+					w.analyzeUrl(apps[app], url);
-						apps[app].setDetected(pattern, type, value, key);
+				}
-					}
-
-					switch ( type ) {
-						case 'url':
-							if ( url ) {
-								w.analyzeUrl(parsePatterns(w.apps[app][type]), url, confirmMatch);
-							}
-
-							break;
-						case 'html':
-							if ( data.html ) {
-								w.analyzeHtml(parsePatterns(w.apps[app][type]), data.html, confirmMatch);
-							}
-
-							break;
-						case 'script':
-							if ( data.html ) {
-								w.analyzeScript(parsePatterns(w.apps[app][type]), data.html, confirmMatch);
-							}
-
-							break;
-						case 'meta':
-							if ( data.html ) {
-								w.analyzeMeta(parsePatterns(w.apps[app][type]), data.html, confirmMatch);
-							}
 
-							break;
+				if ( data.html ) {
-						case 'headers':
+					w.analyzeHtml(apps[app], data.html);
-							if ( data.hasOwnProperty('headers') && data.headers ) {
+					w.analyzeScript(apps[app], data.html);
-								w.analyzeHeaders(parsePatterns(w.apps[app][type]), data.headers, confirmMatch);
+					w.analyzeMeta(apps[app], data.html);
-							}
+				}
 
-							break;
+				if ( data.headers ) {
-						case 'env':
+					w.analyzeHeaders(apps[app], data.headers);
-							if ( data.hasOwnProperty('env') && data.env ) {
+				}
-								w.analyzeEnv(parsePatterns(w.apps[app][type]), data.env, confirmMatch);
-							}
 
-							break;
+				if ( data.env ) {
-						default:
+					w.analyzeEnv(apps[app], data.env);
-					}
 				}
 			}
 
@@ -462,60 +434,75 @@ var wappalyzer = (function() {
 		/**
 		 * Analyze URL
 		 */
-		analyzeUrl: function(patterns, url, confirmMatch) {
+		analyzeUrl: function(app, url) {
-			patterns.forEach(function(pattern) {
+			var patterns = parsePatterns(w.apps[app.app].url);
-				if ( pattern.regex.test(url) ) {
+
-					confirmMatch(pattern, url);
+			if ( patterns.length ) {
-				}
+				patterns.forEach(function(pattern) {
-			});
+					if ( pattern.regex.test(url) ) {
+						app.setDetected(pattern, 'url', url);
+					}
+				});
+			}
 		},
 
 		/**
 		 * Analyze HTML
 		 */
-		analyzeHtml: function(patterns, html, confirmMatch) {
+		analyzeHtml: function(app, html) {
-			patterns.forEach(function(pattern) {
+			var patterns = parsePatterns(w.apps[app.app].html);
-				if ( pattern.regex.test(html) ) {
+
-					confirmMatch(pattern, html);
+			if ( patterns.length ) {
-				}
+				patterns.forEach(function(pattern) {
-			});
+					if ( pattern.regex.test(html) ) {
+						app.setDetected(pattern, 'html', html);
+					}
+				});
+			}
 		},
 
 		/**
 		 * Analyze script tag
 		 */
-		analyzeScript: function(patterns, html, confirmMatch) {
+		analyzeScript: function(app, html) {
-			var regex = new RegExp('<script[^>]+src=("|\')([^"\']+)', 'ig');
+			var
+				regex = new RegExp('<script[^>]+src=("|\')([^"\']+)', 'ig'),
+				patterns = parsePatterns(w.apps[app.app].script);
 
-			patterns.forEach(function(pattern) {
+			if ( patterns.length ) {
-				var match;
+				patterns.forEach(function(pattern) {
+					var match;
 
-				while ( match = regex.exec(html) ) {
+					while ( match = regex.exec(html) ) {
-					if ( pattern.regex.test(match[2]) ) {
+						if ( pattern.regex.test(match[2]) ) {
-						confirmMatch(pattern, match[2]);
+							app.setDetected(pattern, 'script', match[2]);
+						}
 					}
-				}
+				});
-			});
+			}
 		},
 
 		/**
 		 * Analyze meta tag
 		 */
-		analyzeMeta: function(patterns, html, confirmMatch) {
+		analyzeMeta: function(app, html) {
 			var
 				content, match, meta,
-				regex = /<meta[^>]+>/ig;
+				regex = /<meta[^>]+>/ig,
-
+				patterns = parsePatterns(w.apps[app.app].meta);
-			while ( match = regex.exec(html) ) {
-				for ( meta in patterns ) {
-					if ( new RegExp('(name|property)=["\']' + meta + '["\']', 'i').test(match) ) {
-						content = match.toString().match(/content=("|')([^"']+)("|')/i);
 
-						patterns[meta].forEach(function(pattern) {
+			if ( patterns.length ) {
-							if ( content && content.length === 4 && pattern.regex.test(content[2]) ) {
+				while ( match = regex.exec(html) ) {
-								confirmMatch(pattern, content[2], meta);
+					for ( meta in patterns ) {
-							}
+						if ( new RegExp('(name|property)=["\']' + meta + '["\']', 'i').test(match) ) {
-						});
+							content = match.toString().match(/content=("|')([^"']+)("|')/i);
+
+							patterns[meta].forEach(function(pattern) {
+								if ( content && content.length === 4 && pattern.regex.test(content[2]) ) {
+									app.setDetected(pattern, 'meta', content[2], meta);
+								}
+							});
+						}
 					}
 				}
 			}
@@ -524,33 +511,41 @@ var wappalyzer = (function() {
 		/**
 		 * analyze response headers
 		 */
-		analyzeHeaders: function(patterns, headers, confirmMatch) {
+		analyzeHeaders: function(app, headers) {
-			var header;
+			var
+				header,
+				patterns = parsePatterns(w.apps[app.app].headers);
 
-			for ( header in patterns ) {
+			if ( patterns.length && headers ) {
-				patterns[header].forEach(function(pattern) {
+				for ( header in patterns ) {
-					header = header.toLowerCase();
+					patterns[header].forEach(function(pattern) {
+						header = header.toLowerCase();
 
-					if ( headers.hasOwnProperty(header) && pattern.regex.test(headers[header]) ) {
+						if ( headers.hasOwnProperty(header) && pattern.regex.test(headers[header]) ) {
-						confirmMatch(pattern, headers[header], header);
+							app.setDetected(pattern, 'headers', headers[header], header);
-					}
+						}
-				});
+					});
+				}
 			}
 		},
 
 		/**
 		 * Analyze environment variables
 		 */
-		analyzeEnv: function(patterns, envs, confirmMatch) {
+		analyzeEnv: function(app, envs) {
-			var env;
+			var patterns = parsePatterns(w.apps[app.app].env);
 
-			patterns.forEach(function(pattern) {
+			if ( patterns.length ) {
-				for ( env in envs ) {
+				patterns.forEach(function(pattern) {
-					if ( pattern.regex.test(envs[env]) ) {
+					var env;
-						confirmMatch(pattern, envs[env]);
+
+					for ( env in envs ) {
+						if ( pattern.regex.test(envs[env]) ) {
+							app.setDetected(pattern, 'env', envs[env]);
+						}
 					}
-				}
+				});
-			});
+			}
 		}
 	};