currency_engineering/ui_data - Change XI5ALEH6NPTQWB6O62QV62EP4H3K7WSNTHCOGT3LZIIU6I2YDGIQC

Take advantage of keytree FromStr functionality.

Created by efindlay on July 3, 2021

XI5ALEH6NPTQWB6O62QV62EP4H3K7WSNTHCOGT3LZIIU6I2YDGIQC

Dependencies

In channels

main

Change contents

Deletion in src/serve_ui.rs at line 9 [3.14]
B:BD[3.270] → [3.270:292]
B:BD[3.307] → [3.307:324]
```
};
use time_series::{
    MonthlyDate,
```
Insertion in src/serve_ui.rs at line 13 [3.14]
[3.378]
[3.426]
```
    MonthlyDate,
    SeriesId,
```

Replacement in src/serve_ui.rs at line 17 [3.14]

B:BD[2.25] → [2.25:72]

∅:D[2.72] → [3.471:474]

B:BD[3.471] → [3.471:474]

use crate::error:: {
    Error,
    ErrorKind,
};

[2.25]

[3.474]

use crate::error::*;
// --- JSON Serializers -------------------------------------------------------------
// pub struct UIJson(HashMap<(Country Index),Vec<Graphic>
// Do we want meta for each line?
// --- Specification ----------------------------------------------------------------

Replacement in src/serve_ui.rs at line 49 [3.14]

B:BD[2.214] → [2.214:267]

            UISpec(self.vec("ui_spec::ui_graphic")?)

[2.214]

[2.267]

            UISpec(self.vec_at("ui_spec::ui_graphic")?)

Deletion in src/serve_ui.rs at line 88 [3.14]
∅:D[2.1057] → [3.1434:1435]
B:BD[3.1434] → [3.1434:1435]
B:BD[3.1435] → [2.1058:1125]
∅:D[2.1125] → [3.1496:1560]
B:BD[3.1496] → [3.1496:1560]
```
        let country_str: String = self.at("ui_graphic::country")?;
        let country = Country::from_str(&country_str).unwrap();
```

Replacement in src/serve_ui.rs at line 91 [3.14]

B:BD[2.1154] → [2.1154:1438]

                country,
                index:          self.at("ui_graphic::index")?,
                title:          self.at("ui_graphic::title")?,
                time_series:    self.vec("ui_graphic::time_series")?,
                line:           self.vec("ui_graphic::line")?,

[2.1154]

[3.1680]

                country:        self.value("ui_graphic::country")?,
                index:          self.value("ui_graphic::index")?,
                title:          self.value("ui_graphic::title")?,
                time_series:    self.vec_at("ui_graphic::time_series")?,
                line:           self.vec_at("ui_graphic::line")?,

Replacement in src/serve_ui.rs at line 111 [3.14]
B:BD[3.2774] → [3.2774:2804]
```
    x: String,
    y: String,
```
[3.2774]
[3.2804]
```
    x: SeriesId,
    y: SeriesId,
```

Deletion in src/serve_ui.rs at line 121 [3.14]

∅:D[2.1587] → [3.3007:3135]

B:BD[3.3007] → [3.3007:3135]

B:BD[3.3135] → [2.1588:1846]

∅:D[2.1846] → [3.3187:3444]

B:BD[3.3187] → [3.3187:3444]

        let start_date_str: Option<String> = self.op("line::start_date")?;
        let start_date_opt = match start_date_str {
            Some(date) => {
                Some(
                    parse_date(&date)
                        .map_err(|_|
keytree::Error::new(keytree::ErrorKind::User(Error::new(ErrorKind::ParseDate(date)).to_string())))?
                )
            },
            None => None,
        };
        let end_date_str: Option<String> = self.op("line::end_date")?;
        let end_date_opt = match end_date_str { 
            Some(date) => Some(parse_date(&date)?),
            None => None,
        };

Replacement in src/serve_ui.rs at line 123 [3.14]

B:BD[3.3481] → [3.3481:3645]

                x: self.at("line::x")?,
                y: self.at("line::y")?,
                start_date: start_date_opt,
                end_date: end_date_opt,

[3.3481]

[3.3645]

                x: self.value("line::x")?,
                y: self.value("line::y")?,
                start_date: self.opt_value("line::start_date")?,
                end_date: self.opt_value("line::end_date")?,

Replacement in src/serve_ui.rs at line 144 [3.14]

B:BD[2.2125] → [2.2125:2197]

            _ => Err(Error::new(ErrorKind::ParseTransform(s.into()))),

[2.2125]

[3.4843]

            _ => Err(parse_transform(s)),

Deletion in src/serve_ui.rs at line 173 [3.14]

∅:D[2.2759] → [3.5771:5780]

B:BD[3.5771] → [3.5771:5780]

B:BD[3.5780] → [2.2760:2901]

∅:D[2.2901] → [3.6016:6017]

B:BD[3.6016] → [3.6016:6017]

B:BD[3.6017] → [2.2902:3044]

∅:D[2.3044] → [3.6283:6284]

B:BD[3.6283] → [3.6283:6284]

B:BD[3.6284] → [2.3045:3264]

∅:D[2.3264] → [3.6788:6789]

B:BD[3.6788] → [3.6788:6789]

B:BD[3.6789] → [2.3265:3476]

∅:D[2.3476] → [3.6866:6867]

B:BD[3.6866] → [3.6866:6867]

        
        let data_type_str: String = self.at("time_series::data_type")?;
        let data_type = DataType::from_str(&data_type_str).unwrap();
        let transform_str: String = self.at("time_series::transform")?;
        let transform = Transform::from_str(&transform_str).unwrap();
        let start_date_str: Option<String> = self.op("time_series::start_date")?;
        let start_date = match start_date_str {
            Some(date) => Some(parse_date(&date)?),
            None => None,
        };
        let end_date_str: Option<String> = self.op("time_series::end_date")?;
        let end_date = match end_date_str {
            Some(date) => Some(parse_date(&date)?),
            None => None,
        };

Replacement in src/serve_ui.rs at line 175 [3.14]

B:BD[2.3508] → [2.3508:3673]

                data_type,
                start_date,
                end_date,
                series: self.at("time_series::series")?,
                transform,

[2.3508]

[3.7070]

                data_type:  self.value("time_series::data_type")?,
                start_date: self.opt_value("time_series::start_date")?,
                end_date:   self.opt_value("time_series::end_date")?,
                series:     self.value("time_series::series")?,
                transform:  self.value("time_series::transform")?,

Replacement in src/serve_ui.rs at line 185 [3.14]

B:BD[3.7103] → [2.3674:4027]

fn parse_date(s: &str) -> Result<MonthlyDate, keytree::Error> {
    let year = s[..=4].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
    let month = s[5..].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
    Ok(MonthlyDate::ym(year, month))
}

[3.7103]

// fn parse_date(s: &str) -> Result<MonthlyDate, keytree::Error> {
//     let year = s[..=4].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
//     let month = s[5..].parse::<usize>().map_err(|err| keytree::Error(Box::new(keytree::ErrorKind::User(err.to_string()))))?;
//     Ok(MonthlyDate::ym(year, month))
// }

Replacement in src/serve_ui.rs at line 191 [3.14]

B:BD[3.7104] → [2.4028:4156]

#[test]
fn test_parse_date() {
    let s = "1999-03";
    assert!(
        parse_date(s),
        MonthlyDate(1999, 3),
    )
}

[3.7104]

[2.4156]

// #[test]
// fn test_parse_date() {
//     let s = "1999-03";
//     assert!(
//         parse_date(s),
//         MonthlyDate(1999, 3),
//     )
// }

Deletion in src/serve_ts.rs at line 3 [3.7119]
B:BD[4.20] → [4.20:30]
```
    Into,
```

Replacement in src/serve_ts.rs at line 144 [3.7119]

∅:D[4.2241] → [5.1228:1296]

B:BD[5.1228] → [5.1228:1296]

        let page_vec: Vec<TSPageSpec> = self.vec("ts_spec::page")?;

[4.2241]

[5.1296]

        let page_vec: Vec<TSPageSpec> = self.vec_at("ts_spec::page")?;

Deletion in src/serve_ts.rs at line 209 [3.7119]
∅:D[5.2419] → [3.9603:9604]
∅:D[4.2680] → [3.9603:9604]
B:BD[3.9603] → [3.9603:9604]
B:BD[3.9604] → [5.2420:2484]
∅:D[5.2484] → [3.9665:9729]
B:BD[3.9665] → [3.9665:9729]
B:BD[3.9729] → [5.2485:2623]
∅:D[5.2623] → [3.9729:9734]
B:BD[3.9729] → [3.9729:9734]
```
        let country_str: String = self.at("country::country")?;
        let country = Country::from_str(&country_str).unwrap();
        let data_type_str: String = self.at("country::data_type")?;
        let data_type = DataType::from_str(&data_type_str).unwrap();
    
```

Replacement in src/serve_ts.rs at line 210 [3.7119]

B:BD[5.2648] → [2.4158:4179]

∅:D[2.4179] → [5.2678:2712]

B:BD[5.2678] → [5.2678:2712]

∅:D[5.2712] → [3.9788:9841]

B:BD[3.9788] → [3.9788:9841]

            country,
            data_type: data_type,
            graphics: self.vec("country::graphic")?,

[5.2648]

[3.9841]

            country:    self.value("country::country")?,
            data_type:  self.value("country::data_type")?,
            graphics:   self.vec_at("country::graphic")?,

Replacement in src/serve_ts.rs at line 289 [3.7119]

B:BD[3.10902] → [3.10902:11011]

                height: self.op("graphic::height")?,
                series_ids: self.vec("graphic::data")?,

[3.10902]

[3.11011]

                height: self.opt_value("graphic::height")?,
                series_ids: self.vec_value("graphic::data")?,

Deletion in src/serve_ts.rs at line 357 [3.7119]

B:BD[4.4607] → [4.4607:4710]

∅:D[4.4710] → [3.12081:12227]

B:BD[3.12081] → [3.12081:12227]

B:BD[3.12227] → [4.4711:4810]

∅:D[4.4810] → [3.12287:12353]

B:BD[3.12287] → [3.12287:12353]

        let data_type_str: String = self.at("key::data_type")
            .map_err(|err| err.into())?;
        // All KeyTree strings are internal, so if this fails it is a bug.
        let data_type = DataType::from_str(&data_type_str).unwrap();
        let country_str: String = self.at("key::country")
            .map_err(|err| err.into())?;
        let country = Country::from_str(&country_str).unwrap();

Replacement in src/serve_ts.rs at line 358 [3.7119]

B:BD[3.12374] → [3.12374:12438]

            data_type: data_type,
            country: country,

[3.12374]

[3.12438]

            data_type:  self.value("key::data_type")?,
            country:    self.value("key::country")?,

Insertion in src/lib.rs at line 157 [7.16]
[6.10732]
[6.10757]
```
use std::str::FromStr;
```

Insertion in src/lib.rs at line 162 [7.16]

[8.498]

[9.1794]


use crate::error::Error;
use crate::error::*;
/// A date that can be parsed from a string like "07-08-2010".
pub struct MonthlyDate(time_series::MonthlyDate);
impl FromStr for MonthlyDate {
    type Err = Error;
    
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let year = s[..4].parse().map_err(|_| parse_date("failed"))?;
        let month = s[5..7].parse().map_err(|_| parse_date("failed"))?;
        Ok(MonthlyDate(time_series::MonthlyDate::ym(year, month)))
    }
}
/// Represents a FRED series id.
pub struct SeriesId(String);
impl FromStr for SeriesId {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, ()> {
        Ok(SeriesId(String::from(s)))
    }
}

Replacement in src/lib.rs at line 203 [7.16]
B:BD[10.3393] → [6.11060:11076]
```
impl DataType {
```
[10.3393]
[4.7900]
```
impl FromStr for DataType {
    type Err = Error;
```
Replacement in src/lib.rs at line 208 [7.16]
∅:D[4.7971] → [6.11076:11123]
B:BD[6.11076] → [6.11076:11123]
```
    pub fn from_str(s: &str) -> Option<Self> {
```
[4.7971]
[6.11123]
```
    fn from_str(s: &str) -> Result<Self, Self::Err> {
```

Replacement in src/lib.rs at line 210 [7.16]

B:BD[6.11141] → [6.11141:11330]

            "u"   => Some(DataType::U),
            "cpi" => Some(DataType::Cpi),
            "inf" => Some(DataType::Inf),
            "int" => Some(DataType::Int),
            _ => None,

[6.11141]

[9.15738]

            "u"     => Ok(DataType::U),
            "cpi"   => Ok(DataType::Cpi),
            "inf"   => Ok(DataType::Inf),
            "int"   => Ok(DataType::Int),
            _       => Err(parse_datatype(s)),

Insertion in src/check_data.rs at line 4 [11.13227]
[11.13268]
[3.13325]
```
use std::str::FromStr;
```
Deletion in src/check_data.rs at line 26 [11.13227]
B:BD[4.8100] → [4.8100:8149]
```
};
use crate::error::{
    Error,
    ErrorKind,
```
Insertion in src/check_data.rs at line 27 [11.13227]
[4.8152]
[3.13411]
```
use crate::error::*;
```

Replacement in src/check_data.rs at line 97 [11.13227]

B:BD[4.9099] → [4.9099:9233]

            return Err(Error::new(
                ErrorKind::SpecErrorStatus(series_id, checked_series.error.clone())
            ))

[4.9099]

[4.9233]

            return Err(
                spec_has_error_status(&series_id, &checked_series.error.clone())
            )

Replacement in src/check_data.rs at line 112 [11.13227]

B:BD[4.9505] → [4.9505:9637]

                .map_err(|err| Error::new(
                    ErrorKind::NotRegular(checked_series.id.clone())
                ))?

[4.9505]

[4.9637]

                .map_err(|_| time_series_not_regular(&checked_series.id.clone()))?

Replacement in src/check_data.rs at line 239 [11.13227]

B:BD[11.15566] → [4.11015:11073]

            CheckedDataSpec(self.vec("seriess::series")?)

[11.15566]

[11.15623]

            CheckedDataSpec(self.vec_at("seriess::series")?)

Replacement in src/check_data.rs at line 272 [11.13227]

B:BD[4.11209] → [4.11209:11259]

    pub time_stamp: Option<time::OffsetDateTime>,

[4.11209]

[3.15815]

    pub time_stamp: Option<TimeStamp>,
}
/// A timestamp.
#[derive(Clone, Debug)]
pub struct TimeStamp(time::OffsetDateTime);
impl TimeStamp {
    fn format(self, format: &str) -> String {
        self.0.format(format)
    }
    fn now() -> Self {
        let inner = OffsetDateTime::now_utc(); 
        TimeStamp(inner)
    }
}
impl FromStr for TimeStamp {
    type Err = Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match OffsetDateTime::parse(s, "%Y %T") {
            Ok(stamp)   => Ok(TimeStamp(stamp)),
            Err(_)      => Err(parse_timestamp(s)),
        }
    }

Replacement in src/check_data.rs at line 346 [11.13227]

B:BD[3.16806] → [4.11283:11346]

            self.time_stamp = Some(OffsetDateTime::now_utc());

[3.16806]

[3.16868]

            self.time_stamp = Some(TimeStamp::now());

Replacement in src/check_data.rs at line 404 [11.13227]

B:BD[3.18467] → [3.18467:18511]

            Some(ts) => ts.format("%F %T"),

[3.18467]

[3.18511]

            Some(ts) => ts.clone().format("%F %T"),

Deletion in src/check_data.rs at line 416 [11.13227]

B:BD[11.16609] → [11.16609:16745]

        let data_type_str: String = self.at("series::data_type")?;
        let data_type = DataType::from_str(&data_type_str).unwrap();

Replacement in src/check_data.rs at line 417 [11.13227]

B:BD[11.16746] → [11.16746:16873]

B:BD[11.16873] → [3.18614:18686]

        let country_str: String = self.at("series::country")?;
        let country = Country::from_str(&country_str).unwrap();
        let date_str: Option<String> = self.op("series::time_stamp")?;

[11.16746]

[3.18686]

        // let time_stamp = match date_str {
        //     Some(date_str) => {
        //         Some(OffsetDateTime::parse(date_str, "%Y %T").unwrap())
        //     },
        //     None => None,
        // };

Deletion in src/check_data.rs at line 424 [11.13227]

B:BD[3.18687] → [3.18687:18761]

B:BD[3.18761] → [4.11347:11419]

∅:D[4.11419] → [3.18836:18888]

B:BD[3.18836] → [3.18836:18888]

∅:D[3.18888] → [11.16873:16874]

B:BD[11.16873] → [11.16873:16874]

        let time_stamp = match date_str {
            Some(date_str) => {
                Some(OffsetDateTime::parse(date_str, "%Y %T").unwrap())
            },
            None => None,
        };

Replacement in src/check_data.rs at line 426 [11.13227]

B:BD[11.16919] → [11.16919:17066]

B:BD[11.17066] → [3.18889:18917]

                data_type, 
                country,
                id: self.at("series::id")?,
                error: self.at("series::error")?,
                time_stamp,

[11.16919]

[11.17066]

                data_type:      self.value("series::data_type")?, 
                country:        self.value("series::country")?,
                id:             self.value("series::id")?,
                error:          self.value("series::error")?,
                time_stamp:     self.opt_value("series::time_stamp")?,

Replacement in src/check_data.rs at line 494 [11.13227]

B:BD[3.20052] → [3.20052:20596]

                realtime:               self.at("series_meta::realtime")?,
                id:                     self.at("series_meta::id")?,
                title:                  self.at("series_meta::title")?,
                observation_start:      self.at("series_meta::observation_start")?,
                observation_end:        self.at("series_meta::observation_end")?,
                frequency:              self.at("series_meta::frequency")?,
                seasonal_adjustment:    self.at("series_meta::seasonal_adjustment")?,

[3.20052]

[3.20596]

                realtime:               self.value("series_meta::realtime")?,
                id:                     self.value("series_meta::id")?,
                title:                  self.value("series_meta::title")?,
                observation_start:      self.value("series_meta::observation_start")?,
                observation_end:        self.value("series_meta::observation_end")?,
                frequency:              self.value("series_meta::frequency")?,
                seasonal_adjustment:    self.value("series_meta::seasonal_adjustment")?,

Replacement in src/build_spec.rs at line 1036 [3.21266]

B:BD[3.61674] → [3.61674:61724]

            DataSpec(self.vec("seriess:series")?)

[3.61674]

[3.61724]

            DataSpec(self.vec_at("seriess:series")?)

Deletion in src/build_spec.rs at line 1080 [3.21266]

B:BD[3.62617] → [3.62617:62882]

        let data_type_str: String = self.at("series::data_type")?;
        let data_type = DataType::from_str(&data_type_str).unwrap();
        let country_str: String = self.at("series::country")?;
        let country = Country::from_str(&country_str).unwrap();

Replacement in src/build_spec.rs at line 1082 [3.21266]

B:BD[3.62920] → [3.62920:63017]

                data_type, 
                country,
                id: self.at("series::id")?,

[3.62920]

[3.63017]

                data_type:  self.value("series::data_type")?, 
                country:    self.value("series::country")?,
                id:         self.value("series::id")?,