fix(from_usage): removes bug where usage strings have no help text

Creating arguments from usage strings with no help text previously
dropped the final character i.e. --flags -> --flag
This commit fixes that issue by testing if we are at the end of the
string

Closes #83

src/lib.rs

@@ -89,6 +89,24 @@ mod tests {
 		assert_eq!(e.short.unwrap(), 'f');
 		assert_eq!(e.help.unwrap(), "some help info");
 		assert!(e.multiple);
+
+		let e = Arg::from_usage("--flags");
+		assert_eq!(e.name, "flags");
+		assert_eq!(e.long.unwrap(), "flags");
+
+		let e = Arg::from_usage("--flags...");
+		assert_eq!(e.name, "flags");
+		assert_eq!(e.long.unwrap(), "flags");
+		assert!(e.multiple);
+
+		let e = Arg::from_usage("[flags] -f");
+		assert_eq!(e.name, "flags");
+		assert_eq!(e.short.unwrap(), 'f');
+
+		let e = Arg::from_usage("[flags] -f...");
+		assert_eq!(e.name, "flags");
+		assert_eq!(e.short.unwrap(), 'f');
+		assert!(e.multiple);
 	}
 
 	#[test]
@@ -125,6 +143,16 @@ mod tests {
 		assert_eq!(d.help.unwrap(), "some help info");
 		assert!(d.multiple);
 		assert!(d.required);
+
+		let b = Arg::from_usage("<pos>");
+		assert_eq!(b.name, "pos");
+		assert!(!b.multiple);
+		assert!(b.required);
+
+		let c = Arg::from_usage("[pos]...");
+		assert_eq!(c.name, "pos");
+		assert!(c.multiple);
+		assert!(!c.required);
 	}
 
 	#[test]

src/usageparser.rs

@@ -82,6 +82,9 @@ impl<'u> Iterator for UsageParser<'u> {
                             } 
                             if self.e > self.usage.len() { return None }
 
+                            if self.e == self.usage.len() - 1 {
+                                return Some(UsageToken::Long(&self.usage[self.s..]))
+                            }
                             return Some(UsageToken::Long(&self.usage[self.s..self.e]))
                         },
                         Some(c)  => {
@@ -108,7 +111,13 @@ impl<'u> Iterator for UsageParser<'u> {
                         match self.chars.next() {
                             // longs consume one '.' so they match '.. ' whereas shorts can match '...'
                             Some('.') | Some(' ')  => { mult = true; },
-                            _          => { mult = false; break; }
+                            _          => { 
+                                // if there is no help or following space all we can match is '..'
+                                if self.e == self.usage.len() - 1 {
+                                    mult = true;
+                                }
+                                break; 
+                            }
                         }
                     }
                     if mult { return Some(UsageToken::Multiple) }