lab2/README.md

@@ -1,88 +1,4 @@
 # 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

@@ -1,46 +0,0 @@
-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,92 +1,33 @@
-require 'date'
-require_relative 'person'
 require_relative 'student'
-require_relative 'student_short'
-require_relative 'student_repository'
-require_relative 'binary_search_tree'
 
-def test_classes
+begin
-  person = Person.new(id: '1', git: 'https://github.com/example', phone: '+798912465', telegram: '@example_user', email: 'test@example.com')
+  student1 = Student.new(
-  puts "Person Contact Info: #{person.get_first_contact}"
+    surname: 'Алексеевич',
-
+    name: 'Артем-Дариус',
-  student = Student.new(
+    patronymic: 'Вебер',
-    id: '2',
+    id: 1,
-    git: 'https://github.com/student_example',
+    git: 'https://git.djft.ru'
-    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}"
-
-  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
-
-def test_binary_search_tree
-  bst = BinarySearchTree.new
 
-  student1 = Student.new(
+  student1.set_contacts(
-    id: '1',
+    phone: '+79891242223',
-    git: 'https://github.com/student1',
+    telegram: '@alstroemeria22',
-    surname: 'Смирнов',
+    email: 'no-replay@djft.ru'
-    name: 'Алексей',
-    patronymic: 'Иванович',
-    birth_date: Date.new(1999, 2, 15),
-    phone: '+123456789',
-    telegram: '@student1',
-    email: 'student1@example.com'
   )
+
   student2 = Student.new(
-    id: '2',
+    surname: 'Норакет',
-    git: 'https://github.com/student2',
+    name: 'Норакет',
-    surname: 'Иванов',
+    patronymic: 'Фамилия'
-    name: 'Иван',
-    patronymic: 'Сергеевич',
-    birth_date: Date.new(2001, 5, 10),
-    phone: '+987654321',
-    telegram: '@student2',
-    email: 'student2@example.com'
   )
 
-  bst.add(student1)
+  student2.set_contacts(
-  bst.add(student2)
+    phone: '+70000000000'
+  )
 
-  puts "Students in BST (sorted by birth_date):"
+  puts student1
-  bst.each { |student| puts student.to_s }
+  puts '-' * 40
+  puts student2
+rescue ArgumentError => e
+  puts "Ошибка: #{e.message}"
 end
-
-if __FILE__ == $0
-  puts "=== Testing Classes ==="
-  test_classes
-
-  puts "\n=== Testing Parsing ==="
-  test_parsing
-
-  puts "\n=== Testing Binary Search Tree ==="
-  test_binary_search_tree
-end

lab2/person.rb

@@ -1,85 +0,0 @@
-class Person
-  attr_reader :id, :git, :phone, :telegram, :email
-
-  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 surname_initials
-    raise NotImplementedError, "#{self.class} must implement the 'surname_initials' method"
-  end
-
-  def git_present?
-    !@git.nil? && !@git.empty?
-  end
-
-  def contact_present?
-    @phone || @telegram || @email
-  end
-
-  def get_first_contact
-    [@phone, @telegram, @email].compact.first
-  end
-
-  def self.valid_phone_number?(phone)
-    /\A\+?[0-9]{9,15}\z/.match?(phone)
-  end
-
-  def self.valid_telegram?(telegram)
-    /\A@[A-Za-z0-9_]{5,32}\z/.match?(telegram)
-  end
-
-  def self.valid_email?(email)
-    /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/.match?(email)
-  end
-
-  def phone=(phone)
-    if phone && !self.class.valid_phone_number?(phone)
-      raise ArgumentError, "Недопустимый номер телефона: #{phone}"
-    end
-    @phone = phone
-  end
-
-  def telegram=(telegram)
-    if telegram && !self.class.valid_telegram?(telegram)
-      raise ArgumentError, "Некорректный Telegram: #{telegram}"
-    end
-    @telegram = telegram
-  end
-
-  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 self.validate_id(id)
-    raise ArgumentError, 'ID is required and must be a non-empty string' unless valid_id?(id)
-  end
-
-  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
-
-  def self.valid_git?(git)
-    /\Ahttps:\/\/github\.com\/[A-Za-z0-9_\-]+\z/.match?(git)
-  end
-
-  def self.valid_id?(id)
-    id.is_a?(String) && !id.strip.empty?
-  end
-end

lab2/student.rb

@@ -1,103 +1,86 @@
-require_relative 'person'
+class Student
-
+    attr_accessor :id, :surname, :name, :patronymic, :git
-class Student < Person
+  
-  attr_accessor :surname, :name, :patronymic, :birth_date
+    def self.valid_phone_number?(phone)
-
+      phone.match?(/\A\+?[0-9]{10,15}\z/)
-  private
+    end
-
+  
-  NAME_REGEX = /\A[А-Яа-яЁёA-Za-z\-]+\z/
+    def self.valid_name?(name)
-
+      name.match?(/\A[А-Яа-яЁёA-Za-z\-]+\z/)
-  public
+    end
-
+  
-  def initialize(id:, git:, surname:, name:, patronymic:, birth_date:, phone: nil, telegram: nil, email: nil)
+    def self.valid_telegram?(telegram)
-    super(id: id, git: git, phone: phone, telegram: telegram, email: email)
+      telegram.nil? || telegram.match?(/\A@[A-Za-z0-9_]{5,32}\z/)
-    self.surname = surname
+    end
-    self.name = name
+  
-    self.patronymic = patronymic
+    def self.valid_email?(email)
-    self.birth_date = birth_date
+      email.nil? || email.match?(/\A[^@\s]+@[^@\s]+\.[^@\s]+\z/)
-  end
+    end
-
+  
-  def self.from_string(student_string)
+    def self.valid_git?(git)
-    parts = student_string.split('|').map(&:strip)
+      git.nil? || git.match?(/\Ahttps:\/\/github\.com\/[A-Za-z0-9_\-]+\z/)
-    raise ArgumentError, 'Invalid student string format' if parts.size < 7
+    end
-
+  
-    name_parts = parts[0].split(' ')
+    def initialize(args = {})
-    raise ArgumentError, 'Invalid name format' if name_parts.size != 3
+      @surname = args.fetch(:surname)
-
+      raise ArgumentError, "Invalid surname format: #{@surname}" unless Student.valid_name?(@surname)
-    surname, name, patronymic = name_parts
+  
-    id = parts[1].split(': ').last
+      @name = args.fetch(:name)
-    phone = parts[2].split(': ').last
+      raise ArgumentError, "Invalid name format: #{@name}" unless Student.valid_name?(@name)
-    telegram = parts[3].split(': ').last
+  
-    email = parts[4].split(': ').last
+      @patronymic = args.fetch(:patronymic)
-    git = parts[5].split(': ').last
+      raise ArgumentError, "Invalid patronymic format: #{@patronymic}" unless Student.valid_name?(@patronymic)
-    birth_date = Date.parse(parts[6].split(': ').last)
+  
-
+      @id = args[:id] || nil
-    new(
+  
-      id: id,
+      set_contacts(
-      git: git,
+        phone: args[:phone],
-      surname: surname,
+        telegram: args[:telegram],
-      name: name,
+        email: args[:email]
-      patronymic: patronymic,
+      )
-      birth_date: birth_date,
+  
-      phone: phone,
+      @git = args[:git]
-      telegram: telegram,
+      raise ArgumentError, "Invalid git format: #{@git}" unless Student.valid_git?(@git)
-      email: email
+  
-    )
+      validate
-  end
+    end
-
+  
-  def surname_initials
+    def set_contacts(phone: nil, telegram: nil, email: nil)
-    "#{@surname} #{name_initial(@name)}.#{patronymic_initial(@patronymic)}."
+      @phone = phone
-  end
+      raise ArgumentError, "Invalid phone number format: #{@phone}" if @phone && !Student.valid_phone_number?(@phone)
-
+  
-  def to_s
+      @telegram = telegram
-    "#{@surname} #{@name} #{@patronymic} | ID: #{@id} | " \
+      raise ArgumentError, "Invalid telegram format: #{@telegram}" if @telegram && !Student.valid_telegram?(@telegram)
-    "Phone: #{@phone || 'N/A'} | Telegram: #{@telegram || 'N/A'} | " \
+  
-    "Email: #{@email || 'N/A'} | Git: #{@git} | Birth Date: #{@birth_date}"
+      @email = email
-  end
+      raise ArgumentError, "Invalid email format: #{@email}" if @email && !Student.valid_email?(@email)
-
+    end
-  def get_info
+  
-    "#{surname_initials}, Git: #{@git}, Contact: #{get_first_contact}, Birth Date: #{@birth_date}"
+    def git_present?
-  end
+      !@git.nil? && !@git.empty?
-
+    end
-  def surname=(surname)
+  
-    raise ArgumentError, 'Surname is required' if surname.nil? || surname.strip.empty?
+    def contact_present?
-    raise ArgumentError, "Invalid surname format: #{surname}" unless self.class.valid_name?(surname)
+      !(@phone.nil? || @phone.empty?) || !(@telegram.nil? || @telegram.empty?) || !(@email.nil? || @email.empty?)
-  
+    end
-    @surname = surname
+  
-  end
+    def validate
-
+      raise ArgumentError, "Git link is required" unless git_present?
-  def name=(name)
+      raise ArgumentError, "At least one contact (phone, telegram, or email) is required" unless contact_present?
-    raise ArgumentError, 'Name is required' if name.nil? || name.strip.empty?
+    end
-    raise ArgumentError, "Invalid name format: #{name}" unless self.class.valid_name?(name)
+  
-
+    def to_s
-    @name = name
+      "Student: #{@surname} #{@name} #{@patronymic}\n" \
-  end
+      "ID: #{@id || 'N/A'}\n" \
-
+      "Phone: #{@phone || 'N/A'}\n" \
-  def patronymic=(patronymic)
+      "Telegram: #{@telegram || 'N/A'}\n" \
-    raise ArgumentError, 'Patronymic is required' if patronymic.nil? || patronymic.strip.empty?
+      "Email: #{@email || 'N/A'}\n" \
-    raise ArgumentError, "Invalid patronymic format: #{patronymic}" unless self.class.valid_name?(patronymic)
+      "Git: #{@git || 'N/A'}"
-
+    end
-    @patronymic = patronymic
+  
-  end
+    private
-
+  
-  def birth_date=(birth_date)
+    attr_reader :phone, :telegram, :email
-    raise ArgumentError, 'Birth date is required' if birth_date.nil?
+  
-    raise ArgumentError, "Invalid birth date: #{birth_date}" unless birth_date.is_a?(Date)
+    attr_writer :phone, :telegram, :email
-
-    @birth_date = birth_date
-  end
-
-  def self.valid_name?(name)
-    NAME_REGEX.match?(name)
-  end
-
-  private
-
-  def name_initial(name)
-    name[0].upcase
-  end
-
-  def patronymic_initial(patronymic)
-    patronymic[0].upcase
-  end
 end

lab2/student_repository.rb

@@ -1,39 +0,0 @@
-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,59 +0,0 @@
-require_relative 'person'
-
-class StudentShort < Person
-  attr_reader :surname_initials
-
-  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]
-    contact_string = parts[1].split(': ', 2).last.strip
-
-    phone, telegram, email = parse_contact_string(contact_string)
-
-    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 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

@@ -1,3 +0,0 @@
-Иванов Иван Иванович | 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