sequence_domain 0.2.0

A DNA/RNA sequence domain
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

use std::fmt::Display;

use dna_stuff::DnaSequenceValueObject;
use rna_stuff::RnaSequenceValueObject;
use traits::SequenceValue;

use crate::shared::errors::MalformedSequence;

pub mod dna_stuff;
pub mod rna_stuff;
pub mod traits;
pub(crate) mod value_objects;

#[derive(Debug, PartialEq, Eq)]
pub enum SequenceType {
    Dna,
    Rna,
}

impl Display for SequenceType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Dna => write!(f, "dna"),
            Self::Rna => write!(f, "rna"),
        }
    }
}

// struct DirtySequence;

#[derive(Debug, PartialEq)]
pub struct Sequence<T>
where
    T: SequenceValue,
{
    sequence: T,
}

impl Sequence<DnaSequenceValueObject> {
    /// Try creating a new sequence, or return error
    /// # Errors
    /// - `MalformedSequence`:
    ///      The sequence has invalid characters
    pub fn new(sequence: &str) -> Result<Self, MalformedSequence> {
        Ok(Sequence {
            sequence: DnaSequenceValueObject::new(sequence)?,
        })
    }

    pub fn get_sequence(&self) -> &DnaSequenceValueObject {
        &self.sequence
    }

    pub fn to_rna(self) -> Result<Sequence<RnaSequenceValueObject>, MalformedSequence> {
        Ok(Sequence {
            sequence: self.sequence.into(),
        })
    }
}

impl Sequence<RnaSequenceValueObject> {
    /// Try creating a new sequence, or return error
    /// # Errors
    /// - `MalformedSequence`:
    ///      The sequence has invalid characters
    pub fn new(sequence: &str) -> Result<Self, MalformedSequence> {
        Ok(Sequence {
            sequence: RnaSequenceValueObject::new(sequence)?,
        })
    }
    #[must_use]
    pub fn get_sequence(&self) -> &RnaSequenceValueObject {
        &self.sequence
    }

    /// Converts this RNA to DNA
    pub fn to_dna(self) -> Sequence<DnaSequenceValueObject> {
        Sequence {
            sequence: self.sequence.into(),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        domain::{dna_stuff::DnaSequenceValueObject, rna_stuff::RnaSequenceValueObject, Sequence},
        setup_mother_child,
        shared::object_mothers::{
            DnaSequenceObjectMother, RnaSequenceObjectMother, SequenceMother,
        },
    };

    #[test]
    fn should_create_new() {
        setup_mother_child!(
            common_mother,
            _common_child,
            DnaSequenceObjectMother,
            Sequence<DnaSequenceValueObject>
        );
        let manual_sequence: Sequence<DnaSequenceValueObject> =
            Sequence::<DnaSequenceValueObject>::new("atcg").unwrap();
        assert_eq!(
            &manual_sequence.get_sequence().to_string(),
            &common_mother.sequence
        );
    }
    #[test]
    fn should_return_sequence() {
        setup_mother_child!(
            common_mother,
            common_child,
            DnaSequenceObjectMother,
            Sequence<DnaSequenceValueObject>
        );
        assert_eq!(
            &common_child.get_sequence().to_string(),
            &common_mother.sequence
        );
    }
    #[test]
    fn should_change_to_rna() {
        let rna: Sequence<RnaSequenceValueObject> = RnaSequenceObjectMother::init()
            .with_sequence("aucg")
            .build();
        let dna: Sequence<DnaSequenceValueObject> = DnaSequenceObjectMother::init()
            .with_sequence("atcg")
            .build();

        assert_eq!(dna.to_rna().unwrap(), rna)
    }
    #[test]
    fn should_change_to_dna() {
        let rna: Sequence<RnaSequenceValueObject> = RnaSequenceObjectMother::init()
            .with_sequence("aucg")
            .build();
        let dna: Sequence<DnaSequenceValueObject> = DnaSequenceObjectMother::init()
            .with_sequence("atcg")
            .build();

        assert_eq!(rna.to_dna(), dna)
    }
}