pre

Cargo.lock

@@ -1293,7 +1293,7 @@ dependencies = [
 
 [[package]]
 name = "rbx_asset"
-version = "0.4.3"
+version = "0.4.4-pre2"
 dependencies = [
  "bytes",
  "chrono",

rbx_asset/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.4.3"
+version = "0.4.4-pre2"
 edition = "2021"
 publish = ["strafesnet"]
 repository = "https://git.itzana.me/StrafesNET/asset-tool"

rbx_asset/src/cloud.rs

@@ -1,4 +1,5 @@
-use crate::util::{serialize_u64,deserialize_u64,response_ok,ResponseError,MaybeGzippedBytes};
+use crate::util::{serialize_u64,deserialize_u64,response_ok};
+use crate::types::{ResponseError,MaybeGzippedBytes};
 
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]

rbx_asset/src/cookie.rs

@@ -1,4 +1,5 @@
-use crate::util::{response_ok,ResponseError,MaybeGzippedBytes};
+use crate::util::response_ok;
+use crate::types::{ResponseError,MaybeGzippedBytes};
 
 #[derive(Debug)]
 pub enum PostError{

rbx_asset/src/lib.rs

@@ -1,3 +1,4 @@
 pub mod cloud;
 pub mod cookie;
 mod util;
+pub mod types;

rbx_asset/src/types.rs

@@ -0,0 +1,68 @@
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct StatusCodeWithUrlAndBody{
+	pub status_code:reqwest::StatusCode,
+	pub url:url::Url,
+	pub body:String,
+}
+#[derive(Debug)]
+pub enum ResponseError{
+	Reqwest(reqwest::Error),
+	StatusCodeWithUrlAndBody(StatusCodeWithUrlAndBody),
+}
+impl std::fmt::Display for ResponseError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for ResponseError{}
+
+#[cfg(feature="gzip")]
+use std::io::Cursor;
+#[cfg(feature="gzip")]
+use flate2::read::GzDecoder;
+
+/// Some bytes that might be gzipped.  Use the read_with or to_vec methods to transparently decode gzip.
+pub struct MaybeGzippedBytes{
+	bytes:bytes::Bytes,
+}
+impl MaybeGzippedBytes{
+	pub(crate) fn new(bytes:bytes::Bytes)->Self{
+		Self{bytes}
+	}
+	pub fn into_inner(self)->bytes::Bytes{
+		self.bytes
+	}
+	/// get a reference to the bytes, ignoring gzip decoding
+	pub fn as_raw_ref(&self)->&[u8]{
+		self.bytes.as_ref()
+	}
+	/// Transparently decode gzip data, if present (intermediate allocation)
+	#[cfg(feature="gzip")]
+	pub fn to_vec(&self)->std::io::Result<Vec<u8>>{
+		use std::io::Read;
+		match self.bytes.get(0..2){
+			Some(b"\x1f\x8b")=>{
+				let mut buf=Vec::new();
+				GzDecoder::new(Cursor::new(self.bytes.as_ref())).read_to_end(&mut buf)?;
+				Ok(buf)
+			},
+			_=>Ok(self.bytes.to_vec())
+		}
+	}
+	/// Read the bytes with the provided decoders.
+	/// The idea is to make a function that is generic over std::io::Read
+	/// and pass the same function to both closures.
+	/// This two closure hack must be done because of the different concrete types.
+	#[cfg(feature="gzip")]
+	pub fn read_with<'a,ReadGzip,ReadRaw,T>(&'a self,read_gzip:ReadGzip,read_raw:ReadRaw)->T
+		where
+			ReadGzip:Fn(GzDecoder<Cursor<&'a [u8]>>)->T,
+			ReadRaw:Fn(Cursor<&'a [u8]>)->T,
+	{
+		match self.bytes.get(0..2){
+			Some(b"\x1f\x8b")=>read_gzip(GzDecoder::new(Cursor::new(self.bytes.as_ref()))),
+			_=>read_raw(Cursor::new(self.bytes.as_ref()))
+		}
+	}
+}

rbx_asset/src/util.rs

@@ -1,21 +1,5 @@
-#[allow(dead_code)]
-#[derive(Debug)]
-pub struct StatusCodeWithUrlAndBody{
-	pub status_code:reqwest::StatusCode,
-	pub url:url::Url,
-	pub body:String,
-}
-#[derive(Debug)]
-pub enum ResponseError{
-	Reqwest(reqwest::Error),
-	StatusCodeWithUrlAndBody(StatusCodeWithUrlAndBody),
-}
-impl std::fmt::Display for ResponseError{
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for ResponseError{}
+use crate::types::{ResponseError,StatusCodeWithUrlAndBody};
+
 // lazy function to draw out meaningful info from http response on failure
 pub(crate) async fn response_ok(response:reqwest::Response)->Result<reqwest::Response,ResponseError>{
 	let status_code=response.status();
@@ -33,56 +17,6 @@ pub(crate) async fn response_ok(response:reqwest::Response)->Result<reqwest::Res
 	}
 }
 
-#[cfg(feature="gzip")]
-use std::io::Cursor;
-#[cfg(feature="gzip")]
-use flate2::read::GzDecoder;
-
-/// Some bytes that might be gzipped.  Use the read_with or to_vec methods to transparently decode gzip.
-pub struct MaybeGzippedBytes{
-	bytes:bytes::Bytes,
-}
-impl MaybeGzippedBytes{
-	pub(crate) fn new(bytes:bytes::Bytes)->Self{
-		Self{bytes}
-	}
-	pub fn into_inner(self)->bytes::Bytes{
-		self.bytes
-	}
-	/// get a reference to the bytes, ignoring gzip decoding
-	pub fn as_raw_ref(&self)->&[u8]{
-		self.bytes.as_ref()
-	}
-	/// Transparently decode gzip data, if present (intermediate allocation)
-	#[cfg(feature="gzip")]
-	pub fn to_vec(&self)->std::io::Result<Vec<u8>>{
-		use std::io::Read;
-		match self.bytes.get(0..2){
-			Some(b"\x1f\x8b")=>{
-				let mut buf=Vec::new();
-				GzDecoder::new(Cursor::new(self.bytes.as_ref())).read_to_end(&mut buf)?;
-				Ok(buf)
-			},
-			_=>Ok(self.bytes.to_vec())
-		}
-	}
-	/// Read the bytes with the provided decoders.
-	/// The idea is to make a function that is generic over std::io::Read
-	/// and pass the same function to both closures.
-	/// This two closure hack must be done because of the different concrete types.
-	#[cfg(feature="gzip")]
-	pub fn read_with<'a,ReadGzip,ReadRaw,T>(&'a self,read_gzip:ReadGzip,read_raw:ReadRaw)->T
-		where
-			ReadGzip:Fn(GzDecoder<Cursor<&'a [u8]>>)->T,
-			ReadRaw:Fn(Cursor<&'a [u8]>)->T,
-	{
-		match self.bytes.get(0..2){
-			Some(b"\x1f\x8b")=>read_gzip(GzDecoder::new(Cursor::new(self.bytes.as_ref()))),
-			_=>read_raw(Cursor::new(self.bytes.as_ref()))
-		}
-	}
-}
-
 use serde::de::{Error,Unexpected};
 use serde::{Deserializer,Serializer};
 
@@ -97,10 +31,10 @@ impl serde::de::Visitor<'_> for U64StringVisitor{
 	}
 }
 
-pub fn deserialize_u64<'de,D:Deserializer<'de>>(deserializer:D)->Result<u64,D::Error>{
+pub(crate) fn deserialize_u64<'de,D:Deserializer<'de>>(deserializer:D)->Result<u64,D::Error>{
 	deserializer.deserialize_any(U64StringVisitor)
 }
 
-pub fn serialize_u64<S:Serializer>(v:&u64,serializer:S)->Result<S::Ok,S::Error>{
+pub(crate) fn serialize_u64<S:Serializer>(v:&u64,serializer:S)->Result<S::Ok,S::Error>{
 	serializer.serialize_str(v.to_string().as_str())
 }