default to max supported php version

src/args.rs

@@ -1,5 +1,5 @@
 use crate::cloud::CloudOptions;
-use crate::config::Preset;
+use crate::config::{HazeConfig, Preset};
 use crate::service::{Service, ServiceTrait};
 use miette::{IntoDiagnostic, Report, Result};
 use parse_display::Display;
@@ -105,7 +105,7 @@ pub enum ExecService {
 }
 
 impl HazeArgs {
-    pub fn parse<I, S>(presets: &[Preset], mut args: I) -> Result<HazeArgs>
+    pub fn parse<I, S>(config: &HazeConfig, mut args: I) -> Result<HazeArgs>
     where
         S: AsRef<str> + Into<String> + Display,
         I: Iterator<Item = S>,
@@ -142,7 +142,7 @@ impl HazeArgs {
             }),
             HazeCommand::Start => {
                 let mut args = args.peekable();
-                let options = CloudOptions::parse(presets, &mut args)?;
+                let options = CloudOptions::parse(config, &mut args)?;
                 if let Some(leftover) = args.next() {
                     return Err(Report::msg(format!("unrecognized option {}", leftover)));
                 }
@@ -151,13 +151,13 @@ impl HazeArgs {
             HazeCommand::Stop => Ok(HazeArgs::Stop { filter }),
             HazeCommand::Test => {
                 let mut args = args.peekable();
-                let options = CloudOptions::parse(presets, &mut args)?;
+                let options = CloudOptions::parse(config, &mut args)?;
                 let args = args.map(S::into).collect();
                 Ok(HazeArgs::Test { options, args })
             }
             HazeCommand::Integration => {
                 let mut args = args.peekable();
-                let options = CloudOptions::parse(presets, &mut args)?;
+                let options = CloudOptions::parse(config, &mut args)?;
                 let args = args.map(S::into).collect();
                 Ok(HazeArgs::Integration { options, args })
             }
@@ -218,8 +218,8 @@ impl HazeArgs {
                 let mut args = args.peekable();
                 let follow = args.next_if(|arg| arg.as_ref() == "-f").is_some();
                 let service = args
-                    .next_if(|arg| LogService::from_type(presets, arg.as_ref()).is_some())
+                    .next_if(|arg| LogService::from_type(&config.preset, arg.as_ref()).is_some())
-                    .and_then(|arg| LogService::from_type(presets, arg.as_ref()));
+                    .and_then(|arg| LogService::from_type(&config.preset, arg.as_ref()));
                 Ok(HazeArgs::Logs {
                     filter,
                     follow,
@@ -241,7 +241,7 @@ impl HazeArgs {
             }
             HazeCommand::Shell => {
                 let mut args = args.peekable();
-                let options = CloudOptions::parse(presets, &mut args)?;
+                let options = CloudOptions::parse(config, &mut args)?;
                 let command = args.map(S::into).collect();
                 Ok(HazeArgs::Shell { options, command })
             }
@@ -348,25 +348,35 @@ impl HazeCommand {
 
 #[test]
 fn test_arg_parse() {
+    let config = HazeConfig {
+        sources_root: Default::default(),
+        work_dir: Default::default(),
+        auto_setup: Default::default(),
+        volume: vec![],
+        blackfire: None,
+        proxy: Default::default(),
+        preset: vec![],
+    };
+
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze"].into_iter()).unwrap(),
         HazeArgs::List { filter: None }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "test"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "test"].into_iter()).unwrap(),
         HazeArgs::Test {
             options: Default::default(),
             args: vec![]
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "asdasd"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "asdasd"].into_iter()).unwrap(),
         HazeArgs::List {
             filter: Some("asdasd".to_string())
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "asdasd", "db"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "asdasd", "db"].into_iter()).unwrap(),
         HazeArgs::Db {
             filter: Some("asdasd".to_string()),
             root: false,
@@ -375,7 +385,7 @@ fn test_arg_parse() {
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "asdasd", "db", "root"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "asdasd", "db", "root"].into_iter()).unwrap(),
         HazeArgs::Db {
             filter: Some("asdasd".to_string()),
             root: true,
@@ -384,7 +394,11 @@ fn test_arg_parse() {
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "asdasd", "db", "select", "1"].into_iter()).unwrap(),
+        HazeArgs::parse(
+            &config,
+            vec!["haze", "asdasd", "db", "select", "1"].into_iter()
+        )
+        .unwrap(),
         HazeArgs::Db {
             filter: Some("asdasd".to_string()),
             root: false,
@@ -394,7 +408,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "db", "root", "select 1"].into_iter()
         )
         .unwrap(),
@@ -407,7 +421,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "db", "root", "1", "select 1"].into_iter()
         )
         .unwrap(),
@@ -420,7 +434,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "db", "all", "select 1"].into_iter()
         )
         .unwrap(),
@@ -432,7 +446,7 @@ fn test_arg_parse() {
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "exec", "foo", "bar"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "exec", "foo", "bar"].into_iter()).unwrap(),
         HazeArgs::Exec {
             filter: None,
             service: None,
@@ -441,7 +455,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "exec", "foo", "bar"].into_iter()
         )
         .unwrap(),
@@ -453,7 +467,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "exec", "db", "foo", "bar"].into_iter()
         )
         .unwrap(),
@@ -464,14 +478,14 @@ fn test_arg_parse() {
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "test", "foo", "bar"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "test", "foo", "bar"].into_iter()).unwrap(),
         HazeArgs::Test {
             options: Default::default(),
             args: vec!["foo".into(), "bar".into()]
         }
     );
     assert_eq!(
-        HazeArgs::parse(&[], vec!["haze", "logs", "-f", "smb"].into_iter()).unwrap(),
+        HazeArgs::parse(&config, vec!["haze", "logs", "-f", "smb"].into_iter()).unwrap(),
         HazeArgs::Logs {
             filter: None,
             follow: true,
@@ -481,7 +495,7 @@ fn test_arg_parse() {
     );
     assert_eq!(
         HazeArgs::parse(
-            &[],
+            &config,
             vec!["haze", "asdasd", "logs", "smb", "123"].into_iter()
         )
         .unwrap(),

src/cloud.rs

@@ -1,4 +1,4 @@
-use crate::config::{HazeConfig, HazeVolumeConfig, Preset};
+use crate::config::{HazeConfig, HazeVolumeConfig};
 use crate::database::Database;
 use crate::exec::{exec, exec_io, exec_tty, ExitCode};
 use crate::mapping::{default_mappings, Mapping};
@@ -9,7 +9,7 @@ use bollard::container::{ListContainersOptions, RemoveContainerOptions, UpdateCo
 use bollard::models::ContainerState;
 use bollard::network::CreateNetworkOptions;
 use bollard::Docker;
-use camino::Utf8PathBuf;
+use camino::{Utf8Path, Utf8PathBuf};
 use flate2::read::GzDecoder;
 use futures_util::future::try_join_all;
 use miette::{IntoDiagnostic, Report, Result, WrapErr};
@@ -18,6 +18,7 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::fs;
+use std::fs::read_to_string;
 use std::io::{stdout, Cursor, Read, Stdout, Write};
 use std::iter::Peekable;
 use std::net::IpAddr;
@@ -29,7 +30,26 @@ use tokio::fs::remove_dir_all;
 use tokio::task::spawn;
 use tokio::time::sleep;
 
-#[derive(Clone, Default, Debug, Eq, PartialEq)]
+fn get_max_php_version(base_path: &Utf8Path) -> Option<PhpVersion> {
+    let version_check_code = read_to_string(base_path.join("lib/versioncheck.php")).ok()?;
+    let start = version_check_code.find("PHP_VERSION_ID >= ")?;
+    let code_part = &version_check_code[start + "PHP_VERSION_ID >= ".len()..];
+    let end = code_part.find(")")?;
+    let version_code = &code_part[0..end];
+    let mut major: u8 = version_code.get(0..1)?.parse().ok()?;
+    let mut minor: u8 = version_code.get(1..3)?.parse().ok()?;
+
+    if minor > 0 {
+        minor -= 1;
+    } else {
+        major -= 1;
+        minor = PhpVersion::max_minor(major);
+    }
+
+    PhpVersion::from_number(major, minor)
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Default)]
 pub struct CloudOptions {
     pub name: Option<String>,
     pub db: Database,
@@ -39,7 +59,19 @@ pub struct CloudOptions {
 }
 
 impl CloudOptions {
-    pub fn parse<I, S>(presets: &[Preset], args: &mut Peekable<I>) -> Result<CloudOptions>
+    pub fn new(config: &HazeConfig) -> Self {
+        let php = get_max_php_version(&config.sources_root).unwrap_or_default();
+
+        CloudOptions {
+            name: None,
+            php,
+            db: Database::default(),
+            services: vec![],
+            app_packages: vec![],
+        }
+    }
+
+    pub fn parse<I, S>(config: &HazeConfig, args: &mut Peekable<I>) -> Result<CloudOptions>
     where
         S: AsRef<str> + Into<String> + Display,
         I: Iterator<Item = S>,
@@ -57,7 +89,7 @@ impl CloudOptions {
             } else if let Ok(php_option) = PhpVersion::from_str(option.as_ref()) {
                 php = Some(php_option);
                 let _ = args.next();
-            } else if let Some(service) = Service::from_type(presets, option.as_ref()) {
+            } else if let Some(service) = Service::from_type(&config.preset, option.as_ref()) {
                 services.extend_from_slice(&service);
                 let _ = args.next();
             } else if option.as_ref().ends_with(".tar.gz") {
@@ -74,7 +106,9 @@ impl CloudOptions {
         Ok(CloudOptions {
             name,
             db: db.unwrap_or_default(),
-            php: php.unwrap_or_default(),
+            php: php
+                .or_else(|| get_max_php_version(&config.sources_root))
+                .unwrap_or_default(),
             services,
             app_packages: app_package,
         })
@@ -87,14 +121,16 @@ fn test_option_parse() {
     use crate::service::PresetService;
     use crate::service::{Ldap, LdapAdmin};
 
+    let config = HazeConfig::default();
+
     let mut args = vec![].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse::<_, &str>(&[], &mut args).unwrap(),
+        CloudOptions::parse::<_, &str>(&config, &mut args).unwrap(),
         CloudOptions::default()
     );
     let mut args = vec!["mariadb"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             db: Database::MariaDB,
             ..Default::default()
@@ -102,14 +138,14 @@ fn test_option_parse() {
     );
     let mut args = vec!["rest"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             ..Default::default()
         }
     );
     let mut args = vec!["7"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             php: PhpVersion::Php74,
             ..Default::default()
@@ -117,7 +153,7 @@ fn test_option_parse() {
     );
     let mut args = vec!["7", "pgsql", "rest"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             php: PhpVersion::Php74,
             db: Database::Postgres,
@@ -126,7 +162,7 @@ fn test_option_parse() {
     );
     let mut args = vec!["7", "ldap", "pgsql"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             php: PhpVersion::Php74,
             db: Database::Postgres,
@@ -136,7 +172,7 @@ fn test_option_parse() {
     );
     let mut args = vec!["7", "pgsql", "ldap"].into_iter().peekable();
     assert_eq!(
-        CloudOptions::parse(&[], &mut args).unwrap(),
+        CloudOptions::parse(&config, &mut args).unwrap(),
         CloudOptions {
             php: PhpVersion::Php74,
             db: Database::Postgres,
@@ -147,17 +183,19 @@ fn test_option_parse() {
     let mut args = vec!["7", "pgsql", "ldap", "mypreset"]
         .into_iter()
         .peekable();
+
+    let config = HazeConfig {
+        preset: vec![Preset {
+            name: "mypreset".to_string(),
+            commands: Vec::new(),
+            apps: Vec::new(),
+            config: HashMap::default(),
+        }],
+        ..HazeConfig::default()
+    };
+
     assert_eq!(
-        CloudOptions::parse(
+        CloudOptions::parse(&config, &mut args).unwrap(),
-            &[Preset {
-                name: "mypreset".to_string(),
-                commands: Vec::new(),
-                apps: Vec::new(),
-                config: HashMap::default(),
-            }],
-            &mut args
-        )
-        .unwrap(),
         CloudOptions {
             php: PhpVersion::Php74,
             db: Database::Postgres,

src/config.rs

@@ -9,7 +9,7 @@ use std::fs::read_to_string;
 use std::net::IpAddr;
 use toml::Value;
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Default)]
 #[serde(from = "RawHazeConfig")]
 pub struct HazeConfig {
     pub sources_root: Utf8PathBuf,

src/main.rs

@@ -57,7 +57,7 @@ async fn main() -> Result<ExitCode> {
         .wrap_err("Failed to connect to docker")?;
     let config = HazeConfig::load().wrap_err("Failed to load config")?;
 
-    let args = HazeArgs::parse(&config.preset, std::env::args())?;
+    let args = HazeArgs::parse(&config, std::env::args())?;
 
     match args {
         HazeArgs::Clean => {
@@ -265,7 +265,7 @@ async fn main() -> Result<ExitCode> {
             cloud.destroy(&docker).await?;
         }
         HazeArgs::Fmt { path } => {
-            let cloud = Cloud::create(&docker, CloudOptions::default(), &config).await?;
+            let cloud = Cloud::create(&docker, CloudOptions::new(&config), &config).await?;
             let mut out_buffer = Vec::<u8>::with_capacity(1024);
             println!("Waiting for servers to start");
             cloud.wait_for_start(&docker).await?;

src/php.rs

@@ -106,6 +106,27 @@ impl PhpVersion {
         }
     }
 
+    pub fn from_number(major: u8, minor: u8) -> Option<Self> {
+        match (major, minor) {
+            (7, 3) => Some(PhpVersion::Php73),
+            (7, 4) => Some(PhpVersion::Php74),
+            (8, 0) => Some(PhpVersion::Php80),
+            (8, 1) => Some(PhpVersion::Php81),
+            (8, 2) => Some(PhpVersion::Php82),
+            (8, 3) => Some(PhpVersion::Php83),
+            (8, 4) => Some(PhpVersion::Php84),
+            _ => None,
+        }
+    }
+
+    pub fn max_minor(major: u8) -> u8 {
+        match major {
+            7 => 4,
+            8 => 4,
+            _ => 0,
+        }
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub async fn spawn(
         &self,