FilesExpand file tree

 master

/

docCheck.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

94 lines (80 loc) · 3.14 KB

 master

/

docCheck.py

Copy path

Top

File metadata and controls

• Code
• Blame

94 lines (80 loc) · 3.14 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

"""Makes sure all routes have documentation"""

import SoftLayer

from SoftLayer.CLI import routes

from pprint import pprint as pp

import glob

import logging

import os

import sys

import re

class Checker():

def __init__(self):

pass

def getDocFiles(self, path=None):

files = []

if path is None:

path = ".{seper}docs{seper}cli".format(seper=os.path.sep)

for file in glob.glob(path + '/*', recursive=True):

if os.path.isdir(file):

files = files + self.getDocFiles(file)

else:

files.append(file)

return files

def readDocs(self, path=None):

files = self.getDocFiles(path)

commands = {}

click_regex = re.compile(r"\.\. click:: ([a-zA-Z0-9_\.:]*)")

prog_regex = re.compile(r"\W*:prog: (.*)")

for file in files:

click_line = ''

prog_line = ''

with open(file, 'r') as f:

for line in f:

click_match = re.match(click_regex, line)

prog_match = False

if click_match:

click_line = click_match.group(1)

# Prog line should always be directly after click line.

prog_match = re.match(prog_regex, f.readline())

if prog_match:

prog_line = prog_match.group(1).replace(" ", ":")

commands[prog_line] = click_line

click_line = ''

prog_line = ''

# pp(commands)

return commands

def checkCommand(self, command, documented_commands):

"""Sees if a command is documented

:param tuple command: like the entry in the routes file ('command:action', 'SoftLayer.CLI.module.function')

:param documented_commands: dictionary of commands found to be auto-documented.

"""

# These commands use a slightly different loader.

ignored = [

'virtual:capacity',

'virtual:placementgroup',

'object-storage:credential'

]

if command[0] in ignored:

return True

if documented_commands.get(command[0], False) == command[1]:

return True

return False

def main(self, debug=0):

existing_commands = routes.ALL_ROUTES

documented_commands = self.readDocs()

# pp(documented_commands)

exitCode = 0

for command in existing_commands:

if (command[1].find(":") == -1): # Header commands in the routes file, dont need documentaiton.

continue

else:

if self.checkCommand(command, documented_commands):

if debug:

print("{} is documented".format(command[0]))

else:

print("===> {} {} IS UNDOCUMENTED <===".format(command[0], command[1]))

exitCode = 1

sys.exit(exitCode)

if __name__ == "__main__":

main = Checker()

main.main()