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')