From 06f217d5260fb91592b413d1117c062249a3224f Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Fri, 6 Aug 2021 14:46:30 +0800 Subject: [PATCH] Move deprecated functions into separate file. --- src/deprecated.rs | 143 ++++++++++++++++++++++++++++++++++++++++++++++ src/dynamic.rs | 27 --------- src/engine_api.rs | 98 ------------------------------- src/lib.rs | 1 + 4 files changed, 144 insertions(+), 125 deletions(-) create mode 100644 src/deprecated.rs diff --git a/src/deprecated.rs b/src/deprecated.rs new file mode 100644 index 00000000..407f9630 --- /dev/null +++ b/src/deprecated.rs @@ -0,0 +1,143 @@ +//! Module containing all deprecated API that will be removed in the next major version. + +use crate::{Dynamic, Engine, EvalAltResult, ImmutableString, Scope, AST}; + +#[cfg(feature = "no_std")] +use std::prelude::v1::*; + +impl Engine { + /// Evaluate a file, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// Not available under `no_std` or `WASM`. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run_file`][Engine::run_file] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run_file` instead")] + #[cfg(not(feature = "no_std"))] + #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))] + #[inline(always)] + pub fn consume_file(&self, path: std::path::PathBuf) -> Result<(), Box> { + self.run_file(path) + } + + /// Evaluate a file with own scope, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// Not available under `no_std` or `WASM`. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run_file_with_scope`][Engine::run_file_with_scope] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run_file_with_scope` instead")] + #[cfg(not(feature = "no_std"))] + #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))] + #[inline(always)] + pub fn consume_file_with_scope( + &self, + scope: &mut Scope, + path: std::path::PathBuf, + ) -> Result<(), Box> { + self.run_file_with_scope(scope, path) + } + + /// Evaluate a string, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run`][Engine::run] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run` instead")] + #[inline(always)] + pub fn consume(&self, script: &str) -> Result<(), Box> { + self.run(script) + } + + /// Evaluate a string with own scope, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run_with_scope`][Engine::run_with_scope] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run_with_scope` instead")] + #[inline(always)] + pub fn consume_with_scope( + &self, + scope: &mut Scope, + script: &str, + ) -> Result<(), Box> { + self.run_with_scope(scope, script) + } + + /// Evaluate an AST, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run_ast`][Engine::run_ast] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run_ast` instead")] + #[inline(always)] + pub fn consume_ast(&self, ast: &AST) -> Result<(), Box> { + self.run_ast(ast) + } + + /// Evaluate an [`AST`] with own scope, but throw away the result and only return error (if any). + /// Useful for when you don't need the result, but still need to keep track of possible errors. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`run_ast_with_scope`][Engine::run_ast_with_scope] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `run_ast_with_scope` instead")] + #[inline(always)] + pub fn consume_ast_with_scope( + &self, + scope: &mut Scope, + ast: &AST, + ) -> Result<(), Box> { + self.run_ast_with_scope(scope, ast) + } +} + +impl Dynamic { + /// Convert the [`Dynamic`] into a [`String`] and return it. + /// If there are other references to the same string, a cloned copy is returned. + /// Returns the name of the actual type if the cast fails. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`into_string`][Dynamic::into_string] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `into_string` instead")] + #[inline(always)] + pub fn as_string(self) -> Result { + self.into_string() + } + + /// Convert the [`Dynamic`] into an [`ImmutableString`] and return it. + /// Returns the name of the actual type if the cast fails. + /// + /// # Deprecated + /// + /// This method is deprecated. Use [`into_immutable_string`][Dynamic::into_immutable_string] instead. + /// + /// This method will be removed in the next major version. + #[deprecated(since = "1.1.0", note = "use `into_immutable_string` instead")] + #[inline(always)] + pub fn as_immutable_string(self) -> Result { + self.into_immutable_string() + } +} diff --git a/src/dynamic.rs b/src/dynamic.rs index 15862f6a..86eb0487 100644 --- a/src/dynamic.rs +++ b/src/dynamic.rs @@ -1900,20 +1900,6 @@ impl Dynamic { /// Convert the [`Dynamic`] into a [`String`] and return it. /// If there are other references to the same string, a cloned copy is returned. /// Returns the name of the actual type if the cast fails. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`into_string`][Dynamic::into_string] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `into_string` instead")] - #[inline(always)] - pub fn as_string(self) -> Result { - self.into_string() - } - /// Convert the [`Dynamic`] into a [`String`] and return it. - /// If there are other references to the same string, a cloned copy is returned. - /// Returns the name of the actual type if the cast fails. #[inline(always)] pub fn into_string(self) -> Result { self.into_immutable_string() @@ -1921,19 +1907,6 @@ impl Dynamic { } /// Convert the [`Dynamic`] into an [`ImmutableString`] and return it. /// Returns the name of the actual type if the cast fails. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`into_immutable_string`][Dynamic::into_immutable_string] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `into_immutable_string` instead")] - #[inline(always)] - pub fn as_immutable_string(self) -> Result { - self.into_immutable_string() - } - /// Convert the [`Dynamic`] into an [`ImmutableString`] and return it. - /// Returns the name of the actual type if the cast fails. #[inline] pub fn into_immutable_string(self) -> Result { match self.0 { diff --git a/src/engine_api.rs b/src/engine_api.rs index 00e531a8..fd487c82 100644 --- a/src/engine_api.rs +++ b/src/engine_api.rs @@ -1741,23 +1741,6 @@ impl Engine { let lib = &[ast.lib()]; self.eval_global_statements(scope, mods, &mut state, statements, lib, level) } - /// Evaluate a file, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// Not available under `no_std` or `WASM`. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run_file`][Engine::run_file] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run_file` instead")] - #[cfg(not(feature = "no_std"))] - #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))] - #[inline(always)] - pub fn consume_file(&self, path: std::path::PathBuf) -> Result<(), Box> { - self.run_file(path) - } /// Evaluate a file, returning any error (if any). /// /// Not available under `no_std` or `WASM`. @@ -1767,27 +1750,6 @@ impl Engine { pub fn run_file(&self, path: std::path::PathBuf) -> Result<(), Box> { Self::read_file(path).and_then(|contents| self.run(&contents)) } - /// Evaluate a file with own scope, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// Not available under `no_std` or `WASM`. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run_file_with_scope`][Engine::run_file_with_scope] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run_file_with_scope` instead")] - #[cfg(not(feature = "no_std"))] - #[cfg(not(any(target_arch = "wasm32", target_arch = "wasm64")))] - #[inline(always)] - pub fn consume_file_with_scope( - &self, - scope: &mut Scope, - path: std::path::PathBuf, - ) -> Result<(), Box> { - self.run_file_with_scope(scope, path) - } /// Evaluate a file with own scope, returning any error (if any). /// /// Not available under `no_std` or `WASM`. @@ -1801,41 +1763,11 @@ impl Engine { ) -> Result<(), Box> { Self::read_file(path).and_then(|contents| self.run_with_scope(scope, &contents)) } - /// Evaluate a string, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run`][Engine::run] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run` instead")] - #[inline(always)] - pub fn consume(&self, script: &str) -> Result<(), Box> { - self.run(script) - } /// Evaluate a script, returning any error (if any). #[inline(always)] pub fn run(&self, script: &str) -> Result<(), Box> { self.run_with_scope(&mut Default::default(), script) } - /// Evaluate a string with own scope, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run_with_scope`][Engine::run_with_scope] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run_with_scope` instead")] - #[inline(always)] - pub fn consume_with_scope( - &self, - scope: &mut Scope, - script: &str, - ) -> Result<(), Box> { - self.run_with_scope(scope, script) - } /// Evaluate a script with own scope, returning any error (if any). #[inline] pub fn run_with_scope( @@ -1856,41 +1788,11 @@ impl Engine { self.run_ast_with_scope(scope, &ast) } - /// Evaluate an AST, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run_ast`][Engine::run_ast] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run_ast` instead")] - #[inline(always)] - pub fn consume_ast(&self, ast: &AST) -> Result<(), Box> { - self.run_ast(ast) - } /// Evaluate an AST, returning any error (if any). #[inline(always)] pub fn run_ast(&self, ast: &AST) -> Result<(), Box> { self.run_ast_with_scope(&mut Default::default(), ast) } - /// Evaluate an [`AST`] with own scope, but throw away the result and only return error (if any). - /// Useful for when you don't need the result, but still need to keep track of possible errors. - /// - /// # Deprecated - /// - /// This method is deprecated. Use [`run_ast_with_scope`][Engine::run_ast_with_scope] instead. - /// - /// This method will be removed in the next major version. - #[deprecated(since = "1.1.0", note = "use `run_ast_with_scope` instead")] - #[inline(always)] - pub fn consume_ast_with_scope( - &self, - scope: &mut Scope, - ast: &AST, - ) -> Result<(), Box> { - self.run_ast_with_scope(scope, ast) - } /// Evaluate an [`AST`] with own scope, returning any error (if any). #[inline] pub fn run_ast_with_scope( diff --git a/src/lib.rs b/src/lib.rs index 614a8fb8..1466bbb7 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -71,6 +71,7 @@ use std::prelude::v1::*; mod ast; mod custom_syntax; +mod deprecated; mod dynamic; mod engine; mod engine_api;