Add latest methods and their tests

ADD: `where`, `findWhere`, `pairs`, `invert`, `partial`, `indexBy`
and `random`
ADD: tests for these new methods
FIX: return object instead of list if there is only one item `groupBy`
FIX: timing on async tests

Author: serkanyersen

src/underscore.py

@@ -4,6 +4,7 @@
 from itertools import ifilterfalse
 import re
 import functools
+import random
 from sets import Set
 from threading import Timer
 
@@ -314,6 +315,34 @@ def pluck(self, key):
         """
         return self._wrap([x.get(key) for x in self.obj])
 
+    def where(self, attrs=None, first=False):
+        """
+        Convenience version of a common use case of `filter`: selecting only objects
+        containing specific `key:value` pairs.
+        """
+        if attrs is None:
+            return None if first is True else []
+
+        method = _.find if first else _.filter
+
+        def by(val, *args):
+            for key, value in attrs.items():
+                try:
+                    if attrs[key] != val[key]:
+                        return False
+                except KeyError:
+                    return False
+                return True
+
+        return self._wrap(method(self.obj, by))
+
+    def findWhere(self, attrs=None):
+        """
+        Convenience version of a common use case of `find`: getting the first object
+        containing specific `key:value` pairs.
+        """
+        return self._wrap(self._clean.where(attrs, True))
+
     def max(self):
         """ Return the maximum element or (element-based computation).
         """
@@ -335,7 +364,7 @@ def shuffle(self):
             return self._wrap(list())
 
         cloned = self.obj[:]
-        import random
+
         random.shuffle(cloned)
         return self._wrap(cloned)
 
@@ -369,6 +398,8 @@ def e(value, index, *args):
 
         _.each(obj, e)
 
+        if len(ns.result) == 1:
+            return ns.result[0]
         return ns.result
 
     def groupBy(self, val):
@@ -386,6 +417,21 @@ def by(result, key, value):
 
         return self._wrap(res)
 
+    def indexBy(self, val=None):
+        """
+        Indexes the object's values by a criterion, similar to `groupBy`, but for
+        when you know that your index values will be unique.
+        """
+        if val is None:
+            val = lambda *args: args[0]
+
+        def by(result, key, value):
+            result[key] = value
+
+        res = self._group(self.obj, val, by)
+
+        return self._wrap(res)
+
     def countBy(self, val):
         """
         Counts instances of an object that group by a certain criterion. Pass
@@ -676,6 +722,17 @@ def bind(self, context):
         return self._wrap(self.obj)
     curry = bind
 
+    def partial(self, *args):
+        """
+        Partially apply a function by creating a version that has had some of its
+        arguments pre-filled, without changing its dynamic `this` context.
+        """
+        def part(*args2):
+            args3 = args + args2
+            return self.obj(*args3)
+
+        return self._wrap(part)
+
     def bindAll(self, *args):
         """
         Bind all of an object's methods to that object.
@@ -863,6 +920,26 @@ def values(self):
         """
         return self._wrap(self.obj.values())
 
+    def pairs(self):
+        """ Convert an object into a list of `[key, value]` pairs.
+        """
+        keys = self._clean.keys()
+        pairs = []
+        for key in keys:
+            pairs.append([key, self.obj[key]])
+
+        return self._wrap(pairs)
+
+    def invert(self):
+        """ Invert the keys and values of an object. The values must be serializable.
+        """
+        keys = self._clean.keys()
+        inverted = {}
+        for key in keys:
+            inverted[self.obj[key]] = key
+
+        return self._wrap(inverted)
+
     def functions(self):
         """ Return a sorted list of the function names available on the object.
         """
@@ -1176,6 +1253,15 @@ def times(self, func, *args):
 
         return self._wrap(func)
 
+    def random(self, max_number=None):
+        """ Return a random integer between min and max (inclusive).
+        """
+        min_number = self.obj
+        if max_number is None:
+            min_number = 0
+            max_number = self.obj
+        return random.randrange(min_number, max_number)
+
     def result(self, property, *args):
         """
         If the value of the named property is a function then invoke it;

tests/test_collections.py

@@ -182,6 +182,51 @@ def test_size(self):
         self.assertEqual(_.size({"one": 1, "two": 2, "three": 3}), 3, 'can compute the size of an object')
         self.assertEqual(_.size([1, 2, 3]), 3, 'can compute the size of an array')
 
+    def test_where(self):
+        List = [{"a": 1, "b": 2}, {"a": 2, "b": 2}, {"a": 1, "b": 3}, {"a": 1, "b": 4}]
+        result = _.where(List, {"a": 1})
+        self.assertEqual(_.size(result), 3)
+        self.assertEqual(result[-1]['b'], 4)
+
+        result = _.where(List, {"a": 1}, True)
+        self.assertEqual(result["b"], 2)
+
+        result = _.where(List, {"a": 1}, False)
+        self.assertEqual(_.size(result), 3)
+
+    def test_findWhere(self):
+        List = [{"a": 1, "b": 2}, {"a": 2, "b": 2}, {"a": 1, "b": 3}, {"a": 1, "b": 4}]
+        result = _.findWhere(List, {"a": 1})
+        self.assertEqual(result["a"], 1)
+        self.assertEqual(result["b"], 2)
+
+        result = _.findWhere(List, {"b": 4})
+        self.assertEqual(result["a"], 1)
+        self.assertEqual(result["b"], 4)
+
+        result = _.findWhere(List, {"c": 1})
+        self.assertEqual(result, None)
+
+        result = _.findWhere([], {"c": 1})
+        self.assertEqual(result, None)
+
+    def test_indexBy(self):
+        parity = _.indexBy([1, 2, 3, 4, 5], lambda num, *args: num % 2 == 0)
+        self.assertEqual(parity[True], 4)
+        self.assertEqual(parity[False], 5)
+
+        llist = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"]
+        grouped = _.indexBy(llist, lambda x, *args: len(x))
+        self.assertEqual(grouped[3], 'ten')
+        self.assertEqual(grouped[4], 'nine')
+        self.assertEqual(grouped[5], 'eight')
+
+        array = [1, 2, 1, 2, 3]
+        grouped = _.indexBy(array);
+        self.assertEqual(grouped[1], 1)
+        self.assertEqual(grouped[2], 2)
+        self.assertEqual(grouped[3], 3)
+
 if __name__ == "__main__":
-    print "run these tests by executing `python -m unittest discover` in unittests folder"
+    print ("run these tests by executing `python -m unittest discover` in unittests folder")
     unittest.main()

tests/test_functions.py

@@ -41,18 +41,18 @@ def test_delay(self):
         def func():
             ns.delayed = True
 
-        _.delay(func, 50)
+        _.delay(func, 150)
 
         def checkFalse():
             self.assertFalse(ns.delayed)
-            print "ASYNC: delay. OK"
+            print ("\nASYNC: delay. OK")
 
         def checkTrue():
             self.assertTrue(ns.delayed)
-            print "ASYNC: delay. OK"
+            print ("\nASYNC: delay. OK")
 
-        Timer(0.03, checkFalse).start()
-        Timer(0.07, checkTrue).start()
+        Timer(0.05, checkFalse).start()
+        Timer(0.20, checkTrue).start()
 
     def test_defer(self):
         ns = self.Namespace()
@@ -65,7 +65,7 @@ def defertTest(bool):
 
         def deferCheck():
             self.assertTrue(ns.deferred, "deferred the function")
-            print "ASYNC: defer. OK"
+            print ("\nASYNC: defer. OK")
 
         _.delay(deferCheck, 50)
 
@@ -85,15 +85,15 @@ def incr():
         Timer(0.14, throttledIncr).start()
         Timer(0.19, throttledIncr).start()
         Timer(0.22, throttledIncr).start()
-        Timer(0.24, throttledIncr).start()
+        Timer(0.34, throttledIncr).start()
 
         def checkCounter1():
             self.assertEqual(ns.counter, 1, "incr was called immediately")
-            print "ASYNC: throttle. OK"
+            print ("ASYNC: throttle. OK")
 
         def checkCounter2():
             self.assertEqual(ns.counter, 4, "incr was throttled")
-            print "ASYNC: throttle. OK"
+            print ("ASYNC: throttle. OK")
 
         _.delay(checkCounter1, 90)
         _.delay(checkCounter2, 400)
@@ -105,7 +105,7 @@ def test_debounce(self):
         def incr():
             ns.counter += 1
 
-        debouncedIncr = _.debounce(incr, 50)
+        debouncedIncr = _.debounce(incr, 120)
         debouncedIncr()
         debouncedIncr()
         debouncedIncr()
@@ -117,9 +117,9 @@ def incr():
 
         def checkCounter():
             self.assertEqual(1, ns.counter, "incr was debounced")
-            print "ASYNC: debounce. OK"
+            print ("ASYNC: debounce. OK")
 
-        _.delay(checkCounter, 220)
+        _.delay(checkCounter, 300)
 
     def test_once(self):
         ns = self.Namespace()
@@ -187,6 +187,12 @@ def afterFunc():
         self.assertEqual(testAfter(5, 4), 0, "after(N) should not fire unless called N times")
         self.assertEqual(testAfter(0, 0), 1, "after(0) should fire immediately")
 
+    def test_partial(self):
+        def func(*args):
+            return ' '.join(args)
+        pfunc = _.partial(func, 'a', 'b', 'c')
+        self.assertEqual(pfunc('d', 'e'), 'a b c d e')
+
 if __name__ == "__main__":
-    print "run these tests by executing `python -m unittest discover` in unittests folder"
+    print ("run these tests by executing `python -m unittest discover` in unittests folder")
     unittest.main()

tests/test_objects.py

@@ -122,6 +122,17 @@ def interceptor(obj):
         returned = _([1, 2, 3]).chain().map(lambda n, *args: n * 2).max().tap(interceptor).value()
         self.assertTrue(returned == 6 and ns.intercepted == 6, 'can use tapped objects in a chain')
 
+    def test_pairs(self):
+        r = _.pairs({"one": 1, "two": 2})
+        # Python alphabetically orders the keys automatically
+        self.assertEqual(r, [["two", 2], ["one", 1]], 'can convert an object into pairs')
+
+    def test_invert(self):
+        obj = {"first": 'Moe', "second": 'Larry', "third": 'Curly'}
+        r = _(obj).chain().invert().keys().join(' ').value()
+        self.assertEqual(r, 'Larry Moe Curly', 'can invert an object')
+        self.assertEqual(_.invert(_.invert(obj)), obj, "two inverts gets you back where you started")
+
 if __name__ == "__main__":
-    print "run these tests by executing `python -m unittest discover` in unittests folder"
+    print ("run these tests by executing `python -m unittest discover` in unittests folder")
     unittest.main()

tests/test_structure.py

@@ -21,5 +21,5 @@ def test_chaining(self):
         self.assertEqual(6, u.value(), "value should have returned")
 
 if __name__ == "__main__":
-    print "run these tests by executing `python -m unittest discover` in unittests folder"
+    print ("run these tests by executing `python -m unittest discover` in unittests folder")
     unittest.main()

tests/test_utility.py

@@ -2,6 +2,7 @@
 from unittesthelper import init
 init()  # will let you import modules from upper folder
 from src.underscore import _
+import math
 
 
 class TestUtility(unittest.TestCase):
@@ -16,6 +17,21 @@ def test_identity(self):
         moe = {"name": 'moe'}
         self.assertEqual(moe, _.identity(moe), "moe is the same as his identity")
 
+    def test_random(self):
+        array = _.range(1000)
+        mi = math.pow(2, 31)
+        ma = math.pow(2, 62)
+        def check(*args):
+            return _.random(mi, ma) >= mi
+        result = _.every(array, check)
+        self.assertTrue(result, "should produce a random number greater than or equal to the minimum number")
+
+        def check2(*args):
+            r = _.random(ma)
+            return r >= 0 and r <= ma
+        result = _.every(array, check2)
+        self.assertTrue(result, "should produce a random number when passed max_number")
+
     def test_uniqueId(self):
         ns = self.Namespace()
         ns.ids = []
@@ -204,5 +220,5 @@ def test2():
         templateEscaped({"f": test2})
 
 if __name__ == "__main__":
-    print "run these tests by executing `python -m unittest discover` in unittests folder"
+    print ("run these tests by executing `python -m unittest discover` in unittests folder")
     unittest.main()