To_String() cleanup for to_owned on method calls

leaexplores · leaexplores · commit f5ee8686aefa · 2015-09-28T01:19:02.000-04:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -24,7 +24,7 @@
 //!                   )", &[]).unwrap();
 //!     let me = Person {
 //!         id: 0,
-//!         name: "Steven".to_string(),
+//!         name: "Steven".to_owned(),
 //!         data: None
 //!     };
 //!     conn.execute("INSERT INTO person (name, data) VALUES ($1, $2)",
@@ -867,7 +867,7 @@ impl Connection {
     ///     target: ConnectTarget::Unix(some_crazy_path),
     ///     port: None,
     ///     user: Some(UserInfo {
-    ///         user: "postgres".to_string(),
+    ///         user: "postgres".to_owned(),
     ///         password: None
     ///     }),
     ///     database: None,
diff --git a/src/url.rs b/src/url.rs
@@ -65,9 +65,9 @@ impl Url {
         // query and fragment
         let (query, fragment) = try!(get_query_fragment(rest));
 
-        let url = Url::new(scheme.to_string(),
+        let url = Url::new(scheme.to_owned(),
                             userinfo,
-                            host.to_string(),
+                            host.to_owned(),
                             port,
                             path,
                             query,
@@ -180,22 +180,22 @@ pub fn get_scheme(rawurl: &str) -> DecodeResult<(&str, &str)> {
             '0' ... '9' | '+' | '-' | '.' => {
                 if i != 0 { continue }
 
-                Err("url: Scheme must begin with a letter.".to_string())
+                Err("url: Scheme must begin with a letter.".to_owned())
             }
             ':' => {
                 if i == 0 {
-                    Err("url: Scheme cannot be empty.".to_string())
+                    Err("url: Scheme cannot be empty.".to_owned())
                 } else {
                     Ok((&rawurl[0..i], &rawurl[i+1..rawurl.len()]))
                 }
             }
-            _ => Err("url: Invalid character in scheme.".to_string()),
+            _ => Err("url: Invalid character in scheme.".to_owned()),
         };
 
         return result;
     }
 
-    Err("url: Scheme must be terminated with a colon.".to_string())
+    Err("url: Scheme must be terminated with a colon.".to_owned())
 }
 
 // returns userinfo, host, port, and unparsed part, or an error
@@ -255,7 +255,7 @@ fn get_authority(rawurl: &str) ->
             ':' | '@' | '?' | '#' | '/' => {
                 // separators, don't change anything
             }
-            _ => return Err("Illegal character in authority".to_string()),
+            _ => return Err("Illegal character in authority".to_owned()),
         }
 
         // now process states
@@ -271,7 +271,7 @@ fn get_authority(rawurl: &str) ->
                 // multiple colons means ipv6 address.
                 if input == Input::Unreserved {
                     return Err(
-                        "Illegal characters in IPv6 address.".to_string());
+                        "Illegal characters in IPv6 address.".to_owned());
                 }
                 st = State::Ip6Host;
               }
@@ -288,7 +288,7 @@ fn get_authority(rawurl: &str) ->
               }
               State::Ip6Port => {
                 if input == Input::Unreserved {
-                    return Err("Illegal characters in authority.".to_string());
+                    return Err("Illegal characters in authority.".to_owned());
                 }
                 st = State::Ip6Host;
               }
@@ -299,7 +299,7 @@ fn get_authority(rawurl: &str) ->
                     st = State::InPort;
                 }
               }
-              _ => return Err("Invalid ':' in authority.".to_string()),
+              _ => return Err("Invalid ':' in authority.".to_owned()),
             }
             input = Input::Digit; // reset input class
           }
@@ -319,7 +319,7 @@ fn get_authority(rawurl: &str) ->
                 userinfo = Some(UserInfo::new(user, Some(pass)));
                 st = State::InHost;
               }
-              _ => return Err("Invalid '@' in authority.".to_string()),
+              _ => return Err("Invalid '@' in authority.".to_owned()),
             }
             begin = i+1;
           }
@@ -338,7 +338,7 @@ fn get_authority(rawurl: &str) ->
       State::PassHostPort
       | State::Ip6Port => {
         if input != Input::Digit {
-            return Err("Non-digit characters in port.".to_string());
+            return Err("Non-digit characters in port.".to_owned());
         }
         host = &rawurl[begin..pos];
         port = Some(&rawurl[pos+1..end]);
@@ -347,7 +347,7 @@ fn get_authority(rawurl: &str) ->
       | State::InHost => host = &rawurl[begin..end],
       State::InPort => {
         if input != Input::Digit {
-            return Err("Non-digit characters in port.".to_string());
+            return Err("Non-digit characters in port.".to_owned());
         }
         port = Some(&rawurl[pos+1..end]);
       }
@@ -384,13 +384,13 @@ fn get_path(rawurl: &str, is_authority: bool) -> DecodeResult<(String, &str)> {
             end = i;
             break;
           }
-          _ => return Err("Invalid character in path.".to_string())
+          _ => return Err("Invalid character in path.".to_owned())
         }
     }
 
     if is_authority && end != 0 && !rawurl.starts_with("/") {
         Err("Non-empty path must begin with \
-            '/' in presence of authority.".to_string())
+            '/' in presence of authority.".to_owned())
     } else {
         Ok((try!(decode_component(&rawurl[0..end])), &rawurl[end..len]))
     }
diff --git a/tests/types/mod.rs b/tests/types/mod.rs
@@ -52,8 +52,8 @@ fn test_i8_params() {
 
 #[test]
 fn test_name_params() {
-    test_type("NAME", &[(Some("hello world".to_string()), "'hello world'"),
-                       (Some("イロハニホヘト チリヌルヲ".to_string()), "'イロハニホヘト チリヌルヲ'"),
+    test_type("NAME", &[(Some("hello world".to_owned()), "'hello world'"),
+                       (Some("イロハニホヘト チリヌルヲ".to_owned()), "'イロハニホヘト チリヌルヲ'"),
                        (None, "NULL")]);
 }
 
@@ -99,15 +99,15 @@ fn test_f64_params() {
 
 #[test]
 fn test_varchar_params() {
-    test_type("VARCHAR", &[(Some("hello world".to_string()), "'hello world'"),
-                          (Some("イロハニホヘト チリヌルヲ".to_string()), "'イロハニホヘト チリヌルヲ'"),
+    test_type("VARCHAR", &[(Some("hello world".to_owned()), "'hello world'"),
+                          (Some("イロハニホヘト チリヌルヲ".to_owned()), "'イロハニホヘト チリヌルヲ'"),
                           (None, "NULL")]);
 }
 
 #[test]
 fn test_text_params() {
-    test_type("TEXT", &[(Some("hello world".to_string()), "'hello world'"),
-                       (Some("イロハニホヘト チリヌルヲ".to_string()), "'イロハニホヘト チリヌルヲ'"),
+    test_type("TEXT", &[(Some("hello world".to_owned()), "'hello world'"),
+                       (Some("イロハニホヘト チリヌルヲ".to_owned()), "'イロハニホヘト チリヌルヲ'"),
                        (None, "NULL")]);
 }
 
@@ -123,7 +123,7 @@ fn test_bpchar_params() {
     let stmt = or_panic!(conn.prepare("SELECT b FROM foo ORDER BY id"));
     let res = or_panic!(stmt.query(&[]));
 
-    assert_eq!(vec!(Some("12345".to_string()), Some("123  ".to_string()), None),
+    assert_eq!(vec!(Some("12345".to_owned()), Some("123  ".to_owned()), None),
                res.iter().map(|row| row.get(0)).collect::<Vec<_>>());
 }
 
@@ -158,10 +158,10 @@ fn test_hstore_params() {
         })
     }
     test_type("hstore",
-              &[(Some(make_map!("a".to_string() => Some("1".to_string()))), "'a=>1'"),
-               (Some(make_map!("hello".to_string() => Some("world!".to_string()),
-                               "hola".to_string() => Some("mundo!".to_string()),
-                               "what".to_string() => None)),
+              &[(Some(make_map!("a".to_owned() => Some("1".to_owned()))), "'a=>1'"),
+               (Some(make_map!("hello".to_owned() => Some("world!".to_owned()),
+                               "hola".to_owned() => Some("mundo!".to_owned()),
+                               "what".to_owned() => None)),
                 "'hello=>world!,hola=>mundo!,what=>NULL'"),
                 (None, "NULL")]);
 }
@@ -203,7 +203,7 @@ fn test_slice() {
 
     let stmt = conn.prepare("SELECT f FROM foo WHERE id = ANY($1)").unwrap();
     let result = stmt.query(&[&Slice(&[1i32, 3, 4])]).unwrap();
-    assert_eq!(vec!["a".to_string(), "c".to_string(), "d".to_string()],
+    assert_eq!(vec!["a".to_owned(), "c".to_owned(), "d".to_owned()],
                result.iter().map(|r| r.get::<_, String>(0)).collect::<Vec<_>>());
 }
 

Original file line number	Diff line number	Diff line change
`@@ -65,9 +65,9 @@ impl Url {`
`65`	`65`	`// query and fragment`
`66`	`66`	`let (query, fragment) = try!(get_query_fragment(rest));`
`67`	`67`
`68`		`- let url = Url::new(scheme.to_string(),`
	`68`	`+ let url = Url::new(scheme.to_owned(),`
`69`	`69`	`userinfo,`
`70`		`- host.to_string(),`
	`70`	`+ host.to_owned(),`
`71`	`71`	`port,`
`72`	`72`	`path,`
`73`	`73`	`query,`
`@@ -180,22 +180,22 @@ pub fn get_scheme(rawurl: &str) -> DecodeResult<(&str, &str)> {`
`180`	`180`	`'0' ... '9' \| '+' \| '-' \| '.' => {`
`181`	`181`	`if i != 0 { continue }`
`182`	`182`
`183`		`- Err("url: Scheme must begin with a letter.".to_string())`
	`183`	`+ Err("url: Scheme must begin with a letter.".to_owned())`
`184`	`184`	`}`
`185`	`185`	`':' => {`
`186`	`186`	`if i == 0 {`
`187`		`- Err("url: Scheme cannot be empty.".to_string())`
	`187`	`+ Err("url: Scheme cannot be empty.".to_owned())`
`188`	`188`	`} else {`
`189`	`189`	`Ok((&rawurl[0..i], &rawurl[i+1..rawurl.len()]))`
`190`	`190`	`}`
`191`	`191`	`}`
`192`		`- _ => Err("url: Invalid character in scheme.".to_string()),`
	`192`	`+ _ => Err("url: Invalid character in scheme.".to_owned()),`
`193`	`193`	`};`
`194`	`194`
`195`	`195`	`return result;`
`196`	`196`	`}`
`197`	`197`
`198`		`- Err("url: Scheme must be terminated with a colon.".to_string())`
	`198`	`+ Err("url: Scheme must be terminated with a colon.".to_owned())`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`// returns userinfo, host, port, and unparsed part, or an error`
`@@ -255,7 +255,7 @@ fn get_authority(rawurl: &str) ->`
`255`	`255`	`':' \| '@' \| '?' \| '#' \| '/' => {`
`256`	`256`	`// separators, don't change anything`
`257`	`257`	`}`
`258`		`- _ => return Err("Illegal character in authority".to_string()),`
	`258`	`+ _ => return Err("Illegal character in authority".to_owned()),`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`// now process states`
`@@ -271,7 +271,7 @@ fn get_authority(rawurl: &str) ->`
`271`	`271`	`// multiple colons means ipv6 address.`
`272`	`272`	`if input == Input::Unreserved {`
`273`	`273`	`return Err(`
`274`		`- "Illegal characters in IPv6 address.".to_string());`
	`274`	`+ "Illegal characters in IPv6 address.".to_owned());`
`275`	`275`	`}`
`276`	`276`	`st = State::Ip6Host;`
`277`	`277`	`}`
`@@ -288,7 +288,7 @@ fn get_authority(rawurl: &str) ->`
`288`	`288`	`}`
`289`	`289`	`State::Ip6Port => {`
`290`	`290`	`if input == Input::Unreserved {`
`291`		`- return Err("Illegal characters in authority.".to_string());`
	`291`	`+ return Err("Illegal characters in authority.".to_owned());`
`292`	`292`	`}`
`293`	`293`	`st = State::Ip6Host;`
`294`	`294`	`}`
`@@ -299,7 +299,7 @@ fn get_authority(rawurl: &str) ->`
`299`	`299`	`st = State::InPort;`
`300`	`300`	`}`
`301`	`301`	`}`
`302`		`- _ => return Err("Invalid ':' in authority.".to_string()),`
	`302`	`+ _ => return Err("Invalid ':' in authority.".to_owned()),`
`303`	`303`	`}`
`304`	`304`	`input = Input::Digit; // reset input class`
`305`	`305`	`}`
`@@ -319,7 +319,7 @@ fn get_authority(rawurl: &str) ->`
`319`	`319`	`userinfo = Some(UserInfo::new(user, Some(pass)));`
`320`	`320`	`st = State::InHost;`
`321`	`321`	`}`
`322`		`- _ => return Err("Invalid '@' in authority.".to_string()),`
	`322`	`+ _ => return Err("Invalid '@' in authority.".to_owned()),`
`323`	`323`	`}`
`324`	`324`	`begin = i+1;`
`325`	`325`	`}`
`@@ -338,7 +338,7 @@ fn get_authority(rawurl: &str) ->`
`338`	`338`	`State::PassHostPort`
`339`	`339`	`\| State::Ip6Port => {`
`340`	`340`	`if input != Input::Digit {`
`341`		`- return Err("Non-digit characters in port.".to_string());`
	`341`	`+ return Err("Non-digit characters in port.".to_owned());`
`342`	`342`	`}`
`343`	`343`	`host = &rawurl[begin..pos];`
`344`	`344`	`port = Some(&rawurl[pos+1..end]);`
`@@ -347,7 +347,7 @@ fn get_authority(rawurl: &str) ->`
`347`	`347`	`\| State::InHost => host = &rawurl[begin..end],`
`348`	`348`	`State::InPort => {`
`349`	`349`	`if input != Input::Digit {`
`350`		`- return Err("Non-digit characters in port.".to_string());`
	`350`	`+ return Err("Non-digit characters in port.".to_owned());`
`351`	`351`	`}`
`352`	`352`	`port = Some(&rawurl[pos+1..end]);`
`353`	`353`	`}`
`@@ -384,13 +384,13 @@ fn get_path(rawurl: &str, is_authority: bool) -> DecodeResult<(String, &str)> {`
`384`	`384`	`end = i;`
`385`	`385`	`break;`
`386`	`386`	`}`
`387`		`- _ => return Err("Invalid character in path.".to_string())`
	`387`	`+ _ => return Err("Invalid character in path.".to_owned())`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`if is_authority && end != 0 && !rawurl.starts_with("/") {`
`392`	`392`	`Err("Non-empty path must begin with \`
`393`		`- '/' in presence of authority.".to_string())`
	`393`	`+ '/' in presence of authority.".to_owned())`
`394`	`394`	`} else {`
`395`	`395`	`Ok((try!(decode_component(&rawurl[0..end])), &rawurl[end..len]))`
`396`	`396`	`}`