💡 Инструкция: Выберите один ответ из пяти. Время — 70 минут. У каждого задания ровно один правильный вариант. Фрагменты рассчитаны на Ruby 4.0.6; задания Rails — на Rails 8.1.3. После завершения откроются общий процент, 5 тематических результатов и разбор всех ответов.
Вопрос 1 из 25
Какой вывод учитывает и возвращаемое значение, и побочный эффект в теме «Режимы открытия»? Оценивайте ответ целиком: обе части утверждения должны быть точными.
Ruby Ruby — Режимы открытия Копировать
# Проследите выполнение и выберите точный результат.
path = 'sample.txt'
File.write(path, 'old')
File.open(path, 'w') { |f| f.write('new') }
p File.read(path)
File.delete(path)
Открытие в `w` стирает прежнее содержимое до записи новой строки. Это объясняется тем, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
После выхода из блока объект файла сообщает `closed? == true`. Это объясняется тем, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Код суммирует числа построчно и не создаёт строку размером со весь файл. Это объясняется тем, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Открытие в `w` стирает прежнее содержимое до записи новой строки. Это объясняется тем, что блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Открытие в `w` стирает прежнее содержимое до записи новой строки. Это объясняется тем, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Вопрос 3 из 25
Какой фактический результат даст этот фрагмент по теме «Работа с путями через Pathname»? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.
Ruby Ruby — Работа с путями через Pathname Копировать
# Проследите выполнение и выберите точный результат.
require 'pathname'
root = Pathname('/srv/app')
path = root.join('logs', '..', 'data.json')
p path.cleanpath.to_s
p path.absolute?
Чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных. Такой итог следует из правила: pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Код суммирует числа построчно и не создаёт строку размером со весь файл. Такой итог следует из правила: pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе. Такой итог следует из правила: режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе. Такой итог следует из правила: pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе. Такой итог следует из правила: блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Вопрос 5 из 25
Что произойдёт после последней строки в примере по теме «Ошибки интеграции»? Правильным считается только полностью согласованное утверждение.
Ruby Ruby — Ошибки интеграции Копировать
# Проследите выполнение и выберите точный результат.
path = 'sample.txt'
File.write(path, 'data')
io = File.open(path)
io.close
begin
io.read
rescue IOError => e
p [e.class, e.message]
end
File.delete(path)
Чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных. Наблюдение согласуется с тем, что ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных. Наблюдение согласуется с тем, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе. Наблюдение согласуется с тем, что ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных. Наблюдение согласуется с тем, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Код суммирует числа построчно и не создаёт строку размером со весь файл. Наблюдение согласуется с тем, что ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Вопрос 6 из 25
Какое скрытое условие делает фрагмент «Режимы открытия» хрупким? В правильном ответе вторая часть действительно объясняет или проверяет первую.
Ruby Ruby — Режимы открытия Копировать
# Обычный запуск проходит. Найдите скрытый риск.
path = 'sample.txt'
File.write(path, 'old')
File.open(path, 'w') { |f| f.write('new') }
p File.read(path)
File.delete(path)
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Причина — режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. Причина — режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. Причина — блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. Причина — pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. Причина — режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Вопрос 7 из 25
Какое допущение делает этот код по теме «Блоковое закрытие» ненадёжным? Верный вариант не содержит частично правильной подмены причины или следствия.
Ruby Ruby — Блоковое закрытие Копировать
# Обычный запуск проходит. Найдите скрытый риск.
path = 'sample.txt'
File.write(path, "a
b
")
file = nil
File.open(path, 'r') do |f|
file = f
p f.gets.chomp
end
p file.closed?
File.delete(path)
Открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby. Этот риск связан с тем, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby. Этот риск связан с тем, что блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby. Этот риск связан с тем, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. Этот риск связан с тем, что блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Этот риск связан с тем, что блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Вопрос 8 из 25
Базовый пример выглядит корректно. Что всё же нарушает контракт в блоке «Работа с путями через Pathname»? Верный вариант не содержит частично правильной подмены причины или следствия.
Ruby Ruby — Работа с путями через Pathname Копировать
# Обычный запуск проходит. Найдите скрытый риск.
require 'pathname'
root = Pathname('/srv/app')
path = root.join('logs', '..', 'data.json')
p path.cleanpath.to_s
p path.absolute?
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Уязвимое место возникает потому, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. Уязвимое место возникает потому, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Уязвимое место возникает потому, что блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. Уязвимое место возникает потому, что pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Уязвимое место возникает потому, что режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Вопрос 9 из 25
Что в реализации по теме «Потоковая обработка» требует исправления прежде всего? Оценивайте ответ целиком: обе части утверждения должны быть точными.
Ruby Ruby — Потоковая обработка Копировать
# Обычный запуск проходит. Найдите скрытый риск.
path = 'numbers.txt'
File.write(path, "10
20
30
")
sum = File.open(path) do |io|
io.each_line.sum { |line| Integer(line, 10) }
end
p sum
File.delete(path)
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. К такому сбою приводит правило: `IO#each_line` читает поток постепенно, тогда как `read` загружает остаток целиком; потоковая обработка ограничивает память.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. К такому сбою приводит правило: режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. К такому сбою приводит правило: `IO#each_line` читает поток постепенно, тогда как `read` загружает остаток целиком; потоковая обработка ограничивает память.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. К такому сбою приводит правило: `IO#each_line` читает поток постепенно, тогда как `read` загружает остаток целиком; потоковая обработка ограничивает память.
Даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив. К такому сбою приводит правило: блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода.
Вопрос 10 из 25
Что может сломаться при переносе этого решения «Ошибки интеграции» в рабочую систему? Оценивайте ответ целиком: обе части утверждения должны быть точными.
Ruby Ruby — Ошибки интеграции Копировать
# Обычный запуск проходит. Найдите скрытый риск.
path = 'sample.txt'
File.write(path, 'data')
io = File.open(path)
io.close
begin
io.read
rescue IOError => e
p [e.class, e.message]
end
File.delete(path)
Общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику. Источник риска: pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог.
Общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику. Источник риска: ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём. Источник риска: ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает. Источник риска: ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст.
Общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику. Источник риска: режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы.
Вопрос 13 из 25
Какой механизм отделяет верный разбор от похожего, но ошибочного объяснения «Работа с путями через Pathname»? Выберите связку, в которой верны и основной вывод, и его обоснование.
Блоковая форма `File.open` закрывает дескриптор при обычном выходе и исключении; без блока ответственность остаётся у вызывающего кода. Наблюдаемое следствие: соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе.
Pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог. Наблюдаемое следствие: соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе.
Pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог. Наблюдаемое следствие: код суммирует числа построчно и не создаёт строку размером со весь файл.
Pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог. Наблюдаемое следствие: чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных.
Режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы. Наблюдаемое следствие: соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе.
Вопрос 15 из 25
Какое свойство Ruby или Rails определяет результат примера «Ошибки интеграции»? Одного совпавшего вывода недостаточно — проверьте также вторую часть ответа.
Ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст. Это правило даёт такой результат: код суммирует числа построчно и не создаёт строку размером со весь файл.
Режим `r` читает существующий файл, `w` создаёт или обнуляет, `a` дописывает; добавление `b` отключает текстовые преобразования платформы. Это правило даёт такой результат: чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных.
Ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст. Это правило даёт такой результат: соединение частей создаёт нормализуемый объект пути, но `cleanpath` не обращается к файловой системе.
Ввод-вывод может завершиться частично, вернуть EOF или поднять системную ошибку; интеграционный код обязан различать эти исходы и сохранять контекст. Это правило даёт такой результат: чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных.
Pathname предоставляет объектные операции над путями, но не делает путь безопасным и не проверяет автоматически выход за корневой каталог. Это правило даёт такой результат: чтение после закрытия файла поднимает IOError, которое показывает ошибку жизненного цикла, а не отсутствие данных.
Вопрос 16 из 25
Какое изменение устраняет причину проблемы в теме «Режимы открытия», а не маскирует симптом? Ищите не знакомые слова, а технически непротиворечивую пару утверждений.
Ruby Ruby — Режимы открытия Копировать
# Выберите изменение, которое исправляет причину.
path = 'sample.txt'
File.write(path, 'old')
File.open(path, 'w') { |f| f.write('new') }
p File.read(path)
File.delete(path)
Для замены важного файла писать во временный файл в том же каталоге, синхронизировать и атомарно переименовывать. Так закрывается риск: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Так закрывается риск: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Для замены важного файла писать во временный файл в том же каталоге, синхронизировать и атомарно переименовывать. Так закрывается риск: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Для замены важного файла писать во временный файл в том же каталоге, синхронизировать и атомарно переименовывать. Так закрывается риск: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Так закрывается риск: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Вопрос 17 из 25
Что следует изменить в решении «Блоковое закрытие», чтобы закрыть исходный риск? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.
Ruby Ruby — Блоковое закрытие Копировать
# Выберите изменение, которое исправляет причину.
path = 'sample.txt'
File.write(path, "a
b
")
file = nil
File.open(path, 'r') do |f|
file = f
p f.gets.chomp
end
p file.closed?
File.delete(path)
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Это изменение устраняет проблему: открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby.
Использовать блоковую форму или ensure для ресурсов с жизненным циклом длиннее одного выражения. Это изменение устраняет проблему: открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby.
Для замены важного файла писать во временный файл в том же каталоге, синхронизировать и атомарно переименовывать. Это изменение устраняет проблему: открытие файлов в цикле без close исчерпывает лимит дескрипторов задолго до исчерпания памяти Ruby.
Использовать блоковую форму или ensure для ресурсов с жизненным циклом длиннее одного выражения. Это изменение устраняет проблему: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Использовать блоковую форму или ensure для ресурсов с жизненным циклом длиннее одного выражения. Это изменение устраняет проблему: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Вопрос 18 из 25
Что нужно поменять, чтобы ошибка «Работа с путями через Pathname» не возвращалась при следующем изменении? Оценивайте ответ целиком: обе части утверждения должны быть точными.
Ruby Ruby — Работа с путями через Pathname Копировать
# Выберите изменение, которое исправляет причину.
require 'pathname'
root = Pathname('/srv/app')
path = root.join('logs', '..', 'data.json')
p path.cleanpath.to_s
p path.absolute?
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Такая правка нужна из-за риска: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Такая правка нужна из-за риска: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Такая правка нужна из-за риска: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора. Такая правка нужна из-за риска: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Такая правка нужна из-за риска: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Вопрос 19 из 25
Какой рефакторинг делает контракт блока «Потоковая обработка» явным и проверяемым? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.
Ruby Ruby — Потоковая обработка Копировать
# Выберите изменение, которое исправляет причину.
path = 'numbers.txt'
File.write(path, "10
20
30
")
sum = File.open(path) do |io|
io.each_line.sum { |line| Integer(line, 10) }
end
p sum
File.delete(path)
Проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора. Решение адресует следующий дефект: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Решение адресует следующий дефект: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора. Решение адресует следующий дефект: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора. Решение адресует следующий дефект: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Решение адресует следующий дефект: даже потоковый ввод теряет преимущество, если результаты каждой строки без ограничения складываются в массив.
Вопрос 20 из 25
Какое инженерное решение лучше всего соответствует механизму «Ошибки интеграции»? Одного совпавшего вывода недостаточно — проверьте также вторую часть ответа.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Именно эта мера закрывает риск: простая проверка строки на `..` не защищает от символических ссылок и различий между логическим и реальным путём.
Для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок. Именно эта мера закрывает риск: общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику.
Для замены важного файла писать во временный файл в том же каталоге, синхронизировать и атомарно переименовывать. Именно эта мера закрывает риск: общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Именно эта мера закрывает риск: использование `w` там, где ожидалось обновление части файла, уничтожает данные даже если последующая запись падает.
Преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты. Именно эта мера закрывает риск: общий rescue, возвращающий пустую строку, превращает недоступный файл в корректный пустой документ и запускает неверную бизнес-логику.
Вопрос 24 из 25
Какой контрпример проверит реальную границу механизма «Потоковая обработка»? Сопоставьте не только итог, но и правило, риск или проверку, которые с ним связаны.
Проверить несуществующий путь: `realpath` потребует существования, а `expand_path` не обнаружит символическую ссылку. Сценарий подтверждает надёжность решения: проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора.
Проверить очень длинную строку без разделителя: построчное чтение тогда всё равно создаст крупный объект. Сценарий подтверждает надёжность решения: проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора.
Проверить гонку «проверили существование — файл исчез»: полагаться нужно на результат самой операции open. Сценарий подтверждает надёжность решения: проектировать обработку как ограниченный конвейер: читать, валидировать, агрегировать или отправлять дальше без накопления всего набора.
Проверить очень длинную строку без разделителя: построчное чтение тогда всё равно создаст крупный объект. Сценарий подтверждает надёжность решения: для доступа внутри корня разрешать конечный реальный путь и проверять его принадлежность доверенному каталогу с учётом ссылок.
Проверить очень длинную строку без разделителя: построчное чтение тогда всё равно создаст крупный объект. Сценарий подтверждает надёжность решения: преобразовывать системную ошибку в доменную только с путём, операцией и причиной, не выдавая содержимое или секреты.