From bea3616c0459269fc34ee71069bc56b8a99c94df Mon Sep 17 00:00:00 2001 From: zyd Date: Fri, 12 Aug 2022 23:20:54 +0900 Subject: [PATCH 1/6] add method lens / view / lensPath --- ramda/__init__.py | 3 +++ ramda/lens.py | 13 +++++++++++++ ramda/lensPath.py | 11 +++++++++++ ramda/view.py | 12 ++++++++++++ test/test_lens.py | 31 ++++++++++++++++++++++++++++++ test/test_lensPath.py | 44 +++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 114 insertions(+) create mode 100644 ramda/lens.py create mode 100644 ramda/lensPath.py create mode 100644 ramda/view.py create mode 100644 test/test_lens.py create mode 100644 test/test_lensPath.py diff --git a/ramda/__init__.py b/ramda/__init__.py index ca9701b..55d2547 100644 --- a/ramda/__init__.py +++ b/ramda/__init__.py @@ -65,6 +65,8 @@ from .last import last from .lastIndexOf import lastIndexOf from .length import length +from .lens import lens +from .lensPath import lensPath from .lift import lift from .liftN import liftN from .lt import lt @@ -135,6 +137,7 @@ from .useWith import useWith from .values import values from .valuesIn import valuesIn +from .view import view from .where import where from .xprod import xprod # pylint: disable=redefined-builtin diff --git a/ramda/lens.py b/ramda/lens.py new file mode 100644 index 0000000..1b4a66d --- /dev/null +++ b/ramda/lens.py @@ -0,0 +1,13 @@ +from .map import map +from .private._curry2 import _curry2 + + +def inner_lens(getter, setter): + def wrapper1(toFunctorFn): + def wrapper2(target): + return map(lambda focus: setter(focus, target), toFunctorFn(getter(target))) + return wrapper2 + return wrapper1 + + +lens = _curry2(inner_lens) diff --git a/ramda/lensPath.py b/ramda/lensPath.py new file mode 100644 index 0000000..621143f --- /dev/null +++ b/ramda/lensPath.py @@ -0,0 +1,11 @@ +from .assocPath import assocPath +from .lens import lens +from .path import path +from .private._curry1 import _curry1 + + +def inner_lensPath(p): + return lens(path(p), assocPath(p)) + + +lensPath = _curry1(inner_lensPath) diff --git a/ramda/view.py b/ramda/view.py new file mode 100644 index 0000000..ab5cb9d --- /dev/null +++ b/ramda/view.py @@ -0,0 +1,12 @@ +from .private._curry2 import _curry2 + + +def Const(x): + return {'value': x, 'fantasy-land/map': lambda *_: Const(x)} + + +def inner_view(lens, x): + return lens(Const)(x)['value'] + + +view = _curry2(inner_view) diff --git a/test/test_lens.py b/test/test_lens.py new file mode 100644 index 0000000..02f0621 --- /dev/null +++ b/test/test_lens.py @@ -0,0 +1,31 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/lens.js +""" + +alice = { + 'name': 'Alice Jones', + 'address': ['22 Walnut St', 'San Francisco', 'CA'], + 'pets': {'dog': 'joker', 'cat': 'batman'} +} + +nameLens = R.lens(R.prop('name'), R.assoc('name')) +# addressLens = R.lensProp('address') +# headLens = R.lensIndex(0) +dogLens = R.lensPath(['pets', 'dog']) + + +class TestLens(unittest.TestCase): + def test_may_be_applie_to_a_lens_created_by_lensPath(self): + self.assertEqual('joker', R.view(dogLens, alice)) + + def test_may_be_applied_to_a_lens_created_by_lensProp(self): + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_lensPath.py b/test/test_lensPath.py new file mode 100644 index 0000000..b1dd1bb --- /dev/null +++ b/test/test_lensPath.py @@ -0,0 +1,44 @@ +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/lensPath.js +""" + +testDict = { + 'a': [{ + 'b': 1 + }, { + 'b': 2 + }], + 'd': 3 +} + + +class A: + def __init__(self, b): + self.b = b + + +class Obj: + def __init__(self, a, d): + self.a = a + self.d = d + + +testObj = Obj([A(1), A(2)], 3) + + +class TestLensPath(unittest.TestCase): + def test_focuses_the_specified_object_property(self): + self.assertEqual(3, R.view(R.lensPath(['d']), testDict)) + self.assertEqual(2, R.view(R.lensPath(['a', 1, 'b']), testDict)) + self.assertEqual(testDict, R.view(R.lensPath([]), testDict)) + + self.assertEqual(3, R.view(R.lensPath(['d']), testObj)) + self.assertEqual(2, R.view(R.lensPath(['a', 1, 'b']), testObj)) + self.assertEqual(testObj, R.view(R.lensPath([]), testObj)) + +if __name__ == '__main__': + unittest.main() From 8a012828c2a4017e2eac38937bbed6978226fb10 Mon Sep 17 00:00:00 2001 From: zyd Date: Sat, 13 Aug 2022 12:55:15 +0900 Subject: [PATCH 2/6] Add lensPath test cases and some other methods --- ramda/__init__.py | 4 ++++ ramda/inc.py | 3 +++ ramda/over.py | 12 ++++++++++ ramda/set.py | 11 +++++++++ test/test_inc.py | 22 +++++++++++++++++ test/test_lensPath.py | 55 +++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 107 insertions(+) create mode 100644 ramda/inc.py create mode 100644 ramda/over.py create mode 100644 ramda/set.py create mode 100644 test/test_inc.py diff --git a/ramda/__init__.py b/ramda/__init__.py index 55d2547..4aa8b38 100644 --- a/ramda/__init__.py +++ b/ramda/__init__.py @@ -50,6 +50,7 @@ from .head import head from .identity import identity from .ifElse import ifElse +from .inc import inc from .indexOf import indexOf from .insert import insert from .intersection import intersection @@ -86,6 +87,7 @@ from .omit import omit from .once import once from .Or import Or +from .over import over from .partition import partition from .path import path from .pathEq import pathEq @@ -111,6 +113,8 @@ from .repeat import repeat from .replace import replace from .reverse import reverse +# pylint: disable=redefined-builtin +from .set import set from .slice import slice from .sort import sort from .sortBy import sortBy diff --git a/ramda/inc.py b/ramda/inc.py new file mode 100644 index 0000000..25d14cf --- /dev/null +++ b/ramda/inc.py @@ -0,0 +1,3 @@ +from .add import add + +inc = add(1) diff --git a/ramda/over.py b/ramda/over.py new file mode 100644 index 0000000..96610c1 --- /dev/null +++ b/ramda/over.py @@ -0,0 +1,12 @@ +from .private._curry3 import _curry3 + + +def Identity(x): + return {'value': x, 'map': lambda f: Identity(f(x))} + + +def inner_over(lens, f, x): + return lens(lambda y: Identity(f(y)))(x)['value'] + + +over = _curry3(inner_over) diff --git a/ramda/set.py b/ramda/set.py new file mode 100644 index 0000000..ce726c9 --- /dev/null +++ b/ramda/set.py @@ -0,0 +1,11 @@ +from .always import always +from .over import over +from .private._curry3 import _curry3 + + +def inner_set(lens, v, x): + return over(lens, always(v), x) + + +# pylint: disable=redefined-builtin +set = _curry3(inner_set) diff --git a/test/test_inc.py b/test/test_inc.py new file mode 100644 index 0000000..c2d08e9 --- /dev/null +++ b/test/test_inc.py @@ -0,0 +1,22 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/inc.js +""" + + +class TestInc(unittest.TestCase): + def test_increments_its_argument(self): + self.assertEqual(0, R.inc(-1)) + self.assertEqual(1, R.inc(0)) + self.assertEqual(2, R.inc(1)) + self.assertEqual(13.34, R.inc(12.34)) + self.assertEqual(float('-inf'), R.inc(float('-inf'))) + self.assertEqual(float('inf'), R.inc(float('inf'))) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_lensPath.py b/test/test_lensPath.py index b1dd1bb..8c68be0 100644 --- a/test/test_lensPath.py +++ b/test/test_lensPath.py @@ -40,5 +40,60 @@ def test_focuses_the_specified_object_property(self): self.assertEqual(2, R.view(R.lensPath(['a', 1, 'b']), testObj)) self.assertEqual(testObj, R.view(R.lensPath([]), testObj)) + def test_sets_the_value_of_the_object_property_specified(self): + self.assertEqual({'a': [{'b': 1}, {'b': 2}], 'd': 0}, R.set(R.lensPath(['d']), 0, testDict)) + self.assertEqual({'a': [{'b': 0}, {'b': 2}], 'd': 3}, R.set(R.lensPath(['a', 0, 'b']), 0, testDict)) + self.assertEqual(0, R.set(R.lensPath([]), 0, testDict)) + + # TODO: support object, refer assoc + + def test_adds_the_property_to_the_object_if_it_does_not_exist(self): + self.assertEqual({'a': [{'b': 1}, {'b': 2}], 'd': 3, 'X': 0}, R.set(R.lensPath(['X']), 0, testDict)) + self.assertEqual({'a': [{'b': 1, 'X': 0}, {'b': 2}], 'd': 3}, R.set(R.lensPath(['a', 0, 'X']), 0, testDict)) + + # TODO: support object, refer assoc + + def test_applies_function_to_the_value_of_the_specified_object_property(self): + self.assertEqual({'a': [{'b': 1}, {'b': 2}], 'd': 4}, R.over(R.lensPath(['d']), R.inc, testDict)) + self.assertEqual({'a': [{'b': 1}, {'b': 3}], 'd': 3}, R.over(R.lensPath(['a', 1, 'b']), R.inc, testDict)) + self.assertEqual([['a', [{'b': 1}, {'b': 2}]], ['d', 3]], R.over(R.lensPath([]), R.toPairs, testDict)) + + # TODO: support object, refer assoc + + def test_applies_function_to_None_and_adds_the_property_if_it_does_not_exists(self): + self.assertEqual({'a': [{'b': 1}, {'b': 2}], 'd': 3, 'X': None}, R.over(R.lensPath(['X']), R.identity, testDict)) + self.assertEqual({'a': [{'b': 1, 'X': None}, {'b': 2}], 'd': 3}, R.over(R.lensPath(['a', 0, 'X']), R.identity, testDict)) + + # TODO: support object, refer assoc + + def test_can_be_composed(self): + composedLens = R.compose(R.lensPath(['a']), R.lensPath([1, 'b'])) + self.assertEqual(2, R.view(composedLens, testDict)) + self.assertEqual(2, R.view(composedLens, testObj)) + + def test_set_s_get_s_equals_s(self): + # set s (get s) == s + self.assertEqual(testDict, R.set(R.lensPath(['d']), R.view(R.lensPath(['d']), testDict), testDict)) + self.assertEqual(testDict, R.set(R.lensPath(['a', 0, 'b']), R.view(R.lensPath(['a', 0, 'b']), testDict), testDict)) + + # TODO: support object, refer assoc + + def test_get_set_s_v_equals_v(self): + # get (set s v) == v + self.assertEqual(0, R.view(R.lensPath(['d']), R.set(R.lensPath(['d']), 0, testDict))) + self.assertEqual(0, R.view(R.lensPath(['a', 0, 'b']), R.set(R.lensPath(['a', 0, 'b']), 0, testDict))) + + # TODO: support object, refer assoc + + def test_get_set_set_s_v1_v2_equals_v2(self): + # get (set (set s v1) v2) == v2 + p = ['d'] + q = ['a', 0, 'b'] + self.assertEqual(11, R.view(R.lensPath(p), R.set(R.lensPath(p), 11, R.set(R.lensPath(p), 10, testDict)))) + self.assertEqual(11, R.view(R.lensPath(q), R.set(R.lensPath(q), 11, R.set(R.lensPath(q), 10, testDict)))) + + # TODO: support object, refer assoc + + if __name__ == '__main__': unittest.main() From 64d2eec47c743e625538b4ac84b5d10f09deb945 Mon Sep 17 00:00:00 2001 From: zyd Date: Sun, 14 Aug 2022 21:29:08 +0900 Subject: [PATCH 3/6] add method lensProp and mark methods added in readme --- README.md | 14 ++++---- ramda/__init__.py | 1 + ramda/lensProp.py | 11 ++++++ test/test_lensProp.py | 80 +++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 99 insertions(+), 7 deletions(-) create mode 100644 ramda/lensProp.py create mode 100644 test/test_lensProp.py diff --git a/README.md b/README.md index 1f063fd..9d7394b 100644 --- a/README.md +++ b/README.md @@ -298,7 +298,7 @@ R.hasPath(['b'], child) # True - [ ] identical - [x] 0.1.2 identity - [x] ifElse -- [ ] inc +- [x] inc - [ ] includes - [ ] indexBy - [x] 0.1.2 indexOf @@ -465,10 +465,10 @@ class ObjWithoutLength: R.length(ObjWithoutLength()) # float('nan') ``` -- [ ] lens +- [x] lens - [ ] lensIndex -- [ ] lensPath -- [ ] lensProp +- [x] lensPath +- [x] lensProp - [x] 0.7.0 lift - [x] 0.7.0 liftN - [x] 0.1.2 lt @@ -556,7 +556,7 @@ R.omit(['v1', 'v3'], obj) # {'v2': 2} - [x] 0.1.2 once - [x] 0.1.2 or - [ ] otherwise -- [ ] over +- [x] over - [ ] pair - [ ] partial - [ ] partialObject @@ -648,7 +648,7 @@ R.propEq(1, 'v1', {'v1': 1}) # True - [x] 0.1.2 reverse - [ ] scan - [ ] sequence -- [ ] set +- [x] set - [x] 0.1.2 slice ```python @@ -776,7 +776,7 @@ R.values({'a': 1, 'b': 2}) # [1, 2] Use `R.keysIn` to get the keys of an object. -- [ ] view +- [x] view - [ ] when - [x] 0.1.4 where diff --git a/ramda/__init__.py b/ramda/__init__.py index 4aa8b38..7291e09 100644 --- a/ramda/__init__.py +++ b/ramda/__init__.py @@ -68,6 +68,7 @@ from .length import length from .lens import lens from .lensPath import lensPath +from .lensProp import lensProp from .lift import lift from .liftN import liftN from .lt import lt diff --git a/ramda/lensProp.py b/ramda/lensProp.py new file mode 100644 index 0000000..c94132b --- /dev/null +++ b/ramda/lensProp.py @@ -0,0 +1,11 @@ +from .assoc import assoc +from .lens import lens +from .private._curry1 import _curry1 +from .prop import prop + + +def inner_lensProp(k): + return lens(prop(k), assoc(k)) + + +lensProp = _curry1(inner_lensProp) diff --git a/test/test_lensProp.py b/test/test_lensProp.py new file mode 100644 index 0000000..39c0c1f --- /dev/null +++ b/test/test_lensProp.py @@ -0,0 +1,80 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/lensProp.js +""" + +testDict = { + 'a': 1, + 'b': 2, + 'c': 3 +} + + +class Obj: + def __init__(self, a, b, c): + self.a = a + self.b = b + self.c = c + + +testObj = Obj(1, 2, 3) + + +class TestLensProp(unittest.TestCase): + def test_focuses_object_the_specified_object_property(self): + self.assertEqual(1, R.view(R.lensProp('a'), testDict)) + self.assertEqual(1, R.view(R.lensProp('a'), testObj)) + + def test_returns_None_if_the_specified_property_does_not_exist(self): + self.assertEqual(None, R.view(R.lensProp('X'), testDict)) + self.assertEqual(None, R.view(R.lensProp('X'), testObj)) + + def test_sets_the_value_of_the_object_property_specified(self): + self.assertEqual({'a': 0, 'b': 2, 'c': 3}, R.set(R.lensProp('a'), 0, testDict)) + # TODO: support object, refer assoc + + def test_adds_the_property_to_the_object_if_it_does_not_exist(self): + self.assertEqual({'a': 1, 'b': 2, 'c': 3, 'd': 4}, R.set(R.lensProp('d'), 4, testDict)) + # TODO: support object, refer assoc + + def test_applies_function_to_the_value_of_the_specified_object_property(self): + self.assertEqual({'a': 2, 'b': 2, 'c': 3}, R.over(R.lensProp('a'), R.inc, testDict)) + # TODO: support object, refer assoc + + def test_applies_function_to_the_value_of_the_specified_object_property(self): + self.assertEqual({'a': 2, 'b': 2, 'c': 3}, R.over(R.lensProp('a'), R.inc, testDict)) + # TODO: support object, refer assoc + + def test_applies_function_to_None_and_adds_the_property_if_it_does_not_exist(self): + self.assertEqual({'a': 1, 'b': 2, 'c': 3, 'X': None}, R.over(R.lensProp('X'), R.identity, testDict)) + # TODO: support object, refer assoc + + def test_can_be_composed(self): + nestedObj = { + 'a': { + 'b': 1 + }, + 'c': 2 + } + composedLens = R.compose(R.lensProp('a'), R.lensProp('b')) + self.assertEqual(1, R.view(composedLens, nestedObj)) + + def test_set_s_get_s_equals_s(self): + # set s (get s) == s + self.assertEqual(testDict, R.set(R.lensProp('a'), R.view(R.lensProp('a'), testDict), testDict)) + + def test_get_set_s_v_equals_s_v(self): + # get (set s v) == v + self.assertEqual(1, R.view(R.lensProp('a'), R.set(R.lensProp('a'), 1, testDict))) + + def test_get_set_set_s_v1_v2_equals_v2(self): + # get (set (set s v1) v2) == v2 + self.assertEqual(11, R.view(R.lensProp('a'), R.set(R.lensProp('a'), 11, R.set(R.lensProp('a'), 10, testDict)))) + + +if __name__ == '__main__': + unittest.main() From 672155d922ab582d1fda7837cd7e148ffba92861 Mon Sep 17 00:00:00 2001 From: zyd Date: Tue, 16 Aug 2022 10:42:00 +0900 Subject: [PATCH 4/6] add method lensIndex / update --- README.md | 4 ++-- ramda/__init__.py | 2 ++ ramda/lensIndex.py | 11 +++++++++++ ramda/update.py | 10 ++++++++++ test/test_lensIndex.py | 44 ++++++++++++++++++++++++++++++++++++++++++ test/test_update.py | 39 +++++++++++++++++++++++++++++++++++++ 6 files changed, 108 insertions(+), 2 deletions(-) create mode 100644 ramda/lensIndex.py create mode 100644 ramda/update.py create mode 100644 test/test_lensIndex.py create mode 100644 test/test_update.py diff --git a/README.md b/README.md index 9d7394b..6af596e 100644 --- a/README.md +++ b/README.md @@ -466,7 +466,7 @@ R.length(ObjWithoutLength()) # float('nan') ``` - [x] lens -- [ ] lensIndex +- [x] lensIndex - [x] lensPath - [x] lensProp - [x] 0.7.0 lift @@ -757,7 +757,7 @@ Partially supported - [x] 0.3.0 unnest - [ ] until - [ ] unwind -- [ ] update +- [x] update - [x] 0.1.2 useWith - [x] 0.1.2 values diff --git a/ramda/__init__.py b/ramda/__init__.py index 7291e09..6356215 100644 --- a/ramda/__init__.py +++ b/ramda/__init__.py @@ -67,6 +67,7 @@ from .lastIndexOf import lastIndexOf from .length import length from .lens import lens +from .lensIndex import lensIndex from .lensPath import lensPath from .lensProp import lensProp from .lift import lift @@ -139,6 +140,7 @@ from .uniqBy import uniqBy from .uniqWith import uniqWith from .unnest import unnest +from .update import update from .useWith import useWith from .values import values from .valuesIn import valuesIn diff --git a/ramda/lensIndex.py b/ramda/lensIndex.py new file mode 100644 index 0000000..37da722 --- /dev/null +++ b/ramda/lensIndex.py @@ -0,0 +1,11 @@ +from .lens import lens +from .nth import nth +from .private._curry1 import _curry1 +from .update import update + + +def inner_lensIndex(n): + return lens(nth(n), update(n)) + + +lensIndex = _curry1(inner_lensIndex) diff --git a/ramda/update.py b/ramda/update.py new file mode 100644 index 0000000..e8ff567 --- /dev/null +++ b/ramda/update.py @@ -0,0 +1,10 @@ +from .adjust import adjust +from .always import always +from .private._curry3 import _curry3 + + +def inner_update(idx, x, arr): + return adjust(idx, always(x), arr) + + +update = _curry3(inner_update) diff --git a/test/test_lensIndex.py b/test/test_lensIndex.py new file mode 100644 index 0000000..982d774 --- /dev/null +++ b/test/test_lensIndex.py @@ -0,0 +1,44 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/lensIndex.js +""" + +testList = [{'a': 1}, {'b': 2}, {'c': 3}] + + +class TestLensIndex(unittest.TestCase): + def test_focuses_list_element_at_the_specified_index(self): + self.assertEqual({'a': 1}, R.view(R.lensIndex(0), testList)) + + def test_returns_None_if_the_specified_index_does_not_exist(self): + self.assertEqual(None, R.view(R.lensIndex(10), testList)) + + def test_sets_the_list_value_at_the_specified_index(self): + self.assertEqual([0, {'b': 2}, {'c': 3}], R.set(R.lensIndex(0), 0, testList)) + + def test_applies_function_to_the_value_at_the_specified_list_index(self): + self.assertEqual([{'a': 1}, {'b': 2}, ['c']], R.over(R.lensIndex(2), R.keys, testList)) + + def test_can_be_composed(self): + nestedList = [0, [10, 11, 12], 1, 2] + composedLens = R.compose(R.lensIndex(1), R.lensIndex(0)) + self.assertEqual(10, R.view(composedLens, nestedList)) + + def test_set_s_get_s_equals_s(self): + # set s (get s) == s + self.assertEqual(testList, R.set(R.lensIndex(0), R.view(R.lensIndex(0), testList), testList)) + + def test_get_set_s_v_equals_v(self): + # get (set s v) == v + self.assertEqual(0, R.view(R.lensIndex(0), R.set(R.lensIndex(0), 0, testList))) + + def test_get_set_set_s_v1_v2_equals_v2(self): + # get (set (set s v1) v2) == v2 + self.assertEqual(11, R.view(R.lensIndex(0), R.set(R.lensIndex(0), 11, R.set(R.lensIndex(0), 10, testList), testList))) + +if __name__ == '__main__': + unittest.main() diff --git a/test/test_update.py b/test/test_update.py new file mode 100644 index 0000000..f55298e --- /dev/null +++ b/test/test_update.py @@ -0,0 +1,39 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/update.js +""" + + +class TestUpdate(unittest.TestCase): + def test_updates_the_value_at_the_given_index_of_the_supplied_array(self): + self.assertEqual([0, 1, 4, 3], R.update(2, 4, [0, 1, 2, 3])) + + def test_offsets_negative_indexes_from_the_end_of_the_array(self): + self.assertEqual([0, 4, 2, 3], R.update(-3, 4, [0, 1, 2, 3])) + + def test_returns_the_original_array_if_the_supplied_index_is_out_of_bounds(self): + arr = [0, 1, 2, 3] + self.assertEqual(arr, R.update(4, 4, arr)) + self.assertEqual(arr, R.update(-5, 4, arr)) + + def test_does_not_mutate_the_original_array(self): + arr = [0, 1, 2, 3] + self.assertEqual([0, 1, 4, 3], R.update(2, 4, arr)) + self.assertEqual([0, 1, 2, 3], arr) + + def test_curries_the_arguments(self): + self.assertEqual([0, 1, 4, 3], R.update(2)(4)([0, 1, 2, 3])) + + def test_accpets_an_array_like_object(self): + def args(*a): + return list(a) + + self.assertEqual([0, 1, 4, 3], R.update(2, 4, args(0, 1, 2, 3))) + + +if __name__ == '__main__': + unittest.main() From 1c92f091d5b8c5487e01ed41bb3d36654f9a1bf9 Mon Sep 17 00:00:00 2001 From: zyd Date: Wed, 17 Aug 2022 10:12:53 +0900 Subject: [PATCH 5/6] add method toUpper --- README.md | 2 +- ramda/__init__.py | 1 + ramda/toUpper.py | 1 + test/test_lens.py | 8 +++++++- test/test_toUpper.py | 17 +++++++++++++++++ 5 files changed, 27 insertions(+), 2 deletions(-) create mode 100644 ramda/toUpper.py create mode 100644 test/test_toUpper.py diff --git a/README.md b/README.md index 6af596e..e450739 100644 --- a/README.md +++ b/README.md @@ -737,7 +737,7 @@ Partially supported 1. String type, supported 1. for others, just use str(x) instead -- [ ] toUpper +- [x] toUpper - [ ] transduce - [ ] transpose - [ ] traverse diff --git a/ramda/__init__.py b/ramda/__init__.py index 6356215..085e071 100644 --- a/ramda/__init__.py +++ b/ramda/__init__.py @@ -132,6 +132,7 @@ from .toPairs import toPairs from .toPairsIn import toPairsIn from .toString import toString +from .toUpper import toUpper from .trim import trim from .unary import unary from .union import union diff --git a/ramda/toUpper.py b/ramda/toUpper.py new file mode 100644 index 0000000..69aeb49 --- /dev/null +++ b/ramda/toUpper.py @@ -0,0 +1 @@ +def toUpper(s): return s.upper() diff --git a/test/test_lens.py b/test/test_lens.py index 02f0621..4db43dd 100644 --- a/test/test_lens.py +++ b/test/test_lens.py @@ -24,7 +24,13 @@ def test_may_be_applie_to_a_lens_created_by_lensPath(self): self.assertEqual('joker', R.view(dogLens, alice)) def test_may_be_applied_to_a_lens_created_by_lensProp(self): - pass + self.assertEqual('Alice Jones', R.view(nameLens, alice)) + + self.assertEqual({ + 'name': 'ALICE JONES', + 'address': ['22 Walnut St', 'San Francisco', 'CA'], + 'pets': {'dog': 'joker', 'cat': 'batman'} + }, R.over(nameLens, R.toUpper, alice)) if __name__ == '__main__': diff --git a/test/test_toUpper.py b/test/test_toUpper.py new file mode 100644 index 0000000..70ec84e --- /dev/null +++ b/test/test_toUpper.py @@ -0,0 +1,17 @@ + +import unittest + +import ramda as R + +""" +https://github.com/ramda/ramda/blob/master/test/toUpper.js +""" + + +class TestToUpper(unittest.TestCase): + def test_returns_the_upper_case_equivalent_of_the_input_string(self): + self.assertEqual('ABC', R.toUpper('abc')) + + +if __name__ == '__main__': + unittest.main() From 3d9309f7a6903ef056cb47e7262a223674918a7d Mon Sep 17 00:00:00 2001 From: zyd Date: Sat, 20 Aug 2022 17:21:15 +0900 Subject: [PATCH 6/6] add all lens test cases --- test/test_lens.py | 37 +++++++++++++++++++++++++++++++++++-- 1 file changed, 35 insertions(+), 2 deletions(-) diff --git a/test/test_lens.py b/test/test_lens.py index 4db43dd..0634c1e 100644 --- a/test/test_lens.py +++ b/test/test_lens.py @@ -14,8 +14,8 @@ } nameLens = R.lens(R.prop('name'), R.assoc('name')) -# addressLens = R.lensProp('address') -# headLens = R.lensIndex(0) +addressLens = R.lensProp('address') +headLens = R.lensIndex(0) dogLens = R.lensPath(['pets', 'dog']) @@ -32,6 +32,39 @@ def test_may_be_applied_to_a_lens_created_by_lensProp(self): 'pets': {'dog': 'joker', 'cat': 'batman'} }, R.over(nameLens, R.toUpper, alice)) + self.assertEqual({ + 'name': 'Alice Smith', + 'address': ['22 Walnut St', 'San Francisco', 'CA'], + 'pets': {'dog': 'joker', 'cat': 'batman'} + }, R.set(nameLens, 'Alice Smith', alice)) + + def test_may_be_applied_to_a_lens_created_by_lensIndex(self): + self.assertEqual('22 Walnut St', R.view(headLens, alice['address'])) + + self.assertEqual(['22 WALNUT ST', 'San Francisco', 'CA'], R.over(headLens, R.toUpper, alice['address'])) + + self.assertEqual(['52 Crane Ave', 'San Francisco', 'CA'], R.set(headLens, '52 Crane Ave', alice['address'])) + + def test_may_be_applied_to_composed_lenses(self): + streetLens = R.compose(addressLens, headLens) + dogLens = R.compose(R.lensProp('pets'), R.lensProp('dog')) + + self.assertEqual(R.view(dogLens, alice), R.view(R.lensPath(['pets', 'dog']), alice)) + + self.assertEqual('22 Walnut St', R.view(streetLens, alice)) + + self.assertEqual({ + 'name': 'Alice Jones', + 'address': ['22 WALNUT ST', 'San Francisco', 'CA'], + 'pets': {'dog': 'joker', 'cat': 'batman'} + }, R.over(streetLens, R.toUpper, alice)) + + self.assertEqual({ + 'name': 'Alice Jones', + 'address': ['52 Crane Ave', 'San Francisco', 'CA'], + 'pets': {'dog': 'joker', 'cat': 'batman'} + }, R.set(streetLens, '52 Crane Ave', alice)) + if __name__ == '__main__': unittest.main()