Make array macros work with native JS arrays (#384)

* don't assume Ember.Arrays in array macros

addon/array/any.js

@@ -1,5 +1,6 @@
+import { A as emberA } from '@ember/array';
 import { normalizeArray } from './-utils';
 
 export default normalizeArray({ defaultValue: () => false }, (array, callback) => {
-  return array.any(callback);
+  return emberA(array).any(callback);
 });

addon/array/compact.js

@@ -1,5 +1,6 @@
+import { A as emberA } from '@ember/array';
 import { normalizeArray } from './-utils';
 
 export default normalizeArray({}, array => {
-  return array.compact();
+  return emberA(array).compact();
 });

addon/array/filter-by.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -13,7 +14,7 @@ export default createClassComputed(
       if (!array || !key) {
         return [];
       }
-      return array.filterBy(key, ...args);
+      return emberA(array).filterBy(key, ...args);
     });
   }
 );

addon/array/find-by.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -9,7 +10,7 @@ export default createClassComputed(
       if (!array || !key) {
         return undefined;
       }
-      return array.findBy(key, value);
+      return emberA(array).findBy(key, value);
     });
   }
 );

addon/array/is-any.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -11,7 +12,7 @@ export default createClassComputed(
     }
     return computed(...args, (array, ...args) => {
       if (array) {
-        return array.isAny(key, ...args);
+        return emberA(array).isAny(key, ...args);
       }
     });
   }

addon/array/is-every.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -11,7 +12,7 @@ export default createClassComputed(
     }
     return computed(...args, (array, ...args) => {
       if (array) {
-        return array.isEvery(key, ...args);
+        return emberA(array).isEvery(key, ...args);
       }
     });
   }

addon/array/map-by.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -9,7 +10,7 @@ export default createClassComputed(
       if (!array || !key) {
         return array;
       }
-      return array.mapBy(key);
+      return emberA(array).mapBy(key);
     });
   }
 );

addon/array/object-at.js

@@ -1,5 +1,6 @@
+import { A as emberA } from '@ember/array';
 import { normalizeArray } from './-utils';
 
 export default normalizeArray({}, (array, index) => {
-  return array.objectAt(index);
+  return emberA(array).objectAt(index);
 });

addon/array/reject-by.js

@@ -1,3 +1,4 @@
+import { A as emberA } from '@ember/array';
 import createClassComputed from 'ember-macro-helpers/create-class-computed';
 import computed from 'ember-macro-helpers/computed';
 import normalizeArrayKey from 'ember-macro-helpers/normalize-array-key';
@@ -16,7 +17,7 @@ export default createClassComputed(
       if (!key) {
         return array;
       }
-      return array.rejectBy(key, ...args);
+      return emberA(array).rejectBy(key, ...args);
     });
   }
 );

addon/array/uniq-by.js

@@ -12,6 +12,7 @@ export default createClassComputed(
       if (array === undefined || key === undefined) {
         return array;
       }
+
       if (!array.uniqBy) {
         // TODO: polyfill this
         // from https://github.com/emberjs/ember.js/blob/v2.11.0/packages/ember-runtime/lib/mixins/enumerable.js#L1094-L1105
@@ -28,6 +29,7 @@ export default createClassComputed(
 
         return ret;
       }
+
       return array.uniqBy(key);
     });
   }

addon/array/uniq.js

@@ -1,5 +1,6 @@
+import { A as emberA } from '@ember/array';
 import { normalizeArray } from './-utils';
 
 export default normalizeArray({}, array => {
-  return array.uniq();
+  return emberA(array).uniq();
 });

addon/array/without.js

@@ -1,5 +1,6 @@
+import { A as emberA } from '@ember/array';
 import { normalizeArray } from './-utils';
 
 export default normalizeArray({}, (array, item) => {
-  return array.without(item);
+  return emberA(array).without(item);
 });

tests/integration/array/any-test.js

@@ -87,3 +87,14 @@ test('composable: it returns true if any true', function(assert) {
     strictEqual: true
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: any('array', result => result === 3),
+    properties: {
+      array: [1, 2]
+    },
+    strictEqual: false
+  });
+});

tests/integration/array/compact-test.js

@@ -53,3 +53,14 @@ test('composable: it calls compact on array', function(assert) {
     deepEqual: [2]
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: compact('array'),
+    properties: {
+      array: [undefined, 2]
+    },
+    deepEqual: [2]
+  });
+});

tests/integration/array/concat-test.js

@@ -77,3 +77,16 @@ test('composable: it calls concat on array', function(assert) {
     deepEqual: [0, value1, value2]
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: concat('array', 'value1', 'value2'),
+    properties: {
+      array: [0],
+      value1,
+      value2
+    },
+    deepEqual: [0, value1, value2]
+  });
+});

tests/integration/array/every-test.js

@@ -87,3 +87,14 @@ test('composable: it returns true if all true', function(assert) {
     strictEqual: true
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: every('array', result => result === 1),
+    properties: {
+      array: [1, 2]
+    },
+    strictEqual: false
+  });
+});

tests/integration/array/filter-by-test.js

@@ -145,3 +145,16 @@ test('composable: it filters array if found', function(assert) {
     deepEqual: [{ test: 'val2' }]
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: filterBy('array', 'key', 'value'),
+    properties: {
+      array: [{ test: 'val1' }, { test: 'val2' }],
+      key: 'test',
+      value: 'val2'
+    },
+    deepEqual: [{ test: 'val2' }]
+  });
+});

tests/integration/array/filter-test.js

@@ -99,3 +99,14 @@ test('composable: it filters array if found', function(assert) {
     deepEqual: [2]
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: filter('array', result => result === 2),
+    properties: {
+      array: [1, 2]
+    },
+    deepEqual: [2]
+  });
+});

tests/integration/array/find-by-test.js

@@ -115,3 +115,17 @@ test('composable: it returns item if found', function(assert) {
     strictEqual: expected
   });
 });
+
+test('it handles native arrays', function(assert) {
+  let expected = { test: 'val2' };
+  compute({
+    assert,
+    computed: findBy('array', 'key', 'value'),
+    properties: {
+      array: [{ test: 'val1' }, expected],
+      key: 'test',
+      value: 'val2'
+    },
+    strictEqual: expected
+  });
+});

tests/integration/array/find-test.js

@@ -89,3 +89,14 @@ test('composable: it returns item if found', function(assert) {
     strictEqual: 2
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: find('array', result => result === 2),
+    properties: {
+      array: [1, 2]
+    },
+    strictEqual: 2
+  });
+});

tests/integration/array/first-test.js

@@ -35,3 +35,14 @@ test('handles array changes', function(assert) {
 
   assert.strictEqual(get(subject, 'computed'), 'test2');
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: first('array'),
+    properties: {
+      array: ['test1', 'test2']
+    },
+    strictEqual: 'test1'
+  });
+});

tests/integration/array/group-by-test.js

@@ -193,3 +193,30 @@ test('it groups array by key and comparator', function(assert) {
 
   assert.deepEqual(subject.get('computed'), expected);
 });
+
+test('it handles native arrays', function(assert) {
+  let item1 = { test: 1, name: 'foo' };
+  let item2 = { test: 2, name: 'bar' };
+  let item3 = { test: 3, name: 'foo' };
+
+  compute({
+    assert,
+    computed: groupBy('array', 'key'),
+    properties: {
+      array: [item1, item2, item3],
+      key: 'name'
+    },
+    deepEqual: [
+      {
+        key: 'name',
+        value: 'foo',
+        items: [item1, item3]
+      },
+      {
+        key: 'name',
+        value: 'bar',
+        items: [item2]
+      }
+    ]
+  });
+});

tests/integration/array/includes-test.js

@@ -80,3 +80,15 @@ test('it handles nesting', function(assert) {
     strictEqual: true
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: includes('array', 'source'),
+    properties: {
+      array: ['my value'],
+      source: 'my value'
+    },
+    strictEqual: true
+  });
+});

tests/integration/array/index-of-test.js

@@ -64,3 +64,16 @@ test('composable: it calls indexOf on array', function(assert) {
     strictEqual: 2
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: indexOf('array', 'value', 'fromIndex'),
+    properties: {
+      array: [1, 2, 1],
+      value: 1,
+      fromIndex: 1
+    },
+    strictEqual: 2
+  });
+});

tests/integration/array/invoke-test.js

@@ -95,3 +95,21 @@ test('it responds to array property value changes', function(assert) {
     'foo1-baz-val2'
   ]);
 });
+
+test('it handles native arrays', function(assert) {
+  array = [{
+    foo(arg = 'bar') {
+      return arg + '-eval';
+    }
+  }];
+
+  compute({
+    assert,
+    computed: invoke('array', 'methodName'),
+    properties: {
+      array,
+      methodName: 'foo'
+    },
+    deepEqual: ['bar-eval']
+  });
+});

tests/integration/array/is-any-test.js

@@ -177,3 +177,16 @@ test('composable: it calls isAny on array', function(assert) {
     strictEqual: true
   });
 });
+
+test('it handles native arrays', function(assert) {
+  compute({
+    assert,
+    computed: isAny('array', 'key', 'value'),
+    properties: {
+      array: [{ test: 'val1' }, { test: 'val2' }],
+      key: 'test',
+      value: 'val2'
+    },
+    strictEqual: true
+  });
+});