first commit

build/node_modules/http2-push-manifest/lib/listresources.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright 2015 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// jshint node: true
+'use strict';
+
+let fs = require('fs');
+let hyd = require('hydrolysis');
+let dom5 = require('dom5');
+let url = require('url');
+let path = require('path');
+
+/**
+ * Swallows errors from Hydrolysis so ENOENT files don't throw errors.
+ * @class
+ * @extends {hydrolysis.FSResolver}
+ */
+class ErrorSwallowingFSResolver extends hyd.FSResolver {
+  constructor(config) {
+    super(config);
+  }
+
+  accept(uri, deferred) {
+    var reject = deferred.reject;
+    deferred.reject = arg => deferred.resolve('');
+    return super.accept(uri, deferred);
+  }
+}
+
+
+/**
+ * Finds and collects the static resources in a page.
+ * @class
+ */
+class ResourceList {
+
+  static get EXTERNAL_RESOURCE() {
+    return /^(?:https?:)?\/\//;
+  }
+
+  constructor(opts) {
+    this.basePath = opts.basePath;
+
+    let inputPath = opts.inputPath;
+
+    if (!inputPath || !this.basePath) {
+      console.error('Need input path!');
+      process.exit(1);
+    }
+
+    this.basePath = path.resolve(this.basePath);
+    inputPath = path.resolve(path.resolve(this.basePath, inputPath));
+
+    if (fs.statSync(inputPath).isDirectory()) {
+      inputPath = path.join(inputPath, 'index.html');
+    }
+
+    let loader = new hyd.Loader();
+    loader.addResolver(new ErrorSwallowingFSResolver({
+      root: this.basePath,
+      basePath: '/'
+    }));
+
+    // Ignore external resources.
+    loader.addResolver(new hyd.NoopResolver(ResourceList.EXTERNAL_RESOURCE));
+
+    this.analyzer = new hyd.Analyzer(false, loader);
+
+    this.inputPath = path.join('/', path.relative(this.basePath, inputPath));
+  }
+
+  treeToList(tree, accum) {
+    if (!accum) {
+      accum = [];
+    }
+    accum.push(tree.href);
+  }
+
+  styleToUrl(href, style) {
+    let src = dom5.getAttribute(style, 'href');
+    if (ResourceList.EXTERNAL_RESOURCE.test(src)) {
+      return;
+    }
+    if (src) {
+      return url.resolve(href, src);
+    }
+  }
+
+  scriptToUrl(href, script) {
+    let src = dom5.getAttribute(script, 'src');
+    if (ResourceList.EXTERNAL_RESOURCE.test(src)) {
+      return;
+    }
+    if (src) {
+      return url.resolve(href, src);
+    }
+  }
+
+  treeToUrls(tree, accum) {
+    if (!accum) {
+      accum = [];
+    }
+    if (!tree) {
+      return accum;
+    }
+    if (!tree.href) {
+      return accum;
+    }
+    accum.push(tree.href);
+    tree.imports.forEach(im => {
+      if (im.href) {
+        this.treeToUrls(im, accum);
+      }
+    });
+    tree.html.script.forEach(script => {
+      let u = this.scriptToUrl(tree.href, script);
+      if (u) {
+        accum.push(u);
+      }
+    });
+    tree.html.style.forEach(style => {
+      let u = this.styleToUrl(tree.href, style);
+      if (u) {
+        accum.push(u);
+      }
+    });
+    return accum;
+  }
+
+  list() {
+    return this.analyzer.metadataTree(this.inputPath).then(tree => {
+      let list = this.treeToUrls(tree).slice(1).reverse();
+      return list;
+    }).catch(err => {
+      console.error(err);
+    });
+  }
+}
+
+module.exports = ResourceList;