first release

Author: vitiral

Cargo.toml

@@ -1,11 +1,23 @@
 [package]
+authors = ["Garrett Berg <[email protected]>"]
+description = "Types for making working with the filesystem ergonomic, therefore fun."
+documentation = "https://docs.rs/ergo_fs"
+keywords = [
+    "filesystem",
+    "path",
+    "file",
+    "types",
+    "ergonomic",
+]
+license = "MIT OR Apache-2.0"
 name = "ergo_fs"
+readme = "README.md"
+repository = "https://github.com/vitiral/ergo_fs"
 version = "0.1.0"
-authors = ["Garrett Berg <[email protected]>"]
 
 [dependencies]
+path_abs = "^0.3.0"
+std_prelude = "^0.2.9"
 tar = "^0.4.14"
 tempdir = "^0.3.5"
 walkdir = "^2.0.1"
-path_Abs = "^0.3.0"
-lockfile = "*"

LICENSE-APACHE

@@ -0,0 +1,13 @@
+Copyright 2018 Garrett Berg, [email protected]
+
+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.

LICENSE-MIT

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Garrett Berg, [email protected]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,21 @@
+# ergo_fs: types for making working with the filesystem ergonomic, therefore fun.
+[![Build Status](https://travis-ci.org/vitiral/ergo_fs.svg?branch=windows)](https://travis-ci.org/vitiral/ergo_fs)
+[![Build status](https://ci.appveyor.com/api/projects/status/vgis54solhygre0n?svg=true)](https://ci.appveyor.com/project/vitiral/path-abs)
+[![Docs](https://docs.rs/ergo_fs/badge.svg)](https://docs.rs/ergo_fs)
+
+This library aims to make working with the filesystem in rust more ergonomic.
+
+**See the [library docs](https://docs.rs/ergo_fs) for more information**
+
+# LICENSE
+The source code in this repository is Licensed under either of
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or
+  http://opensource.org/licenses/MIT)
+
+at your option.
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.

src/lib.rs

@@ -1,5 +1,14 @@
+/* Copyright (c) 2018 Garrett Berg, [email protected]
+ *
+ * Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+ * http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+ * http://opensource.org/licenses/MIT>, at your option. This file may not be
+ * copied, modified, or distributed except according to those terms.
+ */
 //! ergo_fs: types for making working with the filesystem ergonomic, therefore fun.
 //!
+//! ## Purpose
+//!
 //! This crate provides a minimal set of common types and methods for working with the filesystem.
 //! These types aim to provide:
 //!
@@ -16,9 +25,26 @@
 //!   of files.
 //! - [`walkdir`](https://github.com/BurntSushi/walkdir): Provides an efficient and cross platform
 //!   implementation of recursive directory traversal.
+//! - [`std_prelude`]: prelude that the rust stdlib should have always had.
 //!
 //! Consider supporting their development individually and starring them on github.
 //!
+//! ## How to Use
+//! ergo_fs is intended to be a "standard library" of filesystem types. Therefore you should
+//! use like so:
+//!
+//! ```
+//! extern crate ergo_fs;
+//! use ergo_fs::*;
+//! # fn try_main() -> ::std::io::Result<()> {
+//! # Ok(()) } fn main() { try_main().unwrap() }
+//! ```
+//!
+//! This will also export the [`std_prelude`] crate into your namespace, giving you automatic
+//! access to the `io::{Read, Write}` traits, `path::{Path, PathBuf}` types and more.
+//!
+//! [`std_prelude`]: http://github.com/vitiral/std_prelude
+//!
 //! # Types
 //! This library provides several kinds of types which improve and expand on `std::fs` and
 //! `std::path`, as well as provide new functionality like temporary files and tar archives.
@@ -70,17 +96,18 @@
 //!
 //! ### Examples
 //! ```rust
+//! # extern crate ergo_fs;
 //! use ergo_fs::{WalkDir, PathType};
 //!
-//! # fn try_main() -> Result<(), ::std::io::Error> {
+//! # fn try_main() -> ::std::io::Result<()> {
+//! // note: this will error
 //! for entry in WalkDir::new("foo").min_depth(1) {
-//!     match PathType::new(entry?)? {
+//!     match PathType::new(entry?.path())? {
 //!         PathType::File(file) => println!("got file {}", file.display()),
 //!         PathType::Dir(dir) => println!("got dir {}", dir.display()),
 //!     }
 //! }
-//! # Ok(())
-//! # }
+//! # Ok(()) } fn main() { try_main().unwrap_err(); }
 //! ```
 //!
 //! ## Tar Files
@@ -98,25 +125,24 @@
 //! > would be interested in using `path_abs` under the hood?
 //!
 //! ```rust
-//! use ergo_fs::{PathTmp, FileWrite};
+//! # extern crate ergo_fs;
+//! use ergo_fs::*;
 //! use ergo_fs::tar::Builder;
 //!
-//! # fn try_main() -> Result<(), ::std::io::Error> {
+//! # fn try_main() -> ::std::io::Result<()> {
 //! // We are going to tar the source code of this library
 //!
 //! let tmp = PathTmp::create("tmp")?;
-//! let mut tarfile = PathFile::create(tmp.join("src.tar"))?;
+//! let mut tarfile = FileWrite::create(tmp.join("src.tar"))?;
 //!
 //! // tar the source directory
-//! let mut tar = Builder::new(tarfile)
+//! let mut tar = Builder::new(tarfile);
 //! tar.append_dir_all("src", ".")?;
 //! tar.finish();
-//! let tarfile = tar.into_inner();
-//! tarfile.flush();
+//! let tarfile = tar.into_inner()?;
 //!
 //! // A tarfile now exists, do whatever you would like with it.
-//! # Ok(())
-//! # }
+//! # Ok(()) } fn main() { try_main().unwrap() }
 //! ```
 
 extern crate std_prelude;
@@ -128,6 +154,7 @@ extern crate path_abs;
 pub extern crate tar;
 pub extern crate walkdir;
 
+pub use std_prelude::*;
 pub use path_abs::{PathAbs, PathArc, PathFile, PathDir, PathType, FileRead, FileWrite, FileEdit};
 pub use walkdir::{WalkDir, Error as WalkError};
 

src/tmp.rs

@@ -1,6 +1,7 @@
-// Almost all of this code is copy/pasted from the tempdir crate.
+// Copyright (c) 2018 Garrett Berg, [email protected]
 //
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// Almost all of the docs in this module are copy/pasted from the tempdir crate.
+// Copyright (c) 2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -11,12 +12,11 @@
 // except according to those terms.
 
 use std::env;
-use std::fs;
-use std::io;
+use std::fmt;
 
 use std_prelude::*;
 use tempdir;
-use path_abs::{PathArc, PathAbs, PathDir};
+use path_abs::{PathArc, PathAbs, PathDir, Error, Result};
 
 /// A `PathDir` that is automatically deleted when it goes out of scope.
 ///
@@ -77,18 +77,18 @@ impl PathTmp {
     /// ```
     /// use ergo_fs::{PathFile, PathTmp};
     ///
-    /// let tmp_dir = PathTmp::create("example").unwrap()
+    /// let tmp_dir = PathTmp::create("example").unwrap();
     /// let file = PathFile::create(tmp_dir.join("temporary-note.txt")).unwrap();
     /// let message = "This file existed, but only for a moment.";
     /// file.write_str(message).unwrap();
-    /// assert_eq!(file.read_string(), message);
+    /// assert_eq!(file.read_string().unwrap(), message);
     ///
     /// // Close the tmp_dir manually (would automatically happen when dropped).
     /// // All contents are automatically deleted.
-    /// drop(tmp_dir.close().unwrap();
+    /// tmp_dir.close().unwrap();
     /// assert!(!file.exists());
     /// ```
-    pub fn create(prefix: &str) -> io::Result<PathTmp> {
+    pub fn create(prefix: &str) -> Result<PathTmp> {
         PathTmp::create_in(&env::temp_dir(), prefix)
     }
 
@@ -105,22 +105,23 @@ impl PathTmp {
     /// ```
     /// use ergo_fs::{PathFile, PathTmp};
     ///
-    /// let tmp_dir = PathTmp::create_in(".", "example").unwrap()
+    /// let tmp_dir = PathTmp::create_in(".", "example").unwrap();
     /// let file = PathFile::create(tmp_dir.join("temporary-note.txt")).unwrap();
     /// let message = "This file existed, but only for a moment.";
     /// file.write_str(message).unwrap();
-    /// assert_eq!(file.read_string(), message);
+    /// assert_eq!(file.read_string().unwrap(), message);
     ///
     /// // Close the tmp_dir manually (would automatically happen when dropped).
     /// // All contents are automatically deleted.
-    /// drop(tmp_dir.close().unwrap();
+    /// tmp_dir.close().unwrap();
     /// assert!(!file.exists());
     /// ```
-    pub fn create_in<P: AsRef<Path>>(base: P, prefix: &str) -> io::Result<PathTmp> {
-        let tmp = TempDir::new_in(&base, prefix).map_err(|err| {
-            io::Error::new(
-                err.kind(),
-                format!("{} when creating tmpdir in {}", err, base),
+    pub fn create_in<P: AsRef<Path>>(base: P, prefix: &str) -> Result<PathTmp> {
+        let tmp = tempdir::TempDir::new_in(&base, prefix).map_err(|err| {
+            Error::new(
+                err,
+                "creating tmpdir",
+                PathArc::new(&base),
             )
         })?;
 
@@ -140,16 +141,16 @@ impl PathTmp {
     /// ```
     /// use ergo_fs::PathTmp;
     ///
-    /// let tmp_dir = PathTmp::create_in(".", "persist").unwrap()
-    /// let dir = tmp_dir.persisit();
+    /// let tmp_dir = PathTmp::create_in(".", "persist").unwrap();
+    /// let dir = tmp_dir.persist();
     ///
     /// // The directory is now persisted to disk
     /// assert!(dir.exists());
     ///
     /// // It can still be manually removed though.
     /// dir.remove().unwrap();
     /// ```
-    pub fn persist(mut self) -> PathDir {
+    pub fn persist(self) -> PathDir {
         self.tmp.into_path();
         self.dir
     }
@@ -168,11 +169,13 @@ impl PathTmp {
     /// may be platform specific.
     ///
     /// [`std::io::Error`]: http://doc.rust-lang.org/std/io/struct.Error.html
-    pub fn close(mut self) -> io::Result<()> {
+    pub fn close(self) -> Result<()> {
+        let dir = self.dir;
         self.tmp.close().map_err(|err| {
-            io::Error::new(
-                err.kind(),
-                format!("{} when removing {}", err, self.dir),
+            Error::new(
+                err,
+                "removing",
+                dir.into(),
             )
         })
     }
@@ -196,7 +199,7 @@ impl Hash for PathTmp {
 }
 
 impl AsRef<PathDir> for PathTmp {
-    fn as_ref(&self) -> &PathAbs {
+    fn as_ref(&self) -> &PathDir {
         &self.dir
     }
 }