documentation-scraper/documentation.py at master · kolloldas/documentation-scraper · GitHub

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
131
132
133
134
135
136
137
138
139
class Parameters(dict):
    def add(self, name, param_type, description):
        self[name] = {'type': param_type, 'description': description}

class Returns(dict):
    def set_returns(self, return_type, description):
        self['type'] = return_type
        self['description'] = description

class Documentation(object):
    """
    Encapsulates documentation for a single file
    """
    def __init__(self):
        self._name = None
        self._obj_type = None
        self._api_level = '1'
        self._summary = []
        self._parent_class = 'Object'
        self._interfaces = []
        self._nested_classes = []
        self._constants = []
        self._fields = []
        self._constructors = []
        self._public_methods = []
        self._protected_methods = []

    def set_name(self, name):
        self._name = name

    def set_api_level(self, api_level):
        self._api_level = api_level

    def append_summary(self, summary):
        self._summary.append(summary)

    def set_object_type(self, obj_type):
        self._obj_type = obj_type

    def set_parent_class(self, parent_class):
        self._parent_class = parent_class

    def set_interfaces(self, interfaces):
        self._interfaces = interfaces

    def add_nested_class(self, name, obj_type, description):
        self._nested_classes.append({'name': name,
                                     'type': obj_type,
                                     'description': description})

    def add_constant(self, name, const_type, const_value, description, api_level):
        self._constants.append({'name': name,
                                'type': const_type,
                                'value': const_value,
                                'description': description,
                                'api_level': api_level})

    def add_field(self, name, field_type, description, api_level):
        self._fields.append({'name': name,
                                'type': field_type,
                                'description': description,
                                'api_level': api_level})

    def add_constructor(self, name, description, api_level):
        params = Parameters()
        returns = Returns() #dummy
        self._constructors.append({'name': name,
                                    'params': params,
                                    'description': description,
                                    'api_level': api_level})
        return params, returns

    def add_public_method(self, name, description, api_level):
        params = Parameters()
        returns = Returns()
        self._public_methods.append({'name': name,
                                    'params': params,
                                    'returns': returns,
                                    'description': description,
                                    'api_level': api_level})
        return params, returns

    def add_protected_method(self, name, description, api_level):
        params = Parameters()
        returns = Returns()
        self._protected_methods.append({'name': name,
                                        'params': params,
                                        'returns': returns,
                                        'description': description,
                                        'api_level': api_level})
        return params, returns

    @property
    def name(self):
        return self._name

    @property
    def object_type(self):
        return self._obj_type

    @property
    def api_level(self):
        return self._api_level

    @property
    def summary(self):
        return self._summary if len(self._summary) > 0 else None

    @property
    def parent_class(self):
        return self._parent_class

    @property
    def interfaces(self):
        return self._interfaces if len(self._interfaces) > 0 else None

    @property
    def nested_classes(self):
        return self._nested_classes if len(self._nested_classes) > 0 else None

    @property
    def constants(self):
        return self._constants if len(self._constants) > 0 else None

    @property
    def fields(self):
        return self._fields if len(self._fields) > 0 else None

    @property
    def constructors(self):
        return self._constructors if len(self._constructors) > 0 else None

    @property
    def public_methods(self):
        return self._public_methods if len(self._public_methods) > 0 else None

    @property
    def protected_methods(self):
        return self._protected_methods if len(self._protected_methods) > 0 else None