Rename commands and methods to be inline with REST API names

durch · durch · commit ecf4e8fa9e2a · 2019-05-06T22:14:32.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rust-s3"
-version = "0.12.1"
+version = "0.13.0"
 authors = ["Drazen Urch", "Nick Stevens"]
 description = "Tiny Rust library for working with Amazon S3."
 repository = "https://github.com/durch/rust-s3"
diff --git a/README.md b/README.md
@@ -28,13 +28,13 @@ it is configured for one week which is the maximum Amazon allows ATM.
 
 ```
 [dependencies]
-rust-s3 = "0.12.1"
+rust-s3 = "0.13.0"
 ```
 
 #### Disable SSL verification for endpoints
 ```
 [dependencies]
-rust-s3 = {version = "0.12.1", features = ["no-verify-ssl"]}
+rust-s3 = {version = "0.13.0", features = ["no-verify-ssl"]}
 ```
 
 
diff --git a/src/bin/simple_crud.rs b/src/bin/simple_crud.rs
@@ -33,22 +33,22 @@ pub fn main() -> S3Result<()> {
 
     // Put a "test_file" with the contents of MESSAGE at the root of the
     // bucket.
-    let (_, code) = bucket.put("test_file", MESSAGE.as_bytes(), "text/plain")?;
+    let (_, code) = bucket.put_object("test_file", MESSAGE.as_bytes(), "text/plain")?;
     assert_eq!(200, code);
 
     // Get the "test_file" contents and make sure that the returned message
     // matches what we sent.
-    let (data, code) = bucket.get("test_file")?;
+    let (data, code) = bucket.get_object("test_file")?;
     let string = str::from_utf8(&data).unwrap();
     assert_eq!(200, code);
     assert_eq!(MESSAGE, string);
 
 //  Get bucket location
     println!("{:?}", bucket.location()?);
 
-    bucket.tag("test_file", &[("test", "tag")])?;
+    bucket.put_object_tagging("test_file", &[("test", "tag")])?;
     println!("Tags set");
-    let (tags, _status) = bucket.get_tags("test_file")?;
+    let (tags, _status) = bucket.get_object_tagging("test_file")?;
     println!("{:?}", tags);
 
     Ok(())
diff --git a/src/bucket.rs b/src/bucket.rs
@@ -76,11 +76,11 @@ impl Bucket {
     /// let credentials = Credentials::default();
     /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
     ///
-    /// let (data, code) = bucket.get("/test.file").unwrap();
+    /// let (data, code) = bucket.get_object("/test.file").unwrap();
     /// println!("Code: {}\nData: {:?}", code, data);
     /// ```
-    pub fn get(&self, path: &str) -> S3Result<(Vec<u8>, u32)> {
-        let command = Command::Get;
+    pub fn get_object(&self, path: &str) -> S3Result<(Vec<u8>, u32)> {
+        let command = Command::GetObject;
         let request = Request::new(self, path, command);
         request.execute()
     }
@@ -105,7 +105,7 @@ impl Bucket {
     /// println!("{}", bucket.location().unwrap().0)
     /// ```
     pub fn location(&self) -> S3Result<(Region, u32)> {
-        let request = Request::new(self, "?location", Command::BucketOpGet);
+        let request = Request::new(self, "?location", Command::GetBucketLocation);
         let result = request.execute()?;
         let result_string = String::from_utf8_lossy(&result.0);
         let region = match serde_xml::deserialize(result_string.as_bytes()) {
@@ -137,11 +137,11 @@ impl Bucket {
     /// let credentials = Credentials::default();
     /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
     ///
-    /// let (_, code) = bucket.delete("/test.file").unwrap();
+    /// let (_, code) = bucket.delete_object("/test.file").unwrap();
     /// assert_eq!(204, code);
     /// ```
-    pub fn delete(&self, path: &str) -> S3Result<(Vec<u8>, u32)> {
-        let command = Command::Delete;
+    pub fn delete_object(&self, path: &str) -> S3Result<(Vec<u8>, u32)> {
+        let command = Command::DeleteObject;
         let request = Request::new(self, path, command);
         request.execute()
     }
@@ -164,11 +164,11 @@ impl Bucket {
     /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
     ///
     /// let content = "I want to go to S3".as_bytes();
-    /// let (_, code) = bucket.put("/test.file", content, "text/plain").unwrap();
+    /// let (_, code) = bucket.put_object("/test.file", content, "text/plain").unwrap();
     /// assert_eq!(201, code);
     /// ```
-    pub fn put(&self, path: &str, content: &[u8], content_type: &str) -> S3Result<(Vec<u8>, u32)> {
-        let command = Command::Put {
+    pub fn put_object(&self, path: &str, content: &[u8], content_type: &str) -> S3Result<(Vec<u8>, u32)> {
+        let command = Command::PutObject {
             content,
             content_type,
         };
@@ -208,12 +208,12 @@ impl Bucket {
     /// let credentials = Credentials::default();
     /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
     ///
-    /// let (_, code) = bucket.tag("/test.file", &[("Tag1", "Value1"), ("Tag2", "Value2")]).unwrap();
+    /// let (_, code) = bucket.put_object_tagging("/test.file", &[("Tag1", "Value1"), ("Tag2", "Value2")]).unwrap();
     /// assert_eq!(201, code);
     /// ```
-    pub fn tag(&self, path: &str, tags: &[(&str, &str)]) -> S3Result<(Vec<u8>, u32)> {
+    pub fn put_object_tagging(&self, path: &str, tags: &[(&str, &str)]) -> S3Result<(Vec<u8>, u32)> {
         let content = self._tags_xml(&tags);
-        let command = Command::Tag {
+        let command = Command::PutObjectTagging {
             tags: &content.to_string()
         };
         let request = Request::new(self, path, command);
@@ -237,15 +237,15 @@ impl Bucket {
     /// let credentials = Credentials::default();
     /// let bucket = Bucket::new(bucket_name, region, credentials).unwrap();
     ///
-    /// let (tags, code) = bucket.get_tags("/test.file").unwrap();
+    /// let (tags, code) = bucket.get_object_tagging("/test.file").unwrap();
     /// if code == 200 {
     ///     for tag in tags.expect("No tags found").tag_set {
     ///         println!("{}={}", tag.key(), tag.value());
     ///     }
     /// }
     /// ```
-    pub fn get_tags(&self, path: &str) -> S3Result<(Option<Tagging>, u32)> {
-        let command = Command::GetTags {};
+    pub fn get_object_tagging(&self, path: &str) -> S3Result<(Option<Tagging>, u32)> {
+        let command = Command::GetObjectTagging {};
         let request = Request::new(self, path, command);
         let result = request.execute()?;
 
@@ -265,7 +265,7 @@ impl Bucket {
              delimiter: Option<&str>,
              continuation_token: Option<&str>)
              -> S3Result<(ListBucketResult, u32)> {
-        let command = Command::List {
+        let command = Command::ListBucket {
             prefix,
             delimiter,
             continuation_token,
diff --git a/src/command.rs b/src/command.rs
@@ -1,30 +1,32 @@
 use reqwest::Method;
 
 pub enum Command<'a> {
-    Put {
+    DeleteObject,
+    DeleteObjectTagging,
+    GetObject,
+    GetObjectTagging,
+    PutObject {
         content: &'a [u8],
         content_type: &'a str,
     },
-    Tag {
+    PutObjectTagging {
         tags: &'a str
     },
-    GetTags,
-    Get,
-    Delete,
-    List {
+
+    ListBucket {
         prefix: &'a str,
         delimiter: Option<&'a str>,
         continuation_token: Option<&'a str>
     },
-    BucketOpGet
+    GetBucketLocation
 }
 
 impl<'a> Command<'a> {
     pub fn http_verb(&self) -> Method {
         match *self {
-            Command::Get | Command::List { .. } | Command::BucketOpGet | Command::GetTags => Method::GET,
-            Command::Put { .. } | Command::Tag { .. } => Method::PUT,
-            Command::Delete => Method::DELETE,
+            Command::GetObject | Command::ListBucket { .. } | Command::GetBucketLocation | Command::GetObjectTagging => Method::GET,
+            Command::PutObject { .. } | Command::PutObjectTagging { .. } => Method::PUT,
+            Command::DeleteObject | Command::DeleteObjectTagging => Method::DELETE,
         }
     }
 }
diff --git a/src/request.rs b/src/request.rs
@@ -52,11 +52,11 @@ impl<'a> Request<'a> {
 
     fn url(&self) -> Url {
         let mut url_str = match self.command {
-            Command::BucketOpGet => format!("{}://{}", self.bucket.scheme(), self.bucket.self_host()),
+            Command::GetBucketLocation => format!("{}://{}", self.bucket.scheme(), self.bucket.self_host()),
             _ => format!("{}://{}", self.bucket.scheme(), self.bucket.host())
         };
         match self.command {
-            Command::BucketOpGet => {}
+            Command::GetBucketLocation => {}
             _ => {
                 url_str.push_str("/");
                 url_str.push_str(&self.bucket.name());
@@ -66,7 +66,7 @@ impl<'a> Request<'a> {
             url_str.push_str("/");
         }
         match self.command {
-            Command::BucketOpGet => url_str.push_str(self.path),
+            Command::GetBucketLocation => url_str.push_str(self.path),
             _ => url_str.push_str(&signing::uri_encode(self.path, false))
         };
 
@@ -78,7 +78,7 @@ impl<'a> Request<'a> {
             url.query_pairs_mut().append_pair(key, value);
         }
 
-        if let Command::List { prefix, delimiter, continuation_token } = self.command {
+        if let Command::ListBucket { prefix, delimiter, continuation_token } = self.command {
             let mut query_pairs = url.query_pairs_mut();
             delimiter.map(|d| query_pairs.append_pair("delimiter", d));
             query_pairs.append_pair("prefix", prefix);
@@ -89,7 +89,7 @@ impl<'a> Request<'a> {
         }
 
         match self.command {
-            Command::Tag { .. } | Command::GetTags => {
+            Command::PutObjectTagging { .. } | Command::GetObjectTagging | Command::DeleteObjectTagging => {
                 url.query_pairs_mut().append_pair("tagging", "");
             },
             _ => {}
@@ -101,27 +101,27 @@ impl<'a> Request<'a> {
 
     fn content_length(&self) -> usize {
         match self.command {
-            Command::Put { content, .. } => content.len(),
-            Command::Tag { tags } => tags.len(),
+            Command::PutObject { content, .. } => content.len(),
+            Command::PutObjectTagging { tags } => tags.len(),
             _ => 0,
         }
     }
 
     fn content_type(&self) -> String {
         match self.command {
-            Command::Put { content_type, .. } => content_type.into(),
+            Command::PutObject { content_type, .. } => content_type.into(),
             _ => "text/plain".into(),
         }
     }
 
     fn sha256(&self) -> String {
         match self.command {
-            Command::Put { content, .. } => {
+            Command::PutObject { content, .. } => {
                 let mut sha = Sha256::default();
                 sha.input(content);
                 sha.result().as_slice().to_hex()
             },
-            Command::Tag { tags } => {
+            Command::PutObjectTagging { tags } => {
                 let mut sha = Sha256::default();
                 sha.input(tags.as_bytes());
                 sha.result().as_slice().to_hex()
@@ -185,7 +185,7 @@ impl<'a> Request<'a> {
             .map(|(k, v)| Ok((k.parse::<HeaderName>()?, v.parse::<HeaderValue>()?)))
             .collect::<Result<HeaderMap, S3Error>>()?;
         match self.command {
-            Command::BucketOpGet => headers.insert(header::HOST, self.bucket.self_host().parse()?),
+            Command::GetBucketLocation => headers.insert(header::HOST, self.bucket.self_host().parse()?),
             _ => headers.insert(header::HOST, self.bucket.host().parse()?)
         };
         headers.insert(
@@ -200,7 +200,7 @@ impl<'a> Request<'a> {
             headers.insert("X-Amz-Security-Token", token.parse()?);
         }
 
-        if let Command::Tag { tags } = self.command {
+        if let Command::PutObjectTagging { tags } = self.command {
             let digest = md5::compute(tags);
             let hash = base64::encode(digest.as_ref());
             headers.insert("Content-MD5", hash.parse()?);
@@ -236,9 +236,9 @@ impl<'a> Request<'a> {
         let headers = self.headers()?;
 
         // Get owned content to pass to reqwest
-        let content = if let Command::Put { content, .. } = self.command {
+        let content = if let Command::PutObject { content, .. } = self.command {
             Vec::from(content)
-        } else if let Command::Tag { tags } = self.command {
+        } else if let Command::PutObjectTagging { tags } = self.command {
             Vec::from(tags)
         } else {
             Vec::new()
@@ -290,7 +290,7 @@ mod tests {
         let region = "custom-region".parse()?;
         let bucket = Bucket::new("my-first-bucket", region, fake_credentials())?;
         let path = "/my-first/path";
-        let request = Request::new(&bucket, path, Command::Get);
+        let request = Request::new(&bucket, path, Command::GetObject);
 
         assert_eq!(request.url().scheme(), "https");
 
@@ -306,7 +306,7 @@ mod tests {
         let region = "http://custom-region".parse()?;
         let bucket = Bucket::new("my-second-bucket", region, fake_credentials())?;
         let path = "/my-second/path";
-        let request = Request::new(&bucket, path, Command::Get);
+        let request = Request::new(&bucket, path, Command::GetObject);
 
         assert_eq!(request.url().scheme(), "http");
 
