FilesExpand file tree

 master

/

formatter.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

120 lines (99 loc) · 4.2 KB

 master

/

formatter.py

Copy path

Top

File metadata and controls

• Code
• Blame

120 lines (99 loc) · 4.2 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

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

# Copyright (C) 2008 Andi Albrecht, albrecht.andi@gmail.com

#

# This module is part of python-sqlparse and is released under

# the BSD License: http://www.opensource.org/licenses/bsd-license.php.

"""SQL formatter"""

from sqlparse import filters

from sqlparse.exceptions import SQLParseError

def validate_options(options):

"""Validates options."""

kwcase = options.get('keyword_case', None)

if kwcase not in [None, 'upper', 'lower', 'capitalize']:

raise SQLParseError('Invalid value for keyword_case: %r' % kwcase)

idcase = options.get('identifier_case', None)

if idcase not in [None, 'upper', 'lower', 'capitalize']:

raise SQLParseError('Invalid value for identifier_case: %r' % idcase)

ofrmt = options.get('output_format', None)

if ofrmt not in [None, 'sql', 'python', 'php']:

raise SQLParseError('Unknown output format: %r' % ofrmt)

strip_comments = options.get('strip_comments', False)

if strip_comments not in [True, False]:

raise SQLParseError('Invalid value for strip_comments: %r'

% strip_comments)

strip_ws = options.get('strip_whitespace', False)

if strip_ws not in [True, False]:

raise SQLParseError('Invalid value for strip_whitespace: %r'

% strip_ws)

reindent = options.get('reindent', False)

if reindent not in [True, False]:

raise SQLParseError('Invalid value for reindent: %r'

% reindent)

elif reindent:

options['strip_whitespace'] = True

indent_tabs = options.get('indent_tabs', False)

if indent_tabs not in [True, False]:

raise SQLParseError('Invalid value for indent_tabs: %r' % indent_tabs)

elif indent_tabs:

options['indent_char'] = '\t'

else:

options['indent_char'] = ' '

indent_width = options.get('indent_width', 2)

try:

indent_width = int(indent_width)

except (TypeError, ValueError):

raise SQLParseError('indent_width requires an integer')

if indent_width < 1:

raise SQLParseError('indent_width requires an positive integer')

options['indent_width'] = indent_width

right_margin = options.get('right_margin', None)

if right_margin is not None:

try:

right_margin = int(right_margin)

except (TypeError, ValueError):

raise SQLParseError('right_margin requires an integer')

if right_margin < 10:

raise SQLParseError('right_margin requires an integer > 10')

options['right_margin'] = right_margin

return options

def build_filter_stack(stack, options):

"""Setup and return a filter stack.

Args:

stack: :class:`~sqlparse.filters.FilterStack` instance

options: Dictionary with options validated by validate_options.

"""

# Token filter

if options.get('keyword_case', None):

stack.preprocess.append(

filters.KeywordCaseFilter(options['keyword_case']))

if options.get('identifier_case', None):

stack.preprocess.append(

filters.IdentifierCaseFilter(options['identifier_case']))

# After grouping

if options.get('strip_comments', False):

stack.enable_grouping()

stack.stmtprocess.append(filters.StripCommentsFilter())

if (options.get('strip_whitespace', False)

or options.get('reindent', False)):

stack.enable_grouping()

stack.stmtprocess.append(filters.StripWhitespaceFilter())

if options.get('reindent', False):

stack.enable_grouping()

stack.stmtprocess.append(

filters.ReindentFilter(char=options['indent_char'],

width=options['indent_width']))

if options.get('right_margin', False):

stack.enable_grouping()

stack.stmtprocess.append(

filters.RightMarginFilter(width=options['right_margin']))

# Serializer

if options.get('output_format'):

frmt = options['output_format']

if frmt.lower() == 'php':

fltr = filters.OutputPHPFilter()

elif frmt.lower() == 'python':

fltr = filters.OutputPythonFilter()

else:

fltr = None

if fltr is not None:

stack.postprocess.append(fltr)

return stack