model_gem 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fc216b10492287ed87310ed44a72856af3406f52f12b9782a48a2b92a59f1825
+  data.tar.gz: bc1b8e97cf6bc9b848fc9dde233a99d160dfefe2163a5d9defd87169ace390e1
+SHA512:
+  metadata.gz: 2bd894bf9273785e935270c16c75b954ae09c95ac45077f90c10f0fbd806f5023bb11dfc1874f8950ed81a709e64dd5f49895768e259ea1170a4189505142760
+  data.tar.gz: b6627b989086eac801965da333a7d119ad9a7561972ba68183781f2e860b418aee8a5e48d7347b86e79deca41d32e4f8a18746b4e739839f7b2c77db83202ca7

data/model_gem_source/attr_limited_regex_accessor.rb

@@ -0,0 +1,43 @@
+def attr_limited_regex_accessor(symbol, regex)
+    class_eval %{
+        def #{symbol}
+            @#{symbol}
+        end
+
+        def #{symbol}=(new_value)
+            if new_value != nil && new_value !~ #{regex}
+                raise "invalid #{symbol} format"
+            end
+
+            @#{symbol} = new_value
+        end
+    }
+end
+
+def attr_private_limited_regex_accessor(symbol, regex)
+    class_eval %{
+        def #{symbol}
+            @#{symbol}
+        end
+
+        private def #{symbol}=(new_value)
+            if new_value != nil && new_value !~ #{regex}
+                raise "invalid #{symbol} format"
+            end
+
+            @#{symbol} = new_value
+        end
+    }
+end
+
+def attr_private_accessor(symbol)
+    class_eval %{
+        private def #{symbol}
+            @#{symbol}
+        end
+
+        private def #{symbol}=(new_value)
+            @#{symbol} = new_value
+        end
+    }
+end

data/model_gem_source/controllers/create_student_controller.rb

@@ -0,0 +1,10 @@
+require_relative './create_student_view.rb'
+
+class CreateStudentController
+    attr_reader :ui
+    attr_accessor :onCreate
+
+    def initialize()
+        @ui = CreateStudentView.new(self, nil)
+    end
+end

data/model_gem_source/controllers/edit_student_controller.rb

@@ -0,0 +1,11 @@
+class EditStudentController
+    attr_reader :ui
+    attr_accessor :onCreate
+    attr_reader :edit_user_id
+
+    def initialize(student)
+        @edit_user_id = student.id
+        @ui = CreateStudentView.new(self, student)
+        @ui.set_editing_mode()
+    end
+end

data/model_gem_source/controllers/view_controller.rb

@@ -0,0 +1,96 @@
+require_relative './../../data_construct_pattern/data_construct_pattarn.rb'
+require_relative './main_view.rb'
+require_relative './../create_student_window/create_student_controller.rb'
+require_relative './../create_student_window/edit_student_controller.rb'
+
+class ViewController
+    attr_private_accessor :model
+    attr_private_accessor :view
+    attr_private_accessor :data_list
+
+    attr_accessor :selected_page
+
+    def initialize(model)
+        self.model = model
+
+        self.selected_page = 0
+
+        self.data_list = DataListStudentShort.new(list: [], data_constructor: DefaultDataConstructPattern.new())
+        self.model.get_students(0, 10, self.data_list)
+
+        self.view = MainView.new(self)
+        self.data_list.add_observer(self.view.filter_tab)
+
+        update_table()
+        
+        self.view.window_view.open
+    end
+end
+
+
+# StudentsListViewDelegate
+class ViewController 
+    def pages_count
+        (model.count / 10.0).ceil
+    end
+
+    def table_columns
+        self.data_list.get_names
+    end
+
+    def next_page
+        if self.selected_page != self.pages_count - 1
+            self.selected_page += 1
+        end
+
+        puts self.selected_page
+
+        update_table()
+    end
+
+    def last_page
+        if self.selected_page != 0
+            self.selected_page -= 1
+        end
+
+        puts self.selected_page
+
+        
+        update_table()
+    end
+
+    def update_table
+        model.get_students(self.selected_page * 10, (self.selected_page + 1) * 10, self.data_list)
+        self.view.filter_tab.next_page_button.enabled = self.selected_page != self.pages_count - 1
+        self.view.filter_tab.last_page_button.enabled = self.selected_page != 0
+
+        self.view.filter_tab.table_title.text = (self.selected_page + 1).to_s + " из " + self.pages_count.to_s
+    end
+
+    def open_student_creation_window()
+        controller = CreateStudentController.new()
+        controller.onCreate = lambda { |student|
+            puts student
+            model.add_student(student)
+            update_table()
+        }
+
+        controller.ui.present
+    end
+
+    def open_student_editing_window(id)
+        student = model.get_student(id)
+        controller = EditStudentController.new(student)
+        controller.onCreate = lambda { |student|
+            model.replace_student(controller.edit_user_id, student)
+            update_table()
+        }
+
+        controller.ui.present
+    end
+
+    def remove_student(id)
+        model.remove_student(id)
+        update_table()
+    end
+end

data/model_gem_source/data_construct_pattern/data_construct_pattarn.rb

@@ -0,0 +1,23 @@
+class DataConstructPattern 
+    def execute(values, attrs)
+        raise 'Метод не реализован'
+    end
+end
+
+class DefaultDataConstructPattern 
+    def execute(values, attrs)
+        (0...values.size).map { |item_index|
+            [
+                values[item_index].id,
+                values[item_index].lastname,
+                values[item_index].firstname,
+                values[item_index].patronymic,
+                values[item_index].git,
+                values[item_index].telegram,
+                values[item_index].phone,
+                values[item_index].email
+            ]
+        }
+    end
+end
+

data/model_gem_source/data_list.rb

@@ -0,0 +1,57 @@
+module DataListObserver
+    def notify(data)
+        raise 'not implemented'
+    end
+end
+
+module DataListNotifier
+    attr_accessor :data_list_observers
+
+    def notify
+        raise 'not implemented'
+    end
+end
+
+class DataList 
+    attr_accessor :list
+    attr_private_accessor :selected_objects
+    def initialize(list:)
+        self.data_list_observers = []
+        self.list = list
+    end
+
+    def select(index)
+        selected_objects << index
+    end
+
+    def get_selected_objects
+        (0...list.size)
+            .filter { |x| selected_objects.include? x }
+    end
+
+    def get_names
+        raise "Метод не реализован"
+    end
+
+    def get_data
+        raise "Метод не реализован"
+    end
+end
+
+class DataList
+    include DataListNotifier
+
+    def notify
+        data_list_observers.each { |observer|
+            observer.notify(self.get_data)
+        }
+    end
+
+    def add_observer(observer)
+        self.data_list_observers << observer
+    end
+
+    def remove_observer(observer)
+        self.data_list_observers.delete(observer) 
+    end
+end

data/model_gem_source/data_list_student_short.rb

@@ -0,0 +1,26 @@
+require_relative './data_list.rb'
+require_relative './data_table.rb'
+
+class DataListStudentShort < DataList 
+
+    attr_private_accessor :data_constructor
+
+    def initialize(list:, data_constructor:) 
+        self.data_constructor = data_constructor
+
+        super(list: list)
+    end
+
+    def get_names
+        ["ID", "Фамилия", "Имя", "Отчество", "Гит", "Телега", "Телефон", "Почта"]
+    end
+
+    def get_data 
+        self.data_constructor.execute(list, get_names)
+    end
+
+    def list=(new_list)
+        @list = new_list
+        notify()
+    end
+end

data/model_gem_source/data_table.rb

@@ -0,0 +1,19 @@
+class DataTable
+    attr_private_accessor :data
+
+    def initialize(data:)
+        self.data = data
+    end
+
+    def element(row:, column:)
+        data[row][column]
+    end
+
+    def columnsCount 
+        data[0].size
+    end
+
+    def rowsCount
+        data.size
+    end
+end

data/model_gem_source/database/scripts/create_table.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS student(
+    id INT NOT NULL auto_increment PRIMARY KEY,
+    lastname CHAR(255) NOT NULL,
+    firstname CHAR(255) NOT NULL,
+    patronymic CHAR(255) NOT NULL,
+    git CHAR(255),
+    phone CHAR(255),
+    email CHAR(255),
+    telegram CHAR(255)
+);

data/model_gem_source/database/scripts/fill_data.sql

@@ -0,0 +1,4 @@
+INSERT INTO student (lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+ROW("Хахук", "Рустам", "Нальбиевич", "@Null-Delta", NULL, NULL, NULL),
+ROW("Нагалевский", "Артем", "Михайлович", "@Jakeapps", "+7-800-555-35-35", NULL, NULL),
+ROW("Гиренко", "Даниил", "Евгениевич", "@iamgirya", NULL, "iamgirya@yandex.ru", NULL)

data/model_gem_source/database/students_db.rb

@@ -0,0 +1,75 @@
+require 'mysql2'
+
+class StudentsDB
+    attr_private_accessor :db_connection
+
+    def initialize()
+        self.db_connection = Mysql2::Client.new(:host => "localhost", :username => "root")
+        self.db_connection.query('CREATE DATABASE IF NOT EXISTS my_db')
+        self.db_connection.query('USE my_db')
+        self.db_connection.query('DROP TABLE IF EXISTS student')
+        self.db_connection.query(File.read('database/scripts/create_table.sql'))
+        self.fill_data()
+    end
+
+    private def fill_data()
+        db_connection.query(File.read('database/scripts/fill_data.sql'))
+    end
+
+    def select_by_id(id)
+        db_connection.query("SELECT * FROM student WHERE id = #{id}").map { |x| x }[0]
+    end
+
+    def remove_by_id(id)
+        db_connection.query("DELETE FROM student WHERE id = #{id}")
+    end
+
+    def replace_by_id(id, student_json)
+        db_connection.query("DELETE FROM student WHERE id = #{id}")
+        db_connection.query("""
+            INSERT INTO student (id, lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+            ROW(
+                \"#{id}\",
+                \"#{attr_or_null(student_json[:lastname])}\",
+                \"#{attr_or_null(student_json[:firstname])}\",
+                \"#{attr_or_null(student_json[:patronymic])}\", 
+                \"#{attr_or_null(student_json[:git])}\", 
+                \"#{attr_or_null(student_json[:phone])}\",
+                \"#{attr_or_null(student_json[:email])}\",
+                \"#{attr_or_null(student_json[:telegram])}\"
+            )
+            """)
+    end
+
+    def add_student(student_json)
+        puts student_json[:lastname]
+        db_connection.query("""
+        INSERT INTO student (lastname, firstname, patronymic, git, phone, email, telegram) VALUES
+        ROW(
+            \"#{attr_or_null(student_json[:lastname])}\",
+            \"#{attr_or_null(student_json[:firstname])}\",
+            \"#{attr_or_null(student_json[:patronymic])}\", 
+            \"#{attr_or_null(student_json[:git])}\", 
+            \"#{attr_or_null(student_json[:phone])}\",
+            \"#{attr_or_null(student_json[:email])}\",
+            \"#{attr_or_null(student_json[:telegram])}\"
+        )
+        """)
+    end
+
+    def select_students(from, to)
+        db_connection.query("SELECT * FROM student LIMIT #{from}, #{to}")
+    end
+
+    def count()
+        db_connection.query("SELECT * FROM student").count
+    end
+
+    private def attr_or_null(attr) 
+        if attr == nil
+            "NULL"
+        else
+            attr
+        end
+    end
+end

data/model_gem_source/database/students_list_db.rb

@@ -0,0 +1,34 @@
+require_relative './students_db.rb'
+
+class StudentsListDB    
+    private_class_method :new
+
+    def self.get_student(id)
+        Student.from_json(StudentsListDB.database.select_by_id(id))
+    end
+
+    def self.remove_student(id)
+        StudentsListDB.database.remove_by_id(id)
+    end
+
+    def self.replace_student(id, student)
+        StudentsListDB.database.replace_by_id(id, student.as_json)
+    end
+
+    def self.add_student(student)
+        StudentsListDB.database.add_student(student.as_json)
+    end
+
+    def self.get_students_slice(from, to)
+        StudentsListDB.database.select_students(from, to).map { |x| Student.from_json(x) }
+    end
+
+    def self.count()
+        StudentsListDB.database.count()
+    end
+
+    def self.database
+        @database ||= StudentsDB.new()
+        @database
+    end
+end

data/model_gem_source/student/abstract_student.rb

@@ -0,0 +1,24 @@
+class AbstractStudent
+    private_class_method :new
+    attr_accessor :lastname, :firstname, :patronymic, :id
+
+    def get_info
+        raise "method not implemented"
+    end
+
+    def fio_info
+        raise "method not implemented"
+    end
+
+    def contacts_info
+        raise "method not implemented"
+    end
+
+    def to_s
+        get_info
+    end
+
+    def as_json 
+
+    end
+end

data/model_gem_source/student/student.rb

@@ -0,0 +1,118 @@
+require_relative "../attr_limited_regex_accessor.rb"
+require_relative "./abstract_student.rb"
+
+class Student < AbstractStudent    
+    attr_limited_regex_accessor :phone, '/\d-\d{3}-\d{3}-\d{2}-\d{2}/'
+    attr_limited_regex_accessor :email, '/\w*@\w*.\w{2,3}/'
+    attr_limited_regex_accessor :telegram, '/@\w*/'
+    attr_limited_regex_accessor :git, '/@\w*/'
+
+    public_class_method :new
+
+    def initialize(
+        lastname:,
+        firstname:,
+        patronymic:,
+        params: {}
+    )
+        self.lastname = lastname
+        self.firstname = firstname
+        self.patronymic = patronymic
+        self.id = params[:id]
+
+        self.phone = params[:phone]
+        self.telegram = params[:telegram]
+        self.email = params[:email]
+        self.git = params[:git]
+
+        validate()
+    end
+
+    def self.from_json(json)
+        params = json.map { |v| 
+            [v[0].to_sym, v[1]]
+        }.filter { |v|
+            v[1] != "NULL"
+        }.to_h
+
+        Student.new(
+            lastname: json["lastname"],
+            firstname: json["firstname"],
+            patronymic: json["patronymic"],
+            params: params
+        )
+    end
+
+    def self.from_string(str)
+        params = str
+        .split(";")
+        .map { |x| x.split(":") }
+        .map { |x| [x[0].to_sym, x[1]] }
+        .to_h
+
+        if params[:fio] == nil
+            raise "invalid string representation"
+        end
+
+        fio_components = params[:fio].split(" ")
+
+        Student.new(
+            lastname: fio_components[0],
+            firstname: fio_components[1],
+            patronymic: fio_components[2],
+            params: params
+        )
+    end
+
+    def have_any_contact
+        phone != nil || telegram  != nil || email != nil || git != nil
+    end
+
+    def validate
+        if !have_any_contact 
+            raise "Not finded git or any contact"
+        end
+    end
+
+    def set_contacts(phone: nil, email: nil, git: nil, telegram: nil)
+        if phone != nil then self.phone = phone end
+        if email != nil then self.email = email end
+        if git != nil then self.git = git end
+        if telegram != nil then self.telegram = telegram end
+    end
+
+    def contacts_info
+        contacts = ""
+        if git != nil then contacts << "git:#{git};" end
+        if phone != nil then contacts << "phone:#{phone};" end
+        if email != nil then contacts << "email:#{email};" end
+        if telegram != nil then contacts << "telegram:#{telegram};" end
+        
+        contacts
+    end
+
+    def get_info
+        if id != nil
+            "id:#{id};#{fio_info};#{contacts_info}"
+        else 
+            "#{fio_info};#{contacts_info}"
+        end
+    end
+
+    def fio_info
+        "fio:#{lastname} #{firstname} #{patronymic}"
+    end
+
+    def as_json 
+        {
+            lastname: lastname,
+            firstname: firstname,
+            patronymic: patronymic,
+            id: id,
+            phone: phone,
+            email: email,
+            git: git,
+            telegram: telegram
+        }
+    end
+end

data/model_gem_source/student/student_short.rb

@@ -0,0 +1,57 @@
+require_relative "../attr_limited_regex_accessor.rb"
+require_relative "./abstract_student.rb"
+
+class StudentShort < AbstractStudent
+    attr_private_limited_regex_accessor :git, '/@\w*/'
+    attr_private_limited_regex_accessor :email, '/\w*@\w*.\w{2,3}/'
+
+    public_class_method :new
+
+    def initialize(id:, fio:, git:, email:)
+        fio_components = fio.split(" ")
+
+        self.id = id
+        self.firstname = fio_components[0]
+        self.lastname = fio_components[1]
+        self.patronymic = fio_components[2]
+
+        self.git = git
+        self.email = email
+    end
+
+    def self.from_student(student) 
+        StudentShort.new(
+            id: student.id, 
+            fio: "#{student.firstname} #{student.lastname} #{student.patronymic}",
+            git: student.git,
+            email: student.email
+        )
+    end
+
+    def self.from_string(id, info) 
+        params = info
+        .split(";")
+        .map { |x| x.split(":") }
+        .map { |x| [x[0].to_sym, x[1]] }
+        .to_h
+
+        StudentShort.new(
+            id: id, 
+            fio: params[:fio],
+            git: params[:git],
+            email: params[:email]
+        )
+    end
+
+    def fio_info
+        "fio:#{firstname} #{lastname.upcase[0]} #{patronymic.upcase[0]}"
+    end
+
+    def contacts_info
+        "git:#{git};email:#{email}"
+    end
+
+    def get_info
+        [fio_info, contacts_info].join(";")
+    end
+end

data/model_gem_source/student_list_format.rb

@@ -0,0 +1,48 @@
+class StudentListFormat
+    attr_private_accessor :students
+    attr_accessor :formater
+
+    def initialize(formater)
+        self.formater = formater
+    end
+
+    def read_from(filename)
+        self.students = formater.read_from(filename)
+    end
+
+    def write_to(filename)
+        formater.write_to(filename, self.students)
+    end
+
+    def get_student(id)
+        self.students.detect { |x|
+            x.id == id .to_s
+        }
+    end
+
+    def add_student(student)
+        self.students << student
+    end
+
+    def delete_student(id)
+        index = students.index(students.detect { |x| x.id == id.to_s })
+        self.students.delete_at(index)
+    end
+
+    def replace_student(id, student)
+        self.students.map! { |x| x.id == id.to_s ? student : x }
+    end
+
+    def get_students_slice(k, count)
+        from = [k * count, self.students.count].min
+        to = [self.students.count, from + count].min
+    end
+
+    def count()
+        self.students.count
+    end
+
+    def sort()
+        self.students.sort_by(&:fio_info)
+    end
+end

data/model_gem_source/students_list.rb

@@ -0,0 +1,40 @@
+require_relative "./attr_limited_regex_accessor.rb"
+class StudentsList 
+    attr_private_accessor :students_list_adapter
+
+    def initialize(adapter)
+        self.students_list_adapter = adapter
+    end
+
+    def get_student(id)
+        students_list_adapter.get_student(id)
+    end
+
+    def remove_student(id)
+        students_list_adapter.remove_student(id)
+    end
+
+    def replace_student(id, student)
+        students_list_adapter.replace_student(id, student)
+    end
+
+    def get_students(from, to, data)
+        values = students_list_adapter.get_students(from, to)
+
+        if data == nil
+            data = DataList.new(list: values)
+        else
+            data.list = values
+        end
+
+        data.list
+    end
+
+    def add_student(student)
+        students_list_adapter.add_student(student)
+    end
+
+    def count
+        students_list_adapter.count()
+    end
+end

data/model_gem_source/students_list_adapter.rb

@@ -0,0 +1,87 @@
+class StudentsListAdapter 
+    def get_student(id)
+    end
+
+    def remove_student(id)
+    end
+
+    def replace_student(id, student, data)
+    end
+
+    def get_students(from, to, data)
+    end
+
+    def add_student(student)
+    end
+
+    def count
+    end
+end
+
+class StudentsListDBAdapter < StudentsListAdapter
+    attr_private_accessor :database_list
+
+    def initialize(database_list)
+        self.database_list = database_list
+    end
+
+    def get_student(id)
+        database_list.get_student(id)
+    end
+
+    def remove_student(id)
+        database_list.remove_student(id)
+    end
+
+    def replace_student(id, student)
+        database_list.replace_student(id, student)
+    end
+
+    def get_students(from, to)
+        database_list.get_students_slice(from, to)
+    end
+
+    def add_student(student)
+        database_list.add_student(student)
+    end
+
+    def count
+        database_list.count()
+    end
+end
+
+class StudentsListFormatterAdapter < StudentsListAdapter
+    attr_private_accessor :formatter
+
+    def initialize(formatter, filename)
+        self.formatter = formatter
+        formatter.read_from(filename)
+    end
+
+    def get_student(id)
+        formatter.get_student(id)
+    end
+
+    def remove_student(id)
+        formatter.delete_student(id)
+    end
+
+    def replace_student(id, student)
+        formatter.replace_student(id, student)
+    end
+
+    def get_students(from, to)
+        count = to - from
+        k = from / count
+        
+        formatter.get_students_slice(k, count)
+    end
+
+    def add_student(student)
+        formatter.add_student(student)
+    end
+
+    def count
+        formatter.count()
+    end
+end

data/model_gem_source/students_list_format_strategy.rb

@@ -0,0 +1,57 @@
+require 'json'
+require 'yaml'
+
+class StudentsListFormatStrategy
+    def read_from(filename)
+        require 'method not implemented'
+    end
+
+    def write_to(filename, students)
+        require 'method not implemented'
+    end
+end
+
+class TxtStudentsListFormatStrategy < StudentsListFormatStrategy
+    def read_from(filename)
+        File.read(filename)
+        .split("\n")
+        .map { |v| Student.from_string(v) }
+    end
+
+    def write_to(filename, students)
+        File.open(filename, 'w') { |file| 
+            file.write(
+                students.map { |student| 
+                    student.get_info
+                }
+                .join("\n")
+            )
+        }
+    end
+end
+
+class JsonStudentsListFormatStrategy < StudentsListFormatStrategy
+    def read_from(filename)
+        file = File.read(filename)
+        json = JSON.parse(file)
+        json.map { |x| Student.from_json(x) }
+    end
+
+    def write_to(filename, students)
+        File.open(filename, 'w') do |f|
+            f.write(JSON.generate(students.map { |x| x.as_json }))
+        end
+    end
+end
+
+class YamlStudentsListFormatStrategy < StudentsListFormatStrategy
+    def read_from(filename)
+        YAML.load_file(filename)
+    end
+    
+    def write_to(filename, students)
+        File.open(filename, 'w') do |file|
+            file.write(students.to_yaml)
+        end
+    end
+end

data/model_gem_source/students_tests.rb

@@ -0,0 +1,70 @@
+require "test/unit"
+require_relative "./students_list.rb"
+require_relative "./attr_limited_regex_accessor.rb"
+require_relative "./students_list_adapter.rb"
+require_relative "./database/students_list_db.rb"
+require_relative "./student/student.rb"
+require_relative "./data_list.rb"
+
+class StudentsTests < Test::Unit::TestCase
+    def test_add
+        @students = StudentsList.new(
+            StudentsListDBAdapter.new(
+                StudentsListDB
+            )
+        )
+
+        @start_count = @students.count
+        
+        @students.add_student(
+            Student.new(
+                lastname: "AAA",
+                firstname: "BBB",
+                patronymic: "CCC",
+                params: {
+                    email: "test@email.com"
+                }
+            )    
+        )
+
+        assert_equal(1, @students.count - @start_count)
+    end
+
+    def test_delete
+        @students = StudentsList.new(
+            StudentsListDBAdapter.new(
+                StudentsListDB
+            )
+        )
+
+        @students.add_student(
+            Student.new(
+                lastname: "AAA",
+                firstname: "BBB",
+                patronymic: "CCC",
+                params: {
+                    email: "test@email.com"
+                }
+            )    
+        )
+
+        @students.add_student(
+            Student.new(
+                lastname: "AAA",
+                firstname: "BBB",
+                patronymic: "CCC",
+                params: {
+                    email: "test@email.com"
+                }
+            )    
+        )
+
+        @current_count = @students.count
+
+        @students_list = @students.get_students(0, 10, nil)
+
+        @students.remove_student(@students_list[0].id)
+
+        assert_equal(1, @current_count - @students.count)
+    end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: model_gem
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- Null_Delta
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-04-28 00:00:00.000000000 Z
+dependencies: []
+description: Гем с модельками и контроллерами
+email:
+- delta.null@vk.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./model_gem_source/attr_limited_regex_accessor.rb"
+- "./model_gem_source/controllers/create_student_controller.rb"
+- "./model_gem_source/controllers/edit_student_controller.rb"
+- "./model_gem_source/controllers/view_controller.rb"
+- "./model_gem_source/data_construct_pattern/data_construct_pattarn.rb"
+- "./model_gem_source/data_list.rb"
+- "./model_gem_source/data_list_student_short.rb"
+- "./model_gem_source/data_table.rb"
+- "./model_gem_source/database/scripts/create_table.sql"
+- "./model_gem_source/database/scripts/fill_data.sql"
+- "./model_gem_source/database/students_db.rb"
+- "./model_gem_source/database/students_list_db.rb"
+- "./model_gem_source/student/abstract_student.rb"
+- "./model_gem_source/student/student.rb"
+- "./model_gem_source/student/student_short.rb"
+- "./model_gem_source/student_list_format.rb"
+- "./model_gem_source/students_list.rb"
+- "./model_gem_source/students_list_adapter.rb"
+- "./model_gem_source/students_list_format_strategy.rb"
+- "./model_gem_source/students_tests.rb"
+homepage: https://rubygems.org/gems/model_gem
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://rubygems.org/gems/model_gem
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Гем с модельками и контроллерами
+test_files: []