aboutsummaryrefslogtreecommitdiffstats
path: root/config_file/parsers/json_parser.py
blob: 10d5afc2d11d37a0c9c28664cb54be47735567fd (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import json

from nested_lookup import (
    get_occurrence_of_key,
    nested_delete,
    nested_lookup,
    nested_update,
)

from config_file.exceptions import ParsingError
from config_file.parsers.base_parser import BaseParser
from config_file.parsers.parse_value import parse_value
from config_file.utils import split_on_dot


class JsonParser(BaseParser):
    """
    The JsonParser allows use of json files with ConfigFile. The syntax it
    supports is a bit more flexible than the IniParser.

    By default, the dot syntax is used. However, if you'd like to get/set/delete all
    of a particular key, you can specify so with an optional parameter.

    Example:

        json = {
           "key1": {
               "key2": "foo",
               "key1": "bar"
           },
           "foo": "bar"
        }
        parser = JsonParser(json.dumps(json))
        parser.get('key1')
        >>> { "key2": "foo", "key1": "bar" }
        parser.get('key1.key2')
        >>> "foo"
        parser.get('key1', all=True)
        >>> [{ "key2": "foo", "key1": "bar" }, "bar"]
    """

    def __init__(self, file_contents: str):
        """Reads in the file contents into the parser."""
        super().__init__(file_contents)

    def parse(self, file_contents: str):
        try:
            return json.loads(file_contents)
        except json.decoder.JSONDecodeError as error:
            raise ParsingError(error)

    def get(self, key: str, parse_types: bool = False, all: bool = False):
        """
        Retrieve values using a dot syntax.

        :param key: The key to retrieve. e.g. 'foo.bar.boo'

        :param parse_types: Whether you'd like the type parsed into its native one.

        :param all: Specify whether you'd like to recursively receive
        all values that match the given key. Returned as a list.
        e.g. 'foo' would retrieve all values that have the key 'foo', anywhere
        in the json.

        :return: the value of the given key
        """
        if all:
            result = nested_lookup(key, self.parsed_content)
        elif "." in key:
            split_keys = split_on_dot(key)
            result = self.parsed_content

            # Used so we can more precisely specify what key is causing the error.
            key_for_error = None
            try:
                for key in split_keys:
                    key_for_error = key
                    result = result[key]
            except TypeError:
                raise ParsingError(
                    f"Cannot get {key} because {key_for_error} is not subscriptable."
                )
        else:
            result = self.parsed_content[key]

        return parse_value(result) if parse_types else result

    def set(self, key: str, value, all: bool = False):
        if all:
            nested_update(self.parsed_content, key, value, in_place=True)
        elif "." in key:
            indexes = split_on_dot(key)
            indexes_length = len(indexes)

            ref = self.parsed_content
            for index, key in enumerate(indexes):
                if index == indexes_length - 1:
                    ref[key] = value
                    break

                ref = ref[key]
        else:
            self.parsed_content[key] = value

        return True

    def delete(self, key, all: bool = False):
        if all:
            nested_delete(self.parsed_content, key, in_place=True)
        elif "." in key:
            indexes = split_on_dot(key)
            indexes_length = len(indexes)

            ref = self.parsed_content
            for index, key in enumerate(indexes):
                if index == indexes_length - 1:
                    del ref[key]
                    break

                ref = ref[key]
        else:
            del self.parsed_content[key]

        return True

    def stringify(self) -> str:
        return json.dumps(self.parsed_content)

    def has(self, search_key: str) -> bool:
        return get_occurrence_of_key(self.parsed_content, key=search_key) > 0