rails-assets-enzyme 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2c7dd53db462ee9f020ae0e6804788737dc4d33
+  data.tar.gz: 152794407dc2405b920646ebc5c675c0183711ee
+SHA512:
+  metadata.gz: bc5b396ced19648aeb68cbfd563768fa816e7643bba93a428c413b7465e9517777598bcd3d4205c6d8b48d56cc6092c5053972a50d39cbb30cec53262b655678
+  data.tar.gz: 70ee5a89eb4d5be6e86596793410f3a05504480ec0084c7a488c91ae69bf4a29919b48ff218681ace6e43f8597e717bf59491c83d40b9b7acb2aaca553d8b761

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Franze Jr.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Rails::Assets::Enzyme
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails-assets-enzyme'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails-assets-enzyme
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/rails-assets-enzyme/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/rails/assets/enzyme.rb

@@ -0,0 +1,9 @@
+require "rails/assets/enzyme/version"
+
+module Rails
+  module Assets
+    module Enzyme
+      # Your code goes here...
+    end
+  end
+end

data/lib/rails/assets/enzyme/version.rb

@@ -0,0 +1,7 @@
+module Rails
+  module Assets
+    module Enzyme
+      VERSION = "0.0.1"
+    end
+  end
+end

data/vendor/assets/javascripts/Debug.js

@@ -0,0 +1,133 @@
+import {
+  childrenOfNode,
+} from './ShallowTraversal';
+import {
+  renderedChildrenOfInst,
+} from './MountedTraversal';
+import {
+  isDOMComponent,
+  isCompositeComponent,
+  isElement,
+} from './react-compat';
+import {
+  internalInstance,
+  propsOfNode,
+} from './Utils';
+import without from 'lodash/without';
+import escape from 'lodash/escape';
+import compact from 'lodash/compact';
+import { REACT013 } from './version';
+import objectValues from 'object.values';
+
+export function typeName(node) {
+  return typeof node.type === 'function'
+    ? (node.type.displayName || node.type.name || 'Component')
+    : node.type;
+}
+
+export function spaces(n) {
+  return Array(n + 1).join(' ');
+}
+
+export function indent(depth, string) {
+  return string.split('\n').map(x => `${spaces(depth)}${x}`).join('\n');
+}
+
+function propString(prop) {
+  switch (typeof prop) {
+    case 'function':
+      return '{[Function]}';
+    case 'string':
+      return `"${prop}"`;
+    case 'number':
+    case 'boolean':
+      return `{${prop}}`;
+    case 'object':
+      return '{{...}}';
+    default:
+      return `{[${typeof prop}]}`;
+  }
+}
+
+function propsString(node) {
+  const props = propsOfNode(node);
+  const keys = without(Object.keys(props), 'children');
+  return keys.map(key => `${key}=${propString(props[key])}`).join(' ');
+}
+
+export function debugNode(node, indentLength = 2) {
+  if (typeof node === 'string' || typeof node === 'number') return escape(node);
+  if (!node) return '';
+
+  const children = compact(childrenOfNode(node).map(n => debugNode(n, indentLength)));
+  const type = typeName(node);
+  const props = propsString(node);
+  const beforeProps = props ? ' ' : '';
+  const nodeClose = children.length ? `</${type}>` : '/>';
+  const afterProps = children.length
+    ? '>'
+    : ' ';
+  const childrenIndented = children.length
+    ? `\n${children.map(x => indent(indentLength, x)).join('\n')}\n`
+    : '';
+  return `<${type}${beforeProps}${props}${afterProps}${childrenIndented}${nodeClose}`;
+}
+
+export function debugNodes(nodes) {
+  return nodes.map(debugNode).join('\n\n\n');
+}
+
+export function debugInst(inst, indentLength = 2) {
+  if (typeof inst === 'string' || typeof inst === 'number') return escape(inst);
+  if (!inst) return '';
+
+  if (!inst.getPublicInstance) {
+    const internal = internalInstance(inst);
+    return debugInst(internal, indentLength);
+  }
+  const publicInst = inst.getPublicInstance();
+
+  if (typeof publicInst === 'string' || typeof publicInst === 'number') return escape(publicInst);
+  if (!publicInst && !inst._renderedComponent) return '';
+
+  // do stuff with publicInst
+  const currentElement = inst._currentElement;
+  const type = typeName(currentElement);
+  const props = propsString(currentElement);
+  const children = [];
+  if (isDOMComponent(publicInst)) {
+    const renderedChildren = renderedChildrenOfInst(inst);
+    if (!renderedChildren) {
+      children.push(...childrenOfNode(currentElement));
+    } else {
+      children.push(...objectValues(renderedChildren));
+    }
+  } else if (
+    !REACT013 &&
+    isElement(currentElement) &&
+    typeof currentElement.type === 'function'
+  ) {
+    children.push(inst._renderedComponent);
+  } else if (
+    REACT013 &&
+    isCompositeComponent(publicInst)
+  ) {
+    children.push(inst._renderedComponent);
+  }
+
+  const childrenStrs = compact(children.map(n => debugInst(n, indentLength)));
+
+  const beforeProps = props ? ' ' : '';
+  const nodeClose = childrenStrs.length ? `</${type}>` : '/>';
+  const afterProps = childrenStrs.length
+    ? '>'
+    : ' ';
+  const childrenIndented = childrenStrs.length
+    ? `\n${childrenStrs.map(x => indent(indentLength + 2, x)).join('\n')}\n`
+    : '';
+  return `<${type}${beforeProps}${props}${afterProps}${childrenIndented}${nodeClose}`;
+}
+
+export function debugInsts(insts) {
+  return insts.map(debugInst).join('\n\n\n');
+}

data/vendor/assets/javascripts/MountedTraversal.js

@@ -0,0 +1,305 @@
+import isEmpty from 'lodash/isEmpty';
+import isSubset from 'is-subset';
+import {
+  internalInstance,
+  coercePropValue,
+  nodeEqual,
+  propsOfNode,
+  isFunctionalComponent,
+  isSimpleSelector,
+  splitSelector,
+  selectorError,
+  selectorType,
+  isCompoundSelector,
+  AND,
+  SELECTOR,
+  nodeHasType,
+} from './Utils';
+import {
+  isDOMComponent,
+  isCompositeComponent,
+  isCompositeComponentWithType,
+  isElement,
+  findDOMNode,
+} from './react-compat';
+import { REACT013 } from './version';
+
+export function getNode(inst) {
+  if (!inst || inst._store || typeof inst === 'string') {
+    return inst;
+  }
+  if (inst._currentElement) {
+    return inst._currentElement;
+  }
+  if (internalInstance(inst)) {
+    return internalInstance(inst)._currentElement;
+  }
+  if (inst._reactInternalInstance) {
+    return inst._reactInternalInstance._currentElement;
+  }
+  if (inst._reactInternalComponent) {
+    return inst._reactInternalComponent._currentElement;
+  }
+  return inst;
+}
+
+export function instEqual(a, b) {
+  return nodeEqual(getNode(a), getNode(b));
+}
+
+export function instHasClassName(inst, className) {
+  if (!isDOMComponent(inst)) {
+    return false;
+  }
+  let classes = findDOMNode(inst).className || '';
+  classes = classes.replace(/\s/g, ' ');
+  return ` ${classes} `.indexOf(` ${className} `) > -1;
+}
+
+export function instHasId(inst, id) {
+  if (!isDOMComponent(inst)) return false;
+  const instId = findDOMNode(inst).id || '';
+  return instId === id;
+}
+
+function isFunctionalComponentWithType(inst, func) {
+  return isFunctionalComponent(inst) && getNode(inst).type === func;
+}
+
+export function instHasType(inst, type) {
+  switch (typeof type) {
+    case 'string':
+      return nodeHasType(getNode(inst), type);
+    case 'function':
+      return isCompositeComponentWithType(inst, type) ||
+        isFunctionalComponentWithType(inst, type);
+    default:
+      return false;
+  }
+}
+
+export function instHasProperty(inst, propKey, stringifiedPropValue) {
+  if (!isDOMComponent(inst)) return false;
+  const node = getNode(inst);
+  const nodeProps = propsOfNode(node);
+  const descriptor = Object.getOwnPropertyDescriptor(nodeProps, propKey);
+  if (descriptor && descriptor.get) {
+    return false;
+  }
+  const nodePropValue = nodeProps[propKey];
+
+  const propValue = coercePropValue(propKey, stringifiedPropValue);
+
+  // intentionally not matching node props that are undefined
+  if (nodePropValue === undefined) {
+    return false;
+  }
+
+  if (propValue) {
+    return nodePropValue === propValue;
+  }
+
+  return nodeProps.hasOwnProperty(propKey);
+}
+
+// called with private inst
+export function renderedChildrenOfInst(inst) {
+  return REACT013
+    ? inst._renderedComponent._renderedChildren
+    : inst._renderedChildren;
+}
+
+// called with a private instance
+export function childrenOfInstInternal(inst) {
+  if (!inst) {
+    return [];
+  }
+  if (!inst.getPublicInstance) {
+    const internal = internalInstance(inst);
+    return childrenOfInstInternal(internal);
+  }
+
+  const publicInst = inst.getPublicInstance();
+  const currentElement = inst._currentElement;
+  if (isDOMComponent(publicInst)) {
+    const children = [];
+    const renderedChildren = renderedChildrenOfInst(inst);
+    let key;
+    for (key in renderedChildren) {
+      if (!renderedChildren.hasOwnProperty(key)) {
+        continue;
+      }
+      if (REACT013 && !renderedChildren[key].getPublicInstance) {
+        continue;
+      }
+      if (!REACT013 && typeof renderedChildren[key]._currentElement.type === 'function') {
+        children.push(renderedChildren[key]._instance);
+        continue;
+      }
+      children.push(renderedChildren[key].getPublicInstance());
+    }
+    return children;
+  } else if (
+    !REACT013 &&
+    isElement(currentElement) &&
+    typeof currentElement.type === 'function'
+  ) {
+    return childrenOfInstInternal(inst._renderedComponent);
+  } else if (
+    REACT013 &&
+    isCompositeComponent(publicInst)
+  ) {
+    return childrenOfInstInternal(inst._renderedComponent);
+  }
+  return [];
+}
+
+export function internalInstanceOrComponent(node) {
+  if (REACT013) {
+    return node;
+  } else if (node._reactInternalComponent) {
+    return node._reactInternalComponent;
+  } else if (node._reactInternalInstance) {
+    return node._reactInternalInstance;
+  }
+  return node;
+}
+
+export function childrenOfInst(node) {
+  return childrenOfInstInternal(internalInstanceOrComponent(node));
+}
+
+export function pathToNode(node, root) {
+  const queue = [root];
+  const path = [];
+
+  while (queue.length) {
+    const current = queue.pop();
+    const children = childrenOfInst(current);
+
+    if (current === node) return path;
+
+    path.push(current);
+
+    if (children.length === 0) {
+      // leaf node. if it isn't the node we are looking for, we pop.
+      path.pop();
+    }
+    queue.push.apply(queue, children);
+  }
+
+  return null;
+}
+
+export function parentsOfInst(inst, root) {
+  return pathToNode(inst, root).reverse();
+}
+
+export function instMatchesObjectProps(inst, props) {
+  if (!isDOMComponent(inst)) return false;
+  const node = getNode(inst);
+  return isSubset(propsOfNode(node), props);
+}
+
+export function buildInstPredicate(selector) {
+  switch (typeof selector) {
+    case 'function':
+      // selector is a component constructor
+      return inst => instHasType(inst, selector);
+
+    case 'string':
+      if (!isSimpleSelector(selector)) {
+        throw selectorError(selector);
+      }
+      if (isCompoundSelector.test(selector)) {
+        return AND(splitSelector(selector).map(buildInstPredicate));
+      }
+
+      switch (selectorType(selector)) {
+        case SELECTOR.CLASS_TYPE:
+          return inst => instHasClassName(inst, selector.substr(1));
+        case SELECTOR.ID_TYPE:
+          return inst => instHasId(inst, selector.substr(1));
+        case SELECTOR.PROP_TYPE: {
+          const propKey = selector.split(/\[([a-zA-Z\-\:]*?)(=|\])/)[1];
+          const propValue = selector.split(/=(.*?)]/)[1];
+
+          return node => instHasProperty(node, propKey, propValue);
+        }
+        default:
+          // selector is a string. match to DOM tag or constructor displayName
+          return inst => instHasType(inst, selector);
+      }
+
+    case 'object':
+      if (!Array.isArray(selector) && selector !== null && !isEmpty(selector)) {
+        return node => instMatchesObjectProps(node, selector);
+      }
+      throw new TypeError(
+        'Enzyme::Selector does not support an array, null, or empty object as a selector'
+      );
+
+    default:
+      throw new TypeError('Enzyme::Selector expects a string, object, or Component Constructor');
+  }
+}
+
+// This function should be called with an "internal instance". Nevertheless, if it is
+// called with a "public instance" instead, the function will call itself with the
+// internal instance and return the proper result.
+function findAllInRenderedTreeInternal(inst, test) {
+  if (!inst) {
+    return [];
+  }
+
+  if (!inst.getPublicInstance) {
+    const internal = internalInstance(inst);
+    return findAllInRenderedTreeInternal(internal, test);
+  }
+  const publicInst = inst.getPublicInstance() || inst._instance;
+  let ret = test(publicInst) ? [publicInst] : [];
+  const currentElement = inst._currentElement;
+  if (isDOMComponent(publicInst)) {
+    const renderedChildren = renderedChildrenOfInst(inst);
+    let key;
+    for (key in renderedChildren) {
+      if (!renderedChildren.hasOwnProperty(key)) {
+        continue;
+      }
+      if (REACT013 && !renderedChildren[key].getPublicInstance) {
+        continue;
+      }
+      ret = ret.concat(
+        findAllInRenderedTreeInternal(renderedChildren[key], test)
+      );
+    }
+  } else if (
+    !REACT013 &&
+    isElement(currentElement) &&
+    typeof currentElement.type === 'function'
+  ) {
+    ret = ret.concat(
+      findAllInRenderedTreeInternal(
+        inst._renderedComponent,
+        test
+      )
+    );
+  } else if (
+    REACT013 &&
+    isCompositeComponent(publicInst)
+  ) {
+    ret = ret.concat(
+      findAllInRenderedTreeInternal(
+        inst._renderedComponent,
+        test
+      )
+    );
+  }
+  return ret;
+}
+
+// This function could be called with a number of different things technically, so we need to
+// pass the *right* thing to our internal helper.
+export function treeFilter(node, test) {
+  return findAllInRenderedTreeInternal(internalInstanceOrComponent(node), test);
+}