Add --prefer-single-line option

Author: dflook

src/python_minifier/__init__.py

@@ -72,7 +72,8 @@ def minify(
     remove_debug=False,
     remove_explicit_return_none=True,
     remove_builtin_exception_brackets=True,
-    constant_folding=True
+    constant_folding=True,
+    prefer_single_line=False,
 ):
     """
     Minify a python module
@@ -107,6 +108,7 @@ def minify(
     :param bool remove_explicit_return_none: If explicit return None statements should be replaced with a bare return
     :param bool remove_builtin_exception_brackets: If brackets should be removed when raising exceptions with no arguments
     :param bool constant_folding: If literal expressions should be evaluated
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
 
     :rtype: str
 
@@ -192,7 +194,7 @@ def minify(
     if convert_posargs_to_args:
         module = remove_posargs(module)
 
-    minified = unparse(module)
+    minified = unparse(module, prefer_single_line=prefer_single_line)
 
     if preserve_shebang is True:
         shebang_line = _find_shebang(source)
@@ -219,7 +221,7 @@ def _find_shebang(source):
     return None
 
 
-def unparse(module):
+def unparse(module, prefer_single_line=False):
     """
     Turn a module AST into python code
 
@@ -228,13 +230,14 @@ def unparse(module):
 
     :param module: The module to turn into python code
     :type: module: :class:`ast.Module`
+    :param bool prefer_single_line: If semi-colons should be preferred over newlines where there is no difference in output size
     :rtype: str
 
     """
 
     assert isinstance(module, ast.Module)
 
-    printer = ModulePrinter()
+    printer = ModulePrinter(prefer_single_line=prefer_single_line)
     printer(module)
 
     try:

src/python_minifier/__init__.pyi

@@ -28,11 +28,15 @@ def minify(
     remove_debug: bool = ...,
     remove_explicit_return_none: bool = ...,
     remove_builtin_exception_brackets: bool = ...,
-    constant_folding: bool = ...
+    constant_folding: bool = ...,
+    prefer_single_line: bool = ...
 ) -> Text: ...
 
 
-def unparse(module: ast.Module) -> Text: ...
+def unparse(
+    module: ast.Module,
+    prefer_single_line: bool = ...
+) -> Text: ...
 
 
 def awslambda(

src/python_minifier/__main__.py

@@ -140,6 +140,13 @@ def parse_args():
         dest='in_place'
     )
 
+    parser.add_argument(
+        '--prefer-single-line',
+        action='store_true',
+        help='Prefer multiple statements on a single line where there is no difference in output size',
+        dest='prefer_single_line',
+    )
+
     # Minification arguments
     minification_options = parser.add_argument_group('minification options', 'Options that affect how the source is minified')
     minification_options.add_argument(
@@ -373,7 +380,8 @@ def do_minify(source, filename, minification_args):
         remove_debug=minification_args.remove_debug,
         remove_explicit_return_none=minification_args.remove_explicit_return_none,
         remove_builtin_exception_brackets=minification_args.remove_exception_brackets,
-        constant_folding=minification_args.constant_folding
+        constant_folding=minification_args.constant_folding,
+        prefer_single_line=minification_args.prefer_single_line,
     )
 
     # Encode minified result to bytes for comparison and output

src/python_minifier/expression_printer.py

@@ -11,7 +11,7 @@ class ExpressionPrinter(object):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self):
+    def __init__(self, prefer_single_line=False):
 
         self.precedences = {
             'Lambda': 2,  # Lambda
@@ -34,7 +34,7 @@ def __init__(self):
             'Tuple': 18, 'Set': 18, 'List': 18, 'Dict': 18, 'ListComp': 18, 'SetComp': 18, 'DictComp': 18, 'GeneratorExp': 18,  # Container
         }
 
-        self.printer = TokenPrinter()
+        self.printer = TokenPrinter(prefer_single_line=prefer_single_line)
 
     def __call__(self, module):
         """

src/python_minifier/module_printer.py

@@ -11,8 +11,8 @@ class ModulePrinter(ExpressionPrinter):
     Builds the smallest possible exact representation of an ast
     """
 
-    def __init__(self, indent_char='\t'):
-        super(ModulePrinter, self).__init__()
+    def __init__(self, indent_char='\t', prefer_single_line=False):
+        super(ModulePrinter, self).__init__(prefer_single_line=prefer_single_line)
         self.indent_char = indent_char
 
     def __call__(self, module):

src/python_minifier/token_printer.py

@@ -306,7 +306,7 @@ def leave_block(self):
     def end_statement(self):
         """ End a statement with a newline, or a semi-colon if it saves characters. """
 
-        if self.indent == 0:
+        if self.indent == 0 and not self._prefer_single_line:
             self.newline()
         else:
             if self._code[-1] != ';':

test/test_prefer_single_line.py

@@ -0,0 +1,212 @@
+"""Tests for the prefer_single_line option."""
+import ast
+import sys
+import os
+import tempfile
+
+from python_minifier import minify, unparse
+from python_minifier.ast_annotation import add_parent
+from python_minifier.rename import add_namespace
+
+from subprocess_compat import run_subprocess, safe_decode
+
+
+# minify() tests
+
+def test_minify_default_uses_newlines():
+    """Default behavior uses newlines between module-level statements."""
+    source = '''
+a = 1
+b = 2
+c = 3
+'''
+    expected = 'a=1\nb=2\nc=3'
+    assert minify(source) == expected
+
+
+def test_minify_prefer_single_line_false_uses_newlines():
+    """prefer_single_line=False uses newlines between module-level statements."""
+    source = '''
+a = 1
+b = 2
+c = 3
+'''
+    expected = 'a=1\nb=2\nc=3'
+    assert minify(source, prefer_single_line=False) == expected
+
+
+def test_minify_prefer_single_line_true_uses_semicolons():
+    """prefer_single_line=True uses semicolons between module-level statements."""
+    source = '''
+a = 1
+b = 2
+c = 3
+'''
+    expected = 'a=1;b=2;c=3'
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_single_statement_no_trailing_separator():
+    """Single statement has no trailing separator regardless of option."""
+    source = 'a = 1'
+    expected = 'a=1'
+    assert minify(source, prefer_single_line=False) == expected
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_empty_module():
+    """Empty module produces empty output."""
+    source = ''
+    expected = ''
+    assert minify(source, prefer_single_line=False) == expected
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_function_body_uses_semicolons():
+    """Function body statements use semicolons regardless of option."""
+    source = '''
+def f():
+    a = 1
+    b = 2
+    return a + b
+'''
+    # Both produce identical output since the option only affects module level
+    expected = 'def f():A=1;B=2;return A+B'
+    assert minify(source, prefer_single_line=False) == expected
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_class_body_uses_semicolons():
+    """Class body statements use semicolons regardless of option."""
+    source = '''
+class C:
+    a = 1
+    b = 2
+'''
+    # Both produce identical output since the option only affects module level
+    expected = 'class C:a=1;b=2'
+    assert minify(source, prefer_single_line=False) == expected
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_mixed_module_and_function():
+    """Compound statements like def require newlines regardless of option."""
+    source = '''
+x = 1
+def f():
+    a = 1
+    b = 2
+y = 2
+'''
+    # Both outputs are identical because compound statements require newlines
+    expected = 'x=1\ndef f():A=1;B=2\ny=2'
+    assert minify(source, prefer_single_line=False) == expected
+    assert minify(source, prefer_single_line=True) == expected
+
+
+def test_minify_imports():
+    """Import statements respect prefer_single_line option."""
+    source = '''
+import os
+import sys
+a = 1
+'''
+    # Imports are combined, module-level separator differs
+    expected_newlines = 'import os,sys\na=1'
+    expected_semicolons = 'import os,sys;a=1'
+    assert minify(source, prefer_single_line=False) == expected_newlines
+    assert minify(source, prefer_single_line=True) == expected_semicolons
+
+
+# unparse() tests
+
+def _prepare_module(source):
+    """Parse and annotate a module for unparsing."""
+    module = ast.parse(source)
+    add_parent(module)
+    add_namespace(module)
+    return module
+
+
+def test_unparse_default_uses_newlines():
+    """unparse() default uses newlines."""
+    source = 'a=1\nb=2'
+    expected = 'a=1\nb=2'
+    module = _prepare_module(source)
+    assert unparse(module) == expected
+
+
+def test_unparse_prefer_single_line_false():
+    """unparse() with prefer_single_line=False uses newlines."""
+    source = 'a=1\nb=2'
+    expected = 'a=1\nb=2'
+    module = _prepare_module(source)
+    assert unparse(module, prefer_single_line=False) == expected
+
+
+def test_unparse_prefer_single_line_true():
+    """unparse() with prefer_single_line=True uses semicolons."""
+    source = 'a=1\nb=2'
+    expected = 'a=1;b=2'
+    module = _prepare_module(source)
+    assert unparse(module, prefer_single_line=True) == expected
+
+
+# CLI tests
+
+def test_cli_default_uses_newlines():
+    """CLI without --prefer-single-line uses newlines."""
+    code = 'a = 1\nb = 2\nc = 3'
+    expected = 'a=1\nb=2\nc=3'
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+
+    try:
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier', temp_file
+        ], timeout=30)
+
+        assert result.returncode == 0
+        stdout_text = safe_decode(result.stdout)
+        assert stdout_text == expected
+    finally:
+        os.unlink(temp_file)
+
+
+def test_cli_prefer_single_line_flag():
+    """CLI with --prefer-single-line uses semicolons."""
+    code = 'a = 1\nb = 2\nc = 3'
+    expected = 'a=1;b=2;c=3'
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+        f.write(code)
+        temp_file = f.name
+
+    try:
+        result = run_subprocess([
+            sys.executable, '-m', 'python_minifier',
+            '--prefer-single-line', temp_file
+        ], timeout=30)
+
+        assert result.returncode == 0
+        stdout_text = safe_decode(result.stdout)
+        assert stdout_text == expected
+    finally:
+        os.unlink(temp_file)
+
+
+def test_cli_stdin_prefer_single_line():
+    """CLI --prefer-single-line works with stdin."""
+    code = 'a = 1\nb = 2\nc = 3'
+    expected = 'a=1;b=2;c=3'
+
+    result = run_subprocess([
+        sys.executable, '-m', 'python_minifier',
+        '--prefer-single-line', '-'
+    ], input_data=code, timeout=30)
+
+    assert result.returncode == 0
+    stdout_text = safe_decode(result.stdout)
+    assert stdout_text == expected