#[cfg(test)]
#[path = "./types_test.rs"]
mod types_test;
use crate::legacy;
use ci_info::types::CiInfo;
use indexmap::IndexMap;
use rust_info::types::RustInfo;
pub fn get_platform_name() -> String {
if cfg!(windows) {
"windows".to_string()
} else if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
"mac".to_string()
} else {
"linux".to_string()
}
}
fn get_namespaced_task_name(namespace: &str, task: &str) -> String {
let mut namespaced_task = String::new();
if namespace.len() > 0 {
namespaced_task.push_str(namespace);
namespaced_task.push_str("::");
}
namespaced_task.push_str(task);
namespaced_task
}
#[derive(Debug, Clone)]
pub struct CliArgs {
pub command: String,
pub build_file: Option<String>,
pub task: String,
pub profile: Option<String>,
pub log_level: String,
pub disable_color: bool,
pub cwd: Option<String>,
pub env: Option<Vec<String>>,
pub env_file: Option<String>,
pub disable_workspace: bool,
pub disable_on_error: bool,
pub allow_private: bool,
pub skip_init_end_tasks: bool,
pub print_only: bool,
pub list_all_steps: bool,
pub diff_execution_plan: bool,
pub disable_check_for_updates: bool,
pub experimental: bool,
pub arguments: Option<Vec<String>>,
pub output_format: String,
}
impl CliArgs {
pub fn new() -> CliArgs {
CliArgs {
command: "".to_string(),
build_file: None,
task: "default".to_string(),
profile: None,
log_level: "info".to_string(),
disable_color: false,
cwd: None,
env: None,
env_file: None,
disable_workspace: false,
disable_on_error: false,
allow_private: false,
skip_init_end_tasks: false,
print_only: false,
list_all_steps: false,
diff_execution_plan: false,
disable_check_for_updates: false,
experimental: false,
arguments: None,
output_format: "default".to_string(),
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Cache {
#[serde(skip)]
pub file_name: Option<String>,
pub last_update_check: Option<u64>,
}
impl Cache {
pub fn new() -> Cache {
Cache {
file_name: None,
last_update_check: None,
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct GlobalConfig {
#[serde(skip)]
pub file_name: Option<String>,
pub log_level: Option<String>,
pub default_task_name: Option<String>,
pub update_check_minimum_interval: Option<String>,
pub search_project_root: Option<bool>,
}
impl GlobalConfig {
pub fn new() -> GlobalConfig {
GlobalConfig {
file_name: None,
log_level: None,
default_task_name: None,
update_check_minimum_interval: None,
search_project_root: Some(false),
}
}
}
#[derive(Debug, Clone)]
pub struct GitInfo {
pub branch: Option<String>,
pub user_name: Option<String>,
pub user_email: Option<String>,
}
impl GitInfo {
pub fn new() -> GitInfo {
GitInfo {
branch: None,
user_name: None,
user_email: None,
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Workspace {
pub members: Option<Vec<String>>,
pub exclude: Option<Vec<String>>,
}
impl Workspace {
pub fn new() -> Workspace {
Workspace {
members: None,
exclude: None,
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PackageInfo {
pub name: Option<String>,
pub version: Option<String>,
pub description: Option<String>,
pub license: Option<String>,
pub documentation: Option<String>,
pub homepage: Option<String>,
pub repository: Option<String>,
}
impl PackageInfo {
pub fn new() -> PackageInfo {
PackageInfo {
name: None,
version: None,
description: None,
license: None,
documentation: None,
homepage: None,
repository: None,
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CrateDependencyInfo {
pub path: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum CrateDependency {
Version(String),
Info(CrateDependencyInfo),
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct CrateInfo {
pub package: Option<PackageInfo>,
pub workspace: Option<Workspace>,
pub dependencies: Option<IndexMap<String, CrateDependency>>,
}
impl CrateInfo {
pub fn new() -> CrateInfo {
CrateInfo {
package: None,
workspace: None,
dependencies: None,
}
}
}
#[derive(Debug, Clone)]
pub struct EnvInfo {
pub rust_info: RustInfo,
pub crate_info: CrateInfo,
pub git_info: GitInfo,
pub ci_info: CiInfo,
}
#[derive(Debug, Clone)]
pub struct FlowInfo {
pub config: Config,
pub task: String,
pub env_info: EnvInfo,
pub disable_workspace: bool,
pub disable_on_error: bool,
pub allow_private: bool,
pub skip_init_end_tasks: bool,
pub cli_arguments: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RustVersionCondition {
pub min: Option<String>,
pub max: Option<String>,
pub equal: Option<String>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct TaskCondition {
pub profiles: Option<Vec<String>>,
pub platforms: Option<Vec<String>>,
pub channels: Option<Vec<String>>,
pub env_set: Option<Vec<String>>,
pub env_not_set: Option<Vec<String>>,
pub env: Option<IndexMap<String, String>>,
pub env_true: Option<Vec<String>>,
pub env_false: Option<Vec<String>>,
pub rust_version: Option<RustVersionCondition>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct EnvValueScript {
pub script: Vec<String>,
pub multi_line: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum EnvValue {
Value(String),
Boolean(bool),
Script(EnvValueScript),
Profile(IndexMap<String, EnvValue>),
}
#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
#[serde(transparent)]
pub struct TestArg {
pub inner: Vec<String>,
}
impl std::ops::Deref for TestArg {
type Target = Vec<String>;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for TestArg {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'de> serde::de::Deserialize<'de> for TestArg {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
struct StringVecVisitor;
impl<'de> serde::de::Visitor<'de> for StringVecVisitor {
type Value = TestArg;
fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
formatter.write_str("A string or an array of strings")
}
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
E: serde::de::Error,
{
Ok(TestArg {
inner: vec![s.to_string()],
})
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
where
A: serde::de::SeqAccess<'de>,
{
let mut v = Vec::with_capacity(seq.size_hint().unwrap_or(0));
while let Some(s) = seq.next_element()? {
v.push(s);
}
Ok(TestArg { inner: v })
}
}
deserializer.deserialize_any(StringVecVisitor)
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct InstallCrateInfo {
pub crate_name: String,
pub rustup_component_name: Option<String>,
pub binary: String,
pub test_arg: TestArg,
}
impl PartialEq for InstallCrateInfo {
fn eq(&self, other: &InstallCrateInfo) -> bool {
if self.crate_name != other.crate_name
|| self.binary != other.binary
|| self.test_arg != other.test_arg
{
false
} else {
match self.rustup_component_name {
Some(ref value) => match other.rustup_component_name {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.rustup_component_name {
None => true,
_ => false,
},
}
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct InstallRustupComponentInfo {
pub rustup_component_name: String,
pub binary: Option<String>,
pub test_arg: Option<TestArg>,
}
impl PartialEq for InstallRustupComponentInfo {
fn eq(&self, other: &InstallRustupComponentInfo) -> bool {
if self.rustup_component_name != other.rustup_component_name {
false
} else {
let same = match self.binary {
Some(ref value) => match other.binary {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.binary {
None => true,
_ => false,
},
};
if same {
self.test_arg == other.test_arg
} else {
false
}
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum InstallCrate {
Value(String),
CrateInfo(InstallCrateInfo),
RustupComponentInfo(InstallRustupComponentInfo),
}
impl PartialEq for InstallCrate {
fn eq(&self, other: &InstallCrate) -> bool {
match self {
InstallCrate::Value(value) => match other {
InstallCrate::Value(other_value) => value == other_value,
_ => false,
},
InstallCrate::CrateInfo(info) => match other {
InstallCrate::CrateInfo(other_info) => info == other_info,
_ => false,
},
InstallCrate::RustupComponentInfo(info) => match other {
InstallCrate::RustupComponentInfo(other_info) => info == other_info,
_ => false,
},
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RunTaskDetails {
pub name: String,
pub fork: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RunTaskRoutingInfo {
pub name: String,
pub fork: Option<bool>,
pub condition: Option<TaskCondition>,
pub condition_script: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum RunTaskInfo {
Name(String),
Details(RunTaskDetails),
Routing(Vec<RunTaskRoutingInfo>),
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct WatchOptions {
pub version: Option<String>,
pub postpone: Option<bool>,
pub ignore_pattern: Option<String>,
pub no_git_ignore: Option<bool>,
}
impl PartialEq for WatchOptions {
fn eq(&self, other: &WatchOptions) -> bool {
let mut same = match self.version {
Some(ref value) => match other.version {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.version {
None => true,
_ => false,
},
};
same = if same {
match self.postpone {
Some(ref value) => match other.postpone {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.postpone {
None => true,
_ => false,
},
}
} else {
false
};
same = if same {
match self.ignore_pattern {
Some(ref value) => match other.ignore_pattern {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.ignore_pattern {
None => true,
_ => false,
},
}
} else {
false
};
if same {
match self.no_git_ignore {
Some(ref value) => match other.no_git_ignore {
Some(ref other_value) => value == other_value,
None => false,
},
None => match other.no_git_ignore {
None => true,
_ => false,
},
}
} else {
false
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum TaskWatchOptions {
Boolean(bool),
Options(WatchOptions),
}
impl PartialEq for TaskWatchOptions {
fn eq(&self, other: &TaskWatchOptions) -> bool {
match self {
TaskWatchOptions::Boolean(value) => match other {
TaskWatchOptions::Boolean(other_value) => value == other_value,
_ => false,
},
TaskWatchOptions::Options(info) => match other {
TaskWatchOptions::Options(other_info) => info == other_info,
_ => false,
},
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Task {
pub clear: Option<bool>,
pub description: Option<String>,
pub category: Option<String>,
pub disabled: Option<bool>,
pub private: Option<bool>,
pub extend: Option<String>,
pub workspace: Option<bool>,
pub watch: Option<TaskWatchOptions>,
pub condition: Option<TaskCondition>,
pub condition_script: Option<Vec<String>>,
pub ignore_errors: Option<bool>,
pub force: Option<bool>,
pub env: Option<IndexMap<String, EnvValue>>,
pub cwd: Option<String>,
pub alias: Option<String>,
pub linux_alias: Option<String>,
pub windows_alias: Option<String>,
pub mac_alias: Option<String>,
pub install_crate: Option<InstallCrate>,
pub install_crate_args: Option<Vec<String>>,
pub install_script: Option<Vec<String>>,
pub command: Option<String>,
pub args: Option<Vec<String>>,
pub script: Option<Vec<String>>,
pub script_runner: Option<String>,
pub script_extension: Option<String>,
pub run_task: Option<RunTaskInfo>,
pub dependencies: Option<Vec<String>>,
pub toolchain: Option<String>,
pub linux: Option<PlatformOverrideTask>,
pub windows: Option<PlatformOverrideTask>,
pub mac: Option<PlatformOverrideTask>,
}
impl Task {
pub fn new() -> Task {
Task {
clear: None,
description: None,
category: None,
disabled: None,
private: None,
extend: None,
workspace: None,
watch: None,
condition: None,
condition_script: None,
ignore_errors: None,
force: None,
env: None,
cwd: None,
alias: None,
linux_alias: None,
windows_alias: None,
mac_alias: None,
install_crate: None,
install_crate_args: None,
install_script: None,
command: None,
args: None,
script: None,
script_runner: None,
script_extension: None,
run_task: None,
dependencies: None,
toolchain: None,
linux: None,
windows: None,
mac: None,
}
}
pub fn apply(self: &mut Task, modify_config: &ModifyConfig) {
match modify_config.private {
Some(value) => {
if value {
self.private = Some(true);
}
}
None => (),
};
match modify_config.namespace {
Some(ref namespace) => {
if namespace.len() > 0 {
if self.extend.is_some() {
self.extend = Some(get_namespaced_task_name(
namespace,
&self.extend.clone().unwrap(),
));
}
if self.alias.is_some() {
self.alias = Some(get_namespaced_task_name(
namespace,
&self.alias.clone().unwrap(),
));
}
if self.linux_alias.is_some() {
self.linux_alias = Some(get_namespaced_task_name(
namespace,
&self.linux_alias.clone().unwrap(),
));
}
if self.windows_alias.is_some() {
self.windows_alias = Some(get_namespaced_task_name(
namespace,
&self.windows_alias.clone().unwrap(),
));
}
if self.mac_alias.is_some() {
self.mac_alias = Some(get_namespaced_task_name(
namespace,
&self.mac_alias.clone().unwrap(),
));
}
if self.run_task.is_some() {
let mut run_task = self.run_task.clone().unwrap();
run_task = match run_task {
RunTaskInfo::Name(value) => {
RunTaskInfo::Name(get_namespaced_task_name(namespace, &value))
}
RunTaskInfo::Details(mut run_task_details) => {
run_task_details.name =
get_namespaced_task_name(namespace, &run_task_details.name);
RunTaskInfo::Details(run_task_details)
}
RunTaskInfo::Routing(mut routing_info_vector) => {
for mut routing_info in &mut routing_info_vector {
routing_info.name =
get_namespaced_task_name(namespace, &routing_info.name);
}
RunTaskInfo::Routing(routing_info_vector)
}
};
self.run_task = Some(run_task);
}
if self.dependencies.is_some() {
let dependencies = self.dependencies.clone().unwrap();
let mut modified_dependencies = vec![];
for task in &dependencies {
modified_dependencies.push(get_namespaced_task_name(namespace, &task));
}
self.dependencies = Some(modified_dependencies);
}
}
}
None => (),
};
}
pub fn extend(self: &mut Task, task: &Task) {
let override_values = match task.clear {
Some(value) => value,
None => false,
};
if task.clear.is_some() {
self.clear = task.clear.clone();
}
if task.description.is_some() {
self.description = task.description.clone();
} else if override_values {
self.description = None;
}
if task.category.is_some() {
self.category = task.category.clone();
} else if override_values {
self.category = None;
}
if task.disabled.is_some() {
self.disabled = task.disabled.clone();
} else if override_values {
self.disabled = None;
}
if task.private.is_some() {
self.private = task.private.clone();
} else if override_values {
self.private = None;
}
if task.extend.is_some() {
self.extend = task.extend.clone();
} else if override_values {
self.extend = None;
}
if task.workspace.is_some() {
self.workspace = task.workspace.clone();
} else if override_values {
self.workspace = None;
}
if task.watch.is_some() {
self.watch = task.watch.clone();
} else if override_values {
self.watch = None;
}
if task.condition.is_some() {
self.condition = task.condition.clone();
} else if override_values {
self.condition = None;
}
if task.condition_script.is_some() {
self.condition_script = task.condition_script.clone();
} else if override_values {
self.condition_script = None;
}
if task.ignore_errors.is_some() {
self.ignore_errors = task.ignore_errors.clone();
} else if override_values {
self.ignore_errors = None;
}
if task.force.is_some() {
self.force = task.force.clone();
} else if override_values {
self.force = None;
}
if task.env.is_some() {
self.env = task.env.clone();
} else if override_values {
self.env = None;
}
if task.cwd.is_some() {
self.cwd = task.cwd.clone();
} else if override_values {
self.cwd = None;
}
if task.alias.is_some() {
self.alias = task.alias.clone();
} else if override_values {
self.alias = None;
}
if task.linux_alias.is_some() {
self.linux_alias = task.linux_alias.clone();
} else if override_values {
self.linux_alias = None;
}
if task.windows_alias.is_some() {
self.windows_alias = task.windows_alias.clone();
} else if override_values {
self.windows_alias = None;
}
if task.mac_alias.is_some() {
self.mac_alias = task.mac_alias.clone();
} else if override_values {
self.mac_alias = None;
}
if task.install_crate.is_some() {
self.install_crate = task.install_crate.clone();
} else if override_values {
self.install_crate = None;
}
if task.install_crate_args.is_some() {
self.install_crate_args = task.install_crate_args.clone();
} else if override_values {
self.install_crate_args = None;
}
if task.install_script.is_some() {
self.install_script = task.install_script.clone();
} else if override_values {
self.install_script = None;
}
if task.command.is_some() {
self.command = task.command.clone();
} else if override_values {
self.command = None;
}
if task.args.is_some() {
self.args = task.args.clone();
} else if override_values {
self.args = None;
}
if task.script.is_some() {
self.script = task.script.clone();
} else if override_values {
self.script = None;
}
if task.script_runner.is_some() {
self.script_runner = task.script_runner.clone();
} else if override_values {
self.script_runner = None;
}
if task.script_extension.is_some() {
self.script_extension = task.script_extension.clone();
} else if override_values {
self.script_extension = None;
}
if task.run_task.is_some() {
self.run_task = task.run_task.clone();
} else if override_values {
self.run_task = None;
}
if task.dependencies.is_some() {
self.dependencies = task.dependencies.clone();
} else if override_values {
self.dependencies = None;
}
if task.toolchain.is_some() {
self.toolchain = task.toolchain.clone();
} else if override_values {
self.toolchain = None;
}
if task.linux.is_some() {
self.linux = task.linux.clone();
} else if override_values {
self.linux = None;
}
if task.windows.is_some() {
self.windows = task.windows.clone();
} else if override_values {
self.windows = None;
}
if task.mac.is_some() {
self.mac = task.mac.clone();
} else if override_values {
self.mac = None;
}
}
pub fn should_ignore_errors(self: &Task) -> bool {
match self.ignore_errors {
Some(value) => value,
None => match self.force {
Some(value) => {
legacy::show_deprecated_attriute_warning("force", "ignore_errors");
value
}
None => false,
},
}
}
fn get_override(self: &Task) -> Option<PlatformOverrideTask> {
let platform_name = get_platform_name();
if platform_name == "windows" {
match self.windows {
Some(ref value) => Some(value.clone()),
_ => None,
}
} else if platform_name == "mac" {
match self.mac {
Some(ref value) => Some(value.clone()),
_ => None,
}
} else {
match self.linux {
Some(ref value) => Some(value.clone()),
_ => None,
}
}
}
pub fn get_normalized_task(self: &mut Task) -> Task {
match self.get_override() {
Some(ref mut override_task) => {
override_task.extend(self);
Task {
clear: self.clear.clone(),
description: self.description.clone(),
category: self.category.clone(),
disabled: override_task.disabled.clone(),
private: override_task.private.clone(),
extend: override_task.extend.clone(),
workspace: self.workspace.clone(),
watch: override_task.watch.clone(),
condition: override_task.condition.clone(),
condition_script: override_task.condition_script.clone(),
ignore_errors: override_task.ignore_errors.clone(),
force: override_task.force.clone(),
env: override_task.env.clone(),
cwd: override_task.cwd.clone(),
alias: None,
linux_alias: None,
windows_alias: None,
mac_alias: None,
install_crate: override_task.install_crate.clone(),
install_crate_args: override_task.install_crate_args.clone(),
install_script: override_task.install_script.clone(),
command: override_task.command.clone(),
args: override_task.args.clone(),
script: override_task.script.clone(),
script_runner: override_task.script_runner.clone(),
script_extension: override_task.script_extension.clone(),
run_task: override_task.run_task.clone(),
dependencies: override_task.dependencies.clone(),
toolchain: override_task.toolchain.clone(),
linux: None,
windows: None,
mac: None,
}
}
None => self.clone(),
}
}
pub fn get_alias(self: &Task) -> Option<String> {
let alias = if cfg!(windows) {
match self.windows_alias {
Some(ref value) => Some(value),
_ => None,
}
} else if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
match self.mac_alias {
Some(ref value) => Some(value),
_ => None,
}
} else {
match self.linux_alias {
Some(ref value) => Some(value),
_ => None,
}
};
match alias {
Some(os_alias) => Some(os_alias.clone()),
_ => match self.alias {
Some(ref alias) => Some(alias.clone()),
_ => None,
},
}
}
pub fn is_valid(self: &Task) -> bool {
let mut actions_count = 0;
if self.run_task.is_some() {
actions_count = actions_count + 1;
}
if self.command.is_some() {
actions_count = actions_count + 1;
}
if self.script.is_some() {
actions_count = actions_count + 1;
}
if actions_count <= 1 {
true
} else {
false
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct PlatformOverrideTask {
pub clear: Option<bool>,
pub disabled: Option<bool>,
pub private: Option<bool>,
pub extend: Option<String>,
pub watch: Option<TaskWatchOptions>,
pub condition: Option<TaskCondition>,
pub condition_script: Option<Vec<String>>,
pub ignore_errors: Option<bool>,
pub force: Option<bool>,
pub env: Option<IndexMap<String, EnvValue>>,
pub cwd: Option<String>,
pub install_crate: Option<InstallCrate>,
pub install_crate_args: Option<Vec<String>>,
pub install_script: Option<Vec<String>>,
pub command: Option<String>,
pub args: Option<Vec<String>>,
pub script: Option<Vec<String>>,
pub script_runner: Option<String>,
pub script_extension: Option<String>,
pub run_task: Option<RunTaskInfo>,
pub dependencies: Option<Vec<String>>,
pub toolchain: Option<String>,
}
impl PlatformOverrideTask {
pub fn extend(self: &mut PlatformOverrideTask, task: &mut Task) {
let copy_values = match self.clear {
Some(value) => !value,
None => true,
};
if copy_values {
if self.disabled.is_none() && task.disabled.is_some() {
self.disabled = task.disabled.clone();
}
if self.private.is_none() && task.private.is_some() {
self.private = task.private.clone();
}
if self.extend.is_none() && task.extend.is_some() {
self.extend = task.extend.clone();
}
if self.watch.is_none() && task.watch.is_some() {
self.watch = task.watch.clone();
}
if self.condition.is_none() && task.condition.is_some() {
self.condition = task.condition.clone();
}
if self.condition_script.is_none() && task.condition_script.is_some() {
self.condition_script = task.condition_script.clone();
}
if self.ignore_errors.is_none() && task.ignore_errors.is_some() {
self.ignore_errors = task.ignore_errors.clone();
}
if self.force.is_none() && task.force.is_some() {
self.force = task.force.clone();
}
if self.env.is_none() && task.env.is_some() {
self.env = task.env.clone();
}
if self.cwd.is_none() && task.cwd.is_some() {
self.cwd = task.cwd.clone();
}
if self.install_crate.is_none() && task.install_crate.is_some() {
self.install_crate = task.install_crate.clone();
}
if self.install_crate_args.is_none() && task.install_crate_args.is_some() {
self.install_crate_args = task.install_crate_args.clone();
}
if self.install_script.is_none() && task.install_script.is_some() {
self.install_script = task.install_script.clone();
}
if self.command.is_none() && task.command.is_some() {
self.command = task.command.clone();
}
if self.args.is_none() && task.args.is_some() {
self.args = task.args.clone();
}
if self.script.is_none() && task.script.is_some() {
self.script = task.script.clone();
}
if self.script_runner.is_none() && task.script_runner.is_some() {
self.script_runner = task.script_runner.clone();
}
if self.script_extension.is_none() && task.script_extension.is_some() {
self.script_extension = task.script_extension.clone();
}
if self.run_task.is_none() && task.run_task.is_some() {
self.run_task = task.run_task.clone();
}
if self.dependencies.is_none() && task.dependencies.is_some() {
self.dependencies = task.dependencies.clone();
}
if self.toolchain.is_none() && task.toolchain.is_some() {
self.toolchain = task.toolchain.clone();
}
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ExtendOptions {
pub path: String,
pub optional: Option<bool>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(untagged)]
pub enum Extend {
Path(String),
Options(ExtendOptions),
List(Vec<ExtendOptions>),
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ModifyConfig {
pub private: Option<bool>,
pub namespace: Option<String>,
}
impl ModifyConfig {
pub fn is_modifications_defined(self: &ModifyConfig) -> bool {
if self.private.unwrap_or(false) {
true
} else {
match self.namespace {
Some(ref value) => value.len() > 0,
None => false,
}
}
}
pub fn get_namespace_prefix(self: &ModifyConfig) -> String {
match self.namespace {
Some(ref value) => get_namespaced_task_name(value, ""),
None => "".to_string(),
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ConfigSection {
pub skip_core_tasks: Option<bool>,
pub modify_core_tasks: Option<ModifyConfig>,
pub init_task: Option<String>,
pub end_task: Option<String>,
pub on_error_task: Option<String>,
pub additional_profiles: Option<Vec<String>>,
pub min_version: Option<String>,
pub load_script: Option<Vec<String>>,
pub linux_load_script: Option<Vec<String>>,
pub windows_load_script: Option<Vec<String>>,
pub mac_load_script: Option<Vec<String>>,
}
impl ConfigSection {
pub fn new() -> ConfigSection {
ConfigSection {
skip_core_tasks: None,
modify_core_tasks: None,
init_task: None,
end_task: None,
on_error_task: None,
additional_profiles: None,
min_version: None,
load_script: None,
linux_load_script: None,
windows_load_script: None,
mac_load_script: None,
}
}
pub fn apply(self: &mut ConfigSection, modify_config: &ModifyConfig) {
match modify_config.namespace {
Some(ref namespace) => {
if self.init_task.is_some() {
self.init_task = Some(get_namespaced_task_name(
namespace,
&self.init_task.clone().unwrap(),
));
}
if self.end_task.is_some() {
self.end_task = Some(get_namespaced_task_name(
namespace,
&self.end_task.clone().unwrap(),
));
}
if self.on_error_task.is_some() {
self.on_error_task = Some(get_namespaced_task_name(
namespace,
&self.on_error_task.clone().unwrap(),
));
}
}
None => (),
}
}
pub fn extend(self: &mut ConfigSection, extended: &mut ConfigSection) {
if extended.skip_core_tasks.is_some() {
self.skip_core_tasks = extended.skip_core_tasks.clone();
}
if extended.modify_core_tasks.is_some() {
self.modify_core_tasks = extended.modify_core_tasks.clone();
}
if extended.init_task.is_some() {
self.init_task = extended.init_task.clone();
}
if extended.end_task.is_some() {
self.end_task = extended.end_task.clone();
}
if extended.on_error_task.is_some() {
self.on_error_task = extended.on_error_task.clone();
}
if extended.additional_profiles.is_some() {
self.additional_profiles = extended.additional_profiles.clone();
}
if extended.min_version.is_some() {
self.min_version = extended.min_version.clone();
}
if extended.load_script.is_some() {
self.load_script = extended.load_script.clone();
}
if extended.linux_load_script.is_some() {
self.linux_load_script = extended.linux_load_script.clone();
}
if extended.windows_load_script.is_some() {
self.windows_load_script = extended.windows_load_script.clone();
}
if extended.mac_load_script.is_some() {
self.mac_load_script = extended.mac_load_script.clone();
}
}
pub fn get_load_script(self: &ConfigSection) -> Option<Vec<String>> {
let platform_name = get_platform_name();
if platform_name == "windows" {
if self.windows_load_script.is_some() {
self.windows_load_script.clone()
} else {
self.load_script.clone()
}
} else if platform_name == "mac" {
if self.mac_load_script.is_some() {
self.mac_load_script.clone()
} else {
self.load_script.clone()
}
} else {
if self.linux_load_script.is_some() {
self.linux_load_script.clone()
} else {
self.load_script.clone()
}
}
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Config {
pub config: ConfigSection,
pub env: IndexMap<String, EnvValue>,
pub tasks: IndexMap<String, Task>,
}
impl Config {
pub fn apply(self: &mut Config, modify_config: &ModifyConfig) {
self.config.apply(&modify_config);
let namespace = match modify_config.namespace {
Some(ref namespace) => namespace,
None => "",
};
let mut modified_tasks = IndexMap::<String, Task>::new();
for (key, value) in self.tasks.iter() {
let namespaced_task = get_namespaced_task_name(namespace, &key);
let mut task = value.clone();
task.apply(&modify_config);
modified_tasks.insert(namespaced_task, task);
}
self.tasks = modified_tasks;
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ExternalConfig {
pub extend: Option<Extend>,
pub config: Option<ConfigSection>,
pub env: Option<IndexMap<String, EnvValue>>,
pub tasks: Option<IndexMap<String, Task>>,
}
impl ExternalConfig {
pub fn new() -> ExternalConfig {
ExternalConfig {
extend: None,
config: None,
env: None,
tasks: None,
}
}
}
#[derive(Serialize, Debug)]
pub struct Step {
pub name: String,
pub config: Task,
}
#[derive(Debug)]
pub struct ExecutionPlan {
pub steps: Vec<Step>,
}
#[derive(Debug)]
pub struct CommandSpec {
pub command: String,
pub args: Option<Vec<String>>,
}