Change order of encode method args + make alg field public

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

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]

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
     };

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

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());