Implement sending formatted code to stdout. #19

Author: slomkowski

.gitignore

@@ -136,3 +136,5 @@ dmypy.json
 
 # pytype static type analyzer
 .pytype/
+
+examples/

nginxfmt.py

@@ -9,24 +9,26 @@
 
 import argparse
 import codecs
+import contextlib
 import dataclasses
 import logging
 import pathlib
 import re
+import sys
 
 __author__ = "Michał Słomkowski"
 __license__ = "Apache 2.0"
 __version__ = "1.2.0-SNAPSHOT"
 
-"""Class holds the formatting options. For now, only indentation supported."""
-
 
 @dataclasses.dataclass
 class FormatterOptions:
+    """Class holds the formatting options. For now, only indentation supported."""
     indentation: int = 4
 
 
 class Formatter:
+    """nginx formatter. Can format config loaded from file or string."""
     _TEMPLATE_VARIABLE_OPENING_TAG = '___TEMPLATE_VARIABLE_OPENING_TAG___'
     _TEMPLATE_VARIABLE_CLOSING_TAG = '___TEMPLATE_VARIABLE_CLOSING_TAG___'
 
@@ -56,16 +58,39 @@ def format_string(self,
 
         return text + '\n'
 
+    def get_formatted_string_from_file(self,
+                                       file_path: pathlib.Path) -> str:
+        """Loads nginx config from file, performs formatting and returns contents as string.
+        :param file_path: path to original nginx configuration file."""
+
+        _, original_file_content = self._load_file_content(file_path)
+        return self.format_string(original_file_content)
+
     def format_file(self,
                     file_path: pathlib.Path,
                     original_backup_file_path: pathlib.Path = None):
-        """
-        Performs the formatting on the given file. The function tries to detect file encoding first.
+        """Performs the formatting on the given file. The function tries to detect file encoding first.
         :param file_path: path to original nginx configuration file. This file will be overridden.
-        :param original_backup_file_path: optional path, where original file will be backed up.
-        """
-        encodings = ('utf-8', 'latin1')
+        :param original_backup_file_path: optional path, where original file will be backed up."""
+
+        chosen_encoding, original_file_content = self._load_file_content(file_path)
+
+        with codecs.open(file_path, 'w', encoding=chosen_encoding) as wfp:
+            wfp.write(self.format_string(original_file_content))
+
+        self.logger.info("Formatted content written to original file.")
 
+        if original_backup_file_path:
+            with codecs.open(original_backup_file_path, 'w', encoding=chosen_encoding) as wfp:
+                wfp.write(original_file_content)
+            self.logger.info("Previous content saved to '%s'.", original_backup_file_path)
+
+    def _load_file_content(self,
+                           file_path: pathlib.Path) -> (str, str):
+        """Determines the encoding of the input file and loads its content to string.
+        :param file_path: path to original nginx configuration file."""
+
+        encodings = ('utf-8', 'latin1')
         encoding_failures = []
         chosen_encoding = None
         original_file_content = None
@@ -83,17 +108,10 @@ def format_file(self,
             raise Exception('none of encodings %s are valid for file %s. Errors: %s'
                             % (encodings, file_path, [e.message for e in encoding_failures]))
 
-        assert original_file_content is not None
+        self.logger.info("Loaded file '%s' (detected encoding %s).", file_path, chosen_encoding)
 
-        with codecs.open(file_path, 'w', encoding=chosen_encoding) as wfp:
-            wfp.write(self.format_string(original_file_content))
-
-        self.logger.info("Formatted file '%s' (detected encoding %s).", file_path, chosen_encoding)
-
-        if original_backup_file_path:
-            with codecs.open(original_backup_file_path, 'w', encoding=chosen_encoding) as wfp:
-                wfp.write(original_file_content)
-            self.logger.info("Original saved to '%s'.", original_backup_file_path)
+        assert original_file_content is not None
+        return chosen_encoding, original_file_content
 
     @staticmethod
     def _strip_line(single_line):
@@ -267,24 +285,57 @@ def _perform_indentation(self, lines):
         return indented_lines
 
 
-if __name__ == "__main__":
-    arg_parser = argparse.ArgumentParser(description=__doc__)
+@contextlib.contextmanager
+def _redirect_stdout_to_stderr():
+    """Redirects stdout to stderr for argument parsing. This is to don't pollute the stdout
+    when --print-result is used."""
+    old_stdout = sys.stdout
+    sys.stdout = sys.stderr
+    try:
+        yield
+    finally:
+        sys.stdout = old_stdout
 
+
+def _standalone_run(program_arguments):
     # todo add logger: logs to stderr
-    # option to format from stdin
+
+    arg_parser = argparse.ArgumentParser(description="Formats nginx configuration files in consistent way.")
 
     arg_parser.add_argument("-v", "--verbose", action="store_true", help="show formatted file names")
-    arg_parser.add_argument("-b", "--backup-original", action="store_true", help="backup original config file")
-    arg_parser.add_argument("-i", "--indent", action="store", default=4, type=int,
-                            help="specify number of spaces for indentation")
+
+    backup_xor_print_group = arg_parser.add_mutually_exclusive_group()
+    print_result_action = backup_xor_print_group.add_argument("-p", "--print-result", action="store_true",
+                                                              help="prints result to stdout, original file is not changed")
+    backup_xor_print_group.add_argument("-b", "--backup-original", action="store_true",
+                                        help="backup original config file")
     arg_parser.add_argument("config_files", nargs='+', help="configuration files to format")
 
-    args = arg_parser.parse_args()
+    formatter_options_group = arg_parser.add_argument_group("formatting options")
+    formatter_options_group.add_argument("-i", "--indent", action="store", default=4, type=int,
+                                         help="specify number of spaces for indentation")
+
+    with _redirect_stdout_to_stderr():
+        args = arg_parser.parse_args(program_arguments)
+
+    try:
+        if args.print_result and len(args.config_files) != 1:
+            raise Exception("if %s is enabled, only one file can be passed as input" % argparse._get_action_name(
+                print_result_action))
+    except Exception as e:
+        arg_parser.error(str(e))
 
     format_options = FormatterOptions()
     format_options.indentation = args.indent
     formatter = Formatter(format_options)
 
-    for config_file_path in args.config_files:
-        backup_file_path = config_file_path + '~' if args.backup_original else None
-        formatter.format_file(config_file_path, backup_file_path)
+    if args.print_result:
+        print(formatter.get_formatted_string_from_file(args.config_files[0]))
+    else:
+        for config_file_path in args.config_files:
+            backup_file_path = config_file_path + '~' if args.backup_original else None
+            formatter.format_file(config_file_path, backup_file_path)
+
+
+if __name__ == "__main__":
+    _standalone_run(sys.argv[1:])

test-files/not-formatted-1.conf

@@ -0,0 +1,6 @@
+server {
+    listen 80;
+        listen [::]:80;
+       server_name example.com;
+    }
+

test_nginxfmt.py

@@ -2,18 +2,21 @@
 # -*- coding: utf-8 -*-
 
 """Unit tests for nginxfmt module."""
+import contextlib
+import logging
+import pathlib
 import shutil
 import tempfile
 import unittest
 
-from nginxfmt import *
+import nginxfmt
 
 __author__ = "Michał Słomkowski"
 __license__ = "Apache 2.0"
 
 
 class TestFormatter(unittest.TestCase):
-    fmt = Formatter()
+    fmt = nginxfmt.Formatter()
 
     def __init__(self, method_name: str = ...) -> None:
         super().__init__(method_name)
@@ -238,17 +241,21 @@ def test_multi_semicolon(self):
 
     def test_loading_utf8_file(self):
         tmp_file = pathlib.Path(tempfile.mkstemp('utf-8')[1])
-        shutil.copy('test-files/umlaut-utf8.conf', tmp_file)
-        self.fmt.format_file(tmp_file)
-        # todo perform some tests on result file
-        tmp_file.unlink()
+        try:
+            shutil.copy('test-files/umlaut-utf8.conf', tmp_file)
+            self.fmt.format_file(tmp_file)
+            # todo perform some tests on result file
+        finally:
+            tmp_file.unlink()
 
     def test_loading_latin1_file(self):
         tmp_file = pathlib.Path(tempfile.mkstemp('latin1')[1])
-        shutil.copy('test-files/umlaut-latin1.conf', tmp_file)
-        self.fmt.format_file(tmp_file)
-        # todo perform some tests on result file
-        tmp_file.unlink()
+        try:
+            shutil.copy('test-files/umlaut-latin1.conf', tmp_file)
+            self.fmt.format_file(tmp_file)
+            # todo perform some tests on result file
+        finally:
+            tmp_file.unlink()
 
     def test_issue_15(self):
         self.check_formatting(
@@ -345,6 +352,35 @@ def test_issue_9(self):
             ),
         )
 
+    def test_custom_indentation(self):
+        fo = nginxfmt.FormatterOptions(indentation=2)
+        fmt2 = nginxfmt.Formatter(fo)
+        self.assertMultiLineEqual("{\n"
+                                  "  foo bar;\n"
+                                  "}\n",
+                                  fmt2.format_string(
+                                      "  { \n"
+                                      "     foo    bar;\n"
+                                      "}\n"))
+
+
+class TestStandaloneRun(unittest.TestCase):
+
+    @contextlib.contextmanager
+    def input_test_file(self, file_name):
+        tmp_file = pathlib.Path(tempfile.mkstemp('utf-8')[1])
+        try:
+            shutil.copy('test-files/' + file_name, tmp_file)
+            yield str(tmp_file)
+            # todo perform some tests on result file
+        finally:
+            tmp_file.unlink()
+
+    # todo better tests of standalone mode?
+    def test_print_result(self):
+        with self.input_test_file('not-formatted-1.conf') as input:
+            nginxfmt._standalone_run(['-p', input])
+
 
 if __name__ == '__main__':
     unittest.main()