ari-party/rojo
1
0
Fork 0
forked from rojo-rbx/rojo
Code Pull Requests Activity

Port from Failure to Snafu (#281)

Browse Source 
* Failure -> Snafu for build command

* Port skeletal remains of init to snafu

* failure -> snafu for serve

* failure -> snafu for upload, remove impl_from macro

* failure -> custom error in vfs

* Bye bye, failure

* Fix Rust 1.36 build regression
This commit is contained in:
Lucien Greathouse
2019-12-18 15:44:46 -08:00
committed by GitHub
parent 41396367ac
commit 1b9e90e786
10 changed files with 99 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/cli/build.rs
View File

@@ -3,13 +3,13 @@ use std::{
io::{self, BufWriter, Write},
};
use failure::Fail;
use snafu::{ResultExt, Snafu};
use crate::{
cli::BuildCommand,
common_setup,
project::ProjectError,
vfs::{FsError, RealFetcher, Vfs, WatchMode},
vfs::{RealFetcher, Vfs, WatchMode},
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -32,41 +32,46 @@ fn detect_output_kind(options: &BuildCommand) -> Option<OutputKind> {
}
}
#[derive(Debug, Fail)]
pub enum BuildError {
#[fail(display = "Could not detect what kind of file to create")]
#[derive(Debug, Snafu)]
pub struct BuildError(Error);
#[derive(Debug, Snafu)]
enum Error {
#[snafu(display("Could not detect what kind of file to create"))]
UnknownOutputKind,
#[fail(display = "IO error: {}", _0)]
IoError(#[fail(cause)] io::Error),
#[snafu(display("{}", source))]
Io { source: io::Error },
#[fail(display = "XML model error: {}", _0)]
XmlModelEncodeError(#[fail(cause)] rbx_xml::EncodeError),
#[snafu(display("{}", source))]
XmlModelEncode { source: rbx_xml::EncodeError },
#[fail(display = "Binary model error: {:?}", _0)]
BinaryModelEncodeError(rbx_binary::EncodeError),
#[snafu(display("Binary model error: {:?}", source))]
BinaryModelEncode {
#[snafu(source(false))]
source: rbx_binary::EncodeError,
},
#[fail(display = "{}", _0)]
ProjectError(#[fail(cause)] ProjectError),
#[fail(display = "{}", _0)]
FsError(#[fail(cause)] FsError),
#[snafu(display("{}", source))]
Project { source: ProjectError },
}
impl_from!(BuildError {
io::Error => IoError,
rbx_xml::EncodeError => XmlModelEncodeError,
rbx_binary::EncodeError => BinaryModelEncodeError,
ProjectError => ProjectError,
FsError => FsError,
});
impl From<rbx_binary::EncodeError> for Error {
fn from(source: rbx_binary::EncodeError) -> Self {
Error::BinaryModelEncode { source }
}
}
fn xml_encode_config() -> rbx_xml::EncodeOptions {
rbx_xml::EncodeOptions::new().property_behavior(rbx_xml::EncodePropertyBehavior::WriteUnknown)
}
pub fn build(options: BuildCommand) -> Result<(), BuildError> {
let output_kind = detect_output_kind(&options).ok_or(BuildError::UnknownOutputKind)?;
Ok(build_inner(options)?)
}
fn build_inner(options: BuildCommand) -> Result<(), Error> {
let output_kind = detect_output_kind(&options).ok_or(Error::UnknownOutputKind)?;
log::debug!("Hoping to generate file of type {:?}", output_kind);
@@ -77,14 +82,17 @@ pub fn build(options: BuildCommand) -> Result<(), BuildError> {
let root_id = tree.get_root_id();
log::trace!("Opening output file for write");
let mut file = BufWriter::new(File::create(&options.output)?);
let file = File::create(&options.output).context(Io)?;
let mut file = BufWriter::new(file);
match output_kind {
OutputKind::Rbxmx => {
// Model files include the root instance of the tree and all its
// descendants.
rbx_xml::to_writer(&mut file, tree.inner(), &[root_id], xml_encode_config())?;
rbx_xml::to_writer(&mut file, tree.inner(), &[root_id], xml_encode_config())
.context(XmlModelEncode)?;
}
OutputKind::Rbxlx => {
// Place files don't contain an entry for the DataModel, but our
@@ -93,7 +101,8 @@ pub fn build(options: BuildCommand) -> Result<(), BuildError> {
let root_instance = tree.get_instance(root_id).unwrap();
let top_level_ids = root_instance.children();
rbx_xml::to_writer(&mut file, tree.inner(), top_level_ids, xml_encode_config())?;
rbx_xml::to_writer(&mut file, tree.inner(), top_level_ids, xml_encode_config())
.context(XmlModelEncode)?;
}
OutputKind::Rbxm => {
rbx_binary::encode(tree.inner(), &[root_id], &mut file)?;
@@ -110,7 +119,7 @@ pub fn build(options: BuildCommand) -> Result<(), BuildError> {
}
}
file.flush()?;
file.flush().context(Io)?;
log::trace!("Done!");

22
src/cli/init.rs
View File

@@ -1,17 +1,17 @@
use failure::Fail;
use snafu::Snafu;
use crate::{cli::InitCommand, project::ProjectError};
use crate::cli::InitCommand;
#[derive(Debug, Fail)]
pub enum InitError {
#[fail(display = "Project init error: {}", _0)]
ProjectError(#[fail(cause)] ProjectError),
#[derive(Debug, Snafu)]
pub struct InitError(Error);
#[derive(Debug, Snafu)]
enum Error {}
pub fn init(options: InitCommand) -> Result<(), InitError> {
Ok(init_inner(options)?)
}
impl_from!(InitError {
ProjectError => ProjectError,
});
pub fn init(_options: InitCommand) -> Result<(), InitError> {
fn init_inner(_options: InitCommand) -> Result<(), Error> {
unimplemented!("init command");
}

19
src/cli/serve.rs
View File

@@ -3,12 +3,11 @@ use std::{
sync::Arc,
};
use failure::Fail;
use snafu::Snafu;
use termcolor::{BufferWriter, Color, ColorChoice, ColorSpec, WriteColor};
use crate::{
cli::ServeCommand,
project::ProjectError,
serve_session::ServeSession,
vfs::{RealFetcher, Vfs, WatchMode},
web::LiveServer,
@@ -16,17 +15,17 @@ use crate::{
const DEFAULT_PORT: u16 = 34872;
#[derive(Debug, Fail)]
pub enum ServeError {
#[fail(display = "Couldn't load project: {}", _0)]
ProjectError(#[fail(cause)] ProjectError),
}
#[derive(Debug, Snafu)]
pub struct ServeError(Error);
impl_from!(ServeError {
ProjectError => ProjectError,
});
#[derive(Debug, Snafu)]
enum Error {}
pub fn serve(options: ServeCommand) -> Result<(), ServeError> {
Ok(serve_inner(options)?)
}
fn serve_inner(options: ServeCommand) -> Result<(), Error> {
let vfs = Vfs::new(RealFetcher::new(WatchMode::Enabled));
let session = Arc::new(ServeSession::new(vfs, &options.project));

45
src/cli/upload.rs
View File

@@ -1,5 +1,5 @@
use failure::Fail;
use reqwest::header::{ACCEPT, CONTENT_TYPE, COOKIE, USER_AGENT};
use snafu::{ResultExt, Snafu};
use crate::{
auth_cookie::get_auth_cookie,
@@ -8,31 +8,35 @@ use crate::{
vfs::{RealFetcher, Vfs, WatchMode},
};
#[derive(Debug, Fail)]
pub enum UploadError {
#[fail(display = "Rojo could not find your Roblox auth cookie. Please pass one via --cookie.")]
#[derive(Debug, Snafu)]
pub struct UploadError(Error);
#[derive(Debug, Snafu)]
enum Error {
#[snafu(display(
"Rojo could not find your Roblox auth cookie. Please pass one via --cookie.",
))]
NeedAuthCookie,
#[fail(display = "XML model file encode error: {}", _0)]
XmlModelEncode(#[fail(cause)] rbx_xml::EncodeError),
#[snafu(display("XML model file encode error: {}", source))]
XmlModel { source: rbx_xml::EncodeError },
#[fail(display = "HTTP error: {}", _0)]
Http(#[fail(cause)] reqwest::Error),
#[snafu(display("HTTP error: {}", source))]
Http { source: reqwest::Error },
#[fail(display = "Roblox API error: {}", _0)]
RobloxApi(String),
#[snafu(display("Roblox API error: {}", body))]
RobloxApi { body: String },
}
impl_from!(UploadError {
rbx_xml::EncodeError => XmlModelEncode,
reqwest::Error => Http,
});
pub fn upload(options: UploadCommand) -> Result<(), UploadError> {
Ok(upload_inner(options)?)
}
fn upload_inner(options: UploadCommand) -> Result<(), Error> {
let cookie = options
.cookie
.or_else(get_auth_cookie)
.ok_or(UploadError::NeedAuthCookie)?;
.ok_or(Error::NeedAuthCookie)?;
log::trace!("Constructing in-memory filesystem");
let vfs = Vfs::new(RealFetcher::new(WatchMode::Disabled));
@@ -45,7 +49,7 @@ pub fn upload(options: UploadCommand) -> Result<(), UploadError> {
log::trace!("Encoding XML model");
let config = rbx_xml::EncodeOptions::new()
.property_behavior(rbx_xml::EncodePropertyBehavior::WriteUnknown);
rbx_xml::to_writer(&mut buffer, tree.inner(), &[root_id], config)?;
rbx_xml::to_writer(&mut buffer, tree.inner(), &[root_id], config).context(XmlModel)?;
let url = format!(
"https://data.roblox.com/Data/Upload.ashx?assetid={}",
@@ -62,10 +66,13 @@ pub fn upload(options: UploadCommand) -> Result<(), UploadError> {
.header(CONTENT_TYPE, "application/xml")
.header(ACCEPT, "application/json")
.body(buffer)
.send()?;
.send()
.context(Http)?;
if !response.status().is_success() {
return Err(UploadError::RobloxApi(response.text()?));
return Err(Error::RobloxApi {
body: response.text().context(Http)?,
});
}
Ok(())