Создание приложения на Rust с помощью GPUI

[workspace]members = ["crates/app", "crates/core", "crates/di", "crates/infrastructure", "crates/ui"]default-members = ["crates/app"]resolver = "2"[workspace.dependencies]jojo_stand_viewer = { path = "crates/app" }core = { path = "crates/core" }di = { path = "crates/di" }infrastructure = { path = "crates/infrastructure" }ui = { path = "crates/ui" }gpui = "0.2.2"gpui-component = "0.5.1"serde = { version = "1.0", features = ["derive"] }csv = "1.3.1"anyhow = "1.0"fluent-templates = "0.14" unic-langid = "0.9"

[package]name = "core"version = "1.2.0"edition = "2024"[dependencies]

/// Represents the statistical rank of a Stand's attribute in JoJo's Bizarre Adventure./// /// Used to classify capabilities such as Power, Speed, Range, Power Persistence, Precision, and Developmental Potential.#[derive(Debug, Clone, Copy)]pub enum Rank {    None,    E,    D,    C,    B,    A,    Infinite,}impl Rank {    /// Converts the rank into a numeric value.    ///    /// # Returns    ///    /// * A `u8` integer mapping from 0 (None) to 6 (Infinite) representing the attribute level.    pub fn to_u8(&self) -> u8 {        match self {            Rank::None => 0,            Rank::E => 1,            Rank::D => 2,            Rank::C => 3,            Rank::B => 4,            Rank::A => 5,            Rank::Infinite => 6        }    }    /// Converts the rank into a `String`.    ///    /// # Returns    ///    /// * A heap-allocated `String` containing the official text name of the rank.    pub fn to_string(&self) -> String {        match self {            Rank::None => String::from("None"),            Rank::E => String::from("E"),            Rank::D => String::from("D"),            Rank::C => String::from("C"),            Rank::B => String::from("B"),            Rank::A => String::from("A"),            Rank::Infinite => String::from("Infinite")        }    }}

use crate::types::Rank;/// Represents a Stand with its name and statistical attributes.#[derive(Debug, Clone)]pub struct StandModel {    name: String,    power: Rank,    speed: Rank,    range: Rank,    power_persistence: Rank,    precision: Rank,    development_potential: Rank}impl StandModel {    /// Creates a new instance of a `StandModel` with the specified name and attributes.    ///    /// # Arguments    ///    /// * `name` - The unique name of the Stand.    /// * `power` - The Power rank.    /// * `speed` - The Speed rank.    /// * `range` - The Range rank.    /// * `power_persistence` - The Power Persistence rank.    /// * `precision` - The Precision rank.    /// * `development_potential` - The Developmental Potential rank.    ///    /// # Returns    ///    /// * An initialized `StandModel` instance containing the provided attributes.    pub fn new(        name: String,        power: Rank,        speed: Rank,        range: Rank,        power_persistence: Rank,        precision: Rank,        development_potential: Rank    ) -> Self {        StandModel {            name,            power,            speed,            range,            power_persistence,            precision,            development_potential        }    }    /// Returns a string slice referencing the Stand's name.    ///    /// # Returns    ///    /// * A string slice (`&str`) referencing the heap-allocated name of the Stand.    pub fn name(&self) -> &str {        &self.name    }    /// Returns the Stand's Power rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's power level.    pub fn power(&self) -> Rank {        self.power    }    /// Returns the Stand's Speed rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's speed level.    pub fn speed(&self) -> Rank {        self.speed    }    /// Returns the Stand's Range rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's maximum operational distance.    pub fn range(&self) -> Rank {        self.range    }    /// Returns the Stand's Power Persistence rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's ability to maintain its state over time.    pub fn power_persistence(&self) -> Rank {        self.power_persistence    }    /// Returns the Stand's Precision rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's accuracy and combat control.    pub fn precision(&self) -> Rank {        self.precision    }    /// Returns the Stand's Developmental Potential rank.    ///    /// # Returns    ///    /// * The `Rank` enum representing the Stand's capacity to evolve or manifest new skills.    pub fn development_potential(&self) -> Rank {        self.development_potential    }}impl Default for StandModel {    /// Creates a default placeholder state when no Stand is currently selected.    ///    /// # Returns    ///    /// * A `StandModel` instance with the name "No selected" and all attributes set to `Rank::None`.    fn default() -> Self {        StandModel {            name: String::from("No selected"),            power: Rank::None,            speed: Rank::None,            range: Rank::None,            power_persistence: Rank::None,            precision: Rank::None,            development_potential: Rank::None        }    }}

use crate::models::StandModel;/// A thread-safe repository trait defining data access operations for Stands.pub trait StandRepository: Send + Sync {    /// Retrieves all available Stands from the storage source.    ///    /// # Returns    ///    /// * A `Vec<StandModel>` containing a collection of all stored Stand models.    fn get_all(&self) -> Vec<StandModel>;    /// Retrieves a specific Stand model by its unique name identifier.    ///    /// # Arguments    ///    /// * `name` - A string slice referencing the unique name of the Stand to search for.    ///    /// # Returns    ///    /// * An `Option<StandModel>` containing `Some(StandModel)` if a match is found, or `None` if it does not exist.    fn get_by_name(&self, name: &str) -> Option<StandModel>;}

use std::sync::Arc;use crate::repositories::StandRepository;use crate::models::StandModel;/// A service layer structural component providing high-level business logic operations for Stands.pub struct StandService {    stand_repository: Arc<dyn StandRepository>,}impl StandService {    /// Creates a new instance of a `StandService` injected with a thread-safe repository implementation.    ///    /// # Arguments    ///    /// * `stand_repository` - An atomically reference-counted pointer (`Arc`) wrapping a dynamic `StandRepository` trait object.    ///    /// # Returns    ///    /// * An initialized `StandService` instance.    pub fn new(stand_repository: Arc<dyn StandRepository>) -> Self {        Self {             stand_repository         }    }    /// Fetches a complete collection of all stored Stand models via the underlying repository.    ///    /// # Returns    ///    /// * A `Vec<StandModel>` containing all available Stands.    pub fn get_all(&self) -> Vec<StandModel> {        self.stand_repository.get_all()    }    /// Fetches a specific Stand model by its unique name identifier via the underlying repository.    ///    /// # Arguments    ///    /// * `name` - A string slice referencing the unique name of the Stand.    ///    /// # Returns    ///    /// * An `Option<StandModel>` containing `Some(StandModel)` if found, or `None` if no match exists.    pub fn get_by_name(&self, name: &str) -> Option<StandModel> {        self.stand_repository.get_by_name(name)    }}

[package]name = "infrastructure"version = "1.2.0"edition = "2024"[dependencies]core.workspace = trueserde.workspace = truecsv.workspace = true

use serde::{Serialize, Deserialize};/// A Data Transfer Object (DTO) representing a Stand's statistical rank during serialization and deserialization.#[derive(Debug, Clone, Copy, Serialize)]pub enum RankDto {    None,    E,    D,    C,    B,    A,    Infi}impl From<&str> for RankDto {    /// Maps a raw string slice representation of a rank into a matching `RankDto` variant.    ///    /// # Arguments    ///    /// * `s` - A raw string slice parsed from the data source.    ///    /// # Returns    ///    /// * The corresponding `RankDto` variant, defaulting to `RankDto::None` if the input string is unrecognized.    fn from(s: &str) -> Self {        match s {            "None" => RankDto::None,            "E" => RankDto::E,            "D" => RankDto::D,            "C" => RankDto::C,            "B" => RankDto::B,            "A" => RankDto::A,            "Infi" => RankDto::Infi,            _ => RankDto::None,        }    }}impl<'de> Deserialize<'de> for RankDto {    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>    where        D: serde::Deserializer<'de>    {        let s = String::deserialize(deserializer)?;        Ok(RankDto::from(s.as_str()))    }}

use serde::{Serialize, Deserialize};use super::RankDto;/// A Data Transfer Object (DTO) used for flat-file deserialization and serialization of Stand records.#[derive(Debug, Clone, Serialize, Deserialize)]pub struct StandDto {    #[serde(rename = "Stand")]    stand: String,    #[serde(rename = "PWR")]    pwr: RankDto,    #[serde(rename = "SPD")]    spd: RankDto,    #[serde(rename = "RNG")]    rng: RankDto,    #[serde(rename = "PER")]    per: RankDto,    #[serde(rename = "PRC")]    prc: RankDto,    #[serde(rename = "DEV")]    dev: RankDto}impl StandDto {    /// Creates a new instance of a `StandDto` with explicit raw transfer components.    ///    /// # Arguments    ///    /// * `stand` - The raw name string of the Stand.    /// * `pwr` - The mapped raw power rank token.    /// * `spd` - The mapped raw speed rank token.    /// * `rng` - The mapped raw range rank token.    /// * `per` - The mapped raw persistence rank token.    /// * `prc` - The mapped raw precision rank token.    /// * `dev` - The mapped raw development potential rank token.    ///    /// # Returns    ///    /// * An initialized `StandDto` transfer state payload container.    pub fn new(        stand: String,        pwr: RankDto,        spd: RankDto,        rng: RankDto,        per: RankDto,        prc: RankDto,        dev: RankDto    ) -> Self {        StandDto {            stand,            pwr,            spd,            rng,            per,            prc,            dev        }    }    /// Accesses the raw name of the Stand.    ///    /// # Returns    ///    /// * A string slice referencing the internal name identifier.    pub fn stand(&self) -> &str {        &self.stand    }    /// Accesses the raw short power rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for power.    pub fn power(&self) -> RankDto {        self.pwr    }    /// Accesses the raw short speed rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for speed.    pub fn speed(&self) -> RankDto {        self.spd    }    /// Accesses the raw short range rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for range.    pub fn range(&self) -> RankDto {        self.rng    }    /// Accesses the raw short power persistence rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for power persistence.    pub fn power_persistence(&self) -> RankDto {        self.per    }    /// Accesses the raw short precision rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for precision.    pub fn precision(&self) -> RankDto {        self.prc    }    /// Accesses the raw short developmental potential rank data token.    ///    /// # Returns    ///    /// * The `RankDto` enumeration token value for developmental potential.    pub fn development_potential(&self) -> RankDto {        self.dev    }}

/// A generic data mapping abstraction layer used to convert data structures between different architectural layers.////// Typically implemented within the infrastructure layer to decouple core domain models from external Data Transfer Objects (DTOs).////// # Type Parameters////// * `Model` - The core domain model representing business logic rules./// * `Dto` - The data transfer representation..pub trait Mapper<Model, Dto> {    /// Maps a core domain model reference into its data transfer object counterpart.    ///    /// # Arguments    ///    /// * `model` - A shared reference (`&Model`) to the core entity being converted.    ///    /// # Returns    ///    /// * An instance of the corresponding `Dto`.    fn to_dto(model: &Model) -> Dto;    /// Maps a data transfer object reference back into its core domain model representation.    ///    /// # Arguments    ///    /// * `dto` - A shared reference (`&Dto`) to the data transfer object layout being converted.    ///    /// # Returns    ///    /// * An instance of the corresponding core `Model`.    fn to_model(dto: &Dto) -> Model;}

use core::types::Rank;use crate::dtos::RankDto;use super::mapper::Mapper;/// A stateless mapping utility responsible for converting between domain `Rank` enums and infrastructure `RankDto` representations.pub struct RankMapper;impl Mapper<Rank, RankDto> for RankMapper {    /// Maps a domain `Rank` reference into its infrastructure-specific `RankDto` counterpart.    ///    /// # Arguments    ///    /// * `model` - A shared reference to the domain `Rank` enum variant.    ///    /// # Returns    ///    /// * The corresponding `RankDto` enum variant used for transfer layouts.    fn to_dto(model: &Rank) -> RankDto {        match model {            Rank::None => RankDto::None,            Rank::E => RankDto::E,            Rank::D => RankDto::D,            Rank::C => RankDto::C,            Rank::B => RankDto::B,            Rank::A => RankDto::A,            Rank::Infinite => RankDto::Infi        }    }    /// Maps an infrastructure `RankDto` reference back into its domain `Rank` representation.    ///    /// # Arguments    ///    /// * `dto` - A shared reference to the `RankDto` data serialization variant.    ///    /// # Returns    ///    /// * The corresponding core domain `Rank` enum variant.    fn to_model(dto: &RankDto) -> Rank {        match dto {            RankDto::None => Rank::None,            RankDto::E => Rank::E,            RankDto::D => Rank::D,            RankDto::C => Rank::C,            RankDto::B => Rank::B,            RankDto::A => Rank::A,            RankDto::Infi => Rank::Infinite        }    }}

use core::models::StandModel;use crate::dtos::StandDto;use super::mapper::Mapper;use crate::mappers::RankMapper;/// A stateless mapping utility responsible for converting between complex domain `StandModel` structures and flattened infrastructure `StandDto` data layers.pub struct StandMapper;impl Mapper<StandModel, StandDto> for StandMapper {    /// Maps a domain `StandModel` reference into its infrastructure-specific serialized `StandDto` layout.    ///    /// # Arguments    ///    /// * `model` - A shared reference to the domain `StandModel`.    ///    /// # Returns    ///    /// * A fully initialized `StandDto` instance containing mapped attribute transfer tokens.    fn to_dto(model: &StandModel) -> StandDto {        StandDto::new(            String::from(model.name()),            RankMapper::to_dto(&model.power()),            RankMapper::to_dto(&model.speed()),            RankMapper::to_dto(&model.range()),            RankMapper::to_dto(&model.power_persistence()),            RankMapper::to_dto(&model.precision()),            RankMapper::to_dto(&model.development_potential())        )    }    /// Maps a raw infrastructure `StandDto` data transfer record back into a domain `StandModel`.    ///    /// # Arguments    ///    /// * `dto` - A shared reference to the deserialized external `StandDto` data block.    ///    /// # Returns    ///    /// * A core domain `StandModel` instance.    fn to_model(dto: &StandDto) -> StandModel {        StandModel::new(            String::from(dto.stand()),            RankMapper::to_model(&dto.power()),            RankMapper::to_model(&dto.speed()),            RankMapper::to_model(&dto.range()),            RankMapper::to_model(&dto.power_persistence()),            RankMapper::to_model(&dto.precision()),            RankMapper::to_model(&dto.development_potential())        )    }}

use std::error::Error;use std::fs::File;use std::io::BufReader;use csv::Reader;use core::models::StandModel;use core::repositories::StandRepository;use crate::dtos::StandDto;use crate::mappers::{Mapper,StandMapper};use crate::file::PathManager;pub struct CsvStandRepository {    items: Vec<StandModel>,}/// An implementation of `StandRepository` that loads and caches data from a flat CSV file.impl CsvStandRepository {    /// Initializes the repository by parsing records from a CSV file.    ///    /// # Arguments    ///    /// * `path_manager` - A shared reference to the utility managing environment file paths.    ///    /// # Returns    ///    /// * A `Result` containing the initialized `CsvStandRepository` state on success, or a dynamic wrapper of any IO/Parsing error.    pub fn new(path_manager: &PathManager) -> Result<Self, Box<dyn Error>> {        let mut items = Vec::new();        let path = path_manager.csv_path();        let file = File::open(path)?;        let reader = BufReader::new(file);        let mut rdr = Reader::from_reader(reader);        for result in rdr.deserialize() {            let record: StandDto = result?;            items.push(StandMapper::to_model(&record));        }        Ok(Self { items })    }}impl StandRepository for CsvStandRepository {    /// Returns a cloned snapshot collection of all cached domain models.    ///    /// # Returns    ///    /// * A `Vec<StandModel>` populated with copies of the Stand entities.    fn get_all(&self) -> Vec<StandModel> {        self.items.clone()    }    /// Searches for a specific Stand by its unique string name in the local cached vector.    ///    /// # Arguments    ///    /// * `name` - A string slice referencing the Stand's unique lookup key.    ///    /// # Returns    ///    /// * An `Option<StandModel>` containing a cloned model instance if matched, or `None`.    fn get_by_name(&self, name: &str) -> Option<StandModel> {        self.items.iter().find(|s| s.name() == name).cloned()    }}

use std::path::{Path, PathBuf};/// A utility structure responsible for managing component file paths across the application asset space.////// It constructs and verifies path locations for static data, icons, and dynamic stand images.pub struct PathManager {    assets_dir: PathBuf,    csv_path: PathBuf}impl PathManager {    /// Constructs a new `PathManager` by combining a base directory with specific resource names.    ///    /// # Arguments    ///    /// * `base_dir` - An object that implements `AsRef<Path>` serving as the root directory of the project.    /// * `assets_dir_name` - The subfolder name string holding static resources.    /// * `csv_name` - The base name of the database file without the extension.    ///    /// # Returns    ///    /// * An initialized `PathManager` with calculated asset and database directory trees.    pub fn new(base_dir: impl AsRef<Path>, assets_dir_name: &str, csv_name: &str) -> Self {        let base_dir = base_dir.as_ref().to_path_buf();        let assets_dir = base_dir.join(assets_dir_name);        let csv_filename = format!("{}.csv", csv_name);        let csv_path = assets_dir.join("data").join(csv_filename);        PathManager {            assets_dir,            csv_path        }    }    /// Accesses the root path of the asset directory tree.    ///    /// # Returns    ///    /// * A shared reference to a `Path` pointing to the application's root asset directory.    pub fn assets_dir(&self) -> &Path {        &self.assets_dir    }    /// Accesses the designated CSV flat-file path.    ///    /// # Returns    ///    /// * A shared reference to a `Path` pointing directly to the target CSV database file.    pub fn csv_path(&self) -> &Path {        &self.csv_path    }    /// Resolves the absolute runtime path for a requested Stand profile image.    ///    /// If the specific image file does not exist on disk, it falls back to a default placeholder image.    ///    /// # Arguments    ///    /// * `path` - A string slice referencing the relative path/filename of the stand image.    ///    /// # Returns    ///    /// * A `PathBuf` container holding the verified image file path or the "unknown.png" fallback location.    pub fn image_path(&self, path: &str) -> PathBuf {        let image_path =  self.assets_dir.join("images").join(path);        if image_path.exists() {            image_path        } else {            self.assets_dir.join("images").join("unknown.png")        }    }    /// Resolves the file path for graphical asset icons.    ///    /// # Arguments    ///    /// * `path` - A string slice referencing the relative path or file descriptor of the icon.    ///    /// # Returns    ///    /// * A `PathBuf` holding the absolute directory layout path for the icon file.    pub fn icon_path(&self, path: &str) -> PathBuf {        self.assets_dir.join("icons").join(path)    }}

[package]name = "di"version = "1.2.0"edition = "2024"[dependencies]core.workspace = trueinfrastructure.workspace = truegpui.workspace = true

use std::sync::Arc;use std::path::Path;use gpui::Global;use core::repositories::StandRepository;use core::services::StandService;use infrastructure::file::PathManager;use infrastructure::repositories::CsvStandRepository;/// A centralized dependency injection container that manages the application's global state lifetimes.pub struct DependencyInjector {    path_manager: Arc<PathManager>,    stand_service: Arc<StandService>,}impl Global for DependencyInjector {}impl DependencyInjector {    /// Initializes the entire application dependency graph by assembling infrastructure and core service layers.    ///    /// # Arguments    ///    /// * `base_dir` - An object implementing `AsRef<Path>` that points to the application's root execution directory.    ///    /// # Returns    ///    /// * A `Result` containing the fully wired `DependencyInjector` container on success, or an IO/parsing startup error wrapped in a `Box`.    pub fn init(base_dir: impl AsRef<Path>) -> Result<Self, Box<dyn std::error::Error>> {        let path_manager = Arc::new(PathManager::new(base_dir, "assets", "jojo-stands"));        let csv_stand_repository = CsvStandRepository::new(&path_manager)?;        let stand_repository: Arc<dyn StandRepository> = Arc::new(csv_stand_repository);        let stand_service = Arc::new(StandService::new(stand_repository));        Ok(Self {            path_manager,            stand_service        })    }    /// Provides a thread-safe, reference-counted clone of the `PathManager` service.    ///    /// # Returns    ///    /// * An `Arc<PathManager>` pointer managing asset paths.    pub fn path_manager(&self) -> Arc<PathManager> {        self.path_manager.clone()    }    /// Provides a thread-safe, reference-counted clone of the `StandService`.    ///    /// # Returns    ///    /// * An `Arc<StandService>` pointer used for performing application operations.    pub fn stand_service(&self) -> Arc<StandService> {        self.stand_service.clone()    }}

[package]name = "ui"version = "1.2.0"edition = "2024"[dependencies]core.workspace = trueinfrastructure.workspace = truedi.workspace = truegpui.workspace = truegpui-component.workspace = truefluent-templates.workspace = trueunic-langid.workspace = true

use gpui::{App, Global, Hsla, hsla};/// Represents the active visual mode of the application's user interface.#[derive(Clone)]enum ThemeMode {    Light,    Dark}/// A comprehensive styling configuration containing color palettes and opacity settings for the UI.#[derive(Clone)]pub struct Theme {    mode: ThemeMode,    pub background_color: u32,    pub text_color: u32,    pub button_color: u32,    pub button_hover_color: u32,    pub grid_color: u32,    pub polygon_color: u32,    pub polygon_opacity: u8,    pub radar_text_color: Hsla,}impl Global for Theme {}impl Theme {    /// Constructs a predefined dark theme configuration matching low-light environment palettes.    ///    /// # Returns    ///    /// * A `Theme` instance initialized with dark background colors and high-contrast text markers.    pub fn dark() -> Self {        Self {            mode: ThemeMode::Dark,            background_color: 0x1e1e1e,            text_color: 0xffffff,            button_color: 0x2d2d2d,            button_hover_color: 0x37373d,            grid_color: 0x9d9d9d,            polygon_color: 0xff830f,            polygon_opacity: 120,            radar_text_color: hsla(0.0, 1.0, 0.99, 1.0),        }    }    /// Constructs a predefined light theme configuration matching high-luminance environment palettes.    ///    /// # Returns    ///    /// * A `Theme` instance initialized with light background colors and readable dark accents.    pub fn light() -> Self {        Self {            mode: ThemeMode::Light,            background_color: 0xffffff,            text_color: 0x1e1e1e,            button_color: 0xdadada,            button_hover_color: 0xb7b7b7,            grid_color: 0xafa9a9,            polygon_color: 0xff830f,            polygon_opacity: 120,            radar_text_color: hsla(0.0, 0.0, 0.0, 1.0),        }    }    /// Toggles the global application theme between Light and Dark modes.    ///    /// # Arguments    ///    /// * `cx` - A mutable reference to the GPUI `App` context.    pub fn toggle_theme(&self, cx: &mut App) {        let current = cx.global::<Self>().clone();        let new_theme = match current.mode {            ThemeMode::Light => Self::dark(),            ThemeMode::Dark => Self::light(),        };        cx.set_global(new_theme);        cx.refresh_windows();    }}impl Default for Theme {    fn default() -> Self {        Self::dark()    }}

use gpui::Global;use fluent_templates::{Loader, static_loader};use unic_langid::{langid, LanguageIdentifier};static_loader! {    pub static LOCALES = {        locales: "../../assets/locales",        fallback_language: "en",    };}/// A global localization manager responsible for translating UI strings and managing the application language state.#[derive(Clone)]pub struct Locale {    pub language: LanguageIdentifier,}impl Global for Locale {}impl Locale {    /// Constructs a new `Locale` manager initialized with English ("en") as the default language.    ///    /// # Returns    ///    /// * An initialized `Locale` state instance.    pub fn new() -> Self {        Self {            language: langid!("en"),        }    }    /// Looks up a localization translation resource string matching the provided key identifier.    ///    /// If the key is missing in the primary and fallback languages, it prints a warning to the console and safely returns the raw key string to avoid UI crashes.    ///    /// # Arguments    ///    /// * `key` - A string slice referencing the unique translation key.    ///    /// # Returns    ///    /// * A resolved heap-allocated `String` translation text.    pub fn translate(&self, key: &str) -> String {        LOCALES.try_lookup(&self.language, key)            .unwrap_or_else(|| {                println!("[Localization Warning] Key '{}' not found!", key);                key.to_string()             })    }    /// Toggles the active application language between Russian and English layouts.    ///    /// # Arguments    ///    /// * `cx` - A mutable reference to the global GPUI `App` application instance context.    pub fn toggle_language(&self, cx: &mut gpui::App) {        let locale = cx.global::<Self>().clone();                let new_language = if locale.language == langid!("ru") {            langid!("en")        } else {            langid!("ru")        };        cx.set_global(Locale { language: new_language });        cx.refresh_windows();    }}/// A short global utility helper function used to fetch localized strings swiftly.////// # Arguments////// * `cx` - A shared reference to the GPUI application lifecycle state context./// * `key` - The unique translation dictionary lookup identifier key token.////// # Returns////// * A thread-safe, immutable `SharedString` compatible with GPUI primitive rendering components.pub fn tr(cx: &gpui::App, key: &str) -> gpui::SharedString {    cx.global::<Locale>().translate(key).into()}

use gpui::{    SharedString, IntoElement, ElementId, ClickEvent,    Window, App, Stateful, Div, RenderOnce, InteractiveElement,    Styled, StatefulInteractiveElement, ParentElement,    div, svg, px, rgb,    prelude::FluentBuilder};use di::DependencyInjector;use crate::Theme;/// Defines the visual and structural payload inside the custom UI button.pub enum ButtonContentType {    Text(SharedString),    Icon(String, f32),}/// A highly reusable, composable, and customizable stateful component built on top of GPUI primitives.////// It supports fluid functional styling adjustments via custom modifier closures and lifecycle interaction event hooks.#[derive(IntoElement)]pub struct Button {    id: ElementId,    content_type: ButtonContentType,    on_click: Option<Box<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static>>,    modifier: Option<Box<dyn FnOnce(Stateful<Div>) -> Stateful<Div> + 'static>>}impl Button {    /// Registers an asynchronous interaction callback executed whenever the user dispatches a pointer click event.    ///    /// # Arguments    ///    /// * `on_click` - A closure triggered on execution, mutating the parent frame architecture states.    ///    /// # Returns    ///    /// * The updated `Button` builder instance.    pub fn on_click(mut self, on_click: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static) -> Self {        self.on_click = Some(Box::new(on_click));        self    }    /// Appends external decorative style overrides onto the baseline layout wrapper tree state.    ///    /// # Arguments    ///    /// * `modifier` - A closure taking ownership of the existing stateful element, returning the stylized version.    ///    /// # Returns    ///    /// * The updated `Button` builder instance.    pub fn style_modifier(mut self, modifier: impl FnOnce(Stateful<Div>) -> Stateful<Div> + 'static) -> Self {        self.modifier = Some(Box::new(modifier));        self    }}impl RenderOnce for Button {    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {        let path_manager = cx.global::<DependencyInjector>().path_manager();        let theme = cx.global::<Theme>();        div()            .id(self.id)            .flex()            .items_center()            .justify_center()            .cursor_pointer()            .rounded_md()            .p_2()            .when_some(self.modifier, |this, modifier| {                modifier(this)            })            .when_some(self.on_click, |this, on_click| {                this.on_click(move |evt, window, cx| (on_click)(evt, window, cx))            })            .child(match self.content_type {                ButtonContentType::Text(text) => div().child(text).into_any_element(),                ButtonContentType::Icon(icon, size) => {                    let path = path_manager                        .icon_path(&icon)                        .to_string_lossy()                        .into_owned();                    svg()                        .size(px(size))                        .path(path)                        .text_color(rgb(theme.text_color))                        .into_any_element()                },            })    }}/// A global functional initialization helper used to generate standalone standard interactive `Button` primitives.////// # Arguments////// * `id` - A unique identifier token compatible with GPUI element state matching rules./// * `content_type` - The state token describing what information payload the button displays internally.////// # Returns////// * A baseline configured `Button` component struct instance.pub fn button(id: impl Into<ElementId>, content_type: ButtonContentType) -> Button {    Button {         id: id.into(),        content_type,        on_click: None,        modifier: None    }}

use std::sync::Arc;use core::services::StandService;use core::models::StandModel;/// Represents the presentation and interactive state container for the main screen.pub struct MainScreenState {    stand_service: Arc<StandService>,    stands: Vec<StandModel>,    selected_stand_name: Option<String>,}impl MainScreenState {    /// Constructs a new `MainScreenState`, instantly pre-fetching the available record sets.    ///    /// # Arguments    ///    /// * `stand_service` - A thread-safe shared reference pointer to the core `StandService` instance.    ///    /// # Returns    ///    /// * An initialized state machine payload with no initial selection targeted.    pub fn new(stand_service: Arc<StandService>) -> Self {        let stands = stand_service.get_all();        Self {            stand_service,            stands,            selected_stand_name: None        }    }    /// Provides a slice reference of all pre-cached `StandModel` entities.    ///    /// # Returns    ///    /// * A slice sequence containing compiled model payloads.    pub fn stands(&self) -> &[StandModel] {        &self.stands    }    /// Exposes a shared reference to the unique identifier string of the currently active selection.    ///    /// # Returns    ///    /// * An `Option` reference wrapping the selected target item name key.    pub fn selected_stand_name(&self) -> &Option<String> {        &self.selected_stand_name    }    /// Resolves and fetches the full model payload corresponding to the active user selection state identifier.    ///    /// It queries the business service layer dynamically based on the stored text key index.    ///    /// # Returns    ///    /// * `Some(StandModel)` if an identity key is selected and verified by the repository backend, or `None`.    pub fn selected_stand(&self) -> Option<StandModel> {        let selected_name = self.selected_stand_name.clone();        match selected_name {            None => None,            Some(name) => match self.stand_service.get_by_name(&name.as_str()) {                None => None,                Some(stand) => Some(stand)            }        }    }    /// Mutates the selection index parameters to target a new focused record entry point.    ///    /// # Arguments    ///    /// * `name` - The concrete string name identity token representing the newly focused model item.    pub fn select_stand(&mut self, name: String) {        self.selected_stand_name = Some(name);    }}

use gpui::{    Entity, Subscription, Render, Window, Context,    IntoElement, Styled, ParentElement,    div, rgb};use super::MainScreenState;use super::components::Sidebar;use super::components::StandInfo;use crate::Theme;/// The UI view container component representing the main screen.pub struct MainScreen {    entity: Entity<MainScreenState>,    _subscription: Subscription}impl MainScreen {    /// Constructs a new `MainScreen` instance and binds a change observation listener.    ///    /// # Arguments    ///    /// * `entity` - An encapsulated GPUI `Entity` holding the reactive model state data logic.    /// * `cx` - A mutable reference to the view's current operational execution context.    ///    /// # Returns    ///    /// * An initialized view layout node subscribing to state events.    pub fn new(entity: Entity<MainScreenState>, cx: &mut Context<Self>) -> Self {        let _subscription = cx.observe(&entity, |_, _, cx| cx.notify());        MainScreen {            entity,            _subscription        }    }}impl Render for MainScreen {    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {        let state = self.entity.read(cx);        let stands = state.stands();        let state_clone = self.entity.clone();        let selected_stand = state.selected_stand();        let theme = cx.global::<Theme>();        div()            .size_full()            .flex()            .bg(rgb(theme.background_color))            .text_color(rgb(theme.text_color))            .child(                Sidebar::new(stands.to_vec(), move |stand_name, _window, cx| {                    state_clone.update(cx, |state, _cx| {                        state.select_stand(stand_name);                     });                })            )            .child(                StandInfo::new(selected_stand)            )    }}

[package]name = "app"version = "1.2.0"edition = "2021"publish = false[[bin]]name = "app"path = "src/main.rs"[dependencies]di.workspace = trueui.workspace = truegpui.workspace = truegpui-component.workspace = trueanyhow.workspace = true

use gpui::{    AssetSource, SharedString, Application, App, AppContext};use std::borrow::Cow;use anyhow::Result;use di::DependencyInjector;use ui::{    MainScreenState, MainScreen, Theme, locale::Locale};/// An application asset provider responsible for bridging GPUI's resource management layer with external storage locations.struct Assets;impl AssetSource for Assets {    /// Dynamically loads a resource binary payload from the local filesystem based on its relative path string.    ///    /// # Arguments    ///    /// * `path` - A string slice indicating the unique lookup destination route of the target asset.    ///    /// # Returns    ///    /// * `Ok(Some(Cow::Owned))` containing the raw file byte array vector data if found,    ///   `Ok(None)` if the resource file doesn't exist, or an IO `Err` if a filesystem error occurs.    fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {        std::fs::read(path)            .map(Into::into)            .map_err(Into::into)            .map(Some)    }    /// Scans a directory path and indexes all nested asset identities inside it.    ///    /// Currently stubbed to return an empty collection since the framework accesses targeted     /// media assets explicitly by their exact paths via the `load` method.    ///    /// # Arguments    ///    /// * `_path` - A root directory path token slice where the recursive scanning would begin.    ///    /// # Returns    ///    /// * An empty vector array wrapped in a successful `Result`.    fn list(&self, _path: &str) -> Result<Vec<SharedString>> {        Ok(vec![])    }}fn main() {    let base_dir = std::env::current_dir().unwrap();    let di = DependencyInjector::init(&base_dir).unwrap();    let stand_service = di.stand_service();    Application::new().with_assets(Assets{}).run(move |cx: &mut App| {        cx.set_global(gpui_component::Theme::default());        cx.set_global(di);        cx.set_global(Theme::default());        cx.set_global(Locale::new());        let main_state = cx.new(|_cx| {            MainScreenState::new(stand_service)        });        cx.open_window(            gpui::WindowOptions::default(),            |_, cx| {                cx.new(|cx| {                    MainScreen::new(main_state, cx)                })            },        ).unwrap();    });}