def test_multiple_indices(self):
# jmespath: foo[1].bar[1]
child = ast.SubExpression(
ast.SubExpression(ast.Field('foo'), ast.Index(1)),
ast.SubExpression(ast.Field('bar'), ast.Index(1)))
match = child.search({'foo': ['one', {'bar': ['zero', 'one']}]})
self.assertEqual(match, 'one')
def test_index_with_children(self):
# jmespath: foo.bar[-1]
child = ast.SubExpression(
ast.Field('foo'), ast.SubExpression(ast.Field('bar'),
ast.Index(-1)))
match = child.search({'foo': {'bar': ['first', 'middle', 'last']}})
self.assertEqual(match, 'last')
def test_associative(self):
data = {'foo': {'bar': ['one']}}
# jmespath: foo.bar[0]
first = ast.SubExpression(
ast.Field('foo'), ast.SubExpression(ast.Field('bar'),
ast.Index(0)))
second = ast.SubExpression(
ast.SubExpression(ast.Field('foo'), ast.Field('bar')),
ast.Index(0))
self.assertEqual(first.search(data), 'one')
self.assertEqual(second.search(data), 'one')
def test_multiple_nestings(self):
# jmespath: foo.bar.baz
child = ast.SubExpression(
ast.Field('foo'),
ast.SubExpression(ast.Field('bar'), ast.Field('baz')))
match = child.search({'foo': {'bar': {'baz': 'correct'}}})
self.assertEqual(match, 'correct')
self.assertEqual(child.search({'foo': {
'bar': {
'wrong': 'wrong'
}
}}), None)
self.assertEqual(child.search({}), None)
self.assertEqual(child.search([]), None)
self.assertEqual(child.search(''), None)
def test_filter_expression(self):
# foo[?bar==`yes`]
field_foo = ast.Field('foo')
field_bar = ast.Field('bar')
literal = ast.Literal('yes')
eq = ast.OPEquals(field_bar, literal)
filter_expression = ast.FilterExpression(eq)
full_expression = ast.SubExpression(field_foo, filter_expression)
match = full_expression.search({
'foo': [
{
'bar': 'yes',
'v': 1
},
{
'bar': 'no',
'v': 2
},
{
'bar': 'yes',
'v': 3
},
]
})
self.assertEqual(match, [{
'bar': 'yes',
'v': 1
}, {
'bar': 'yes',
'v': 3
}])
def p_jmespath_subexpression(self, p):
""" expression : expression DOT expression
| STAR
"""
if len(p) == 2:
# Then this is the STAR rule.
p[0] = ast.WildcardValues()
else:
# This is the expression DOT expression rule.
p[0] = ast.SubExpression(p[1], p[3])
def _token_led_dot(self, left):
if not self._current_token() == 'star':
right = self._parse_dot_rhs(self.BINDING_POWER['dot'])
return ast.SubExpression(left, right)
else:
# We're creating a projection.
self._advance()
right = self._parse_projection_rhs(
self.BINDING_POWER['dot'])
return ast.ValueProjection(left, right)
def p_jmespath_index(self, p):
"""expression : expression bracket-spec
| bracket-spec
"""
if len(p) == 3:
p[0] = ast.SubExpression(p[1], p[2])
elif len(p) == 2:
# Otherwise this is just a bracket-spec, which is valid as a root
# level node (e.g. [2]) so we just assign the root node to the
# bracket-spec.
p[0] = p[1]
def test_multiselect_list(self):
# foo.[bar,baz]
field_foo = ast.Field('foo')
field_bar = ast.Field('bar')
field_baz = ast.Field('baz')
multiselect = ast.MultiFieldList([field_bar, field_baz])
subexpr = ast.SubExpression(field_foo, multiselect)
self.assertEqual(
subexpr.search({'foo': {
'bar': 1,
'baz': 2,
'qux': 3
}}), [1, 2])
def test_multiselect_dict(self):
# foo.{bar,baz
field_foo = ast.KeyValPair(key_name='foo', node=ast.Field('foo'))
field_bar = ast.KeyValPair(key_name='bar', node=ast.Field('bar'))
field_baz = ast.KeyValPair(key_name='baz', node=ast.Field('baz'))
multiselect = ast.MultiFieldDict([field_bar, field_baz])
subexpr = ast.SubExpression(field_foo, multiselect)
self.assertEqual(
subexpr.search({'foo': {
'bar': 1,
'baz': 2,
'qux': 3
}}), {
'bar': 1,
'baz': 2
})
def test_negative_index(self):
# jmespath: foo[-1]
child = ast.SubExpression(ast.Field('foo'), ast.Index(-1))
match = child.search({'foo': ['one', 'two', 'last']})
self.assertEqual(match, 'last')
def test_bad_index(self):
# jmespath: foo[100]
child = ast.SubExpression(ast.Field('foo'), ast.Index(100))
match = child.search({'foo': ['one', 'two', 'three']})
self.assertEqual(match, None)
def test_dot_syntax(self):
# jmespath: foo.bar
child = ast.SubExpression(ast.Field('foo'), ast.Field('bar'))
match = child.search({'foo': {'bar': 'correct', 'baz': 'wrong'}})
self.assertEqual(match, 'correct')
