From 002f8a8c7f3f10a69f47d74c0e6f506592314794 Mon Sep 17 00:00:00 2001
From: Vincent Prouillet <vincent@wearewizards.io>
Date: Mon, 21 Dec 2015 19:23:10 +0000
Subject: [PATCH] Change order of encode method args + make alg field public

---
 README.md                 | 6 ++++--
 benches/jwt.rs            | 2 +-
 examples/claims.rs        | 2 +-
 examples/custom_header.rs | 5 +++--
 src/lib.rs                | 8 ++++----
 5 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 6a18eb0..4f654d2 100644
--- a/README.md
+++ b/README.md
@@ -23,10 +23,11 @@ use jwt::{encode, decode, Header, Algorithm};
 
 ### Encoding
 ```rust
-let token = encode(&my_claims, "secret".as_ref(), Header::default()).unwrap();
+let token = encode(Header::default(), &my_claims, "secret".as_ref()).unwrap();
 ```
 In that example, `my_claims` is an instance of the Claims struct.  
 The struct you are using for your claims should derive `RustcEncodable` and `RustcDecodable`.
+The default algorithm is HS256. Look at custom headers section to see how to change that.
 
 ### Decoding
 ```rust
@@ -50,7 +51,8 @@ If you want to set the `kid` parameter for example:
 ```rust
 let mut header = Header::default();
 header.kid = Some("blabla".to_owned());
-let token = encode(&my_claims, "secret".as_ref(), header).unwrap();
+header.alg = Algorithm::HS512;
+let token = encode(header, &my_claims, "secret".as_ref()).unwrap();
 ```
 
 ## Algorithms
diff --git a/benches/jwt.rs b/benches/jwt.rs
index 1de9124..5813bc9 100644
--- a/benches/jwt.rs
+++ b/benches/jwt.rs
@@ -18,7 +18,7 @@ fn bench_encode(b: &mut test::Bencher) {
         company: "ACME".to_owned()
     };
 
-    b.iter(|| encode(&claim, "secret".as_ref(), Header::default()));
+    b.iter(|| encode(Header::default(), &claim, "secret".as_ref()));
 }
 
 #[bench]
diff --git a/examples/claims.rs b/examples/claims.rs
index a8330fb..0e70c18 100644
--- a/examples/claims.rs
+++ b/examples/claims.rs
@@ -29,7 +29,7 @@ fn main() {
         company: "ACME".to_owned()
     };
     let key = "secret";
-    let token = match encode(&my_claims, key.as_ref(), Header::default()) {
+    let token = match encode(Header::default(), &my_claims, key.as_ref()) {
         Ok(t) => t,
         Err(_) => panic!() // in practice you would return the error
     };
diff --git a/examples/custom_header.rs b/examples/custom_header.rs
index 62622d0..1b7e686 100644
--- a/examples/custom_header.rs
+++ b/examples/custom_header.rs
@@ -20,13 +20,14 @@ fn main() {
 
     let mut header = Header::default();
     header.kid = Some("signing_key".to_owned());
+    header.alg = Algorithm::HS512;
 
-    let token = match encode(&my_claims, key.as_ref(), header) {
+    let token = match encode(header, &my_claims, key.as_ref()) {
         Ok(t) => t,
         Err(_) => panic!() // in practice you would return the error
     };
 
-    let token_data = match decode::<Claims>(&token, key.as_ref(), Algorithm::HS256) {
+    let token_data = match decode::<Claims>(&token, key.as_ref(), Algorithm::HS512) {
         Ok(c) => c,
         Err(err) => match err {
             Error::InvalidToken => panic!(), // Example on how to handle a specific error
diff --git a/src/lib.rs b/src/lib.rs
index fb23678..451c391 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -56,7 +56,7 @@ impl<T> Part for T where T: Encodable + Decodable {
 /// set to `JWT`. All the other fields are optional
 pub struct Header {
     typ: String,
-    alg: Algorithm,
+    pub alg: Algorithm,
     pub jku: Option<String>,
     pub kid: Option<String>,
     pub x5u: Option<String>,
@@ -111,7 +111,7 @@ fn verify(signature: &str, data: &str, secret: &[u8], algorithm: Algorithm) -> b
 }
 
 /// Encode the claims passed and sign the payload using the algorithm from the header and the secret
-pub fn encode<T: Part>(claims: &T, secret: &[u8], header: Header) -> Result<String, Error> {
+pub fn encode<T: Part>(header: Header, claims: &T, secret: &[u8]) -> Result<String, Error> {
     let encoded_header = try!(header.to_base64());
     let encoded_claims = try!(claims.to_base64());
     // seems to be a tiny bit faster than format!("{}.{}", x, y)
@@ -193,7 +193,7 @@ mod tests {
         };
         let mut header = Header::default();
         header.kid = Some("kid".to_owned());
-        let token = encode(&my_claims, "secret".as_ref(), header).unwrap();
+        let token = encode(header, &my_claims, "secret".as_ref()).unwrap();
         let token_data = decode::<Claims>(&token, "secret".as_ref(), Algorithm::HS256).unwrap();
         assert_eq!(my_claims, token_data.claims);
         assert_eq!("kid", token_data.header.kid.unwrap());
@@ -205,7 +205,7 @@ mod tests {
             sub: "b@b.com".to_owned(),
             company: "ACME".to_owned()
         };
-        let token = encode(&my_claims, "secret".as_ref(), Header::default()).unwrap();
+        let token = encode(Header::default(), &my_claims, "secret".as_ref()).unwrap();
         let token_data = decode::<Claims>(&token, "secret".as_ref(), Algorithm::HS256).unwrap();
         assert_eq!(my_claims, token_data.claims);
         assert!(token_data.header.kid.is_none());