select_all-rails 0.3.0 → 0.3.1

data/node_modules/jsdom/lib/jsdom/living/nodes/NonDocumentTypeChildNode-impl.js

@@ -0,0 +1,28 @@
+"use strict";
+
+const domSymbolTree = require("../helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../node-type");
+
+class NonDocumentTypeChildNodeImpl {
+  get nextElementSibling() {
+    for (const sibling of domSymbolTree.nextSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+
+  get previousElementSibling() {
+    for (const sibling of domSymbolTree.previousSiblingsIterator(this)) {
+      if (sibling.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+}
+
+module.exports = {
+  implementation: NonDocumentTypeChildNodeImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/NonElementParentNode-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+class NonElementParentNodeImpl {
+
+}
+
+module.exports = {
+  implementation: NonElementParentNodeImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/ParentNode-impl.js

@@ -0,0 +1,91 @@
+"use strict";
+
+const idlUtils = require("../generated/utils");
+
+const nwmatcher = require("nwmatcher/src/nwmatcher-noqsa");
+const DOMException = require("../../web-idl/DOMException");
+const domSymbolTree = require("../helpers/internal-constants").domSymbolTree;
+const NODE_TYPE = require("../node-type");
+const createHTMLCollection = require("../html-collection").create;
+const updateHTMLCollection = require("../html-collection").update;
+const memoizeQuery = require("../../utils").memoizeQuery;
+const createStaticNodeList = require("../node-list").createStatic;
+
+// nwmatcher gets `document.documentElement` at creation-time, so we have to initialize lazily, since in the initial
+// stages of Document initialization, there is no documentElement present yet.
+function addNwmatcher(parentNode) {
+  const document = parentNode._ownerDocument;
+
+  if (!document._nwmatcher) {
+    document._nwmatcher = nwmatcher({ document });
+    document._nwmatcher.configure({ UNIQUE_ID: false });
+  }
+
+  return document._nwmatcher;
+}
+
+class ParentNodeImpl {
+  get children() {
+    if (!this._childrenList) {
+      this._childrenList = createHTMLCollection(this, () => {
+        return domSymbolTree.childrenToArray(this, { filter(node) {
+          return node.nodeType === NODE_TYPE.ELEMENT_NODE;
+        } });
+      });
+    } else {
+      updateHTMLCollection(this._childrenList);
+    }
+    return this._childrenList;
+  }
+
+  get firstElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this)) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get lastElementChild() {
+    for (const child of domSymbolTree.childrenIterator(this, { reverse: true })) {
+      if (child.nodeType === NODE_TYPE.ELEMENT_NODE) {
+        return child;
+      }
+    }
+
+    return null;
+  }
+
+  get childElementCount() {
+    return this.children.length;
+  }
+}
+
+ParentNodeImpl.prototype.querySelector = memoizeQuery(function (selectors) {
+  const matcher = addNwmatcher(this);
+
+  try {
+    return matcher.first(selectors, idlUtils.wrapperForImpl(this));
+  } catch (e) {
+    throw new DOMException(DOMException.SYNTAX_ERR, e.message);
+  }
+});
+
+ParentNodeImpl.prototype.querySelectorAll = memoizeQuery(function (selectors) {
+  const matcher = addNwmatcher(this);
+
+  let list;
+  try {
+    list = matcher.select(selectors, idlUtils.wrapperForImpl(this));
+  } catch (e) {
+    throw new DOMException(DOMException.SYNTAX_ERR, e.message);
+  }
+
+  return createStaticNodeList(list);
+});
+
+module.exports = {
+  implementation: ParentNodeImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/ProcessingInstruction-impl.js

@@ -0,0 +1,22 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const NODE_TYPE = require("../node-type");
+
+class ProcessingInstructionImpl extends CharacterDataImpl {
+  constructor(args, privateData) {
+    super(args, privateData);
+
+    this.nodeType = NODE_TYPE.PROCESSING_INSTRUCTION_NODE;
+    this._target = privateData.target;
+  }
+
+  get target() {
+    return this._target;
+  }
+}
+
+module.exports = {
+  implementation: ProcessingInstructionImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/Text-impl.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const CharacterDataImpl = require("./CharacterData-impl").implementation;
+
+const domSymbolTree = require("../helpers/internal-constants").domSymbolTree;
+const DOMException = require("../../web-idl/DOMException");
+const NODE_TYPE = require("../node-type");
+
+class TextImpl extends CharacterDataImpl {
+  constructor(args, privateData) {
+    super(args, privateData);
+
+    this.nodeType = NODE_TYPE.TEXT_NODE;
+  }
+
+  splitText(offset) {
+    offset >>>= 0;
+
+    const length = this.length;
+
+    if (offset > length) {
+      throw new DOMException(DOMException.INDEX_SIZE_ERR);
+    }
+
+    const count = length - offset;
+    const newData = this.substringData(offset, count);
+
+    const newNode = this._ownerDocument.createTextNode(newData);
+
+    const parent = domSymbolTree.parent(this);
+
+    if (parent !== null) {
+      parent.insertBefore(newNode, this.nextSibling);
+    }
+
+    this.replaceData(offset, count, "");
+
+    return newNode;
+
+    // TODO: range stuff
+  }
+
+  // TODO: wholeText property
+}
+
+module.exports = {
+  implementation: TextImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/WindowEventHandlers-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+class WindowEventHandlersImpl {
+
+}
+
+module.exports = {
+  implementation: WindowEventHandlersImpl
+};

data/node_modules/jsdom/lib/jsdom/living/nodes/XMLDocument-impl.js

@@ -0,0 +1,4 @@
+"use strict";
+const DocumentImpl = require("./Document-impl").implementation;
+
+exports.implementation = class XMLDocumentImpl extends DocumentImpl {};

data/node_modules/jsdom/lib/jsdom/living/post-message.js

@@ -0,0 +1,36 @@
+"use strict";
+const isValidTargetOrigin = require("../utils").isValidTargetOrigin;
+const DOMException = require("../web-idl/DOMException");
+
+module.exports = function (message, targetOrigin) {
+  if (arguments.length < 2) {
+    throw new TypeError("'postMessage' requires 2 arguments: 'message' and 'targetOrigin'");
+  }
+
+  targetOrigin = String(targetOrigin);
+
+  if (!isValidTargetOrigin(targetOrigin)) {
+    throw new DOMException(DOMException.SYNTAX_ERR, "Failed to execute 'postMessage' on 'Window': " +
+      "Invalid target origin '" + targetOrigin + "' in a call to 'postMessage'.");
+  }
+
+  // TODO: targetOrigin === '/' - requires reference to source window
+  // See https://github.com/tmpvar/jsdom/pull/1140#issuecomment-111587499
+  if (targetOrigin !== "*" && targetOrigin !== this.origin) {
+    return;
+  }
+
+  // TODO: event.source - requires reference to source window
+  // TODO: event.origin - requires reference to source window
+  // TODO: event.ports
+  // TODO: event.data - structured clone message - requires cloning DOM nodes
+  const event = new this.MessageEvent("message", {
+    data: message
+  });
+
+  event.initEvent("message", false, false);
+
+  setTimeout(() => {
+    this.dispatchEvent(event);
+  }, 0);
+};

data/node_modules/jsdom/lib/jsdom/living/register-elements.js

@@ -0,0 +1,306 @@
+"use strict";
+/* eslint global-require: 0 */
+
+const DocumentImpl = require("./nodes/Document-impl.js");
+
+const mappings = {
+  HTMLElement: {
+    file: require("./generated/HTMLElement.js"),
+    tags: []
+  },
+  HTMLAnchorElement: {
+    file: require("./generated/HTMLAnchorElement.js"),
+    tags: ["a"]
+  },
+  HTMLAppletElement: {
+    file: require("./generated/HTMLAppletElement.js"),
+    tags: ["applet"]
+  },
+  HTMLAreaElement: {
+    file: require("./generated/HTMLAreaElement.js"),
+    tags: ["area"]
+  },
+  HTMLAudioElement: {
+    file: require("./generated/HTMLAudioElement.js"),
+    tags: ["audio"]
+  },
+  HTMLBaseElement: {
+    file: require("./generated/HTMLBaseElement.js"),
+    tags: ["base"]
+  },
+  HTMLBodyElement: {
+    file: require("./generated/HTMLBodyElement.js"),
+    tags: ["body"]
+  },
+  HTMLBRElement: {
+    file: require("./generated/HTMLBRElement.js"),
+    tags: ["br"]
+  },
+  HTMLButtonElement: {
+    file: require("./generated/HTMLButtonElement.js"),
+    tags: ["button"]
+  },
+  HTMLCanvasElement: {
+    file: require("./generated/HTMLCanvasElement.js"),
+    tags: ["canvas"]
+  },
+  HTMLDataElement: {
+    file: require("./generated/HTMLDataElement.js"),
+    tags: ["data"]
+  },
+  HTMLDataListElement: {
+    file: require("./generated/HTMLDataListElement.js"),
+    tags: ["datalist"]
+  },
+  HTMLDialogElement: {
+    file: require("./generated/HTMLDialogElement.js"),
+    tags: ["dialog"]
+  },
+  HTMLDirectoryElement: {
+    file: require("./generated/HTMLDirectoryElement.js"),
+    tags: ["dir"]
+  },
+  HTMLDivElement: {
+    file: require("./generated/HTMLDivElement.js"),
+    tags: ["div"]
+  },
+  HTMLDListElement: {
+    file: require("./generated/HTMLDListElement.js"),
+    tags: ["dl"]
+  },
+  HTMLEmbedElement: {
+    file: require("./generated/HTMLEmbedElement.js"),
+    tags: ["embed"]
+  },
+  HTMLFieldSetElement: {
+    file: require("./generated/HTMLFieldSetElement.js"),
+    tags: ["fieldset"]
+  },
+  HTMLFontElement: {
+    file: require("./generated/HTMLFontElement.js"),
+    tags: ["font"]
+  },
+  HTMLFormElement: {
+    file: require("./generated/HTMLFormElement.js"),
+    tags: ["form"]
+  },
+  HTMLFrameElement: {
+    file: require("./generated/HTMLFrameElement.js"),
+    tags: ["frame"]
+  },
+  HTMLFrameSetElement: {
+    file: require("./generated/HTMLFrameSetElement.js"),
+    tags: ["frameset"]
+  },
+  HTMLHeadingElement: {
+    file: require("./generated/HTMLHeadingElement.js"),
+    tags: ["h1", "h2", "h3", "h4", "h5", "h6"]
+  },
+  HTMLHeadElement: {
+    file: require("./generated/HTMLHeadElement.js"),
+    tags: ["head"]
+  },
+  HTMLHRElement: {
+    file: require("./generated/HTMLHRElement.js"),
+    tags: ["hr"]
+  },
+  HTMLHtmlElement: {
+    file: require("./generated/HTMLHtmlElement.js"),
+    tags: ["html"]
+  },
+  HTMLIFrameElement: {
+    file: require("./generated/HTMLIFrameElement.js"),
+    tags: ["iframe"]
+  },
+  HTMLImageElement: {
+    file: require("./generated/HTMLImageElement.js"),
+    tags: ["img"]
+  },
+  HTMLInputElement: {
+    file: require("./generated/HTMLInputElement.js"),
+    tags: ["input"]
+  },
+  HTMLLabelElement: {
+    file: require("./generated/HTMLLabelElement.js"),
+    tags: ["label"]
+  },
+  HTMLLegendElement: {
+    file: require("./generated/HTMLLegendElement.js"),
+    tags: ["legend"]
+  },
+  HTMLLIElement: {
+    file: require("./generated/HTMLLIElement.js"),
+    tags: ["li"]
+  },
+  HTMLLinkElement: {
+    file: require("./generated/HTMLLinkElement.js"),
+    tags: ["link"]
+  },
+  HTMLMapElement: {
+    file: require("./generated/HTMLMapElement.js"),
+    tags: ["map"]
+  },
+  HTMLMediaElement: {
+    file: require("./generated/HTMLMediaElement.js"),
+    tags: []
+  },
+  HTMLMenuElement: {
+    file: require("./generated/HTMLMenuElement.js"),
+    tags: ["menu"]
+  },
+  HTMLMetaElement: {
+    file: require("./generated/HTMLMetaElement.js"),
+    tags: ["meta"]
+  },
+  HTMLMeterElement: {
+    file: require("./generated/HTMLMeterElement.js"),
+    tags: ["meter"]
+  },
+  HTMLModElement: {
+    file: require("./generated/HTMLModElement.js"),
+    tags: ["del", "ins"]
+  },
+  HTMLObjectElement: {
+    file: require("./generated/HTMLObjectElement.js"),
+    tags: ["object"]
+  },
+  HTMLOListElement: {
+    file: require("./generated/HTMLOListElement.js"),
+    tags: ["ol"]
+  },
+  HTMLOptGroupElement: {
+    file: require("./generated/HTMLOptGroupElement.js"),
+    tags: ["optgroup"]
+  },
+  HTMLOptionElement: {
+    file: require("./generated/HTMLOptionElement.js"),
+    tags: ["option"]
+  },
+  HTMLOutputElement: {
+    file: require("./generated/HTMLOutputElement.js"),
+    tags: ["output"]
+  },
+  HTMLParagraphElement: {
+    file: require("./generated/HTMLParagraphElement.js"),
+    tags: ["p"]
+  },
+  HTMLParamElement: {
+    file: require("./generated/HTMLParamElement.js"),
+    tags: ["param"]
+  },
+  HTMLPreElement: {
+    file: require("./generated/HTMLPreElement.js"),
+    tags: ["pre"]
+  },
+  HTMLProgressElement: {
+    file: require("./generated/HTMLProgressElement.js"),
+    tags: ["progress"]
+  },
+  HTMLQuoteElement: {
+    file: require("./generated/HTMLQuoteElement.js"),
+    tags: ["blockquote", "q"]
+  },
+  HTMLScriptElement: {
+    file: require("./generated/HTMLScriptElement.js"),
+    tags: ["script"]
+  },
+  HTMLSelectElement: {
+    file: require("./generated/HTMLSelectElement.js"),
+    tags: ["select"]
+  },
+  HTMLSourceElement: {
+    file: require("./generated/HTMLSourceElement.js"),
+    tags: ["source"]
+  },
+  HTMLSpanElement: {
+    file: require("./generated/HTMLSpanElement.js"),
+    tags: ["span"]
+  },
+  HTMLStyleElement: {
+    file: require("./generated/HTMLStyleElement.js"),
+    tags: ["style"]
+  },
+  HTMLTableCaptionElement: {
+    file: require("./generated/HTMLTableCaptionElement.js"),
+    tags: ["caption"]
+  },
+  HTMLTableCellElement: {
+    file: require("./generated/HTMLTableCellElement.js"),
+    tags: []
+  },
+  HTMLTableColElement: {
+    file: require("./generated/HTMLTableColElement.js"),
+    tags: ["col", "colgroup"]
+  },
+  HTMLTableDataCellElement: {
+    file: require("./generated/HTMLTableDataCellElement.js"),
+    tags: ["td"]
+  },
+  HTMLTableElement: {
+    file: require("./generated/HTMLTableElement.js"),
+    tags: ["table"]
+  },
+  HTMLTableHeaderCellElement: {
+    file: require("./generated/HTMLTableHeaderCellElement.js"),
+    tags: ["th"]
+  },
+  HTMLTimeElement: {
+    file: require("./generated/HTMLTimeElement.js"),
+    tags: ["time"]
+  },
+  HTMLTitleElement: {
+    file: require("./generated/HTMLTitleElement.js"),
+    tags: ["title"]
+  },
+  HTMLTableRowElement: {
+    file: require("./generated/HTMLTableRowElement.js"),
+    tags: ["tr"]
+  },
+  HTMLTableSectionElement: {
+    file: require("./generated/HTMLTableSectionElement.js"),
+    tags: ["thead", "tbody", "tfoot"]
+  },
+  HTMLTemplateElement: {
+    file: require("./generated/HTMLTemplateElement.js"),
+    tags: ["template"]
+  },
+  HTMLTextAreaElement: {
+    file: require("./generated/HTMLTextAreaElement.js"),
+    tags: ["textarea"]
+  },
+  HTMLTrackElement: {
+    file: require("./generated/HTMLTrackElement.js"),
+    tags: ["track"]
+  },
+  HTMLUListElement: {
+    file: require("./generated/HTMLUListElement.js"),
+    tags: ["ul"]
+  },
+  HTMLUnknownElement: {
+    file: require("./generated/HTMLUnknownElement.js"),
+    tags: []
+  },
+  HTMLVideoElement: {
+    file: require("./generated/HTMLVideoElement.js"),
+    tags: ["video"]
+  }
+};
+
+module.exports = core => {
+  for (const interfaceName of Object.keys(mappings)) {
+    const file = mappings[interfaceName].file;
+    const tags = mappings[interfaceName].tags;
+
+    core[interfaceName] = file.interface;
+
+    for (const tagName of tags) {
+      DocumentImpl.implementation.prototype._elementBuilders[tagName] = (document, elName) => {
+        return file.create([], {
+          core,
+          ownerDocument: document,
+          localName: elName || tagName.toUpperCase()
+        });
+      };
+    }
+  }
+};