Fix : #6

src/adapter/file_adapter.rs

@@ -4,32 +4,33 @@ use crate::{
     model::Model,
     util::parse_csv_line,
     Result,
+
 };
 
 
 #[cfg(feature = "runtime-async-std")]
 use async_std::{
-    fs::File as asyncFile,
+    fs::File as file,
     io::prelude::*,
-    io::{BufReader as asyncBufReader, Error as asyncIoError, ErrorKind as asyncErrorKind},
-    path::Path as asyncPath,
+    io::{BufReader as ioBufReader, Error as ioError, ErrorKind as ioErrorKind},
+    path::Path as ioPath,
     prelude::*,
 };
 
+
 #[cfg(feature = "runtime-tokio")]
 use std::{
-    io::{Error as tokioIoError, ErrorKind as tokioErrorKind},
-    path::Path as tokioPath,
+    io::{Error as ioError, ErrorKind as ioErrorKind},
+    path::Path as ioPath,
 };
 #[cfg(feature = "runtime-tokio")]
 use tokio::{
-    fs::File as tokioFile,
-    io::{AsyncBufReadExt, AsyncWriteExt, BufReader as tokioBufReader},
+    fs::File as file,
+    io::{AsyncBufReadExt, AsyncWriteExt, BufReader as ioBufReader},
 };
 
-use async_trait::async_trait;
 
-use std::convert::AsRef;
+use async_trait::async_trait;
 use std::fmt::Write;
 
 pub struct FileAdapter<P> {
@@ -43,7 +44,7 @@ type LoadFilteredPolicyFileHandler<'a> =
 
 impl<P> FileAdapter<P>
 where
-    P: AsRef<tokioPath> + Send + Sync,
+    P: AsRef<ioPath> + Send + Sync,
 {
     pub fn new(p: P) -> FileAdapter<P> {
         FileAdapter {
@@ -64,8 +65,8 @@ where
         m: &mut dyn Model,
         handler: LoadPolicyFileHandler,
     ) -> Result<()> {
-        let f = tokioFile::open(&self.file_path).await?;
-        let mut lines = tokioBufReader::new(f).lines();
+        let f = file::open(&self.file_path).await?;
+        let mut lines = ioBufReader::new(f).lines();
         #[cfg(feature = "runtime-async-std")]
         while let Some(line) = lines.next().await {
             handler(line?, m)
@@ -85,8 +86,8 @@ where
         filter: Filter<'a>,
         handler: LoadFilteredPolicyFileHandler<'a>,
     ) -> Result<bool> {
-        let f = tokioFile::open(&self.file_path).await?;
-        let mut lines = tokioBufReader::new(f).lines();
+        let f = file::open(&self.file_path).await?;
+        let mut lines = ioBufReader::new(f).lines();
 
         let mut is_filtered = false;
         #[cfg(feature = "runtime-async-std")]
@@ -107,7 +108,7 @@ where
     }
 
     async fn save_policy_file(&self, text: String) -> Result<()> {
-        let mut file = tokioFile::create(&self.file_path).await?;
+        let mut file = file::create(&self.file_path).await?;
         file.write_all(text.as_bytes()).await?;
         Ok(())
     }
@@ -116,7 +117,7 @@ where
 #[async_trait]
 impl<P> Adapter for FileAdapter<P>
 where
-    P: AsRef<tokioPath> + Send + Sync,
+    P: AsRef<ioPath> + Send + Sync,
 {
     async fn load_policy(&mut self, m: &mut dyn Model) -> Result<()> {
         self.is_filtered = false;
@@ -138,8 +139,8 @@ where
 
     async fn save_policy(&mut self, m: &mut dyn Model) -> Result<()> {
         if self.file_path.as_ref().as_os_str().is_empty() {
-            return Err(tokioIoError::new(
-                tokioErrorKind::Other,
+            return Err(ioError::new(
+                ioErrorKind::Other,
                 "save policy failed, file path is empty",
             )
             .into());

src/config.rs

@@ -3,21 +3,21 @@ use crate::Result;
 #[cfg(feature = "runtime-async-std")]
 use async_std::{
     io::prelude::*,
-    io::{BufReader, Cursor, Error as IoError, ErrorKind},
+    io::{BufReader as ioBufReader, Cursor, Error as ioError, ioErrorKind},
 };
 
 #[cfg(all(feature = "runtime-async-std", not(target_arch = "wasm32")))]
-use async_std::{fs::File, path::Path};
+use async_std::{fs::File as file, path::Path as ioPath};
 
 #[cfg(feature = "runtime-tokio")]
-use std::{io::Cursor as tokioCursor, path::Path as tokioPath};
+use std::{io::Cursor as tokioCursor, path::Path as ioPath};
 #[cfg(feature = "runtime-tokio")]
 use tokio::io::{
-    AsyncBufReadExt, AsyncReadExt, BufReader as tokioBufReader, Error as tokioIoError, ErrorKind as tokioErrorKind,
+    AsyncBufReadExt, AsyncReadExt, BufReader as ioBufReader, Error as ioError, ErrorKind as ioErrorKind,
 };
 
 #[cfg(all(feature = "runtime-tokio", not(target_arch = "wasm32")))]
-use tokio::fs::File as tokioFile;
+use tokio::fs::File as file;
 
 use std::collections::HashMap;
 
@@ -32,7 +32,7 @@ pub(crate) struct Config {
 
 impl Config {
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) async fn from_file<P: AsRef<tokioPath>>(p: P) -> Result<Self> {
+    pub(crate) async fn from_file<P: AsRef<ioPath>>(p: P) -> Result<Self> {
         let mut c = Config {
             data: HashMap::new(),
         };
@@ -46,25 +46,25 @@ impl Config {
             data: HashMap::new(),
         };
 
-        c.parse_buffer(&mut tokioBufReader::new(tokioCursor::new(s.as_ref().as_bytes())))
+        c.parse_buffer(&mut ioBufReader::new(tokioCursor::new(s.as_ref().as_bytes())))
             .await?;
         Ok(c)
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    async fn parse<P: AsRef<tokioPath>>(&mut self, p: P) -> Result<()> {
-        let mut f = tokioFile::open(p).await?;
+    async fn parse<P: AsRef<ioPath>>(&mut self, p: P) -> Result<()> {
+        let mut f = file::open(p).await?;
         let mut c = Vec::new();
         f.read_to_end(&mut c).await?;
 
-        let mut reader: tokioBufReader<tokioCursor<&[u8]>> =
-            tokioBufReader::new(tokioCursor::new(&c));
+        let mut reader: ioBufReader<tokioCursor<&[u8]>> =
+            ioBufReader::new(tokioCursor::new(&c));
         self.parse_buffer(&mut reader).await
     }
 
     async fn parse_buffer(
         &mut self,
-        reader: &mut tokioBufReader<tokioCursor<&[u8]>>,
+        reader: &mut ioBufReader<tokioCursor<&[u8]>>,
     ) -> Result<()> {
         let mut section = String::new();
 
@@ -122,8 +122,8 @@ impl Config {
                     .collect();
 
                 if option_val.len() != 2 {
-                    return Err(tokioIoError::new(
-                        tokioErrorKind::Other,
+                    return Err(ioError::new(
+                        ioErrorKind::Other,
                         format!("parse content error, line={}", line),
                     )
                     .into());

src/model/default_model.rs

@@ -14,10 +14,10 @@ use parking_lot::RwLock;
 use ritelinked::{LinkedHashMap, LinkedHashSet};
 
 #[cfg(all(feature = "runtime-async-std", not(target_arch = "wasm32")))]
-use async_std::path::Path;
+use async_std::path::Path as ioPath;
 
 #[cfg(feature = "runtime-tokio")]
-use std::path::Path as tokioPath;
+use std::path::Path as ioPath;
 
 use std::{collections::HashMap, sync::Arc};
 
@@ -28,7 +28,7 @@ pub struct DefaultModel {
 
 impl DefaultModel {
     #[cfg(not(target_arch = "wasm32"))]
-    pub async fn from_file<P: AsRef<tokioPath>>(p: P) -> Result<DefaultModel> {
+    pub async fn from_file<P: AsRef<ioPath>>(p: P) -> Result<DefaultModel> {
         let cfg = Config::from_file(p).await?;
 
         let mut model = DefaultModel::default();