courses 0.9.4

A publishing system for interactive content
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use cdoc::config::Format;

use cdoc::package::Dependency;
use cdoc::parser::{Parser, ParserSettings};

use cdoc::renderers::extensions::structure::DocStructureConfig;
use cdoc::renderers::extensions::RenderExtensionConfig;
use cdoc_parser::notebook::NotebookMeta;
use clap::ValueEnum;
use semver::VersionReq;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectConfigDummy {
    pub courses: CoursesConfig,

    #[serde(flatten)]
    pub everything: HashMap<String, serde_yaml::Value>,
}

/// Refers to a configuration.yml file in the project that specifies a variety
/// of options for the project.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectConfig {
    pub courses: CoursesConfig,

    #[serde(default)]
    pub url_prefix: String,
    #[serde(default)]
    pub repository: RepositoryConfig,
    #[serde(default)]
    pub outputs: Vec<Box<dyn Format>>,
    #[serde(default = "default_profiles")]
    pub profiles: HashMap<String, Profile>,

    #[serde(default)]
    pub packages: Vec<Dependency>,

    #[serde(default)]
    pub custom: HashMap<String, serde_yaml::Value>,
    pub notebook_meta: Option<NotebookMeta>,

    #[serde(default)]
    pub scripts: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CoursesConfig {
    pub version: VersionReq,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Profile {
    #[serde(default)]
    pub mode: Mode,
    #[serde(default)]
    pub parser: Parser,
    #[serde(default)]
    pub formats: Vec<Box<dyn Format>>,
    #[serde(default)]
    pub render_extensions: HashMap<String, Vec<Box<dyn RenderExtensionConfig>>>,
    #[serde(default)]
    pub create_filters: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct RepositoryConfig {
    pub url: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BuildConfigSet {
    pub dev: BuildConfig,
    pub release: BuildConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BuildConfig {
    pub katex_output: bool,
}

fn default_profiles() -> HashMap<String, Profile> {
    let mut p = HashMap::new();
    p.insert(
        "draft".to_string(),
        Profile {
            mode: Mode::Draft,
            parser: Parser {
                preprocessors: vec![],
                settings: ParserSettings { solutions: true },
            },
            formats: vec![],
            render_extensions: HashMap::from([(
                "html".to_string(),
                vec![Box::new(DocStructureConfig {
                    max_heading_level: 0,
                    included_commands: vec![],
                })
                    as Box<dyn RenderExtensionConfig + 'static>],
            )]),
            create_filters: true,
        },
    );

    p.insert(
        "release".to_string(),
        Profile {
            mode: Mode::Release,
            parser: Parser {
                preprocessors: vec![],
                settings: ParserSettings { solutions: false },
            },
            formats: vec![],
            render_extensions: HashMap::from([(
                "html".to_string(),
                vec![Box::new(DocStructureConfig {
                    max_heading_level: 0,
                    included_commands: vec![],
                })
                    as Box<dyn RenderExtensionConfig + 'static>],
            )]),
            create_filters: false,
        },
    );

    p
}

/// Build mode. This is used internally for generation but is also available in templates.
#[derive(Serialize, Deserialize, Clone, Debug, Copy, ValueEnum, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum Mode {
    /// Don't include drafts
    Release,
    /// Include drafts.
    Draft,
}

impl Default for Mode {
    fn default() -> Self {
        Self::Draft
    }
}