obfuscator-rb 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 631dc474ce83763052076cc0859f85012e0e79a623d4394ffc1485152d92ae41
+  data.tar.gz: 0b6f3963a2f67f29f4f84ea226f181331a77802bfdab22046b802c5ea9df82ab
+SHA512:
+  metadata.gz: 694433e45c631fc851840d63af7f8dceff5d77da72b28a0818a3cbb5001c9456e55c45c10d3597e53b6b55e7a6eb29bc1aada13edad2ded2f53a85bf906458fc
+  data.tar.gz: d7bcd0e7b17e725c782a92a9ed865c7f78dc03e9b7afd8d10afe3725cf4a46080839e3abcd5fe756fd18853b74a7db96f572ec3e483ae10b5f67eaa1c8e9dbcc

data/.rubocop.yml

@@ -0,0 +1,55 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+  Exclude:
+    - "bin/**/*"
+    - ".git/**/*"
+    - ".bundle/**/*"
+    - ".vscode/**/*"
+    - ".ruby-lsp/**/*"
+    - "vendor/**/*"
+  SuggestExtensions: false
+
+require:
+  - rubocop-minitest
+  - rubocop-performance
+
+Naming/FileName:
+  Exclude:
+    - 'lib/obfuscator-rb.rb'
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_first_argument
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/ClassLength:
+  Max: 140
+  Exclude:
+    - "test/*"
+
+Metrics/BlockLength:
+  Max: 50
+
+Metrics/MethodLength:
+  Max: 60
+
+Metrics/AbcSize:
+  Max: 40
+  Exclude:
+    - "test/*"
+
+Metrics/PerceivedComplexity:
+  Max: 35
+
+Metrics/CyclomaticComplexity:
+  Max: 30

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.1] - 2025-02-07
+### Fixed
+- Restored proper deterministic behavior for sequential obfuscation calls when using seed
+- Fixed language detection for capitalized words
+- Added test coverage for sequential determinism with seeds
+
+## [0.3.0] - 2025-02-07
+### Changed
+- Renamed gem from 'obfuscator' to 'obfuscator-rb' for RubyGems.org publication
+- Restructured main entry point for better gem compatibility
+- Updated documentation to reflect new gem name
+
+## [0.2.0] - 2025-02-06
+### Added
+- DateObfuscator class for handling date obfuscation
+- Support for various date formats (EU, ISO, Russian)
+- Configurable date constraints (year range, month/weekday preservation)
+- Random number generation, array and range sampling helper methods
+
+### Changed
+- Refactored internal RNG handling for better maintainability and consistency
+- Fixed seed handling to ensure proper reproducibility of results
+
+## [0.1.0] - 2025-02-03
+### Added
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 ad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,225 @@
+# Obfuscator
+
+[Русский](#русский) | [English](#english)
+
+## Русский
+
+Ruby-гем для обфускации текста. Сохраняет структуру, заменяя содержимое бессмысленными словами, сохраняющими при этом
+естественный вид исходного текста. Поддерживает русский и английский языки.
+
+### Установка
+
+Добавьте эту строку в Gemfile вашего приложения:
+
+```ruby
+gem 'obfuscator-rb', git: 'https://hub.mos.ru/ad/obfuscator.git'
+```
+
+И выполните:
+
+```bash
+$ bundle install
+```
+
+Или установите самостоятельно:
+
+```bash
+$ gem install obfuscator-rb
+```
+
+### Возможности
+
+- Сохраняет структуру текста (пунктуация, пробелы, регистр)
+- Сохраняет длину слов (если не включена натурализация)
+- Поддерживает несколько режимов обфускации
+- Опциональная натурализация текста по некоторым простым правилам
+- Необратимая трансформация текста
+- Детерминированный вывод при использовании сида
+- Полная поддержка UTF-8
+- Обеспечена обработка ошибок определённых типов данных
+
+### Использование
+
+```ruby
+require 'obfuscator-rb'
+
+# Базовое использование (режим :direct по умолчанию)
+obfuscator = Obfuscator::Multilang.new
+text = "Hello, Привет! This is a TEST текст."
+result = obfuscator.obfuscate(text)
+# => Каждое слово обфусцируется с использованием исходного алфавита
+# => "Idise, Кющэшэ! Izib oq g MUGU дипяд."
+
+# Смешанный режим с обоими алфавитами
+obfuscator = Obfuscator::Multilang.new(mode: :mixed)
+result = obfuscator.obfuscate(text)
+# => Слова могут содержать и латинские, и кириллические символы
+# => "Fаyef, Фeфeгю! Muci лi r HЫЛO ицижё."
+
+# С натурализацией по простым правилам для более естественного вывода
+obfuscator = Obfuscator::Multilang.new(mode: :mixed, naturalize: true)
+result = obfuscator.obfuscate(text)
+# => Вывод обрабатывается для более естественного вида
+# => "Ohеsion, Wорыой! Наvы мe л ЛУНI yeзing."
+
+# С сидом для воспроизводимых результатов
+obfuscator = Obfuscator::Multilang.new(seed: 12345)
+result = obfuscator.obfuscate(text)
+# => Одинаковый ввод + одинаковый сид = одинаковый вывод
+# => "Cumic, Фяцёне! Okac ub h POWO щюзёс."
+```
+
+### Доступные режимы
+
+- `:direct` (по умолчанию) - сохраняет исходный язык для каждого слова
+- `:eng_to_eng` - только английский в английский
+- `:rus_to_rus` - только русский в русский
+- `:swapped` - английский в русский и наоборот
+- `:mixed` - использует оба алфавита (просто ради прикола)
+
+### Обработка входных данных
+
+Обфускатор обрабатывает разлличные типы данных:
+
+- `nil` → возвращает nil
+- Числа → возвращаются без изменений
+- Объекты с методом `to_s` → обрабатываются нормально
+- Объекты без базовых методов Ruby → вызывают `InputError`
+- Неверные кодировки → вызывают `EncodingError`
+
+#### Типы ошибок
+
+- `Obfuscator::Error` - Базовый класс ошибок гема
+- `Obfuscator::InputError` - Возникает при неверном типе входных данных
+- `Obfuscator::EncodingError` - Возникает при проблемах с кодировкой
+
+#### Пример использования с обработкой ошибок
+
+```ruby
+
+begin
+  obfuscator.obfuscate(текст)
+rescue Obfuscator::InputError => e
+  # Обработка неверного типа входных данных
+  puts "Неверный тип данных: #{e.message}"
+rescue Obfuscator::EncodingError => e
+  # Обработка проблем с кодировкой
+  puts "Ошибка кодировки: #{e.message}"
+rescue Obfuscator::Error => e
+  # Обработка прочих ошибок обфускации
+  puts "Ошибка обфускации: #{e.message}"
+end
+```
+
+## English
+
+A Ruby gem for text obfuscation that preserves text structure while replacing content with meaningless but
+natural-looking words. Supports both English and Russian languages.
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'obfuscator-rb', git: 'https://hub.mos.ru/ad/obfuscator.git'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install obfuscator-rb
+```
+
+### Features
+
+- Preserves text structure (punctuation, spacing, capitalization)
+- Maintains word lengths (unless naturalization is enabled)
+- Supports multiple obfuscation modes
+- Optional text naturalization according to some basic rules
+- Irreversible transformation
+- Deterministic output with seeds
+- Full UTF-8 support
+- Comprehensive error handling with specific error types
+
+### Usage
+
+```ruby
+require 'obfuscator-rb'
+
+# Basic usage (default :direct mode)
+obfuscator = Obfuscator::Multilang.new
+text = "Hello, Привет! This is a TEST текст."
+result = obfuscator.obfuscate(text)
+# => Each word is obfuscated using its source alphabet
+# => "Idise, Кющэшэ! Izib oq g MUGU дипяд."
+
+# Mixed mode with both alphabets
+obfuscator = Obfuscator::Multilang.new(mode: :mixed)
+result = obfuscator.obfuscate(text)
+# => Words may contain both Latin and Cyrillic characters
+# => "Fаyef, Фeфeгю! Muci лi r HЫЛO ицижё."
+
+# With basic naturalization for more natural-looking output
+obfuscator = Obfuscator::Multilang.new(mode: :mixed, naturalize: true)
+result = obfuscator.obfuscate(text)
+# => Output is processed to look more natural
+# => "Ohеsion, Wорыой! Наvы мe л ЛУНI yeзing."
+
+# With seed for reproducible results
+obfuscator = Obfuscator::Multilang.new(seed: 12345)
+result = obfuscator.obfuscate(text)
+# => Same input + same seed = same output
+# => "Cumic, Фяцёне! Okac ub h POWO щюзёс."
+```
+
+### Available Modes
+
+- `:direct` (default) - preserves source language for each word
+- `:eng_to_eng` - English to English only
+- `:rus_to_rus` - Russian to Russian only
+- `:swapped` - English to Russian and vice versa
+- `:mixed` - uses both alphabets (just for fun)
+
+### Input Handling
+
+The obfuscator handles various input types:
+
+- `nil` → returns nil
+- Numbers → returns unchanged
+- Objects responding to `to_s` → processes normally
+- Objects without basic Ruby methods → raises `InputError`
+- Invalid encodings → raises `EncodingError`
+
+#### Error Types
+
+- `Obfuscator::Error` - Base error class for the gem
+- `Obfuscator::InputError` - Raised for invalid input types
+- `Obfuscator::EncodingError` - Raised for encoding-related issues
+
+#### Example Usage with Error Handling
+
+```ruby
+
+begin
+  obfuscator.obfuscate(text)
+rescue Obfuscator::InputError => e
+  # Handle invalid input types
+  puts "Invalid input: #{e.message}"
+rescue Obfuscator::EncodingError => e
+  # Handle encoding issues
+  puts "Encoding error: #{e.message}"
+rescue Obfuscator::Error => e
+  # Handle other obfuscation errors
+  puts "Obfuscation failed: #{e.message}"
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
+
+Minitest::TestTask.create
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/obfuscator/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Obfuscator
+  module Constants
+    ENGLISH_CONSONANTS = %w[b c d f g h j k l m n p q r s t v w x y z].freeze
+    ENGLISH_VOWELS = %w[a e i o u].freeze
+
+    RUSSIAN_CONSONANTS = %w[б в г д ж з к л м н п р с т ф х ц ч ш щ].freeze
+    RUSSIAN_VOWELS = %w[а е ё и о у ы э ю я].freeze
+
+    # Impossible combinations in both languages
+    IMPOSSIBLE_COMBINATIONS = %w[
+      щщ щц щч щж щш щх
+      жщ жж жц жч
+      цщ цж цч
+      чщ чж чц
+      th щ th ж th ц th ч
+      wa щ wa ж wa ц wa ч
+    ].freeze
+
+    # Typical Russian word endings
+    RUSSIAN_ENDINGS = %w[
+      ый ой ая ое ые ий ь
+      ость ение ство ация
+    ].freeze
+
+    # Typical English word endings
+    ENGLISH_ENDINGS = %w[
+      ing ed ly tion sion
+      ment ness ful less
+    ].freeze
+  end
+end

data/lib/obfuscator/date_obfuscator.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'date'
+require_relative 'internal/rng'
+
+module Obfuscator
+  # Class for obfuscating dates while preserving their format and optionally some properties.
+  #
+  # Supports various date formats through presets or custom format strings.
+  # Can preserve certain date characteristics (month, weekday) and respect year constraints.
+  # All generated dates are valid - for example, it won't generate February 31st.
+  #
+  # @example Basic usage with preset format
+  #   obfuscator = DateObfuscator.new
+  #   obfuscator.obfuscate('2023-12-31')  # => "2025-07-15"
+  #
+  # @example With custom format string
+  #   obfuscator = DateObfuscator.new(format: '%Y-%m-%d')
+  #   obfuscator.obfuscate('2023-12-31')  # => "2025-07-15"
+  #
+  # @example With constraints
+  #   obfuscator = DateObfuscator.new(
+  #     constraints: {
+  #       min_year: 2020,        # Minimum year to generate
+  #       max_year: 2025,        # Maximum year to generate
+  #       preserve_month: true,   # Keep the same month
+  #       preserve_weekday: true  # Keep the same day of week
+  #     }
+  #   )
+  #
+  # @example With seed for reproducible results
+  #   obfuscator = DateObfuscator.new(seed: 12345)
+  #   obfuscator.obfuscate('2023-12-31')  # => Same result for same seed
+  #
+  # Available preset formats:
+  # - :eu        => '%d.%m.%Y'  # 31.12.2023
+  # - :eu_short  => '%d.%m.%y'  # 31.12.23
+  # - :rus       => '%d.%m.%Y'  # 31.12.2023
+  # - :rus_short => '%d.%m.%y'  # 31.12.23
+  # - :iso       => '%Y-%m-%d'  # 2023-12-31
+  #
+  # @param format [Symbol, String] Preset format name or custom format string (default: :iso)
+  # @param seed [Integer, nil] Optional seed for reproducible results
+  # @param constraints [Hash] Optional constraints for date generation
+  # @option constraints [Integer] :min_year Minimum year to generate (default: 2000)
+  # @option constraints [Integer] :max_year Maximum year to generate (default: 2030)
+  # @option constraints [Boolean] :preserve_month Keep the same month (default: false)
+  # @option constraints [Boolean] :preserve_weekday Keep the same day of week (default: false)
+  #
+  # @raise [Error] If date string is invalid or doesn't match the format
+  class DateObfuscator
+    include Internal::RNG
+
+    PRESET_FORMATS = {
+      eu:        '%d.%m.%Y', # 31.12.2023
+      eu_short:  '%d.%m.%y', # 31.12.23
+      rus:       '%d.%m.%Y', # 31.12.2023
+      rus_short: '%d.%m.%y', # 31.12.23
+      iso:       '%Y-%m-%d' # 2023-12-31
+    }.freeze
+
+    def initialize(format: :iso, seed: nil, constraints: {})
+      setup_rng(seed)
+      @format = PRESET_FORMATS[format] || format
+      @constraints = default_constraints.merge(constraints)
+    end
+
+    def obfuscate(date_string)
+      return date_string if date_string.nil? || date_string.empty?
+
+      begin
+        date = ::Date.strptime(date_string, @format)
+        obfuscated_date = generate_date(date)
+        obfuscated_date.strftime(@format)
+      rescue ArgumentError => e
+        raise Error, "Invalid date or format: #{e.message}"
+      end
+    end
+
+    private
+
+    def default_constraints
+      {
+        min_year:         2000,
+        max_year:         2030,
+        preserve_month:   false,
+        preserve_weekday: false
+      }
+    end
+
+    def generate_date(original_date)
+      year = random_year
+      month = @constraints[:preserve_month] ? original_date.month : random_month
+      day = random_day(year, month, original_date)
+
+      ::Date.new(year, month, day)
+    end
+
+    def random_year
+      random_range(@constraints[:min_year]..@constraints[:max_year])
+    end
+
+    def random_month
+      random_range(1..12)
+    end
+
+    def random_day(year, month, original_date)
+      days_in_month = ::Date.new(year, month, -1).day
+
+      if @constraints[:preserve_weekday]
+        # Find a day that falls on the same weekday
+        target_weekday = original_date.wday
+        possible_days = (1..days_in_month).select do |d|
+          ::Date.new(year, month, d).wday == target_weekday
+        end
+        random_sample(possible_days)
+      else
+        random_range(1..days_in_month)
+      end
+    end
+  end
+end

data/lib/obfuscator/internal/rng.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Obfuscator
+  module Internal
+    # Internal module providing Random Number Generation functionality.
+    # This module is intended for internal use only and shouldn't be used directly by gem users.
+    #
+    # Provides consistent random number generation across the gem's classes,
+    # with optional seed support for reproducible results.
+    #
+    # @api private
+    #
+    # Usage:
+    #   include Internal::RNG
+    #
+    #   def initialize(seed = nil)
+    #     setup_rng(seed)
+    #   end
+    #
+    #   private
+    #
+    #   def some_method
+    #     random_sample(some_array)      # For array sampling
+    #     random_probability             # For random float between 0 and 1
+    #     random_range(some_range)       # For range sampling
+    #   end
+    module RNG
+      private
+
+      def setup_rng(seed = nil)
+        @rng = seed.nil? ? Random.new : Random.new(seed)
+      end
+
+      def random_sample(array)
+        array.sample(random: @rng)
+      end
+
+      def random_probability
+        @rng.rand
+      end
+
+      def random_range(range)
+        @rng.rand(range)
+      end
+    end
+  end
+end

data/lib/obfuscator/multilang.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'internal/rng'
+require_relative 'naturalizer'
+
+module Obfuscator
+  # A class responsible for obfuscating text in Russian and English languages.
+  #
+  # This class provides various modes for obfuscating text while preserving the original
+  # text structure, whitespace, punctuation, and capitalization. The obfuscation can be
+  # performed in several modes and optionally naturalized to produce more readable output.
+  #
+  # Available modes:
+  # - MODE_DIRECT (default): Preserves language, replacing words with same-language random words
+  # - MODE_ENG_TO_ENG: Only obfuscates English words, leaves Russian untouched
+  # - MODE_RUS_TO_RUS: Only obfuscates Russian words, leaves English untouched
+  # - MODE_SWAPPED: Swaps languages (English→Russian and Russian→English)
+  # - MODE_MIXED: Generates words containing both English and Russian characters
+  #
+  # @example Basic usage
+  #   obfuscator = Multilang.new
+  #   obfuscator.obfuscate("Hello world!") # => "Kites mefal!"
+  #
+  # @example Using swapped mode with naturalization
+  #   obfuscator = Multilang.new(mode: :swapped, naturalize: true)
+  #   obfuscator.obfuscate("Hello мир!") # => "Привет world!"
+  #
+  # @param mode [Symbol] The obfuscation mode to use (default: MODE_DIRECT)
+  # @param seed [Integer, nil] Optional seed for reproducible results
+  # @param naturalize [Boolean] Whether to naturalize the output (default: false)
+  #
+  # @raise [InputError] If input doesn't respond to :to_s
+  # @raise [EncodingError] If input has invalid encoding
+  # @raise [Error] If obfuscation fails for any other reason
+  class Multilang
+    include Constants
+    include Internal::RNG
+
+    MODE_DIRECT = :direct # 1:1 obfuscation, the default
+    MODE_ENG_TO_ENG = :eng_to_eng # eng/rus → eng/rus untouched
+    MODE_RUS_TO_RUS = :rus_to_rus # eng/rus → eng untouched/rus
+    MODE_SWAPPED = :swapped # eng→rus and rus→eng
+    MODE_MIXED = :mixed # eng/rus → eng+rus mix just for fun
+
+    def initialize(mode: MODE_DIRECT, seed: nil, naturalize: false)
+      @mode = mode
+      @seed = seed # Store the seed
+      setup_rng(seed)
+      @naturalizer = Naturalizer.new(seed) if naturalize
+    end
+
+    def obfuscate(input)
+      # Reset RNG state before each obfuscation if seed was provided
+      setup_rng(@seed) if @seed
+
+      raise InputError, 'Input must respond to :to_s' unless input.respond_to?(:to_s)
+      return input if input.nil? || input.is_a?(Numeric)
+
+      text = input.to_s
+
+      # Ensure UTF-8 encoding
+      begin
+        text = text.encode('UTF-8') unless text.encoding == Encoding::UTF_8
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
+        raise EncodingError, "Encoding error: #{e.message}"
+      end
+
+      # Split preserving all whitespace and punctuation
+      begin
+        tokens = text.split(/(\s+|[[:punct:]])/)
+        tokens.map do |token|
+          if token.match?(/\s+|[[:punct:]]/)
+            token # Preserve whitespace and punctuation
+          else
+            process_word(token)
+          end
+        end.join
+      rescue ArgumentError => e
+        raise EncodingError, "Encoding error: #{e.message}" if e.message.include?('invalid byte sequence')
+
+        raise Error, "Obfuscation error: #{e.message}"
+      rescue StandardError => e
+        raise Error, "Obfuscation error: #{e.message}"
+      end
+    rescue NoMethodError => e
+      raise InputError, "Input must be a Ruby object with basic methods: #{e.message}"
+    end
+
+    private
+
+    def process_word(word)
+      return word if word.empty?
+
+      begin
+        source_lang = detect_language(word)
+        return word if source_lang == :unknown
+
+        result = case @mode
+                 when MODE_ENG_TO_ENG
+                   source_lang == :english ? obfuscate_word(word, :english) : word
+                 when MODE_RUS_TO_RUS
+                   source_lang == :russian ? obfuscate_word(word, :russian) : word
+                 when MODE_SWAPPED
+                   target_lang = source_lang == :english ? :russian : :english
+                   obfuscate_word(word, target_lang)
+                 when MODE_MIXED
+                   obfuscate_mixed_word(word)
+                 when MODE_DIRECT
+                   obfuscate_word(word, source_lang)
+                 else
+                   word
+                 end
+
+        @naturalizer ? @naturalizer.naturalize(result) : result
+      rescue StandardError => e
+        raise Error, "Word processing error for '#{word}': #{e.message}"
+      end
+    end
+
+    def detect_language(word)
+      first_char = word[0]
+      return :russian if first_char.match?(/[а-яёА-ЯЁ]/)
+      return :english if first_char.match?(/[a-zA-Z]/)
+
+      :unknown
+    end
+
+    def obfuscate_word(word, target_lang)
+      # Store capitalization pattern
+      caps_pattern = word.chars.map { |char| char.match?(/[A-ZА-ЯЁ]/) }
+
+      # Generate new word
+      new_word = case target_lang
+                 when :english
+                   generate_english_word(word.length)
+                 when :russian
+                   generate_russian_word(word.length)
+                 end
+
+      # Apply capitalization pattern
+      apply_caps_pattern(new_word, caps_pattern)
+    end
+
+    def obfuscate_mixed_word(word)
+      caps_pattern = word.chars.map { |char| char.match?(/[A-ZА-ЯЁ]/) }
+      new_word = generate_mixed_word(word.length)
+      apply_caps_pattern(new_word, caps_pattern)
+    end
+
+    def generate_english_word(length)
+      generate_word(length, ENGLISH_CONSONANTS, ENGLISH_VOWELS, 0.4)
+    end
+
+    def generate_russian_word(length)
+      generate_word(length, RUSSIAN_CONSONANTS, RUSSIAN_VOWELS, 0.25)
+    end
+
+    def generate_word(length, consonants, vowels, vowel_start_prob)
+      return '' if length.zero?
+
+      result = ''
+      is_vowel = random_probability < vowel_start_prob
+
+      while result.length < length
+        chars = is_vowel ? vowels : consonants
+        result += random_sample(chars)
+        is_vowel = !is_vowel
+      end
+
+      result[0...length]
+    end
+
+    def generate_mixed_word(length)
+      return '' if length.zero?
+
+      is_vowel = random_probability < 0.25
+
+      result = ''
+      while result.length < length
+        # 50/50 chance of Russian or English
+        use_russian = random_probability < 0.5
+
+        # 25/75 chance of vowel for Russian/English
+        # is_vowel = @rng.rand < (use_russian ? 0.25 : 0.4)
+
+        char = if is_vowel
+                 if use_russian
+                   random_sample(RUSSIAN_VOWELS)
+                 else
+                   random_sample(ENGLISH_VOWELS)
+                 end
+               elsif use_russian
+                 random_sample(RUSSIAN_CONSONANTS)
+               else
+                 random_sample(ENGLISH_CONSONANTS)
+               end
+
+        result += char
+        is_vowel = !is_vowel
+      end
+
+      result[0...length]
+    end
+
+    def apply_caps_pattern(word, pattern)
+      word.chars.map.with_index do |c, i|
+        pattern[i] ? c.upcase : c.downcase
+      end.join
+    end
+
+    def random_sample(array)
+      array.sample(random: @rng)
+    end
+
+    def random_probability
+      @rng.rand
+    end
+  end
+end

data/lib/obfuscator/naturalizer.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative 'internal/rng'
+
+module Obfuscator
+  # A class responsible for naturalizing words by applying linguistic rules to make them
+  # more readable and natural-looking while preserving their structure.
+  #
+  # The naturalizer applies several rules to improve readability:
+  # 1. No soft/hard signs (ь/ъ) after Latin letters
+  # 2. No щ after w/th combinations
+  # 3. No й after consonants
+  # 4. No triple consonants (inserts appropriate vowel)
+  # 5. Handles impossible letter combinations
+  # 6. No double vowels
+  # 7. Special handling for ё, ю, я after consonants
+  # 8. Applies appropriate language-specific endings for longer words
+  #
+  # @example Basic usage
+  #   naturalizer = Naturalizer.new
+  #   naturalizer.naturalize("Thщит") # => "Thкит"
+  #
+  # @example With seed for reproducible results
+  #   naturalizer = Naturalizer.new(12345)
+  #   naturalizer.naturalize("Thщит") # => Same result for same seed
+  #
+  # @param seed [Integer, nil] Optional seed for reproducible results
+  #
+  # @see Multilang For the main obfuscation class that uses this naturalizer
+  class Naturalizer
+    include Constants
+    include Internal::RNG
+
+    def initialize(seed = nil)
+      setup_rng(seed)
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
+    def naturalize(word)
+      return word unless word.respond_to?(:to_s)
+      return word if word.length < 2
+
+      begin
+        chars = word.chars
+        result = []
+
+        chars.each_with_index do |char, i|
+          next_char = chars[i + 1]
+
+          if next_char.nil?
+            result << char
+            next
+          end
+
+          # Rule 1: No ь/ъ after Latin letters
+          soft_hard_signs = %w[ь ъ]
+          if latin?(char) && soft_hard_signs.include?(next_char)
+            chars[i + 1] = random_sample(RUSSIAN_CONSONANTS.reject { |c| soft_hard_signs.include?(c) })
+          end
+
+          # Rule 2: No щ after w/th
+          if (char == 'w' || (i.positive? && chars[i - 1] == 't' && char == 'h')) && next_char == 'щ'
+            chars[i + 1] = random_sample(RUSSIAN_CONSONANTS - ['щ'])
+          end
+
+          # Rule 3: No й after consonants
+          chars[i + 1] = random_sample(RUSSIAN_CONSONANTS - ['й']) if consonant?(char) && next_char == 'й'
+
+          # Rule 4: No triple consonants
+          if i < chars.length - 2 &&
+             consonant?(char) &&
+             consonant?(next_char) &&
+             consonant?(chars[i + 2])
+            chars[i + 1] = if cyrillic?(next_char)
+                             random_sample(RUSSIAN_VOWELS)
+                           else
+                             random_sample(ENGLISH_VOWELS)
+                           end
+          end
+
+          # Rule 5: Handle impossible combinations
+          current_pair = char + next_char
+          if IMPOSSIBLE_COMBINATIONS.any? { |combo| current_pair.include?(combo) }
+            chars[i + 1] = if cyrillic?(next_char)
+                             random_sample(RUSSIAN_CONSONANTS)
+                           else
+                             random_sample(ENGLISH_CONSONANTS)
+                           end
+          end
+
+          # Rule 6: No double vowels
+          if vowel?(char) && vowel?(next_char)
+            chars[i + 1] = if cyrillic?(next_char)
+                             random_sample(RUSSIAN_CONSONANTS)
+                           else
+                             random_sample(ENGLISH_CONSONANTS)
+                           end
+          end
+
+          # Rule 7: Handle ё, ю, я after consonants
+          # This rule is a special case of Rule 5
+          soft_vowels = %w[ё ю я]
+          if consonant?(char) && soft_vowels.include?(next_char)
+            chars[i + 1] = random_sample(RUSSIAN_VOWELS - soft_vowels)
+          end
+
+          result << char
+        rescue StandardError => e
+          raise Error, "Naturalization error for '#{word}': #{e.message}"
+        end
+      end
+
+      # Rule 8: Apply appropriate ending if word is long enough
+      final_word = result.join
+      if final_word.length > 4
+        if mostly_russian?(final_word)
+          apply_russian_ending(final_word)
+        elsif mostly_english?(final_word)
+          apply_english_ending(final_word)
+        else
+          final_word
+        end
+      else
+        final_word
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
+
+    private
+
+    def latin?(char)
+      char.match?(/[a-zA-Z]/)
+    end
+
+    def cyrillic?(char)
+      char.match?(/[а-яёА-ЯЁ]/)
+    end
+
+    def consonant?(char)
+      down_char = char.downcase
+      ENGLISH_CONSONANTS.include?(down_char) || RUSSIAN_CONSONANTS.include?(down_char)
+    end
+
+    def vowel?(char)
+      down_char = char.downcase
+      ENGLISH_VOWELS.include?(down_char) || RUSSIAN_VOWELS.include?(down_char)
+    end
+
+    def mostly_russian?(word)
+      russian_chars = word.chars.count { |c| cyrillic?(c) }
+      russian_chars > word.length / 2
+    end
+
+    def mostly_english?(word)
+      english_chars = word.chars.count { |c| latin?(c) }
+      english_chars > word.length / 2
+    end
+
+    def apply_russian_ending(word)
+      return word if word.length < 4
+
+      base = word[0...-2]
+      base + random_sample(RUSSIAN_ENDINGS)
+    end
+
+    def apply_english_ending(word)
+      return word if word.length < 4
+
+      base = word[0...-2]
+      base + random_sample(ENGLISH_ENDINGS)
+    end
+  end
+end

data/lib/obfuscator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Obfuscator
+  VERSION = '0.3.1'
+end

data/lib/obfuscator-rb.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Obfuscator is a text obfuscation library that preserves text structure while replacing content
+# with meaningless but natural-looking words. It supports both English and Russian languages.
+#
+# The gem provides two main obfuscators:
+# - {Multilang} for text obfuscation with multiple language support
+# - {DateObfuscator} for date obfuscation with format preservation
+#
+# @example Basic text obfuscation
+#   require 'obfuscator-rb'
+#
+#   obfuscator = Obfuscator::Multilang.new
+#   obfuscator.obfuscate("Hello, World!") # => "Kites, Mefal!"
+#
+# @example Date obfuscation
+#   date_obf = Obfuscator::DateObfuscator.new
+#   date_obf.obfuscate("2023-12-31") # => "2025-07-15"
+#
+# Error handling is provided through specific error classes:
+# - {Error} Base error class for the gem
+# - {InputError} Raised for invalid input types
+# - {EncodingError} Raised for encoding-related issues
+#
+# @see Multilang For text obfuscation functionality
+# @see DateObfuscator For date obfuscation functionality
+# @see Internal::RNG For random number generation utilities
+
+module Obfuscator
+  class Error < StandardError; end
+  class EncodingError < Error; end
+  class InputError < Error; end
+end
+
+require_relative 'obfuscator/version'
+require_relative 'obfuscator/constants'
+require_relative 'obfuscator/internal/rng'
+require_relative 'obfuscator/naturalizer'
+require_relative 'obfuscator/multilang'
+require_relative 'obfuscator/date_obfuscator'
+
+# Usage example:
+if __FILE__ == $PROGRAM_NAME
+  obfuscator = Obfuscator::Multilang.new(seed: 12_345)
+  original_text = 'Hello, Мир! This is a TEST текст.'
+  obfuscated = obfuscator.obfuscate(original_text)
+
+  puts "Original: #{original_text}"
+  puts "Obfuscated: #{obfuscated}" # 'Cumic, Фяц! Piwi ok c UBOH ричуг.'
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: obfuscator-rb
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Aleksandr Dryzhuk
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-02-19 00:00:00.000000000 Z
+dependencies: []
+description: |
+  A Ruby gem for text obfuscation that preserves text structure while replacing content
+  with meaningless but natural-looking words. Supports both English and Russian languages,
+  with various obfuscation modes and optional text naturalization.
+
+  Гем для обфускации текста, сохраняющий его структуру и естественный вид, но заменяющий при этом содержимое
+  бессмысленными словами. Поддерживает английский и русский языки, различные режимы обфускации и опциональную
+  натурализацию текста.
+email:
+- dev@ad-it.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/obfuscator-rb.rb
+- lib/obfuscator/constants.rb
+- lib/obfuscator/date_obfuscator.rb
+- lib/obfuscator/internal/rng.rb
+- lib/obfuscator/multilang.rb
+- lib/obfuscator/naturalizer.rb
+- lib/obfuscator/version.rb
+homepage: https://hub.mos.ru/ad/obfuscator
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://hub.mos.ru/ad/obfuscator
+  source_code_uri: https://hub.mos.ru/ad/obfuscator
+  changelog_uri: https://hub.mos.ru/ad/obfuscator/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Text obfuscator that preserves structure while working with both English
+  and Russian languages
+test_files: []