Skip to content

Commit 31d7d58

Browse files
github-actions[bot]github-actions[bot]
committed
Auto-format: cargo fmt --all
1 parent c4b01ad commit 31d7d58

1 file changed

Lines changed: 63 additions & 57 deletions

File tree

‎crates/stdlib/src/lzma.rs‎

Lines changed: 63 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -210,8 +210,7 @@ mod _lzma {
210210
if self.track_header && self.header_collected < 8 {
211211
let need = (8 - self.header_collected) as usize;
212212
let n = need.min(input.len());
213-
self.header_buf[self.header_collected as usize..][..n]
214-
.copy_from_slice(&input[..n]);
213+
self.header_buf[self.header_collected as usize..][..n].copy_from_slice(&input[..n]);
215214
self.header_collected += n as u8;
216215
}
217216

@@ -268,15 +267,11 @@ mod _lzma {
268267
}
269268
}
270269

271-
fn parse_filter_spec_lzma(
272-
spec: &PyObjectRef,
273-
vm: &VirtualMachine,
274-
) -> PyResult<LzmaOptions> {
270+
fn parse_filter_spec_lzma(spec: &PyObjectRef, vm: &VirtualMachine) -> PyResult<LzmaOptions> {
275271
let preset = get_dict_opt_u32(spec, "preset", vm)?.unwrap_or(PRESET_DEFAULT);
276272

277-
let mut opts = LzmaOptions::new_preset(preset).map_err(|_| {
278-
new_lzma_error(format!("Invalid compression preset: {preset}"), vm)
279-
})?;
273+
let mut opts = LzmaOptions::new_preset(preset)
274+
.map_err(|_| new_lzma_error(format!("Invalid compression preset: {preset}"), vm))?;
280275

281276
if let Some(v) = get_dict_opt_u32(spec, "dict_size", vm)? {
282277
opts.dict_size(v);
@@ -329,24 +324,48 @@ mod _lzma {
329324
) -> Result<(), Error> {
330325
if start_offset == 0 {
331326
match filter_id {
332-
FILTER_X86 => { filters.x86(); }
333-
FILTER_POWERPC => { filters.powerpc(); }
334-
FILTER_IA64 => { filters.ia64(); }
335-
FILTER_ARM => { filters.arm(); }
336-
FILTER_ARMTHUMB => { filters.arm_thumb(); }
337-
FILTER_SPARC => { filters.sparc(); }
327+
FILTER_X86 => {
328+
filters.x86();
329+
}
330+
FILTER_POWERPC => {
331+
filters.powerpc();
332+
}
333+
FILTER_IA64 => {
334+
filters.ia64();
335+
}
336+
FILTER_ARM => {
337+
filters.arm();
338+
}
339+
FILTER_ARMTHUMB => {
340+
filters.arm_thumb();
341+
}
342+
FILTER_SPARC => {
343+
filters.sparc();
344+
}
338345
_ => unreachable!(),
339346
}
340347
Ok(())
341348
} else {
342349
let props = start_offset.to_le_bytes();
343350
match filter_id {
344-
FILTER_X86 => { filters.x86_properties(&props)?; }
345-
FILTER_POWERPC => { filters.powerpc_properties(&props)?; }
346-
FILTER_IA64 => { filters.ia64_properties(&props)?; }
347-
FILTER_ARM => { filters.arm_properties(&props)?; }
348-
FILTER_ARMTHUMB => { filters.arm_thumb_properties(&props)?; }
349-
FILTER_SPARC => { filters.sparc_properties(&props)?; }
351+
FILTER_X86 => {
352+
filters.x86_properties(&props)?;
353+
}
354+
FILTER_POWERPC => {
355+
filters.powerpc_properties(&props)?;
356+
}
357+
FILTER_IA64 => {
358+
filters.ia64_properties(&props)?;
359+
}
360+
FILTER_ARM => {
361+
filters.arm_properties(&props)?;
362+
}
363+
FILTER_ARMTHUMB => {
364+
filters.arm_thumb_properties(&props)?;
365+
}
366+
FILTER_SPARC => {
367+
filters.sparc_properties(&props)?;
368+
}
350369
_ => unreachable!(),
351370
}
352371
Ok(())
@@ -367,9 +386,8 @@ mod _lzma {
367386

368387
let mut filters = Filters::new();
369388
for spec in &filter_specs {
370-
let filter_id = get_dict_opt_u64(spec, "id", vm)?.ok_or_else(|| {
371-
vm.new_value_error("Filter specifier must have an \"id\" entry")
372-
})?;
389+
let filter_id = get_dict_opt_u64(spec, "id", vm)?
390+
.ok_or_else(|| vm.new_value_error("Filter specifier must have an \"id\" entry"))?;
373391

374392
match filter_id {
375393
FILTER_LZMA1 => {
@@ -472,9 +490,8 @@ mod _lzma {
472490

473491
match filter_id {
474492
FILTER_LZMA1 => {
475-
let (lc, lp, pb, dict_size) = decode_lzma1_properties(props).ok_or_else(|| {
476-
new_lzma_error("Invalid or unsupported options", vm)
477-
})?;
493+
let (lc, lp, pb, dict_size) = decode_lzma1_properties(props)
494+
.ok_or_else(|| new_lzma_error("Invalid or unsupported options", vm))?;
478495
dict.set_item("lc", vm.new_pyobj(lc), vm)?;
479496
dict.set_item("lp", vm.new_pyobj(lp), vm)?;
480497
dict.set_item("pb", vm.new_pyobj(pb), vm)?;
@@ -497,8 +514,7 @@ mod _lzma {
497514
FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
498515
| FILTER_SPARC => {
499516
if props.len() == 4 {
500-
let start_offset =
501-
u32::from_le_bytes([props[0], props[1], props[2], props[3]]);
517+
let start_offset = u32::from_le_bytes([props[0], props[1], props[2], props[3]]);
502518
dict.set_item("start_offset", vm.new_pyobj(start_offset), vm)?;
503519
}
504520
}
@@ -528,9 +544,8 @@ mod _lzma {
528544
filter_spec: PyObjectRef,
529545
vm: &VirtualMachine,
530546
) -> PyResult<Vec<u8>> {
531-
let filter_id = get_dict_opt_u64(&filter_spec, "id", vm)?.ok_or_else(|| {
532-
vm.new_value_error("Filter specifier must have an \"id\" entry")
533-
})?;
547+
let filter_id = get_dict_opt_u64(&filter_spec, "id", vm)?
548+
.ok_or_else(|| vm.new_value_error("Filter specifier must have an \"id\" entry"))?;
534549

535550
match filter_id {
536551
FILTER_LZMA1 => {
@@ -556,8 +571,7 @@ mod _lzma {
556571
}
557572
FILTER_X86 | FILTER_POWERPC | FILTER_IA64 | FILTER_ARM | FILTER_ARMTHUMB
558573
| FILTER_SPARC => {
559-
let start_offset =
560-
get_dict_opt_u32(&filter_spec, "start_offset", vm)?.unwrap_or(0);
574+
let start_offset = get_dict_opt_u32(&filter_spec, "start_offset", vm)?.unwrap_or(0);
561575
if start_offset == 0 {
562576
Ok(vec![])
563577
} else {
@@ -608,18 +622,14 @@ mod _lzma {
608622

609623
fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
610624
if args.format == FORMAT_RAW && args.memlimit.is_some() {
611-
return Err(
612-
vm.new_value_error("Cannot specify memory limit with FORMAT_RAW")
613-
);
625+
return Err(vm.new_value_error("Cannot specify memory limit with FORMAT_RAW"));
614626
}
615627

616628
if args.format == FORMAT_RAW && args.filters.is_none() {
617629
return Err(vm.new_value_error("Must specify filters for FORMAT_RAW"));
618630
}
619631
if args.format != FORMAT_RAW && args.filters.is_some() {
620-
return Err(
621-
vm.new_value_error("Cannot specify filters except with FORMAT_RAW")
622-
);
632+
return Err(vm.new_value_error("Cannot specify filters except with FORMAT_RAW"));
623633
}
624634

625635
let memlimit = args.memlimit.unwrap_or(u64::MAX);
@@ -637,22 +647,21 @@ mod _lzma {
637647
LzmaStream::new(stream, CHECK_UNKNOWN as i32, true)
638648
}
639649
FORMAT_ALONE => {
640-
let stream = Stream::new_lzma_decoder(memlimit)
641-
.map_err(|e| catch_lzma_error(e, vm))?;
650+
let stream =
651+
Stream::new_lzma_decoder(memlimit).map_err(|e| catch_lzma_error(e, vm))?;
642652
LzmaStream::new(stream, CHECK_NONE as i32, false)
643653
}
644654
FORMAT_RAW => {
645655
let filter_specs = args.filters.unwrap(); // safe: checked above
646656
let filters = parse_filter_chain_spec(filter_specs, vm)?;
647-
let stream = Stream::new_raw_decoder(&filters)
648-
.map_err(|e| catch_lzma_error(e, vm))?;
657+
let stream =
658+
Stream::new_raw_decoder(&filters).map_err(|e| catch_lzma_error(e, vm))?;
649659
LzmaStream::new(stream, CHECK_NONE as i32, false)
650660
}
651661
_ => {
652-
return Err(vm.new_value_error(format!(
653-
"Invalid container format: {}",
654-
args.format
655-
)));
662+
return Err(
663+
vm.new_value_error(format!("Invalid container format: {}", args.format))
664+
);
656665
}
657666
};
658667

@@ -783,8 +792,7 @@ mod _lzma {
783792
Stream::new_stream_encoder(&filters, real_check)
784793
.map_err(|e| catch_lzma_error(e, vm))
785794
} else {
786-
Stream::new_easy_encoder(preset, real_check)
787-
.map_err(|e| catch_lzma_error(e, vm))
795+
Stream::new_easy_encoder(preset, real_check).map_err(|e| catch_lzma_error(e, vm))
788796
}
789797
}
790798

@@ -811,9 +819,8 @@ mod _lzma {
811819
filter_specs: Option<Vec<PyObjectRef>>,
812820
vm: &VirtualMachine,
813821
) -> PyResult<Stream> {
814-
let filter_specs = filter_specs.ok_or_else(|| {
815-
vm.new_value_error("Must specify filters for FORMAT_RAW")
816-
})?;
822+
let filter_specs = filter_specs
823+
.ok_or_else(|| vm.new_value_error("Must specify filters for FORMAT_RAW"))?;
817824
let filters = parse_filter_chain_spec(filter_specs, vm)?;
818825
Stream::new_raw_encoder(&filters).map_err(|e| catch_lzma_error(e, vm))
819826
}
@@ -859,10 +866,9 @@ mod _lzma {
859866
FORMAT_ALONE => Self::init_alone(preset, args.filters, vm)?,
860867
FORMAT_RAW => Self::init_raw(args.filters, vm)?,
861868
_ => {
862-
return Err(vm.new_value_error(format!(
863-
"Invalid container format: {}",
864-
args.format
865-
)));
869+
return Err(
870+
vm.new_value_error(format!("Invalid container format: {}", args.format))
871+
);
866872
}
867873
};
868874

0 commit comments

Comments
 (0)