Revert "Make main_helper useful with values not from getopts."

This reverts commit b4c7e8e057.

src/main.rs

@@ -32,11 +32,11 @@ fn main() {
 
     main_helper::setup_logging(&matches);
 
-    let session = main_helper::session_from_matches(&matches);
+    let session = main_helper::create_session(&matches);
-    let credentials = main_helper::credentials_from_matches(&session, &matches);
+    let credentials = main_helper::get_credentials(&session, &matches);
     session.login(credentials).unwrap();
 
-    let player = main_helper::player_from_matches(&session, &matches);
+    let player = main_helper::create_player(&session, &matches);
 
     let spirc = SpircManager::new(session.clone(), player);
     let spirc_signal = spirc.clone();

src/main_helper.rs

@@ -55,26 +55,14 @@ pub fn add_player_arguments(opts: &mut getopts::Options) {
         .optopt("", "device", "Audio device to use. Use '?' to list options", "DEVICE");
 }
 
-pub fn session_from_matches(matches: &getopts::Matches) -> Session {
+pub fn create_session(matches: &getopts::Matches) -> Session {
-    create_session(matches.opt_str("n").unwrap(),
-                   matches.opt_str("b").as_ref().map(String::as_ref),
-                   matches.opt_str("c").as_ref().map(String::as_ref),
-                   matches.opt_str("onstart"),
-                   matches.opt_str("onstop"))
-}
-
-pub fn create_session(name: String,
-                      bitrate: Option<&str>,
-                      cache: Option<&str>,
-                      onstart: Option<String>,
-                      onstop: Option<String>)
-                      -> Session {
     info!("librespot {} ({}). Built on {}.",
              version::short_sha(),
              version::commit_date(),
              version::short_now());
 
-    let bitrate = match bitrate {
+    let name = matches.opt_str("n").unwrap();
+    let bitrate = match matches.opt_str("b").as_ref().map(String::as_ref) {
         None => Bitrate::Bitrate160, // default value
 
         Some("96") => Bitrate::Bitrate96,
@@ -86,10 +74,13 @@ pub fn create_session(name: String,
         }
     };
 
-    let cache = cache.map(|cache_location| {
+    let cache = matches.opt_str("c").map(|cache_location| {
         Box::new(DefaultCache::new(PathBuf::from(cache_location)).unwrap()) as Box<Cache + Send + Sync>
     }).unwrap_or_else(|| Box::new(NoCache) as Box<Cache + Send + Sync>);
 
+    let onstart = matches.opt_str("onstart");
+    let onstop = matches.opt_str("onstop");
+
     let config = Config {
         user_agent: version::version_string(),
         device_name: name,
@@ -101,16 +92,13 @@ pub fn create_session(name: String,
     Session::new(config, cache)
 }
 
-pub fn credentials_from_matches(session: &Session,
+pub fn get_credentials(session: &Session, matches: &getopts::Matches) -> Credentials {
-                                matches: &getopts::Matches) -> Credentials {
-    get_credentials(session, matches.opt_str("username"), matches.opt_str("password"))
-}
-
-pub fn get_credentials(session: &Session, username: Option<String>,
-                       password: Option<String>) -> Credentials {
     let credentials = session.cache().get_credentials();
 
-    match (username, password, credentials) {
+    match (matches.opt_str("username"),
+           matches.opt_str("password"),
+           credentials) {
+
         (Some(username), Some(password), _)
             => Credentials::with_password(username, password),
 
@@ -134,14 +122,11 @@ pub fn get_credentials(session: &Session, username: Option<String>,
     }
 }
 
-pub fn player_from_matches(session: &Session, matches: &getopts::Matches) -> Player {
+pub fn create_player(session: &Session, matches: &getopts::Matches) -> Player {
-    create_player(session, matches.opt_str("backend").as_ref().map(String::as_ref)
+    let backend_name = matches.opt_str("backend");
-                  , matches.opt_str("device"))
+    let device_name = matches.opt_str("device");
-}
 
-pub fn create_player(session: &Session, backend_name: Option<&str>
+    let make_backend = find_backend(backend_name.as_ref().map(AsRef::as_ref));
-                     , device_name: Option<String>) -> Player {
-    let make_backend = find_backend(backend_name);
 
     Player::new(session.clone(), move || {
         make_backend(device_name.as_ref().map(AsRef::as_ref))