Merge branch 'develop' of https://github.com/jmespath/jmespath.py into develop

Author: jansel

docs/proposals/filter-expressions.rst

@@ -143,7 +143,7 @@ element resolves to the comparison ``"char" < "bar"``, and because these types
 are string, the expression results in ``null``, so the first element is not
 included in the result list.  The second element resolves to ``2 < 1``,
 which is ``false``, so the second element is excluded from the result list.
-The third expression resolves to ``1 < 2`` which evalutes to ``true``, so the
+The third expression resolves to ``1 < 2`` which evaluates to ``true``, so the
 third element is included in the list.  The final result of that expression
 is ``[{"a": 1, "b": 2}]``.
 
@@ -247,7 +247,7 @@ In order for this to be useful we need to define what corresponds to true and
 false values, e.g. an empty list is a false value.  Additionally, "or
 expressions" would need to change its semantics to branch based on the
 true/false value of an expression instead of whether or not the expression
-evalutes to null.
+evaluates to null.
 
 This is certainly a direction to take in the future, adding arbitrary
 expressions in a filter would be a backwards compatible change, so it's not

docs/proposals/functions.rst

@@ -118,7 +118,7 @@ Each function signature declares the types of its input parameters.  If any
 type constraints are not met, implementations must indicate that an
 ``invalid-type`` error occurred.
 
-In order to accommodate type contraints, functions are provided to convert
+In order to accommodate type constraints, functions are provided to convert
 types to other types (``to_string``, ``to_number``) which are defined below.
 No explicit type conversion happens unless a user specifically uses one of
 these type conversion functions.

docs/proposals/improved-identifiers.rst

@@ -199,7 +199,7 @@ identifier cannot start with ``-``::
 escape.json
 -----------
 
-The escape.json has several more interseting cases that need to be updated.
+The escape.json has several more interesting cases that need to be updated.
 This has to do with the updated escaping rules.  Each one will be explained.
 
 ::

docs/proposals/pipes.rst

@@ -104,7 +104,7 @@ The following modified JMESPath grammar supports piped expressions.
 
 .. note::
 
-    ``pipe-expression`` has a higher precendent than the ``or-operator``
+    ``pipe-expression`` has a higher precedent than the ``or-operator``
 
 Compliance Tests
 ================

docs/specification.rst

@@ -202,7 +202,7 @@ SubExpressions
                                          "*" )
 
 A subexpression is a combination of two expressions separated by the '.' char.
-A subexpression is evaluted as follows:
+A subexpression is evaluated as follows:
 
 * Evaluate the expression on the left with the original JSON document.
 * Evaluate the expression on the right with the result of the left expression
@@ -455,7 +455,7 @@ evaluated as follows:
 1. A hash is created: ``{}``
 2. A key ``foo`` is created whose value is the result of evaluating ``one.two``
    against the provided JSON document: ``{"foo": evaluate(one.two, <data>)}``
-3. A key ``bar`` is created whose value is the result of evaluting the
+3. A key ``bar`` is created whose value is the result of evaluating the
    expression ``bar`` against the provided JSON document.
 
 The final result will be: ``{"foo": "one-two", "bar": "bar"}``.
@@ -576,7 +576,7 @@ Filter Expressions
 A filter expression provides a way to select JSON elements based on a
 comparison to another expression.  A filter expression is evaluated as follows:
 for each element in an array evaluate the ``list-filter-expr`` against the
-element.  If the expression evalutes to ``true``, the item (in its entirety) is
+element.  If the expression evaluates to ``true``, the item (in its entirety) is
 added to the result list.  Otherwise it is excluded from the result list.  A
 filter expression is only defined for a JSON array.  Attempting to evaluate a
 filter expression against any other type will return ``null``.
@@ -606,7 +606,7 @@ For ``string/number/true/false/null`` types, equality is an exact match. A
 ``string`` is equal to another ``string`` if they they have the exact sequence
 of code points.  The literal values ``true/false/null`` are only equal to their
 own literal values.  Two JSON objects are equal if they have the same set of
-keys and values (given two JSON objeccts ``x`` and ``y``, for each key value
+keys and values (given two JSON objects ``x`` and ``y``, for each key value
 pair ``(i, j)`` in ``x``, there exists an equivalent pair ``(i, j)`` in ``y``).
 Two JSON arrays are equal if they have equal elements in the same order (given
 two arrays ``x`` and ``y``, for each ``i`` from ``0`` until ``length(x)``,
@@ -629,7 +629,7 @@ element resolves to the comparison ``"char" < "bar"``, and because these types
 are string, the expression results in ``null``, so the first element is not
 included in the result list.  The second element resolves to ``2 < 1``,
 which is ``false``, so the second element is excluded from the result list.
-The third expression resolves to ``1 < 2`` which evalutes to ``true``, so the
+The third expression resolves to ``1 < 2`` which evaluates to ``true``, so the
 third element is included in the list.  The final result of that expression
 is ``[{"a": 1, "b": 2}]``.
 
@@ -734,7 +734,7 @@ Each function signature declares the types of its input parameters.  If any
 type constraints are not met, implementations must indicate that an
 ``invalid-type`` error occurred.
 
-In order to accommodate type contraints, functions are provided to convert
+In order to accommodate type constraints, functions are provided to convert
 types to other types (``to_string``, ``to_number``) which are defined below.
 No explicit type conversion happens unless a user specifically uses one of
 these type conversion functions.
@@ -1258,7 +1258,7 @@ not_null
 
 Returns the first argument that does not resolve to ``null``.  This function
 accepts one or more arguments, and will evaluate them in order until a
-non null argument is encounted.  If all arguments values resolve to ``null``,
+non null argument is encountered.  If all arguments values resolve to ``null``,
 then a value of ``null`` is returned.
 
 .. list-table:: Examples

extra/test_hypothesis.py

@@ -36,7 +36,7 @@
 }
 
 
-# For all of these tests they verify these proprties:
+# For all of these tests they verify these properties:
 # either the operation succeeds or it raises a JMESPathError.
 # If any other exception is raised then we error out.
 @settings(**BASE_SETTINGS)

jmespath/functions.py

@@ -28,7 +28,7 @@
     'boolean': ('bool',),
     'array': ('list', '_Projection'),
     'object': ('dict', 'OrderedDict',),
-    'null': ('None',),
+    'null': ('NoneType',),
     'string': ('unicode', 'str'),
     'number': ('float', 'int', 'long'),
     'expref': ('_Expression',),

jmespath/visitor.py

@@ -60,13 +60,13 @@ class Options(object):
     """Options to control how a JMESPath function is evaluated."""
     def __init__(self, dict_cls=None, custom_functions=None):
         #: The class to use when creating a dict.  The interpreter
-        #  may create dictionaries during the evalution of a JMESPath
+        #  may create dictionaries during the evaluation of a JMESPath
         #  expression.  For example, a multi-select hash will
         #  create a dictionary.  By default we use a dict() type.
         #  You can set this value to change what dict type is used.
         #  The most common reason you would change this is if you
         #  want to set a collections.OrderedDict so that you can
-        #  have predictible key ordering.
+        #  have predictable key ordering.
         self.dict_cls = dict_cls
         self.custom_functions = custom_functions
 

scripts/astrender

@@ -42,7 +42,7 @@ def main():
         svg_name = os.path.splitext(f.name)[0] + '.png'
         check_call('dot -Tpng %s -o %s' % (f.name, svg_name), shell=True)
         webbrowser.open('file://%s' % svg_name)
-    # Rather than prompt the user to hit enterr
+    # Rather than prompt the user to hit enter
     # just sleep for as long as we think is reasonable for
     # an application to open and display the png.
     time.sleep(2)

tests/test_custom_functions.py

@@ -0,0 +1,25 @@
+import unittest
+
+import jmespath
+from jmespath import functions
+
+
+class CustomFunctions(functions.Functions):
+    @functions.signature({'types': ['string', 'array', 'object', 'null']})
+    def _func_length0(self, s):
+        return 0 if s is None else len(s)
+
+
+class TestCustomFunctions(unittest.TestCase):
+    def setUp(self):
+        self.options = jmespath.Options(custom_functions=CustomFunctions())
+
+    def test_null_to_nonetype(self):
+        data = {
+            'a': {
+                'b': [1, 2, 3]
+            }
+        }
+
+        self.assertEqual(jmespath.search('length0(a.b)', data, self.options), 3)
+        self.assertEqual(jmespath.search('length0(a.c)', data, self.options), 0)