XHTML minify

Last modified	2016-10-05
Lines	100

Parent directory Download CGIread sitemap Main page

Quick links: engine

1. #!/usr/bin/python

3. '''Minify XHTML

5. Simple filter.

7. This simple XHTML minifier removes only indentation and comments. The reason

8. I wrote this is that the other HTML minifiers caused validation errors.

9. '''

11. #import sys

13. no_minify = [

14.     ('<pre', '</pre>')          # Start/stop patterns.

15. ]

17. def engine(get_input, set_output):

18.     '''get_input is a function that returns a string (one line) with a

19.     trailing newline.

20.     set_output is a function that takes one argument: string.

22.     Returns when get_input returns empty string.

23.     '''

24.     nop_mode = False

25.     comment = False

26.     in_str = get_input()

27.     if not in_str:

28.         return

29.     #Comment

30.     #   Leave?

31.     #No comment

32.     #   Does a comment begin on this line?

33.     #   nop_mode

34.     #           Leave nop_mode?

35.     #   normal mode

36.     #           Enter nop_mode?

37.     #   Did a comment begin on this line?

38.     while True:

39.         # Get input it before the loop and in the end, simplifies

40.         # nop_mode changes.

41.         if comment:

42.             # Leave comment mode?

43.             ptr = in_str.find('-->')

44.             if ptr >= 0:

45.                 in_str = in_str[ptr + 3:]

46.                 comment = False

47.                 continue

48.         else:

49.             # Does a comment begin on this line?

50.             comment_ptr = in_str.find('<!--')

51.             if comment_ptr >= 0:

52.                 comment = True

53.                 in_str,comment_str = in_str[:comment_ptr],in_str[comment_ptr:]

54.             if nop_mode:

55.                 # Input must not be modified.

57.                 # Get back to normal mode?

58.                 ptrs = filter(lambda x: x >= 0,

59.                             [in_str.find(stop) for start, stop in no_minify])

60.                 if not len(ptrs):

61.                     set_output(in_str)

62.                 else:

63.                     set_output(in_str[:min(ptrs)])

64.                     in_str = in_str[min(ptrs):]

65.                     nop_mode = False

66.                     # Make it believe it came from a new line.

67.                     continue

68.             else:

69.                 # Preserve the newline and remove all leading whitespace.

71.                 # Get into NOP mode?

72.                 ptrs = filter(lambda x: x >= 0,

73.                             [in_str.find(start) for start, stop in no_minify])

74.                 if not len(ptrs):

75.                     for ptr, c in enumerate(in_str):

76.                         if c not in ' \t':

77.                             set_output(in_str[ptr:])

78.                             break

79.                 else:

80.                     for ptr, c in enumerate(in_str):

81.                         if c not in ' \t':

82.                             set_output(in_str[ptr:min(ptrs)])

83.                             break

84.                     in_str = in_str[min(ptrs):]

85.                     nop_mode = True

86.                     continue

87.             # Did a comment begin on this line?

88.             if comment:

89.                 # Loop in comment mode using the rest of the string instead

90.                 # of a new line.

91.                 in_str = comment_str

92.                 continue

93.         in_str = get_input()

94.         if not in_str:

95.             break

97. if __name__ == '__main__':

98.     import sys

99.     engine(sys.stdin.readline, sys.stdout.write)