jumpcut 1.0.0

JumpCut is a library and CLI for converting Fountain-formatted text files into FDX, HTML, JSON, text, and PDF formats.
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

use crate::render_attributes::RenderAttributes;
use crate::styled_text::StyledText;
use serde::{Deserialize, Deserializer, Serialize};

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Fragment {
    Whole,
    ContinuedFromPrev,
    ContinuedToNext,
    ContinuedFromPrevAndToNext,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct LineRange(pub u32, pub u32);

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PaginationScope {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub first_page_number: Option<u32>,
    pub title_page_count: Option<u32>,
    pub body_start_page: Option<u32>,
}

#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct PageBreakFixtureSourceRefs {
    pub fountain: Option<String>,
    pub fdx: Option<String>,
    pub pdf: Option<String>,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct NormalizedElement {
    pub element_id: String,
    pub kind: String,
    pub text: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub inline_text: Option<StyledText>,
    #[serde(default, skip_serializing_if = "RenderAttributes::is_default")]
    pub render_attributes: RenderAttributes,
    pub fragment: Option<Fragment>,
    pub block_kind: Option<String>,
    pub block_id: Option<String>,
    pub dual_dialogue_group: Option<String>,
    pub dual_dialogue_side: Option<u8>,
}

impl<'de> Deserialize<'de> for NormalizedElement {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct NormalizedElementRepr {
            element_id: String,
            kind: String,
            text: String,
            #[serde(default)]
            inline_text: Option<StyledText>,
            #[serde(default)]
            render_attributes: Option<RenderAttributes>,
            fragment: Option<Fragment>,
            #[serde(default)]
            centered: bool,
            #[serde(default)]
            starts_new_page: bool,
            #[serde(default)]
            scene_number: Option<String>,
            block_kind: Option<String>,
            block_id: Option<String>,
            dual_dialogue_group: Option<String>,
            dual_dialogue_side: Option<u8>,
        }

        let repr = NormalizedElementRepr::deserialize(deserializer)?;
        let render_attributes = repr.render_attributes.unwrap_or(RenderAttributes {
            centered: repr.centered,
            starts_new_page: repr.starts_new_page,
            scene_number: repr.scene_number,
            ..RenderAttributes::default()
        });

        Ok(Self {
            element_id: repr.element_id,
            kind: repr.kind,
            text: repr.text,
            inline_text: repr.inline_text,
            render_attributes,
            fragment: repr.fragment,
            block_kind: repr.block_kind,
            block_id: repr.block_id,
            dual_dialogue_group: repr.dual_dialogue_group,
            dual_dialogue_side: repr.dual_dialogue_side,
        })
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct NormalizedScreenplay {
    pub screenplay: String,
    pub starting_page_number: Option<u32>,
    pub elements: Vec<NormalizedElement>,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PageItem {
    pub element_id: String,
    pub kind: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub text_preview: Option<String>,
    pub fragment: Fragment,
    pub line_range: Option<LineRange>,
    pub block_id: Option<String>,
    pub dual_dialogue_group: Option<String>,
    pub dual_dialogue_side: Option<u8>,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PageBreakFixturePage {
    pub number: u32,
    pub items: Vec<PageItem>,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PageBreakFixture {
    pub screenplay: String,
    pub style_profile: String,
    pub source: PageBreakFixtureSourceRefs,
    pub scope: PaginationScope,
    pub pages: Vec<PageBreakFixturePage>,
}