Browse Source

Create neutauri_data crate to reduce dependencies

main
Tim-Paik 2 months ago
parent
commit
c1577c5450
Signed by: Tim-Paik
GPG Key ID: DC36A050DB42566D
  1. 17
      Cargo.lock
  2. 1
      Cargo.toml
  3. 4
      neutauri_bundler/Cargo.toml
  4. 11
      neutauri_bundler/src/bundle.rs
  5. 4
      neutauri_bundler/src/dev.rs
  6. 4
      neutauri_bundler/src/main.rs
  7. 17
      neutauri_data/Cargo.toml
  8. 108
      neutauri_data/src/lib.rs
  9. 4
      neutauri_runtime/Cargo.toml
  10. 255
      neutauri_runtime/src/data.rs
  11. 3
      neutauri_runtime/src/main.rs

17
Cargo.lock generated

@ -1192,10 +1192,8 @@ name = "neutauri_bundler"
version = "0.1.0"
dependencies = [
"anyhow",
"bincode",
"brotli",
"gumdrop",
"image",
"neutauri_data",
"new_mime_guess",
"rcedit",
"serde",
@ -1205,12 +1203,23 @@ dependencies = [
]
[[package]]
name = "neutauri_runtime"
name = "neutauri_data"
version = "0.1.0"
dependencies = [
"bincode",
"brotli",
"image",
"new_mime_guess",
"serde",
"toml",
"wry",
]
[[package]]
name = "neutauri_runtime"
version = "0.1.0"
dependencies = [
"neutauri_data",
"winres",
"wry",
]

1
Cargo.toml

@ -2,4 +2,5 @@
members = [
"neutauri_runtime",
"neutauri_bundler",
"neutauri_data",
]

4
neutauri_bundler/Cargo.toml

@ -5,10 +5,8 @@ version = "0.1.0"
[dependencies]
anyhow = "1.0"
bincode = "1.3"
brotli = "3.3"
gumdrop = "0.8"
image = "0.24"
neutauri_data = {path = "../neutauri_data", features = ["bundler"]}
new_mime_guess = "4.0"
serde = {version = "1.0", features = ["derive"]}
toml = "0.5"

11
neutauri_bundler/src/bundle.rs

@ -1,16 +1,15 @@
use crate::data;
use std::{
fs,
io::{self, Write},
};
#[cfg(windows)]
use anyhow::Context;
use neutauri_data as data;
#[cfg(windows)]
use std::{
env,
hash::{Hash, Hasher},
};
use std::{
fs,
io::{self, Write},
};
fn options() -> fs::OpenOptions {
#[cfg(not(windows))]

4
neutauri_bundler/src/dev.rs

@ -1,5 +1,5 @@
use neutauri_data as data;
use std::{fs, io::Read, path::PathBuf};
use wry::{
application::{
dpi::{PhysicalSize, Size},
@ -10,8 +10,6 @@ use wry::{
webview::{WebContext, WebViewBuilder},
};
use crate::data;
const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
const PROTOCOL: &str = "dev";

4
neutauri_bundler/src/main.rs

@ -1,8 +1,6 @@
use gumdrop::Options;
mod bundle;
mod dev;
mod data;
#[derive(Debug, Options)]
struct Args {
@ -80,7 +78,7 @@ fn main() -> anyhow::Result<()> {
}
let config_path = opts.config.unwrap_or_else(|| "neutauri.toml".to_string());
dev::dev(config_path)?;
},
}
},
None => print_help_and_exit(args),
}

17
neutauri_data/Cargo.toml

@ -0,0 +1,17 @@
[package]
edition = "2021"
name = "neutauri_data"
version = "0.1.0"
[dependencies]
bincode = "1.3"
brotli = "3.3"
image = {version = "0.24", optional = true}
new_mime_guess = {version = "4.0", optional = true}
serde = {version = "1.0", features = ["derive"]}
toml = {version = "0.5", optional = true}
wry = {version = "0.15", default-features = false, features = ["protocol", "tray", "gtk-tray", "transparent", "fullscreen"]}
[features]
bundler = ["new_mime_guess", "toml", "image"]
runtime = []

108
neutauri_bundler/src/data.rs → neutauri_data/src/lib.rs

@ -2,7 +2,7 @@ use bincode::Options;
use serde::{Deserialize, Serialize};
use std::{
fs,
io::{self, Read, Result},
io::{self, Read, Result, SeekFrom, Seek},
path::{self, Component, Path, PathBuf},
};
use wry::application::dpi::Position;
@ -104,6 +104,102 @@ pub struct WebViewAttr {
pub initialization_script: Option<String>,
}
#[cfg(feature = "runtime")]
impl File {
pub fn decompressed_data(&mut self) -> Result<Vec<u8>> {
let mut data = Vec::with_capacity(self.data.len());
let mut r = brotli::Decompressor::new(self.data.as_slice(), 4096);
r.read_to_end(&mut data)?;
Ok(data)
}
pub fn mimetype(&self) -> String {
self.mime.clone()
}
}
#[cfg(feature = "runtime")]
impl Data {
pub fn new<P: AsRef<path::Path> + Copy>(path: P) -> Result<Self> {
let mut base = fs::File::open(path)?;
let base_length = base.metadata()?.len();
let mut magic_number_start_data = [0; MAGIC_NUMBER_START.len()];
let mut data_length_data = [0; USIZE_LEN];
let mut data = Vec::new();
let mut magic_number_end_data = [0; MAGIC_NUMBER_END.len()];
base.seek(SeekFrom::Start(base_length - MAGIC_NUMBER_END.len() as u64))?;
// 此时指针指向 MAGIC_NUMBER_END 之前
base.read_exact(&mut magic_number_end_data)?;
if &magic_number_end_data != MAGIC_NUMBER_END {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"MAGIC_NUMBER_END not found",
));
}
base.seek(SeekFrom::Start(
base_length - MAGIC_NUMBER_END.len() as u64 - USIZE_LEN as u64,
))?;
// 此时指针指向 data_length 之前
base.read_exact(&mut data_length_data)?;
base.seek(SeekFrom::Start(
base_length - u64::from_be_bytes(data_length_data),
))?;
// 此时指针指向 MAGIC_NUMBER_START
base.read_exact(&mut magic_number_start_data)?;
if &magic_number_start_data != MAGIC_NUMBER_START {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"MAGIC_NUMBER_START not found",
));
}
base.read_exact(&mut data_length_data)?;
// 此时指针指向 Data 前
base.take(u64::from_be_bytes(data_length_data))
.read_to_end(&mut data)?;
let serialize_options = bincode::DefaultOptions::new()
.with_fixint_encoding()
.allow_trailing_bytes()
.with_limit(104857600 /* 100MiB */);
let fs: Self = match serialize_options.deserialize(&data) {
Ok(fs) => fs,
Err(e) => {
return Err(io::Error::new(io::ErrorKind::InvalidData, e));
}
};
Ok(fs)
}
fn open_file(&self, current_dir: &Dir, mut path: path::Iter) -> Result<File> {
let next_path = match path.next() {
Some(str) => str.to_string_lossy().to_string(),
None => return Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
};
for (name, file) in &current_dir.files {
if next_path == *name {
return Ok(file.clone());
}
}
for (name, dir) in &current_dir.dirs {
if next_path == *name {
return self.open_file(dir, path);
}
}
Err(io::Error::new(io::ErrorKind::NotFound, "file not found"))
}
pub fn open<P: AsRef<path::Path>>(&self, path: P) -> Result<File> {
let path = normalize_path(path.as_ref());
let path = if path.starts_with("/") {
path.strip_prefix("/")
.unwrap_or_else(|_| Path::new(""))
.to_path_buf()
} else {
path
};
self.open_file(&self.fs, path.iter())
}
}
#[cfg(feature = "bundler")]
impl Dir {
// 使用本地文件系统填充 Dir 结构体
fn fill_with<P: AsRef<path::Path>>(
@ -155,6 +251,7 @@ impl Dir {
}
}
#[cfg(feature = "bundler")]
impl Data {
pub fn build_from_dir<P: AsRef<path::Path>>(
source: P,
@ -229,6 +326,7 @@ impl Data {
}
}
#[cfg(feature = "bundler")]
impl Default for Config {
fn default() -> Self {
Self {
@ -255,6 +353,7 @@ impl Default for Config {
}
}
#[cfg(feature = "bundler")]
impl Config {
pub fn window_attr(&self) -> Result<WindowAttr> {
Ok(WindowAttr {
@ -294,10 +393,17 @@ impl Config {
}
}
#[cfg(feature = "runtime")]
pub fn load<P: AsRef<path::Path> + Copy>(path: P) -> Result<Data> {
Data::new(path)
}
#[cfg(feature = "bundler")]
pub fn pack<P: AsRef<path::Path>>(config: P) -> Result<()> {
Data::pack(config)
}
#[cfg(feature = "bundler")]
fn load_icon(path: &Path) -> Result<Icon> {
let image = image::open(path)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))?

4
neutauri_runtime/Cargo.toml

@ -4,9 +4,7 @@ name = "neutauri_runtime"
version = "0.1.0"
[dependencies]
bincode = "1.3"
brotli = "3.3"
serde = {version = "1.0", features = ["derive"]}
neutauri_data = {path = "../neutauri_data", features = ["runtime"]}
wry = {version = "0.15", default-features = false, features = ["protocol", "tray", "gtk-tray", "transparent", "fullscreen"]}
[target.'cfg(windows)'.build-dependencies]

255
neutauri_runtime/src/data.rs

@ -1,255 +0,0 @@
use bincode::Options;
use serde::{Deserialize, Serialize};
use std::{
fs,
io::{self, Read, Result, Seek, SeekFrom},
path::{self, Component, Path, PathBuf},
};
use wry::application::dpi::Position;
const MAGIC_NUMBER_START: &[u8; 9] = b"NEUTFSv01";
const MAGIC_NUMBER_END: &[u8; 9] = b"NEUTFSEnd";
const USIZE_LEN: usize = usize::MAX.to_be_bytes().len();
#[non_exhaustive]
#[derive(Serialize, Deserialize, Clone, Debug)]
pub enum Compress {
Brotli,
None,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct File {
mime: String,
data: Vec<u8>,
compress: Compress,
}
#[derive(Serialize, Deserialize, Debug)]
struct Dir {
files: Vec<(String, File)>,
dirs: Vec<(String, Dir)>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct Data {
pub window_attr: WindowAttr,
pub webview_attr: WebViewAttr,
fs: Dir,
}
#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
pub enum WindowSize {
Large,
Medium,
Small,
Fixed { width: f64, height: f64 },
Scale { factor: f64 },
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct Config {
pub source: PathBuf,
pub target: PathBuf,
pub inner_size: Option<WindowSize>,
pub min_inner_size: Option<WindowSize>,
pub max_inner_size: Option<WindowSize>,
pub resizable: bool,
pub fullscreen: bool,
pub title: String,
pub maximized: bool,
pub visible: bool,
pub transparent: bool,
pub decorations: bool,
pub always_on_top: bool,
pub icon: Option<PathBuf>,
pub spa: bool,
pub url: Option<String>,
pub html: Option<PathBuf>,
pub initialization_script: Option<String>,
pub manifest: Option<PathBuf>,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default)]
pub struct Icon {
pub rgba: Vec<u8>,
pub width: u32,
pub height: u32,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct WindowAttr {
pub inner_size: Option<WindowSize>,
pub min_inner_size: Option<WindowSize>,
pub max_inner_size: Option<WindowSize>,
pub position: Option<Position>,
pub resizable: bool,
pub fullscreen: bool,
pub title: String,
pub maximized: bool,
pub visible: bool,
pub transparent: bool,
pub decorations: bool,
pub always_on_top: bool,
pub icon: Option<Icon>,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct WebViewAttr {
pub visible: bool,
pub transparent: bool,
pub spa: bool,
pub url: Option<String>,
pub html: Option<String>,
pub initialization_script: Option<String>,
}
impl File {
pub fn decompressed_data(&mut self) -> Result<Vec<u8>> {
let mut data = Vec::with_capacity(self.data.len());
let mut r = brotli::Decompressor::new(self.data.as_slice(), 4096);
r.read_to_end(&mut data)?;
Ok(data)
}
pub fn mimetype(&self) -> String {
self.mime.clone()
}
}
impl Data {
pub fn new<P: AsRef<path::Path> + Copy>(path: P) -> Result<Self> {
let mut base = fs::File::open(path)?;
let base_length = base.metadata()?.len();
let mut magic_number_start_data = [0; MAGIC_NUMBER_START.len()];
let mut data_length_data = [0; USIZE_LEN];
let mut data = Vec::new();
let mut magic_number_end_data = [0; MAGIC_NUMBER_END.len()];
base.seek(SeekFrom::Start(base_length - MAGIC_NUMBER_END.len() as u64))?;
// 此时指针指向 MAGIC_NUMBER_END 之前
base.read_exact(&mut magic_number_end_data)?;
if &magic_number_end_data != MAGIC_NUMBER_END {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"MAGIC_NUMBER_END not found",
));
}
base.seek(SeekFrom::Start(
base_length - MAGIC_NUMBER_END.len() as u64 - USIZE_LEN as u64,
))?;
// 此时指针指向 data_length 之前
base.read_exact(&mut data_length_data)?;
base.seek(SeekFrom::Start(
base_length - u64::from_be_bytes(data_length_data),
))?;
// 此时指针指向 MAGIC_NUMBER_START
base.read_exact(&mut magic_number_start_data)?;
if &magic_number_start_data != MAGIC_NUMBER_START {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"MAGIC_NUMBER_START not found",
));
}
base.read_exact(&mut data_length_data)?;
// 此时指针指向 Data 前
base.take(u64::from_be_bytes(data_length_data))
.read_to_end(&mut data)?;
let serialize_options = bincode::DefaultOptions::new()
.with_fixint_encoding()
.allow_trailing_bytes()
.with_limit(104857600 /* 100MiB */);
let fs: Self = match serialize_options.deserialize(&data) {
Ok(fs) => fs,
Err(e) => {
return Err(io::Error::new(io::ErrorKind::InvalidData, e));
}
};
Ok(fs)
}
fn open_file(&self, current_dir: &Dir, mut path: path::Iter) -> Result<File> {
let next_path = match path.next() {
Some(str) => str.to_string_lossy().to_string(),
None => return Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
};
for (name, file) in &current_dir.files {
if next_path == *name {
return Ok(file.clone());
}
}
for (name, dir) in &current_dir.dirs {
if next_path == *name {
return self.open_file(dir, path);
}
}
Err(io::Error::new(io::ErrorKind::NotFound, "file not found"))
}
pub fn open<P: AsRef<path::Path>>(&self, path: P) -> Result<File> {
let path = normalize_path(path.as_ref());
let path = if path.starts_with("/") {
path.strip_prefix("/")
.unwrap_or_else(|_| Path::new(""))
.to_path_buf()
} else {
path
};
self.open_file(&self.fs, path.iter())
}
}
impl Default for Config {
fn default() -> Self {
Self {
source: PathBuf::from("."),
target: PathBuf::from("app.neu"),
inner_size: Some(WindowSize::Medium),
min_inner_size: None,
max_inner_size: None,
resizable: true,
fullscreen: false,
title: "".into(),
maximized: false,
visible: true,
transparent: false,
decorations: true,
always_on_top: false,
icon: None,
spa: false,
url: Some("/index.html".into()),
html: None,
initialization_script: None,
manifest: None,
}
}
}
pub fn load<P: AsRef<path::Path> + Copy>(path: P) -> Result<Data> {
Data::new(path)
}
pub fn normalize_path(path: &Path) -> PathBuf {
let mut components = path.components().peekable();
let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
components.next();
PathBuf::from(c.as_os_str())
} else {
PathBuf::new()
};
for component in components {
match component {
Component::Prefix(..) => {}
Component::RootDir => {
ret.push(component.as_os_str());
}
Component::CurDir => {}
Component::ParentDir => {
ret.pop();
}
Component::Normal(c) => {
ret.push(c);
}
}
}
ret
}

3
neutauri_runtime/src/main.rs

@ -1,7 +1,7 @@
#![windows_subsystem = "windows"]
use neutauri_data as data;
use std::path::PathBuf;
use wry::{
application::{
dpi::{PhysicalSize, Size},
@ -11,7 +11,6 @@ use wry::{
},
webview::{WebContext, WebViewBuilder},
};
mod data;
const PROTOCOL_PREFIX: &str = "{PROTOCOL}://";
const PROTOCOL: &str = "neu";

Loading…
Cancel
Save