pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 18:11:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove sp-serializer which is not useful (#14134)

Browse Source 
* remove `sp-serializer` which is not useful

* Update primitives/core/Cargo.toml

* fix cargo.toml

* ".git/.scripts/commands/fmt/fmt.sh"

---------

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: command-bot <>
This commit is contained in:
yjh
2023-05-14 22:32:27 +08:00
committed by GitHub
parent 44f5d8afe4
commit 8136ab981e
8 changed files with 26 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/Cargo.lock
Generated
-9
View File
@@ -10900,7 +10900,6 @@ dependencies = [
"sp-debug-derive",
"sp-externalities",
"sp-runtime-interface",
"sp-serializer",
"sp-std",
"sp-storage",
"ss58-registry",
@@ -11218,14 +11217,6 @@ dependencies = [
"substrate-wasm-builder",
]
[[package]]
name = "sp-serializer"
version = "4.0.0-dev"
dependencies = [
"serde",
"serde_json",
]
[[package]]
name = "sp-session"
version = "4.0.0-dev"
substrate/Cargo.toml
-1
View File
@@ -219,7 +219,6 @@ members = [
"primitives/runtime-interface/test",
"primitives/runtime-interface/test-wasm",
"primitives/runtime-interface/test-wasm-deprecated",
"primitives/serializer",
"primitives/session",
"primitives/staking",
"primitives/state-machine",
substrate/primitives/core/Cargo.toml
-1
View File
@@ -56,7 +56,6 @@ sp-runtime-interface = { version = "7.0.0", default-features = false, path = "..
w3f-bls = { version = "0.1.3", default-features = false, optional = true}
[dev-dependencies]
sp-serializer = { version = "4.0.0-dev", path = "../serializer" }
rand = "0.8.5"
criterion = "0.4.0"
serde_json = "1.0"
substrate/primitives/core/src/hash.rs
+16 -11
View File
@@ -32,7 +32,6 @@ pub fn convert_hash<H1: Default + AsMut<[u8]>, H2: AsRef<[u8]>>(src: &H2) -> H1
#[cfg(test)]
mod tests {
use super::*;
use sp_serializer as ser;
#[test]
fn test_h160() {
@@ -47,8 +46,11 @@ mod tests {
];
for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
assert_eq!(
format!("{:?}", expected),
serde_json::to_string_pretty(&number).expect("Json pretty print failed")
);
assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
}
}
@@ -86,30 +88,33 @@ mod tests {
];
for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
assert_eq!(
format!("{:?}", expected),
serde_json::to_string_pretty(&number).expect("Json pretty print failed")
);
assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
}
}
#[test]
fn test_invalid() {
assert!(ser::from_str::<H256>(
assert!(serde_json::from_str::<H256>(
"\"0x000000000000000000000000000000000000000000000000000000000000000\""
)
.unwrap_err()
.is_data());
assert!(ser::from_str::<H256>(
assert!(serde_json::from_str::<H256>(
"\"0x000000000000000000000000000000000000000000000000000000000000000g\""
)
.unwrap_err()
.is_data());
assert!(ser::from_str::<H256>(
assert!(serde_json::from_str::<H256>(
"\"0x00000000000000000000000000000000000000000000000000000000000000000\""
)
.unwrap_err()
.is_data());
assert!(ser::from_str::<H256>("\"\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"0\"").unwrap_err().is_data());
assert!(ser::from_str::<H256>("\"10\"").unwrap_err().is_data());
assert!(serde_json::from_str::<H256>("\"\"").unwrap_err().is_data());
assert!(serde_json::from_str::<H256>("\"0\"").unwrap_err().is_data());
assert!(serde_json::from_str::<H256>("\"10\"").unwrap_err().is_data());
}
}
substrate/primitives/core/src/uint.rs
+10 -8
View File
@@ -23,7 +23,6 @@ pub use primitive_types::{U256, U512};
mod tests {
use super::*;
use codec::{Decode, Encode};
use sp_serializer as ser;
macro_rules! test {
($name: ident, $test_name: ident) => {
@@ -43,14 +42,17 @@ mod tests {
];
for (number, expected) in tests {
assert_eq!(format!("{:?}", expected), ser::to_string_pretty(&number));
assert_eq!(number, ser::from_str(&format!("{:?}", expected)).unwrap());
assert_eq!(
format!("{:?}", expected),
serde_json::to_string_pretty(&number).expect("Json pretty print failed")
);
assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
}
// Invalid examples
assert!(ser::from_str::<$name>("\"0x\"").unwrap_err().is_data());
assert!(ser::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
assert!(ser::from_str::<$name>("\"\"").unwrap_err().is_data());
assert!(serde_json::from_str::<$name>("\"0x\"").unwrap_err().is_data());
assert!(serde_json::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
assert!(serde_json::from_str::<$name>("\"\"").unwrap_err().is_data());
}
};
}
@@ -78,10 +80,10 @@ mod tests {
#[test]
fn test_large_values() {
assert_eq!(
ser::to_string_pretty(&!U256::zero()),
serde_json::to_string_pretty(&!U256::zero()).expect("Json pretty print failed"),
"\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
);
assert!(ser::from_str::<U256>(
assert!(serde_json::from_str::<U256>(
"\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
)
.unwrap_err()
substrate/primitives/serializer/Cargo.toml
-18
View File
@@ -1,18 +0,0 @@
[package]
name = "sp-serializer"
version = "4.0.0-dev"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2021"
license = "Apache-2.0"
homepage = "https://substrate.io"
repository = "https://github.com/paritytech/substrate/"
description = "Substrate customizable serde serializer."
documentation = "https://docs.rs/sp-serializer"
readme = "README.md"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
[dependencies]
serde = "1.0.136"
serde_json = "1.0.85"
substrate/primitives/serializer/README.md
-6
View File
@@ -1,6 +0,0 @@
Substrate customizable serde serializer.
The idea is that we can later change the implementation
to something more compact, but for now we're using JSON.
License: Apache-2.0
substrate/primitives/serializer/src/lib.rs
-45
View File
@@ -1,45 +0,0 @@
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Substrate customizable serde serializer.
//!
//! The idea is that we can later change the implementation
//! to something more compact, but for now we're using JSON.
#![warn(missing_docs)]
pub use serde_json::{from_reader, from_slice, from_str, Error, Result};
const PROOF: &str = "Serializers are infallible; qed";
/// Serialize the given data structure as a pretty-printed String of JSON.
pub fn to_string_pretty<T: serde::Serialize + ?Sized>(value: &T) -> String {
serde_json::to_string_pretty(value).expect(PROOF)
}
/// Serialize the given data structure as a JSON byte vector.
pub fn encode<T: serde::Serialize + ?Sized>(value: &T) -> Vec<u8> {
serde_json::to_vec(value).expect(PROOF)
}
/// Serialize the given data structure as JSON into the IO stream.
pub fn to_writer<W: ::std::io::Write, T: serde::Serialize + ?Sized>(
writer: W,
value: &T,
) -> Result<()> {
serde_json::to_writer(writer, value)
}