gradle_sync/
configfile.rs

1use error::GradleResult;
2use error::Error;
3use std::io::{Read, Write};
4use std::fs::OpenOptions;
5use std::fs::File;
6use std::env;
7use semver::Version;
8use version::GradleVersion;
9use version::sem_version_parse;
10
11pub struct GradleFile<T> {
12    filename: String,
13    content: T
14}
15
16impl<T> GradleFile<T> where T: ConfigurationFormat {
17    pub fn new(filename: &str) -> GradleResult<GradleFile<T>> {
18        let fd = File::open(filename.clone())
19            .map_err(|_err| {
20                let reason = format!("failed to read file: {}", filename);
21                Error::IoError(reason)
22            })?;
23        Ok(Self {
24            filename: filename.to_string(),
25            content: T::from(fd)?
26        })
27    }
28
29    pub fn sync_with_cargo(&mut self) -> GradleResult<()> {
30        let pkg_version = env::var("CARGO_PKG_VERSION").unwrap();
31        let pkg_version = sem_version_parse(&pkg_version)?;
32        self.sync_version(&pkg_version)?;
33        if self.content.is_modified() {
34            self.write()?;
35        }
36        Ok(())
37    }
38
39    pub fn sync_version(&mut self, new_version: &Version) -> GradleResult<()> {
40        self.content.sync_version(&new_version)
41    }
42
43    pub fn write(&self) -> GradleResult<()> {
44        let mut fd = OpenOptions::new()
45            .write(true)
46            .create(true)
47            .open(&self.filename).map_err(|_err| {
48                let reason = format!("failed to open file for reading '{}'", self.filename);
49                Error::IoError(reason)
50            })?;
51        self.content.write(&mut fd)
52    }
53}
54
55pub trait ConfigurationFormat where Self: Sized {
56    fn from<R: Read>(reader: R) -> GradleResult<Self>;
57    fn current_version(&self) -> GradleResult<&GradleVersion>;
58    fn is_modified(&self) -> bool;
59    fn sync_version(&mut self, new_version: &Version) -> GradleResult<()>;
60    fn lines(&self) -> Vec<String>;
61
62    fn write<W: Write> (&self, writer: &mut W) -> GradleResult<()> {
63        for line in self.lines().iter() {
64            writer.write(line.as_bytes())
65                .map_err(|_err| {
66                    Error::IoError("failed to write".to_string())
67                })?;
68            writer.write(b"\n")
69                .map_err(|_err| {
70                    Error::IoError("failed to write".to_string())
71                })?;
72        };
73        Ok(())
74    }
75}