Fixed key-less sort so that numbers automatically sort properly

Created copy module and implemented copy and deepcopy
Removed broken copy and deepcopy functions from builtins
Moved dict related autotest from div_issues to dictionaries
Added additional autotests for sort and sorted
Added module_copy autotest module
Created autotests for copy and deepcopy

Author: JennaSys

transcrypt/development/automated_tests/transcrypt/autotest.py

@@ -38,6 +38,7 @@
 if __pragma__ ('defined', 'undefined'):
     import module_collections
 
+import module_copy
 import module_datetime
 import module_itertools
 import module_math
@@ -96,6 +97,7 @@
 if __pragma__ ('defined', 'undefined'):
     autoTester.run (module_collections, 'module_collections')
 
+autoTester.run (module_copy, 'module_copy')
 autoTester.run (module_datetime, 'module_datetime')
 autoTester.run (module_itertools, 'module_itertools')
 autoTester.run (module_math, 'module_math')

transcrypt/development/automated_tests/transcrypt/dictionaries/__init__.py

@@ -89,7 +89,6 @@ def run (autoTester):
     autoTester.check (tel.pop ('foo', None))
 
     # Check compound keys (issue 281)
-    
     d = {}
     d ['a'] = 3777
     d [(1, 2)] = 4777
@@ -101,7 +100,16 @@ def run (autoTester):
     d [(1, 2)] = 4777
     autoTester.check (d ['a'], d [(1, 2)])
     __pragma__ ('noopov')
-    
+
+    # Check dict.popitem (issue 306)
+    dict_306 = {'Abraham': 'Lincoln', 'Barack': 'O\'Bama', 'Thomas': 'Jefferson'}
+    results = []
+    try:
+        while True:
+            results.append (list(dict_306.popitem ()))
+    except Exception as exception:
+        autoTester.check (sorted (results))
+
     # Check exceptions
     knights = {'robin': 'the brave', 'gallahad': 'the pure'}
     autoTester.check (

transcrypt/development/automated_tests/transcrypt/div_issues/__init__.py

@@ -264,16 +264,6 @@ def filter_word (word0, word1):
     autoTester.check (filter_word ('_in_', 'kind'))
     autoTester.check (filter_word ('min_', 'kind'))
 
-    autoTester.check ('Issue 306')
-    dict_306 = {'Abraham': 'Lincoln', 'Barack': 'O\'Bama', 'Thomas': 'Jefferson'}
-    results = []
-    try:
-        while True:
-            results.append (dict_306.popitem ())
-    except Exception as exception:
-        autoTester.check (sorted (results))
-        autoTester.check ('That\'s it')
-
     autoTester.check ('Issue 314')
     try:
         autoTester.check (int (float (123)))

transcrypt/development/automated_tests/transcrypt/general_functions/__init__.py

@@ -35,12 +35,36 @@ def run (autoTester):
         autoTester.check (len (collection))
 
     autoTester.check ('sort and sorted<br>')
-    a = [1, 5, 3, 2, -1]
+    a = [11, 7, 23, 4, -1]
     b = ['sun', 'earth', 'moon']
-    
+    c = [{'name': 'Defg', 'qty': 99}, {'name': 'Abcd', 'qty': 42}, {'name': 'Hijk', 'qty': 11}]
+    d = [[21, 19, 54], [22, 7, 12, 37]]
+
+    autoTester.check (a)
     autoTester.check (sorted (a))
+    autoTester.check (a)
+    autoTester.check (sorted (a, key=str))
+    autoTester.check (sorted (a, key=int))
     autoTester.check (sorted (b))
-    
+
+    autoTester.check (sorted(c, key=lambda k: k['qty']))
+    autoTester.check (sorted(c, key=lambda k: k['name']))
+    autoTester.check (sorted(c, key=lambda k: k['name'], reverse=True))
+
+    autoTester.check (sorted(d))
+    autoTester.check (sorted(d, key=sum))
+
+    # Make sure sorted is doing a proper shallow copy (issue 866)
+    e = sorted(d)
+    autoTester.check(e)
+    d[1][1] = 9
+    autoTester.check(d)
+    autoTester.check(e)
+    d[1] = [22,14,36]
+    autoTester.check(d)
+    autoTester.check(e)
+
+
     a.sort ()
     autoTester.check (a)
 
@@ -53,6 +77,9 @@ def run (autoTester):
     a.sort (reverse = True)
     autoTester.check (a)
 
+    a.sort (key=int)
+    autoTester.check (a)
+
     b.sort (reverse = True)
     autoTester.check (b)
 

transcrypt/development/automated_tests/transcrypt/module_copy/__init__.py

@@ -0,0 +1,23 @@
+import copy
+
+def run (autoTester):
+    a = {'a': 1, 'b': 2, 'c': 3}
+    b = copy.copy(a)
+    c = [[1,2,3],[4,5,6]]
+    d = copy.copy(c)
+    e = copy.deepcopy(c)
+
+    autoTester.check ('copy')
+    autoTester.check (b)
+    autoTester.check (a)
+    a['b'] = 9
+    autoTester.check (a)
+    autoTester.check (b)
+
+    autoTester.check ('deepcopy')
+    autoTester.check (d)
+    autoTester.check (e)
+    c[1][1] = 9
+    autoTester.check (c)
+    autoTester.check (d)
+    autoTester.check (e)

transcrypt/development/automated_tests/transcrypt/transducers/__init__.py

@@ -1,7 +1,11 @@
 
 def run (autoTester):
-    autoTester.check (list (filter (lambda x: x % 2 == 0, range (10))))
+    autoTester.check ('filter',
+                      list (filter (lambda x: x % 2 == 0, range (10))),
+                      )
 
-    autoTester.check (list (map (lambda x: x* x, range(0, 31, 3))))
-    autoTester.check (list (map (lambda x, y: x * y, range(0, 31, 3), [1, 2, 3])))
-    autoTester.check (list (map (lambda x, y, z: x * y + z, range(0, 31, 3), [1, 2, 3, 4], (2, 4, 6))))
+    autoTester.check ('map',
+                      list (map (lambda x: x* x, range(0, 31, 3))),
+                      list (map (lambda x, y: x * y, range(0, 31, 3), [1, 2, 3])),
+                      list (map (lambda x, y, z: x * y + z, range(0, 31, 3), [1, 2, 3, 4], (2, 4, 6))),
+                      )

transcrypt/modules/copy/__init__.js

@@ -0,0 +1,41 @@
+export function __copy(isDeep, obj) {
+    var result;
+
+    // Handle primitives
+    if (obj === null || typeof obj !== "object") return obj;
+
+    // Handle Date
+    if (obj instanceof Date) {
+        result = new Date();
+        result.setTime(obj.getTime());
+        return result;
+    }
+
+    // Handle Array
+    if (obj instanceof Array) {
+        result = [];
+        for (var i = 0, len = obj.length; i < len; i++) {
+            result[i] = isDeep ? __copy(isDeep, obj[i]) : obj[i];
+        }
+        return result;
+    }
+
+    // Handle Object
+    if (obj instanceof Object) {
+        result = {};
+        for (var attr in obj) {
+            if (obj.hasOwnProperty(attr)) result[attr] = isDeep ? __copy(isDeep, obj[attr]) : obj[attr];
+        }
+        return result;
+    }
+
+    throw new Error("Copy not implemented for type ".concat(Object.prototype.toString.call(obj)));
+}
+
+export function copy(obj) {
+    return __copy(false, obj);
+}
+
+export function deepcopy(obj) {
+    return __copy(true, obj);
+}

transcrypt/modules/org/transcrypt/__builtin__.js

@@ -686,9 +686,9 @@ function min_max (f_compare, ...args) {
     if (args.length > 1 && dflt !== undefined) throw TypeError("Cannot specify a default with multiple positional arguments", new Error ());
     if (args.length === 1){
         if (Object.prototype.toString.call(args[0]) !== '[object Array]') throw TypeError("object is not iterable", new Error());
-        args = args[0];
+        args = args[0];  // Passed in arg is itself an iterable
     }
-    if (args === null || args.length === 0){
+    if (args.length === 0){
         if (dflt === undefined) throw ValueError ("arg is an empty sequence", new Error ());
         return dflt
     }
@@ -699,13 +699,11 @@ function min_max (f_compare, ...args) {
 // Maximum of n values
 export function max (...args) {
     return min_max(function (a, b){return a > b}, ...args)
-    // return arguments.length == 1 ? Math.max (...nrOrSeq) : Math.max (...arguments);
 }
 
 // Minimum of n numbers
 export function min (...args) {
     return min_max(function (a, b){return a < b}, ...args)
-    // return arguments.length == 1 ? Math.min (...nrOrSeq) : Math.min (...arguments);
 }
 
 // Integer to binary
@@ -978,35 +976,35 @@ export function enumerate(iterable, start = 0) {
 
 // Shallow and deepcopy
 
-export function copy (anObject) {
-    if (anObject == null || typeof anObject == "object") {
-        return anObject;
-    }
-    else {
-        var result = {};
-        for (var attrib in obj) {
-            if (anObject.hasOwnProperty (attrib)) {
-                result [attrib] = anObject [attrib];
-            }
-        }
-        return result;
-    }
-}
-
-export function deepcopy (anObject) {
-    if (anObject == null || typeof anObject == "object") {
-        return anObject;
-    }
-    else {
-        var result = {};
-        for (var attrib in obj) {
-            if (anObject.hasOwnProperty (attrib)) {
-                result [attrib] = deepcopy (anObject [attrib]);
-            }
-        }
-        return result;
-    }
-}
+// export function copy (anObject) {
+//     if (anObject == null || typeof anObject == "object") {
+//         return anObject;
+//     }
+//     else {
+//         var result = {};
+//         for (var attrib in obj) {
+//             if (anObject.hasOwnProperty (attrib)) {
+//                 result [attrib] = anObject [attrib];
+//             }
+//         }
+//         return result;
+//     }
+// }
+//
+// export function deepcopy (anObject) {
+//     if (anObject == null || typeof anObject == "object") {
+//         return anObject;
+//     }
+//     else {
+//         var result = {};
+//         for (var attrib in obj) {
+//             if (anObject.hasOwnProperty (attrib)) {
+//                 result [attrib] = deepcopy (anObject [attrib]);
+//             }
+//         }
+//         return result;
+//     }
+// }
 
 // List extensions to Array
 

transcrypt/modules/org/transcrypt/__runtime__.py

@@ -5,8 +5,9 @@
 #__pragma__ ('js', '{}', __include__ ('org/transcrypt/__builtin__.js'))
 
 #__pragma__ ('skip')
-copy = Math = __typeof__ = __repr__ = document = console = window = 0
+Math = __typeof__ = __repr__ = document = console = window = 0
 #__pragma__ ('noskip')
+from copy import copy as _copy
 
 #__pragma__ ('notconv')  # !!! tconv gives a problem with __terminal__, needs investigation
 #__pragma__ ('nokwargs')
@@ -102,30 +103,30 @@ class RuntimeWarning (Warning):
 
 #__pragma__ ('kwargs')
 
-def __sort__ (iterable, key = None, reverse = False):               # Used by py_sort, can deal with kwargs
+def __sort__(iterable, key = None, reverse = False):               # Used by py_sort, can deal with kwargs
     if key:
         iterable.sort (lambda a, b: 1 if key (a) > key (b) else -1) # JavaScript sort, case '==' is irrelevant for sorting
     else:
-        iterable.sort ()                                            # JavaScript sort
+        iterable.sort (lambda a, b: 1 if a > b else -1)                                            # JavaScript sort
 
     if reverse:
         iterable.reverse ()
 
-def sorted (iterable, key = None, reverse = False):
+def sorted(iterable, key = None, reverse = False):
     if type (iterable) == dict:
-        result = copy (iterable.keys ()) 
+        result = _copy (iterable.keys ())
     else:       
-        result = copy (iterable)
+        result = _copy (iterable)
 
     __sort__ (result, key, reverse)
     return result
 
 #__pragma__ ('nokwargs')
 
-def map (func, *iterables):
+def map(func, *iterables):
     return [func(*items) for items in zip(*iterables)]
 
-def filter (func, iterable):
+def filter(func, iterable):
     if func == None:
         func = bool
     return [item for item in iterable if func (item)]