enh(xcodegen): types

Author: kkharji

src/types/project.rs

@@ -1,80 +1,92 @@
+mod config;
+mod dependency;
+mod options;
+mod package;
+mod platform;
+mod target;
+mod target_type;
+
 use super::Root;
-#[cfg(feature = "daemon")]
-use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::PathBuf;
+pub use {
+    config::PluginConfig, dependency::*, options::*, package::*, platform::*, target::*,
+    target_type::*,
+};
+
+#[cfg(feature = "daemon")]
+use anyhow::Result;
 
 /// Represent XcodeGen Project
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct Project {
     /// Project Name or rather xproj generated file name.
     pub name: String,
+
     /// The list of targets in the project mapped by name
-    pub targets: HashMap<String, Target>,
-    /// xbase local configuration
+    pub targets: HashMap<String, ProjectTarget>,
+
     #[serde(rename(deserialize = "xbase"), default)]
-    pub xcode_base: LocalConfig,
-    /// Root directory
+    /// xbase local configuration
+    pub xbase: PluginConfig,
+
     #[serde(skip)]
+    /// Root directory
     pub root: Root,
-    /// Connected Clients
+
     #[serde(default)]
+    /// Connected Clients
     pub clients: Vec<i32>,
-    /// Ignore Patterns
+
     #[serde(default)]
+    /// Ignore Patterns
     pub ignore_patterns: Vec<String>,
-}
 
-/// Represent Xcode Target
-// TODO: serialize from string or vector
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Target {
-    pub r#type: String,
-    pub platform: String,
-    pub sources: Vec<PathBuf>,
-}
+    #[serde(default)]
+    /// Options to override default behaviour
+    pub options: ProjectOptions,
 
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct LocalConfig {
-    pub ignore: Vec<String>,
+    #[serde(default)]
+    /// Packages
+    pub packages: HashMap<String, ProjectPackage>,
 }
 
 #[cfg(feature = "daemon")]
 impl Project {
-    pub async fn new(root: &PathBuf) -> Result<Self> {
+    pub async fn new(root: &std::path::PathBuf) -> Result<Self> {
         let path = root.join("project.yml");
         if !path.exists() {
             anyhow::bail!("project.yaml doesn't exist in '{:?}'", root)
         }
 
-        let project = tokio::fs::read_to_string(path).await?;
-        let mut project = serde_yaml::from_str::<Project>(&project)?;
-
-        let ignore_patterns: Vec<String> = vec![
-            "**/.git/**".into(),
-            "**/*.xcodeproj/**".into(),
-            "**/.*".into(),
-            "**/build/**".into(),
-            "**/buildServer.json".into(),
-        ];
+        let content = tokio::fs::read_to_string(path).await?;
+        let mut project = serde_yaml::from_str::<Project>(&content)?;
 
         // Note: Add extra ignore patterns to `ignore` local config requires restarting daemon.
+        project.ignore_patterns.extend(project.xbase.ignore.clone());
         project
             .ignore_patterns
-            .extend(project.xcode_base.ignore.clone());
-
-        project.ignore_patterns.extend(ignore_patterns);
+            .extend(DEFAULT_IGNORE_PATTERN.clone().into_iter());
 
         Ok(project)
     }
 
     pub async fn update(&mut self) -> Result<()> {
-        let new_project = Self::new(&self.root).await?;
-        self.name = new_project.name;
-        self.targets = new_project.targets;
-        self.xcode_base = new_project.xcode_base;
-
+        let ignore_patterns = self.ignore_patterns.clone();
+        *self = Self::new(&self.root).await?;
+        self.ignore_patterns = ignore_patterns;
         Ok(())
     }
 }
+
+#[cfg(feature = "daemon")]
+lazy_static::lazy_static! {
+    static ref DEFAULT_IGNORE_PATTERN: Vec<String> = vec![
+            "**/.git/**".into(),
+            "**/*.xcodeproj/**".into(),
+            "**/.*".into(),
+            "**/build/**".into(),
+            "**/buildServer.json".into(),
+        ];
+}

src/types/project/config.rs

@@ -0,0 +1,6 @@
+use super::*;
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+pub struct PluginConfig {
+    pub ignore: Vec<String>,
+}

src/types/project/dependency.rs

@@ -0,0 +1,22 @@
+#[derive(Debug)]
+pub enum ProjectDependency {
+    /// Links to another target. If you are using project references you can specify a target
+    /// within another project by using ProjectName/TargetName for the name
+    Target(String),
+    /// Links to a framework or XCFramework
+    Framework(String),
+    /// Helper for linking to a Carthage framework (not XCFramework)
+    Carthage(String),
+    /// Links to a dependency with the SDK. This can either be a relative path within the sdk root
+    /// or a single filename that references a framework (.framework) or lib (.tbd)
+    Sdk(String),
+    /// Links to a Swift Package. The name must match the name of a package defined in the top
+    /// level packages
+    Package(String),
+    /// Adds the pre-built bundle for the supplied name to the copy resources build phase. This is
+    /// useful when a dependency exists on a static library target that has an associated bundle
+    /// target, both existing in a separate project. Only usable in target types which can copy
+    /// resources.
+    Bundle(String),
+    None,
+}

src/types/project/options.rs

@@ -0,0 +1,71 @@
+use super::*;
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectOptions {
+    /// If this is specified then any target that doesn't have an PRODUCT_BUNDLE_IDENTIFIER (via
+    /// all levels of build settings) will get an autogenerated one by combining bundleIdPrefix and
+    /// the target name: bundleIdPrefix.name. The target name will be stripped of all characters
+    /// that aren't alphanumerics, hyphens, or periods. Underscores will be replaced with hyphens.
+    ///
+    /// Note: This is used to launch apps
+    bundle_id_prefix: String,
+
+    /// The path to the carthage build directory. Defaults to Carthage/Build. This is used when
+    /// specifying target carthage dependencies
+    ///
+    #[serde(default = "carthage_build_path_default")]
+    carthage_build_path: String,
+
+    /// The path to the carthage executable. Defaults to carthage.
+    carthage_executable_path: Option<String>,
+
+    /// When this is set to true, all the invididual frameworks for Carthage framework dependencies
+    /// will automatically be found. This property can be overriden individually for each carthage
+    /// dependency - for more details see See findFrameworks in the Dependency section. Defaults to
+    /// false.
+    #[serde(default)]
+    find_carthage_frameworks: bool,
+
+    /// This controls the settings that are automatically applied to the project and its targets.
+    /// These are the same build settings that Xcode would add when creating a new project. Project
+    /// settings are applied by config type. Target settings are applied by the product type and
+    /// platform. By default this is set to all
+    ///
+    /// - all: project and target settings
+    /// - project: only project settings
+    /// - targets: only target settings
+    /// - none: no settings are automatically applied
+    #[serde(default = "setting_presets_default")]
+    setting_presets: String,
+
+    /// A project wide deployment target can be specified for each platform otherwise the default
+    /// SDK version in Xcode will be used. This will be overridden by any custom build settings
+    /// that set the deployment target eg IPHONEOS_DEPLOYMENT_TARGET. Target specific deployment
+    /// targets can also be set with Target.deploymentTarget.
+    #[serde(default)]
+    deployment_target: HashMap<Platform, String>,
+
+    /// The default configuration for command line builds from Xcode. If the configuration provided
+    /// here doesn't match one in your configs key, XcodeGen will fail. If you don't set this, the
+    /// first configuration alphabetically will be chosen.
+    default_config: Option<String>,
+
+    /// If this is false and your project does not include resources located in a Base.lproj
+    /// directory then Base will not be included in the projects 'known regions'. The default value
+    /// is true.
+    #[serde(default = "use_base_internationalization_default")]
+    use_base_internationalization: bool,
+}
+
+const fn use_base_internationalization_default() -> bool {
+    true
+}
+
+fn carthage_build_path_default() -> String {
+    String::from("Carthage/Build")
+}
+
+fn setting_presets_default() -> String {
+    String::from("all")
+}

src/types/project/package.rs

@@ -0,0 +1,30 @@
+use super::*;
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectPackage {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    from: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    branch: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    exact_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    major_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    minor_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    min_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_version: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    revision: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    github: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    group: Option<String>,
+}

src/types/project/platform.rs

@@ -0,0 +1,48 @@
+use super::*;
+#[derive(Debug, Default, Deserialize, Serialize, Hash, PartialEq, Eq)]
+pub enum Platform {
+    #[serde(rename = "iOS")]
+    IOS,
+    #[serde(rename = "watchOS")]
+    WatchOS,
+    #[serde(rename = "tvOS")]
+    TvOS,
+    #[serde(rename = "macOS")]
+    MacOS,
+    #[default]
+    None,
+}
+
+impl Platform {
+    /// Returns `true` if the platfrom is [`IOS`].
+    ///
+    /// [`IOS`]: Platfrom::IOS
+    #[must_use]
+    pub fn is_ios(&self) -> bool {
+        matches!(self, Self::IOS)
+    }
+
+    /// Returns `true` if the platfrom is [`WatchOS`].
+    ///
+    /// [`WatchOS`]: Platfrom::WatchOS
+    #[must_use]
+    pub fn is_watch_os(&self) -> bool {
+        matches!(self, Self::WatchOS)
+    }
+
+    /// Returns `true` if the platfrom is [`TvOS`].
+    ///
+    /// [`TvOS`]: Platfrom::TvOS
+    #[must_use]
+    pub fn is_tv_os(&self) -> bool {
+        matches!(self, Self::TvOS)
+    }
+
+    /// Returns `true` if the platfrom is [`MacOS`].
+    ///
+    /// [`MacOS`]: Platfrom::MacOS
+    #[must_use]
+    pub fn is_mac_os(&self) -> bool {
+        matches!(self, Self::MacOS)
+    }
+}