kira-linux/kira-installer
SHA256
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactoring for StageResult related to issue #1

Browse Source
This commit is contained in:
Kira
2026-05-16 21:10:50 +02:00
parent 4000e0cfac
commit cf916eb508
8 changed files with 190 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/stage.rs
+99 -31
View File
@@ -1,23 +1,22 @@
// <Kira Installer - universal Linux installer.>
// Copyright (C) <2026> <Kira Foundation>
// <Kira Installer - universal Linux installer.>
// Copyright (C) <2026> <Kira Foundation>
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
/*
This file contains basic enums and structs to be used with stages.
*/
*/
use std::collections::HashMap;
@@ -29,15 +28,98 @@ pub enum ConfigValue {
F64(f64),
Bool(bool),
Vector(Vec<ConfigValue>),
Dictionary(HashMap<String, ConfigValue>)
Dictionary(HashMap<String, ConfigValue>),
}
#[derive(Debug, Clone)]
pub struct StageResult {
pub name: String,
pub config: Option<HashMap<String, ConfigValue>>,
pub resuts: Option<HashMap<String, ConfigValue>>,
pub error: Option<String>
pub error: Option<String>,
}
impl StageResult {
pub fn new(name: &str) -> Self {
Self {
name: name.into(),
config: None,
error: None,
}
}
pub fn add_error(mut self, ex: String) -> Self {
self.error = Some(ex);
self
}
pub fn add_val(mut self, val_name: &str, conf_val: ConfigValue) -> Self {
match &mut self.config {
Some(c) => {
c.insert(val_name.into(), conf_val);
}
None => {
self.config = Some(HashMap::from([(val_name.into(), conf_val)]));
}
}
self
}
pub fn add_val_string(self, val_name: &str, v: String) -> Self {
self.add_val(val_name, ConfigValue::String(v))
}
pub fn add_val_bool(self, val_name: &str, v: bool) -> Self {
self.add_val(val_name, ConfigValue::Bool(v))
}
pub fn get_val(&self, val_name: &str) -> Option<ConfigValue> {
let v = self
.config
.as_ref()
.and_then(|hm| hm.get(val_name).cloned());
return v;
}
pub fn get_val_str(&self, val_name: &str) -> Option<String> {
match self.get_val(val_name) {
Some(ConfigValue::String(v)) => Some(v),
_ => None,
}
}
pub fn get_val_bool(&self, val_name: &str) -> Option<bool> {
match self.get_val(val_name) {
Some(ConfigValue::Bool(v)) => Some(v),
_ => None,
}
}
}
pub struct KiraConfig {
pub config_trail: Vec<StageResult>,
}
impl Default for KiraConfig {
fn default() -> Self {
Self {
config_trail: Vec::new(),
}
}
}
impl KiraConfig {
pub fn get_stage(&self, name: &str) -> Option<StageResult> {
self.config_trail
.iter()
.find(|v| v.name == name)
.and_then(|v| Some(v.clone()))
}
pub fn pop_last(&mut self) -> Option<StageResult> {
self.config_trail.pop()
}
pub fn push(&mut self, stage_result: StageResult) {
self.config_trail.push(stage_result);
}
}
#[derive(Debug, Clone)]
@@ -47,17 +129,3 @@ pub enum StageAction {
Next(StageResult),
Abort,
}
pub struct KiraConfig {
pub config_trail: Vec<StageResult>,
}
impl KiraConfig {
pub fn get_stage(&self, name: &str) -> Option<StageResult> {
self.config_trail.iter().find(|v| v.name == name)
.and_then(|v| Some(v.clone()))
}
}
src/stages/keyboard/mod.rs
+5 -18
View File
@@ -276,25 +276,12 @@ impl KeyboardStage {
if let Some(model) = &self.model
&& let Some(k_l) = &self.keyboard_layout
{
StageResult {
name: "keyboard".to_string(),
config: Some(HashMap::from([
(
"model".to_string(),
ConfigValue::String(model.model.clone()),
),
("layout".to_string(), ConfigValue::String(k_l.to_result())),
])),
resuts: None,
error: None,
}
StageResult::new("keyboard")
.add_val_string("model", model.model.clone())
.add_val_string("layout", k_l.to_result())
} else {
StageResult {
name: "keyboard".to_string(),
config: None,
resuts: None,
error: Some("Something go terrible wrong, there is no keyboard layouts.".into()),
}
StageResult::new("keyboard")
.add_error("Something go terrible wrong, there is no keyboard layouts.".into())
}
}
src/stages/license/mod.rs
+2 -10
View File
@@ -21,7 +21,6 @@
use iced::{Alignment, widget};
use rust_i18n::t;
use std::collections::HashMap;
use crate::stage;
use crate::stage::StageResult;
@@ -44,15 +43,8 @@ pub enum Message {
impl LicenseStage {
fn accepted() -> StageResult {
StageResult {
name: "license".into(),
config: Some(HashMap::from([(
"accepted".to_string(),
stage::ConfigValue::Bool(true),
)])),
resuts: None,
error: None,
}
StageResult::new("license")
.add_val_bool("accepted", true)
}
pub fn update(&mut self, message: Message) -> stage::StageAction {
src/stages/locale/mod.rs
+7 -27
View File
@@ -215,35 +215,15 @@ impl LocaleStage {
if let Some(lang_locale) = &self.lang_locale
&& let Some(formats_locale) = &self.formats_locale
{
StageResult {
name: "locale".to_string(),
config: Some(HashMap::from([
(
"lang_locale".to_string(),
ConfigValue::String(lang_locale.code.clone()),
),
(
"formats_locale".to_string(),
ConfigValue::String(formats_locale.code.clone()),
),
])),
resuts: None,
error: None,
}
StageResult::new("locale")
.add_val_string("lang_locale", lang_locale.code.clone())
.add_val_string("formats_locale", formats_locale.code.clone())
} else {
let loc = LocaleData::default();
StageResult {
name: "locale".to_string(),
config: Some(HashMap::from([
(
"lang_locale".to_string(),
ConfigValue::String(loc.code.clone()),
),
("formats_locale".to_string(), ConfigValue::String(loc.code)),
])),
resuts: None,
error: None,
}
StageResult::new("locale")
.add_val_string("lang_locale", loc.code.clone())
.add_val_string("formats_locale", loc.code)
}
}
src/stages/network/mod.rs
+3 -15
View File
@@ -127,21 +127,9 @@ impl NetworkStage {
}
fn gen_result(&self) -> StageResult {
StageResult {
name: "network".into(),
config: Some(HashMap::from([
(
"internet_active".to_string(),
stage::ConfigValue::Bool(self.internet_active),
),
(
"use_net_settings".to_string(),
stage::ConfigValue::Bool(self.use_net_settings),
),
])),
resuts: None,
error: None,
}
StageResult::new("network")
.add_val_bool("internet_active", self.internet_active)
.add_val_bool("use_net_settings", self.use_net_settings)
}
pub fn update(&mut self, message: Message) -> UpdateResult {
src/stages/partition/mod.rs
+47 -45
View File
@@ -20,13 +20,10 @@
use crate::stage::{ConfigValue, StageAction, StageResult};
use iced::{
Alignment, Color, Length,
widget,
};
use crate::kira_color_bar;
use iced::{Alignment, Color, Length, widget};
use rust_i18n::t;
use std::collections::HashMap;
use crate::kira_color_bar;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SwapMode {
@@ -243,30 +240,47 @@ pub fn get_dev_part_blocking(dev_name: &str) -> Result<Vec<PartInfo>, String> {
}
}
use toml::Table;
impl PartitionStage {
pub fn gen_disk_layout_estimate(&self) -> Vec<PartInfo> {
let dev = self.device.clone().unwrap();
let swap_size: u64 = match self.swap_mode {
Some(SwapMode::NoSwap) => 0,
Some(SwapMode::SwapHibernate) => 666,
Some(SwapMode::SwapNoHibernate) => 1024,
_ => 1024
_ => 1024,
};
let mut res: Vec<PartInfo> = Vec::new();
// UEFI partition
res.push(PartInfo { name: "EFI".into(), part_type: "vfat".into(), size_mb: 256 });
res.push(PartInfo {
name: "EFI".into(),
part_type: "vfat".into(),
size_mb: 256,
});
// boot A and B
res.push(PartInfo { name: "kira_boot_a".into(), part_type: "xfs".into(), size_mb: 512 });
res.push(PartInfo { name: "kira_boot_b".into(), part_type: "xfs".into(), size_mb: 512 });
res.push(PartInfo {
name: "kira_boot_a".into(),
part_type: "xfs".into(),
size_mb: 512,
});
res.push(PartInfo {
name: "kira_boot_b".into(),
part_type: "xfs".into(),
size_mb: 512,
});
// user data
res.push(PartInfo { name: "kira_data".into(), part_type: "xfs".into(), size_mb: dev.size_mb - 1024 - 256 - swap_size });
res.push(PartInfo {
name: "kira_data".into(),
part_type: "xfs".into(),
size_mb: dev.size_mb - 1024 - 256 - swap_size,
});
// swap
if swap_size > 0 {
res.push(PartInfo { name: "".into(), part_type: "swap".into(), size_mb: swap_size });
res.push(PartInfo {
name: "".into(),
part_type: "swap".into(),
size_mb: swap_size,
});
}
res
@@ -306,36 +320,23 @@ impl PartitionStage {
}
fn gen_result(&self) -> StageResult {
StageResult {
name: "partition".to_string(),
config: Some(HashMap::from([
(
"device".to_string(),
ConfigValue::String(
StageResult::new("partition")
.add_val_string(
"device",
self.device
.as_ref()
.and_then(|v| Some(v.name.clone()))
.unwrap_or_else(|| "NONE".to_string()),
),
),
(
"swap_mode".to_string(),
ConfigValue::String(
)
.add_val_string(
"swap_mode",
self.swap_mode
.clone()
.unwrap_or(SwapMode::NoSwap)
.to_string(),
),
),
("zram".to_string(), ConfigValue::Bool(self.use_zram)),
(
"secure_boot".to_string(),
ConfigValue::Bool(self.secure_boot),
),
])),
resuts: None,
error: None,
}
)
.add_val_bool("zram", self.use_zram)
.add_val_bool("secure_boot", self.secure_boot)
}
pub fn update(&mut self, message: Message) -> StageAction {
@@ -375,30 +376,31 @@ impl PartitionStage {
}
pub fn view(&self) -> iced::Element<'_, Message> {
let dev_parts_es: Option<Vec<(String, u16, Color)>> = if self.selected_disk_parts.is_some() {
Some(self.gen_disk_layout_estimate().iter()
let dev_parts_es: Option<Vec<(String, u16, Color)>> = if self.selected_disk_parts.is_some()
{
Some(
self.gen_disk_layout_estimate()
.iter()
.map(|part_inf| part_inf.to_ct_params(self.device.clone().unwrap().size_mb))
.collect())
}
else {
.collect(),
)
} else {
None
};
let dev_parts_text = match dev_parts_es {
Some(_) => widget::text(t!("partition.current_after_install")),
None => widget::text("")
None => widget::text(""),
};
let dev_parts_content = kira_color_bar::color_bar(dev_parts_es, 48);
let dev_parts_content = widget::column![dev_parts_text, dev_parts_content];
let back_button = widget::button(widget::text(t!("button.back"))).on_press(Message::Back);
let next_button = widget::button(widget::text(t!("button.next"))).on_press(Message::Next);
let selected_dev_text = match self.selected_disk_parts {
Some(_) => widget::text(t!("partition.current_dev_layout")),
None => widget::text("")
None => widget::text(""),
};
let selected_dev_content = kira_color_bar::color_bar(self.selected_disk_parts.clone(), 48);
let selected_dev_content = widget::column![selected_dev_text, selected_dev_content];
src/stages/timezone/mod.rs
+5 -25
View File
@@ -146,32 +146,12 @@ impl TimeZoneStage {
fn gen_result(&self) -> StageResult {
if let Some(time_zone) = &self.selected_zone {
StageResult {
name: "time_zone".to_string(),
config: Some(HashMap::from([
(
"name".to_string(),
ConfigValue::String(time_zone.to_string()),
),
(
"region".to_string(),
ConfigValue::String(time_zone.region.clone()),
),
(
"zone".to_string(),
ConfigValue::String(time_zone.zone.clone()),
),
])),
resuts: None,
error: None,
}
StageResult::new("time_zone")
.add_val_string("name", time_zone.to_string())
.add_val_string("region", time_zone.region.clone())
.add_val_string("zone", time_zone.zone.clone())
} else {
StageResult {
name: "time_zone".to_string(),
config: None,
resuts: None,
error: None,
}
StageResult::new("time_zone")
}
}
src/stages/welcome/mod.rs
+6 -30
View File
@@ -70,37 +70,13 @@ impl WelcomeStage {
fn gen_result(&self) -> StageResult {
if let Some(loc) = &self.locale {
StageResult {
name: "welcome".to_string(),
config: Some(HashMap::from([
(
"loc_code".to_string(),
ConfigValue::String(loc.code.clone()),
),
(
"loc_name".to_string(),
ConfigValue::String(loc.name.clone()),
),
])),
resuts: None,
error: None,
}
StageResult::new("welcome")
.add_val_string("loc_code", loc.code.clone())
.add_val_string("loc_name", loc.name.clone())
} else {
StageResult {
name: "welcome".to_string(),
config: Some(HashMap::from([
(
"loc_code".to_string(),
ConfigValue::String("en".to_string()),
),
(
"loc_name".to_string(),
ConfigValue::String("English".to_string()),
),
])),
resuts: None,
error: None,
}
StageResult::new("welcome")
.add_val_string("loc_code", "en".to_string())
.add_val_string("loc_name", "English".to_string())
}
}