whitespace-format 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

{whitespace_format-0.0.4.dist-info → whitespace_format-0.0.6.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: whitespace-format
-Version: 0.0.4
+Version: 0.0.6
 Summary: Linter and formatter for source code files and text files
 Home-page: https://github.com/DavidPal/whitespace-format
 License: MIT
 Author: David Pal
 Author-email: davidko.pal@gmail.com
-Requires-Python: >=3.7.2,<4.0.0
+Requires-Python: >=3.8.0,<4.0.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -14,6 +14,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Project-URL: Repository, https://github.com/DavidPal/whitespace-format
 Description-Content-Type: text/markdown
 
@@ -49,7 +51,7 @@ second time (with the same parameters) has no effect.
 pip install whitespace-format
 ```
 
-Installation requires Python 3.7.5 or higher.
+Installation requires Python 3.8.0 or higher.
 
 ## Usage
 
@@ -61,17 +63,18 @@ whitespace-format \
     --normalize-new-line-markers \
     foo.txt  my_project/
 ```
-The command above formats `foo.txt` and all files contained `my_project/` and
-its subdirectories. Files that contain `.git/` or `.idea/` in their (relative)
-path are excluded. For example, files in `my_project/.git/` and files in
-`my_project/.idea/` are excluded. Likewise, files ending with `*.pyc` are
-excluded.
-
-If you want only know if any changes **would be** made, add `--check-only` option:
+The command above formats `foo.txt` and all files contained in `my_project/`
+directory and its subdirectories. Files that contain `.git/` or `.idea/` in
+their (relative) path are excluded. For example, files in `my_project/.git/`
+and files in `my_project/.idea/` are excluded. Likewise, files ending with
+`*.pyc` are excluded.
+
+If you want to know only if any changes **would be** made, add `--check-only`
+option:
 ```shell
 whitespace-format \
-    --exclude ".git/|.idea/|.pyc$" \
     --check-only \
+    --exclude ".git/|.idea/|.pyc$" \
     --new-line-marker linux \
     --normalize-new-line-markers \
     foo.txt  my_project/
@@ -93,20 +96,21 @@ The regular expression is evaluated on the path of each file.
 
 * `--add-new-line-marker-at-end-of-file` -- Add missing new line marker at end of each file.
 * `--remove-new-line-marker-from-end-of-file` -- Remove all new line marker(s) from the end of each file.
-This option is ignored when `--add-new-line-marker-at-end-of-file` is used.
-Empty lines at the end of the file are removed.
+This option cannot be used in combination with `--add-new-line-marker-at-end-of-file`.
+Empty lines at the end of the file are removed, i.e., this option implies `--remove-trailing-empty-lines`
+option.
 * `--normalize-new-line-markers` -- Make new line markers consistent in each file
-by replacing `\\r\\n`, `\\n`, and `\r` with a consistent new line marker.
+by replacing `\r\n`, `\n`, and `\r` with a consistent new line marker.
 * `--remove-trailing-whitespace` -- Remove whitespace at the end of each line.
 * `--remove-trailing-empty-lines` -- Remove empty lines at the end of each file.
-* `--new-line-marker=MARKER` -- This option specifies what new line marker to use.
-`MARKER` must be one of the following:
+* `--new-line-marker=MARKER` -- This option specifies what new line marker to when
+adding or replacing new line markers. `MARKER` must be one of the following:
   * `auto` -- Use new line marker that is the most common in each individual file.
   If no new line marker is present in the file, Linux `\n` is used.
   This is the default option.
-  * `linux` -- Use Linux new line marker `\\n`.
-  * `mac` -- Use Mac new line marker `\\r`.
-  * `windows` -- Use Windows new line marker `\\r\\n`.
+  * `linux` -- Use Linux new line marker `\n`.
+  * `mac` -- Use Mac new line marker `\r`.
+  * `windows` -- Use Windows new line marker `\r\n`.
 * `--encoding` -- Text encoding for both reading and writing files. Default encoding is `utf-8`.
 List of supported encodings can be found at
 https://docs.python.org/3/library/codecs.html#standard-encodings
@@ -161,7 +165,7 @@ Default value is `-1`.
 
 * `--normalize-non-standard-whitespace=MODE` -- Replace or remove
 non-standard whitespace characters (`\v` and `\f`). `MODE` must be one of the following:
-  * `ignore` -- Leave `\v` and `f` as is. This is the default option.
+  * `ignore` -- Leave `\v` and `\f` as is. This is the default option.
   * `replace` -- Replace any occurrence of `\v` or `\f` with a single space.
   * `remove` -- Remove all occurrences of `\v` and `\f`
 
@@ -181,13 +185,7 @@ MIT
     brew install poetry
     ```
 
-3) Create Python virtual environment with the correct Python version:
-   ```shell
-   make install-python
-   make create-environment
-   ```
-
-4) Add the following lines to `.zshrc` or `.bash_profile` and restart the terminal:
+3) Add the following lines to `.zshrc` or `.bash_profile` and restart the terminal:
    ```shell
    # Pyenv settings
    export PYENV_ROOT="$HOME/.pyenv"
@@ -196,6 +194,12 @@ MIT
    eval "$(pyenv virtualenv-init -)"
    ```
 
+4) Create Python virtual environment with the correct Python version:
+   ```shell
+   make install-python
+   make create-environment
+   ```
+
 5) Install all dependencies
     ```shell
     make install-dependecies

whitespace_format-0.0.6.dist-info/RECORD

@@ -0,0 +1,6 @@
+whitespace_format.py,sha256=Z-h8ePtLgn82M8Sj0OqdcIg1FNGqqkzmW23lJx4IE7E,28946
+whitespace_format-0.0.6.dist-info/LICENSE,sha256=rT6UNfWDYFQc-eo65FioDJRMAyVOndtF95wNCUhkK74,1076
+whitespace_format-0.0.6.dist-info/METADATA,sha256=lz3cNbXeyuTD4sTVINHswLIUNjPM3gL98bYScrAYt0k,10399
+whitespace_format-0.0.6.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+whitespace_format-0.0.6.dist-info/entry_points.txt,sha256=LbXoevzUZAF5MVbI2foNC9xeDjKS_Woz7VbA1ZNF5CY,60
+whitespace_format-0.0.6.dist-info/RECORD,,

{whitespace_format-0.0.4.dist-info → whitespace_format-0.0.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.7.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

whitespace_format.py

@@ -3,7 +3,8 @@
 """Formatter of whitespace in text files.
 
 Author: David Pal <davidko.pal@gmail.com>
-Date: 2023
+Date: 2023 - 2024
+License: MIT License
 
 Usage:
 
@@ -13,21 +14,37 @@ Usage:
 from __future__ import annotations
 
 import argparse
-import copy
 import dataclasses
 import pathlib
 import re
 import sys
-from typing import Callable
-from typing import Dict
+from enum import Enum
 from typing import List
+from typing import Tuple
 
-VERSION = "0.0.4"
+VERSION = "0.0.6"
 
 # Regular expression that does NOT match any string.
 UNMATCHABLE_REGEX = "$."
 
-END_OF_LINE_MARKERS = {
+# Whitespace characters
+CARRIAGE_RETURN = "\r"
+LINE_FEED = "\n"
+SPACE = " "
+TAB = "\t"
+VERTICAL_TAB = "\v"
+FORM_FEED = "\f"
+
+WHITESPACE_CHARACTERS = {
+    CARRIAGE_RETURN,
+    LINE_FEED,
+    SPACE,
+    TAB,
+    VERTICAL_TAB,
+    FORM_FEED,
+}
+
+NEW_LINE_MARKERS = {
     "windows": "\r\n",
     "linux": "\n",
     "mac": "\r",
@@ -59,403 +76,471 @@ COLORS = {
     "WHITE": "\033[97m",
 }
 
+ESCAPE_TRANSLATION_TABLE = str.maketrans(
+    {
+        CARRIAGE_RETURN: "\\r",
+        LINE_FEED: "\\n",
+        TAB: "\\t",
+        VERTICAL_TAB: "\\v",
+        FORM_FEED: "\\f",
+    }
+)
 
-def color_print(message: str, parsed_arguments: argparse.Namespace):
-    """Outputs a colored message."""
-    if parsed_arguments.quiet:
-        return
-    for color, code in COLORS.items():
-        if parsed_arguments.color:
-            message = message.replace(f"[{color}]", code)
-        else:
-            message = message.replace(f"[{color}]", "")
-    print(message)
 
+class ChangeType(Enum):
+    """Type of change that happened to a file."""
 
-def die(error_code: int, message: str = ""):
-    """Exits the script."""
-    if message:
-        print(message)
-    sys.exit(error_code)
+    # New line marker was added to the end of the file (because it was missing).
+    ADDED_NEW_LINE_MARKER_TO_END_OF_FILE = 1
 
+    # New line marker was removed from the end of the file.
+    REMOVED_NEW_LINE_MARKER_FROM_END_OF_FILE = 2
 
-def read_file_content(file_name: str, encoding: str) -> str:
-    """Reads content of a file."""
-    try:
-        with open(file_name, "r", encoding=encoding) as file:
-            return file.read()
-    except IOError as exception:
-        die(2, f"Cannot read file '{file_name}': {exception}")
-    except UnicodeError as exception:
-        die(3, f"Cannot decode file '{file_name}': {exception}")
-    return ""
+    # New line marker was replaced by another one.
+    REPLACED_NEW_LINE_MARKER = 3
 
+    # White at the end of a line was removed.
+    REMOVED_TRAILING_WHITESPACE = 4
 
-def write_file(file_name: str, file_content: str, encoding: str):
-    """Writes data to a file."""
-    try:
-        with open(file_name, "w", encoding=encoding) as file:
-            file.write(file_content)
-    except IOError as exception:
-        die(4, f"Cannot write to file '{file_name}': {exception}")
+    # Empty line(s) at the end of file were removed.
+    REMOVED_EMPTY_LINES = 5
 
+    # An empty file was replaced by a file consisting of single empty line.
+    REPLACED_EMPTY_FILE_WITH_ONE_LINE = 6
 
-@dataclasses.dataclass
-class Line:
-    """Line of a text file.
+    # A file consisting of only whitespace was replaced by an empty file.
+    REPLACED_WHITESPACE_ONLY_FILE_WITH_EMPTY_FILE = 7
 
-    The line is split into two parts:
-        1) Content
-        2) End of line marker ("\n", or "\r", or "\r\n")
-    """
+    # A file consisting of only whitespace was replaced by a file consisting of single empty line.
+    REPLACED_WHITESPACE_ONLY_FILE_WITH_ONE_LINE = 8
 
-    content: str
-    end_of_line_marker: str
+    # A tab character was replaces by space character(s).
+    REPLACED_TAB_WITH_SPACES = 9
 
-    @staticmethod
-    def create_from_string(line: str) -> Line:
-        """Creates a line from a string.
+    # A tab character was removed.
+    REMOVED_TAB = 10
 
-        The function splits the input into content and end_of_line_marker.
-        """
-        for end_of_line_marker in ["\r\n", "\n", "\r"]:
-            if line.endswith(end_of_line_marker):
-                return Line(line[: -len(end_of_line_marker)], end_of_line_marker)
-        return Line(line, "")
+    # A non-standard whitespace character (`\f` or `\v`) was replaced by a space character.
+    REPLACED_NONSTANDARD_WHITESPACE = 11
 
+    # A non-standard whitespace character (`\f` or `\v`) was removed.
+    REMOVED_NONSTANDARD_WHITESPACE = 12
 
-def split_lines(text: str) -> List[Line]:
-    """Splits a string into lines."""
-    lines: List[Line] = []
-    current_line = ""
-    for i, char in enumerate(text):
-        current_line += char
-        if (char == "\n") or (
-            (char == "\r") and ((i >= len(text) - 1) or (not text[i + 1] == "\n"))
-        ):
-            lines.append(Line.create_from_string(current_line))
-            current_line = ""
 
-    if current_line:
-        lines.append(Line.create_from_string(current_line))
+@dataclasses.dataclass
+class Change:
+    """Description of a change of the content of a file."""
 
-    return lines
+    change_type: ChangeType
+    line_number: int
+    changed_from: str = ""
+    changed_to: str = ""
 
+    def message(self, check_only: bool) -> str:
+        """Returns a message describing the change."""
+        check_only_word = " would be " if check_only else " "
 
-def concatenate_lines(lines: List[Line]) -> str:
-    """Concatenates a list of lines into a single string including end-of-line markers."""
-    return "".join(line.content + line.end_of_line_marker for line in lines)
+        if self.change_type == ChangeType.ADDED_NEW_LINE_MARKER_TO_END_OF_FILE:
+            return f"New line marker{check_only_word}added to the end of the file."
 
+        if self.change_type == ChangeType.REMOVED_NEW_LINE_MARKER_FROM_END_OF_FILE:
+            return f"New line marker{check_only_word}removed from the end of the file."
 
-def guess_end_of_line_marker(lines: List[Line]) -> str:
-    """Guesses the end of line marker.
+        if self.change_type == ChangeType.REPLACED_NEW_LINE_MARKER:
+            return (
+                f"New line marker '{escape_chars(self.changed_from)}'"
+                f"{check_only_word}replaced by '{escape_chars(self.changed_to)}'."
+            )
 
-    The function returns the most common end-of-line marker.
-    Ties are broken in order Linux "\n", Mac "\r", Windows "\r\n".
-    If no end-of-line marker is present, default to the Linux "\n" end-of-line marker.
-    """
-    counts: Dict[str, int] = {"\n": 0, "\r": 0, "\r\n": 0}
-    for line in lines:
-        if line.end_of_line_marker in counts:
-            counts[line.end_of_line_marker] += 1
-    max_count = max(counts.values())
-    for end_of_line_marker, count in counts.items():
-        if count == max_count:
-            return end_of_line_marker
-    return "\n"  # This return statement is never executed.
-
-
-def remove_trailing_empty_lines(lines: List[Line]) -> List[Line]:
-    """Removes trailing empty lines.
-
-    If there are no lines, empty list is returned.
-    If all lines are empty, the first line is kept.
-    """
-    num_empty_trailing_lines = 0
-    while (num_empty_trailing_lines < len(lines) - 1) and (
-        not lines[-num_empty_trailing_lines - 1].content
-    ):
-        num_empty_trailing_lines += 1
-    return copy.deepcopy(lines[: len(lines) - num_empty_trailing_lines])
+        if self.change_type == ChangeType.REMOVED_TRAILING_WHITESPACE:
+            return f"Trailing whitespace{check_only_word}removed."
 
+        if self.change_type == ChangeType.REMOVED_EMPTY_LINES:
+            return f"Empty line(s) at the end of the file{check_only_word}removed."
 
-def remove_dummy_lines(lines: List[Line]) -> List[Line]:
-    """Remove empty lines that also have empty end-of-line markers."""
-    return [line for line in lines if line.content or line.end_of_line_marker]
+        if self.change_type == ChangeType.REPLACED_EMPTY_FILE_WITH_ONE_LINE:
+            return f"Empty file{check_only_word}replaced with a single empty line."
 
+        if self.change_type == ChangeType.REPLACED_WHITESPACE_ONLY_FILE_WITH_EMPTY_FILE:
+            return f"File{check_only_word}replaced with an empty file."
 
-def remove_trailing_whitespace(lines: List[Line]) -> List[Line]:
-    """Removes trailing whitespace from every line."""
-    lines = [
-        Line(
-            re.sub(r"[ \n\r\t\f\v]*$", "", line.content),
-            line.end_of_line_marker,
-        )
-        for line in lines
-    ]
-    return remove_dummy_lines(lines)
+        if self.change_type == ChangeType.REPLACED_WHITESPACE_ONLY_FILE_WITH_ONE_LINE:
+            return f"File{check_only_word}replaced with a single empty line."
 
+        if self.change_type == ChangeType.REPLACED_TAB_WITH_SPACES:
+            return f"Tab{check_only_word}replaced with spaces."
 
-def normalize_end_of_line_markers(lines: List[Line], new_end_of_line_marker: str) -> List[Line]:
-    """Replaces end-of-line marker in all lines with a new end-of-line marker.
+        if self.change_type == ChangeType.REMOVED_TAB:
+            return f"Tab{check_only_word}removed."
 
-    Lines without end-of-line markers (i.e. possibly the last line) are left unchanged.
-    """
-    return [
-        Line(line.content, new_end_of_line_marker) if line.end_of_line_marker else line
-        for line in lines
-    ]
+        if self.change_type == ChangeType.REPLACED_NONSTANDARD_WHITESPACE:
+            return (
+                f"Non-standard whitespace character '{escape_chars(self.changed_from)}'"
+                f"{check_only_word}replaced by a space."
+            )
 
+        if self.change_type == ChangeType.REMOVED_NONSTANDARD_WHITESPACE:
+            return f"Non-standard whitespace character '{escape_chars(self.changed_from)}'{check_only_word}removed."
 
-def remove_all_end_of_line_markers_from_end_of_file(lines: List[Line]) -> List[Line]:
-    """Removes all end-of-line markers from the end of the file."""
-    lines = remove_trailing_empty_lines(lines)
-    if not lines:
-        return []
-    lines[-1] = Line(lines[-1].content, "")
-    return remove_dummy_lines(lines)
+        raise ValueError(f"Unknown change type: {self.change_type}")
 
+    def color_print(self, parsed_arguments: argparse.Namespace) -> None:
+        """Prints a message in color."""
+        color_print(
+            f"[BOLD][BLUE]↳ line {self.line_number + 1}: "
+            f"[WHITE]{self.message(parsed_arguments.check_only)}[RESET_ALL]",
+            parsed_arguments,
+        )
 
-def add_end_of_line_marker_at_end_of_file(
-    lines: List[Line], new_end_of_line_marker: str
-) -> List[Line]:
-    """Adds new end-of-line marker to the end of file if it is missing."""
-    if not lines:
-        return [Line("", new_end_of_line_marker)]
-    lines = copy.deepcopy(lines)
-    lines[-1] = Line(lines[-1].content, new_end_of_line_marker)
-    return lines
 
+def color_print(message: str, parsed_arguments: argparse.Namespace):
+    """Outputs a colored message."""
+    if parsed_arguments.quiet:
+        return
+    for color, code in COLORS.items():
+        if parsed_arguments.color:
+            message = message.replace(f"[{color}]", code)
+        else:
+            message = message.replace(f"[{color}]", "")
+    print(message)
 
-def normalize_empty_file(lines: List[Line], mode: str, new_end_of_line_marker: str) -> List[Line]:
-    """Replaces file with an empty file."""
-    if mode == "empty":
-        return []
-    if mode == "one-line":
-        return [Line("", new_end_of_line_marker)]
-    return copy.deepcopy(lines)
 
+def escape_chars(text: str) -> str:
+    """Escapes special characters in a string."""
+    return text.translate(ESCAPE_TRANSLATION_TABLE)
 
-def is_whitespace_only(lines: List[Line]) -> bool:
-    """Determines if file consists only of whitespace."""
-    for line in lines:
-        if line.content.strip(" \n\r\t\v\f"):
-            return False
-    return True
 
+def string_to_hex(text: str) -> str:
+    """Converts a string into a human-readable hexadecimal representation.
 
-def normalize_non_standard_whitespace(lines: List[Line], mode: str) -> List[Line]:
-    """Removes non-standard whitespace characters."""
-    if mode == "ignore":
-        return copy.deepcopy(lines)
-    if mode == "replace":
-        return [
-            Line(line.content.translate(str.maketrans("\v\f", "  ", "")), line.end_of_line_marker)
-            for line in lines
-        ]
-    return [
-        Line(line.content.translate(str.maketrans("", "", "\v\f")), line.end_of_line_marker)
-        for line in lines
-    ]
+    This function is for debugging purposes only. It is used only during development.
+    """
+    return ":".join(f"{ord(character):02x}" for character in text)
 
 
-def replace_tabs_with_spaces(lines: List[Line], num_spaces: int) -> List[Line]:
-    """Replaces tabs with spaces."""
-    if num_spaces < 0:
-        return copy.deepcopy(lines)
-    return [
-        Line(line.content.replace("\t", num_spaces * " "), line.end_of_line_marker)
-        for line in lines
-    ]
+def die(error_code: int, message: str = ""):
+    """Exits the script."""
+    if message:
+        print(message)
+    sys.exit(error_code)
 
 
-def compute_difference(original_lines: List[Line], new_lines: List[Line]) -> List[int]:
-    """Computes the indices of lines that differ."""
-    line_numbers = [
-        line_number
-        for line_number, (original_line, new_line) in enumerate(zip(original_lines, new_lines))
-        if not original_line == new_line
-    ]
-    if len(original_lines) != len(new_lines):
-        line_numbers.append(min(len(original_lines), len(new_lines)))
-    return line_numbers
+def read_file_content(file_name: str, encoding: str) -> str:
+    """Reads content of a file.
 
+    New line markers are preserved in their original form.
+    """
+    try:
+        with open(file_name, "r", encoding=encoding, newline="") as file:
+            return file.read()
+    except IOError as exception:
+        die(2, f"Cannot read file '{file_name}': {exception}")
+    except UnicodeError as exception:
+        die(3, f"Cannot decode file '{file_name}': {exception}")
+    return ""
 
-@dataclasses.dataclass
-class ChangeDescription:
-    """Description of a change of the content of a file."""
 
-    check_only: str
-    change: str
+def write_file(file_name: str, file_content: str, encoding: str):
+    """Writes data to a file."""
+    try:
+        with open(file_name, "w", encoding=encoding) as file:
+            file.write(file_content)
+    except IOError as exception:
+        die(4, f"Cannot write to file '{file_name}': {exception}")
 
 
-@dataclasses.dataclass
-class LineChange:
-    """Description of a change on a particular line."""
+def is_whitespace_only(text: str) -> bool:
+    """Determines if a string consists of only whitespace characters."""
+    for char in text:
+        if char not in WHITESPACE_CHARACTERS:
+            return False
+    return True
 
-    check_only: str
-    change: str
-    line_number: int
 
+def find_most_common_new_line_marker(text: str) -> str:
+    """Returns the most common new line marker in a string.
 
-class FileContentTracker:
-    """Tracks changes of the content of a file as it undergoes formatting."""
+    If there are ties, prefer Linux '\n' to Windows '\r\n' to Mac '\r'.
+    If there are no new line markers, return Linux.
 
-    def __init__(self, lines: List[Line]):
-        """Initializes an instance of the file content tracker."""
-        self.initial_lines = lines
-        self.lines = copy.deepcopy(lines)
-        self.line_changes: List[LineChange] = []
+    Args:
+        text: A string.
+
+    Returns:
+        Either '\n', or '\r\n' or '\r'.
+    """
+    linux_count = 0
+    mac_count = 0
+    windows_count = 0
+    i = 0
 
-    def format(self, change: ChangeDescription, function: Callable[..., List[Line]], *args):
-        """Applies a change to the content of the file."""
-        previous_content = self.lines
-        self.lines = function(self.lines, *args)
-        if previous_content != self.lines:
-            line_numbers = compute_difference(previous_content, self.lines)
-            for line_number in line_numbers:
-                self.line_changes.append(LineChange(change.check_only, change.change, line_number))
+    while i < len(text):
+        if text[i] == CARRIAGE_RETURN:
+            if i < len(text) - 1 and text[i + 1] == LINE_FEED:
+                windows_count += 1
+                i += 1
+            else:
+                mac_count += 1
+        elif text[i] == LINE_FEED:
+            linux_count += 1
+        i += 1
 
-    def is_changed(self) -> bool:
-        """Determines if the file content has changed."""
-        return self.lines != self.initial_lines
+    if mac_count > windows_count and mac_count > linux_count:
+        return "\r"
+
+    if windows_count > linux_count:
+        return "\r\n"
+
+    return "\n"
 
 
 def format_file_content(
-    file_content_tracker: FileContentTracker,
+    file_content: str,
     parsed_arguments: argparse.Namespace,
-):
-    """Formats the content of file represented as a string."""
-    new_line_marker = END_OF_LINE_MARKERS.get(
+) -> Tuple[str, List[Change]]:
+    """Formats content of a file.
+
+    The formatting options are specified in the parsed_arguments.
+
+    Args:
+        file_content: Content of the file.
+        parsed_arguments: Parsed command line arguments.
+
+    Returns:
+        A pair consisting of the formatted file content and a list of changes.
+    """
+    output_new_line_marker = NEW_LINE_MARKERS.get(
         parsed_arguments.new_line_marker,
-        guess_end_of_line_marker(file_content_tracker.initial_lines),
+        find_most_common_new_line_marker(file_content),
     )
 
-    if is_whitespace_only(file_content_tracker.initial_lines):
-        changes = {
-            "ignore": ChangeDescription("", ""),
-            "empty": ChangeDescription(
-                check_only="File needs to be replaced with an empty file.",
-                change="File was replaced with an empty file.",
-            ),
-            "one-line": ChangeDescription(
-                check_only=(
-                    f"File must be replaced with a single-line empty line {repr(new_line_marker)}."
-                ),
-                change=(
-                    f"File was replaced with a single-line empty line {repr(new_line_marker)}."
-                ),
-            ),
-        }
-        if not file_content_tracker.initial_lines:
-            file_content_tracker.format(
-                changes[parsed_arguments.normalize_empty_files],
-                normalize_empty_file,
-                parsed_arguments.normalize_empty_files,
-                new_line_marker,
-            )
-        else:
-            file_content_tracker.format(
-                changes[parsed_arguments.normalize_whitespace_only_files],
-                normalize_empty_file,
-                parsed_arguments.normalize_whitespace_only_files,
-                new_line_marker,
-            )
-
-    else:
-        if parsed_arguments.remove_trailing_whitespace:
-            file_content_tracker.format(
-                ChangeDescription(
-                    check_only="Whitespace at the end of line needs to be removed.",
-                    change="Whitespace at the end of line was removed.",
-                ),
-                remove_trailing_whitespace,
-            )
+    # Handle empty file:
+    if not file_content:
+        if parsed_arguments.normalize_empty_files in ["ignore", "empty"]:
+            return "", []
+        if parsed_arguments.normalize_empty_files == "one-line":
+            return output_new_line_marker, [Change(ChangeType.REPLACED_EMPTY_FILE_WITH_ONE_LINE, 1)]
+
+    # Handle non-empty file consisting of whitespace only.
+    if is_whitespace_only(file_content):
+        if parsed_arguments.normalize_whitespace_only_files == "empty":
+            return "", [Change(ChangeType.REPLACED_WHITESPACE_ONLY_FILE_WITH_EMPTY_FILE, 1)]
+        if parsed_arguments.normalize_whitespace_only_files == "one-line":
+            if file_content == output_new_line_marker:
+                return file_content, []
+            return output_new_line_marker, [
+                Change(ChangeType.REPLACED_WHITESPACE_ONLY_FILE_WITH_ONE_LINE, 1)
+            ]
+        if parsed_arguments.normalize_whitespace_only_files == "ignore":
+            return file_content, []
+
+    # Index into the input buffer.
+    i = 0
+
+    # List of changes
+    changes: List[Change] = []
+
+    # Line number. It is incremented every time we encounter a new end of line marker.
+    line_number = 1
+
+    # Position one character past the end of last line in the output buffer
+    # including the last end of line marker.
+    last_end_of_line_including_eol_marker = 0
+
+    # Position one character past the last non-whitespace character in the output buffer.
+    last_non_whitespace = 0
+
+    # Position one character past the end of last non-empty line in the output buffer
+    # excluding the last end of line marker.
+    last_end_of_non_empty_line_excluding_eol_marker = 0
+
+    # Position one character past the end of last non-empty line in the output buffer,
+    # including the last end of line marker.
+    last_end_of_non_empty_line_including_eol_marker = 0
+
+    # Line number of the last non-empty line.
+    last_non_empty_line_number = 0
+
+    # Formatted output
+    output = ""
+
+    while i < len(file_content):
+        if file_content[i] in [CARRIAGE_RETURN, LINE_FEED]:
+            # Parse the new line marker
+            new_line_marker = ""
+            if file_content[i] == LINE_FEED:
+                new_line_marker = LINE_FEED
+            elif i < len(file_content) - 1 and file_content[i + 1] == LINE_FEED:
+                new_line_marker = "\r\n"
+                # Windows new line marker consists of two characters.
+                # Skip the extra character.
+                i += 1
+            else:
+                new_line_marker = CARRIAGE_RETURN
+
+            # Remove trailing whitespace
+            if parsed_arguments.remove_trailing_whitespace and max(
+                last_non_whitespace, last_end_of_line_including_eol_marker
+            ) < len(output):
+                changes.append(
+                    Change(
+                        ChangeType.REMOVED_TRAILING_WHITESPACE,
+                        line_number,
+                    )
+                )
+                output = output[
+                    : max(
+                        last_non_whitespace,
+                        last_end_of_line_including_eol_marker,
+                    )
+                ]
+
+            # Determine if the last line is empty
+            is_empty_line: bool = last_end_of_line_including_eol_marker == len(output)
+
+            # Position one character past the end of last line in the output buffer
+            # excluding the last end of line marker.
+            last_end_of_line_excluding_eol_marker = len(output)
+
+            # Add new line marker
+            if (
+                parsed_arguments.normalize_new_line_markers
+                and output_new_line_marker != new_line_marker
+            ):
+                changes.append(
+                    Change(
+                        ChangeType.REPLACED_NEW_LINE_MARKER,
+                        line_number,
+                        new_line_marker,
+                        output_new_line_marker,
+                    )
+                )
+                output += output_new_line_marker
+            else:
+                output += new_line_marker
 
-        if parsed_arguments.remove_trailing_empty_lines:
-            file_content_tracker.format(
-                ChangeDescription(
-                    check_only="Empty line(s) at the end of file need to be removed.",
-                    change="Empty line(s) at the end of file were removed.",
-                ),
-                remove_trailing_empty_lines,
-            )
+            last_end_of_line_including_eol_marker = len(output)
 
-        file_content_tracker.format(
-            ChangeDescription(
-                check_only="Tabs need to be replaced with spaces.",
-                change="Tabs were replaced by spaces.",
-            ),
-            replace_tabs_with_spaces,
-            parsed_arguments.replace_tabs_with_spaces,
-        )
+            # Update position of last non-empty line.
+            if not is_empty_line:
+                last_end_of_non_empty_line_excluding_eol_marker = (
+                    last_end_of_line_excluding_eol_marker
+                )
+                last_end_of_non_empty_line_including_eol_marker = (
+                    last_end_of_line_including_eol_marker
+                )
+                last_non_empty_line_number = line_number
+
+            line_number += 1
+
+        elif file_content[i] == SPACE:
+            output += file_content[i]
+
+        elif file_content[i] == TAB:
+            if parsed_arguments.replace_tabs_with_spaces < 0:
+                output += file_content[i]
+            elif parsed_arguments.replace_tabs_with_spaces > 0:
+                changes.append(Change(ChangeType.REPLACED_TAB_WITH_SPACES, line_number))
+                output += SPACE * parsed_arguments.replace_tabs_with_spaces
+            else:
+                # Remove the tab character.
+                changes.append(Change(ChangeType.REMOVED_TAB, line_number))
+
+        elif file_content[i] in [VERTICAL_TAB, FORM_FEED]:
+            if parsed_arguments.normalize_non_standard_whitespace == "ignore":
+                output += file_content[i]
+            elif parsed_arguments.normalize_non_standard_whitespace == "replace":
+                output += SPACE
+                changes.append(
+                    Change(
+                        ChangeType.REPLACED_NONSTANDARD_WHITESPACE,
+                        line_number,
+                        file_content[i],
+                        SPACE,
+                    )
+                )
+            elif parsed_arguments.normalize_non_standard_whitespace == "remove":
+                changes.append(
+                    Change(
+                        ChangeType.REMOVED_NONSTANDARD_WHITESPACE, line_number, file_content[i], ""
+                    )
+                )
+            else:
+                raise ValueError("Unknown value of normalize_non_standard_whitespace")
+        else:
+            output += file_content[i]
+            last_non_whitespace = len(output)
 
-        file_content_tracker.format(
-            ChangeDescription(
-                check_only=(
-                    "Non-standard whitespace characters need to be removed or replaced by spaces."
-                ),
-                change="Non-standard whitespace characters were removed or replaced by spaces.",
-            ),
-            normalize_non_standard_whitespace,
-            parsed_arguments.normalize_non_standard_whitespace,
-        )
+        # Move to the next character
+        i += 1
 
-        if parsed_arguments.normalize_new_line_markers:
-            file_content_tracker.format(
-                ChangeDescription(
-                    check_only=(
-                        f"New line marker(s) need to be replaced with {repr(new_line_marker)}."
-                    ),
-                    change=f"New line marker(s) were replaced with {repr(new_line_marker)}.",
-                ),
-                normalize_end_of_line_markers,
-                new_line_marker,
-            )
+    # Remove trailing whitespace from the last line.
+    if (
+        parsed_arguments.remove_trailing_whitespace
+        and last_end_of_line_including_eol_marker < len(output)
+        and last_non_whitespace < len(output)
+    ):
+        changes.append(Change(ChangeType.REMOVED_TRAILING_WHITESPACE, line_number))
+        output = output[:last_non_whitespace]
+
+    # Remove trailing empty lines.
+    if (
+        parsed_arguments.remove_trailing_empty_lines
+        and last_end_of_line_including_eol_marker == len(output)
+        and last_end_of_non_empty_line_including_eol_marker < len(output)
+    ):
+        line_number = last_non_empty_line_number + 1
+        last_end_of_line_including_eol_marker = last_end_of_non_empty_line_including_eol_marker
+        changes.append(Change(ChangeType.REMOVED_EMPTY_LINES, line_number))
+        output = output[:last_end_of_non_empty_line_including_eol_marker]
+
+    # Add new line marker at the end of the file
+    if (
+        parsed_arguments.add_new_line_marker_at_end_of_file
+        and last_end_of_line_including_eol_marker < len(output)
+    ):
+        changes.append(Change(ChangeType.ADDED_NEW_LINE_MARKER_TO_END_OF_FILE, line_number))
+        output += output_new_line_marker
+        last_end_of_line_including_eol_marker = len(output)
+        line_number += 1
+
+    # Remove new line marker(s) from the end of the file
+    if (
+        parsed_arguments.remove_new_line_marker_from_end_of_file
+        and last_end_of_line_including_eol_marker == len(output)
+        and line_number >= 2
+    ):
+        line_number = last_non_empty_line_number
+        changes.append(Change(ChangeType.REMOVED_NEW_LINE_MARKER_FROM_END_OF_FILE, line_number))
+        output = output[:last_end_of_non_empty_line_excluding_eol_marker]
 
-        if parsed_arguments.add_new_line_marker_at_end_of_file:
-            file_content_tracker.format(
-                ChangeDescription(
-                    check_only=f"New line marker needs to be added to the end of the file, "
-                    f"or replaced with {repr(new_line_marker)}.",
-                    change=f"New line marker was added to the end of the file, "
-                    f"or replaced with {repr(new_line_marker)}.",
-                ),
-                add_end_of_line_marker_at_end_of_file,
-                new_line_marker,
-            )
-        elif parsed_arguments.remove_new_line_marker_from_end_of_file:
-            file_content_tracker.format(
-                ChangeDescription(
-                    check_only="New line marker(s) need to removed from the end of the file.",
-                    change="New line marker(s) were removed from the end of the file.",
-                ),
-                remove_all_end_of_line_markers_from_end_of_file,
-            )
+    return output, changes
 
 
 def reformat_file(file_name: str, parsed_arguments: argparse.Namespace) -> bool:
-    """Reformats a file."""
+    """Reformats a file.
+
+    Args:
+        file_name: Name of the file to reformat.
+        parsed_arguments: Parsed command line arguments.
+
+    Returns:
+         True if the file was changed, False otherwise.
+    """
     file_content = read_file_content(file_name, parsed_arguments.encoding)
-    lines = split_lines(file_content)
-    file_content_tracker = FileContentTracker(lines)
-    format_file_content(file_content_tracker, parsed_arguments)
-    is_changed = file_content_tracker.is_changed()
+    formatted_file_content, file_changes = format_file_content(file_content, parsed_arguments)
     if parsed_arguments.verbose:
-        color_print(f"Processing file '{file_name}'...", parsed_arguments)
+        color_print(f"[WHITE]Processing file [BOLD]{file_name}[RESET_ALL]...", parsed_arguments)
     if parsed_arguments.check_only:
-        if is_changed:
+        if file_changes:
             color_print(
                 f"[RED]✘[RESET_ALL] [BOLD][WHITE]{file_name} "
                 f"[RED]needs to be formatted[RESET_ALL]",
                 parsed_arguments,
             )
-            for line_change in file_content_tracker.line_changes:
-                color_print(
-                    f"   [BOLD][BLUE]↳ line {line_change.line_number + 1}: "
-                    f"[WHITE]{line_change.check_only}[RESET_ALL]",
-                    parsed_arguments,
-                )
+            for line_change in file_changes:
+                print("   ", end="")
+                line_change.color_print(parsed_arguments)
         else:
             if parsed_arguments.verbose:
                 color_print(
@@ -464,21 +549,21 @@ def reformat_file(file_name: str, parsed_arguments: argparse.Namespace) -> bool:
                     parsed_arguments,
                 )
     else:
-        if is_changed:
+        if file_changes:
             color_print(f"[WHITE]Reformatted [BOLD]{file_name}[RESET_ALL]", parsed_arguments)
-            for line_change in file_content_tracker.line_changes:
-                color_print(
-                    f"   [BOLD][BLUE]↳ line {line_change.line_number + 1}: "
-                    f"[WHITE]{line_change.change}[RESET_ALL]",
-                    parsed_arguments,
-                )
+            for line_change in file_changes:
+                print("   ", end="")
+                line_change.color_print(parsed_arguments)
             write_file(
-                file_name, concatenate_lines(file_content_tracker.lines), parsed_arguments.encoding
+                file_name,
+                formatted_file_content,
+                parsed_arguments.encoding,
             )
         else:
             if parsed_arguments.verbose:
-                color_print(f"[WHITE]{file_name} [BLUE]left unchanged[RESET_ALL]", parsed_arguments)
-    return is_changed
+                color_print(f"[WHITE]Unchanged [BOLD]{file_name}[RESET_ALL]", parsed_arguments)
+
+    return bool(file_changes)
 
 
 def reformat_files(file_names: List[str], parsed_arguments: argparse.Namespace):
@@ -571,20 +656,24 @@ def parse_command_line() -> argparse.Namespace:
         default="utf-8",
         type=str,
     )
-    parser.add_argument(
+
+    # Mutually exclusive group of parameters.
+    group1 = parser.add_mutually_exclusive_group()
+    group1.add_argument(
         "--verbose",
         help="Print more messages than normally.",
         required=False,
         action="store_true",
         default=False,
     )
-    parser.add_argument(
+    group1.add_argument(
         "--quiet",
         help="Do not print any messages, except for errors when reading or writing files.",
         required=False,
         action="store_true",
         default=False,
     )
+
     parser.add_argument(
         "--color",
         help="Print messages in color.",
@@ -622,6 +711,10 @@ def parse_command_line() -> argparse.Namespace:
             "mac: Use Mac new line marker '\\r'. "
             "windows: Use Windows new line marker '\\r\\n'. "
         ),
+        required=False,
+        type=str,
+        choices=["auto", "linux", "mac", "windows"],
+        default="auto",
     )
     parser.add_argument(
         "--normalize-new-line-markers",
@@ -661,20 +754,27 @@ def parse_command_line() -> argparse.Namespace:
         default="ignore",
         choices=["ignore", "empty", "one-line"],
     )
-    parser.add_argument(
+
+    # Mutually exclusive group of parameters.
+    group2 = parser.add_mutually_exclusive_group()
+    group2.add_argument(
         "--add-new-line-marker-at-end-of-file",
         help="Add missing new line marker at end of each file.",
         required=False,
         default=False,
         action="store_true",
     )
-    parser.add_argument(
+    group2.add_argument(
         "--remove-new-line-marker-from-end-of-file",
-        help="Remove new line markers from the end of each file.",
+        help="Remove new line markers from the end of each file. "
+        "This option conflicts with --add-new-line-marker-at-end-of-file. "
+        "This option implies --remove-trailing-empty-lines option, i.e., "
+        "all empty lines at the end of the file are removed.",
         required=False,
         default=False,
         action="store_true",
     )
+
     parser.add_argument(
         "--remove-trailing-whitespace",
         help="Remove whitespace at the end of each line.",
@@ -684,7 +784,8 @@ def parse_command_line() -> argparse.Namespace:
     )
     parser.add_argument(
         "--remove-trailing-empty-lines",
-        help="Remove empty lines at the end of each file.",
+        help="Remove empty lines at the end of each file. "
+        "If --remove-new-line-marker-from-end-of-file is used, this option is used automatically.",
         required=False,
         default=False,
         action="store_true",
@@ -721,8 +822,8 @@ def parse_command_line() -> argparse.Namespace:
     if parsed_arguments.normalize_whitespace_only_files == "empty":
         parsed_arguments.normalize_empty_files = parsed_arguments.normalize_whitespace_only_files
 
-    if parsed_arguments.verbose:
-        parsed_arguments.quiet = False
+    if parsed_arguments.remove_new_line_marker_from_end_of_file:
+        parsed_arguments.remove_empty_lines = True
 
     return parsed_arguments
 

whitespace_format-0.0.4.dist-info/RECORD

@@ -1,6 +0,0 @@
-whitespace_format.py,sha256=cSM_YnzCNsJjPGz-b9HVINv3TT8YK8C51m5RePwPNCk,25434
-whitespace_format-0.0.4.dist-info/LICENSE,sha256=rT6UNfWDYFQc-eo65FioDJRMAyVOndtF95wNCUhkK74,1076
-whitespace_format-0.0.4.dist-info/METADATA,sha256=Dk2GpHPm2ll_EvKpMxFCP86MCyU49rkYr43wBkZ7D7Q,10172
-whitespace_format-0.0.4.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-whitespace_format-0.0.4.dist-info/entry_points.txt,sha256=LbXoevzUZAF5MVbI2foNC9xeDjKS_Woz7VbA1ZNF5CY,60
-whitespace_format-0.0.4.dist-info/RECORD,,