From 54760d5c73ca20de2e155df274d576cec9ea0ed0 Mon Sep 17 00:00:00 2001 From: nsfisis Date: Mon, 10 Aug 2026 02:48:46 +0900 Subject: style(php-shim): drop the underscore from used parameter names These parameters kept the leading underscore they were given while their function bodies were still todo!(), and the underscore now reads as "this argument is ignored" for arguments the bodies do use. Removing the prefix stops it from suppressing four clippy lints, fixed alongside: one redundant field name, and three `&mut Vec` parameters that only need a slice. Co-Authored-By: Claude Opus 5 (1M context) --- crates/shirabe-php-shim/src/array.rs | 114 +++++++++--------- crates/shirabe-php-shim/src/fs.rs | 115 +++++++++---------- crates/shirabe-php-shim/src/runtime.rs | 4 +- crates/shirabe-php-shim/src/string.rs | 203 ++++++++++++++++----------------- crates/shirabe-php-shim/src/var.rs | 32 +++--- 5 files changed, 229 insertions(+), 239 deletions(-) (limited to 'crates') diff --git a/crates/shirabe-php-shim/src/array.rs b/crates/shirabe-php-shim/src/array.rs index c4cb2d6e..00e44da3 100644 --- a/crates/shirabe-php-shim/src/array.rs +++ b/crates/shirabe-php-shim/src/array.rs @@ -2,21 +2,21 @@ use crate::PhpMixed; use crate::php_to_string; use indexmap::IndexMap; -pub fn array_values(_array: &IndexMap) -> Vec { - _array.values().cloned().collect() +pub fn array_values(array: &IndexMap) -> Vec { + array.values().cloned().collect() } -pub fn array_keys(_array: &IndexMap) -> Vec { - _array.keys().cloned().collect() +pub fn array_keys(array: &IndexMap) -> Vec { + array.keys().cloned().collect() } -pub fn array_push(_array: &mut Vec, _value: String) -> i64 { - _array.push(_value); - _array.len() as i64 +pub fn array_push(array: &mut Vec, value: String) -> i64 { + array.push(value); + array.len() as i64 } -pub fn array_search_in_vec(_needle: &str, _haystack: &[String]) -> Option { - _haystack.iter().position(|s| s.as_str() == _needle) +pub fn array_search_in_vec(needle: &str, haystack: &[String]) -> Option { + haystack.iter().position(|s| s.as_str() == needle) } pub fn array_map_str_fn String>(_callback: F, _array: &[String]) -> Vec { @@ -136,10 +136,10 @@ pub fn array_merge_map( result } -pub fn array_diff(_array1: &[String], _array2: &[String]) -> Vec { - _array1 +pub fn array_diff(array1: &[String], array2: &[String]) -> Vec { + array1 .iter() - .filter(|&x| !_array2.contains(x)) + .filter(|&x| !array2.contains(x)) .cloned() .collect() } @@ -158,12 +158,12 @@ pub fn array_unique(array: &[T]) -> Vec { } pub fn array_intersect_key( - _array1: &IndexMap, - _array2: &IndexMap, + array1: &IndexMap, + array2: &IndexMap, ) -> IndexMap { - _array1 + array1 .iter() - .filter(|(k, _)| _array2.contains_key(k.as_str())) + .filter(|(k, _)| array2.contains_key(k.as_str())) .map(|(k, v)| (k.clone(), v.clone())) .collect() } @@ -260,72 +260,72 @@ pub fn array_search(needle: &str, haystack: &IndexMap) -> Option .map(|(key, _)| key.clone()) } -pub fn array_shift(_array: &mut Vec) -> Option { - if _array.is_empty() { +pub fn array_shift(array: &mut Vec) -> Option { + if array.is_empty() { None } else { - Some(_array.remove(0)) + Some(array.remove(0)) } } -pub fn array_pop(_array: &mut Vec) -> Option { - _array.pop() +pub fn array_pop(array: &mut Vec) -> Option { + array.pop() } -pub fn array_unshift(_array: &mut Vec, _value: T) { - _array.insert(0, _value); +pub fn array_unshift(array: &mut Vec, value: T) { + array.insert(0, value); } -pub fn array_reverse(_array: &[T], _preserve_keys: bool) -> Vec { - _array.iter().rev().cloned().collect() +pub fn array_reverse(array: &[T], _preserve_keys: bool) -> Vec { + array.iter().rev().cloned().collect() } -pub fn array_filter(_array: &[T], _callback: F) -> Vec +pub fn array_filter(array: &[T], callback: F) -> Vec where F: Fn(&T) -> bool, { - _array.iter().filter(|&x| _callback(x)).cloned().collect() + array.iter().filter(|&x| callback(x)).cloned().collect() } pub fn array_filter_map( - _array: &IndexMap, - _callback: F, + array: &IndexMap, + callback: F, ) -> IndexMap where F: Fn(&PhpMixed) -> bool, { - _array + array .iter() - .filter(|&(_, v)| _callback(v)) + .filter(|&(_, v)| callback(v)) .map(|(k, v)| (k.clone(), v.clone())) .collect() } -pub fn array_all(_array: &[T], _callback: F) -> bool +pub fn array_all(array: &[T], callback: F) -> bool where F: Fn(&T) -> bool, { - _array.iter().all(_callback) + array.iter().all(callback) } -pub fn array_any(_array: &[T], _callback: F) -> bool +pub fn array_any(array: &[T], callback: F) -> bool where F: Fn(&T) -> bool, { - _array.iter().any(_callback) + array.iter().any(callback) } -pub fn array_reduce(_array: &[T], _callback: F, _initial: U) -> U +pub fn array_reduce(array: &[T], callback: F, initial: U) -> U where F: Fn(U, &T) -> U, { - _array.iter().fold(_initial, _callback) + array.iter().fold(initial, callback) } -pub fn array_intersect(_array1: &[T], _array2: &[T]) -> Vec { - _array1 +pub fn array_intersect(array1: &[T], array2: &[T]) -> Vec { + array1 .iter() - .filter(|&x| _array2.contains(x)) + .filter(|&x| array2.contains(x)) .cloned() .collect() } @@ -365,16 +365,16 @@ pub fn array_flip(array: &PhpMixed) -> PhpMixed { PhpMixed::Array(result) } -pub fn array_flip_strings(_array: &[String]) -> IndexMap { - _array +pub fn array_flip_strings(array: &[String]) -> IndexMap { + array .iter() .enumerate() .map(|(i, s)| (s.clone(), PhpMixed::Int(i as i64))) .collect() } -pub fn array_key_exists(_key: &str, _array: &IndexMap) -> bool { - _array.contains_key(_key) +pub fn array_key_exists(key: &str, array: &IndexMap) -> bool { + array.contains_key(key) } pub fn array_is_list(array: &PhpMixed) -> bool { @@ -518,24 +518,24 @@ pub fn array_slice( .collect() } -pub fn array_map(_callback: F, _array: &[T]) -> Vec +pub fn array_map(callback: F, array: &[T]) -> Vec where F: Fn(&T) -> U, { - _array.iter().map(_callback).collect() + array.iter().map(callback).collect() } -pub fn array_chunk(_array: &[T], _size: i64, _preserve_keys: bool) -> Vec> { - _array.chunks(_size as usize).map(|c| c.to_vec()).collect() +pub fn array_chunk(array: &[T], size: i64, _preserve_keys: bool) -> Vec> { + array.chunks(size as usize).map(|c| c.to_vec()).collect() } pub fn array_diff_key( - _array1: IndexMap, - _array2: &IndexMap, + array1: IndexMap, + array2: &IndexMap, ) -> IndexMap { - _array1 + array1 .into_iter() - .filter(|(k, _)| !_array2.contains_key(k.as_str())) + .filter(|(k, _)| !array2.contains_key(k.as_str())) .collect() } @@ -663,8 +663,8 @@ where array.sort_by(|_, v1, _, v2| compare(v1, v2).cmp(&0)); } -pub fn sort(_array: &mut Vec) { - _array.sort(); +pub fn sort(array: &mut [T]) { + array.sort(); } pub const SORT_REGULAR: i64 = 0; @@ -673,12 +673,12 @@ pub const SORT_STRING: i64 = 2; pub const SORT_NATURAL: i64 = 6; pub const SORT_FLAG_CASE: i64 = 8; -pub fn usort(_array: &mut Vec, _compare: F) +pub fn usort(array: &mut [T], compare: F) where F: FnMut(&T, &T) -> i64, { - let mut compare = _compare; - _array.sort_by(|a, b| compare(a, b).cmp(&0)); + let mut compare = compare; + array.sort_by(|a, b| compare(a, b).cmp(&0)); } pub fn ksort(array: &mut IndexMap) { diff --git a/crates/shirabe-php-shim/src/fs.rs b/crates/shirabe-php-shim/src/fs.rs index c2b0dc41..a948a6f2 100644 --- a/crates/shirabe-php-shim/src/fs.rs +++ b/crates/shirabe-php-shim/src/fs.rs @@ -205,28 +205,25 @@ impl RecursiveIteratorFileInfo { } pub fn recursive_directory_iterator( - _path: impl AsRef, - _flags: i64, + path: impl AsRef, + flags: i64, ) -> Result { - let root = _path.as_ref().to_path_buf(); + let root = path.as_ref().to_path_buf(); if !root.is_dir() { return Err(UnexpectedValueException::new(format!( "RecursiveDirectoryIterator::__construct({}): Failed to open directory", root.display() ))); } - Ok(RecursiveDirectoryIterator { - root, - flags: _flags, - }) + Ok(RecursiveDirectoryIterator { root, flags }) } pub fn recursive_iterator_iterator( - _iter: RecursiveDirectoryIterator, - _mode: i64, + iter: RecursiveDirectoryIterator, + mode: i64, ) -> RecursiveIteratorIterator { let mut entries = Vec::new(); - rii_walk(&_iter.root, &_iter.root, _iter.flags, _mode, &mut entries); + rii_walk(&iter.root, &iter.root, iter.flags, mode, &mut entries); RecursiveIteratorIterator { entries, cursor: std::cell::Cell::new(0), @@ -712,9 +709,9 @@ pub fn fflush(stream: &PhpResource) -> bool { } } -pub fn lstat(_filename: impl AsRef) -> Option> { +pub fn lstat(filename: impl AsRef) -> Option> { use std::os::unix::fs::MetadataExt; - let m = std::fs::symlink_metadata(_filename).ok()?; + let m = std::fs::symlink_metadata(filename).ok()?; Some(stat_fields_map([ ("dev", m.dev() as i64), ("ino", m.ino() as i64), @@ -789,16 +786,16 @@ pub fn touch3(path: impl AsRef, mtime: i64, atime: i64) -> bool touch_impl(path.as_ref(), mtime, atime) } -pub fn chmod(_path: impl AsRef, _mode: u32) -> bool { +pub fn chmod(path: impl AsRef, mode: u32) -> bool { use std::os::unix::fs::PermissionsExt; - std::fs::set_permissions(_path.as_ref(), std::fs::Permissions::from_mode(_mode)).is_ok() + std::fs::set_permissions(path.as_ref(), std::fs::Permissions::from_mode(mode)).is_ok() } -pub fn fileperms(_path: impl AsRef) -> i64 { +pub fn fileperms(path: impl AsRef) -> i64 { use std::os::unix::fs::MetadataExt; // PHP returns the full st_mode (file type bits included). // TODO(phase-c): PHP returns false on error; this i64 signature reports 0 instead. - std::fs::metadata(_path.as_ref()) + std::fs::metadata(path.as_ref()) .map(|m| m.mode() as i64) .unwrap_or(0) } @@ -811,12 +808,12 @@ pub fn file_exists(path: impl AsRef) -> bool { path.as_ref().exists() } -pub fn is_writable(_path: impl AsRef) -> bool { - nix::unistd::access(_path.as_ref(), nix::unistd::AccessFlags::W_OK).is_ok() +pub fn is_writable(path: impl AsRef) -> bool { + nix::unistd::access(path.as_ref(), nix::unistd::AccessFlags::W_OK).is_ok() } -pub fn is_readable(_path: impl AsRef) -> bool { - let path = _path.as_ref(); +pub fn is_readable(path: impl AsRef) -> bool { + let path = path.as_ref(); match std::fs::metadata(path) { Ok(meta) => { if meta.is_dir() { @@ -829,8 +826,8 @@ pub fn is_readable(_path: impl AsRef) -> bool { } } -pub fn is_executable(_path: impl AsRef) -> bool { - nix::unistd::access(_path.as_ref(), nix::unistd::AccessFlags::X_OK).is_ok() +pub fn is_executable(path: impl AsRef) -> bool { + nix::unistd::access(path.as_ref(), nix::unistd::AccessFlags::X_OK).is_ok() } pub fn is_file(path: impl AsRef) -> bool { @@ -856,16 +853,16 @@ pub fn readlink(path: impl AsRef) -> Option { .map(|target| target.to_string_lossy().into_owned()) } -pub fn fileatime(_filename: impl AsRef) -> Option { - std::fs::metadata(_filename.as_ref()) +pub fn fileatime(filename: impl AsRef) -> Option { + std::fs::metadata(filename.as_ref()) .ok() .and_then(|m| m.accessed().ok()) .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()) .map(|d| d.as_secs() as i64) } -pub fn filemtime(_filename: impl AsRef) -> Option { - std::fs::metadata(_filename.as_ref()) +pub fn filemtime(filename: impl AsRef) -> Option { + std::fs::metadata(filename.as_ref()) .ok() .and_then(|m| m.modified().ok()) .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok()) @@ -876,21 +873,19 @@ pub fn unlink(path: impl AsRef) -> Result<(), std::io::Error> { std::fs::remove_file(path) } -pub fn unlink_silent(_path: impl AsRef) -> bool { +pub fn unlink_silent(path: impl AsRef) -> bool { // PHP's `@unlink`: delete the file, suppressing any warning. - std::fs::remove_file(_path.as_ref()).is_ok() + std::fs::remove_file(path.as_ref()).is_ok() } -pub fn file_put_contents(_path: &str, _data: &[u8]) -> Option { - std::fs::write(_path, _data) - .ok() - .map(|_| _data.len() as i64) +pub fn file_put_contents(path: &str, data: &[u8]) -> Option { + std::fs::write(path, data).ok().map(|_| data.len() as i64) } -pub fn file_put_contents3(_filename: &str, _data: &str, _flags: i64) -> Option { +pub fn file_put_contents3(filename: &str, data: &str, flags: i64) -> Option { // TODO(phase-c): the LOCK_EX and FILE_USE_INCLUDE_PATH flags are ignored; only FILE_APPEND is // honored. - let append = _flags & FILE_APPEND != 0; + let append = flags & FILE_APPEND != 0; let mut opts = std::fs::OpenOptions::new(); opts.write(true).create(true); if append { @@ -898,9 +893,9 @@ pub fn file_put_contents3(_filename: &str, _data: &str, _flags: i64) -> Option) -> Option { @@ -916,25 +911,25 @@ pub fn file_get_contents(path: impl AsRef) -> Option { } pub fn file_get_contents5( - _path: &str, + path: &str, _use_include_path: bool, _context: PhpMixed, - _offset: i64, - _length: Option, + offset: i64, + length: Option, ) -> Option { // TODO(phase-c): the stream $context and FILE_USE_INCLUDE_PATH are ignored; only $offset and // $length are applied (to the file read from the local filesystem). // PHP supports the file:// stream wrapper; strip it to read the local file. - let path = _path.strip_prefix("file://").unwrap_or(_path); + let path = path.strip_prefix("file://").unwrap_or(path); let bytes = std::fs::read(path).ok()?; let len = bytes.len() as i64; - let start = if _offset < 0 { - (len + _offset).max(0) + let start = if offset < 0 { + (len + offset).max(0) } else { - _offset.min(len) + offset.min(len) } as usize; let slice = &bytes[start..]; - let slice = match _length { + let slice = match length { Some(l) if l >= 0 => &slice[..(l as usize).min(slice.len())], _ => slice, }; @@ -947,21 +942,21 @@ pub fn getcwd() -> Option { .map(|p| p.to_string_lossy().into_owned()) } -pub fn chdir(_path: impl AsRef) -> anyhow::Result<()> { - Ok(std::env::set_current_dir(_path.as_ref())?) +pub fn chdir(path: impl AsRef) -> anyhow::Result<()> { + Ok(std::env::set_current_dir(path.as_ref())?) } -pub fn glob(_pattern: &str) -> Vec { - glob_with_flags(_pattern, 0) +pub fn glob(pattern: &str) -> Vec { + glob_with_flags(pattern, 0) } pub const FILE_SKIP_EMPTY_LINES: i64 = 4; -pub fn file(_filename: &str, _flags: i64) -> Option> { - let content = std::fs::read(_filename).ok()?; +pub fn file(filename: &str, flags: i64) -> Option> { + let content = std::fs::read(filename).ok()?; let s = String::from_utf8_lossy(&content); - let ignore_newlines = _flags & FILE_IGNORE_NEW_LINES != 0; - let skip_empty = _flags & FILE_SKIP_EMPTY_LINES != 0; + let ignore_newlines = flags & FILE_IGNORE_NEW_LINES != 0; + let skip_empty = flags & FILE_SKIP_EMPTY_LINES != 0; let mut lines = Vec::new(); // PHP keeps the trailing newline on each element unless FILE_IGNORE_NEW_LINES is set. for line in s.split_inclusive('\n') { @@ -1025,8 +1020,8 @@ pub fn rename( std::fs::rename(old_name, new_name).is_ok() } -pub fn copy(_source: impl AsRef, _dest: impl AsRef) -> bool { - std::fs::copy(_source.as_ref(), _dest.as_ref()).is_ok() +pub fn copy(source: impl AsRef, dest: impl AsRef) -> bool { + std::fs::copy(source.as_ref(), dest.as_ref()).is_ok() } pub fn ftruncate(stream: &PhpResource, size: i64) -> bool { @@ -1167,15 +1162,15 @@ pub const GLOB_MARK: i64 = 8; pub const GLOB_ONLYDIR: i64 = 1024; pub const GLOB_BRACE: i64 = 4096; -pub fn glob_with_flags(_pattern: &str, _flags: i64) -> Vec { - let patterns = if _flags & GLOB_BRACE != 0 { - glob_expand_braces(_pattern) +pub fn glob_with_flags(pattern: &str, flags: i64) -> Vec { + let patterns = if flags & GLOB_BRACE != 0 { + glob_expand_braces(pattern) } else { - vec![_pattern.to_string()] + vec![pattern.to_string()] }; let mut results: Vec = Vec::new(); for pattern in patterns { - glob_collect(&pattern, _flags, &mut results); + glob_collect(&pattern, flags, &mut results); } // PHP sorts the result set by default (GLOB_NOSORT is not modeled here). results.sort(); diff --git a/crates/shirabe-php-shim/src/runtime.rs b/crates/shirabe-php-shim/src/runtime.rs index 6b165567..86cbfd74 100644 --- a/crates/shirabe-php-shim/src/runtime.rs +++ b/crates/shirabe-php-shim/src/runtime.rs @@ -334,8 +334,8 @@ pub fn trigger_deprecation(_package: &str, _version: &str, _message: &str, _arg: todo!() } -pub fn usleep(_microseconds: u64) { - std::thread::sleep(std::time::Duration::from_micros(_microseconds)); +pub fn usleep(microseconds: u64) { + std::thread::sleep(std::time::Duration::from_micros(microseconds)); } /// Equivalent to PHP's __DIR__ magic constant diff --git a/crates/shirabe-php-shim/src/string.rs b/crates/shirabe-php-shim/src/string.rs index a322e36f..8cab6eca 100644 --- a/crates/shirabe-php-shim/src/string.rs +++ b/crates/shirabe-php-shim/src/string.rs @@ -14,16 +14,16 @@ pub fn str_replace(search: &str, replace: &str, subject: &str) -> String { subject.replace(search, replace) } -pub fn str_contains(_haystack: &str, _needle: &str) -> bool { - _haystack.contains(_needle) +pub fn str_contains(haystack: &str, needle: &str) -> bool { + haystack.contains(needle) } -pub fn str_starts_with(_haystack: &str, _needle: &str) -> bool { - _haystack.starts_with(_needle) +pub fn str_starts_with(haystack: &str, needle: &str) -> bool { + haystack.starts_with(needle) } -pub fn str_ends_with(_haystack: &str, _needle: &str) -> bool { - _haystack.ends_with(_needle) +pub fn str_ends_with(haystack: &str, needle: &str) -> bool { + haystack.ends_with(needle) } pub fn substr_count(haystack: &str, needle: &str) -> i64 { @@ -48,8 +48,8 @@ pub fn substr_replace(string: &str, replace: &str, start: usize, length: usize) String::from_utf8_lossy(&out).into_owned() } -pub fn str_repeat(_s: &str, _count: usize) -> String { - _s.repeat(_count) +pub fn str_repeat(s: &str, count: usize) -> String { + s.repeat(count) } pub fn str_replace_array(search: &[String], replace: &[String], subject: &str) -> String { @@ -63,29 +63,29 @@ pub fn str_replace_array(search: &[String], replace: &[String], subject: &str) - result } -pub fn str_pad(_input: &str, _length: usize, _pad_string: &str, _pad_type: i64) -> String { +pub fn str_pad(input: &str, length: usize, pad_string: &str, pad_type: i64) -> String { // PHP str_pad() works on bytes: it pads up to `length` bytes by repeating `pad_string`. - let input_len = _input.len(); - if _length <= input_len || _pad_string.is_empty() { - return _input.to_string(); + let input_len = input.len(); + if length <= input_len || pad_string.is_empty() { + return input.to_string(); } - let pad = _pad_string.as_bytes(); + let pad = pad_string.as_bytes(); let make = |n: usize| -> Vec { (0..n).map(|i| pad[i % pad.len()]).collect() }; - let total = _length - input_len; - let mut out: Vec = Vec::with_capacity(_length); - match _pad_type { + let total = length - input_len; + let mut out: Vec = Vec::with_capacity(length); + match pad_type { STR_PAD_LEFT => { out.extend(make(total)); - out.extend_from_slice(_input.as_bytes()); + out.extend_from_slice(input.as_bytes()); } STR_PAD_BOTH => { let left = total / 2; out.extend(make(left)); - out.extend_from_slice(_input.as_bytes()); + out.extend_from_slice(input.as_bytes()); out.extend(make(total - left)); } _ => { - out.extend_from_slice(_input.as_bytes()); + out.extend_from_slice(input.as_bytes()); out.extend(make(total)); } } @@ -96,10 +96,10 @@ pub const STR_PAD_LEFT: i64 = 0; pub const STR_PAD_RIGHT: i64 = 1; pub const STR_PAD_BOTH: i64 = 2; -pub fn str_split(_s: &str, _length: i64) -> Vec { +pub fn str_split(s: &str, length: i64) -> Vec { // PHP str_split() chunks the string by bytes into pieces of `length` bytes. - let length = _length.max(1) as usize; - let bytes = _s.as_bytes(); + let length = length.max(1) as usize; + let bytes = s.as_bytes(); if bytes.is_empty() { return vec![String::new()]; } @@ -109,10 +109,10 @@ pub fn str_split(_s: &str, _length: i64) -> Vec { .collect() } -pub fn str_bitand(_a: &str, _b: &str) -> String { +pub fn str_bitand(a: &str, b: &str) -> String { // PHP's string `&` operator: byte-wise AND, the result truncated to the shorter operand. - let a = _a.as_bytes(); - let b = _b.as_bytes(); + let a = a.as_bytes(); + let b = b.as_bytes(); let n = a.len().min(b.len()); let out: Vec = (0..n).map(|i| a[i] & b[i]).collect(); String::from_utf8_lossy(&out).into_owned() @@ -132,20 +132,20 @@ pub fn str_replace_arr(search: &[&str], replace: &str, subject: &str) -> String result } -pub fn strcasecmp(_s1: &str, _s2: &str) -> i64 { - _s1.to_ascii_lowercase().cmp(&_s2.to_ascii_lowercase()) as i64 +pub fn strcasecmp(s1: &str, s2: &str) -> i64 { + s1.to_ascii_lowercase().cmp(&s2.to_ascii_lowercase()) as i64 } -pub fn strpos(_haystack: &str, _needle: &str) -> Option { - _haystack.find(_needle) +pub fn strpos(haystack: &str, needle: &str) -> Option { + haystack.find(needle) } -pub fn strtoupper(_s: &str) -> String { - _s.to_ascii_uppercase() +pub fn strtoupper(s: &str) -> String { + s.to_ascii_uppercase() } -pub fn strlen(_s: &str) -> i64 { - _s.len() as i64 +pub fn strlen(s: &str) -> i64 { + s.len() as i64 } pub fn strtr(str: &str, from: &str, to: &str) -> String { @@ -175,8 +175,8 @@ pub fn strnatcasecmp(s1: &str, s2: &str) -> i64 { strnatcmp_ex(s1.as_bytes(), s2.as_bytes(), true) } -pub fn strrpos(_haystack: &str, _needle: &str) -> Option { - _haystack.rfind(_needle) +pub fn strrpos(haystack: &str, needle: &str) -> Option { + haystack.rfind(needle) } // Byte-based, matching PHP: strrev() reverses the bytes, not the characters. @@ -186,14 +186,14 @@ pub fn strrev(s: &str) -> String { String::from_utf8_lossy(&bytes).into_owned() } -pub fn strtolower(_s: &str) -> String { - _s.to_ascii_lowercase() +pub fn strtolower(s: &str) -> String { + s.to_ascii_lowercase() } -pub fn stripos(_haystack: &str, _needle: &str) -> Option { - _haystack +pub fn stripos(haystack: &str, needle: &str) -> Option { + haystack .to_ascii_lowercase() - .find(_needle.to_ascii_lowercase().as_str()) + .find(needle.to_ascii_lowercase().as_str()) } // Byte-based, matching PHP's array form of strtr: at each position the longest @@ -225,8 +225,8 @@ pub fn strtr_array(s: &str, pairs: &IndexMap) -> String { String::from_utf8_lossy(&result).into_owned() } -pub fn strcmp(_s1: &str, _s2: &str) -> i64 { - _s1.cmp(_s2) as i64 +pub fn strcmp(s1: &str, s2: &str) -> i64 { + s1.cmp(s2) as i64 } pub fn strnatcmp(s1: &str, s2: &str) -> i64 { @@ -311,8 +311,8 @@ pub fn substr(s: &str, start: i64, length: Option) -> String { String::from_utf8_lossy(&bytes[start as usize..end as usize]).into_owned() } -pub fn implode(_glue: &str, _pieces: &[String]) -> String { - _pieces.join(_glue) +pub fn implode(glue: &str, pieces: &[String]) -> String { + pieces.join(glue) } pub fn explode(delimiter: &str, string: &str) -> Vec { @@ -356,13 +356,13 @@ fn canonical_encoding(name: &str) -> String { } } -pub fn mb_convert_encoding(_string: Vec, _to_encoding: &str, _from_encoding: &str) -> String { - let to = canonical_encoding(_to_encoding); - let from = canonical_encoding(_from_encoding); +pub fn mb_convert_encoding(string: Vec, to_encoding: &str, from_encoding: &str) -> String { + let to = canonical_encoding(to_encoding); + let from = canonical_encoding(from_encoding); // ASCII is a subset of UTF-8, so converting among ASCII/UTF-8 is a byte-level no-op. Other // encodings need conversion tables that have not been ported yet. if matches!(to.as_str(), "UTF-8" | "ASCII") && matches!(from.as_str(), "UTF-8" | "ASCII") { - return String::from_utf8_lossy(&_string).into_owned(); + return String::from_utf8_lossy(&string).into_owned(); } todo!("mb_convert_encoding {} -> {}", from, to) } @@ -372,27 +372,27 @@ pub fn mb_strlen(s: &str, _encoding: &str) -> i64 { s.chars().count() as i64 } -pub fn mb_check_encoding(_value: &str, _encoding: &str) -> bool { - match _encoding.to_ascii_uppercase().replace('-', "").as_str() { +pub fn mb_check_encoding(value: &str, encoding: &str) -> bool { + match encoding.to_ascii_uppercase().replace('-', "").as_str() { // A Rust &str is, by construction, valid UTF-8. "UTF8" => true, - "ASCII" | "USASCII" => _value.is_ascii(), + "ASCII" | "USASCII" => value.is_ascii(), // Other encodings need the mbstring validation tables, which have not been ported. _ => todo!(), } } pub fn mb_detect_encoding( - _s: &str, - _encodings: Option>, + s: &str, + encodings: Option>, _strict: bool, ) -> Option { - // PHP's default detection order is ASCII then UTF-8. `_s` is already valid UTF-8, so detection + // PHP's default detection order is ASCII then UTF-8. `s` is already valid UTF-8, so detection // reduces to: pure-ASCII content matches "ASCII", anything else matches "UTF-8". - let order = _encodings.unwrap_or_else(|| vec!["ASCII".to_string(), "UTF-8".to_string()]); + let order = encodings.unwrap_or_else(|| vec!["ASCII".to_string(), "UTF-8".to_string()]); for enc in order { match canonical_encoding(&enc).as_str() { - "ASCII" if _s.is_ascii() => return Some(enc), + "ASCII" if s.is_ascii() => return Some(enc), "UTF-8" => return Some(enc), _ => {} } @@ -421,13 +421,13 @@ pub fn mb_str_split(s: &str, length: i64) -> Vec { .collect() } -pub fn mb_convert_variables(_to: &str, _from: &str, _vars: &mut Vec) -> Option { - // Converts each variable in place from `_from` to `_to`, returning the source encoding (PHP - // returns the detected source encoding; here `_from` is a single named encoding). - for v in _vars.iter_mut() { - *v = mb_convert_encoding(std::mem::take(v).into_bytes(), _to, _from); +pub fn mb_convert_variables(to: &str, from: &str, vars: &mut [String]) -> Option { + // Converts each variable in place from `from` to `to`, returning the source encoding (PHP + // returns the detected source encoding; here `from` is a single named encoding). + for v in vars.iter_mut() { + *v = mb_convert_encoding(std::mem::take(v).into_bytes(), to, from); } - Some(_from.to_string()) + Some(from.to_string()) } /// Resolve PHP array_slice/substr-style (offset, length) into a `[start, end)` @@ -492,9 +492,9 @@ pub fn urlencode(s: &str) -> String { out } -pub fn base64_encode(_data: impl AsRef<[u8]>) -> String { +pub fn base64_encode(data: impl AsRef<[u8]>) -> String { const TABLE: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - let bytes = _data.as_ref(); + let bytes = data.as_ref(); let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4); for chunk in bytes.chunks(3) { let b1 = chunk.get(1).copied(); @@ -516,11 +516,11 @@ pub fn base64_encode(_data: impl AsRef<[u8]>) -> String { out } -pub fn base64_decode(_data: &str) -> Option> { +pub fn base64_decode(data: &str) -> Option> { // Non-strict mode (PHP's default $strict = false): characters outside the base64 alphabet are // silently skipped, and padding terminates the input. - let mut sextets: Vec = Vec::with_capacity(_data.len()); - for &b in _data.as_bytes() { + let mut sextets: Vec = Vec::with_capacity(data.len()); + for &b in data.as_bytes() { let v = match b { b'A'..=b'Z' => b - b'A', b'a'..=b'z' => b - b'a' + 26, @@ -552,16 +552,16 @@ pub fn base64_decode(_data: &str) -> Option> { Some(out) } -pub fn ctype_alnum(_s: &str) -> bool { - !_s.is_empty() && _s.bytes().all(|b| b.is_ascii_alphanumeric()) +pub fn ctype_alnum(s: &str) -> bool { + !s.is_empty() && s.bytes().all(|b| b.is_ascii_alphanumeric()) } pub fn ctype_digit(s: &str) -> bool { !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()) } -pub fn ord(_c: &str) -> i64 { - _c.as_bytes().first().copied().unwrap_or(0) as i64 +pub fn ord(c: &str) -> i64 { + c.as_bytes().first().copied().unwrap_or(0) as i64 } pub fn ucwords(s: &str) -> String { @@ -589,8 +589,8 @@ fn hex_digit_value(b: u8) -> Option { } } -pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { - let fb = _format.as_bytes(); +pub fn sprintf(format: &str, args: &[PhpMixed]) -> String { + let fb = format.as_bytes(); let mut out = String::new(); let mut i = 0; let mut next_arg = 0usize; @@ -601,7 +601,7 @@ pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { while i < fb.len() && fb[i] != b'%' { i += 1; } - out.push_str(&_format[start..i]); + out.push_str(&format[start..i]); continue; } i += 1; @@ -623,7 +623,7 @@ pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { k += 1; } if k > i && k < fb.len() && fb[k] == b'$' { - explicit_arg = _format[i..k].parse::().ok(); + explicit_arg = format[i..k].parse::().ok(); i = k + 1; } } @@ -661,7 +661,7 @@ pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { i += 1; } if i > start { - width = _format[start..i].parse().unwrap_or(0); + width = format[start..i].parse().unwrap_or(0); } } @@ -673,7 +673,7 @@ pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { while i < fb.len() && fb[i].is_ascii_digit() { i += 1; } - precision = Some(_format[start..i].parse().unwrap_or(0)); + precision = Some(format[start..i].parse().unwrap_or(0)); } if i >= fb.len() { @@ -683,9 +683,9 @@ pub fn sprintf(_format: &str, _args: &[PhpMixed]) -> String { i += 1; let arg = match explicit_arg { - Some(n) => _args.get(n.wrapping_sub(1)), + Some(n) => args.get(n.wrapping_sub(1)), None => { - let a = _args.get(next_arg); + let a = args.get(next_arg); next_arg += 1; a } @@ -841,8 +841,8 @@ fn php_to_float(v: &PhpMixed) -> f64 { } } -pub fn bin2hex(_data: &[u8]) -> String { - _data.iter().map(|b| format!("{:02x}", b)).collect() +pub fn bin2hex(data: &[u8]) -> String { + data.iter().map(|b| format!("{:02x}", b)).collect() } pub fn ucfirst(s: &str) -> String { @@ -989,11 +989,11 @@ pub fn php_strip_whitespace(path: impl AsRef) -> Result i64 { +pub fn hexdec(s: &str) -> i64 { // PHP hexdec() ignores characters outside [0-9A-Fa-f]. // TODO(phase-c): PHP promotes the result to float on overflow; this i64 return wraps instead. let mut acc: u64 = 0; - for &b in _s.as_bytes() { + for &b in s.as_bytes() { let d = match b { b'0'..=b'9' => b - b'0', b'a'..=b'f' => b - b'a' + 10, @@ -1009,17 +1009,17 @@ pub fn byte_at(s: &str, i: usize) -> u8 { s.as_bytes().get(i).copied().unwrap_or(0) } -pub fn wordwrap(_s: &str, _width: i64, _break_str: &str, _cut: bool) -> String { +pub fn wordwrap(s: &str, width: i64, break_str: &str, cut: bool) -> String { // PHP throws a ValueError for either argument combination before reaching the wrapping loop. assert!( - !_break_str.is_empty(), + !break_str.is_empty(), "wordwrap(): Argument #3 ($break) must not be empty" ); assert!( - !(_width == 0 && _cut), + !(width == 0 && cut), "wordwrap(): Argument #4 ($cut) cannot be true when argument #2 ($width) is 0" ); - php_wordwrap(_s, _width, _break_str, _cut) + php_wordwrap(s, width, break_str, cut) } pub fn levenshtein(string1: &str, string2: &str) -> i64 { @@ -1041,14 +1041,14 @@ pub fn levenshtein(string1: &str, string2: &str) -> i64 { } pub fn number_format( - _number: f64, - _decimals: i64, - _decimal_separator: &str, - _thousands_separator: &str, + number: f64, + decimals: i64, + decimal_separator: &str, + thousands_separator: &str, ) -> String { - let decimals = _decimals.max(0) as usize; - let negative = _number < 0.0; - let magnitude = _number.abs(); + let decimals = decimals.max(0) as usize; + let negative = number < 0.0; + let magnitude = number.abs(); // PHP rounds half away from zero; Rust's f64::round() does the same, so round the scaled value // to a whole number before formatting to avoid the round-half-to-even of `{:.*}`. let factor = 10f64.powi(decimals as i32); @@ -1066,12 +1066,12 @@ pub fn number_format( let len = int_bytes.len(); for (idx, &b) in int_bytes.iter().enumerate() { if idx > 0 && (len - idx) % 3 == 0 { - result.push_str(_thousands_separator); + result.push_str(thousands_separator); } result.push(b as char); } if decimals > 0 { - result.push_str(_decimal_separator); + result.push_str(decimal_separator); result.push_str(frac_part); } // PHP drops the sign when the rounded value is zero. @@ -1081,19 +1081,14 @@ pub fn number_format( result } -pub fn uniqid(_prefix: &str, _more_entropy: bool) -> String { +pub fn uniqid(prefix: &str, more_entropy: bool) -> String { // PHP builds the id from the current time: 8 hex digits of seconds followed by 5 hex digits of // microseconds. With $more_entropy a '.' and a random fraction (PHP's "%08.8F") are appended. let now = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default(); - let base = format!( - "{}{:08x}{:05x}", - _prefix, - now.as_secs(), - now.subsec_micros() - ); - if _more_entropy { + let base = format!("{}{:08x}{:05x}", prefix, now.as_secs(), now.subsec_micros()); + if more_entropy { // TODO(phase-c): PHP uses its combined LCG; this uses `fastrand`, so the random suffix is // not reproducible against PHP (it is non-deterministic in PHP too). format!("{}.{:.8}", base, fastrand::f64() * 10.0) diff --git a/crates/shirabe-php-shim/src/var.rs b/crates/shirabe-php-shim/src/var.rs index af3c1b3b..bf8fa0ce 100644 --- a/crates/shirabe-php-shim/src/var.rs +++ b/crates/shirabe-php-shim/src/var.rs @@ -93,21 +93,21 @@ pub fn canonical_int_key(key: &str) -> Option { key.parse::().ok() } -pub fn is_bool(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::Bool(_)) +pub fn is_bool(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::Bool(_)) } -pub fn is_string(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::String(_)) +pub fn is_string(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::String(_)) } -pub fn is_int(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::Int(_)) +pub fn is_int(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::Int(_)) } -pub fn is_scalar(_value: &PhpMixed) -> bool { +pub fn is_scalar(value: &PhpMixed) -> bool { matches!( - _value, + value, PhpMixed::Bool(_) | PhpMixed::Int(_) | PhpMixed::Float(_) | PhpMixed::String(_) ) } @@ -131,8 +131,8 @@ pub fn is_callable(value: &PhpMixed) -> bool { } } -pub fn is_object(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::Object(_)) +pub fn is_object(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::Object(_)) } pub fn is_a(_object_or_class: &PhpMixed, _class: &str, _allow_string: bool) -> bool { @@ -141,12 +141,12 @@ pub fn is_a(_object_or_class: &PhpMixed, _class: &str, _allow_string: bool) -> b todo!() } -pub fn is_array(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::List(_) | PhpMixed::Array(_)) +pub fn is_array(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::List(_) | PhpMixed::Array(_)) } -pub fn is_null(_value: &PhpMixed) -> bool { - matches!(_value, PhpMixed::Null) +pub fn is_null(value: &PhpMixed) -> bool { + matches!(value, PhpMixed::Null) } pub fn is_iterable(value: &PhpMixed) -> bool { @@ -255,9 +255,9 @@ pub fn strval(value: &PhpMixed) -> String { php_to_string(value) } -pub fn intval(_value: &PhpMixed) -> i64 { +pub fn intval(value: &PhpMixed) -> i64 { // Single-argument PHP intval(), i.e. base 10. - match _value { + match value { PhpMixed::Null => 0, PhpMixed::Bool(b) => *b as i64, PhpMixed::Int(i) => *i, -- cgit v1.3.1-4-g156e