Zed IDE: обзор нового редактора от создателей Atom

"""
Модуль для фильтрации текста от нежелательных слов и фраз.
"""

import re
from typing import List, Optional
from config import Config


class TextFilter:
    """Класс для фильтрации текста от нежелательных слов."""

    def __init__(self, config: Optional[Config] = None, bad_words: Optional[List[str]] = None, replacement_char: Optional[str] = None):
        """
        Инициализация фильтра.

        Args:
            config: Объект конфигурации (приоритет над остальными параметрами)
            bad_words: Список нежелательных слов/фраз
            replacement_char: Символ для замены
        """
        self.config = config or Config()
        self.bad_words = bad_words or self.config.get_bad_words()
        self.replacement_char = replacement_char or self.config.get_replacement_char()

    def _get_default_bad_words(self) -> List[str]:
        """Возвращает список нежелательных фраз по умолчанию."""
        return [
            "php лучше python",
            "пишу код без тестов",
            "Stack Overflow умер",
            "люблю xml",
            "верстаю на диванах",
            "дебажу в проде",
            "всё работает, не трогай",
            "написал свой фреймворк",
            "просто добавь AI",
            "джава лучше всех",
            "всё на jQuery",
            "css — это просто",
            "мне не нужен ваш git",
            "главное — чтобы запускалось",
            "типизация мешает творчеству"
        ]

    def filter_text(self, text: str, case_sensitive: Optional[bool] = None) -> str:
        """
        Фильтрует текст, заменяя нежелательные слова на символы замены.

        Args:
            text: Текст для фильтрации
            case_sensitive: Учитывать ли регистр при поиске (None - использовать из конфига)

        Returns:
            Отфильтрованный текст
        """
        if not text:
            return text

        # Определяем чувствительность к регистру
        is_case_sensitive = case_sensitive if case_sensitive is not None else self.config.is_case_sensitive()

        filtered_text = text

        for bad_word in self.bad_words:
            pattern = re.escape(bad_word)
            replacement = self.replacement_char * len(bad_word)

            if is_case_sensitive:
                filtered_text = re.sub(pattern, replacement, filtered_text)
            else:
                filtered_text = re.sub(pattern, replacement, filtered_text, flags=re.IGNORECASE)

        return filtered_text

    def add_bad_word(self, word: str, category: Optional[str] = None, save_to_config: bool = True) -> None:
        """
        Добавляет новое нежелательное слово в список.

        Args:
            word: Слово для добавления
            category: Категория слова (опционально)
            save_to_config: Сохранять ли изменения в конфиг
        """
        if word and word not in self.bad_words:
            self.bad_words.append(word)
            if save_to_config:
                self.config.add_bad_word(word, category)

    def remove_bad_word(self, word: str, category: Optional[str] = None, save_to_config: bool = True) -> bool:
        """
        Удаляет слово из списка нежелательных.

        Args:
            word: Слово для удаления
            category: Категория слова (опционально)
            save_to_config: Сохранять ли изменения в конфиг

        Returns:
            True если слово было удалено, False если его не было в списке
        """
        try:1
            self.bad_words.remove(word)
            if save_to_config:
                self.config.remove_bad_word(word, category)
            return True
        except ValueError:
            return False

    def get_bad_words(self) -> List[str]:
        """Возвращает копию списка нежелательных слов."""
        return self.bad_words.copy()

    def set_replacement_char(self, char: str, save_to_config: bool = True) -> None:
        """
        Устанавливает новый символ замены.

        Args:
            char: Новый символ замены
            save_to_config: Сохранять ли изменения в конфиг
        """
        self.replacement_char = char
        if save_to_config:
            self.config.set_replacement_char(char)


    def load_category_words(self, category: str) -> None:
        """Загружает слова из определённой категории."""
        category_words = self.config.get_bad_words(category)
        self.bad_words = category_words

    def get_categories(self) -> List[str]:
        """Возвращает список доступных категорий."""
        return self.config.get_categories()

    def save_config(self) -> bool:
        """Сохраняет текущую конфигурацию."""
        return self.config.save_config()


def get_user_input() -> str:
    """Получает ввод от пользователя."""
    try:
        return input("Введите текст: ")
    except (KeyboardInterrupt, EOFError):
        print("\nВвод отменён пользователем.")
        return ""


def display_result(original_text: str, filtered_text: str) -> None:
    """Отображает результат фильтрации."""
    print("\n" + "="*50)
    print("РЕЗУЛЬТАТ ФИЛЬТРАЦИИ:")
    print("="*50)
    print(f"Исходный текст: {original_text}")
    print(f"Отфильтрованный: {filtered_text}")
    print("="*50)


def interactive_menu(text_filter: TextFilter) -> None:
    """Интерактивное меню для управления фильтром."""
    while True:
        print("\n" + "="*50)
        print("МЕНЮ УПРАВЛЕНИЯ ФИЛЬТРОМ")
        print("="*50)
        print("1. Фильтровать текст")
        print("2. Просмотреть нежелательные слова")
        print("3. Добавить нежелательное слово")
        print("4. Удалить нежелательное слово")
        print("5. Изменить символ замены")
        print("6. Просмотреть категории")
        print("7. Загрузить слова категории")
        print("8. Сохранить конфигурацию")
        print("0. Выход")
        print("-" * 50)

        try:
            choice = input("Выберите опцию (0-8): ").strip()

            if choice == "0":
                print("До свидания! ????")
                break
            elif choice == "1":
                user_text = get_user_input()
                if user_text:
                    filtered_text = text_filter.filter_text(user_text)
                    display_result(user_text, filtered_text)
            elif choice == "2":
                bad_words = text_filter.get_bad_words()
                print(f"\nТекущие нежелательные слова ({len(bad_words)}):")
                for i, word in enumerate(bad_words, 1):
                    print(f"{i}. {word}")
            elif choice == "3":
                word = input("Введите нежелательное слово: ").strip()
                if word:
                    text_filter.add_bad_word(word)
                    print(f"✅ Слово '{word}' добавлено!")
            elif choice == "4":
                word = input("Введите слово для удаления: ").strip()
                if text_filter.remove_bad_word(word):
                    print(f"✅ Слово '{word}' удалено!")
                else:
                    print(f"❌ Слово '{word}' не найдено!")
            elif choice == "5":
                char = input("Введите новый символ замены: ").strip()
                if char:
                    text_filter.set_replacement_char(char)
                    print(f"✅ Символ замены изменён на '{char}'!")
            elif choice == "6":
                categories = text_filter.get_categories()
                print(f"\nДоступные категории ({len(categories)}):")
                for i, cat in enumerate(categories, 1):
                    print(f"{i}. {cat}")
            elif choice == "7":
                categories = text_filter.get_categories()
                if categories:
                    print("Доступные категории:")
                    for i, cat in enumerate(categories, 1):
                        print(f"{i}. {cat}")
                    try:
                        cat_index = int(input("Выберите номер категории: ")) - 1
                        if 0 <= cat_index < len(categories):
                            text_filter.load_category_words(categories[cat_index])
                            print(f"✅ Загружены слова категории '{categories[cat_index]}'!")
                        else:
                            print("❌ Неверный номер категории!")
                    except ValueError:
                        print("❌ Введите корректный номер!")
                else:
                    print("❌ Категории не найдены!")
            elif choice == "8":
                if text_filter.save_config():
                    print("✅ Конфигурация сохранена!")
                else:
                    print("❌ Ошибка сохранения конфигурации!")
            else:
                print("❌ Неверный выбор! Попробуйте снова.")

        except (KeyboardInterrupt, EOFError):
            print("\n\nДо свидания! ????")
            break
        except Exception as e:
            print(f"❌ Произошла ошибка: {e}")


def main():
    """Основная функция программы."""
    print("???? Фильтр нежелательных слов v2.0")
    print("-" * 40)

    try:
        # Создаём экземпляр фильтра с конфигурацией
        config = Config()
        text_filter = TextFilter(config=config)

        # Показываем краткую информацию
        print(f"???? Загружено {len(text_filter.bad_words)} нежелательных слов")
        print(f"???? Символ замены: '{text_filter.replacement_char}'")

        # Запускаем интерактивное меню
        interactive_menu(text_filter)

    except Exception as e:
        print(f"❌ Критическая ошибка: {e}")
        print("Использование базовых настроек...")

        # Fallback к базовому функционалу
        text_filter = TextFilter()
        user_text = get_user_input()

        if user_text:
            filtered_text = text_filter.filter_text(user_text)
            display_result(user_text, filtered_text)


if __name__ == "__main__":
    main()