students_list_yaml 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4a1156ccf6aab89dc74f1cfb32eb6069bc558d4363692afbdb76588f505cc14c
+  data.tar.gz: 3e6af363bcceb9bcbfe4088011b29a26ffdc2356989b5c529df72fe18a073f31
+SHA512:
+  metadata.gz: ec4a0460228be9775535087d6dda30f379c60575984726e3a50eca60d7053939c0fcc52d412cad0c0016916bb39cc3ab3027219cb19148a66ebe28bb661ec600
+  data.tar.gz: 85fef37b60095af40a2c35a3fa07fcdd600b2030ec4f2d6b505bfc31f28b8528cdd381956fb92412bc15c17967251e51aefde89ebc2ae10a9954184d5e97b32d

data/lib/data_list.rb

@@ -0,0 +1,58 @@
+class DataList
+    def initialize(elements)
+        @elements = elements
+        @selected = []
+    end
+
+    def elements=(new_elements)
+        @elements = new_elements.dup
+        clear_selected
+    end
+
+    def select(number)
+        validate_index(number)
+        @selected << number unless @selected.include?(number)
+    end
+
+    def get_selected
+        @selected.map { |index| @elements[index].id }.dup
+    end
+
+    def get_names
+        raise NotImplementedError, "Метод должен быть реализован в наследниках"
+    end
+
+    def get_data
+        data = []
+        
+        @elements.each_with_index do |student, index|
+            row = [index + 1]
+            row.concat(student_info(student))
+            data << row
+        end
+        
+        create_data_table(data)
+        
+    end
+
+    def student_info student
+        raise NotImplementedError, "Метод должен быть реализован в наследниках"
+    end
+
+    def create_data_table data
+        raise NotImplementedError, "Метод должен быть реализован в наследниках"
+    end
+
+    def clear_selected
+        @selected.clear
+    end
+
+    protected
+
+    def validate_index(index)
+        if index < 0 || index >= @elements.length
+            raise IndexError, "Некорректный индекс: #{index}"
+        end
+    end
+
+end

data/lib/data_list_student_short.rb

@@ -0,0 +1,89 @@
+require_relative 'data_list'
+require_relative 'student_short'
+require_relative 'data_table'
+
+class DataListStudentShort < DataList
+    def get_names
+        ["№ по порядку", "ФИО", "Контакт", "Git"]
+    end
+
+    def student_info student
+        [student.last_name_initials, student.contact || "нет", student.git || "нет"]
+    end
+
+    def create_data_table data
+        DataTable.new(data)
+    end
+end
+
+'''
+students = [
+    StudentShort.new(
+        id: 1,
+        last_name_initials: "Иванов И.И.",
+        contact: "phone - +79181112233",
+        git: "https://github.com/qwerty"
+    ),
+    StudentShort.new(
+        id: 2,
+        last_name_initials: "Сидоров С.С.", 
+        contact: "email - allakk@mail.ru",
+        git: "https://github.com/asdfg"
+    ),
+    StudentShort.new(
+        id: 3,
+        last_name_initials: "Петров П.П.",
+        contact: "telegram - @popopo",
+        git: nil 
+    )
+]
+
+data_list = DataListStudentShort.new(students)
+
+data_table = data_list.get_data
+puts "Кол-во студентов: #{data_table.rows_count}"
+puts "Кол-во столббцов: #{data_table.columns_count}"
+
+header = data_list.get_names
+puts header.join("\t\t")
+
+(0...data_table.rows_count).each do |row|
+    row_data = (0...data_table.columns_count).map { |column| data_table.get_element(row, column) }
+    puts row_data.join(" | ")
+end
+
+puts "\nРабота c select:"
+data_list.select(0)  
+data_list.select(2)  
+
+puts "Получим, кого выделили (id): #{data_list.get_selected}"
+data_list.clear_selected
+puts "Очистили: #{data_list.get_selected}"
+ 
+puts "Контакт в строке 1: #{data_table.get_element(0, 2)}" 
+puts "Студент в строке 2: #{data_table.get_element(1, 1)}"  
+puts "Git в строке 3: #{data_table.get_element(2, 3)}"  
+'''
+
+'''
+#можно заменять через сеттер для 5 задания
+students1 = [
+    StudentShort.new(id: 1, last_name_initials: "Иванов И.И.", contact: "phone1", git: "git1"),
+    StudentShort.new(id: 2, last_name_initials: "Петров П.П.", contact: "phone2", git: "git2")
+]
+
+data_list = DataListStudentShort.new(students1)
+data_list.select(0)
+puts "Выделенные после первого набора: #{data_list.get_selected}"
+
+students2 = [
+    StudentShort.new(id: 3, last_name_initials: "Сидоров С.С.", contact: "phone3", git: "git3"),
+    StudentShort.new(id: 4, last_name_initials: "Козлов К.К.", contact: "phone4", git: "git4"),
+    StudentShort.new(id: 5, last_name_initials: "Новиков Н.Н.", contact: "phone5", git: "git5")
+]
+
+data_list.elements = students2
+puts "Выделенные после замены массива: #{data_list.get_selected}" 
+
+puts "Заголовки столбцов: #{data_list.get_names}" 
+'''

data/lib/data_table.rb

@@ -0,0 +1,119 @@
+class DataTable
+    def initialize(data)
+        validate_data(data)
+        @data = data.dup
+    end
+
+    def get_element(row, col)
+        validate_indices(row, col)
+        safe_return(@data[row][col])
+    end
+
+    def columns_count
+        return 0 if @data.empty?
+        @data.map{|element| element.length}.max
+    end
+
+    def rows_count
+        @data.length
+    end
+
+    private
+
+    def validate_data(data)
+        unless data.is_a?(Array) && data.all? { |row| row.is_a?(Array) }
+            raise ArgumentError, "Данные д/б двумерным массивом"
+        end
+        widths = data.map{|element| element.length}.uniq
+        return if widths.length <= 1
+        raise ArgumentError, "Все строки должны иметь одинаковое количество атрибутов"
+    end
+
+    def validate_indices(row, col)
+        if row < 0 || row >= rows_count
+            raise IndexError, " индекс строки: #{row}"
+        end
+        if col < 0 || col >= @data[row].length
+            raise IndexError, "Некорректный индекс столбца: #{col}"
+        end
+    end
+
+    def safe_return(value)
+        copy = deep_copy(value)
+    end
+
+    def deep_copy(obj)
+        case obj
+        when Array
+            obj.map { |v| deep_copy(v) }
+        when Hash
+            obj.transform_values { |v| deep_copy(v) }
+        when String
+            obj.dup
+        else
+            obj
+        end
+    end
+
+end
+
+'''
+employee_data = [
+    [1, "Иван Иванов", 25, [50000,20], false],
+    [2, "Мария Петрова", 30, 60000, false],
+    [3, "Петр Сидоров", 35, 70000, true],
+    [4, "Анна Козлова", 28, 55000, true]
+]
+
+employee_table = DataTable.new(employee_data)
+
+puts "Таблица сотрудников:"
+puts "Количество строк: #{employee_table.rows_count}"  
+puts "Количество столбцов: #{employee_table.columns_count}" 
+
+puts "\nКонкретный элемент до попытки записи: #{employee_table.get_element(0,3)}" 
+puts "table element id: #{employee_table.get_element(0,3).object_id}"
+
+element= employee_table.get_element(0,3)<<4
+puts "element: #{element}"
+puts "element id: #{element.object_id}" 
+
+puts "Конкретный элемент после попытки записи: #{employee_table.get_element(0,3)}"
+
+
+puts "\nДанные:"
+(0...employee_table.rows_count).each do |row|
+    (0...employee_table.columns_count).each do |col|
+        print "#{employee_table.get_element(row, col)}\t" 
+    end
+    puts
+end
+
+# с dup не добавляется, работает как надо.
+# puts "Проверка на добавление в исходный массив, поменяется ли наш экземпляр?"
+# employee_data << [1, "Иван Иванов", 25, [50000,20], true]
+# puts "\nДанные:"
+# (0...employee_table.rows_count).each do |row|
+#     (0...employee_table.columns_count).each do |col|
+#         print "#{employee_table.get_element(row, col)}\t" 
+#     end
+#     puts
+# end
+
+puts "Полученный элемент нельзя редактировать:"
+data = [[1, "test"], [2, "hello"]]
+table = DataTable.new(data)
+element = table.get_element(0, 1)  
+element << " modified"            
+puts "#{table.get_element(0, 1)}" 
+
+#не работает, так и д/б. нет доступа
+# table.get_element(0, 1) = 1111
+# puts "#{table.get_element(0, 1)}" 
+
+#Тоже не работает кек, так и должно быть. нет доступа
+#puts "#{employee_table.@data}"
+#puts "#{employee_table.data}"
+'''
+
+

data/lib/module.rb

@@ -0,0 +1,14 @@
+module ValidatedAttributes
+
+    def attr_validate_writer(attribute, field_name: nil, required: true, with:)
+        define_method("#{attribute}=") do |value|
+            if value.nil? && !required
+                instance_variable_set("@#{attribute}", value)
+            elsif value && self.class.send(with, value)
+                instance_variable_set("@#{attribute}", value)
+            else
+                raise ArgumentError, "Ошибка валидации #{attribute}."
+            end
+        end
+    end
+end

data/lib/student.rb

@@ -0,0 +1,124 @@
+require_relative 'student_base.rb'
+require_relative 'module.rb'
+
+class Student < StudentBase
+    include Comparable
+    extend ValidatedAttributes
+    attr_reader :last_name, :first_name, :patronymic
+
+    NAME_REGEX = /\A[A-ZА-ЯЁ][a-zа-яё]+\z/
+    PHONE_REGEX = /^(\+7|8)?[\s\-\(]?(\d{3})[\s\-\)]?(\d{3})[\s\-]?(\d{2})[\s\-]?(\d{2})$/
+    TELEGRAM_REGEX = /^@[a-zA-Z0-9_]{5,32}$/
+    EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/
+    GIT_REGEX = /^https:\/\/(github|gitlab)\.com\/[a-zA-Z0-9_-]+\/?$/
+
+    
+    attr_validate_writer :last_name, field_name: "фамилии", required: true, with: :valid_name?
+    attr_validate_writer :first_name, field_name: "имени", required: true, with: :valid_name?
+    attr_validate_writer :patronymic, field_name: "отчества", required: false, with: :valid_name?
+    attr_validate_writer :git, field_name: "Гита", required: false, with: :valid_git?
+    attr_validate_writer :phone, field_name: "телефона", required: false, with: :valid_phone?
+    attr_validate_writer :telegram, field_name: "телеграмма", required: false, with: :valid_telegram?
+    attr_validate_writer :email, field_name: "почты", required: false, with: :valid_email?
+
+    def initialize(last_name:, first_name:, id: nil, patronymic: nil, phone: nil, telegram: nil, email: nil, git: nil)
+        raise ArgumentError, "Ошибка валидации гита" if !git.nil? && !self.class.valid_git?(git)
+        super(id: id, git: git)
+        self.last_name = last_name
+        self.first_name = first_name
+        self.patronymic = patronymic
+
+        set_contact_values(phone: phone, telegram: telegram, email: email)
+    end
+
+    def contact 
+        contact_data = find_primary_contact
+        return nil unless contact_data
+        
+        "#{contact_data[:type]} - #{contact_data[:value]}"
+    end
+
+    def contact=(hash)
+        raise ArgumentError, "Неверный формат (не Hash)." unless hash.is_a?(Hash)
+        raise ArgumentError, "Не введено 3 контакта." if hash.length != 3 
+
+        valid_keys = [:phone, :telegram, :email]
+        invalid_keys = hash.keys - valid_keys
+        
+        raise ArgumentError, "Неизвестный тип контакта: #{invalid_keys.first}." if !invalid_keys.empty?
+        
+        set_contact_values(phone: hash[:phone], telegram: hash[:telegram], email: hash[:email])
+    end
+
+    def last_name_initials
+        initials = "#{first_name[0]}."
+        initials += " #{patronymic[0]}." if patronymic
+        "#{last_name} #{initials}"
+    end
+
+    def <=>(other)
+        return nil unless other.is_a?(Student)
+    
+        [@last_name, @first_name, @patronymic || ''] <=> 
+        [other.last_name, other.first_name, other.patronymic || '']
+    end
+
+    def to_s
+        result = "#{id}" 
+        result += "\nФИО: #{last_name} #{first_name} #{patronymic || 'нет'} "
+        result += "\nТелефон: #{@phone}" if @phone && !@phone.empty?
+        result += "\nТелеграм: #{@telegram}" if @telegram && !@telegram.empty?
+        result += "\nПочта: #{@email}" if @email && !@email.empty?
+        result += "Git: #{git}" if has_git?
+    end
+
+    class << self
+        def valid_name?(name)
+            name.is_a?(String) && name.length >= 2 && name.match?(NAME_REGEX)
+        end
+
+        def valid_phone?(phone)
+            validate_field(phone) { |v| v.match?(PHONE_REGEX) }
+        end
+
+        def valid_telegram?(telegram)
+            validate_field(telegram) { |v| v.match?(TELEGRAM_REGEX) }
+        end
+
+        def valid_email?(email)
+            validate_field(email) { |v| v.match?(EMAIL_REGEX) }
+        end
+
+        def valid_git?(git)
+            validate_field(git) { |v| v.match?(GIT_REGEX) }
+        end
+
+        private 
+        
+        def validate_field(value)
+            return true if value.nil? || value.empty?
+            yield(value)
+        end
+    end
+
+    private
+
+    def find_primary_contact
+        [
+            { type: 'telegram', value: @telegram },
+            { type: 'email', value: @email },
+            { type: 'phone', value: @phone }
+        ].find { |contact| contact_present?(contact[:value]) }
+    end
+
+    def contact_present?(value)
+        value && !value.empty?
+    end
+
+    def set_contact_values(phone:, telegram:, email:)
+        self.phone = phone
+        self.telegram = telegram
+        self.email = email
+    end
+
+end

data/lib/student_base.rb

@@ -0,0 +1,36 @@
+class StudentBase
+    attr_reader :id, :git
+    
+    def initialize(id: nil, git: nil)
+        @id = id
+        @git = git
+    end
+
+    def to_s
+        raise NotImplementedError, "Метод to_s должен быть реализован в подклассе"
+    end
+
+    def contact
+        raise NotImplementedError, "Метод contact должен быть реализован в подклассе"
+    end
+
+    def last_name_initials
+        raise NotImplementedError, "Метод last_name_initials должен быть реализован в подклассе"
+    end
+
+    def has_contact?
+        !contact.nil?
+    end
+
+    def has_git?
+        !git.nil?
+    end
+
+    def short_info
+        info = "ID: #{id}, ФИО: #{last_name_initials}"
+        info += ", Контакт: #{contact}" if has_contact?
+        info += ", Git: #{git}" if has_git?
+        info
+    end
+
+end

data/lib/student_short.rb

@@ -0,0 +1,28 @@
+require_relative 'student.rb'
+require_relative 'student_base.rb'
+
+class StudentShort < StudentBase
+    attr_reader :last_name_initials, :contact
+    
+    def initialize(id:, last_name_initials:, contact: nil, git: nil)
+        super(id: id, git: git)
+        @last_name_initials = last_name_initials
+        @contact = contact
+    end
+
+    def self.from_student(student)
+        raise ArgumentError, 'Указан не экземпляр класса Student' unless student.is_a?(Student)
+
+        new( id: student.id, last_name_initials: student.last_name_initials, contact: student.contact, git: student.git)
+    end
+    
+    def to_s
+        <<~TEXT
+        ID: #{id}
+        ФИО: #{last_name_initials} 
+        Контакт: #{contact}
+        Гит: #{git}
+        TEXT
+    end
+
+end

data/lib/students_list_common.rb

@@ -0,0 +1,237 @@
+require_relative 'student'
+require_relative 'student_short'
+require_relative 'data_list_student_short'
+
+# Abstract base class for managing student data persistence
+# 
+# This class provides a common interface for reading and writing student data
+# to different file formats. It implements the Template Method pattern,
+# defining the overall algorithm while delegating format-specific operations
+# to concrete subclasses.
+#
+# @abstract Subclasses must implement {#concrete_realization_read} and {#concrete_realization_write}
+# @example
+#   # This class should not be instantiated directly
+#   # Use StudentsListJSON or StudentsListYAML instead
+#   json_list = StudentsListJSON.new('students.json')
+#   students = json_list.read_all
+class StudentsListCommon
+    # Initialize a new StudentsListCommon instance
+    #
+    # @param file_path [String] Path to the file where student data will be stored
+    # @raise [NotImplementedError] if the file doesn't exist and concrete implementation
+    #   doesn't provide write method
+    def initialize file_path
+        @file_path = file_path
+        ensure_file_exists
+    end
+
+    # Read all student data from the file
+    #
+    # @return [Array<Hash>] Array of student data as hashes
+    # @raise [ArgumentError] if the parsed data is not an array
+    # @raise [NotImplementedError] if concrete_realization_read is not implemented
+    def read_all
+        raw = File.exist?(@file_path) ? File.read(@file_path) : ''
+        return [] if raw.strip.empty?
+        data = concrete_realization_read(raw)
+        raise ArgumentError, "Должен содержать массив" unless data.is_a?(Array)
+        data
+    end
+
+    # Write all student data to the file
+    #
+    # @param array_of_hashes [Array<Hash>] Array of student data as hashes to write
+    # @raise [ArgumentError] if array_of_hashes is not an array
+    # @raise [NotImplementedError] if concrete_realization_write is not implemented
+    def write_all array_of_hashes
+        raise ArgumentError, "Ожидается массив" unless array_of_hashes.is_a?(Array)
+        File.write(@file_path, concrete_realization_write(array_of_hashes))
+    end
+
+    # Find a student by their ID
+    #
+    # @param student_id [Integer] The ID of the student to find
+    # @return [Student, nil] The student object if found, nil otherwise
+    def get_student_by_id student_id
+        h = read_all.find { |element| element['id'] == student_id }
+        return nil unless h
+        hash_to_student(h)
+    end
+
+    # Get a paginated list of student short objects
+    #
+    # @param k [Integer] Number of students to return (page size)
+    # @param n [Integer] Starting index (offset)
+    # @param existing_data_list [DataListStudentShort, nil] Optional existing data list to populate
+    # @return [DataListStudentShort] Data list containing student short objects
+    # @raise [ArgumentError] if k or n are not non-negative integers
+    def get_k_n_student_short_list(k, n, existing_data_list=nil)
+        raise ArgumentError, "k и n должны быть неотрицательными" unless k.is_a?(Integer) && n.is_a?(Integer) && k >= 0 && n >= 0
+        slice = read_all[n, k] || []
+        shorts = slice.map { |h| StudentShort.from_student(hash_to_student(h)) }
+        if existing_data_list
+            existing_data_list.elements = shorts
+            existing_data_list
+        else
+            DataListStudentShort.new(shorts)
+        end
+    end
+
+    # Sort all students by full name and save to file
+    #
+    # Sorts students by last_name, then first_name, then patronymic
+    # @return [void]
+    def sort_by_full_name
+        all = read_all
+        all.sort_by! { |h| [h['last_name'] || '', h['first_name'] || '', h['patronymic'] || ''] }
+        write_all(all)
+    end
+
+    # Add a new student to the list
+    #
+    # @param student [Student] The student object to add
+    # @return [Integer] The ID assigned to the new student
+    # @raise [ArgumentError] if student is not a Student object
+    def add_student student
+        raise ArgumentError, "Ожидается объект класса Student" unless student.is_a?(Student)
+        all = read_all
+        new_id = generate_new_id(all)
+        student_with_id = Student.new(
+            id: new_id,
+            last_name: student.last_name,
+            first_name: student.first_name,
+            patronymic: student.instance_variable_get(:@patronymic),
+            phone: student.instance_variable_get(:@phone),
+            telegram: student.instance_variable_get(:@telegram),
+            email: student.instance_variable_get(:@email),
+            git: student.git
+        )
+        all << student_to_hash(student_with_id)
+        write_all(all)
+        new_id
+    end
+
+    # Replace a student with the given ID
+    #
+    # @param student_id [Integer] The ID of the student to replace
+    # @param new_student [Student] The new student object
+    # @return [Boolean] true if replacement was successful
+    # @raise [ArgumentError] if new_student is not a Student object or student with ID not found
+    def replace_student_by_id(student_id, new_student)
+        raise ArgumentError, "Ожидается объект класса Student" unless new_student.is_a?(Student)
+        all = read_all
+        index = all.index { |h| h['id'] == student_id }
+        raise ArgumentError, "Студент с таким id не найден" unless index
+        replaced = Student.new(
+            id: student_id,
+            last_name: new_student.last_name,
+            first_name: new_student.first_name,
+            patronymic: new_student.instance_variable_get(:@patronymic),
+            phone: new_student.instance_variable_get(:@phone),
+            telegram: new_student.instance_variable_get(:@telegram),
+            email: new_student.instance_variable_get(:@email),
+            git: new_student.git
+        )
+        all[index] = student_to_hash(replaced)
+        write_all(all)
+        true
+    end
+
+    # Delete a student by their ID
+    #
+    # @param student_id [Integer] The ID of the student to delete
+    # @return [Boolean] true if student was deleted, false if not found
+    def delete_student_by_id student_id
+        all = read_all
+        before = all.length
+        all.reject! { |h| h['id'] == student_id }
+        deleted = all.length < before
+        write_all(all) if deleted
+        deleted
+    end
+
+    # Get the total count of students
+    #
+    # @return [Integer] Number of students in the list
+    def get_student_short_count
+        read_all.length
+    end
+
+    protected
+
+    # Parse raw file content into an array of hashes
+    #
+    # This method must be implemented by concrete subclasses to handle
+    # format-specific parsing (JSON, YAML, etc.)
+    #
+    # @param raw [String] Raw content from the file
+    # @return [Array<Hash>] Parsed array of student data
+    # @raise [NotImplementedError] if not implemented in subclass
+    def concrete_realization_read raw
+        raise NotImplementedError, "Метод concrete_realization должен быть реализован в подклассах"
+    end
+
+    # Convert array of hashes to format-specific string
+    #
+    # This method must be implemented by concrete subclasses to handle
+    # format-specific serialization (JSON, YAML, etc.)
+    #
+    # @param array_of_hashes [Array<Hash>] Array of student data to serialize
+    # @return [String] Serialized data ready for writing to file
+    # @raise [NotImplementedError] if not implemented in subclass
+    def concrete_realization_write array_of_hashes
+        raise NotImplementedError, "Метод concrete_realization_write должен быть реализован в подклассах"
+    end
+
+    # Ensure the file exists, create it with empty array if it doesn't
+    #
+    # @return [void]
+    def ensure_file_exists
+        return if File.exist?(@file_path)
+        File.write(@file_path, concrete_realization_write([]))
+    end
+
+    # Generate a new unique ID for a student
+    #
+    # @param all [Array<Hash>] Array of all existing student data
+    # @return [Integer] New unique ID (max existing ID + 1)
+    def generate_new_id all
+        max_id = all.map { |h| h['id'] }.compact.max || 0
+        max_id + 1
+    end
+
+    # Convert a Student object to a hash
+    #
+    # @param student [Student] Student object to convert
+    # @return [Hash] Hash representation of the student
+    def student_to_hash student
+        {
+            'id' => student.id,
+            'last_name' => student.last_name,
+            'first_name' => student.first_name,
+            'patronymic' => student.patronymic,
+            'phone' => student.instance_variable_get(:@phone),
+            'telegram' => student.instance_variable_get(:@telegram),
+            'email' => student.instance_variable_get(:@email),
+            'git' => student.git
+        }
+    end
+
+    # Convert a hash to a Student object
+    #
+    # @param h [Hash] Hash containing student data
+    # @return [Student] Student object created from hash
+    def hash_to_student h
+        Student.new(
+            id: h['id'],
+            last_name: h['last_name'],
+            first_name: h['first_name'],
+            patronymic: h['patronymic'],
+            phone: h['phone'],
+            telegram: h['telegram'],
+            email: h['email'],
+            git: h['git']
+        )
+    end
+end

data/lib/students_list_yaml.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+require 'date'
+require_relative 'students_list_common'
+
+# Concrete implementation of StudentsListCommon for YAML format
+#
+# This class provides YAML-specific serialization and deserialization
+# for student data persistence. It extends the base StudentsListCommon
+# class with YAML parsing and generation capabilities, supporting
+# Date and Time objects with safe loading.
+#
+# @example
+#   yaml_list = StudentsListYAML.new('students.yaml')
+#   students = yaml_list.read_all
+#   yaml_list.add_student(Student.new(last_name: 'Smith', first_name: 'John'))
+class StudentsListYAML < StudentsListCommon
+
+    protected
+
+    # Parse YAML string into an array of hashes
+    #
+    # Uses safe loading with permitted Date and Time classes to prevent
+    # code execution vulnerabilities while supporting common data types.
+    #
+    # @param raw [String] Raw YAML content from the file
+    # @return [Array<Hash>] Parsed array of student data
+    # @raise [Psych::SyntaxError] if YAML is malformed
+    def concrete_realization_read raw
+        YAML.safe_load(raw, permitted_classes: [Date, Time], aliases: true)
+    end
+
+    # Convert array of hashes to YAML string
+    #
+    # @param array_of_hashes [Array<Hash>] Array of student data to serialize
+    # @return [String] YAML string ready for writing to file
+    def concrete_realization_write array_of_hashes
+        YAML.dump(array_of_hashes)
+    end
+    #
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: students_list_yaml
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- akhit
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides YAML serialization for student data storage
+email:
+- annakhit02@mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/data_list.rb
+- lib/data_list_student_short.rb
+- lib/data_table.rb
+- lib/module.rb
+- lib/student.rb
+- lib/student_base.rb
+- lib/student_short.rb
+- lib/students_list_common.rb
+- lib/students_list_yaml.rb
+homepage: https://example.com
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: YAML-based student list management
+test_files: []