Merge pull request #14 from LukasKalbertodt/dev

Version 0.2.0

Author: LukasKalbertodt

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "telegram-bot"
-version = "0.1.2"
+version = "0.2.0"
 authors = ["Lukas Kalbertodt <[email protected]>"]
 
 description = "A library for creating Telegram bots."
@@ -17,3 +17,4 @@ exclude = ["deploy.sh"]
 [dependencies]
 hyper = "*"
 rustc-serialize = "*"
+url = "*"

examples/features.rs

@@ -2,28 +2,21 @@ extern crate rustc_serialize;
 extern crate telegram_bot;
 
 use telegram_bot::*;
-use std::env;
 use rustc_serialize::json;
 
 fn main() {
-    // Fetch environment variable with bot token
-    let token = match env::var("TELEGRAM_BOT_TOKEN") {
-        Ok(tok) => tok,
-        Err(e) =>
-            panic!("Environment variable 'TELEGRAM_BOT_TOKEN' missing! {}", e),
-    };
-
     // Create bot, test simple API call and print bot information
-    let mut bot = Bot::new(token);
-    println!("getMe: {:?}", bot.get_me());
+    let mut api = Api::from_env("TELEGRAM_BOT_TOKEN").unwrap();
+    println!("getMe: {:?}", api.get_me());
+    let mut listener = api.listener(ListeningMethod::LongPoll(None));
 
     // Just to demonstrate this method. Sadly, a server listening for updates
     // is not (yet!) integrated in this library.
-    println!("Webhook: {:?}", bot.set_webhook(Some("https://example.com")));
-    println!("Webhook: {:?}", bot.set_webhook::<&str>(None));
+    println!("Webhook: {:?}", api.set_webhook(Some("https://example.com")));
+    println!("Webhook: {:?}", api.set_webhook::<&str>(None));
 
     // Fetch new updates via long poll method
-    let res = bot.long_poll(None, |bot, u| {
+    let res = listener.listen(|u| {
         // If the received update contains a message...
         if let Some(m) = u.message {
             let name = m.from.first_name + &*m.from.last_name
@@ -45,7 +38,7 @@ fn main() {
                     };
 
                     // Reply with custom Keyboard
-                    try!(bot.send_message(
+                    try!(api.send_message(
                         chat_id,
                         format!("Hi, {}!", name),
                         None, None, Some(keyboard.into())));
@@ -58,7 +51,7 @@ fn main() {
 
                     // Send chat action (this is useless here, it's just for
                     // demonstration purposes)
-                    try!(bot.send_chat_action(chat_id, ChatAction::Typing));
+                    try!(api.send_chat_action(chat_id, ChatAction::Typing));
 
                     // Calculate and send the location on the other side of the
                     // earth.
@@ -69,21 +62,21 @@ fn main() {
                         loc.longitude + 180.0
                     };
 
-                    try!(bot.send_location(chat_id, lat, lng, None, None));
+                    try!(api.send_location(chat_id, lat, lng, None, None));
                 },
                 MessageType::Contact(c) => {
                     // Print event
                     println!("<{}> send a contact: {}", name,
                         json::encode(&c).unwrap());
 
                     // Just forward the contact back to the sender...
-                    try!(bot.forward_message(chat_id, chat_id, m.message_id));
+                    try!(api.forward_message(chat_id, chat_id, m.message_id));
                 }
                 _ => {}
             }
 
         }
-        Ok(())
+        Ok(ListeningAction::Continue)
     });
 
     if let Err(e) = res {

examples/simple.rs

@@ -1,22 +1,15 @@
 extern crate telegram_bot;
 
 use telegram_bot::*;
-use std::env;
 
 fn main() {
-    // Fetch environment variable with bot token
-    let token = match env::var("TELEGRAM_BOT_TOKEN") {
-        Ok(tok) => tok,
-        Err(e) =>
-            panic!("Environment variable 'TELEGRAM_BOT_TOKEN' missing! {}", e),
-    };
-
     // Create bot, test simple API call and print bot information
-    let mut bot = Bot::new(token);
-    println!("getMe: {:?}", bot.get_me());
+    let mut api = Api::from_env("TELEGRAM_BOT_TOKEN").unwrap();
+    println!("getMe: {:?}", api.get_me());
+    let mut listener = api.listener(ListeningMethod::LongPoll(None));
 
     // Fetch new updates via long poll method
-    let res = bot.long_poll(None, |bot, u| {
+    let res = listener.listen(|u| {
         // If the received update contains a message...
         if let Some(m) = u.message {
             let name = m.from.first_name;
@@ -28,11 +21,11 @@ fn main() {
                     println!("<{}> {}", name, t);
 
                     if t == "/exit" {
-                        return Err(Error::UserInterrupt);
+                        return Ok(ListeningAction::Stop);
                     }
 
                     // Answer message with "Hi"
-                    try!(bot.send_message(
+                    try!(api.send_message(
                         m.chat.id(),
                         format!("Hi, {}! You just wrote '{}'", name, t),
                         None, None, None));
@@ -42,7 +35,7 @@ fn main() {
         }
 
         // If none of the "try!" statements returned an error: It's Ok!
-        Ok(())
+        Ok(ListeningAction::Continue)
     });
 
     // When the method `long_poll` returns, its due to an error. Check it here.

src/error.rs

@@ -1,5 +1,7 @@
 use std::fmt;
 use rustc_serialize::json;
+use std::env;
+
 /// Telegram-Bot Result
 pub type Result<T> = ::std::result::Result<T, Error>;
 
@@ -14,9 +16,15 @@ pub enum Error {
     JsonDecode(json::DecoderError),
     /// Error while encoding JSON data
     JsonEncode(json::EncoderError),
+    /// Telegram server reponsded with an error + description
     Api(String),
+    /// This should never happen (it possibly could if the telegram servers
+    /// would respond with garbage)
     InvalidState(String),
-    UserInterrupt,
+    /// Occurs, if the given bot token would not result in a valid request URL.
+    InvalidTokenFormat(::url::ParseError),
+    /// The given environment variable could not be fetched.
+    InvalidEnvironmentVar(env::VarError),
 }
 
 impl ::std::error::Error for Error {
@@ -26,9 +34,10 @@ impl ::std::error::Error for Error {
             Error::Io(ref e) => e.description(),
             Error::JsonDecode(ref e) => e.description(),
             Error::JsonEncode(ref e) => e.description(),
-            Error::Api(ref s) => &*s,
-            Error::InvalidState(ref s) => &*s,
-            Error::UserInterrupt => "user interrupt",
+            Error::Api(ref s) => &s,
+            Error::InvalidState(ref s) => &s,
+            Error::InvalidTokenFormat(ref e) => e.description(),
+            Error::InvalidEnvironmentVar(ref e) => e.description(),
         }
     }
 }
@@ -42,7 +51,8 @@ impl fmt::Display for Error {
             Error::JsonEncode(ref e) => e.fmt(f),
             Error::Api(ref s) => s.fmt(f),
             Error::InvalidState(ref s) => s.fmt(f),
-            Error::UserInterrupt => "user interrupt".fmt(f),
+            Error::InvalidTokenFormat(ref e) => e.fmt(f),
+            Error::InvalidEnvironmentVar(ref e) => e.fmt(f),
         }
     }
 }
@@ -61,3 +71,5 @@ from_impl!(::hyper::error::Error, Http);
 from_impl!(::std::io::Error, Io);
 from_impl!(json::DecoderError, JsonDecode);
 from_impl!(json::EncoderError, JsonEncode);
+from_impl!(::url::ParseError, InvalidTokenFormat);
+from_impl!(env::VarError, InvalidEnvironmentVar);