move tests to use lodash-es

Author: mansona

lib/add-inherited-items.js

@@ -1,9 +1,9 @@
-import _ from 'lodash';
+import { clone, find, values } from 'lodash-es';
 
 export default function addInheritedItems(docSets) {
   docSets.forEach(versionData => {
     let data = versionData.data;
-    let classes = _.values(data.classes).filter(klass => klass && klass.name);
+    let classes = values(data.classes).filter(klass => klass && klass.name);
     classes = classes.filter(removeLongDocsBecauseEmber1HasWeirdDocs);
     let classItems = data.classitems.filter(({ itemtype }) => itemtype);
 
@@ -17,7 +17,7 @@ export default function addInheritedItems(docSets) {
         if (!parent) return;
         let parentItems = classItems.filter(item => item.class === parent.name);
         parentItems = parentItems.map(item => {
-          item = _.clone(item);
+          item = clone(item);
           item.inherited = true;
           item.inheritedFrom = item.class;
           item.class = klass.name;
@@ -40,7 +40,7 @@ function getParents(klass, classes) {
     parents = parents.concat(klass.uses.reverse());
   }
   return parents
-    .map(parent => _.find(classes, ({ name }) => name === parent))
+    .map(parent => find(classes, ({ name }) => name === parent))
     .filter(parent => parent);
 }
 

lib/add-since-tags.js

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import { chain, values } from 'lodash-es';
 
 export default function addSinceTags(docSets) {
   let versionIndex = Object.create(null);
@@ -14,7 +14,7 @@ export default function addSinceTags(docSets) {
       createMethodEntry(versionIndex, classItemName, classItem.itemtype, version);
     });
 
-    let classes = _.values(data.classes);
+    let classes = values(data.classes);
 
     classes.forEach(klass => {
       klass.version = version;
@@ -33,11 +33,11 @@ export default function addSinceTags(docSets) {
     classItem.since = version;
   });
 
-  let classes = _.chain(docSets)
+  let classes = chain(docSets)
     .map('data')
     .map('classes')
     .flatten()
-    .map(klassSet => _.values(klassSet))
+    .map(klassSet => values(klassSet))
     .flatten()
     .value();
 

lib/filter-jsonapi-doc.js

@@ -1,22 +1,22 @@
-import _ from 'lodash';
+import { filter } from 'lodash-es';
 
 function byType(document, type) {
-  return _.filter(totalData(document), ['type', type]);
+  return filter(totalData(document), ['type', type]);
 }
 
 function totalData({ data, included }) {
   return data.concat(included || []);
 }
 
 function hasBelongsTo(document, relationshipName, relationshipValue) {
-  return _.filter(totalData(document), [
+  return filter(totalData(document), [
     `relationships.${relationshipName}.data.id`,
     relationshipValue,
   ]);
 }
 
 function classWithIncluded(document, klass) {
-  let classDocument = _.filter(byType(document, 'class'), ['id', klass])[0];
+  let classDocument = filter(byType(document, 'class'), ['id', klass])[0];
 
   let related = hasBelongsTo(document, 'class', klass);
 

lib/modules-transform.js

@@ -1,23 +1,23 @@
-import _ from 'lodash';
+import { curry, curryRight, filter, flow, has, partition, reduce, sortBy, values } from 'lodash-es';
 
 function addSubModulesParentAttribute(moduleObj) {
   moduleObj.parent = moduleObj.is_submodule ? moduleObj.module : null;
 }
 
 function filterStaticAndDerived(classes, className) {
   let included =
-    (_.has(classes, className) &&
-      !_.has(classes[className], 'static') &&
-      _.has(classes[className], 'file')) ||
-    !_.has(classes, className);
+    (has(classes, className) &&
+      !has(classes[className], 'static') &&
+      has(classes[className], 'file')) ||
+    !has(classes, className);
   return included;
 }
 
 function addPrivatePublicClassesAttributes(module, classes) {
   let classNames = Object.keys(module.classes);
-  let applicableClassNames = _.filter(classNames, _.curry(filterStaticAndDerived)(classes));
+  let applicableClassNames = filter(classNames, curry(filterStaticAndDerived)(classes));
 
-  let [privateclasses, publicclasses] = _.partition(applicableClassNames, className => {
+  let [privateclasses, publicclasses] = partition(applicableClassNames, className => {
     return classes[className].access === 'private' || classes[className].deprecated === true;
   });
   module.publicclasses = publicclasses;
@@ -39,23 +39,23 @@ function separateByClassName(result, value) {
 }
 
 function sortByName(items) {
-  return _.sortBy(items, 'name');
+  return sortBy(items, 'name');
 }
 
 function separateFunctions(moduleName, classitems, accessFilter) {
   let matchesModule = ({ module }) => module === moduleName;
-  return _.flow([
-    _.curryRight(_.filter)(matchesModule),
-    _.curryRight(_.filter)(accessFilter),
+  return flow([
+    curryRight(filter)(matchesModule),
+    curryRight(filter)(accessFilter),
     sortByName,
-    _.curryRight(_.reduce)(separateByClassName, {}),
+    curryRight(reduce)(separateByClassName, {}),
   ])(classitems);
 }
 
 function cleanUpSubmodules({ submodules }) {
-  return _.flow([
-    _.curryRight(_.filter)(item => item !== 'undefined'),
-    _.curryRight(_.reduce)((result, value) => {
+  return flow([
+    curryRight(filter)(item => item !== 'undefined'),
+    curryRight(reduce)((result, value) => {
       result[value] = 1;
       return result;
     }, {}),
@@ -65,7 +65,7 @@ function cleanUpSubmodules({ submodules }) {
 export default function transformModules(docSets) {
   try {
     docSets.forEach(({ data }) => {
-      let modules = _.values(data.modules);
+      let modules = values(data.modules);
       let classes = data.classes;
       let classitems = data.classitems;
       modules.forEach(mod => {

lib/normalize-ember-dependencies.js

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import _ from 'lodash-es';
 import { byType } from './filter-jsonapi-doc.js';
 
 const missingDoc = ({ id, version }) => {

lib/normalize-ids.js

@@ -1,8 +1,8 @@
-import _ from 'lodash';
 import saveDoc from './save-document.js';
 import tojsonapi from 'yuidoc-to-jsonapi/lib/converter.js';
 import updateIDs from './update-with-versions-and-project.js';
 import { byType as findType } from './filter-jsonapi-doc.js';
+import { curry, flatten, has } from 'lodash-es';
 
 function removeLongDocsBecauseEmber1HasWeirdDocs({ id }) {
   let str = 'A Suite can';
@@ -49,7 +49,7 @@ async function normalizeIDs(pVersions, projectName) {
   });
 
   let jsonapidoc = {
-    data: _.flatten(jsonapidocs.map(({ data }) => data)),
+    data: flatten(jsonapidocs.map(({ data }) => data)),
   };
 
   jsonapidoc.data = jsonapidoc.data.filter(removeLongDocsBecauseEmber1HasWeirdDocs);
@@ -61,14 +61,14 @@ async function normalizeIDs(pVersions, projectName) {
 
     let namespaces = classes.filter(({ attributes }) => attributes.static === 1);
     classes = classes.filter(
-      ({ attributes }) => attributes.static !== 1 && _.has(attributes, 'file'),
+      ({ attributes }) => attributes.static !== 1 && has(attributes, 'file'),
     );
 
     namespaces.forEach(ns => (ns.type = 'namespace'));
 
     let modules = findType(jsonapidoc, 'module')
       .filter(filterForVersion(version))
-      .filter(_.curry(filter176)(projectName, version.version));
+      .filter(curry(filter176)(projectName, version.version));
 
     return {
       id: `${projectName}-${version.version}`,

lib/update-with-versions-and-project.js

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import { cloneDeep } from 'lodash-es';
 
 function generateID(type, projectName, version, id) {
   if (!projectName) {
@@ -10,7 +10,7 @@ function generateID(type, projectName, version, id) {
 }
 
 function updateDocument(doc, projectName, version) {
-  let dup = _.cloneDeep(doc);
+  let dup = cloneDeep(doc);
 
   dup.id = generateID(doc.type, projectName, version, dup.id);
 
@@ -46,7 +46,7 @@ function updateDocument(doc, projectName, version) {
 }
 
 export default function updateWithIDs(document, projectName, version) {
-  let dup = _.cloneDeep(document);
+  let dup = cloneDeep(document);
 
   if (Array.isArray(dup.data)) {
     dup.data = dup.data.map(data => {

test/add-since-tag-test.js

@@ -1,10 +1,10 @@
+import { range } from 'lodash-es';
 import addSinceTags from '../lib/add-since-tags.js';
 import { assert } from 'chai';
-import _ from 'lodash';
 
 describe('addSinceTags', () => {
   beforeEach(function () {
-    this.yuiDocSets = _.range(3).map(i => {
+    this.yuiDocSets = range(3).map(i => {
       return {
         version: `v1.0.${i}`,
         data: {

test/filter-jsonapi-doc-test.js

@@ -1,6 +1,6 @@
 import { assert } from 'chai';
-import _ from 'lodash';
 import { classWithIncluded } from '../lib/filter-jsonapi-doc.js';
+import { filter } from 'lodash-es';
 
 describe('filter json api docs', () => {
   describe('#classWithIncluded', () => {
@@ -61,7 +61,7 @@ describe('filter json api docs', () => {
     });
 
     it('does not return unassociated models', function () {
-      let unassociated = _.filter(this.response.included, ['type', 'yoloswag']);
+      let unassociated = filter(this.response.included, ['type', 'yoloswag']);
       assert.equal(unassociated.length, 0);
     });
   });

test/markup-test.js

@@ -1,7 +1,6 @@
 import markup from '../lib/markup.js';
 import { assert } from 'chai';
 import fs from 'fs';
-import { join } from 'path';
 
 function desc(path) {
   return {

test/modules-transform-test.js

@@ -1,10 +1,10 @@
 import transformModules from '../lib/modules-transform.js';
 import { assert } from 'chai';
-import _ from 'lodash';
+import { range, filter } from 'lodash-es';
 
 describe('transformModules', () => {
   beforeEach(function () {
-    this.yuiDocSets = _.range(3).map(i => {
+    this.yuiDocSets = range(3).map(i => {
       return {
         version: `v1.0.${i}`,
         data: {
@@ -74,7 +74,7 @@ describe('transformModules', () => {
 
   it('adds a parent attribute to sub modules', function () {
     this.yuiDocSets.forEach(({ data }) => {
-      let subModules = _.filter(data.modules, ({ is_submodule }) => is_submodule);
+      let subModules = filter(data.modules, ({ is_submodule }) => is_submodule);
       subModules.forEach(({ parent }) => {
         assert.equal(parent, 'foo');
       });