a",n=d.getElementsByTagName("*")||[],r=d.getElementsByTagName("a")[0],!r||!r.style||!n.length)return t;s=a.createElement("select"),u=s.appendChild(a.createElement("option")),o=d.getElementsByTagName("input")[0],r.style.cssText="top:1px;float:left;opacity:.5",t.getSetAttribute="t"!==d.className,t.leadingWhitespace=3===d.firstChild.nodeType,t.tbody=!d.getElementsByTagName("tbody").length,t.htmlSerialize=!!d.getElementsByTagName("link").length,t.style=/top/.test(r.getAttribute("style")),t.hrefNormalized="/a"===r.getAttribute("href"),t.opacity=/^0.5/.test(r.style.opacity),t.cssFloat=!!r.style.cssFloat,t.checkOn=!!o.value,t.optSelected=u.selected,t.enctype=!!a.createElement("form").enctype,t.html5Clone="<:nav>"!==a.createElement("nav").cloneNode(!0).outerHTML,t.inlineBlockNeedsLayout=!1,t.shrinkWrapBlocks=!1,t.pixelPosition=!1,t.deleteExpando=!0,t.noCloneEvent=!0,t.reliableMarginRight=!0,t.boxSizingReliable=!0,o.checked=!0,t.noCloneChecked=o.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!u.disabled;try{delete d.test}catch(h){t.deleteExpando=!1}o=a.createElement("input"),o.setAttribute("value",""),t.input=""===o.getAttribute("value"),o.value="t",o.setAttribute("type","radio"),t.radioValue="t"===o.value,o.setAttribute("checked","t"),o.setAttribute("name","t"),l=a.createDocumentFragment(),l.appendChild(o),t.appendChecked=o.checked,t.checkClone=l.cloneNode(!0).cloneNode(!0).lastChild.checked,d.attachEvent&&(d.attachEvent("onclick",function(){t.noCloneEvent=!1}),d.cloneNode(!0).click());for(f in{submit:!0,change:!0,focusin:!0})d.setAttribute(c="on"+f,"t"),t[f+"Bubbles"]=c in e||d.attributes[c].expando===!1;d.style.backgroundClip="content-box",d.cloneNode(!0).style.backgroundClip="",t.clearCloneStyle="content-box"===d.style.backgroundClip;for(f in x(t))break;return t.ownLast="0"!==f,x(function(){var n,r,o,s="padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;",l=a.getElementsByTagName("body")[0];l&&(n=a.createElement("div"),n.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",l.appendChild(n).appendChild(d),d.innerHTML="
';
+
+ return result;
+ });
+
+ hb.registerHelper('getErrorHTML', function(errorObject) {
+ var html = '';
+ var urls = Object.keys(errorObject);
+ urls.forEach(function(url) {
+ html += '
' + url + ' reason ' + errorObject[url] + '
';
+ });
+ return html;
+ });
+
+ hb.registerHelper('getWPTWaterFall', function(run, whichView) {
+ if (Array.isArray(run))
+ return run[0][whichView].images.waterfall;
+ else
+ return run[whichView].images.waterfall;
+ });
+
+
+ hb.registerHelper('getColumnsMeta', function(column, columnsMeta, ruleDictionary, type) {
+
+ // strip
+ if (column.indexOf('rules.')===0)
+ column = column.replace('rules.','');
+ else if (column.indexOf('yslow.assets.')===0)
+ column = column.replace('yslow.assets.','');
+ else if (column.indexOf('yslow.')===0)
+ column = column.replace('yslow.','');
+ else if (column.indexOf('timings.')===0)
+ column = column.replace('timings.','');
+ else if (column.indexOf('gpsi.')===0)
+ column = column.replace('gpsi.','');
+ else if (column.indexOf('wpt.')===0)
+ column = column.replace('wpt.','');
+
+ // If we have matching in the columns meta data use it
+ if (columnsMeta.hasOwnProperty(column))
+ return columnsMeta[column][type];
+ // else it is a rule or BT data, if it's a rule, use the rule title as description
+ else if (ruleDictionary.hasOwnProperty(column) && type === 'desc')
+ return ruleDictionary[column].name;
+ // if we display number of components returned for a rule
+ else if (column.indexOf('.items')>0) {
+ // display short version in title
+ if (type==='title')
+ return column.replace('.items','') + " components";
+ // and long in description
+ else
+ // TODO we need to change the impl of how the ruleDictionary is implemented,
+ // now one page needs to be run before it will work
+ /*
+ if (ruleDictionary[column.replace('-items','')].hasOwnProperty('name'))
+ return ruleDictionary[column.replace('-items','')].name;
+ else console.log("Column:" + column + " " + ruleDictionary[column.replace('-items','')] );
+ */
+ return column;
+ }
+ else if (ruleDictionary.hasOwnProperty(column))
+ return column + " score";
+ else return column.replace('.',' ');
+ });
+
+ /*
+ * Bootstrap has in a way a complicated handling of defining how many boxes
+ * that will be on each row. This function helps us to know if it is time
+ * to output the div for a new row.
+ */
+ hb.registerHelper('bootstrapIsNewRow', function(index, perRow, options) {
+ if(index % perRow === 0) {
+ return options.fn(this);
+ }
+ });
+
+ /*
+ * Bootstrap has in a way a complicated handling of defining how many boxes
+ * that will be on each row. This function helps us to know if it is time
+ * to output the div for ending a row.
+ */
+ hb.registerHelper('bootstrapIsEndRow', function(index, size, perRow, options) {
+ if((index+1) % perRow === 0) {
+ return options.fn(this);
+ }
+
+ // Taking care of the case for the last row
+ else if(size - (index+1) === 0) {
+ return options.fn(this);
+ }
+
+ });
+
+ /*
+ * Bootstrap has in a way a complicated handling of defining how many boxes
+ * that will be on each row. This function helps us to know how many boxes that
+ * will be on this row (or e.g defining how much we will span).
+ */
+ hb.registerHelper('getBootstrapSpan', function(index, perRow, size) {
+
+ var itemsLastRow = size % perRow;
+
+ // TODO make this generic, now it's hardcoded to 3 per row
+ if(size - index <= itemsLastRow) {
+ if (itemsLastRow === 2)
+ return 6;
+ else
+ return 12;
+ }
+ return 4;
+
+ });
+};
diff --git a/lib/htmlRenderer.js b/lib/htmlRenderer.js
new file mode 100644
index 000000000..36bf93adb
--- /dev/null
+++ b/lib/htmlRenderer.js
@@ -0,0 +1,217 @@
+/**
+ * Sitespeed.io - How speedy is your site? (http://www.sitespeed.io)
+ * Copyright (c) 2014, Peter Hedenskog, Tobias Lidskog
+ * and other contributors
+ * Released under the Apache 2.0 License
+ */
+var hb = require('handlebars'),
+ fs = require('fs-extra'),
+ path = require('path'),
+ log = require('winston'),
+ config = require('./conf'),
+ helpers = require('./hb-helpers');
+ columnsMetaData = require('../conf/columnsMetaData.json');
+ util = require('./util');
+
+module.exports = HTMLRenderer;
+
+var compiledTemplates = {},
+ compiledPartials = {},
+ ruleDictionary = {};
+
+function HTMLRenderer() {
+ this.numberOfAnalyzedPages = 0;
+ precompileTemplates();
+ helpers.registerHelpers();
+ copyAssets();
+}
+
+function copyAssets() {
+ fs.copy(path.join(__dirname, '../assets/'), config.run.absResultDir, function (err) {
+ if (err) throw err;
+ });
+}
+
+HTMLRenderer.prototype.renderPage = function (url, pageData) {
+ this.numberOfAnalyzedPages++;
+
+ var renderData = {};
+ if (pageData.yslow) {
+ renderData = {
+ "url": pageData.yslow.originalUrl,
+ "score": pageData.yslow.o,
+ "size": util.getSize(pageData.yslow.comps),
+ "rules": pageData.yslow.g,
+ "assets": pageData.yslow.comps,
+ "noOfDomains": util.getNumberOfDomains(pageData.yslow.comps),
+ "timeSinceLastModificationStats": util.getLastModStats(pageData.yslow.comps),
+ "cacheTimeStats": util.getCacheTimeStats(pageData.yslow.comps),
+ "noOfAssetsThatIsCached": (pageData.yslow.comps.length - pageData.yslow.g.expiresmod.components.length),
+ "assetsPerDomain": util.getAssetsPerDomain(pageData.yslow.comps),
+ "assetsPerContentType": util.getAssetsPerContentType(pageData.yslow.comps),
+ "sizePerContentType": util.getAssetsSizePerContentType(pageData.yslow.comps),
+ "ruleDictionary": pageData.yslow.dictionary.rules,
+ };
+ }
+ else {
+ renderData.url = util.getURLFromPageData(pageData);
+ }
+
+ renderData.gpsiData = pageData.gpsi;
+ renderData.browsertimeData = pageData.browsertime;
+ renderData.wptData = pageData.webpagetest;
+ renderData.config = config;
+ renderData.pageMeta = {
+ "path": "../",
+ "title": "Page data, collected by sitespeed.io for page " + url,
+ "description": "All data collected for this individual page."
+ };
+ var hash = util.getUrlHash(url);
+ renderHtmlToFile('page', renderData, hash + '.html', 'pages');
+};
+
+HTMLRenderer.prototype.renderRules = function () {
+ var renderData = {
+ "ruleDictionary": ruleDictionary,
+ "config": config,
+ "pageMeta": {
+ "title": "The sitespeed.io rules used by this run",
+ "description": "",
+ "isRules": true
+ }
+ };
+renderHtmlToFile('rules', renderData);
+};
+
+HTMLRenderer.prototype.renderScreenshots = function (pages) {
+ var renderData = {
+ "pages": pages,
+ "config": config,
+ "pageMeta": {
+ "title": "",
+ "description": "",
+ "isScreenshots": true
+ }
+ };
+renderHtmlToFile('screenshots', renderData);
+};
+
+
+HTMLRenderer.prototype.renderErrors = function (downloadErrors, analysisErrors) {
+ var renderData = {
+ "errors": {
+ "downloadErrorUrls": downloadErrors,
+ "analysisErrorUrls": analysisErrors
+ },
+ "totalErrors": Object.keys(downloadErrors).length + Object.keys(analysisErrors).length ,
+ "config": config,
+ "numberOfPages":this.numberOfAnalyzedPages,
+ "pageMeta": {
+ "title": "Pages that couldn't be analyzed",
+ "description": "Here are the pages that couldn't be analyzed by sitespeed.io",
+ "isErrors": true
+ }
+};
+renderHtmlToFile('errors', renderData);
+};
+
+HTMLRenderer.prototype.renderSummary = function (aggregates) {
+ // TODO change to reduce
+ var filtered = aggregates.filter(function(box) {
+ return (config.summaryBoxes.indexOf(box.id) > -1);
+ }).sort(function(box, box2) {
+ return config.summaryBoxes.indexOf(box.id) - config.summaryBoxes.indexOf(box2.id);
+ });
+ var renderData = {
+ "aggregates": filtered,
+ "config": config,
+ "numberOfPages":this.numberOfAnalyzedPages,
+ "pageMeta": {
+ "title": "Summary of the sitespeed.io result",
+ "description": "A executive summary.",
+ "isSummary": true
+ }
+ };
+
+ renderHtmlToFile('site-summary', renderData, 'index.html');
+
+ renderData = {
+ "aggregates": aggregates,
+ "config": config,
+ "numberOfPages":this.numberOfAnalyzedPages,
+ "pageMeta": {
+ "title": "In details summary of the sitespeed.io result",
+ "description": "The summary in details.",
+ "isDetailedSummary": true
+ }
+ };
+ renderHtmlToFile('detailed-site-summary', renderData);
+};
+
+HTMLRenderer.prototype.renderPages = function (pages) {
+ var renderData = {
+ "pages": pages,
+ "columnsMeta": columnsMetaData,
+ "config": config,
+ "ruleDictionary": ruleDictionary,
+ "numberOfPages":this.numberOfAnalyzedPages,
+ "pageMeta": {
+ "title": "All pages information",
+ "description": "All request data, for all the pages",
+ "isPages": true
+ }
+ };
+
+ renderHtmlToFile('pages', renderData);
+};
+
+HTMLRenderer.prototype.renderAssets = function (assets) {
+
+ var sorted = assets.sort(function(asset, asset2) {
+ return asset2.count - asset.count;
+ });
+
+ if (sorted.length>200)
+ sorted.length = 200;
+
+ var renderData = {
+ "assets": sorted,
+ "config": config,
+ "numberOfPages":this.numberOfAnalyzedPages,
+ "pageMeta": {
+ "title": "The most used assets",
+ "description": "A list of the most used assets for the analyzed pages.",
+ "isAssets": true
+ }
+ };
+ renderHtmlToFile('assets', renderData);
+};
+
+function renderHtmlToFile(template, renderData, fileName, optionalPath) {
+ fileName = fileName || (template + ".html");
+ optionalPath = optionalPath || '';
+ var result = compiledTemplates[template](renderData);
+ var file = path.join(config.run.absResultDir, optionalPath, fileName);
+ fs.outputFile(file, result, function(err) {
+ if (err)
+ log.log('error', "Couldn't write the file " + file + ' err:' + err);
+ });
+}
+
+function precompileTemplates() {
+ compiledTemplates = compileTemplates(path.join(__dirname, "../templates/"));
+ compiledPartials = compileTemplates(path.join(__dirname, "../templates/partials/"));
+
+ for (var key in compiledPartials) {
+ hb.registerPartial(key, compiledPartials[key]);
+ }
+}
+
+function compileTemplates(folderPath) {
+ var templates = {};
+ fs.readdirSync(folderPath).forEach(function (file) {
+ if (!fs.lstatSync(path.join(folderPath + file)).isDirectory())
+ templates[path.basename(file, '.hb')] = hb.compile(fs.readFileSync(path.join(folderPath + file), 'utf8'));
+ });
+ return templates;
+}
diff --git a/lib/junitRenderer.js b/lib/junitRenderer.js
new file mode 100644
index 000000000..097ff7e57
--- /dev/null
+++ b/lib/junitRenderer.js
@@ -0,0 +1,200 @@
+/**
+ * Sitespeed.io - How speedy is your site? (http://www.sitespeed.io)
+ * Copyright (c) 2014, Peter Hedenskog, Tobias Lidskog
+ * and other contributors
+ * Released under the Apache 2.0 License
+ */
+var builder = require('xmlbuilder'),
+ config = require('./conf'),
+ fs = require('fs-extra'),
+ path = require('path'),
+ util = require('./util');
+
+module.exports = JUnitRenderer;
+
+function JUnitRenderer(collector) {
+ this.collector = collector;
+ this.ruleTestsuites = builder.create('testsuites', {
+ version: '1.0',
+ encoding: 'UTF-8'
+ });
+ this.timingTestsuites = builder.create('testsuites', {
+ version: '1.0',
+ encoding: 'UTF-8'
+ });
+}
+
+JUnitRenderer.prototype.renderForEachPage = function(url, pageData) {
+
+ var yslowData = pageData.yslow,
+ ruleDictionary = yslowData.dictionary.rules,
+ rules = pageData.yslow.g,
+ score = pageData.yslow.o,
+ browserTimeData = pageData.browsertime;
+ generateRuleTestSuitePerPage(url, score, rules, ruleDictionary, this.ruleTestsuites);
+
+ if (browserTimeData)
+ generateBrowserTimeTestSuitePerPage(browserTimeData, this.timingTestsuites);
+
+};
+
+function generateBrowserTimeTestSuitePerPage(browserTimeData, timingTestsuites) {
+
+ browserTimeData.forEach(function(run) {
+ var testsuite = timingTestsuites.ele('testsuite', {
+ 'name': 'sitespeed.io.timings.' + run.pageData.url.replace(/\./g, '_')
+ });
+
+ var url = run.pageData.url;
+
+ // First check if we have specific values configured for that URL else use the default ones
+ if (config.timingThresholds.pages) {
+ if (config.timingThresholds.pages.hasOwnProperty(url)) {
+
+ Object.keys(config.timingThresholds.pages[url]).forEach(function(
+ timing) {
+ run.statistics.forEach(function(stats) {
+ if (stats.name === timing) {
+ generateTimingTestCase(stats, timing, run, testsuite,
+ config.timingThresholds
+ .pages[url][timing]);
+ }
+ });
+ });
+ }
+ // Use default values
+ else {
+ Object.keys(config.timingThresholds.
+ default).forEach(function(timing) {
+ run.statistics.forEach(function(stats) {
+ if (stats.name === timing) {
+ generateTimingTestCase(stats, timing, run, testsuite,
+ config.timingThresholds.
+ default [timing]);
+ }
+ });
+ });
+ }
+ }
+ });
+}
+
+function generateTimingTestCase(stats, timing, run, testsuite, limit) {
+ var browser = run.pageData.browserName,
+ version = run.pageData.browserVersion,
+ url = run.pageData.url;
+
+ // The time in Jenkins needs to be in seconds
+ var testCase = testsuite.ele('testcase', {
+ 'name': timing,
+ 'time': stats[config.timingThresholds.type] / 1000
+ });
+
+ // is it a failure
+ if (stats[config.timingThresholds.type] > limit) {
+ testCase.ele('failure', {
+ 'type': 'failedTiming',
+ 'message': 'The time for ' + timing + ' is ' + stats[
+ config.timingThresholds.type] +
+ ' ms, that is higher than your limit of ' + limit + ' ms. Using ' +
+ browser + ' ' +
+ version + ' ' + config.timingThresholds.type + ' value'
+ });
+
+ }
+}
+
+
+function generateRuleTestSuitePerPage(url, score, rules, ruleDictionary,
+ testsuites) {
+ var rule = Object.keys(rules);
+
+ var failures = 0,
+ skipped = 0;
+
+ var testsuite = testsuites.ele('testsuite', {
+ 'name': 'sitespeed.io.rules.' + url.replace(/\./g, '_'),
+ 'tests': (rule.length + 1)
+ });
+ var overallPageTestCase = testsuite.ele('testcase');
+
+ overallPageTestCase.att({
+ 'name': 'Overall page score',
+ 'status': score
+ });
+ if (isFailure("overall", score)) {
+ overallPageTestCase.ele('failure', {
+ 'type': 'failedRule',
+ 'message': 'The average overall page score ' + score +
+ ' is below your limit'
+ });
+ failures++;
+ }
+
+
+ for (var i = 0; i < rule.length; i++) {
+
+ // is this skippable?
+ if (config.skipTest) {
+ if (config.skipTest.indexOf(rule[i]) > -1) {
+ skipped++;
+ continue;
+ }
+ }
+
+ var testCase = testsuite.ele('testcase', {
+ 'name': '(' + rule[i] + ') ' + ruleDictionary[rule[i]].name,
+ 'status': rules[rule[i]].score
+ });
+
+ if (isFailure(rule[i], rules[rule[i]].score)) {
+ failures++;
+ var failure = testCase.ele('failure', {
+ 'type': 'failedRule',
+ 'message': 'Score ' + score + ' - ' + rules[rule[i]].message
+ });
+
+ var comps = '';
+ rules[rule[i]].components.forEach(function(comp) {
+ comps += util.decodeURIComponent(comp) + '\n';
+ });
+
+ failure.txt(comps);
+ }
+
+ }
+
+ testsuite.att('failures', failures);
+ testsuite.att('skipped', skipped);
+}
+
+function isFailure(ruleid, value) {
+ if (config.thresholds) {
+ if (config.thresholds.hasOwnProperty(ruleid))
+ return (value < config.thresholds[ruleid]);
+ else return (value < config.threshold);
+ } else return (value < config.threshold);
+}
+
+JUnitRenderer.prototype.renderAfterFullAnalyse = function() {
+ // create testsuites and write to disk
+ var rulesXML = this.ruleTestsuites.end({
+ pretty: true,
+ indent: ' ',
+ newline: '\n'
+ });
+ var timingXML = this.timingTestsuites.end({
+ pretty: true,
+ indent: ' ',
+ newline: '\n'
+ });
+
+ renderXMLFile(rulesXML,"junit.xml");
+ renderXMLFile(timingXML,"junit-timings.xml");
+
+};
+
+function renderXMLFile(xml, fileName) {
+ console.log("Writing " + fileName);
+ fs.outputFileSync(path.join(config.run.absResultDir,fileName), xml);
+}
diff --git a/lib/log.js b/lib/log.js
new file mode 100644
index 000000000..8e43640d8
--- /dev/null
+++ b/lib/log.js
@@ -0,0 +1,15 @@
+/**
+ * Sitespeed.io - How speedy is your site? (http://www.sitespeed.io)
+ * Copyright (c) 2014, Peter Hedenskog, Tobias Lidskog
+ * and other contributors
+ * Released under the Apache 2.0 License
+ */
+var winston = require('winston'),
+ path = require('path'),
+ config = require('./conf');
+
+winston.add(winston.transports.File, {
+ filename: path.join(config.run.absResultDir, 'info.log'),
+ level: 'info'
+});
+// winston.remove(winston.transports.Console);
diff --git a/lib/runner.js b/lib/runner.js
new file mode 100644
index 000000000..e2e1d7a28
--- /dev/null
+++ b/lib/runner.js
@@ -0,0 +1,159 @@
+/**
+ * Sitespeed.io - How speedy is your site? (http://www.sitespeed.io)
+ * Copyright (c) 2014, Peter Hedenskog, Tobias Lidskog
+ * and other contributors
+ * Released under the Apache 2.0 License
+ */
+var crawler = require('./crawler'),
+ Analyzer = require('./analyze/analyzer'),
+ HTMLRenderer = require('./htmlRenderer'),
+ Collector = require('./collector'),
+ JUnitRenderer = require('./junitRenderer'),
+ Graphite = require('./graphite'),
+ logger = require('./log'),
+ path = require('path'),
+ fs = require('fs-extra'),
+ config = require('./conf'),
+ log = require('winston');
+
+module.exports = Runner;
+
+function Runner() {
+ var self = this;
+ this.analyzer = new Analyzer(function(err) {
+ self.analysisComplete(err);
+ });
+ this.collector = new Collector();
+ this.htmlRenderer = new HTMLRenderer();
+ this.junitRenderer = new JUnitRenderer(this.collector);
+ this.graphite = new Graphite(config.graphiteHost, config.graphitePort, config
+ .graphiteNamespace, this.collector);
+ this.downloadErrors = {};
+ this.analysisErrors = {};
+}
+
+
+Runner.prototype.analysisComplete = function(err) {
+ log.log('info', 'Done analyzing urls');
+
+ log.log('info', 'Render summary');
+ var aggregates = this.collector.createAggregates();
+ this.htmlRenderer.renderSummary(aggregates);
+
+ log.log('info', 'Render assets');
+ var assets = this.collector.createCollections().assets;
+ this.htmlRenderer.renderAssets(assets);
+
+ log.log('info', 'Render pages');
+ var pages = this.collector.createCollections().pages;
+ this.htmlRenderer.renderPages(pages);
+
+ log.log('info', 'Render rules');
+ this.htmlRenderer.renderRules();
+
+ if (config.screenshot) {
+ this.htmlRenderer.renderScreenshots(pages);
+ }
+
+ log.log('info', 'Render errors');
+ this.htmlRenderer.renderErrors(this.downloadErrors, this.analysisErrors);
+ if (config.graphiteHost)
+ this.graphite.sendPageData(aggregates, pages);
+ if (config.junit)
+ this.junitRenderer.renderAfterFullAnalyse();
+
+ log.log('info', "Wrote results to " + config.run.absResultDir);
+
+};
+
+
+Runner.prototype.run = function() {
+
+ // setup the directories needed
+ fs.mkdirsSync(path.join(config.run.absResultDir, config.dataDir));
+
+ // store the config file, so we can backtrack errors and/or use it again
+ fs.writeFile(path.join(config.run.absResultDir, 'config.json'), JSON.stringify(
+ config), function(err) {
+ if (err) throw err;
+ });
+
+ console.time("sitespeed.io");
+ if (config.url) {
+ log.log('info', "Will crawl from start point " + config.url +
+ " with crawl depth " + config.deep);
+ this.crawl(config.urlObject);
+ } else {
+ log.log('info', "Will fetch urls from the file " + config.file);
+ this.readFromFile(config.file);
+ }
+};
+
+Runner.prototype.readFromFile = function(file) {
+ var urls = fs.readFileSync(file).toString().split("\n");
+ urls = urls.filter(function(l) {
+ return l.length > 0;
+ });
+ analyzeUrls(urls);
+};
+
+Runner.prototype.crawl = function(url) {
+ var self = this;
+ crawler.crawl(url, function(okUrls, errorUrls) {
+ self.handleResult(okUrls, errorUrls);
+ });
+};
+
+Runner.prototype.handleResult = function(okUrls, errorUrls) {
+ var downloadErrors = this.downloadErrors;
+ Object.keys(errorUrls).forEach(function(url) {
+ log.log('error', "Failed to download " + url);
+ downloadErrors[url] = errorUrls[url];
+ });
+
+ // limit
+ if (config.maxPagesToTest) {
+ if (okUrls.length > config.maxPagesToTest)
+ okUrls.length = config.maxPagesToTest;
+ }
+ if (okUrls.length === 0) {
+ log.log('info', "Didn't get any URLs from the crawl");
+ return;
+ }
+
+ saveUrls(okUrls);
+
+ this.analyzeUrls(okUrls);
+};
+
+function saveUrls(urls) {
+ fs.writeFile(path.join(config.run.absResultDir, 'data', 'urls.txt'), urls.join(
+ "\n"), function(err) {
+ if (err) {
+ throw err;
+ }
+ });
+}
+
+Runner.prototype.analyzeUrls = function(urls) {
+ console.log("Will analyze " + urls.length + " pages");
+ var junitRenderer = this.junitRenderer;
+ var htmlRenderer = this.htmlRenderer;
+ var analysisErrors = this.analysisErrors;
+ this.analyzer.analyze(urls, this.collector, function(err, url, pageData) {
+
+ if (err) {
+ log.log('error', 'Could not analyze ' + url + ' (' + JSON.stringify(err) +
+ ')');
+ analysisErrors[url] = err;
+ return;
+ }
+
+ if (config.junit)
+ junitRenderer.renderForEachPage(url, pageData);
+ htmlRenderer.renderPage(url, pageData);
+ }
+
+
+ );
+};
diff --git a/lib/screenshot.js b/lib/screenshot.js
new file mode 100644
index 000000000..a8744124b
--- /dev/null
+++ b/lib/screenshot.js
@@ -0,0 +1,47 @@
+var page = require('webpage').create(),
+ address, output, size, w, h, agent, full, basicauth, auth;
+
+
+if (phantom.args.length < 5 || phantom.args.length > 7) {
+ console.log('Usage: screenshot.js URL filename width height user-agent full basic:auth');
+ phantom.exit();
+} else {
+ address = phantom.args[0];
+ output = phantom.args[1];
+ w = phantom.args[2];
+ h = phantom.args[3];
+ agent = phantom.args[4];
+ full = phantom.args[5];
+ basicauth = phantom.args[6];
+
+ if (basicauth) {
+ auth = basicauth.split(":");
+ page.settings.userName = auth[0];
+ page.settings.password = auth[1];
+ }
+
+
+ page.viewportSize = {
+ width: w,
+ height: h
+ };
+ page.settings.userAgent = agent;
+ page.open(address, function(status) {
+ if (status !== 'success') {
+ console.log('Unable to load the address!');
+ } else {
+ window.setTimeout(function() {
+
+ if (full != 'true')
+ page.clipRect = {
+ left: 0,
+ top: 0,
+ width: w,
+ height: h
+ };
+ page.render(output);
+ phantom.exit();
+ }, 200);
+ }
+ });
+}
diff --git a/lib/util.js b/lib/util.js
new file mode 100644
index 000000000..a6db44013
--- /dev/null
+++ b/lib/util.js
@@ -0,0 +1,411 @@
+/**
+ * Sitespeed.io - How speedy is your site? (http://www.sitespeed.io)
+ * Copyright (c) 2014, Peter Hedenskog, Tobias Lidskog
+ * and other contributors
+ * Released under the Apache 2.0 License
+ */
+var Stats = require('fast-stats').Stats,
+ crypto = require('crypto'),
+ config = require('./conf'),
+ url = require('url');
+
+module.exports = {
+ /**
+ * Get the cache time in seconds for a YSlow component
+ * a.k.a asset.
+ *
+ *
+ * @param {YSLOW.component} comp a component
+ * @return {Integer} The cache time in seconds
+ */
+ getCacheTime: function(comp) {
+
+ // This is how we do it: max-age will always win (HTTP 1.1)
+ // If max-age is found use it, else expires
+ // if no cache header, return 0
+ var maxAgeRegExp = /max-age=(\d+)/,
+ expireTime = 0;
+
+ var response = comp.headers.response;
+ for (var headerName in response) {
+ if (! response.hasOwnProperty(headerName))
+ continue;
+
+ // Cache-control always wins before Expires
+ // in the HTTP spec
+ if ('cache-control' === headerName.toLowerCase()) {
+ var cacheControl = response[headerName];
+ if (cacheControl) {
+ if (cacheControl.indexOf('no-cache') !== -1 ||
+ cacheControl.indexOf('no-store') !== -1) {
+ return 0;
+ }
+ var matches = cacheControl.match(maxAgeRegExp);
+ if (matches) {
+ return parseInt(matches[1], 10);
+ }
+ }
+
+ } else if ('expires' === headerName.toLowerCase()) {
+ var expiresDate = new Date(response[headerName]);
+ var now = new Date().getTime();
+ expireTime = expiresDate.getTime() - now;
+ }
+ }
+
+ return expireTime;
+ },
+
+ /**
+ * Get the cache time statistics for
+ * all YSlow components.
+ */
+ getCacheTimeStats: function(components) {
+ var stats = new Stats();
+
+ components.forEach(function(comp) {
+ stats.push(module.exports.getCacheTime(comp));
+ });
+
+ return module.exports.getStatisticsObject(stats,0);
+ },
+
+ /**
+ * Get the last modification time statistics for
+ * all YSlow components.
+ */
+ getLastModStats: function(components) {
+ var stats = new Stats();
+
+ components.forEach(function(comp) {
+ stats.push(module.exports.getTimeSinceLastMod(comp));
+ });
+
+ return module.exports.getStatisticsObject(stats,0);
+ },
+
+ /**
+ * Get the time in seconds since a component was
+ * last modified. If the server doesn't send a
+ * last-modified header, the modified time will
+ * be set to now.
+ *
+ *
+ * @param the YSlow component
+ * @return {Integer} The time in seconds or -1 if unknown
+ */
+ getTimeSinceLastMod: function(comp) {
+ var now = new Date();
+ var lastModifiedDate;
+ var response = comp.headers.response;
+ for (var headerName in response) {
+ if (! response.hasOwnProperty(headerName))
+ continue;
+
+ if ('last-modified' === headerName.toLowerCase()) {
+ lastModifiedDate = new Date(response[headerName]);
+ } else if ('date' === headerName.toLowerCase()) {
+ now = new Date(response[headerName]);
+ }
+ }
+
+ // TODO how do we define this?
+ if (!lastModifiedDate)
+ return -1;
+
+ return (now.getTime() - lastModifiedDate.getTime()) / 1000;
+ },
+
+ /**
+ * Print seconds as the largest available time.
+ * @param {Integer} seconds A number in seconds
+ * @return {String} The time in nearest largest definition.
+ */
+ prettyPrintSeconds: function(seconds) {
+
+ if (seconds === -1) return -1;
+
+ var secondsPerYear = 365 * 24 * 60 * 60,
+ secondsPerWeek = 60 * 60 * 24 * 7,
+ secondsPerDay = 60 * 60 * 24,
+ secondsPerHour = 60 * 60,
+ secondsPerMinute = 60,
+ sign = (seconds < 0) ? "-" : "";
+
+ if (seconds < 0)
+ seconds = Math.abs(seconds);
+
+ if (seconds / secondsPerYear >= 1)
+ return sign + Math.round(seconds / secondsPerYear) + " year" + ((Math.round(
+ seconds / secondsPerYear) > 1) ? "s" : "");
+ else if (seconds / secondsPerWeek >= 1)
+ return sign + Math.round(seconds / secondsPerWeek) + " week" + ((Math.round(
+ seconds / secondsPerWeek) > 1) ? "s" : "");
+ else if (seconds / secondsPerDay >= 1)
+ return sign + Math.round(seconds / secondsPerDay) + " day" + ((Math.round(
+ seconds / secondsPerDay) > 1) ? "s" : "");
+ else if (seconds / secondsPerHour >= 1)
+ return sign + Math.round(seconds / secondsPerHour) + " hour" + ((Math.round(
+ seconds / secondsPerHour) > 1) ? "s" : "");
+ else if (seconds / secondsPerMinute >= 1)
+ return sign + Math.round(seconds / secondsPerMinute) + " minute" + ((
+ Math.round(seconds / secondsPerMinute) > 1) ? "s" : "");
+ else return sign + seconds + " second" + ((seconds > 1) ? "s" : "");
+ },
+
+ /**
+ * Get seconds, milliseconds or bytes in a human readable format.
+ * Will turn seconds into the largest avalible time format (minutes, hours etc),
+ * add ms to milliseconds and turn bytes into kiloytes.
+ */
+ getHumanReadable: function(data, value, showUnit) {
+ if (data.unit === 'seconds')
+ return this.prettyPrintSeconds(value);
+ else if (data.unit === 'milliseconds')
+ return value + (showUnit ? ' ms':'');
+ else if (data.unit === 'bytes')
+ return this.getKbSize(value, showUnit);
+ else return value;
+ },
+
+ /**
+ * If we have a matching rule definition, we will return the
+ * matching Bootstrap CSS name, so that the CSS will have the right color.
+ */
+ getRuleColor: function(rule, value) {
+ if (config.rules[rule]) {
+ var diff = config.rules[rule].warning - config.rules[rule].error;
+ if (diff > 0) {
+ if (value>config.rules[rule].warning)
+ return 'success';
+ else if (value>config.rules[rule].error)
+ return 'warning';
+ return 'danger';
+ }
+ else {
+ if (value 100 ? 100 : 10);
+ size -= remainder;
+ return parseFloat(size / 1000) + (0 === (size % 1000) ? ".0" : "") + (showUnit?' kb':'');
+ },
+
+ select: function(object, keyPath, defaultValue) {
+ return keyPath.split('.').reduce(function (result, key) {
+ result = result[key];
+ return result || defaultValue;
+ }, object);
+ },
+
+ decodeURIComponent: function(value) {
+ try {
+ return decodeURIComponent(value);
+ } catch (err) {
+ return value;
+ }
+ },
+
+ /**
+ * Get the URL as a hash so it can be stored on disk.
+ */
+ getUrlHash: function(u) {
+ var urlComponents = url.parse(u);
+ var hash = crypto.createHash('md5').update(u).digest('hex').substr(0, 7);
+ var name = urlComponents.pathname;
+ if (name == '/') {
+ name = urlComponents.hostname;
+ } else {
+ name = name.replace(/^\/|\/$/g, '').split('/').pop();
+ name = name.split('.')[0];
+ }
+ return encodeURIComponent(name) + '-' + hash;
+ },
+
+ /**
+ * Get the hostname from a URL String
+ */
+ getHostname: function(u) {
+ u = this.decodeURIComponent(u);
+ var hostname = u.split('/')[2];
+ return (hostname && hostname.split(':')[0]) || '';
+ },
+
+ /**
+ * Get a usable view of the statistics object. Will format the
+ * result to decimals.
+ */
+ getStatisticsObject: function(stats, decimals) {
+ return {
+ min: stats.percentile(0).toFixed(decimals),
+ max: stats.percentile(100).toFixed(decimals),
+ p10: stats.percentile(10).toFixed(decimals),
+ p70: stats.percentile(70).toFixed(decimals),
+ p80: stats.percentile(80).toFixed(decimals),
+ p90: stats.percentile(90).toFixed(decimals),
+ p99: stats.percentile(99).toFixed(decimals),
+ median: stats.median().toFixed(decimals),
+ mean: stats.amean().toFixed(decimals)
+ };
+ },
+
+ /**
+ * Get the number of domains used for YSlow
+ * components
+ */
+ getNumberOfDomains: function(components) {
+ var self = this;
+ var domains = this.aggregate(components,
+ function (comp) {
+ return self.getHostname(comp.url);
+ }
+ );
+
+ return Object.keys(domains).length;
+ },
+
+ /**
+ * Get the size in bytes for a specific domain
+ */
+ getSizeForDomain: function (domain, components) {
+ var self = this;
+ var hostAndSize = this.aggregate(components,
+ function (comp) {
+ return self.getHostname(comp.url);
+ },
+ function (comp) {
+ return comp.size;
+ }
+ );
+
+ return hostAndSize[domain];
+ },
+
+ /**
+ * Get the number of assets per domain.
+ */
+ getAssetsPerDomain: function(components) {
+ var self = this;
+ return this.aggregate(components, function (comp) {
+ return self.getHostname(comp.url);
+ });
+ },
+
+
+ /**
+ * Get the number of assets per content type.
+ */
+ getAssetsPerContentType: function(components) {
+ return this.aggregate(components, function (comp) {
+ return comp.type;
+ });
+ },
+
+ /**
+ * Get the size in bytes per content type.
+ */
+ getAssetsSizePerContentType: function(components) {
+ return this.aggregate(components,
+ function (comp) {
+ return comp.type;
+ },
+ function (comp) {
+ return comp.size;
+ }
+ );
+ },
+
+ aggregate: function (array, keyFunction, valueFunction) {
+ return array.reduce(function (result, item) {
+ var key = keyFunction ? keyFunction(item) : item;
+ var value = valueFunction ? valueFunction(item) : 1;
+
+ if (result.hasOwnProperty(key)) {
+ result[key] += value;
+ } else {
+ result[key] = value;
+ }
+ return result;
+ }, {});
+ },
+
+ /**
+ * Hack to format Google Page Speed Insights result
+ *
+ **/
+ gpsiReplacer: function(args, text) {
+
+ if (args.length === 1) {
+ return text.replace('$1', args[0].value);
+ } else if (args.length === 2) {
+ return text.replace('$1', args[0].value).replace('$2', args[1].value);
+ } else if (args.length === 3) {
+ return text.replace('$1', args[0].value).replace('$2', args[1].value).replace(
+ '$3', args[2].value);
+ } else return text;
+ },
+
+ /**
+ * Get the URL from pageData.
+ */
+ getURLFromPageData: function(pageData) {
+ if (pageData.yslow)
+ return pageData.yslow.originalUrl;
+ else if (pageData.browsertime)
+ return pageData.browsertime[0].pageData.url;
+ else if (pageData.gpsi)
+ return pageData.gpsi.id;
+ return 'undefined';
+ },
+
+ getGraphiteURLKey: function(theUrl) {
+ myUrl = url.parse(theUrl);
+ var protocol = myUrl.protocol.replace(':', '');
+ var hostname = myUrl.hostname;
+ var path = myUrl.pathname;
+
+
+ if (path.indexOf(".") > -1) path = path.replace(".", "_");
+ if (path.indexOf("~") > -1) path = path.replace("~", "_");
+
+
+ if (path === '' || path === '/')
+ return protocol + '.' + hostname + '.slash.';
+
+
+ var key = protocol + '.' + hostname + '.' + path.replace('/', '.');
+ if (key.indexOf('.', key.length - 1) !== -1)
+ return key;
+ else return key + '.';
+
+
+}
+};
diff --git a/lib/yslow-3.1.8-sitespeed.js b/lib/yslow-3.1.8-sitespeed.js
new file mode 100644
index 000000000..5ceb8347c
--- /dev/null
+++ b/lib/yslow-3.1.8-sitespeed.js
@@ -0,0 +1,11717 @@
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyright (c) 2013, Marcel Duran and other contributors. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global phantom, YSLOW*/
+/*jslint browser: true, evil: true, sloppy: true, regexp: true*/
+
+/**
+ * JSLint is tolerating evil because there's a Function constructor needed to
+ * inject the content coming from phantom arguments and page resources which is
+ * later evaluated into the page in order to run YSlow.
+ */
+
+// For using yslow in phantomjs, see instructions @ http://yslow.org/phantomjs/
+
+// parse args
+var i, arg, page, urlCount, viewport,
+ webpage = require('webpage'),
+ args = phantom.args,
+ len = args.length,
+ urls = [],
+ yslowArgs = {
+ info: 'all',
+ format: 'json',
+ ruleset: 'ydefault',
+ beacon: false,
+ ua: false,
+ viewport: false,
+ headers: false,
+ console: 0,
+ threshold: 80,
+ cdns: '',
+ file:'',
+ basicauth: ''
+ },
+ unaryArgs = {
+ help: false,
+ version: false,
+ dict: false,
+ verbose: false
+ },
+ argsAlias = {
+ i: 'info',
+ f: 'format',
+ r: 'ruleset',
+ h: 'help',
+ V: 'version',
+ d: 'dict',
+ u: 'ua',
+ vp: 'viewport',
+ c: 'console',
+ b: 'beacon',
+ v: 'verbose',
+ t: 'threshold',
+ ch: 'headers',
+ ba: 'basicauth'
+ };
+
+// loop args
+for (i = 0; i < len; i += 1) {
+ arg = args[i];
+ if (arg[0] !== '-') {
+ // url, normalize if needed
+ if (arg.indexOf('http') !== 0) {
+ arg = 'http://' + arg;
+ }
+ urls.push(arg);
+ }
+ arg = arg.replace(/^\-\-?/, '');
+ if (yslowArgs.hasOwnProperty(arg)) {
+ // yslow argument
+ i += 1;
+ yslowArgs[arg] = args[i];
+ } else if (yslowArgs.hasOwnProperty(argsAlias[arg])) {
+ // yslow argument alias
+ i += 1;
+ yslowArgs[argsAlias[arg]] = args[i];
+ } else if (unaryArgs.hasOwnProperty(arg)) {
+ // unary argument
+ unaryArgs[arg] = true;
+ } else if (unaryArgs.hasOwnProperty(argsAlias[arg])) {
+ // unary argument alias
+ unaryArgs[argsAlias[arg]] = true;
+ }
+}
+urlCount = urls.length;
+
+// check for version
+if (unaryArgs.version) {
+ console.log('3.1.8');
+ phantom.exit();
+}
+
+// print usage
+if (len === 0 || urlCount === 0 || unaryArgs.help) {
+ console.log([
+ '',
+ ' Usage: phantomjs [phantomjs options] ' + phantom.scriptName + ' [yslow options] [url ...]',
+ '',
+ ' PhantomJS Options:',
+ '',
+ ' http://y.ahoo.it/phantomjs/options',
+ '',
+ ' YSlow Options:',
+ '',
+ ' -h, --help output usage information',
+ ' -V, --version output the version number',
+ ' -i, --info specify the information to display/log (basic|grade|stats|comps|all) [all]',
+ ' -f, --format specify the output results format (json|xml|plain|tap|junit) [json]',
+ ' -r, --ruleset specify the YSlow performance ruleset to be used (ydefault|yslow1|yblog) [ydefault]',
+ ' -b, --beacon specify an URL to log the results',
+ ' -d, --dict include dictionary of results fields',
+ ' -v, --verbose output beacon response information',
+ ' -t, --threshold for test formats, the threshold to test scores ([0-100]|[A-F]|{JSON}) [80]',
+ ' e.g.: -t B or -t 75 or -t \'{"overall": "B", "ycdn": "F", "yexpires": 85}\'',
+ ' -u, --ua "" specify the user agent string sent to server when the page requests resources',
+ ' -vp, --viewport specify page viewport size WxY, where W = width and H = height [400x300]',
+ ' -ch, --headers specify custom request headers, e.g.: -ch \'{"Cookie": "foo=bar"}\'',
+ ' -c, --console output page console messages (0: none, 1: message, 2: message + line + source) [0]',
+ ' --cdns "" specify comma separated list of additional CDNs',
+ ' -ba, --basicauth "" username & password used for basic auth',
+ ' --file output the result to file',
+ '',
+ ' Examples:',
+ '',
+ ' phantomjs ' + phantom.scriptName + ' http://yslow.org',
+ ' phantomjs ' + phantom.scriptName + ' -i grade -f xml www.yahoo.com www.cnn.com www.nytimes.com',
+ ' phantomjs ' + phantom.scriptName + ' --info all --format plain --ua "MSIE 9.0" http://yslow.org',
+ ' phantomjs ' + phantom.scriptName + ' -i basic --rulseset yslow1 -d http://yslow.org',
+ ' phantomjs ' + phantom.scriptName + ' -i grade -b http://www.showslow.com/beacon/yslow/ -v yslow.org',
+ ' phantomjs --load-plugins=yes ' + phantom.scriptName + ' -vp 800x600 http://www.yahoo.com',
+ ' phantomjs ' + phantom.scriptName + ' -i grade -f tap -t 85 http://yslow.org',
+ ''
+ ].join('\n'));
+ phantom.exit();
+}
+
+// set yslow unary args
+yslowArgs.dict = unaryArgs.dict;
+yslowArgs.verbose = unaryArgs.verbose;
+
+// loop through urls
+urls.forEach(function (url) {
+ var page = webpage.create();
+
+ // set user agent string
+ if (yslowArgs.basicauth) {
+ auth = yslowArgs.basicauth.split(":");
+ page.settings.userName = auth[0];
+ page.settings.password = auth[1];
+ }
+
+ page.resources = {};
+
+ // allow x-domain requests, used to retrieve components content
+ page.settings.webSecurityEnabled = false;
+
+ // this is a hack for sitespeed.io 2.0 for solving the
+ // redirect issue in YSLow.
+ page.redirects = [];
+
+ // request
+ page.onResourceRequested = function (req) {
+ page.resources[req.url] = {
+ request: req
+ };
+ };
+
+ // response
+ page.onResourceReceived = function (res) {
+ var info,
+ resp = page.resources[res.url].response;
+
+ // hack for taking care of redirects
+ if (res.stage === 'end' )
+ if (res.status === 301 || res.status === 302) {
+ var locationValue;
+ for (var i = 0; i < res.headers.length; i++) {
+ if (res.headers[i].name==='Location')
+ locationValue = res.headers[i].value;
+ }
+ page.redirects.push('From ' + res.url + ' to ' + locationValue + '.');
+ }
+
+ if (!resp) {
+ page.resources[res.url].response = res;
+ } else {
+ for (info in res) {
+ if (res.hasOwnProperty(info)) {
+ resp[info] = res[info];
+ }
+ }
+ }
+ };
+
+ // used for better error messages
+ page.onResourceError = function(resourceError) {
+ page.reason = resourceError.errorString;
+ page.reason_url = resourceError.url;
+ };
+
+ // supressing all errors for now
+ /*
+ page.onConsoleMessage = function (msg){};
+ page.onAlert = function (msg) {};
+ page.onError = function(msg, trace) {};
+ */
+ // enable console output, useful for debugging
+
+ yslowArgs.console = parseInt(yslowArgs.console, 10) || 0;
+ if (yslowArgs.console) {
+ if (yslowArgs.console === 1) {
+ page.onConsoleMessage = function (msg) {
+ console.log(msg);
+ };
+ page.onError = function (msg) {
+ console.error(msg);
+ };
+ } else {
+ page.onConsoleMessage = function (msg, line, source) {
+ console.log(JSON.stringify({
+ message: msg,
+ lineNumber: line,
+ source: source
+ }, null, 4));
+ };
+ page.onError = function (msg, trace) {
+ console.error(JSON.stringify({
+ message: msg,
+ stacktrace: trace
+ }));
+ };
+ }
+ } else {
+ page.onError = function () {
+ // catch uncaught error from the page
+ };
+ }
+
+
+ // set user agent string
+ if (yslowArgs.ua) {
+ page.settings.userAgent = yslowArgs.ua;
+ }
+
+ // set page viewport
+ if (yslowArgs.viewport) {
+ viewport = yslowArgs.viewport.toLowerCase();
+ page.viewportSize = {
+ width: parseInt(viewport.slice(0, viewport.indexOf('x')), 10) ||
+ page.viewportSize.width,
+ height: parseInt(viewport.slice(viewport.indexOf('x') + 1), 10) ||
+ page.viewportSize.height
+ };
+ }
+
+ // set custom headers
+ if (yslowArgs.headers) {
+ try {
+ page.customHeaders = JSON.parse(yslowArgs.headers);
+ } catch (err) {
+ console.log('Invalid custom headers: ' + err);
+ }
+ }
+
+ // open page
+ page.startTime = new Date();
+ page.open(url, function (status) {
+ var yslow, ysphantomjs, controller, evalFunc,
+ loadTime, url, resp, output,
+ exitStatus = 0,
+ startTime = page.startTime,
+ resources = page.resources;
+
+ if (status !== 'success') {
+ console.error('FAIL to load ' + url + ' reason:' + page.reason + ' url:' + page.reason_url);
+ exitStatus += 1;
+ } else {
+ // page load time
+ loadTime = new Date() - startTime;
+
+ // set resources response time
+ for (url in resources) {
+ if (resources.hasOwnProperty(url)) {
+ resp = resources[url].response;
+ if (resp) {
+ resp.time = new Date(resp.time) - startTime;
+ }
+ }
+ }
+
+ // yslow wrapper to be evaluated by page
+ yslow = function () {
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW:true*/
+/*jslint white: true, onevar: true, undef: true, nomen: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true */
+
+/**
+ * @module YSLOW
+ * @class YSLOW
+ * @static
+ */
+if (typeof YSLOW === 'undefined') {
+ YSLOW = {};
+}
+
+/**
+ * Enable/disable debbuging messages
+ */
+YSLOW.DEBUG = true;
+
+/**
+ *
+ * Adds a new rule to the pool of rules.
+ *
+ * Rule objects must implement the rule interface or an error will be thrown. The interface
+ * of a rule object is as follows:
+ *
+ *
id, e.g. "numreq"
+ *
name, e.g. "Minimize HTTP requests"
+ *
url, more info about the rule
+ *
config, configuration object with defaults
+ *
lint() a method that accepts a document, array of components and a config object and returns a reuslt object
+ *
+ *
+ * @param {YSLOW.Rule} rule A new rule object to add
+ */
+YSLOW.registerRule = function (rule) {
+ YSLOW.controller.addRule(rule);
+};
+
+/**
+ *
+ * Adds a new ruleset (new grading algorithm).
+ *
+ * Ruleset objects must implement the ruleset interface or an error will be thrown. The interface
+ * of a ruleset object is as follows:
+ *
+ *
id, e.g. "ydefault"
+ *
name, e.g. "Yahoo! Default"
+ *
rules a hash of ruleID => ruleconfig
+ *
weights a hash of ruleID => ruleweight
+ *
+ *
+ * @param {YSLOW.Ruleset} ruleset The new ruleset object to be registered
+ */
+YSLOW.registerRuleset = function (ruleset) {
+ YSLOW.controller.addRuleset(ruleset);
+};
+
+/**
+ * Register a renderer.
+ *
+ * Renderer objects must implement the renderer interface.
+ * The interface is as follows:
+ *
+ *
id
+ *
supports a hash of view_name => 1 or 0 to indicate what views are supported
+ *
and the methods
+ *
+ *
+ * For instance if you define a JSON renderer that only render grade. Your renderer object will look like this:
+ * { id: 'json',
+ * supports: { reportcard: 1, components: 0, stats: 0, cookies: 0},
+ * reportcardView: function(resultset) { ... }
+ * }
+ *
+ * Refer to YSLOW.HTMLRenderer for the function prototype.
+ *
+ *
+ * @param {YSLOW.renderer} renderer The new renderer object to be registered.
+ */
+YSLOW.registerRenderer = function (renderer) {
+ YSLOW.controller.addRenderer(renderer);
+};
+
+/**
+ * Adds a new tool.
+ *
+ * Tool objects must implement the tool interface or an error will be thrown.
+ * The interface of a tool object is as follows:
+ *
+ *
id, e.g. 'mytool'
+ *
name, eg. 'Custom tool #3'
+ *
print_output, whether this tool will produce output.
+ *
run, function that takes doc and componentset object, return content to be output
+ *
+ *
+ * @param {YSLOW.Tool} tool The new tool object to be registered
+ */
+YSLOW.registerTool = function (tool) {
+ YSLOW.Tools.addCustomTool(tool);
+};
+
+
+/**
+ * Register an event listener
+ *
+ * @param {String} event_name Name of the event
+ * @param {Function} callback A function to be called when the event fires
+ * @param {Object} that Object to be assigned to the "this" value of the callback function
+ */
+YSLOW.addEventListener = function (event_name, callback, that) {
+ YSLOW.util.event.addListener(event_name, callback, that);
+};
+
+/**
+ * Unregister an event listener.
+ *
+ * @param {String} event_name Name of the event
+ * @param {Function} callback The callback function that was added as a listener
+ * @return {Boolean} TRUE is the listener was removed successfully, FALSE otherwise (for example in cases when the listener doesn't exist)
+ */
+YSLOW.removeEventListener = function (event_name, callback) {
+ return YSLOW.util.event.removeListener(event_name, callback);
+};
+
+/**
+ * @namespace YSLOW
+ * @constructor
+ * @param {String} name Error type
+ * @param {String} message Error description
+ */
+YSLOW.Error = function (name, message) {
+ /**
+ * Type of error, e.g. "Interface error"
+ * @type String
+ */
+ this.name = name;
+ /**
+ * Error description
+ * @type String
+ */
+ this.message = message;
+};
+
+YSLOW.Error.prototype = {
+ toString: function () {
+ return this.name + "\n" + this.message;
+ }
+};
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+YSLOW.version = '3.1.8';
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyright (c) 2013, Marcel Duran and other contributors. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW,MutationEvent*/
+/*jslint browser: true, continue: true, sloppy: true, maxerr: 50, indent: 4 */
+
+/**
+ * ComponentSet holds an array of all the components and get the response info from net module for each component.
+ *
+ * @constructor
+ * @param {DOMElement} node DOM Element
+ * @param {Number} onloadTimestamp onload timestamp
+ */
+YSLOW.ComponentSet = function (node, onloadTimestamp) {
+
+ //
+ // properties
+ //
+ this.root_node = node;
+ this.components = [];
+ this.outstanding_net_request = 0;
+ this.component_info = [];
+ this.onloadTimestamp = onloadTimestamp;
+ this.nextID = 1;
+ this.notified_fetch_done = false;
+
+};
+
+YSLOW.ComponentSet.prototype = {
+
+ /**
+ * Call this function when you don't use the component set any more.
+ * A chance to do proper clean up, e.g. remove event listener.
+ */
+ clear: function () {
+ this.components = [];
+ this.component_info = [];
+ this.cleared = true;
+ if (this.outstanding_net_request > 0) {
+ YSLOW.util.dump("YSLOW.ComponentSet.Clearing component set before all net requests finish.");
+ }
+ },
+
+ /**
+ * Add a new component to the set.
+ * @param {String} url URL of component
+ * @param {String} type type of component
+ * @param {String} base_href base href of document that the component belongs.
+ * @param {Object} obj DOMElement (for image type only)
+ * @return Component object that was added to ComponentSet
+ * @type ComponentObject
+ */
+ addComponent: function (url, type, base_href, o) {
+ var comp, found, isDoc;
+
+ if (!url) {
+ if (!this.empty_url) {
+ this.empty_url = [];
+ }
+ this.empty_url[type] = (this.empty_url[type] || 0) + 1;
+ }
+ if (url && type) {
+ // check if url is valid.
+ if (!YSLOW.ComponentSet.isValidProtocol(url) ||
+ !YSLOW.ComponentSet.isValidURL(url)) {
+ return comp;
+ }
+
+ // Make sure url is absolute url.
+ url = YSLOW.util.makeAbsoluteUrl(url, base_href);
+ // For security purpose
+ url = YSLOW.util.escapeHtml(url);
+
+ found = typeof this.component_info[url] !== 'undefined';
+ isDoc = type === 'doc';
+
+ // make sure this component is not already in this component set,
+ // but also check if a doc is coming after a redirect using same url
+ if (!found || isDoc) {
+ this.component_info[url] = {
+ 'state': 'NONE',
+ 'count': found ? this.component_info[url].count : 0
+ };
+
+ comp = new YSLOW.Component(url, type, this, o);
+ if (comp) {
+ comp.id = this.nextID += 1;
+ this.components[this.components.length] = comp;
+
+ // shortcup for document component
+ if (!this.doc_comp && isDoc) {
+ this.doc_comp = comp;
+ }
+
+ if (this.component_info[url].state === 'NONE') {
+ // net.js has probably made an async request.
+ this.component_info[url].state = 'REQUESTED';
+ this.outstanding_net_request += 1;
+ }
+ } else {
+ this.component_info[url].state = 'ERROR';
+ YSLOW.util.event.fire("componentFetchError");
+ }
+ }
+ this.component_info[url].count += 1;
+ }
+
+ return comp;
+ },
+
+ /**
+ * Add a new component to the set, ignore duplicate.
+ * @param {String} url url of component
+ * @param {String} type type of component
+ * @param {String} base_href base href of document that the component belongs.
+ */
+ addComponentNoDuplicate: function (url, type, base_href) {
+
+ if (url && type) {
+ // For security purpose
+ url = YSLOW.util.escapeHtml(url);
+ url = YSLOW.util.makeAbsoluteUrl(url, base_href);
+ if (this.component_info[url] === undefined) {
+ return this.addComponent(url, type, base_href);
+ }
+ }
+
+ },
+
+ /**
+ * Get components by type.
+ *
+ * @param {String|Array} type The type of component to get, e.g. "js" or
+ * ['js', 'css']
+ * @param {Boolean} include_after_onload If component loaded after onload
+ * should be included in the returned results, default is FALSE,
+ * don't include
+ * @param {Boolean} include_beacons If image beacons (1x1 images) should
+ * be included in the returned results, default is FALSE, don't
+ * include
+ * @return An array of matching components
+ * @type Array
+ */
+ getComponentsByType: function (type, includeAfterOnload, includeBeacons) {
+ var i, j, len, lenJ, t, comp, info,
+ components = this.components,
+ compInfo = this.component_info,
+ comps = [],
+ types = {};
+
+ if (typeof includeAfterOnload === 'undefined') {
+ includeAfterOnload = !(YSLOW.util.Preference.getPref(
+ 'excludeAfterOnload',
+ true
+ ));
+ }
+ if (typeof includeBeacons === 'undefined') {
+ includeBeacons = !(YSLOW.util.Preference.getPref(
+ 'excludeBeaconsFromLint',
+ true
+ ));
+ }
+
+ if (typeof type === 'string') {
+ types[type] = 1;
+ } else {
+ for (i = 0, len = type.length; i < len; i += 1) {
+ t = type[i];
+ if (t) {
+ types[t] = 1;
+ }
+ }
+ }
+
+ for (i = 0, len = components.length; i < len; i += 1) {
+ comp = components[i];
+ if (!comp || (comp && !types[comp.type]) ||
+ (comp.is_beacon && !includeBeacons) ||
+ (comp.after_onload && !includeAfterOnload)) {
+ continue;
+ }
+ comps[comps.length] = comp;
+ info = compInfo[i];
+ if (!info || (info && info.count <= 1)) {
+ continue;
+ }
+ for (j = 1, lenJ = info.count; j < lenJ; j += 1) {
+ comps[comps.length] = comp;
+ }
+ }
+
+ return comps;
+ },
+
+ /**
+ * @private
+ * Get fetching progress.
+ * @return { 'total' => total number of component, 'received' => number of components fetched }
+ */
+ getProgress: function () {
+ var i,
+ total = 0,
+ received = 0;
+
+ for (i in this.component_info) {
+ if (this.component_info.hasOwnProperty(i) &&
+ this.component_info[i]) {
+ if (this.component_info[i].state === 'RECEIVED') {
+ received += 1;
+ }
+ total += 1;
+ }
+ }
+
+ return {
+ 'total': total,
+ 'received': received
+ };
+ },
+
+ /**
+ * Event callback when component's GetInfoState changes.
+ * @param {Object} event object
+ */
+ onComponentGetInfoStateChange: function (event_object) {
+ var comp, state, progress;
+
+ if (event_object) {
+ if (typeof event_object.comp !== 'undefined') {
+ comp = event_object.comp;
+ }
+ if (typeof event_object.state !== 'undefined') {
+ state = event_object.state;
+ }
+ }
+ if (typeof this.component_info[comp.url] === 'undefined') {
+ // this should not happen.
+ YSLOW.util.dump("YSLOW.ComponentSet.onComponentGetInfoStateChange(): Unexpected component: " + comp.url);
+ return;
+ }
+
+ if (this.component_info[comp.url].state === "NONE" && state === 'DONE') {
+ this.component_info[comp.url].state = "RECEIVED";
+ } else if (this.component_info[comp.url].state === "REQUESTED" && state === 'DONE') {
+ this.component_info[comp.url].state = "RECEIVED";
+ this.outstanding_net_request -= 1;
+ // Got all component detail info.
+ if (this.outstanding_net_request === 0) {
+ this.notified_fetch_done = true;
+ YSLOW.util.event.fire("componentFetchDone", {
+ 'component_set': this
+ });
+ }
+ } else {
+ // how does this happen?
+ YSLOW.util.dump("Unexpected component info state: [" + comp.type + "]" + comp.url + "state: " + state + " comp_info_state: " + this.component_info[comp.url].state);
+ }
+
+ // fire event.
+ progress = this.getProgress();
+ YSLOW.util.event.fire("componentFetchProgress", {
+ 'total': progress.total,
+ 'current': progress.received,
+ 'last_component_url': comp.url
+ });
+ },
+
+ /**
+ * This is called when peeler is done.
+ * If ComponentSet has all the component info, fire componentFetchDone event.
+ */
+ notifyPeelDone: function () {
+ if (this.outstanding_net_request === 0 && !this.notified_fetch_done) {
+ this.notified_fetch_done = true;
+ YSLOW.util.event.fire("componentFetchDone", {
+ 'component_set': this
+ });
+ }
+ },
+
+ /**
+ * After onload guess (simple version)
+ * Checkes for elements with src or href attributes within
+ * the original document html source
+ */
+ setSimpleAfterOnload: function (callback, obj) {
+ var i, j, comp, doc_el, doc_comps, src,
+ indoc, url, el, type, len, lenJ,
+ docBody, doc, components, that;
+
+ if (obj) {
+ docBody = obj.docBody;
+ doc = obj.doc;
+ components = obj.components;
+ that = obj.components;
+ } else {
+ docBody = this.doc_comp && this.doc_comp.body;
+ doc = this.root_node;
+ components = this.components;
+ that = this;
+ }
+
+ // skip testing when doc not found
+ if (!docBody) {
+ YSLOW.util.dump('doc body is empty');
+ return callback(that);
+ }
+
+ doc_el = doc.createElement('div');
+ doc_el.innerHTML = docBody;
+ doc_comps = doc_el.getElementsByTagName('*');
+
+ for (i = 0, len = components.length; i < len; i += 1) {
+ comp = components[i];
+ type = comp.type;
+ if (type === 'cssimage' || type === 'doc') {
+ // docs are ignored
+ // css images are likely to be loaded before onload
+ continue;
+ }
+ indoc = false;
+ url = comp.url;
+ for (j = 0, lenJ = doc_comps.length; !indoc && j < lenJ; j += 1) {
+ el = doc_comps[j];
+ src = el.src || el.href || el.getAttribute('src') ||
+ el.getAttribute('href') ||
+ (el.nodeName === 'PARAM' && el.value);
+ indoc = (src === url);
+ }
+ // if component wasn't found on original html doc
+ // assume it was loaded after onload
+ comp.after_onload = !indoc;
+ }
+
+ callback(that);
+ },
+
+ /**
+ * After onload guess
+ * Checkes for inserted elements with src or href attributes after the
+ * page onload event triggers using an iframe with original doc html
+ */
+ setAfterOnload: function (callback, obj) {
+ var ifrm, idoc, iwin, timer, done, noOnloadTimer,
+ that, docBody, doc, components, ret, enough, triggered,
+ util = YSLOW.util,
+ addEventListener = util.addEventListener,
+ removeEventListener = util.removeEventListener,
+ setTimer = setTimeout,
+ clearTimer = clearTimeout,
+ comps = [],
+ compsHT = {},
+
+ // get changed component and push to comps array
+ // reset timer for 1s after the last dom change
+ getTarget = function (e) {
+ var type, attr, target, src, oldSrc;
+
+ clearTimer(timer);
+
+ type = e.type;
+ attr = e.attrName;
+ target = e.target;
+ src = target.src || target.href || (target.getAttribute && (
+ target.getAttribute('src') || target.getAttribute('href')
+ ));
+ oldSrc = target.dataOldSrc;
+
+ if (src &&
+ (type === 'DOMNodeInserted' ||
+ (type === 'DOMSubtreeModified' && src !== oldSrc) ||
+ (type === 'DOMAttrModified' &&
+ (attr === 'src' || attr === 'href'))) &&
+ !compsHT[src]) {
+ compsHT[src] = 1;
+ comps.push(target);
+ }
+
+ timer = setTimer(done, 1000);
+ },
+
+ // temp iframe onload listener
+ // - cancel noOnload timer since onload was fired
+ // - wait 3s before calling done if no dom mutation happens
+ // - set enough timer, limit is 10 seconds for mutations, this is
+ // for edge cases when page inserts/removes nodes within a loop
+ iframeOnload = function () {
+ var i, len, all, el, src;
+
+ clearTimer(noOnloadTimer);
+ all = idoc.getElementsByTagName('*');
+ for (i = 0, len = all.length; i < len; i += 1) {
+ el = all[i];
+ src = el.src || el.href;
+ if (src) {
+ el.dataOldSrc = src;
+ }
+ }
+ addEventListener(iwin, 'DOMSubtreeModified', getTarget);
+ addEventListener(iwin, 'DOMNodeInserted', getTarget);
+ addEventListener(iwin, 'DOMAttrModified', getTarget);
+ timer = setTimer(done, 3000);
+ enough = setTimer(done, 10000);
+ };
+
+ if (obj) {
+ that = YSLOW.ComponentSet.prototype;
+ docBody = obj.docBody;
+ doc = obj.doc;
+ components = obj.components;
+ ret = components;
+ } else {
+ that = this;
+ docBody = that.doc_comp && that.doc_comp.body;
+ doc = that.root_node;
+ components = that.components;
+ ret = that;
+ }
+
+ // check for mutation event support or anti-iframe option
+ if (typeof MutationEvent === 'undefined' || YSLOW.antiIframe) {
+ return that.setSimpleAfterOnload(callback, obj);
+ }
+
+ // skip testing when doc not found
+ if (!docBody) {
+ util.dump('doc body is empty');
+
+ return callback(ret);
+ }
+
+ // set afteronload properties for all components loaded after window onlod
+ done = function () {
+ var i, j, len, lenJ, comp, src, cmp;
+
+ // to avoid executing this function twice
+ // due to ifrm iwin double listeners
+ if (triggered) {
+ return;
+ }
+
+ // cancel timers
+ clearTimer(enough);
+ clearTimer(timer);
+
+ // remove listeners
+ removeEventListener(iwin, 'DOMSubtreeModified', getTarget);
+ removeEventListener(iwin, 'DOMNodeInserted', getTarget);
+ removeEventListener(iwin, 'DOMAttrModified', getTarget);
+ removeEventListener(ifrm, 'load', iframeOnload);
+ removeEventListener(iwin, 'load', iframeOnload);
+
+ // changed components loop
+ for (i = 0, len = comps.length; i < len; i += 1) {
+ comp = comps[i];
+ src = comp.src || comp.href || (comp.getAttribute &&
+ (comp.getAttribute('src') || comp.getAttribute('href')));
+ if (!src) {
+ continue;
+ }
+ for (j = 0, lenJ = components.length; j < lenJ; j += 1) {
+ cmp = components[j];
+ if (cmp.url === src) {
+ cmp.after_onload = true;
+ }
+ }
+ }
+
+ // remove temp iframe and invoke callback passing cset
+ ifrm.parentNode.removeChild(ifrm);
+ triggered = 1;
+ callback(ret);
+ };
+
+ // create temp iframe with doc html
+ ifrm = doc.createElement('iframe');
+ ifrm.style.cssText = 'position:absolute;top:-999em;';
+ doc.body.appendChild(ifrm);
+ iwin = ifrm.contentWindow;
+
+ // set a fallback when onload is not triggered
+ noOnloadTimer = setTimer(done, 3000);
+
+ // set onload and ifram content
+ if (iwin) {
+ idoc = iwin.document;
+ } else {
+ iwin = idoc = ifrm.contentDocument;
+ }
+ addEventListener(iwin, 'load', iframeOnload);
+ addEventListener(ifrm, 'load', iframeOnload);
+ idoc.open().write(docBody);
+ idoc.close();
+ addEventListener(iwin, 'load', iframeOnload);
+ }
+};
+
+/*
+ * List of valid protocols in component sets.
+ */
+YSLOW.ComponentSet.validProtocols = ['http', 'https', 'ftp'];
+
+/**
+ * @private
+ * Check if url has an allowed protocol (no chrome://, about:)
+ * @param url
+ * @return false if url does not contain hostname.
+ */
+YSLOW.ComponentSet.isValidProtocol = function (s) {
+ var i, index, protocol,
+ validProtocols = this.validProtocols,
+ len = validProtocols.length;
+
+ s = s.toLowerCase();
+ index = s.indexOf(':');
+ if (index > 0) {
+ protocol = s.substr(0, index);
+ for (i = 0; i < len; i += 1) {
+ if (protocol === validProtocols[i]) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+};
+
+
+/**
+ * @private
+ * Check if passed url has hostname specified.
+ * @param url
+ * @return false if url does not contain hostname.
+ */
+YSLOW.ComponentSet.isValidURL = function (url) {
+ var arr, host;
+
+ url = url.toLowerCase();
+
+ // all url is in the format of :
+ arr = url.split(":");
+
+ // for http protocol, we want to make sure there is a host in the url.
+ if (arr[0] === "http" || arr[0] === "https") {
+ if (arr[1].substr(0, 2) !== "//") {
+ return false;
+ }
+ host = arr[1].substr(2);
+ if (host.length === 0 || host.indexOf("/") === 0) {
+ // no host specified.
+ return false;
+ }
+ }
+
+ return true;
+};
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyright (c) 2013, Marcel Duran and other contributors. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW*/
+/*jslint white: true, onevar: true, undef: true, newcap: true, nomen: true, plusplus: true, bitwise: true, browser: true, maxerr: 50, indent: 4 */
+
+/**
+ * @namespace YSLOW
+ * @class Component
+ * @constructor
+ */
+YSLOW.Component = function (url, type, parent_set, o) {
+ var obj = o && o.obj,
+ comp = (o && o.comp) || {};
+
+ /**
+ * URL of the component
+ * @type String
+ */
+ this.url = url;
+
+ /**
+ * Component type, one of the following:
+ *
+ *
doc
+ *
js
+ *
css
+ *
...
+ *
+ * @type String
+ */
+ this.type = type;
+
+ /**
+ * Parent component set.
+ */
+ this.parent = parent_set;
+
+ this.headers = {};
+ this.raw_headers = '';
+ this.req_headers = null;
+ this.body = '';
+ this.compressed = false;
+ this.expires = undefined; // to be replaced by a Date object
+ this.size = 0;
+ this.status = 0;
+ this.is_beacon = false;
+ this.method = 'unknown';
+ this.cookie = '';
+ this.respTime = null;
+ this.after_onload = false;
+
+ // component object properties
+ // e.g. for image, image element width, image element height, actual width, actual height
+ this.object_prop = undefined;
+
+ // construction part
+ if (type === undefined) {
+ this.type = 'unknown';
+ }
+
+ this.get_info_state = 'NONE';
+
+ if (obj && type === 'image' && obj.width && obj.height) {
+ this.object_prop = {
+ 'width': obj.width,
+ 'height': obj.height
+ };
+ }
+
+ if (comp.containerNode) {
+ this.containerNode = comp.containerNode;
+ }
+
+ this.setComponentDetails(o);
+};
+
+/**
+ * Return the state of getting detail info from the net.
+ */
+YSLOW.Component.prototype.getInfoState = function () {
+ return this.get_info_state;
+};
+
+YSLOW.Component.prototype.populateProperties = function (resolveRedirect, ignoreImgReq) {
+ var comp, encoding, expires, content_length, img_src, obj, dataUri,
+ that = this,
+ NULL = null,
+ UNDEF = 'undefined';
+
+ // check location
+ // bookmarklet and har already handle redirects
+ if (that.headers.location && resolveRedirect && that.headers.location !== that.url) {
+ // Add a new component.
+ comp = that.parent.addComponentNoDuplicate(that.headers.location,
+ (that.type !== 'redirect' ? that.type : 'unknown'), that.url);
+ if (comp && that.after_onload) {
+ comp.after_onload = true;
+ }
+ that.type = 'redirect';
+ }
+
+ content_length = that.headers['content-length'];
+
+ // gzip, deflate
+ encoding = YSLOW.util.trim(that.headers['content-encoding']);
+ if (encoding === 'gzip' || encoding === 'deflate') {
+ that.compressed = encoding;
+ that.size = (that.body.length) ? that.body.length : NULL;
+ if (content_length) {
+ that.size_compressed = parseInt(content_length, 10) ||
+ content_length;
+ } else if (typeof that.nsize !== UNDEF) {
+ that.size_compressed = that.nsize;
+ } else {
+ // a hack
+ that.size_compressed = Math.round(that.size / 3);
+ }
+ } else {
+ that.compressed = false;
+ that.size_compressed = NULL;
+ if (content_length) {
+ that.size = parseInt(content_length, 10);
+ } else if (typeof that.nsize !== UNDEF) {
+ that.size = parseInt(that.nsize, 10);
+ } else {
+ that.size = that.body.length;
+ }
+ }
+
+ // size check/correction, @todo be more precise here
+ if (!that.size) {
+ if (typeof that.nsize !== UNDEF) {
+ that.size = that.nsize;
+ } else {
+ that.size = that.body.length;
+ }
+ }
+ that.uncompressed_size = that.body.length;
+
+ // expiration based on either Expires or Cache-Control headers
+ // always use max-age if exists following 1.1 spec
+ // http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3
+ if (that.getMaxAge() !== undefined) {
+ that.expires = that.getMaxAge();
+ }
+ else if (that.headers.expires && that.headers.expires.length > 0) {
+ that.expires = new Date(that.headers.expires);
+ }
+
+ // compare image original dimensions with actual dimensions, data uri is
+ // first attempted to get the orginal dimension, if it fails (btoa) then
+ // another request to the orginal image is made
+ if (that.type === 'image' && !ignoreImgReq) {
+ if (typeof Image !== UNDEF) {
+ obj = new Image();
+ } else {
+ obj = document.createElement('img');
+ }
+ if (that.body.length) {
+ img_src = 'data:' + that.headers['content-type'] + ';base64,' +
+ YSLOW.util.base64Encode(that.body);
+ dataUri = 1;
+ } else {
+ img_src = that.url;
+ }
+ obj.onerror = function () {
+ obj.onerror = NULL;
+ if (dataUri) {
+ obj.src = that.url;
+ }
+ };
+ obj.onload = function () {
+ obj.onload = NULL;
+ if (obj && obj.width && obj.height) {
+ if (that.object_prop) {
+ that.object_prop.actual_width = obj.width;
+ that.object_prop.actual_height = obj.height;
+ } else {
+ that.object_prop = {
+ 'width': obj.width,
+ 'height': obj.height,
+ 'actual_width': obj.width,
+ 'actual_height': obj.height
+ };
+ }
+ if (obj.width < 2 && obj.height < 2) {
+ that.is_beacon = true;
+ }
+ }
+ };
+ obj.src = img_src;
+ }
+};
+
+/**
+ * Return true if this object has a last-modified date significantly in the past.
+ */
+YSLOW.Component.prototype.hasOldModifiedDate = function () {
+ var now = Number(new Date()),
+ modified_date = this.headers['last-modified'];
+
+ if (typeof modified_date !== 'undefined') {
+ // at least 1 day in the past
+ return ((now - Number(new Date(modified_date))) > (24 * 60 * 60 * 1000));
+ }
+
+ return false;
+};
+
+/**
+ * Return true if this object has a far future Expires.
+ * @todo: make the "far" interval configurable
+ * @param expires Date object
+ * @return true if this object has a far future Expires.
+ */
+YSLOW.Component.prototype.hasFarFutureExpiresOrMaxAge = function () {
+ var expires_in_seconds,
+ now = Number(new Date()),
+ minSeconds = YSLOW.util.Preference.getPref('minFutureExpiresSeconds', 2 * 24 * 60 * 60),
+ minMilliSeconds = minSeconds * 1000;
+
+ if (typeof this.expires === 'object') {
+ expires_in_seconds = Number(this.expires);
+ if ((expires_in_seconds - now) > minMilliSeconds) {
+ return true;
+ }
+ }
+
+ return false;
+};
+
+YSLOW.Component.prototype.getEtag = function () {
+ return this.headers.etag || '';
+};
+
+YSLOW.Component.prototype.getMaxAge = function () {
+ var index, maxage, expires,
+ cache_control = this.headers['cache-control'];
+
+ if (cache_control) {
+ index = cache_control.indexOf('max-age');
+ if (index > -1) {
+ maxage = parseInt(cache_control.substring(index + 8), 10);
+ if (maxage > 0) {
+ expires = YSLOW.util.maxAgeToDate(maxage);
+ }
+ }
+ }
+
+ return expires;
+};
+
+/**
+ * Return total size of Set-Cookie headers of this component.
+ * @return total size of Set-Cookie headers of this component.
+ * @type Number
+ */
+YSLOW.Component.prototype.getSetCookieSize = function () {
+ // only return total size of cookie received.
+ var aCookies, k,
+ size = 0;
+
+ if (this.headers && this.headers['set-cookie']) {
+ aCookies = this.headers['set-cookie'].split('\n');
+ if (aCookies.length > 0) {
+ for (k = 0; k < aCookies.length; k += 1) {
+ size += aCookies[k].length;
+ }
+ }
+ }
+
+ return size;
+};
+
+/**
+ * Return total size of Cookie HTTP Request headers of this component.
+ * @return total size of Cookie headers Request of this component.
+ * @type Number
+ */
+YSLOW.Component.prototype.getReceivedCookieSize = function () {
+ // only return total size of cookie sent.
+ var aCookies, k,
+ size = 0;
+
+ if (this.cookie && this.cookie.length > 0) {
+ aCookies = this.cookie.split('\n');
+ if (aCookies.length > 0) {
+ for (k = 0; k < aCookies.length; k += 1) {
+ size += aCookies[k].length;
+ }
+ }
+ }
+
+ return size;
+};
+
+/**
+ * Platform implementation of
+ * YSLOW.Component.prototype.setComponentDetails = function (o) {}
+ * goes here
+/*
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyright (c) 2013, Marcel Duran and other contributors. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW*/
+/*jslint browser: true, sloppy: true*/
+
+/**
+ * Parse details (HTTP headers, content, etc) from a
+ * given source and set component properties.
+ * @param o The object containing component details.
+ */
+YSLOW.Component.prototype.setComponentDetails = function (o) {
+ var comp = this,
+
+ parse = function (request, response) {
+ var xhr;
+
+ comp.ttfb = response.starttime - request.starttime;
+ // copy from the response object
+ comp.status = response.status;
+ comp.headers = {};
+ comp.raw_headers = '';
+ response.headers.forEach(function (header) {
+ comp.headers[header.name.toLowerCase()] = header.value;
+ comp.raw_headers += header.name + ': ' + header.value + '\n';
+ });
+ comp.req_headers = {};
+ request.headers.forEach(function (header) {
+ comp.req_headers[header.name.toLowerCase()] = header.value;
+ });
+ comp.method = request.method;
+ if (response.contentText) {
+ comp.body = response.contentText;
+ } else {
+ // try to fetch component again using sync xhr while
+ // content is not available through phantomjs.
+ // see: http://code.google.com/p/phantomjs/issues/detail?id=158
+ // and http://code.google.com/p/phantomjs/issues/detail?id=156
+ try {
+ xhr = new XMLHttpRequest();
+ xhr.open('GET', comp.url, false);
+ xhr.send();
+ comp.body = xhr.responseText;
+ } catch (err) {
+ comp.body = {
+ toString: function () {
+ return '';
+ },
+ length: response.bodySize || 0
+ };
+ }
+ }
+ // for security checking
+ comp.response_type = comp.type;
+ comp.cookie = (comp.headers['set-cookie'] || '') +
+ (comp.req_headers.cookie || '');
+ comp.nsize = parseInt(comp.headers['content-length'], 10) ||
+ response.bodySize;
+ comp.respTime = response.time;
+ comp.after_onload = (new Date(request.time)
+ .getTime()) > comp.parent.onloadTimestamp;
+
+ // populate properties ignoring redirect
+ // resolution and image request
+ comp.populateProperties(false, true);
+
+ comp.get_info_state = 'DONE';
+
+ // notify parent ComponentSet that this component has gotten net response.
+ comp.parent.onComponentGetInfoStateChange({
+ 'comp': comp,
+ 'state': 'DONE'
+ });
+ };
+
+ if (o.request && o.response) {
+ parse(o.request, o.response);
+ }
+};
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyright (c) 2013, Marcel Duran and other contributors. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW*/
+/*jslint white: true, browser: true, onevar: true, undef: true, nomen: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true */
+
+/**
+ * @namespace YSLOW
+ * @class controller
+ * @static
+ */
+
+YSLOW.controller = {
+
+ rules: {},
+
+ rulesets: {},
+
+ onloadTimestamp: null,
+
+ renderers: {},
+
+ default_ruleset_id: 'ydefault',
+
+ run_pending: 0,
+
+ /**
+ * Init code. Add event listeners.
+ */
+ init: function () {
+ var arr_rulesets, i, obj, value;
+
+ // listen to onload event.
+ YSLOW.util.event.addListener("onload", function (e) {
+ this.onloadTimestamp = e.time;
+ YSLOW.util.setTimer(function () {
+ YSLOW.controller.run_pending_event();
+ });
+ }, this);
+
+ // listen to onunload event.
+ YSLOW.util.event.addListener("onUnload", function (e) {
+ this.run_pending = 0;
+ this.onloadTimestamp = null;
+ }, this);
+
+ // load custom ruleset
+ arr_rulesets = YSLOW.util.Preference.getPrefList("customRuleset.", undefined);
+ if (arr_rulesets && arr_rulesets.length > 0) {
+ for (i = 0; i < arr_rulesets.length; i += 1) {
+ value = arr_rulesets[i].value;
+ if (typeof value === "string" && value.length > 0) {
+ obj = JSON.parse(value, null);
+ obj.custom = true;
+ this.addRuleset(obj);
+ }
+ }
+ }
+
+ this.default_ruleset_id = YSLOW.util.Preference.getPref("defaultRuleset", 'ydefault');
+
+ // load rule config preference
+ this.loadRulePreference();
+ },
+
+ /**
+ * Run controller to start peeler. Don't start if the page is not done loading.
+ * Delay the running until onload event.
+ *
+ * @param {Window} win window object
+ * @param {YSLOW.context} yscontext YSlow context to use.
+ * @param {Boolean} autorun value to indicate if triggered by autorun
+ */
+ run: function (win, yscontext, autorun) {
+ var cset, line,
+ doc = win.document;
+
+ if (!doc || !doc.location || doc.location.href.indexOf("about:") === 0 || "undefined" === typeof doc.location.hostname) {
+ if (!autorun) {
+ line = 'Please enter a valid website address before running YSlow.';
+ YSLOW.ysview.openDialog(YSLOW.ysview.panel_doc, 389, 150, line, '', 'Ok');
+ }
+ return;
+ }
+
+ // Since firebug 1.4, onload event is not passed to YSlow if firebug
+ // panel is not opened. Recommendation from firebug dev team is to
+ // refresh the page before running yslow, which is unnecessary from
+ // yslow point of view. For now, just don't enforce running YSlow
+ // on a page has finished loading.
+ if (!yscontext.PAGE.loaded) {
+ this.run_pending = {
+ 'win': win,
+ 'yscontext': yscontext
+ };
+ // @todo: put up spining logo to indicate waiting for page finish loading.
+ return;
+ }
+
+ YSLOW.util.event.fire("peelStart", undefined);
+ cset = YSLOW.peeler.peel(doc, this.onloadTimestamp);
+ // need to set yscontext_component_set before firing peelComplete,
+ // otherwise, may run into infinite loop.
+ yscontext.component_set = cset;
+ YSLOW.util.event.fire("peelComplete", {
+ 'component_set': cset
+ });
+
+ // notify ComponentSet peeling is done.
+ cset.notifyPeelDone();
+ },
+
+ /**
+ * Start pending run function.
+ */
+ run_pending_event: function () {
+ if (this.run_pending) {
+ this.run(this.run_pending.win, this.run_pending.yscontext, false);
+ this.run_pending = 0;
+ }
+ },
+
+ /**
+ * Run lint function of the ruleset matches the passed rulset_id.
+ * If ruleset_id is undefined, use Controller's default ruleset.
+ * @param {Document} doc Document object of the page to run lint.
+ * @param {YSLOW.context} yscontext YSlow context to use.
+ * @param {String} ruleset_id ID of the ruleset to run.
+ * @return Lint result
+ * @type YSLOW.ResultSet
+ */
+ lint: function (doc, yscontext, ruleset_id) {
+ var rule, rules, i, conf, result, weight, score,
+ ruleset = [],
+ results = [],
+ total_score = 0,
+ total_weight = 0,
+ that = this,
+ rs = that.rulesets,
+ defaultRuleSetId = that.default_ruleset_id;
+
+ if (ruleset_id) {
+ ruleset = rs[ruleset_id];
+ } else if (defaultRuleSetId && rs[defaultRuleSetId]) {
+ ruleset = rs[defaultRuleSetId];
+ } else {
+ // if no ruleset, take the first one available
+ for (i in rs) {
+ if (rs.hasOwnProperty(i) && rs[i]) {
+ ruleset = rs[i];
+ break;
+ }
+ }
+ }
+
+ rules = ruleset.rules;
+ for (i in rules) {
+ if (rules.hasOwnProperty(i) && rules[i] &&
+ this.rules.hasOwnProperty(i)) {
+ try {
+ rule = this.rules[i];
+ conf = YSLOW.util.merge(rule.config, rules[i]);
+
+ result = rule.lint(doc, yscontext.component_set, conf);
+
+ // apply rule weight to result.
+ weight = (ruleset.weights ? ruleset.weights[i] : undefined);
+ if (weight !== undefined) {
+ weight = parseInt(weight, 10);
+ }
+ if (weight === undefined || weight < 0 || weight > 100) {
+ if (rs.ydefault.weights[i]) {
+ weight = rs.ydefault.weights[i];
+ } else {
+ weight = 5;
+ }
+ }
+ result.weight = weight;
+
+ if (result.score !== undefined) {
+ if (typeof result.score !== "number") {
+ score = parseInt(result.score, 10);
+ if (!isNaN(score)) {
+ result.score = score;
+ }
+ }
+
+ if (typeof result.score === 'number') {
+ total_weight += result.weight;
+
+ if (!YSLOW.util.Preference.getPref('allowNegativeScore', false)) {
+ if (result.score < 0) {
+ result.score = 0;
+ }
+ if (typeof result.score !== 'number') {
+ // for backward compatibilty of n/a
+ result.score = -1;
+ }
+ }
+
+ if (result.score !== 0) {
+ total_score += result.score * (typeof result.weight !== 'undefined' ? result.weight : 1);
+ }
+ }
+ }
+
+ result.name = rule.name;
+ result.category = rule.category;
+ result.rule_id = i;
+
+ results[results.length] = result;
+ } catch (err) {
+ YSLOW.util.dump("YSLOW.controller.lint: " + i, err);
+ YSLOW.util.event.fire("lintError", {
+ 'rule': i,
+ 'message': err
+ });
+ }
+ }
+ }
+
+ yscontext.PAGE.overallScore = total_score / (total_weight > 0 ? total_weight : 1);
+ yscontext.result_set = new YSLOW.ResultSet(results, yscontext.PAGE.overallScore, ruleset);
+ yscontext.result_set.url = yscontext.component_set.doc_comp.url;
+ YSLOW.util.event.fire("lintResultReady", {
+ 'yslowContext': yscontext
+ });
+
+ return yscontext.result_set;
+ },
+
+ /**
+ * Run tool that matches the passed tool_id
+ * @param {String} tool_id ID of the tool to be run.
+ * @param {YSLOW.context} yscontext YSlow context
+ * @param {Object} param parameters to be passed to run method of tool.
+ */
+ runTool: function (tool_id, yscontext, param) {
+ var result, html, doc, h, css, uri, req2, l, s, message, body,
+ tool = YSLOW.Tools.getTool(tool_id);
+
+ try {
+ if (typeof tool === "object") {
+ result = tool.run(yscontext.document, yscontext.component_set, param);
+ if (tool.print_output) {
+ html = '';
+ if (typeof result === "object") {
+ html = result.html;
+ } else if (typeof result === "string") {
+ html = result;
+ }
+ doc = YSLOW.util.getNewDoc();
+ body = doc.body || doc.documentElement;
+ body.innerHTML = html;
+ h = doc.getElementsByTagName('head')[0];
+ if (typeof result.css === "undefined") {
+ // use default.
+ uri = 'chrome://yslow/content/yslow/tool.css';
+ req2 = new XMLHttpRequest();
+ req2.open('GET', uri, false);
+ req2.send(null);
+ css = req2.responseText;
+ } else {
+ css = result.css;
+ }
+ if (typeof css === "string") {
+ l = doc.createElement("style");
+ l.setAttribute("type", "text/css");
+ l.appendChild(doc.createTextNode(css));
+ h.appendChild(l);
+ }
+
+ if (typeof result.js !== "undefined") {
+ s = doc.createElement("script");
+ s.setAttribute("type", "text/javascript");
+ s.appendChild(doc.createTextNode(result.js));
+ h.appendChild(s);
+ }
+ if (typeof result.plot_component !== "undefined" && result.plot_component === true) {
+ // plot components
+ YSLOW.renderer.plotComponents(doc, yscontext);
+ }
+ }
+ } else {
+ message = tool_id + " is not a tool.";
+ YSLOW.util.dump(message);
+ YSLOW.util.event.fire("toolError", {
+ 'tool_id': tool_id,
+ 'message': message
+ });
+ }
+ } catch (err) {
+ YSLOW.util.dump("YSLOW.controller.runTool: " + tool_id, err);
+ YSLOW.util.event.fire("toolError", {
+ 'tool_id': tool_id,
+ 'message': err
+ });
+ }
+ },
+
+ /**
+ * Find a registered renderer with the passed id to render the passed view.
+ * @param {String} id ID of renderer to be used. eg. 'html'
+ * @param {String} view id of view, e.g. 'reportcard', 'stats' and 'components'
+ * @param {Object} params parameter object to pass to XXXview method of renderer.
+ * @return content the renderer generated.
+ */
+ render: function (id, view, params) {
+ var renderer = this.renderers[id],
+ content = '';
+
+ if (renderer.supports[view] !== undefined && renderer.supports[view] === 1) {
+ switch (view) {
+ case 'components':
+ content = renderer.componentsView(params.comps, params.total_size);
+ break;
+ case 'reportcard':
+ content = renderer.reportcardView(params.result_set);
+ break;
+ case 'stats':
+ content = renderer.statsView(params.stats);
+ break;
+ case 'tools':
+ content = renderer.toolsView(params.tools);
+ break;
+ case 'rulesetEdit':
+ content = renderer.rulesetEditView(params.rulesets);
+ break;
+ }
+ }
+ return content;
+
+ },
+
+ /**
+ * Get registered renderer with the passed id.
+ * @param {String} id ID of the renderer
+ */
+ getRenderer: function (id) {
+ return this.renderers[id];
+ },
+
+ /**
+ * @see YSLOW.registerRule
+ */
+ addRule: function (rule) {
+ var i, doc_obj,
+ required = ['id', 'name', 'config', 'info', 'lint'];
+
+ // check YSLOW.doc class for text
+ if (YSLOW.doc.rules && YSLOW.doc.rules[rule.id]) {
+ doc_obj = YSLOW.doc.rules[rule.id];
+ if (doc_obj.name) {
+ rule.name = doc_obj.name;
+ }
+ if (doc_obj.info) {
+ rule.info = doc_obj.info;
+ }
+ }
+
+ for (i = 0; i < required.length; i += 1) {
+ if (typeof rule[required[i]] === 'undefined') {
+ throw new YSLOW.Error('Interface error', 'Improperly implemented rule interface');
+ }
+ }
+ if (this.rules[rule.id] !== undefined) {
+ throw new YSLOW.Error('Rule register error', rule.id + " is already defined.");
+ }
+ this.rules[rule.id] = rule;
+ },
+
+ /**
+ * @see YSLOW.registerRuleset
+ */
+ addRuleset: function (ruleset, update) {
+ var i, required = ['id', 'name', 'rules'];
+
+ for (i = 0; i < required.length; i += 1) {
+ if (typeof ruleset[required[i]] === 'undefined') {
+ throw new YSLOW.Error('Interface error', 'Improperly implemented ruleset interface');
+ }
+ if (this.checkRulesetName(ruleset.id) && update !== true) {
+ throw new YSLOW.Error('Ruleset register error', ruleset.id + " is already defined.");
+ }
+ }
+ this.rulesets[ruleset.id] = ruleset;
+ },
+
+ /**
+ * Remove ruleset from controller.
+ * @param {String} ruleset_id ID of the ruleset to be deleted.
+ */
+ removeRuleset: function (ruleset_id) {
+ var ruleset = this.rulesets[ruleset_id];
+
+ if (ruleset && ruleset.custom === true) {
+ delete this.rulesets[ruleset_id];
+
+ // if we are deleting the default ruleset, change default to 'ydefault'.
+ if (this.default_ruleset_id === ruleset_id) {
+ this.default_ruleset_id = 'ydefault';
+ YSLOW.util.Preference.setPref("defaultRuleset", this.default_ruleset_id);
+ }
+ return ruleset;
+ }
+
+ return null;
+ },
+
+ /**
+ * Save ruleset to preference.
+ * @param {YSLOW.Ruleset} ruleset ruleset to be saved.
+ */
+ saveRulesetToPref: function (ruleset) {
+ if (ruleset.custom === true) {
+ YSLOW.util.Preference.setPref("customRuleset." + ruleset.id, JSON.stringify(ruleset, null, 2));
+ }
+ },
+
+ /**
+ * Remove ruleset from preference.
+ * @param {YSLOW.Ruleset} ruleset ruleset to be deleted.
+ */
+ deleteRulesetFromPref: function (ruleset) {
+ if (ruleset.custom === true) {
+ YSLOW.util.Preference.deletePref("customRuleset." + ruleset.id);
+ }
+ },
+
+ /**
+ * Get ruleset with the passed id.
+ * @param {String} ruleset_id ID of ruleset to be retrieved.
+ */
+ getRuleset: function (ruleset_id) {
+ return this.rulesets[ruleset_id];
+ },
+
+ /**
+ * @see YSLOW.registerRenderer
+ */
+ addRenderer: function (renderer) {
+ this.renderers[renderer.id] = renderer;
+ },
+
+ /**
+ * Return a hash of registered ruleset objects.
+ * @return a hash of rulesets with ruleset_id => ruleset
+ */
+ getRegisteredRuleset: function () {
+ return this.rulesets;
+ },
+
+ /**
+ * Return a hash of registered rule objects.
+ * @return all the registered rule objects in a hash. rule_id => rule object
+ */
+ getRegisteredRules: function () {
+ return this.rules;
+ },
+
+ /**
+ * Return the rule object identified by rule_id
+ * @param {String} rule_id ID of rule object to be retrieved.
+ * @return rule object.
+ */
+ getRule: function (rule_id) {
+ return this.rules[rule_id];
+ },
+
+ /**
+ * Check if name parameter is conflict with any existing ruleset name.
+ * @param {String} name Name to check.
+ * @return true if name conflicts, false otherwise.
+ * @type Boolean
+ */
+ checkRulesetName: function (name) {
+ var id, ruleset,
+ rulesets = this.rulesets;
+
+ name = name.toLowerCase();
+ for (id in rulesets) {
+ if (rulesets.hasOwnProperty(id)) {
+ ruleset = rulesets[id];
+ if (ruleset.id.toLowerCase() === name ||
+ ruleset.name.toLowerCase() === name) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ },
+
+ /**
+ * Set default ruleset.
+ * @param {String} id ID of the ruleset to be used as default.
+ */
+ setDefaultRuleset: function (id) {
+ if (this.rulesets[id] !== undefined) {
+ this.default_ruleset_id = id;
+ // save to pref
+ YSLOW.util.Preference.setPref("defaultRuleset", id);
+ }
+ },
+
+ /**
+ * Get default ruleset.
+ * @return default ruleset
+ * @type YSLOW.Ruleset
+ */
+ getDefaultRuleset: function () {
+ if (this.rulesets[this.default_ruleset_id] === undefined) {
+ this.setDefaultRuleset('ydefault');
+ }
+ return this.rulesets[this.default_ruleset_id];
+ },
+
+ /**
+ * Get default ruleset id
+ * @return ID of the default ruleset
+ * @type String
+ */
+ getDefaultRulesetId: function () {
+ return this.default_ruleset_id;
+ },
+
+ /**
+ * Load user preference for some rules. This is needed before enabling user writing ruleset yslow plugin.
+ */
+ loadRulePreference: function () {
+ var rule = this.getRule('yexpires'),
+ minSeconds = YSLOW.util.Preference.getPref("minFutureExpiresSeconds", 2 * 24 * 60 * 60);
+
+ if (minSeconds > 0 && rule) {
+ rule.config.howfar = minSeconds;
+ }
+ }
+};
+/**
+ * Copyright (c) 2012, Yahoo! Inc. All rights reserved.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+
+/*global YSLOW, Firebug, Components, ActiveXObject, gBrowser, window, getBrowser*/
+/*jslint sloppy: true, bitwise: true, browser: true, regexp: true*/
+
+/**
+ * @namespace YSLOW
+ * @class util
+ * @static
+ */
+YSLOW.util = {
+
+ /**
+ * merges two objects together, the properties of the second
+ * overwrite the properties of the first
+ *
+ * @param {Object} a Object a
+ * @param {Object} b Object b
+ * @return {Object} A new object, result of the merge
+ */
+ merge: function (a, b) {
+ var i, o = {};
+
+ for (i in a) {
+ if (a.hasOwnProperty(i)) {
+ o[i] = a[i];
+ }
+ }
+ for (i in b) {
+ if (b.hasOwnProperty(i)) {
+ o[i] = b[i];
+ }
+ }
+ return o;
+
+ },
+
+
+ /**
+ * Dumps debug information in FB console, Error console or alert
+ *
+ * @param {Object} what Object to dump
+ */
+ dump: function () {
+ var args;
+
+ // skip when debbuging is disabled
+ if (!YSLOW.DEBUG) {
+ return;
+ }
+
+ // get arguments and normalize single parameter
+ args = Array.prototype.slice.apply(arguments);
+ args = args && args.length === 1 ? args[0] : args;
+
+ try {
+ if (typeof Firebug !== 'undefined' && Firebug.Console
+ && Firebug.Console.log) { // Firebug
+ Firebug.Console.log(args);
+ } else if (typeof Components !== 'undefined' && Components.classes
+ && Components.interfaces) { // Firefox
+ Components.classes['@mozilla.org/consoleservice;1']
+ .getService(Components.interfaces.nsIConsoleService)
+ .logStringMessage(JSON.stringify(args, null, 2));
+ }
+ } catch (e1) {
+ try {
+ console.log(args);
+ } catch (e2) {
+ // alert shouldn't be used due to its annoying modal behavior
+ }
+ }
+ },
+
+ /**
+ * Filters an object/hash using a callback
+ *
+ * The callback function will be passed two params - a key and a value of each element
+ * It should return TRUE is the element is to be kept, FALSE otherwise
+ *
+ * @param {Object} hash Object to be filtered
+ * @param {Function} callback A callback function
+ * @param {Boolean} rekey TRUE to return a new array, FALSE to return an object and keep the keys/properties
+ */
+ filter: function (hash, callback, rekey) {
+ var i,
+ result = rekey ? [] : {};
+
+ for (i in hash) {
+ if (hash.hasOwnProperty(i) && callback(i, hash[i])) {
+ result[rekey ? result.length : i] = hash[i];
+ }
+ }
+
+ return result;
+ },
+
+ expires_month: {
+ Jan: 1,
+ Feb: 2,
+ Mar: 3,
+ Apr: 4,
+ May: 5,
+ Jun: 6,
+ Jul: 7,
+ Aug: 8,
+ Sep: 9,
+ Oct: 10,
+ Nov: 11,
+ Dec: 12
+ },
+
+
+ /**
+ * Make a pretty string out of an Expires object.
+ *
+ * @todo Remove or replace by a general-purpose date formatting method
+ *
+ * @param {String} s_expires Datetime string
+ * @return {String} Prity date
+ */
+ prettyExpiresDate: function (expires) {
+ var month;
+
+ if (Object.prototype.toString.call(expires) === '[object Date]' && expires.toString() !== 'Invalid Date' && !isNaN(expires)) {
+ month = expires.getMonth() + 1;
+ return expires.getFullYear() + "/" + month + "/" + expires.getDate();
+ } else if (!expires) {
+ return 'no expires';
+ }
+ return 'invalid date object';
+ },
+
+ /**
+ * Converts cache-control: max-age=? into a JavaScript date
+ *
+ * @param {Integer} seconds Number of seconds in the cache-control header
+ * @return {Date} A date object coresponding to the expiry date
+ */
+ maxAgeToDate: function (seconds) {
+ var d = new Date();
+
+ d = d.getTime() + parseInt(seconds, 10) * 1000;
+ return new Date(d);
+ },
+
+ /**
+ * Produces nicer sentences accounting for single/plural occurences.
+ *
+ * For example: "There are 3 scripts" vs "There is 1 script".
+ * Currently supported tags to be replaced are:
+ * %are%, %s% and %num%
+ *
+ *
+ * @param {String} template A template with tags, like "There %are% %num% script%s%"
+ * @param {Integer} num An integer value that replaces %num% and also deternmines how the other tags will be replaced
+ * @return {String} The text after substitution
+ */
+ plural: function (template, number) {
+ var i,
+ res = template,
+ repl = {
+ are: ['are', 'is'],
+ s: ['s', ''],
+ 'do': ['do', 'does'],
+ num: [number, number]
+ };
+
+
+ for (i in repl) {
+ if (repl.hasOwnProperty(i)) {
+ res = res.replace(new RegExp('%' + i + '%', 'gm'), (number === 1) ? repl[i][1] : repl[i][0]);
+ }
+ }
+
+ return res;
+ },
+
+ /**
+ * Counts the number of expression in a given piece of stylesheet.
+ *
+ * Expressions are identified by the presence of the literal string "expression(".
+ * There could be false positives in commented out styles.
+ *
+ * @param {String} content Text to inspect for the presence of expressions
+ * @return {Integer} The number of expressions in the text
+ */
+ countExpressions: function (content) {
+ var num_expr = 0,
+ index;
+
+ index = content.indexOf("expression(");
+ while (index !== -1) {
+ num_expr += 1;
+ index = content.indexOf("expression(", index + 1);
+ }
+
+ return num_expr;
+ },
+
+ /**
+ * Counts the number of AlphaImageLoader filter in a given piece of stylesheet.
+ *
+ * AlphaImageLoader filters are identified by the presence of the literal string "filter:" and
+ * "AlphaImageLoader" .
+ * There could be false positives in commented out styles.
+ *
+ * @param {String} content Text to inspect for the presence of filters
+ * @return {Hash} 'filter type' => count. For Example, {'_filter' : count }
+ */
+ countAlphaImageLoaderFilter: function (content) {
+ var index, colon, filter_hack, value,
+ num_filter = 0,
+ num_hack_filter = 0,
+ result = {};
+
+ index = content.indexOf("filter:");
+ while (index !== -1) {
+ filter_hack = false;
+ if (index > 0 && content.charAt(index - 1) === '_') {
+ // check underscore.
+ filter_hack = true;
+ }
+ // check literal string "AlphaImageLoader"
+ colon = content.indexOf(";", index + 7);
+ if (colon !== -1) {
+ value = content.substring(index + 7, colon);
+ if (value.indexOf("AlphaImageLoader") !== -1) {
+ if (filter_hack) {
+ num_hack_filter += 1;
+ } else {
+ num_filter += 1;
+ }
+ }
+ }
+ index = content.indexOf("filter:", index + 1);
+ }
+
+ if (num_hack_filter > 0) {
+ result.hackFilter = num_hack_filter;
+ }
+ if (num_filter > 0) {
+ result.filter = num_filter;
+ }
+
+ return result;
+ },
+
+ /**
+ * Returns the hostname (domain) for a given URL
+ *
+ * @param {String} url The absolute URL to get hostname from
+ * @return {String} The hostname
+ */
+ getHostname: function (url) {
+ var hostname = url.split('/')[2];
+
+ return (hostname && hostname.split(':')[0]) || '';
+ },
+
+ /**
+ * Returns an array of unique domain names, based on a given array of components
+ *
+ * @param {Array} comps An array of components (not a @see ComponentSet)
+ * @param {Boolean} exclude_ips Whether to exclude IP addresses from the list of domains (for DNS check purposes)
+ * @return {Array} An array of unique domian names
+ */
+ getUniqueDomains: function (comps, exclude_ips) {
+ var i, len, parts,
+ domains = {},
+ retval = [];
+
+ for (i = 0, len = comps.length; i < len; i += 1) {
+ parts = comps[i].url.split('/');
+ if (parts[2]) {
+ // add to hash, but remove port number first
+ domains[parts[2].split(':')[0]] = 1;
+ }
+ }
+
+ for (i in domains) {
+ if (domains.hasOwnProperty(i)) {
+ if (!exclude_ips) {
+ retval.push(i);
+ } else {
+ // exclude ips, identify them by the pattern "what.e.v.e.r.[number]"
+ parts = i.split('.');
+ if (isNaN(parseInt(parts[parts.length - 1], 10))) {
+ // the last part is "com" or something that is NaN
+ retval.push(i);
+ }
+ }
+ }
+ }
+
+ return retval;
+ },
+
+ summaryByDomain: function (comps, sumFields, excludeIPs) {
+ var i, j, len, parts, hostname, domain, comp, sumLen, field, sum,
+ domains = {},
+ retval = [];
+
+ // normalize sumField to array (makes things easier)
+ sumFields = [].concat(sumFields);
+ sumLen = sumFields.length;
+
+ // loop components, count and summarize fields
+ for (i = 0, len = comps.length; i < len; i += 1) {
+ comp = comps[i];
+ parts = comp.url.split('/');
+ if (parts[2]) {
+ // add to hash, but remove port number first
+ hostname = parts[2].split(':')[0];
+ domain = domains[hostname];
+ if (!domain) {
+ domain = {
+ domain: hostname,
+ count: 0
+ };
+ domains[hostname] = domain;
+ }
+ domain.count += 1;
+ // fields summary
+ for (j = 0; j < sumLen; j += 1) {
+ field = sumFields[j];
+ sum = domain['sum_' + field] || 0;
+ sum += parseInt(comp[field], 10) || 0;
+ domain['sum_' + field] = sum;
+ }
+ }
+ }
+
+ // loop hash of unique domains
+ for (domain in domains) {
+ if (domains.hasOwnProperty(domain)) {
+ if (!excludeIPs) {
+ retval.push(domains[domain]);
+ } else {
+ // exclude ips, identify them by the pattern "what.e.v.e.r.[number]"
+ parts = domain.split('.');
+ if (isNaN(parseInt(parts[parts.length - 1], 10))) {
+ // the last part is "com" or something that is NaN
+ retval.push(domains[domain]);
+ }
+ }
+ }
+ }
+
+ return retval;
+ },
+
+ /**
+ * Checks if a given piece of text (sctipt, stylesheet) is minified.
+ *
+ * The logic is: we strip consecutive spaces, tabs and new lines and
+ * if this improves the size by more that 20%, this means there's room for improvement.
+ *
+ * @param {String} contents The text to be checked for minification
+ * @return {Boolean} TRUE if minified, FALSE otherwise
+ */
+ isMinified: function (contents) {
+ var len = contents.length,
+ striplen;
+
+ if (len === 0) { // blank is as minified as can be
+ return true;
+ }
+
+ // TODO: enhance minifier logic by adding comment checking: \/\/[\w\d \t]*|\/\*[\s\S]*?\*\/
+ // even better: add jsmin/cssmin
+ striplen = contents.replace(/\n| {2}|\t|\r/g, '').length; // poor man's minifier
+ if (((len - striplen) / len) > 0.2) { // we saved 20%, so this component can get some mifinication done
+ return false;
+ }
+
+ return true;
+ },
+
+
+ /**
+ * Inspects the ETag.
+ *
+ * Returns FALSE (bad ETag) only if the server is Apache or IIS and the ETag format
+ * matches the default ETag format for the server. Anything else, including blank etag
+ * returns TRUE (good ETag).
+ * Default IIS: Filetimestamp:ChangeNumber
+ * Default Apache: inode-size-timestamp
+ *
+ * @param {String} etag ETag response header
+ * @return {Boolean} TRUE if ETag is good, FALSE otherwise
+ */
+ isETagGood: function (etag) {
+ var reIIS = /^[0-9a-f]+:([1-9a-f]|[0-9a-f]{2,})$/,
+ reApache = /^[0-9a-f]+\-[0-9a-f]+\-[0-9a-f]+$/;
+
+ if (!etag) {
+ return true; // no etag is ok etag
+ }
+
+ etag = etag.replace(/^["']|["'][\s\S]*$/g, ''); // strip " and '
+ return !(reApache.test(etag) || reIIS.test(etag));
+ },
+
+ /**
+ * Get internal component type from passed mime type.
+ * @param {String} content_type mime type of the content.
+ * @return yslow internal component type
+ * @type String
+ */
+ getComponentType: function (content_type) {
+ var c_type = 'unknown';
+
+ if (content_type && typeof content_type === "string") {
+ if (content_type === "text/html" || content_type === "text/plain") {
+ c_type = 'doc';
+ } else if (content_type === "text/css") {
+ c_type = 'css';
+ } else if (/javascript/.test(content_type)) {
+ c_type = 'js';
+ } else if (/flash/.test(content_type)) {
+ c_type = 'flash';
+ } else if (/image/.test(content_type)) {
+ c_type = 'image';
+ } else if (/font/.test(content_type)) {
+ c_type = 'font';
+ }
+ }
+
+ return c_type;
+ },
+
+ /**
+ * base64 encode the data. This works with data that fails win.atob.
+ * @param {bytes} data data to be encoded.
+ * @return bytes array of data base64 encoded.
+ */
+ base64Encode: function (data) {
+ var i, a, b, c, new_data = '',
+ padding = 0,
+ arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'];
+
+ for (i = 0; i < data.length; i += 3) {
+ a = data.charCodeAt(i);
+ if ((i + 1) < data.length) {
+ b = data.charCodeAt(i + 1);
+ } else {
+ b = 0;
+ padding += 1;
+ }
+ if ((i + 2) < data.length) {
+ c = data.charCodeAt(i + 2);
+ } else {
+ c = 0;
+ padding += 1;
+ }
+
+ new_data += arr[(a & 0xfc) >> 2];
+ new_data += arr[((a & 0x03) << 4) | ((b & 0xf0) >> 4)];
+ if (padding > 0) {
+ new_data += "=";
+ } else {
+ new_data += arr[((b & 0x0f) << 2) | ((c & 0xc0) >> 6)];
+ }
+ if (padding > 1) {
+ new_data += "=";
+ } else {
+ new_data += arr[(c & 0x3f)];
+ }
+ }
+
+ return new_data;
+ },
+
+ /**
+ * Creates x-browser XHR objects
+ *
+ * @return {XMLHTTPRequest} A new XHR object
+ */
+ getXHR: function () {
+ var i = 0,
+ xhr = null,
+ ids = ['MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP', 'Microsoft.XMLHTTP'];
+
+
+ if (typeof XMLHttpRequest === 'function') {
+ return new XMLHttpRequest();
+ }
+
+ for (i = 0; i < ids.length; i += 1) {
+ try {
+ xhr = new ActiveXObject(ids[i]);
+ break;
+ } catch (e) {}
+
+ }
+
+ return xhr;
+ },
+
+ /**
+ * Returns the computed style
+ *
+ * @param {HTMLElement} el A node
+ * @param {String} st Style identifier, e.g. "backgroundImage"
+ * @param {Boolean} get_url Whether to return a url
+ * @return {String|Boolean} The value of the computed style, FALSE if get_url is TRUE and the style is not a URL
+ */
+ getComputedStyle: function (el, st, get_url) {
+ var style, urlMatch,
+ res = '';
+
+ if (el.currentStyle) {
+ res = el.currentStyle[st];
+ }
+
+ if (el.ownerDocument && el.ownerDocument.defaultView && document.defaultView.getComputedStyle) {
+ style = el.ownerDocument.defaultView.getComputedStyle(el, '');
+ if (style) {
+ res = style[st];
+ }
+ }
+
+ if (!get_url) {
+ return res;
+ }
+
+ if (typeof res !== 'string') {
+ return false;
+ }
+
+ urlMatch = res.match(/\burl\((\'|\"|)([^\'\"]+?)\1\)/);
+ if (urlMatch) {
+ return urlMatch[2];
+ } else {
+ return false;
+ }
+ },
+
+ /**
+ * escape '<' and '>' in the passed html code.
+ * @param {String} html code to be escaped.
+ * @return escaped html code
+ * @type String
+ */
+ escapeHtml: function (html) {
+ return (html || '').toString()
+ .replace(//g, ">");
+ },
+
+ /**
+ * escape quotes in the passed html code.
+ * @param {String} str string to be escaped.
+ * @param {String} which type of quote to be escaped. 'single' or 'double'
+ * @return escaped string code
+ * @type String
+ */
+ escapeQuotes: function (str, which) {
+ if (which === 'single') {
+ return str.replace(/\'/g, '\\\''); // '
+ }
+ if (which === 'double') {
+ return str.replace(/\"/g, '\\\"'); // "
+ }
+ return str.replace(/\'/g, '\\\'').replace(/\"/g, '\\\"'); // ' and "
+ },
+
+ /**
+ * Convert a HTTP header name to its canonical form,
+ * e.g. "content-length" => "Content-Length".
+ * @param headerName the header name (case insensitive)
+ * @return {String} the formatted header name
+ */
+ formatHeaderName: (function () {
+ var specialCases = {
+ 'content-md5': 'Content-MD5',
+ dnt: 'DNT',
+ etag: 'ETag',
+ p3p: 'P3P',
+ te: 'TE',
+ 'www-authenticate': 'WWW-Authenticate',
+ 'x-att-deviceid': 'X-ATT-DeviceId',
+ 'x-cdn': 'X-CDN',
+ 'x-ua-compatible': 'X-UA-Compatible',
+ 'x-xss-protection': 'X-XSS-Protection'
+ };
+ return function (headerName) {
+ var lowerCasedHeaderName = headerName.toLowerCase();
+ if (specialCases.hasOwnProperty(lowerCasedHeaderName)) {
+ return specialCases[lowerCasedHeaderName];
+ } else {
+ // Make sure that the first char and all chars following a dash are upper-case:
+ return lowerCasedHeaderName.replace(/(^|-)([a-z])/g, function ($0, optionalLeadingDash, ch) {
+ return optionalLeadingDash + ch.toUpperCase();
+ });
+ }
+ };
+ }()),
+
+ /**
+ * Math mod method.
+ * @param {Number} divisee
+ * @param {Number} base
+ * @return mod result
+ * @type Number
+ */
+ mod: function (divisee, base) {
+ return Math.round(divisee - (Math.floor(divisee / base) * base));
+ },
+
+ /**
+ * Abbreviate the passed url to not exceed maxchars.
+ * (Just display the hostname and first few chars after the last slash.
+ * @param {String} url originial url
+ * @param {Number} maxchars max. number of characters in the result string.
+ * @return abbreviated url
+ * @type String
+ */
+ briefUrl: function (url, maxchars) {
+ var iDoubleSlash, iQMark, iFirstSlash, iLastSlash;
+
+ maxchars = maxchars || 100; // default 100 characters
+ if (url === undefined) {
+ return '';
+ }
+
+ // We assume it's a full URL.
+ iDoubleSlash = url.indexOf("//");
+ if (-1 !== iDoubleSlash) {
+
+ // remove query string
+ iQMark = url.indexOf("?");
+ if (-1 !== iQMark) {
+ url = url.substring(0, iQMark) + "?...";
+ }
+
+ if (url.length > maxchars) {
+ iFirstSlash = url.indexOf("/", iDoubleSlash + 2);
+ iLastSlash = url.lastIndexOf("/");
+ if (-1 !== iFirstSlash && -1 !== iLastSlash && iFirstSlash !== iLastSlash) {
+ url = url.substring(0, iFirstSlash + 1) + "..." + url.substring(iLastSlash);
+ } else {
+ url = url.substring(0, maxchars + 1) + "...";
+ }
+ }
+ }
+
+ return url;
+ },
+
+ /**
+ * Return a string with an anchor around a long piece of text.
+ * (It's confusing, but often the "long piece of text" is the URL itself.)
+ * Snip the long text if necessary.
+ * Optionally, break the long text across multiple lines.
+ * @param {String} text
+ * @param {String} url
+ * @param {String} sClass class name for the new anchor
+ * @param {Boolean} bBriefUrl whether the url should be abbreviated.
+ * @param {Number} maxChars max. number of chars allowed for each line.
+ * @param {Number} numLines max. number of lines allowed
+ * @param {String} rel rel attribute of anchor.
+ * @return html code for the anchor.
+ * @type String
+ */
+ prettyAnchor: function (text, url, sClass, bBriefUrl, maxChars, numLines, rel) {
+ var escaped_dq_url,
+ sTitle = '',
+ sResults = '',
+ iLines = 0;
+
+ if (typeof url === 'undefined') {
+ url = text;
+ }
+ if (typeof sClass === 'undefined') {
+ sClass = '';
+ } else {
+ sClass = ' class="' + sClass + '"';
+ }
+ if (typeof maxChars === 'undefined') {
+ maxChars = 100;
+ }
+ if (typeof numLines === 'undefined') {
+ numLines = 1;
+ }
+ rel = (rel) ? ' rel="' + rel + '"' : '';
+
+ url = YSLOW.util.escapeHtml(url);
+ text = YSLOW.util.escapeHtml(text);
+
+ escaped_dq_url = YSLOW.util.escapeQuotes(url, 'double');
+
+ if (bBriefUrl) {
+ text = YSLOW.util.briefUrl(text, maxChars);
+ sTitle = ' title="' + escaped_dq_url + '"';
+ }
+
+ while (0 < text.length) {
+ sResults += '' + text.substring(0, maxChars);
+ text = text.substring(maxChars);
+ iLines += 1;
+ if (iLines >= numLines) {
+ // We've reached the maximum number of lines.
+ if (0 < text.length) {
+ // If there's still text leftover, snip it.
+ sResults += "[snip]";
+ }
+ sResults += "";
+ break;
+ } else {
+ // My (weak) attempt to break long URLs.
+ sResults += " ";
+ }
+ }
+
+ return sResults;
+ },
+
+ /**
+ * Convert a number of bytes into a readable KB size string.
+ * @param {Number} size
+ * @return readable KB size string
+ * @type String
+ */
+ kbSize: function (size) {
+ var remainder = size % (size > 100 ? 100 : 10);
+ size -= remainder;
+ return parseFloat(size / 1000) + (0 === (size % 1000) ? ".0" : "") + "K";
+ },
+
+ /**
+ * @final
+ */
+ prettyTypes: {
+ "image": "Image",
+ "doc": "HTML/Text",
+ "cssimage": "CSS Image",
+ "css": "Stylesheet File",
+ "js": "JavaScript File",
+ "flash": "Flash Object",
+ "iframe": "IFrame",
+ "xhr": "XMLHttpRequest",
+ "redirect": "Redirect",
+ "favicon": "Favicon",
+ "unknown": "Unknown"
+ },
+
+/*
+ * Convert a type (eg, "cssimage") to a prettier name (eg, "CSS Images").
+ * @param {String} sType component type
+ * @return display name of component type
+ * @type String
+ */
+ prettyType: function (sType) {
+ return YSLOW.util.prettyTypes[sType];
+ },
+
+ /**
+ * Return a letter grade for a score.
+ * @param {String or Number} iScore
+ * @return letter grade for a score
+ * @type String
+ */
+ prettyScore: function (score) {
+ var letter = 'F';
+
+ if (!parseInt(score, 10) && score !== 0) {
+ return score;
+ }
+ if (score === -1) {
+ return 'N/A';
+ }
+
+ if (score >= 90) {
+ letter = 'A';
+ } else if (score >= 80) {
+ letter = 'B';
+ } else if (score >= 70) {
+ letter = 'C';
+ } else if (score >= 60) {
+ letter = 'D';
+ } else if (score >= 50) {
+ letter = 'E';
+ }
+
+ return letter;
+ },
+
+ /**
+ * Returns YSlow results as an Object.
+ * @param {YSLOW.context} yscontext yslow context.
+ * @param {String|Array} info Information to be shown
+ * (basic|grade|stats|comps|all) [basic].
+ * @return {Object} the YSlow results object.
+ */
+ getResults: function (yscontext, info) {
+ var i, l, results, url, type, comps, comp, encoded_url, obj, cr,
+ cs, etag, name, len, include_grade, include_comps, include_stats,
+ result, len2, spaceid, header, sourceHeaders, targetHeaders,
+ reButton = /
';
+
+ this.addButtonView('panel_about', sHtml);
+ },
+
+ /**
+ * Show progress bar.
+ */
+ genProgressView: function () {
+ var sBody = '
Finding components in the page:
' + '
' + '
Getting component information:
' + '
start...
';
+
+ this.setButtonView('panel_about', sBody);
+ },
+
+ /**
+ * Update progress bar with passed info.
+ * @param {String} progress_type Type of progress info: either 'peel' or 'fetch'.
+ * @param {Object} progress_info
+ *
For peel:
+ *
current_step - {Number} current phase of peeling
+ *
total_step - {Number} total number peeling phases
+ *
message - {String} Progress message
+ *
+ *
For fetch:
+ *
current - {Number} Number of components already downloaded
+ *
total - {Number} Total number of componetns to be downloaded
+ *
last_component_url - {String} URL of the last downloaded component.
+ *
+ */
+ updateProgressView: function (progress_type, progress_info) {
+ var outerbar, progbar, progtext, percent, view, maxwidth, width, left,
+ message = '';
+
+ if (this.curButtonId === 'panel_about') {
+ view = this.getButtonView(this.curButtonId);
+
+ if (progress_type === 'peel') {
+ outerbar = this.getElementByTagNameAndId(view, 'div', 'peelprogress');
+ progbar = this.getElementByTagNameAndId(view, 'div', 'progbar');
+ progtext = this.getElementByTagNameAndId(view, 'div', 'progtext');
+ message = progress_info.message;
+ percent = (progress_info.current_step * 100) / progress_info.total_step;
+ } else if (progress_type === 'fetch') {
+ outerbar = this.getElementByTagNameAndId(view, 'div', 'fetchprogress');
+ progbar = this.getElementByTagNameAndId(view, 'div', 'progbar2');
+ progtext = this.getElementByTagNameAndId(view, 'div', 'progtext2');
+ message = progress_info.last_component_url;
+ percent = (progress_info.current * 100) / progress_info.total;
+ } else if (progress_type === 'message') {
+ progtext = this.getElementByTagNameAndId(view, 'div', 'progtext2');
+ if (progtext) {
+ progtext.innerHTML = progress_info;
+ }
+
+ return;
+ } else {
+ return;
+ }
+ }
+
+ if (outerbar && progbar && progtext) {
+ maxwidth = outerbar.clientWidth;
+
+ if (percent < 0) {
+ percent = 0;
+ }
+ if (percent > 100) {
+ percent = 100;
+ }
+
+ percent = 100 - percent;
+ width = (maxwidth * percent) / 100;
+ if (width > maxwidth) {
+ width = maxwidth;
+ }
+ left = maxwidth - parseInt(width, 10);
+ progbar.style.width = parseInt(width, 10) + "px";
+ progbar.style.left = parseInt(left, 10) + "px";
+
+ progtext.innerHTML = message;
+ }
+ },
+
+ /**
+ * @private
+ */
+ updateStatusBar: function (doc) {
+ var size, grade, result, info, url,
+ yslow = YSLOW,
+ util = yslow.util,
+ view = yslow.view,
+ pref = util.Preference,
+ yscontext = this.yscontext;
+
+ if (!yscontext.PAGE.statusbar) {
+ // only set the bar once
+ yscontext.PAGE.statusbar = true;
+
+ // If some of the info isn't available, we have to run some code.
+ if (!yscontext.PAGE.overallScore) {
+ // run lint
+ yslow.controller.lint(doc, yscontext);
+ }
+ if (!yscontext.PAGE.totalSize) {
+ // collect stats
+ yscontext.collectStats();
+ }
+
+ size = util.kbSize(yscontext.PAGE.totalSize);
+ grade = util.prettyScore(yscontext.PAGE.overallScore);
+
+ view.setStatusBar(grade, 'yslow_status_grade');
+ view.setStatusBar(size, 'yslow_status_size');
+
+ // Send a beacon.
+ if (pref.getPref('optinBeacon', false)) {
+ info = pref.getPref('beaconInfo', 'basic'),
+ url = pref.getPref('beaconUrl',
+ 'http://rtblab.pclick.yahoo.com/images/ysb.gif');
+ result = util.getResults(yscontext, info);
+ util.sendBeacon(result, info, url);
+ }
+ }
+ },
+
+ /**
+ * @private
+ */
+ getRulesetListSource: function (rulesets) {
+ var id, custom,
+ sHtml = '',
+ defaultRulesetId = YSLOW.controller.getDefaultRulesetId();
+
+ for (id in rulesets) {
+ if (rulesets[id]) {
+ sHtml += '