refactor: implement surname_initials method and update references for consistency

lab2/README.md

@@ -1,4 +1,88 @@
 # Lab 2
 
-> "И тут я обнаружил что случайно сделал 3-5 задачи в 1-2"
+
+## Диаграмма классов:
+
+```mermaid
+classDiagram
+    class BinarySearchTree {
+        - root : Node
+        + add(student : Student) : void
+        + each(&block) : void
+        - insert(node : Node, student : Student) : Node
+        - in_order_traversal(node : Node, &block) : void
+    }
+
+    class Node {
+        - student : Student
+        - left : Node
+        - right : Node
+        + Node(student : Student)
+    }
+
+    class Person {
+        - id : String
+        - git : String
+        - phone : String?
+        - telegram : String?
+        - email : String?
+        + Person(id : String, git : String, phone: String, telegram: String, email: String)
+        + phone=(String) : Boolean
+        + telegram=(String) : Boolean
+        + email=(String) : Boolean
+        + surname_initials() : NotImplementedError
+        + valid_phone_number() : Boolean <<class>>
+        + valid_telegram() : Boolean <<class>>
+        + valid_email() : Boolean <<class>>
+        + git_present() : Boolean
+        + contact_present() : Boolean
+        + get_first_contact() : String
+        + git=(git : String) : void
+        + validate_id(id: String) : void <<class>>
+        + validate_git(git : String) : void <<class>>
+        - valid_git?(git : String) : Boolean
+        - valid_id?(id : String) : Boolean
+    }
+
+    class StudentRepository {
+        + read_from_txt(file_path : String) : List~Student~ <<class>>
+        + write_to_txt(file_path : String, students : List~Student~) <<class>>
+    }
+
+    class StudentShort {
+        - surname_initials : String
+        + get_surname_initials() : String
+        + StudentShort(id : String, surname_initials : String, phone: String, telegram: String, email: String)
+        + from_student(student : Student) : StudentShort <<class>>
+        + from_string(id : String, info_string : String) : StudentShort <<class>>
+        + to_s() : String
+        - parse_contact_string(contact_string: String) : Array<String> <<class>>
+    }
+
+    class Student {
+        - surname : String
+        - name : String
+        - patronymic : String
+        - birth_date : Date
+        - const NAME_REGEX : String
+        + Student(id : String, git : String, phone: String, telegram: String, email: String, surname : String, name : String, patronymic : String, birth_date : Date)
+        + from_string(student_string : String) : Student <<class>>
+        + surname_initials() : String
+        + to_s() : String
+        + get_info() : String
+        + surname=(surname : String)
+        + name=(name : String)
+        + patronymic=(patronymic : String)
+        + birth_date=(birthdate : String)
+        + valid_name?(name : String) : Boolean <<class>>
+        - name_initial(name : String) : String
+        - patronymic(patronymic : String) : String
+    }
+
+    BinarySearchTree o-- Node
+    Node o-- Student
+    Person <|-- Student
+    Person <|-- StudentShort
+    Student <.. StudentRepository
+```
 

lab2/binary_search_tree.rb

@@ -0,0 +1,46 @@
+class BinarySearchTree
+  include Enumerable
+
+  class Node
+    attr_accessor :student, :left, :right
+
+    def initialize(student)
+      @student = student
+      @left = nil
+      @right = nil
+    end
+  end
+
+  def initialize
+    @root = nil
+  end
+
+  def add(student)
+    @root = insert(@root, student)
+  end
+
+  def each(&block)
+    in_order_traversal(@root, &block)
+  end
+
+  private
+
+  def insert(node, student)
+    return Node.new(student) if node.nil?
+
+    if student.birth_date < node.student.birth_date
+      node.left = insert(node.left, student)
+    else
+      node.right = insert(node.right, student)
+    end
+    node
+  end
+
+  def in_order_traversal(node, &block)
+    return if node.nil?
+
+    in_order_traversal(node.left, &block)
+    yield node.student
+    in_order_traversal(node.right, &block)
+  end
+end

lab2/main.rb

@@ -1,59 +1,92 @@
+require 'date'
+require_relative 'person'
 require_relative 'student'
 require_relative 'student_short'
+require_relative 'student_repository'
+require_relative 'binary_search_tree'
 
-begin
-    student_string = "Норакет Норакет Норакет | ID: 2 | Phone: +1234567890 | Telegram: @noracat | Email: nora@example.com | Git: https://github.com/nora"
-    student_from_string = Student.from_string(student_string)
-    puts "Создан объект из строки:\n#{student_from_string}"
+def test_classes
+  person = Person.new(id: '1', git: 'https://github.com/example', phone: '+798912465', telegram: '@example_user', email: 'test@example.com')
+  puts "Person Contact Info: #{person.get_first_contact}"
 
-
-    student1 = Student.new(
-        surname: 'Алексеевич',
-        name: 'Артем-Дариус',
-        patronymic: 'Вебер',
-        id: 1,
-        git: 'https://github.com/space-creator'
+  student = Student.new(
+    id: '2',
+    git: 'https://github.com/student_example',
+    surname: 'Иванов',
+    name: 'Иван',
+    patronymic: 'Иванович',
+    birth_date: Date.new(2000, 5, 15),
+    phone: '+79891234567',
+    telegram: '@student_ivan',
+    email: 'ivanov@example.com'
   )
+  puts "Student Full Info: #{student.to_s}"
+  puts "Student Initials: #{student.surname_initials}"
+  puts "Student Contact Info: #{student.get_first_contact}"
 
-    student1.set_contacts(
-        phone: '+79891242223',
-        telegram: '@alstroemeria22',
-        email: 'no-replay@djft.ru'
-    )
+  student_short = StudentShort.from_student(student)
+  puts "Student Short Info: #{student_short.to_s}"
+
+  file_path = 'students.txt'
+  students = StudentRepository.read_from_txt(file_path)
+  puts "Read Students from File:"
+  students.each { |s| puts s.to_s }
+
+  output_path = 'output_students.txt'
+  StudentRepository.write_to_txt(output_path, students)
+  puts "Students written to file: #{output_path}"
+end
+
+def test_parsing
+  student_string = 'Иванов Иван Иванович | ID: 3 | Phone: +79876543210 | Telegram: @ivan_user | Email: ivan@example.com | Git: https://github.com/ivanov | Birth Date: 2001-01-01'
+  student = Student.from_string(student_string)
+  puts "Parsed Student: #{student.to_s}"
+
+  short_string = 'Иванов И.И., Contact: Phone: +79876543210'
+  student_short = StudentShort.from_string('4', short_string)
+  puts "Parsed StudentShort: #{student_short.to_s}"
+end
 
-    puts student1.get_info
-    puts "Surname and Initials: #{student1.surname_and_initials}"
-    puts "Git Info: #{student1.git_info}"
-    puts "Contact Info: #{student1.contact_info}"
+def test_binary_search_tree
+  bst = BinarySearchTree.new
 
+  student1 = Student.new(
+    id: '1',
+    git: 'https://github.com/student1',
+    surname: 'Смирнов',
+    name: 'Алексей',
+    patronymic: 'Иванович',
+    birth_date: Date.new(1999, 2, 15),
+    phone: '+123456789',
+    telegram: '@student1',
+    email: 'student1@example.com'
+  )
   student2 = Student.new(
-        surname: 'Норакет',
-        name: 'Норакет',
-        patronymic: 'Фамилия'
+    id: '2',
+    git: 'https://github.com/student2',
+    surname: 'Иванов',
+    name: 'Иван',
+    patronymic: 'Сергеевич',
+    birth_date: Date.new(2001, 5, 10),
+    phone: '+987654321',
+    telegram: '@student2',
+    email: 'student2@example.com'
   )
 
-    student2.set_contacts(
-        phone: '+70000000000'
-    )
+  bst.add(student1)
+  bst.add(student2)
+
+  puts "Students in BST (sorted by birth_date):"
+  bst.each { |student| puts student.to_s }
+end
+
+if __FILE__ == $0
+  puts "=== Testing Classes ==="
+  test_classes
+
+  puts "\n=== Testing Parsing ==="
+  test_parsing
 
-    puts student1
-    puts '-' * 40
-    puts student2
-
-
-    student_short_from_student = StudentShort.new(student1)
-    puts "StudentShort from Student object:"
-    puts "ID: #{student_short_from_student.id}"
-    puts "Surname and Initials: #{student_short_from_student.surname_initials}"
-    puts "Git: #{student_short_from_student.git}"
-    puts "Contact: #{student_short_from_student.contact}"
-
-    student_short_from_string = StudentShort.from_string(5, 'Skye A.A., Git: https://github.com/skye, Contact: Phone: +4923467890')
-    puts "StudentShort from string:"
-    puts "ID: #{student_short_from_string.id}"
-    puts "Surname and Initials: #{student_short_from_string.surname_initials}"
-    puts "Git: #{student_short_from_string.git}"
-    puts "Contact: #{student_short_from_string.contact}"
-rescue ArgumentError => e
-  puts "Ошибка: #{e.message}"
+  puts "\n=== Testing Binary Search Tree ==="
+  test_binary_search_tree
 end

lab2/person.rb

@@ -1,65 +1,85 @@
 class Person
-    attr_accessor :id, :git
+  attr_reader :id, :git, :phone, :telegram, :email
 
-    def initialize(args = {})
-      @id = args[:id] || nil
-      @git = args[:git]
-      validate
+  def initialize(id:, git: nil, phone: nil, telegram: nil, email: nil)
+    self.class.validate_id(id)
+    self.phone = phone
+    self.telegram = telegram
+    self.email = email
+    raise ArgumentError, "Необходимо указать хотя бы один контакт (телефон, Telegram или email)" unless contact_present?
+  
+    @id = id
+    @git = git
   end
 
-    def set_contacts(phone: nil, telegram: nil, email: nil)
-      @phone = phone
-      raise ArgumentError, "Invalid phone number format: #{@phone}" if @phone && !self.class.valid_phone_number?(@phone)
+  def surname_initials
+    raise NotImplementedError, "#{self.class} must implement the 'surname_initials' method"
+  end
 
-      @telegram = telegram
-      raise ArgumentError, "Invalid telegram format: #{@telegram}" if @telegram && !self.class.valid_telegram?(@telegram)
+  def git_present?
+    !@git.nil? && !@git.empty?
+  end
 
-      @email = email
-      raise ArgumentError, "Invalid email format: #{@email}" if @email && !self.class.valid_email?(@email)
+  def contact_present?
+    @phone || @telegram || @email
   end
 
-    def self.valid_phone_number?(phone)
-      phone.match?(/\A\+?[0-9]{10,15}\z/)
+  def get_first_contact
+    [@phone, @telegram, @email].compact.first
   end
 
-    def self.valid_name?(name)
-      name.match?(/\A[А-Яа-яЁёA-Za-z\-]+\z/)
+  def self.valid_phone_number?(phone)
+    /\A\+?[0-9]{9,15}\z/.match?(phone)
   end
 
   def self.valid_telegram?(telegram)
-      telegram.nil? || telegram.match?(/\A@[A-Za-z0-9_]{5,32}\z/)
+    /\A@[A-Za-z0-9_]{5,32}\z/.match?(telegram)
   end
 
   def self.valid_email?(email)
-      email.nil? || email.match?(/\A[^@\s]+@[^@\s]+\.[^@\s]+\z/)
+    /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/.match?(email)
   end
 
-    def self.valid_git?(git)
-      git.nil? || git.match?(/\Ahttps:\/\/github\.com\/[A-Za-z0-9_\-]+\z/)
+  def phone=(phone)
+    if phone && !self.class.valid_phone_number?(phone)
+      raise ArgumentError, "Недопустимый номер телефона: #{phone}"
+    end
+    @phone = phone
   end
 
-    def git_present?
-      !@git.nil? && !@git.empty?
+  def telegram=(telegram)
+    if telegram && !self.class.valid_telegram?(telegram)
+      raise ArgumentError, "Некорректный Telegram: #{telegram}"
+    end
+    @telegram = telegram
   end
 
-    def contact_present?
-      !(@phone.nil? || @phone.empty?) || !(@telegram.nil? || @telegram.empty?) || !(@email.nil? || @email.empty?)
+  def email=(email)
+    if email && !self.class.valid_email?(email)
+      raise ArgumentError, "Некорректный email: #{email}"
+    end
+    @email = email
+  end
+
+  def git=(git)
+    self.class.validate_git(git)
+    @git = git
   end
 
-    def validate
-      raise ArgumentError, "Git link is required" unless git_present?
-      raise ArgumentError, "At least one contact (phone, telegram, or email) is required" unless contact_present?
+  def self.validate_id(id)
+    raise ArgumentError, 'ID is required and must be a non-empty string' unless valid_id?(id)
   end
 
-    def contact_info
-      return "Phone: #{@phone}" if @phone
-      return "Telegram: #{@telegram}" if @telegram
-      return "Email: #{@email}" if @email
-      'No contact available'
+  def self.validate_git(git)
+    raise ArgumentError, 'Git link is required' if git.nil? || git.strip.empty?
+    raise ArgumentError, 'Invalid Git link format' unless valid_git?(git)
   end
 
-    private
+  def self.valid_git?(git)
+    /\Ahttps:\/\/github\.com\/[A-Za-z0-9_\-]+\z/.match?(git)
+  end
 
-    attr_reader :phone, :telegram, :email
-    attr_writer :phone, :telegram, :email
+  def self.valid_id?(id)
+    id.is_a?(String) && !id.strip.empty?
+  end
 end

lab2/student.rb

@@ -1,92 +1,103 @@
 require_relative 'person'
 
 class Student < Person
-    attr_accessor :surname, :name, :patronymic
+  attr_accessor :surname, :name, :patronymic, :birth_date
 
-    def initialize(args = {})
-      super(args)
-      @surname = args.fetch(:surname)
-      raise ArgumentError, "Invalid surname format: #{@surname}" unless self.class.valid_name?(@surname)
+  private
 
-      @name = args.fetch(:name)
-      raise ArgumentError, "Invalid name format: #{@name}" unless self.class.valid_name?(@name)
+  NAME_REGEX = /\A[А-Яа-яЁёA-Za-z\-]+\z/
 
-      @patronymic = args.fetch(:patronymic)
-      raise ArgumentError, "Invalid patronymic format: #{@patronymic}" unless self.class.valid_name?(@patronymic)
+  public
 
-      set_contacts(
-        phone: args[:phone],
-        telegram: args[:telegram],
-        email: args[:email]
-      )
+  def initialize(id:, git:, surname:, name:, patronymic:, birth_date:, phone: nil, telegram: nil, email: nil)
+    super(id: id, git: git, phone: phone, telegram: telegram, email: email)
+    self.surname = surname
+    self.name = name
+    self.patronymic = patronymic
+    self.birth_date = birth_date
   end
 
   def self.from_string(student_string)
     parts = student_string.split('|').map(&:strip)
-      surname, name, patronymic = parts[0].split(' ')
-      id = parts[1].split(': ').last.to_i
+    raise ArgumentError, 'Invalid student string format' if parts.size < 7
+
+    name_parts = parts[0].split(' ')
+    raise ArgumentError, 'Invalid name format' if name_parts.size != 3
+
+    surname, name, patronymic = name_parts
+    id = parts[1].split(': ').last
     phone = parts[2].split(': ').last
     telegram = parts[3].split(': ').last
     email = parts[4].split(': ').last
     git = parts[5].split(': ').last
+    birth_date = Date.parse(parts[6].split(': ').last)
 
     new(
+      id: id,
+      git: git,
       surname: surname,
       name: name,
       patronymic: patronymic,
-        id: id,
+      birth_date: birth_date,
       phone: phone,
       telegram: telegram,
-        email: email,
-        git: git
+      email: email
     )
   end
 
-    def self.read_from_txt(file_path)
-        raise IOError, "File path is invalid or file does not exist: #{file_path}" unless File.exist?(file_path)
-    
-        students = []
-    
-        File.foreach(file_path) do |line|
-          line.strip!
-          next if line.empty?
+  def surname_initials
+    "#{@surname} #{name_initial(@name)}.#{patronymic_initial(@patronymic)}."
+  end
 
-          begin
-            student = from_string(line)
-            students << student
-          rescue ArgumentError => e
-            puts "Error processing line: '#{line}'. Reason: #{e.message}"
+  def to_s
+    "#{@surname} #{@name} #{@patronymic} | ID: #{@id} | " \
+    "Phone: #{@phone || 'N/A'} | Telegram: #{@telegram || 'N/A'} | " \
+    "Email: #{@email || 'N/A'} | Git: #{@git} | Birth Date: #{@birth_date}"
   end
+
+  def get_info
+    "#{surname_initials}, Git: #{@git}, Contact: #{get_first_contact}, Birth Date: #{@birth_date}"
   end
 
-        students
+  def surname=(surname)
+    raise ArgumentError, 'Surname is required' if surname.nil? || surname.strip.empty?
+    raise ArgumentError, "Invalid surname format: #{surname}" unless self.class.valid_name?(surname)
+  
+    @surname = surname
   end
 
-    def self.write_to_txt(file_path, students)
-        raise ArgumentError, "Expected an array of Student objects" unless students.is_a?(Array) && students.all? { |s| s.is_a?(Student) }
+  def name=(name)
+    raise ArgumentError, 'Name is required' if name.nil? || name.strip.empty?
+    raise ArgumentError, "Invalid name format: #{name}" unless self.class.valid_name?(name)
 
-        File.open(file_path, 'w') do |file|
-          students.each do |student|
-            file.puts student.to_s
+    @name = name
   end
+
+  def patronymic=(patronymic)
+    raise ArgumentError, 'Patronymic is required' if patronymic.nil? || patronymic.strip.empty?
+    raise ArgumentError, "Invalid patronymic format: #{patronymic}" unless self.class.valid_name?(patronymic)
+
+    @patronymic = patronymic
   end
 
-        puts "Data successfully written to #{file_path}"
-    rescue IOError => e
-        puts "An error occurred while writing to the file: #{e.message}"
+  def birth_date=(birth_date)
+    raise ArgumentError, 'Birth date is required' if birth_date.nil?
+    raise ArgumentError, "Invalid birth date: #{birth_date}" unless birth_date.is_a?(Date)
+
+    @birth_date = birth_date
   end
 
-    def surname_and_initials
-      "#{@surname} #{name[0]}.#{patronymic[0]}."
+  def self.valid_name?(name)
+    NAME_REGEX.match?(name)
   end
 
-    def to_s
-      "#{@surname} #{@name} #{@patronymic} | ID: #{@id || 'N/A'} | " \
-      "Phone: #{@phone || 'N/A'} | Telegram: #{@telegram || 'N/A'} | " \
-      "Email: #{@email || 'N/A'} | Git: #{@git || 'N/A'}"
+  private
+
+  def name_initial(name)
+    name[0].upcase
   end
 
-    def get_info
-      "#{surname_and_initials}, Git: #{git_info}, Contact: #{contact_info}"
+  def patronymic_initial(patronymic)
+    patronymic[0].upcase
   end
 end

lab2/student_repository.rb

@@ -0,0 +1,39 @@
+require_relative 'student'
+
+class StudentRepository
+  def self.read_from_txt(file_path)
+    raise IOError, "File does not exist: #{file_path}" unless File.exist?(file_path)
+
+    students = []
+
+    File.foreach(file_path) do |line|
+      line.strip!
+      next if line.empty?
+
+      begin
+        student = Student.from_string(line)
+        students << student
+      rescue ArgumentError => e
+        puts "Error processing line: '#{line}'. Reason: #{e.message}"
+      end
+    end
+
+    students
+  end
+
+  def self.write_to_txt(file_path, students)
+    unless students.is_a?(Array) && students.all? { |s| s.is_a?(Student) }
+      raise ArgumentError, 'Expected an array of Student objects'
+    end
+
+    File.open(file_path, 'w') do |file|
+      students.each do |student|
+        file.puts student.to_s
+      end
+    end
+
+    puts "Data successfully written to #{file_path}"
+  rescue IOError => e
+    puts "An error occurred while writing to the file: #{e.message}"
+  end
+end

lab2/student_short.rb

@@ -1,31 +1,59 @@
 require_relative 'person'
 
 class StudentShort < Person
-    attr_reader :surname_initials, :contact
+  attr_reader :surname_initials
 
-    def initialize(student)
-      super(id: student.id, git: student.git_info)
-      @surname_initials = student.surname_and_initials
-      @contact = student.contact_info
+  def initialize(id:, surname_initials:, phone: nil, telegram: nil, email: nil)
+    super(id: id, phone: phone, telegram: telegram, email: email)
+    @surname_initials = surname_initials
+    freeze
+  end
+
+  def self.from_student(student)
+    new(
+      id: student.id,
+      surname_initials: student.surname_initials,
+      phone: student.phone,
+      telegram: student.telegram,
+      email: student.email
+    )
   end
 
   def self.from_string(id, info_string)
     parts = info_string.split(',').map(&:strip)
+    raise ArgumentError, 'Invalid info string format' if parts.size < 2
+
     surname_initials = parts[0]
-      git = parts[1].split(': ').last
-      contact = parts[2].split(': ').last
+    contact_string = parts[1].split(': ', 2).last.strip
+
+    phone, telegram, email = parse_contact_string(contact_string)
 
-      new_instance = allocate
-      new_instance.send(:initialize_from_data, id, surname_initials, git, contact)
-      new_instance
+    new(
+      id: id,
+      surname_initials: surname_initials,
+      phone: phone,
+      telegram: telegram,
+      email: email
+    )
+  end
+
+  def to_s
+    contact_info = get_first_contact()
+    "#{@surname_initials}, Contact: #{contact_info}"
   end
 
   private
 
-    def initialize_from_data(id, surname_initials, git, contact)
-      @id = id
-      @surname_initials = surname_initials
-      @git = git
-      @contact = contact
+  def self.parse_contact_string(contact_string)
+    case contact_string
+    when /\APhone: (.+)\z/i
+      [Regexp.last_match(1).strip, nil, nil]
+    when /\ATelegram: (.+)\z/i
+      [nil, Regexp.last_match(1).strip, nil]
+    when /\AEmail: (.+)\z/i
+      [nil, nil, Regexp.last_match(1).strip]
+    else
+      raise ArgumentError, "Invalid contact string format: #{contact_string}"
+    end
   end
 end

lab2/students.txt

@@ -0,0 +1,3 @@
+Иванов Иван Иванович | ID: 1 | Phone: +12345678901 | Telegram: @ivanov_user | Email: ivanov@example.com | Git: https://github.com/ivanov
+Петров Петр Петрович | ID: 2 | Phone: +98765432101 | Telegram: @petrov_user | Email: petrov@example.com | Git: https://github.com/petrov
+Сидоров Сидор Сидорович | ID: 3 | Phone: +56789012345 | Telegram: @sidorov_user | Email: sidorov@example.com | Git: https://github.com/sidorov