Remove argparse dependency

As we have replaced argparse with structopt, we no longer need it as a
dependency.  This patch removes the dependency from Cargo.toml and
deletes the included copy.

Delete subrepo argparse/:argparse

37 files changed, 1 insertions, 3283 deletions

diff --git a/argparse/.gitignore b/argparse/.gitignore
deleted file mode 100644
index 6ae6389..0000000
--- a/argparse/.gitignore
+++ /dev/null
@@ -1,13 +0,0 @@
-/.vagga
-*.o
-*.so
-*.rlib
-/argparse_test
-/target
-# examples
-/greeting
-/structure
-/subcommands
-
-# Cargo files
-Cargo.lock
diff --git a/argparse/.travis.yml b/argparse/.travis.yml
deleted file mode 100644
index 7ccbf43..0000000
--- a/argparse/.travis.yml
+++ /dev/null
@@ -1,34 +0,0 @@
-sudo: false
-dist: trusty
-language: rust
-
-cache:
-- cargo
-
-before_cache:
-- rm -r $TRAVIS_BUILD_DIR/target/debug
-
-jobs:
-  include:
-  - os: linux
-    rust: stable
-  - os: linux
-    rust: beta
-  - os: linux
-    rust: nightly
-
-  # deploy
-  - stage: publish
-    os: linux
-    rust: stable
-    env:
-    # CARGO_TOKEN
-    - secure: "tk6bJEv46YfZwAKYzxn9+afzEb6nGym9lo/YJgjYIolv2qsNyMLlmC8ptRSRTHwOQPd3c54Y9XYP+61miMmWjppQSjJ4yvkUqnyiYzzdxzVM5dNIbXcqO6GbTgE2rIx9BOH0c/qrmw1KW2iz8TChxgQu/vv8pmDL1kmyawVy3EE="
-    install: true
-    script: true
-
-    deploy:
-    - provider: script
-      script: 'cargo publish --verbose --token=$CARGO_TOKEN'
-      on:
-        tags: true
diff --git a/argparse/Cargo.toml b/argparse/Cargo.toml
deleted file mode 100644
index 7552373..0000000
--- a/argparse/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-
-name = "argparse"
-description = "Powerful command-line argument parsing library"
-license = "MIT"
-readme = "README.rst"
-keywords = ["command-line", "cli", "command", "argument"]
-categories = ["command-line-interface"]
-homepage = "http://github.com/tailhook/rust-argparse"
-version = "0.2.2"
-authors = ["Paul Colomiets <paul@colomiets.name>"]
-
diff --git a/argparse/LICENSE b/argparse/LICENSE
deleted file mode 100644
index 3e00de4..0000000
--- a/argparse/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2014-2015 Paul Colomiets
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/argparse/README.rst b/argparse/README.rst
deleted file mode 100644
index 8a3fca0..0000000
--- a/argparse/README.rst
+++ /dev/null
@@ -1,341 +0,0 @@
-========
-Argparse
-========
-
-The ``rust-argparse`` is command-line parsing module for rust. It's inspired
-by python's ``argparse`` module.
-
-Features:
-
-* Supports standard (GNU) option conventions
-* Properly typed values
-* Automatically generated help and usage messages
-
-Importing
-=========
-Edit your Cargo.toml to add ``rust-argparse`` to your project.
-
-.. code-block:: rust
-
-    [dependencies]
-    argparse = "0.2.2"
-
-
-Example
-=======
-
-The following code is a simple Rust program with command-line arguments:
-
-.. code-block:: rust
-
-    extern crate argparse;
-
-    use argparse::{ArgumentParser, StoreTrue, Store};
-
-    fn main() {
-        let mut verbose = false;
-        let mut name = "World".to_string();
-        {  // this block limits scope of borrows by ap.refer() method
-            let mut ap = ArgumentParser::new();
-            ap.set_description("Greet somebody.");
-            ap.refer(&mut verbose)
-                .add_option(&["-v", "--verbose"], StoreTrue,
-                "Be verbose");
-            ap.refer(&mut name)
-                .add_option(&["--name"], Store,
-                "Name for the greeting");
-            ap.parse_args_or_exit();
-        }
-
-        if verbose {
-            println!("name is {}", name);
-        }
-        println!("Hello {}!", name);
-    }
-
-Assuming the Rust code above is saved into a file ``greeting.rs``, let's see
-what we have now::
-
-    $ rustc greeting.rs
-    $ ./greeting -h
-    Usage:
-      ./greeting [OPTIONS]
-
-    Greet somebody.
-
-    Optional arguments:
-      -h, --help  Show this help message and exit
-      -v, --verbose
-                 Be verbose
-      --name NAME Name for the greeting
-    $ ./greeting
-    Hello World!
-    $ ./greeting --name Bob
-    Hello Bob!
-    $ ./greeting -v --name Alice
-    name is Alice
-    Hello Alice!
-
-
-Basic Workflow
-==============
-
-
-Create ArgumentParser
----------------------
-
-The argument parser is created empty and is built incrementally. So we create
-a mutable variable::
-
-    extern crate argparse;
-    use argparse::ArgumentParser;
-
-    let mut parser = ArgumentParser::new();
-
-
-Customize
----------
-
-There are optional customization methods. The most important one is::
-
-    parser.set_description("My command-line utility")
-
-The descripion is rewrapped to fit 80 column string nicely. Just like option
-descriptions.
-
-Add Options
------------
-
-The ``refer`` method creates a cell variable, which the result will be written
-to::
-
-    let mut verbose = false;
-    parser.refer(&mut verbose);
-
-Next we add an options which control the variable:
-For example::
-
-    parser.refer(&mut verbose)
-        .add_option(&["-v", "--verbose"], StoreTrue,
-                    "Be verbose");
-
-You may add multiple options for the same variable::
-
-    parser.refer(&mut verbose)
-        .add_option(&["-v", "--verbose"], StoreTrue,
-                    "Be verbose")
-        .add_option(&["-q", "--quiet"], StoreFalse,
-                    "Be verbose");
-
-Similarly positional arguments are added::
-
-    let mut command = String;
-    parser.refer(&mut command)
-        .add_argument("command", Store,
-                      "Command to run");
-
-
-
-Organizing Options
-------------------
-
-It's often useful to organize options into some kind of structure. You can
-easily borrow variables from the structure into option parser. For example::
-
-    struct Options {
-        verbose: bool,
-    }
-    ...
-    let mut options = Options { verbose: false };
-    parser.refer(&mut options.verbose)
-        .add_option(&["-v"], StoreTrue,
-                    "Be verbose");
-
-
-Parsing Arguments
------------------
-
-All the complex work is done in ``parser.parse_args()``. But there is
-a simpler option::
-
-    parser.parse_args_or_exit()
-
-In case you don't want argparse to exit itself, you might use the
-``parse_args`` function directly::
-
-    use std::process::exit;
-
-    match parser.parse_args() {
-        Ok(()) =>  {}
-        Err(x) => {
-            std::process::exit(x);
-        }
-    }
-
-
-ArgumentParser Methods
-======================
-
-``parser.refer<T>(var: &mut T) -> Ref``
-    Attach the variable to argument parser. The options are added to the
-    returned ``Ref`` object and modify a variable passed to the method.
-
-``parser.add_option(names: &[&str], action: TypedAction, help: &str)``
-    Add a single option which has no parameters. Most options must be added
-    by ``refer(..)`` and methods on ``Ref`` object (see below).
-
-    Example::
-
-        ap.add_option(&["-V", "--version"],
-            Print(env!("CARGO_PKG_VERSION").to_string()), "Show version");
-
-``parser.set_description(descr: &str)``
-    Set description that is at the top of help message.
-
-``parser.stop_on_first_argument(val: bool)``
-    If called with ``true``, parser will stop searching for options when first
-    non-option (the one doesn't start with ``-``) argument is encountered. This
-    is useful if you want to parse following options with another argparser or
-    external program.
-
-``parser.silence_double_dash(val: bool)``
-    If called with ``true`` (default), parser will not treat *first* double
-    dash ``--`` as positional argument. Use ``false`` if you need to add some
-    meaning to the ``--`` marker.
-
-``parser.print_usage(name: &str, writer: &mut Write)``
-    Prints usage string to stderr.
-
-``parser.print_help(name: &str, writer: &mut Write)``
-    Writes help to ``writer``, used by ``--help`` option internally.
-
-``parser.parse_args()``
-    Method that does all the dirty work. And returns ``Result``
-
-``parser.parse_args_or_exit()``
-    Method that does all the dirty work. And in case of failure just ``exit()``
-
-
-Variable Reference Methods
-==========================
-
-The ``argparse::Ref`` object is returned from ``parser.refer()``.
-The following methods are used to add and customize arguments:
-
-``option.add_option(names: &[&str], action: TypedAction, help: &str)``
-    Add an option. All items in names should be either in format ``-X`` or
-    ``--long-option`` (i.e. one dash and one char or two dashes and long name).
-    How this option will be interpreted and whether it will have an argument
-    dependes on the action. See below list of actions.
-
-``option.add_argument(name: &str, action: TypedAction, help: &str)``
-    Add a positional argument
-
-``option.metavar(var: &str)``
-    A name of the argument in usage messages (for options having argument).
-
-``option.envvar(var: &str)``
-    A name of the environment variable to get option value from. The value
-    would be parsed with ``FromStr::from_str``, just like an option having
-    ``Store`` action.
-
-``option.required()``
-    The option or argument is required (it's optional by default). If multiple
-    options or multiple arguments are defined for this reference at least one
-    of them is required.
-
-
-Actions
-=======
-
-The following actions are available out of the box. They may be used in either
-``add_option`` or ``add_argument``:
-
-``Store``
-    An option has single argument. Stores a value from command-line in a
-    variable. Any type that has the ``FromStr`` and ``Clone`` traits implemented
-    may be used.
-
-``StoreOption``
-    As ``Store``, but wrap value with ``Some`` for use with ``Option``. For
-    example:
-
-        let mut x: Option<i32> = None;
-        ap.refer(&mut x).add_option(&["-x"], StoreOption, "Set var x");
-
-``StoreConst(value)``
-    An option has no arguments. Store a hard-coded ``value`` into variable,
-    when specified. Any type with the ``Clone`` trait implemented may be used.
-
-``PushConst(value)``
-    An option has no arguments. Push a hard-coded ``value`` into variable,
-    when specified. Any type which has the ``Clone`` type implemented may be
-    used. Option might used for a list of operations to perform, when ``required``
-    is set for this variable, at least one operation is required.
-
-``StoreTrue``
-    Stores boolean ``true`` value in a variable.
-    (shortcut for ``StoreConst(true)``)
-
-``StoreFalse``
-    Stores boolean ``false`` value in a variable.
-    (shortcut for ``StoreConst(false)``)
-
-
-``IncrBy(num)``
-    An option has no arguments. Increments the value stored in a variable by a
-    value ``num``. Any type which has the ``Add`` and ``Clone`` traits may be used.
-
-``DecrBy(nym)``
-    Decrements the value stored in a variable by a value ``num``. Any type
-    which has the ``Add`` and ``Clone`` traits may be used.
-
-``Collect``
-    When used for an ``--option``, requires single argument. When used for a
-    positional argument consumes all remaining arguments. Parsed options are
-    added to the list. I.e. a ``Collect`` action requires a
-    ``Vec<int>`` variable. Parses arguments using ``FromStr`` trait.
-
-``List``
-    When used for positional argument, works the same as ``List``. When used
-    as an option, consumes all remaining arguments.
-
-    Note the usage of ``List`` is strongly discouraged, because of complex
-    rules below. Use ``Collect`` and positional options if possible. But usage
-    of ``List`` action may be useful if you need shell expansion of anything
-    other than last positional argument.
-
-    Let's learn rules by example. For the next options::
-
-        ap.refer(&mut lst1).add_option(&["-X", "--xx"], List, "List1");
-        ap.refer(&mut lst2).add_argument("yy", List, "List2");
-
-    The following command line::
-
-        ./run 1 2 3 -X 4 5 6
-
-    Will return ``[1, 2, 3]`` in the ``lst1`` and the ``[4,5,6]`` in the
-    ``lst2``.
-
-    Note that using when using ``=`` or equivalent short option mode, the
-    'consume all' mode is not enabled. I.e. in the following command-line::
-
-        ./run 1 2 -X3 4 --xx=5 6
-
-    The ``lst1`` has ``[3, 5]`` and ``lst2`` has ``[1, 2, 4, 6]``.
-    The argument consuming also stops on ``--`` or the next option::
-
-        ./run: -X 1 2 3 -- 4 5 6
-        ./run: -X 1 2 --xx=3 4 5 6
-
-    Both of the above parse ``[4, 5, 6]`` as ``lst1`` and
-    the ``[1, 2, 3]`` as the ``lst2``.
-
-``Print(value)``
-    Print the text and exit (with status ``0``). Useful for ``--version``
-    option::
-
-        ap.add_option(&["-V", "--version"],
-            Print(env!("CARGO_PKG_VERSION").to_string()), "Show version");
-
-
diff --git a/argparse/bulk.yaml b/argparse/bulk.yaml
deleted file mode 100644
index 73a7d02..0000000
--- a/argparse/bulk.yaml
+++ /dev/null
@@ -1,11 +0,0 @@
-minimum-bulk: v0.4.5
-
-versions:
-
-- file: Cargo.toml
-  block-start: ^\[package\]
-  block-end: ^\[.*\]
-  regex: ^version\s*=\s*"(\S+)"
-
-- file: README.rst
-  regex: ^\s*argparse\s*=\s*"(\S+)"
diff --git a/argparse/examples/greeting.rs b/argparse/examples/greeting.rs
deleted file mode 100644
index 77e719c..0000000
--- a/argparse/examples/greeting.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-extern crate argparse;
-
-use argparse::{ArgumentParser, StoreTrue, Store, Print};
-
-fn main() {
-    let mut verbose = false;
-    let mut name = "World".to_string();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Greet somebody.");
-        ap.add_option(&["-V", "--version"],
-            Print(env!("CARGO_PKG_VERSION").to_string()), "Show version");
-        ap.refer(&mut verbose)
-            .add_option(&["-v", "--verbose"], StoreTrue,
-            "Be verbose");
-        ap.refer(&mut name)
-            .add_option(&["--name"], Store,
-            "Name for the greeting");
-        ap.parse_args_or_exit();
-    }
-
-    if verbose {
-        println!("name is {}", name);
-    }
-    println!("Hello {}!", name);
-}
diff --git a/argparse/examples/structure.rs b/argparse/examples/structure.rs
deleted file mode 100644
index 59b9345..0000000
--- a/argparse/examples/structure.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-extern crate argparse;
-
-use std::process::exit;
-
-use argparse::{ArgumentParser, StoreTrue, Store};
-
-struct Options {
-    verbose: bool,
-    name: String,
-}
-
-fn main() {
-    let mut options = Options {
-        verbose: false,
-        name: "World".to_string(),
-    };
-    {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Greet somebody.");
-        ap.refer(&mut options.verbose)
-            .add_option(&["-v", "--verbose"], StoreTrue,
-            "Be verbose");
-        ap.refer(&mut options.name)
-            .add_option(&["--name"], Store,
-            "Name for the greeting");
-        match ap.parse_args() {
-            Ok(()) => {}
-            Err(x) => {
-                exit(x);
-            }
-        }
-    }
-
-    if options.verbose {
-        println!("name is {}", options.name);
-    }
-    println!("Hello {}!", options.name);
-}
diff --git a/argparse/examples/subcommands.rs b/argparse/examples/subcommands.rs
deleted file mode 100644
index 8fb061a..0000000
--- a/argparse/examples/subcommands.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use std::str::FromStr;
-use std::io::{stdout, stderr};
-extern crate argparse;
-
-use argparse::{ArgumentParser, StoreTrue, Store, List};
-
-#[allow(non_camel_case_types)]
-#[derive(Debug)]
-enum Command {
-    play,
-    record,
-}
-
-impl FromStr for Command {
-    type Err = ();
-    fn from_str(src: &str) -> Result<Command, ()> {
-        return match src {
-            "play" => Ok(Command::play),
-            "record" => Ok(Command::record),
-            _ => Err(()),
-        };
-    }
-}
-
-
-
-fn play_command(verbose: bool, args: Vec<String>) {
-    let mut output = "".to_string();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Plays a sound");
-        ap.refer(&mut output)
-            .add_option(&["--output"], Store,
-                r#"Output sink to play to"#);
-        match ap.parse(args, &mut stdout(), &mut stderr()) {
-            Ok(()) =>  {}
-            Err(x) => {
-                std::process::exit(x);
-            }
-        }
-    }
-    println!("Verbosity: {}, Output: {}", verbose, output);
-}
-
-fn record_command(verbose: bool, args: Vec<String>) {
-    let mut input = "".to_string();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Records a sound");
-        ap.refer(&mut input)
-            .add_option(&["--input"], Store,
-                r#"Output source to record from"#);
-        match ap.parse(args, &mut stdout(), &mut stderr()) {
-            Ok(()) =>  {}
-            Err(x) => {
-                std::process::exit(x);
-            }
-        }
-    }
-    println!("Verbosity: {}, Input: {}", verbose, input);
-}
-
-fn main() {
-    let mut verbose = false;
-    let mut subcommand = Command::play;
-    let mut args = vec!();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.set_description("Plays or records sound");
-        ap.refer(&mut verbose)
-            .add_option(&["-v", "--verbose"], StoreTrue,
-            "Be verbose");
-        ap.refer(&mut subcommand).required()
-            .add_argument("command", Store,
-                r#"Command to run (either "play" or "record")"#);
-        ap.refer(&mut args)
-            .add_argument("arguments", List,
-                r#"Arguments for command"#);
-        ap.stop_on_first_argument(true);
-        ap.parse_args_or_exit();
-    }
-
-    args.insert(0, format!("subcommand {:?}", subcommand));
-    match subcommand {
-        Command::play => play_command(verbose, args),
-        Command::record => record_command(verbose, args),
-    }
-}
diff --git a/argparse/src/action.rs b/argparse/src/action.rs
deleted file mode 100644
index c3a0aff..0000000
--- a/argparse/src/action.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-
-pub enum ParseResult {
-    Parsed,
-    Help,
-    Exit,
-    Error(String),
-}
-
-
-pub enum Action<'a> {
-    Flag(Box<IFlagAction + 'a>),
-    Single(Box<IArgAction + 'a>),
-    Push(Box<IArgsAction + 'a>),
-    Many(Box<IArgsAction + 'a>),
-}
-
-pub trait TypedAction<T> {
-    fn bind<'x>(&self, Rc<RefCell<&'x mut T>>) -> Action<'x>;
-}
-
-pub trait IFlagAction {
-    fn parse_flag(&self) -> ParseResult;
-}
-
-pub trait IArgAction {
-    fn parse_arg(&self, arg: &str) -> ParseResult;
-}
-
-pub trait IArgsAction {
-    fn parse_args(&self, args: &[&str]) -> ParseResult;
-}
diff --git a/argparse/src/bool.rs b/argparse/src/bool.rs
deleted file mode 100644
index 6ada458..0000000
--- a/argparse/src/bool.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-
-use super::action::Action;
-use super::action::TypedAction;
-use super::action::Action::Flag;
-use super::generic::StoreConstAction;
-use super::{StoreTrue, StoreFalse};
-
-
-impl TypedAction<bool> for StoreTrue {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut bool>>) -> Action<'x> {
-        return Flag(Box::new(StoreConstAction { cell: cell, value: true }));
-    }
-}
-
-impl TypedAction<bool> for StoreFalse {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut bool>>) -> Action<'x> {
-        return Flag(Box::new(StoreConstAction { cell: cell, value: false }));
-    }
-}
-
diff --git a/argparse/src/custom.rs b/argparse/src/custom.rs
deleted file mode 100644
index d002ffe..0000000
--- a/argparse/src/custom.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-
-use super::{Parse, ParseOption, ParseList, ParseCollect, FromCommandLine};
-use super::action::Action;
-use super::action::{TypedAction, IArgAction, IArgsAction};
-use super::action::ParseResult;
-use super::action::ParseResult::{Parsed, Error};
-use super::action::Action::{Single, Push, Many};
-
-pub struct ParseAction<'a, T: 'a> {
-    pub cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct ParseOptionAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Option<T>>>,
-}
-
-pub struct ParseListAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Vec<T>>>,
-}
-
-impl<T: 'static + FromCommandLine> TypedAction<T> for Parse {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        return Single(Box::new(ParseAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromCommandLine> TypedAction<Option<T>> for ParseOption {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Option<T>>>) -> Action<'x> {
-        return Single(Box::new(ParseOptionAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromCommandLine + Clone> TypedAction<Vec<T>> for ParseList {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Many(Box::new(ParseListAction { cell: cell }));
-    }
-}
-
-impl<T> TypedAction<Vec<T>> for ParseCollect
-    where T: 'static + FromCommandLine + Clone
-{
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Push(Box::new(ParseListAction { cell: cell }))
-    }
-}
-
-impl<'a, T: FromCommandLine> IArgAction for ParseAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromCommandLine::from_argument(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = x;
-                return Parsed;
-            }
-            Err(error) => {
-                return Error(format!("Bad value {:?}: {}", arg, error));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromCommandLine> IArgAction for ParseOptionAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromCommandLine::from_argument(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = Some(x);
-                return Parsed;
-            }
-            Err(error) => {
-                return Error(format!("Bad value {:?}: {}", arg, error));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromCommandLine + Clone> IArgsAction for ParseListAction<'a, T> {
-    fn parse_args(&self, args: &[&str]) -> ParseResult {
-        let mut result = vec!();
-        for arg in args.iter() {
-            match FromCommandLine::from_argument(*arg) {
-                Ok(x) => {
-                    result.push(x);
-                }
-                Err(error) => {
-                    return Error(format!("Bad value {:?}: {}", arg, error));
-                }
-            }
-        }
-        **self.cell.borrow_mut() = result;
-        return Parsed;
-    }
-}
-
-
diff --git a/argparse/src/from_cli.rs b/argparse/src/from_cli.rs
deleted file mode 100644
index 7ea6d58..0000000
--- a/argparse/src/from_cli.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use std::str::FromStr;
-use std::path::PathBuf;
-use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr};
-
-use super::FromCommandLine;
-
-
-impl FromCommandLine for PathBuf {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        Ok(From::from(s))
-    }
-}
-
-impl FromCommandLine for f32 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for f64 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-
-// TODO(tailhook) implement various radices for integer values
-impl FromCommandLine for isize {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for i8 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for i16 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for i32 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for i64 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for usize {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for u8 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for u16 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for u32 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for u64 {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for bool {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for String {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|_| unreachable!())
-    }
-}
-impl FromCommandLine for Ipv4Addr {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for Ipv6Addr {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
-impl FromCommandLine for SocketAddr {
-    fn from_argument(s: &str) -> Result<Self, String> {
-        FromStr::from_str(s).map_err(|e| format!("{:?}", e))
-    }
-}
diff --git a/argparse/src/generic.rs b/argparse/src/generic.rs
deleted file mode 100644
index 1b1b7dc..0000000
--- a/argparse/src/generic.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use std::cell::RefCell;
-use std::str::FromStr;
-use std::rc::Rc;
-
-use super::{StoreConst, Store, StoreOption, List, Collect, PushConst};
-use super::action::Action;
-use super::action::{TypedAction, IFlagAction, IArgAction, IArgsAction};
-use super::action::ParseResult;
-use super::action::ParseResult::{Parsed, Error};
-use super::action::Action::{Flag, Single, Push, Many};
-
-pub struct StoreConstAction<'a, T: 'a> {
-    pub value: T,
-    pub cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct PushConstAction<'a, T: 'a> {
-    pub value: T,
-    pub cell: Rc<RefCell<&'a mut Vec<T>>>,
-}
-
-pub struct StoreAction<'a, T: 'a> {
-    pub cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct StoreOptionAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Option<T>>>,
-}
-
-pub struct ListAction<'a, T: 'a> {
-    cell: Rc<RefCell<&'a mut Vec<T>>>,
-}
-
-impl<T: 'static + Clone> TypedAction<T> for StoreConst<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        let StoreConst(ref val) = *self;
-        return Flag(Box::new(StoreConstAction { cell: cell, value: val.clone() }));
-    }
-}
-
-impl<T: 'static + Clone> TypedAction<Vec<T>> for PushConst<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        let PushConst(ref val) = *self;
-        return Flag(Box::new(PushConstAction { cell: cell, value: val.clone() }));
-    }
-}
-
-impl<T: 'static + FromStr> TypedAction<T> for Store {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        return Single(Box::new(StoreAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr> TypedAction<Option<T>> for StoreOption {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Option<T>>>) -> Action<'x> {
-        return Single(Box::new(StoreOptionAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr + Clone> TypedAction<Vec<T>> for List {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Many(Box::new(ListAction { cell: cell }));
-    }
-}
-
-impl<T: 'static + FromStr + Clone> TypedAction<Vec<T>> for Collect {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut Vec<T>>>) -> Action<'x> {
-        return Push(Box::new(ListAction { cell: cell }));
-    }
-}
-
-impl<'a, T: Clone> IFlagAction for StoreConstAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let mut targ = self.cell.borrow_mut();
-        **targ = self.value.clone();
-        return Parsed;
-    }
-}
-
-impl<'a, T: Clone> IFlagAction for PushConstAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let mut targ = self.cell.borrow_mut();
-        targ.push(self.value.clone());
-        return Parsed;
-    }
-}
-
-impl<'a, T: FromStr> IArgAction for StoreAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromStr::from_str(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = x;
-                return Parsed;
-            }
-            Err(_) => {
-                return Error(format!("Bad value {}", arg));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromStr> IArgAction for StoreOptionAction<'a, T> {
-    fn parse_arg(&self, arg: &str) -> ParseResult {
-        match FromStr::from_str(arg) {
-            Ok(x) => {
-                **self.cell.borrow_mut() = Some(x);
-                return Parsed;
-            }
-            Err(_) => {
-                return Error(format!("Bad value {}", arg));
-            }
-        }
-    }
-}
-
-impl<'a, T: FromStr + Clone> IArgsAction for ListAction<'a, T> {
-    fn parse_args(&self, args: &[&str]) -> ParseResult {
-        let mut result = vec!();
-        for arg in args.iter() {
-            match FromStr::from_str(*arg) {
-                Ok(x) => {
-                    result.push(x);
-                }
-                Err(_) => {
-                    return Error(format!("Bad value {}", arg));
-                }
-            }
-        }
-        **self.cell.borrow_mut() = result;
-        return Parsed;
-    }
-}
-
diff --git a/argparse/src/help.rs b/argparse/src/help.rs
deleted file mode 100644
index c7145be..0000000
--- a/argparse/src/help.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use std::str::CharIndices;
-use std::io::Result as IoResult;
-use std::io::Write;
-
-use super::action::{IFlagAction, ParseResult};
-use super::action::ParseResult::Help;
-
-pub struct HelpAction;
-
-impl IFlagAction for HelpAction {
-    fn parse_flag(&self) -> ParseResult {
-        return Help;
-    }
-}
-
-
-struct WordsIter<'a> {
-    data: &'a str,
-    iter: CharIndices<'a>,
-}
-
-impl<'a> WordsIter<'a> {
-    fn new(data: &'a str) -> WordsIter<'a> {
-        return WordsIter {
-            data: data,
-            iter: data.char_indices(),
-            };
-    }
-}
-
-impl<'a> Iterator for WordsIter<'a> {
-    type Item = &'a str;
-    fn next(&mut self) -> Option<&'a str> {
-        let word_start;
-        loop {
-            let (idx, ch) = match self.iter.next() {
-                None => return None,
-                Some((idx, ch)) => ((idx, ch)),
-            };
-            match ch {
-                ' ' | '\t' | '\r' | '\n' => continue,
-                _ => {
-                    word_start = idx;
-                    break;
-                }
-            }
-        }
-        loop {
-            let (idx, ch) = match self.iter.next() {
-                None => break,
-                Some((idx, ch)) => ((idx, ch)),
-            };
-            match ch {
-                ' ' | '\t' | '\r' | '\n' => {
-                    return Some(&self.data[word_start..idx]);
-                }
-                _ => continue,
-            }
-        }
-        return Some(&self.data[word_start..self.data.len()]);
-    }
-}
-
-pub fn wrap_text(buf: &mut Write, data: &str, width: usize, indent: usize)
-    -> IoResult<()>
-{
-    let mut witer = WordsIter::new(data);
-    let mut off = indent;
-    match witer.next() {
-        None => {
-            return Ok(());
-        }
-        Some(word) => {
-            try!(buf.write(word.as_bytes()));
-            off += word.len();
-        }
-    }
-    for word in witer {
-        if off + word.len() + 1 > width {
-            try!(buf.write(b"\n"));
-            for _ in 0..indent {
-                try!(buf.write(b" "));
-            }
-            off = indent;
-        } else {
-            try!(buf.write(b" "));
-            off += 1;
-        }
-        try!(buf.write(word.as_bytes()));
-        off += word.len();
-    }
-    return Ok(());
-}
diff --git a/argparse/src/lib.rs b/argparse/src/lib.rs
deleted file mode 100644
index 62b0cf9..0000000
--- a/argparse/src/lib.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#![crate_name = "argparse"]
-#![crate_type = "lib"]
-
-pub use self::parser::{ArgumentParser, Ref};
-
-pub mod action;
-pub mod parser;
-mod generic;
-mod custom;
-mod help;
-mod print;
-
-mod bool;
-mod num;
-mod from_cli;
-
-pub trait FromCommandLine: Sized {
-    fn from_argument(s: &str) -> Result<Self, String>;
-}
-
-// TODO(tailhook) make consts
-pub struct StoreTrue;
-pub struct StoreFalse;
-
-pub struct StoreConst<T>(pub T);
-
-pub struct PushConst<T>(pub T);
-
-pub struct Store;
-pub struct Parse;
-
-pub struct StoreOption;
-pub struct ParseOption;
-
-pub struct List;
-pub struct ParseList;
-
-pub struct Collect;
-pub struct ParseCollect;
-
-/// Print string and exit with status 0
-///
-/// Particularly useful for `--version` option and similar
-pub struct Print(pub String);
-
-pub struct IncrBy<T>(pub T);
-
-pub struct DecrBy<T>(pub T);
-
-
-#[cfg(test)] mod test_parser;
-#[cfg(test)] mod test_bool;
-#[cfg(test)] mod test_int;
-#[cfg(test)] mod test_float;
-#[cfg(test)] mod test_str;
-#[cfg(test)] mod test_enum;
-#[cfg(test)] mod test_pos;
-#[cfg(test)] mod test_many;
-#[cfg(test)] mod test_optional;
-#[cfg(test)] mod test_usage;
-#[cfg(test)] mod test_help;
-#[cfg(test)] mod test_env;
-#[cfg(test)] mod test_const;
-#[cfg(test)] mod test_path;
diff --git a/argparse/src/num.rs b/argparse/src/num.rs
deleted file mode 100644
index 9f34de7..0000000
--- a/argparse/src/num.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::ops::{Add, Sub};
-
-use super::{IncrBy, DecrBy};
-use super::action::{TypedAction, Action, ParseResult};
-use super::action::ParseResult::Parsed;
-use super::action::IFlagAction;
-use super::action::Action::Flag;
-
-pub struct IncrByAction<'a, T: 'a> {
-    delta: T,
-    cell: Rc<RefCell<&'a mut T>>,
-}
-
-pub struct DecrByAction<'a, T: 'a> {
-    delta: T,
-    cell: Rc<RefCell<&'a mut T>>,
-}
-
-impl<T: 'static + Add<Output = T> + Clone> TypedAction<T> for IncrBy<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        let IncrBy(ref delta) = *self;
-        return Flag(Box::new(IncrByAction { cell: cell, delta: delta.clone() }));
-    }
-}
-
-impl<T: 'static + Sub<Output = T> + Clone> TypedAction<T> for DecrBy<T> {
-    fn bind<'x>(&self, cell: Rc<RefCell<&'x mut T>>) -> Action<'x> {
-        let DecrBy(ref delta) = *self;
-        return Flag(Box::new(DecrByAction { cell: cell, delta: delta.clone() }));
-    }
-}
-
-impl<'a, T: Add<Output = T> + Clone> IFlagAction for IncrByAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let oldval = {
-            let targ = self.cell.borrow();
-            targ.clone()
-        };
-        let mut targ = self.cell.borrow_mut();
-        **targ = oldval + self.delta.clone();
-        return Parsed;
-    }
-}
-
-impl<'a, T: Sub<Output = T> + Clone> IFlagAction for DecrByAction<'a, T> {
-    fn parse_flag(&self) -> ParseResult {
-        let oldval = {
-            let targ = self.cell.borrow();
-            targ.clone()
-        };
-        let mut targ = self.cell.borrow_mut();
-        **targ = oldval - self.delta.clone();
-        return Parsed;
-    }
-}
-
diff --git a/argparse/src/parser.rs b/argparse/src/parser.rs
deleted file mode 100644
index ac7e3da..0000000
--- a/argparse/src/parser.rs
+++ /dev/null
@@ -1,967 +0,0 @@
-use std::env;
-use std::io::{Write};
-use std::io::Result as IoResult;
-use std::io::{stdout, stderr};
-use std::rc::Rc;
-use std::cell::RefCell;
-use std::iter::Peekable;
-use std::slice::Iter;
-use std::hash::Hash;
-use std::hash::Hasher;
-use std::str::FromStr;
-use std::process::exit;
-
-#[allow(unused_imports)] #[allow(deprecated)]
-use std::ascii::AsciiExt;
-
-use std::collections::HashMap;
-use std::collections::hash_map::Entry;
-use std::collections::HashSet;
-
-use super::action::{Action, ParseResult};
-use super::action::ParseResult::{Parsed, Help, Exit, Error};
-use super::action::TypedAction;
-use super::action::Action::{Flag, Single, Push, Many};
-use super::action::IArgAction;
-use super::generic::StoreAction;
-use super::help::{HelpAction, wrap_text};
-use action::IFlagAction;
-
-use self::ArgumentKind::{Positional, ShortOption, LongOption, Delimiter};
-
-
-static OPTION_WIDTH: usize = 24;
-static TOTAL_WIDTH: usize = 79;
-
-
-enum ArgumentKind {
-    Positional,
-    ShortOption,
-    LongOption,
-    Delimiter, // Barely "--"
-}
-
-
-impl ArgumentKind {
-    fn check(name: &str) -> ArgumentKind {
-        let mut iter = name.chars();
-        let char1 = iter.next();
-        let char2 = iter.next();
-        let char3 = iter.next();
-        return match char1 {
-            Some('-') => match char2 {
-                Some('-') => match char3 {
-                        Some(_) => LongOption, // --opt
-                        None => Delimiter,  // just --
-                },
-                Some(_) => ShortOption,  // -opts
-                None => Positional,  // single dash
-            },
-            Some(_) | None => Positional,
-        }
-    }
-}
-
-struct GenericArgument<'parser> {
-    id: usize,
-    varid: usize,
-    name: &'parser str,
-    help: &'parser str,
-    action: Action<'parser>,
-}
-
-struct GenericOption<'parser> {
-    id: usize,
-    varid: Option<usize>,
-    names: Vec<&'parser str>,
-    help: &'parser str,
-    action: Action<'parser>,
-}
-
-struct EnvVar<'parser> {
-    varid: usize,
-    name: &'parser str,
-    action: Box<IArgAction + 'parser>,
-}
-
-impl<'a> Hash for GenericOption<'a> {
-    fn hash<H>(&self, state: &mut H) where H: Hasher {
-        self.id.hash(state);
-    }
-}
-
-impl<'a> PartialEq for GenericOption<'a> {
-    fn eq(&self, other: &GenericOption<'a>) -> bool {
-        return self.id == other.id;
-    }
-}
-
-impl<'a> Eq for GenericOption<'a> {}
-
-impl<'a> Hash for GenericArgument<'a> {
-    fn hash<H>(&self, state: &mut H) where H: Hasher {
-        self.id.hash(state);
-    }
-}
-
-impl<'a> PartialEq for GenericArgument<'a> {
-    fn eq(&self, other: &GenericArgument<'a>) -> bool {
-        return self.id == other.id;
-    }
-}
-
-impl<'a> Eq for GenericArgument<'a> {}
-
-pub struct Var {
-    id: usize,
-    metavar: String,
-    required: bool,
-}
-
-impl Hash for Var {
-    fn hash<H>(&self, state: &mut H) where H: Hasher {
-        self.id.hash(state);
-    }
-}
-
-impl PartialEq for Var {
-    fn eq(&self, other: &Var) -> bool {
-        return self.id == other.id;
-    }
-}
-
-impl Eq for Var {}
-
-struct Context<'ctx, 'parser: 'ctx> {
-    parser: &'ctx ArgumentParser<'parser>,
-    set_vars: HashSet<usize>,
-    list_options: HashMap<Rc<GenericOption<'parser>>, Vec<&'ctx str>>,
-    list_arguments: HashMap<Rc<GenericArgument<'parser>>, Vec<&'ctx str>>,
-    arguments: Vec<&'ctx str>,
-    iter: Peekable<Iter<'ctx, String>>,
-    stderr: &'ctx mut (Write + 'ctx),
-}
-
-impl<'a, 'b> Context<'a, 'b> {
-
-    fn parse_option(&mut self, opt: Rc<GenericOption<'b>>,
-        optarg: Option<&'a str>)
-        -> ParseResult
-    {
-        let value = match optarg {
-            Some(value) => value,
-            None => match self.iter.next() {
-                Some(value) => {
-                    &value[..]
-                }
-                None => {
-                    return match opt.action {
-                        Many(_) => Parsed,
-                        _ => Error(format!(
-                            // TODO(tailhook) is {:?} ok?
-                            "Option {:?} requires an argument", opt.names)),
-                    };
-                }
-            },
-        };
-        match opt.varid {
-            Some(varid) => { self.set_vars.insert(varid); }
-            None => {}
-        }
-        match opt.action {
-            Single(ref action) => {
-                return action.parse_arg(value);
-            }
-            Push(_) => {
-                (match self.list_options.entry(opt.clone()) {
-                    Entry::Occupied(occ) => occ.into_mut(),
-                    Entry::Vacant(vac) => vac.insert(Vec::new()),
-                }).push(value);
-                return Parsed;
-            }
-            Many(_) => {
-                let vec = match self.list_options.entry(opt.clone()) {
-                    Entry::Occupied(occ) => occ.into_mut(),
-                    Entry::Vacant(vac) => vac.insert(Vec::new()),
-                };
-                vec.push(value);
-                match optarg {
-                    Some(_) => return Parsed,
-                    _ => {}
-                }
-                loop {
-                    match self.iter.peek() {
-                        None => { break; }
-                        Some(arg) if arg.starts_with("-") => {
-                            break;
-                        }
-                        Some(value) => {
-                            vec.push(&value[..]);
-                        }
-                    }
-                    self.iter.next();
-                }
-                return Parsed;
-            }
-            _ => panic!(),
-        };
-    }
-
-    fn parse_long_option(&mut self, arg: &'a str) -> ParseResult {
-        let mut equals_iter = arg.splitn(2, '=');
-        let optname = equals_iter.next().unwrap();
-        let valueref = equals_iter.next();
-        let opt = self.parser.long_options.get(&optname.to_string());
-        match opt {
-            Some(opt) => {
-                match opt.action {
-                    Flag(ref action) => {
-                        match valueref {
-                            Some(_) => {
-                                return Error(format!(
-                                    "Option {} does not accept an argument",
-                                    optname));
-                            }
-                            None => {
-                                match opt.varid {
-                                    Some(varid) => {
-                                        self.set_vars.insert(varid);
-                                    }
-                                    None => {}
-                                }
-                                return action.parse_flag();
-                            }
-                        }
-                    }
-                    Single(_) | Push(_) | Many(_) => {
-                        return self.parse_option(opt.clone(), valueref);
-                    }
-                }
-            }
-            None => {
-                return Error(format!("Unknown option {}", arg));
-            }
-        }
-    }
-
-    fn parse_short_options<'x>(&'x mut self, arg: &'a str) -> ParseResult {
-        let mut iter = arg.char_indices();
-        iter.next();
-        for (idx, ch) in iter {
-            let opt = match self.parser.short_options.get(&ch) {
-                Some(opt) => { opt }
-                None => {
-                    return Error(format!("Unknown short option \"{}\"", ch));
-                }
-            };
-            let res = match opt.action {
-                Flag(ref action) => {
-                    match opt.varid {
-                        Some(varid) => { self.set_vars.insert(varid); }
-                        None => {}
-                    }
-                    action.parse_flag()
-                }
-                Single(_) | Push(_) | Many(_) => {
-                    let value;
-                    if idx + 1 < arg.len() {
-                        value = Some(&arg[idx+1..arg.len()]);
-                    } else {
-                        value = None;
-                    }
-                    return self.parse_option(opt.clone(), value);
-                }
-            };
-            match res {
-                Parsed => { continue; }
-                x => { return x; }
-            }
-        }
-        return Parsed;
-    }
-
-    fn postpone_argument(&mut self, arg: &'a str) {
-        self.arguments.push(arg);
-    }
-
-    fn parse_options(&mut self) -> ParseResult {
-        self.iter.next();  // Command name
-        loop {
-            let next = self.iter.next();
-            let arg = match next {
-                Some(arg) => { arg }
-                None => { break; }
-            };
-            let res = match ArgumentKind::check(&arg[..]) {
-                Positional => {
-                    self.postpone_argument(&arg[..]);
-                    if self.parser.stop_on_first_argument {
-                        break;
-                    }
-                    continue;
-                }
-                LongOption => self.parse_long_option(&arg[..]),
-                ShortOption => self.parse_short_options(&arg[..]),
-                Delimiter => {
-                    if !self.parser.silence_double_dash {
-                        self.postpone_argument("--");
-                    }
-                    break;
-                }
-            };
-            match res {
-                Parsed => continue,
-                _ => return res,
-            }
-        }
-
-        loop {
-            match self.iter.next() {
-                None => break,
-                Some(arg) => self.postpone_argument(&arg[..]),
-            }
-        }
-        return Parsed;
-    }
-
-    fn parse_arguments(&mut self) -> ParseResult {
-        let mut pargs = self.parser.arguments.iter();
-        for arg in self.arguments.iter() {
-            let opt;
-            loop {
-                match pargs.next() {
-                    Some(option) => {
-                        if self.set_vars.contains(&option.varid) {
-                            continue;
-                        }
-                        opt = option;
-                        break;
-                    }
-                    None => match self.parser.catchall_argument {
-                        Some(ref option) => {
-                            opt = option;
-                            break;
-                        }
-                        None => return Error(format!(
-                            "Unexpected argument {}", arg)),
-                    }
-                };
-            }
-            let res = match opt.action {
-                Single(ref act) => {
-                    self.set_vars.insert(opt.varid);
-                    act.parse_arg(*arg)
-                },
-                Many(_) | Push(_) => {
-                    (match self.list_arguments.entry(opt.clone()) {
-                        Entry::Occupied(occ) => occ.into_mut(),
-                        Entry::Vacant(vac) => vac.insert(Vec::new()),
-                    }).push(*arg);
-                    Parsed
-                },
-                _ => unreachable!(),
-            };
-            match res {
-                Parsed => continue,
-                _ => return res,
-            }
-        }
-        return Parsed;
-    }
-
-    fn parse_list_vars(&mut self) -> ParseResult {
-        for (opt, lst) in self.list_options.iter() {
-            match opt.action {
-                Push(ref act) | Many(ref act) => {
-                    let res = act.parse_args(&lst[..]);
-                    match res {
-                        Parsed => continue,
-                        _ => return res,
-                    }
-                }
-                _ => panic!(),
-            }
-        }
-        for (opt, lst) in self.list_arguments.iter() {
-            match opt.action {
-                Push(ref act) | Many(ref act) => {
-                    let res = act.parse_args(&lst[..]);
-                    match res {
-                        Parsed => continue,
-                        _ => return res,
-                    }
-                }
-                _ => panic!(),
-            }
-        }
-        return Parsed;
-    }
-
-    fn parse_env_vars(&mut self) -> ParseResult {
-        for evar in self.parser.env_vars.iter() {
-            match env::var(evar.name) {
-                Ok(val) => {
-                    match evar.action.parse_arg(&val[..]) {
-                        Parsed => {
-                            self.set_vars.insert(evar.varid);
-                            continue;
-                        }
-                        Error(err) => {
-                            write!(self.stderr,
-                                "WARNING: Environment variable {}: {}\n",
-                                evar.name, err).ok();
-                        }
-                        _ => unreachable!(),
-                    }
-                }
-                Err(_) => {}
-            }
-        }
-        return Parsed;
-    }
-
-    fn check_required(&mut self) -> ParseResult {
-        // Check for required arguments
-        for var in self.parser.vars.iter() {
-            if var.required && !self.set_vars.contains(&var.id) {
-                // First try positional arguments
-                for opt in self.parser.arguments.iter() {
-                    if opt.varid == var.id {
-                        return Error(format!(
-                            "Argument {} is required", opt.name));
-                    }
-                }
-                // Then options
-                let mut all_options = vec!();
-                for opt in self.parser.options.iter() {
-                    match opt.varid {
-                        Some(varid) if varid == var.id => {}
-                        _ => { continue }
-                    }
-                    all_options.extend(opt.names.clone().into_iter());
-                }
-                if all_options.len() > 1 {
-                    return Error(format!(
-                        "One of the options {:?} is required", all_options));
-                } else if all_options.len() == 1 {
-                    return Error(format!(
-                        "Option {:?} is required", all_options));
-                }
-                // Then envvars
-                for envvar in self.parser.env_vars.iter() {
-                    if envvar.varid == var.id {
-                        return Error(format!(
-                            "Environment var {} is required", envvar.name));
-                    }
-                }
-            }
-        }
-        return Parsed;
-    }
-
-    fn parse(parser: &ArgumentParser, args: &Vec<String>, stderr: &mut Write)
-        -> ParseResult
-    {
-        let mut ctx = Context {
-            parser: parser,
-            iter: args.iter().peekable(),
-            set_vars: HashSet::new(),
-            list_options: HashMap::new(),
-            list_arguments: HashMap::new(),
-            arguments: Vec::new(),
-            stderr: stderr,
-        };
-
-        match ctx.parse_env_vars() {
-            Parsed => {}
-            x => { return x; }
-        }
-
-        match ctx.parse_options() {
-            Parsed => {}
-            x => { return x; }
-        }
-
-        match ctx.parse_arguments() {
-            Parsed => {}
-            x => { return x; }
-        }
-
-        match ctx.parse_list_vars() {
-            Parsed => {}
-            x => { return x; }
-        }
-
-        match ctx.check_required() {
-            Parsed => {}
-            x => { return x; }
-        }
-
-        return Parsed;
-    }
-}
-
-pub struct Ref<'parser:'refer, 'refer, T: 'parser> {
-    cell: Rc<RefCell<&'parser mut T>>,
-    varid: usize,
-    parser: &'refer mut ArgumentParser<'parser>,
-}
-
-impl<'parser, 'refer, T> Ref<'parser, 'refer, T> {
-
-    pub fn add_option<'x, A: TypedAction<T>>(&'x mut self,
-        names: &[&'parser str], action: A, help: &'parser str)
-        -> &'x mut Ref<'parser, 'refer, T>
-    {
-        {
-            let var = &mut self.parser.vars[self.varid];
-            if var.metavar.len() == 0 {
-                let mut longest_name = names[0];
-                let mut llen = longest_name.len();
-                for name in names.iter() {
-                    if name.len() > llen {
-                        longest_name = *name;
-                        llen = longest_name.len();
-                    }
-                }
-                if llen > 2 {
-                    var.metavar = longest_name[2..llen]
-                        .to_ascii_uppercase().replace("-", "_");
-                }
-            }
-        }
-        self.parser.add_option_for(Some(self.varid), names,
-            action.bind(self.cell.clone()),
-            help);
-        return self;
-    }
-
-    pub fn add_argument<'x, A: TypedAction<T>>(&'x mut self,
-        name: &'parser str, action: A, help: &'parser str)
-        -> &'x mut Ref<'parser, 'refer, T>
-    {
-        let act = action.bind(self.cell.clone());
-        let opt = Rc::new(GenericArgument {
-            id: self.parser.arguments.len(),
-            varid: self.varid,
-            name: name,
-            help: help,
-            action: act,
-            });
-        match opt.action {
-            Flag(_) => panic!("Flag arguments can't be positional"),
-            Many(_) | Push(_) => {
-                match self.parser.catchall_argument {
-                    Some(ref y) => panic!(format!(
-                        "Option {} conflicts with option {}",
-                        name, y.name)),
-                    None => {},
-                }
-                self.parser.catchall_argument = Some(opt);
-            }
-            Single(_) => {
-                self.parser.arguments.push(opt);
-            }
-        }
-        {
-            let var = &mut self.parser.vars[self.varid];
-            if var.metavar.len() == 0 {
-                var.metavar = name.to_string();
-            }
-        }
-        return self;
-    }
-
-    pub fn metavar<'x>(&'x mut self, name: &str)
-        -> &'x mut Ref<'parser, 'refer, T>
-    {
-        {
-            let var = &mut self.parser.vars[self.varid];
-            var.metavar = name.to_string();
-        }
-        return self;
-    }
-
-    pub fn required<'x>(&'x mut self)
-        -> &'x mut Ref<'parser, 'refer, T>
-    {
-        {
-            let var = &mut self.parser.vars[self.varid];
-            var.required = true;
-        }
-        return self;
-    }
-}
-
-impl<'parser, 'refer, T: 'static + FromStr> Ref<'parser, 'refer, T> {
-    pub fn envvar<'x>(&'x mut self, varname: &'parser str)
-        -> &'x mut Ref<'parser, 'refer, T>
-    {
-        self.parser.env_vars.push(Rc::new(EnvVar {
-            varid: self.varid,
-            name: varname,
-            action: Box::new(StoreAction { cell: self.cell.clone() }),
-            }));
-        return self;
-    }
-}
-
-/// The main argument parser class
-pub struct ArgumentParser<'parser> {
-    description: &'parser str,
-    vars: Vec<Box<Var>>,
-    options: Vec<Rc<GenericOption<'parser>>>,
-    arguments: Vec<Rc<GenericArgument<'parser>>>,
-    env_vars: Vec<Rc<EnvVar<'parser>>>,
-    catchall_argument: Option<Rc<GenericArgument<'parser>>>,
-    short_options: HashMap<char, Rc<GenericOption<'parser>>>,
-    long_options: HashMap<String, Rc<GenericOption<'parser>>>,
-    stop_on_first_argument: bool,
-    silence_double_dash: bool,
-}
-
-
-
-impl<'parser> ArgumentParser<'parser> {
-
-    /// Create an empty argument parser
-    pub fn new() -> ArgumentParser<'parser> {
-
-        let mut ap = ArgumentParser {
-            description: "",
-            vars: Vec::new(),
-            env_vars: Vec::new(),
-            arguments: Vec::new(),
-            catchall_argument: None,
-            options: Vec::new(),
-            short_options: HashMap::new(),
-            long_options: HashMap::new(),
-            stop_on_first_argument: false,
-            silence_double_dash: true,
-            };
-        ap.add_option_for(None, &["-h", "--help"], Flag(Box::new(HelpAction)),
-            "Show this help message and exit");
-        return ap;
-    }
-
-    /// Borrow mutable variable for an argument
-    ///
-    /// This returns `Ref` object which should be used configure the option
-    pub fn refer<'x, T>(&'x mut self, val: &'parser mut T)
-        -> Box<Ref<'parser, 'x, T>>
-    {
-        let cell = Rc::new(RefCell::new(val));
-        let id = self.vars.len();
-        self.vars.push(Box::new(Var {
-                id: id,
-                required: false,
-                metavar: "".to_string(),
-                }));
-        return Box::new(Ref {
-            cell: cell.clone(),
-            varid: id,
-            parser: self,
-        });
-    }
-
-    /// Add option to argument parser
-    ///
-    /// This is only useful for options that don't store value. For
-    /// example `Print(...)`
-    pub fn add_option<F:IFlagAction + 'parser>(&mut self,
-        names: &[&'parser str], action: F, help: &'parser str)
-    {
-        self.add_option_for(None, names, Flag(Box::new(action)), help);
-    }
-
-    /// Set description of the command
-    pub fn set_description(&mut self, descr: &'parser str) {
-        self.description = descr;
-    }
-
-    fn add_option_for(&mut self, var: Option<usize>,
-        names: &[&'parser str],
-        action: Action<'parser>, help: &'parser str)
-    {
-        let opt = Rc::new(GenericOption {
-            id: self.options.len(),
-            varid: var,
-            names: names.to_vec(),
-            help: help,
-            action: action,
-            });
-
-        if names.len() < 1 {
-            panic!("At least one name for option must be specified");
-        }
-        for nameptr in names.iter() {
-            let name = *nameptr;
-            match ArgumentKind::check(name) {
-                Positional|Delimiter => {
-                    panic!("Bad argument name {}", name);
-                }
-                LongOption => {
-                    self.long_options.insert(
-                        name.to_string(), opt.clone());
-                }
-                ShortOption => {
-                    if name.len() > 2 {
-                        panic!("Bad short argument {}", name);
-                    }
-                    self.short_options.insert(
-                        name.as_bytes()[1] as char, opt.clone());
-                }
-            }
-        }
-        self.options.push(opt);
-    }
-
-    /// Print help
-    ///
-    /// Usually command-line option is used for printing help,
-    /// this is here for any awkward cases
-    pub fn print_help(&self, name: &str, writer: &mut Write) -> IoResult<()> {
-        return HelpFormatter::print_help(self, name, writer);
-    }
-
-    /// Print usage
-    ///
-    /// Usually printed into stderr on error of command-line parsing
-    pub fn print_usage(&self, name: &str, writer: &mut Write) -> IoResult<()>
-    {
-        return HelpFormatter::print_usage(self, name, writer);
-    }
-
-    /// Parse arguments
-    ///
-    /// This is most powerful method. Usually you need `parse_args`
-    /// or `parse_args_or_exit` instead
-    pub fn parse(&self, args: Vec<String>,
-        stdout: &mut Write, stderr: &mut Write)
-        -> Result<(), i32>
-    {
-        let name = if args.len() > 0 { &args[0][..] } else { "unknown" };
-        match Context::parse(self, &args, stderr) {
-            Parsed => return Ok(()),
-            Exit => return Err(0),
-            Help => {
-                self.print_help(name, stdout).unwrap();
-                return Err(0);
-            }
-            Error(message) => {
-                self.error(&name[..], &message[..], stderr);
-                return Err(2);
-            }
-        }
-    }
-
-    /// Write an error similar to one produced by the library itself
-    ///
-    /// Only needed if you like to do some argument validation that is out
-    /// of scope of the argparse
-    pub fn error(&self, command: &str, message: &str, writer: &mut Write) {
-        self.print_usage(command, writer).unwrap();
-        write!(writer, "{}: {}\n", command, message).ok();
-    }
-
-    /// Configure parser to ignore options when first non-option argument is
-    /// encountered.
-    ///
-    /// Useful for commands that want to pass following options to the
-    /// subcommand or subprocess, but need some options to be set before
-    /// command is specified.
-    pub fn stop_on_first_argument(&mut self, want_stop: bool) {
-        self.stop_on_first_argument = want_stop;
-    }
-
-    /// Do not put double-dash (bare `--`) into argument
-    ///
-    /// The double-dash is used to stop parsing options and treat all the
-    /// following tokens as the arguments regardless of whether they start
-    /// with dash (minus) or not.
-    ///
-    /// The method only useful for `List` arguments. On by default. The method
-    /// allows to set option to `false` so that `cmd xx -- yy` will get
-    /// ``xx -- yy`` as arguments instead of ``xx yy`` by default. This is
-    /// useful if your ``--`` argument is meaningful. Only first double-dash
-    /// is ignored by default.
-    pub fn silence_double_dash(&mut self, silence: bool) {
-        self.silence_double_dash = silence;
-    }
-
-    /// Convenience method to parse arguments
-    ///
-    /// On error returns error code that is supposed to be returned by
-    /// an application. (i.e. zero on `--help` and `2` on argument error)
-    pub fn parse_args(&self) -> Result<(), i32> {
-        // TODO(tailhook) can we get rid of collect?
-        return self.parse(env::args().collect(),
-            &mut stdout(), &mut stderr());
-    }
-
-    /// The simplest conveninece method
-    ///
-    /// The method returns only in case of successful parsing or exits with
-    /// appropriate code (including successful on `--help`) otherwise.
-    pub fn parse_args_or_exit(&self) {
-        // TODO(tailhook) can we get rid of collect?
-        self.parse(env::args().collect(), &mut stdout(), &mut stderr())
-            .map_err(|c| exit(c))
-            .ok();
-    }
-}
-
-struct HelpFormatter<'a, 'b: 'a> {
-    name: &'a str,
-    parser: &'a ArgumentParser<'b>,
-    buf: &'a mut (Write + 'a),
-}
-
-impl<'a, 'b> HelpFormatter<'a, 'b> {
-    pub fn print_usage(parser: &ArgumentParser, name: &str, writer: &mut Write)
-        -> IoResult<()>
-    {
-        return HelpFormatter { parser: parser, name: name, buf: writer }
-            .write_usage();
-    }
-
-    pub fn print_help(parser: &ArgumentParser, name: &str, writer: &mut Write)
-        -> IoResult<()>
-    {
-        return HelpFormatter { parser: parser, name: name, buf: writer }
-            .write_help();
-    }
-
-    pub fn print_argument(&mut self, arg: &GenericArgument<'b>)
-        -> IoResult<()>
-    {
-        let mut num = 2;
-        try!(write!(self.buf, "  {}", arg.name));
-        num += arg.name.len();
-        if num >= OPTION_WIDTH {
-            try!(write!(self.buf, "\n"));
-            for _ in 0..OPTION_WIDTH {
-                try!(write!(self.buf, " "));
-            }
-        } else {
-            for _ in num..OPTION_WIDTH {
-                try!(write!(self.buf, " "));
-            }
-        }
-        try!(wrap_text(self.buf, arg.help, TOTAL_WIDTH, OPTION_WIDTH));
-        try!(write!(self.buf, "\n"));
-        return Ok(());
-    }
-
-    pub fn print_option(&mut self, opt: &GenericOption<'b>) -> IoResult<()> {
-        let mut num = 2;
-        try!(write!(self.buf, "  "));
-        let mut niter = opt.names.iter();
-        let name = niter.next().unwrap();
-        try!(write!(self.buf, "{}", name));
-        num += name.len();
-        for name in niter {
-            try!(write!(self.buf, ","));
-            try!(write!(self.buf, "{}", name));
-            num += name.len() + 1;
-        }
-        match opt.action {
-            Flag(_) => {}
-            Single(_) | Push(_) | Many(_) => {
-                try!(write!(self.buf, " "));
-                let var = &self.parser.vars[opt.varid.unwrap()];
-                try!(write!(self.buf, "{}", &var.metavar[..]));
-                num += var.metavar.len() + 1;
-            }
-        }
-        if num >= OPTION_WIDTH {
-            try!(write!(self.buf, "\n"));
-            for _ in 0..OPTION_WIDTH {
-                try!(write!(self.buf, " "));
-            }
-        } else {
-            for _ in num..OPTION_WIDTH {
-                try!(write!(self.buf, " "));
-            }
-        }
-        try!(wrap_text(self.buf, opt.help, TOTAL_WIDTH, OPTION_WIDTH));
-        try!(write!(self.buf, "\n"));
-        return Ok(());
-    }
-
-    fn write_help(&mut self) -> IoResult<()> {
-        try!(self.write_usage());
-        try!(write!(self.buf, "\n"));
-        if self.parser.description.len() > 0 {
-            try!(wrap_text(self.buf, self.parser.description,TOTAL_WIDTH, 0));
-            try!(write!(self.buf, "\n"));
-        }
-        if self.parser.arguments.len() > 0
-            || self.parser.catchall_argument.is_some()
-        {
-            try!(write!(self.buf, "\nPositional arguments:\n"));
-            for arg in self.parser.arguments.iter() {
-                try!(self.print_argument(&**arg));
-            }
-            match self.parser.catchall_argument {
-                Some(ref opt) => {
-                    try!(self.print_argument(&**opt));
-                }
-                None => {}
-            }
-        }
-        if self.parser.short_options.len() > 0
-            || self.parser.long_options.len() > 0
-        {
-            try!(write!(self.buf, "\nOptional arguments:\n"));
-            for opt in self.parser.options.iter() {
-                try!(self.print_option(&**opt));
-            }
-        }
-        return Ok(());
-    }
-
-    fn write_usage(&mut self) -> IoResult<()> {
-        try!(write!(self.buf, "Usage:\n  "));
-        try!(write!(self.buf, "{}", self.name));
-        if self.parser.options.len() != 0 {
-            if self.parser.short_options.len() > 1
-                || self.parser.long_options.len() > 1
-            {
-                try!(write!(self.buf, " [OPTIONS]"));
-            }
-            for opt in self.parser.arguments.iter() {
-                let var = &self.parser.vars[opt.varid];
-                try!(write!(self.buf, " "));
-                if !var.required {
-                    try!(write!(self.buf, "["));
-                }
-                try!(write!(self.buf, "{}",
-                    &opt.name.to_ascii_uppercase()[..]));
-                if !var.required {
-                    try!(write!(self.buf, "]"));
-                }
-            }
-            match self.parser.catchall_argument {
-                Some(ref opt) => {
-                    let var = &self.parser.vars[opt.varid];
-                    try!(write!(self.buf, " "));
-                    if !var.required {
-                        try!(write!(self.buf, "["));
-                    }
-                    try!(write!(self.buf, "{}",
-                        &opt.name.to_ascii_uppercase()[..]));
-                    if !var.required {
-                        try!(write!(self.buf, " ...]"));
-                    } else {
-                        try!(write!(self.buf, " [...]"));
-                    }
-                }
-                None => {}
-            }
-        }
-        try!(write!(self.buf, "\n"));
-        return Ok(());
-    }
-
-}
diff --git a/argparse/src/print.rs b/argparse/src/print.rs
deleted file mode 100644
index d0335c5..0000000
--- a/argparse/src/print.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use Print;
-use action::{IFlagAction, ParseResult};
-
-impl IFlagAction for Print {
-    fn parse_flag(&self) -> ParseResult {
-        if self.0.ends_with("\n") {
-            print!("{}", self.0);
-        } else {
-            println!("{}", self.0);
-        }
-        return ParseResult::Exit;
-    }
-}
diff --git a/argparse/src/test_bool.rs b/argparse/src/test_bool.rs
deleted file mode 100644
index a30cf3c..0000000
--- a/argparse/src/test_bool.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use parser::ArgumentParser;
-use super::Store;
-use super::{StoreTrue, StoreFalse};
-use test_parser::{check_ok};
-
-fn store_true(args: &[&str]) -> bool {
-    let mut verbose = false;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut verbose)
-          .add_option(&["-t", "--true"], StoreTrue,
-            "Store true action");
-        check_ok(&ap,  args);
-    }
-    return verbose;
-}
-
-#[test]
-fn test_store_true() {
-    assert!(!store_true(&["./argparse_test"]));
-    assert!(store_true(&["./argparse_test", "--true"]));
-}
-
-fn store_false(args: &[&str]) -> bool {
-    let mut verbose = true;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut verbose)
-          .add_option(&["-f", "--false"], StoreFalse,
-            "Store false action");
-        check_ok(&ap,  args);
-    }
-    return verbose;
-}
-#[test]
-fn test_store_false() {
-    assert!(store_false(&["./argparse_test"]));
-    assert!(!store_false(&["./argparse_test", "--false"]));
-}
-
-fn store_bool(args: &[&str]) -> bool {
-    let mut verbose = false;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut verbose)
-          .add_option(&["-f", "--false"], StoreFalse,
-            "Store false action")
-          .add_option(&["-t", "--true"], StoreTrue,
-            "Store false action");
-        check_ok(&ap,  args);
-    }
-    return verbose;
-}
-
-#[test]
-fn test_bool() {
-    assert!(!store_bool(&["./argparse_test"]));
-    assert!(store_bool(&["./argparse_test", "-t"]));
-    assert!(!store_bool(&["./argparse_test", "-f"]));
-    assert!(store_bool(&["./argparse_test", "-fft"]));
-    assert!(!store_bool(&["./argparse_test", "-fffft", "-f"]));
-    assert!(store_bool(&["./argparse_test", "--false", "-fffft", "-f",
-                   "--true"]));
-}
-
-fn set_bool(args: &[&str]) -> bool {
-    let mut verbose = false;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut verbose)
-          .add_option(&["-s", "--set"], Store,
-            "Set boolean value");
-        check_ok(&ap,  args);
-    }
-    return verbose;
-}
-
-
-#[test]
-fn test_set_bool() {
-    assert!(!set_bool(&["./argparse_test"]));
-    assert!(set_bool(&["./argparse_test", "-strue"]));
-    assert!(!set_bool(&["./argparse_test", "-sfalse"]));
-
-    // Unfortunately other values do not work
-}
-
-#[test]
-#[should_panic(expected="Bad value yes")]
-fn test_bad_bools1() {
-    assert!(!set_bool(&["./argparse_test", "-syes"]));
-}
-
-#[test]
-#[should_panic(expected="Bad value no")]
-fn test_bad_bools2() {
-    assert!(!set_bool(&["./argparse_test", "-sno"]));
-}
diff --git a/argparse/src/test_const.rs b/argparse/src/test_const.rs
deleted file mode 100644
index b12e3d8..0000000
--- a/argparse/src/test_const.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use parser::ArgumentParser;
-use super::{PushConst};
-use test_parser::{check_ok};
-
-
-fn push_const(args: &[&str]) -> Vec<u32> {
-    let mut res = vec!();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut res)
-          .add_option(&["-o", "--one"], PushConst(1),
-            "Add one to the list")
-          .add_option(&["-t", "--two"], PushConst(2),
-            "Add two to the list")
-          .add_option(&["-3", "--three"], PushConst(3),
-            "Add three to the list");
-        check_ok(&ap,  args);
-    }
-    return res;
-}
-
-#[test]
-fn test_push() {
-    assert_eq!(push_const(&["./argparse_test"]), vec!());
-    assert_eq!(push_const(&["./argparse_test", "--one"]), vec!(1));
-    assert_eq!(push_const(&["./argparse_test", "-3"]), vec!(3));
-    assert_eq!(push_const(&["./argparse_test", "-oo3tt"]), vec!(1, 1, 3, 2, 2));
-}
diff --git a/argparse/src/test_enum.rs b/argparse/src/test_enum.rs
deleted file mode 100644
index 5205738..0000000
--- a/argparse/src/test_enum.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use std::str::FromStr;
-
-use parser::ArgumentParser;
-use super::Store;
-use test_parser::{check_ok};
-
-use self::Greeting::{Hello, Hi, NoGreeting};
-
-
-#[derive(PartialEq, Eq, Debug)]
-enum Greeting {
-    Hello,
-    Hi,
-    NoGreeting,
-}
-
-impl FromStr for Greeting {
-    type Err = ();
-    fn from_str(src: &str) -> Result<Greeting, ()> {
-        return match src {
-            "hello" => Ok(Hello),
-            "hi" => Ok(Hi),
-            _ => Err(()),
-        };
-    }
-}
-
-fn parse_enum(args: &[&str]) -> Greeting {
-    let mut val = NoGreeting;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-g"], Store,
-            "Greeting");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_parse_enum() {
-    assert_eq!(parse_enum(&["./argparse_test"]), NoGreeting);
-    assert_eq!(parse_enum(&["./argparse_test", "-ghello"]), Hello);
-    assert_eq!(parse_enum(&["./argparse_test", "-ghi"]), Hi);
-}
-
-#[test]
-#[should_panic]
-fn test_parse_error() {
-    parse_enum(&["./argparse_test", "-ghell"]);
-}
diff --git a/argparse/src/test_env.rs b/argparse/src/test_env.rs
deleted file mode 100644
index 2e1b649..0000000
--- a/argparse/src/test_env.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use std::env;
-
-use parser::ArgumentParser;
-use super::Store;
-use test_parser::{check_ok};
-
-
-fn required(args: &[&str]) -> (isize, isize) {
-    let mut val1 = 1isize;
-    let mut val2 = 2isize;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1)
-            .add_option(&["--v1"], Store, "The value 1")
-            .add_argument("v1", Store, "The value 1")
-            .envvar("TEST_ENV_REQUIRED_V1")
-            .required();
-        ap.refer(&mut val2)
-            .add_argument("v2", Store, "The value 2");
-        check_ok(&ap, args);
-    }
-    return (val1, val2)
-}
-
-#[test]
-#[should_panic]
-fn test_required() {
-    env::set_var("TEST_ENV_REQUIRED_V1", "some_crap");
-    required(&["./argparse_test"]);
-    env::remove_var("TEST_ENV_REQUIRED_V1");
-}
-
-#[test]
-fn test_req() {
-    env::set_var("TEST_ENV_REQUIRED_V1", "some_crap");
-    assert_eq!(required(&["./argparse_test", "10"]), (10, 2));
-    assert_eq!(required(&["./argparse_test", "11", "21"]), (11, 21));
-    assert_eq!(required(&["./argparse_test", "--v1=7"]), (7, 2));
-    env::set_var("TEST_ENV_REQUIRED_V1", "9");
-    assert_eq!(required(&["./argparse_test", "10"]), (9, 10));
-    assert_eq!(required(&["./argparse_test", "7", "--v1=15"]), (15, 7));
-    env::remove_var("TEST_ENV_REQUIRED_V1");
-}
diff --git a/argparse/src/test_float.rs b/argparse/src/test_float.rs
deleted file mode 100644
index 9ef0f56..0000000
--- a/argparse/src/test_float.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use parser::ArgumentParser;
-use super::{IncrBy,DecrBy};
-use super::Store;
-use test_parser::{check_ok};
-
-fn incr_decr(args: &[&str]) -> f32 {
-    let mut val = 0f32;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-d", "--decr"], DecrBy(0.25f32),
-            "Decrement value")
-          .add_option(&["-i", "--incr"], IncrBy(0.5f32),
-            "Increment value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_incr_decr() {
-    assert_eq!(incr_decr(&["./argparse_test",
-        "--incr", "-iii"]), 2.0);
-    assert_eq!(incr_decr(&["./argparse_test",
-        "-iiddd", "--incr", "-iii"]), 2.25);
-}
-
-#[test]
-fn test_float() {
-    let mut val = 0.1;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], Store,
-            "Set float value");
-        check_ok(&ap, &["./argparse_test", "-s", "15.125"]);
-    }
-    assert_eq!(val, 15.125);
-}
-
-#[test]
-#[should_panic]
-fn test_fail() {
-    let mut val = 0.1;
-    let mut ap = ArgumentParser::new();
-    ap.refer(&mut val)
-      .add_option(&["-s", "--set"], Store,
-        "Set float value");
-    check_ok(&ap, &["./argparse_test", "-s", "test"]);
-}
diff --git a/argparse/src/test_help.rs b/argparse/src/test_help.rs
deleted file mode 100644
index f23b14b..0000000
--- a/argparse/src/test_help.rs
+++ /dev/null
@@ -1,154 +0,0 @@
-use std::str::from_utf8;
-
-use parser::ArgumentParser;
-use super::{Store, List};
-
-#[test]
-fn test_empty() {
-    let mut ap = ArgumentParser::new();
-    let mut buf = Vec::<u8>::new();
-    ap.set_description("Test program");
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test\n"
-        + "\n"
-        + "Test program\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
-
-#[test]
-fn test_options() {
-    let mut val = 0;
-    let mut val2 = 0;
-    let mut ap = ArgumentParser::new();
-    ap.set_description("Test program. The description of the program is ought
-        to be very long, because we want to test how word wrapping works for
-        it. So some more text would be ok for the test");
-    ap.refer(&mut val)
-      .add_option(&["--value"], Store,
-        "Set integer value");
-    ap.refer(&mut val2)
-      .add_option(&["-L", "--long-option"], Store,
-        "Long option value");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test [OPTIONS]
-
-Test program. The description of the program is ought to be very long, because
-we want to test how word wrapping works for it. So some more text would be ok
-for the test\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        + "  --value VALUE         Set integer value\n"
-        + "  -L,--long-option LONG_OPTION\n"
-        + "                        Long option value\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
-
-#[test]
-fn test_argument() {
-    let mut val = 0;
-    let mut ap = ArgumentParser::new();
-    ap.set_description("Test program");
-    ap.refer(&mut val)
-      .add_argument("value", Store,
-        "Integer value");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test [VALUE]\n"
-        + "\n"
-        + "Test program\n"
-        + "\n"
-        + "Positional arguments:\n"
-        + "  value                 Integer value\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
-
-#[test]
-fn test_arguments() {
-    let mut v1 = 0;
-    let mut v2 = Vec::<u32>::new();
-    let mut ap = ArgumentParser::new();
-    ap.set_description("Test program");
-    ap.refer(&mut v1)
-      .add_argument("v1", Store,
-        "Integer value 1");
-    ap.refer(&mut v2)
-      .add_argument("v2", List,
-        "More values");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test [V1] [V2 ...]\n"
-        + "\n"
-        + "Test program\n"
-        + "\n"
-        + "Positional arguments:\n"
-        + "  v1                    Integer value 1\n"
-        + "  v2                    More values\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
-
-#[test]
-fn test_req_arguments() {
-    let mut v1 = 0;
-    let mut v2 = Vec::<u32>::new();
-    let mut ap = ArgumentParser::new();
-    ap.set_description("Test program");
-    ap.refer(&mut v1)
-      .add_argument("v1", Store,
-        "Integer value 1")
-      .required();
-    ap.refer(&mut v2)
-      .add_argument("v2", List,
-        "More values")
-      .required();
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test V1 V2 [...]\n"
-        + "\n"
-        + "Test program\n"
-        + "\n"
-        + "Positional arguments:\n"
-        + "  v1                    Integer value 1\n"
-        + "  v2                    More values\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
-
-#[test]
-fn test_metavar() {
-    let mut val2 = 0;
-    let mut ap = ArgumentParser::new();
-    ap.set_description("Test program.");
-    ap.refer(&mut val2)
-      .add_option(&["-L", "--long-option"], Store,
-        "Long option value")
-      .metavar("VAL");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_help("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n".to_string()
-        + "  ./argparse_test [OPTIONS]\n"
-        + "\n"
-        + "Test program.\n"
-        + "\n"
-        + "Optional arguments:\n"
-        + "  -h,--help             Show this help message and exit\n"
-        + "  -L,--long-option VAL  Long option value\n"
-        , from_utf8(&buf[..]).unwrap().to_string());
-}
diff --git a/argparse/src/test_int.rs b/argparse/src/test_int.rs
deleted file mode 100644
index 1826eaf..0000000
--- a/argparse/src/test_int.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use parser::ArgumentParser;
-use super::{IncrBy,DecrBy};
-use super::Store;
-use test_parser::{check_ok};
-
-fn incr_int(args: &[&str]) -> usize {
-    let mut val = 0;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-i", "--incr"], IncrBy(1usize),
-            "Increment value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_incr_int() {
-    assert_eq!(incr_int(&["./argparse_test"]), 0);
-    assert_eq!(incr_int(&["./argparse_test", "--incr"]), 1);
-    assert_eq!(incr_int(&["./argparse_test", "-iiiii"]), 5);
-}
-
-fn decr_int(args: &[&str]) -> isize {
-    let mut val = 5;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-d", "--decr"], DecrBy(1isize),
-            "Decrement value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_decr_int() {
-    assert_eq!(decr_int(&["./argparse_test"]), 5);
-    assert_eq!(decr_int(&["./argparse_test", "--decr"]), 4);
-    assert_eq!(decr_int(&["./argparse_test", "-dddddd"]), -1);
-}
-
-#[test]
-fn test_incr_decr() {
-    let mut val = 0;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-d", "--decr"], DecrBy(1isize),
-            "Decrement value")
-          .add_option(&["-i", "--incr"], IncrBy(1isize),
-            "Increment value");
-        check_ok(&ap, &["./argparse_test",
-            "-iiddd", "--incr", "-iii"]);
-    }
-    assert_eq!(val, 3);
-}
-
-fn set_int(args: &[&str]) -> isize {
-    let mut val = 0;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], Store,
-            "Set integer value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_set_int() {
-    assert_eq!(set_int(&["./argparse_test", "-s", "10"]), 10);
-    assert_eq!(set_int(&["./argparse_test", "--set", "99"]), 99);
-    assert_eq!(set_int(&["./argparse_test", "-s", "7", "-s77"]), 77);
-    assert_eq!(set_int(&["./argparse_test", "-s333", "--set=123"]), 123);
-}
-
-#[test]
-#[should_panic(expected="Bad value 1.5")]
-fn test_set_int_bad() {
-    set_int(&["./argparse_test", "-s1.5"]);
-}
-
-fn set_i16(args: &[&str]) -> i16 {
-    let mut val = 0;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], Store,
-            "Set integer value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_i16() {
-    assert_eq!(set_i16(&["./argparse_test", "-s", "124"]), 124);
-}
-
-#[test]
-#[should_panic(expected="Bad value 1000000")]
-fn test_i16_big() {
-    set_i16(&["./argparse_test", "-s", "1000000"]);
-}
diff --git a/argparse/src/test_many.rs b/argparse/src/test_many.rs
deleted file mode 100644
index 68e2cec..0000000
--- a/argparse/src/test_many.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use parser::ArgumentParser;
-use super::{List, Store, Collect};
-use test_parser::{check_ok};
-
-fn pos_list(args: &[&str]) -> (isize, Vec<isize>) {
-    let mut val1 = 1;
-    let mut val2 = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1).add_argument("v1", Store, "The value 1");
-        ap.refer(&mut val2).add_argument("v2", List, "The list of vals");
-        check_ok(&ap, args);
-    }
-    return (val1, val2);
-}
-
-#[test]
-fn test_pos_list() {
-    assert_eq!(pos_list(&["./argparse_test", "10"]), (10, vec!()));
-    assert_eq!(pos_list(&["./argparse_test", "11", "21"]), (11, vec!(21)));
-    assert_eq!(pos_list(&["./argparse_test", "10", "20", "30"]),
-        (10, vec!(20, 30)));
-}
-
-fn pos_collect(args: &[&str]) -> Vec<isize> {
-    let mut lst = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut lst)
-            .add_argument("v", Collect, "The list of vals");
-        check_ok(&ap, args);
-    }
-    return lst;
-}
-
-#[test]
-fn test_pos_collect() {
-    assert_eq!(pos_collect(&["./argparse_test", "10"]), vec!(10));
-    assert_eq!(pos_collect(&["./argparse_test", "11", "21"]), vec!(11, 21));
-    assert_eq!(pos_collect(&["./argparse_test", "10", "20", "30"]),
-        vec!(10, 20, 30));
-}
-
-#[test]
-#[should_panic]
-fn wrong_type() {
-    pos_collect(&["./argparse_test", "10", "20", "test"]);
-}
-
-fn collect(args: &[&str]) -> Vec<isize> {
-    let mut lst = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut lst).add_option(&["-a", "--add"], Collect,
-            "The list of vals");
-        check_ok(&ap, args);
-    }
-    return lst;
-}
-
-#[test]
-fn test_collect() {
-    assert_eq!(collect(&["./argparse_test", "-a10"]), vec!(10));
-    assert_eq!(collect(&["./argparse_test", "--add=11", "-a", "21"]),
-        vec!(11, 21));
-    assert_eq!(collect(&["./argparse_test",
-        "-a", "10", "--add=20", "--add", "30"]), vec!(10, 20, 30));
-}
-
-#[test]
-#[should_panic]
-fn test_extra() {
-    collect(&["./argparse_test", "-a", "10", "20", "30"]);
-}
-
-fn list(args: &[&str]) -> Vec<isize> {
-    let mut vec = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut vec).add_option(&["-a", "--add"], List,
-            "The list of vals");
-        check_ok(&ap, args);
-    }
-    return vec;
-}
-
-#[test]
-#[should_panic]
-fn test_list() {
-    assert_eq!(list(&["./argparse_test", "-a10"]), vec!(10));
-    assert_eq!(list(&["./argparse_test", "--add", "11", "21"]), vec!(11, 21));
-    assert_eq!(list(&["./argparse_test", "-a", "10", "20", "30"]),
-        vec!(10, 20, 30));
-    assert_eq!(list(&["./argparse_test", "10", "20", "30"]), vec!(10, 20, 30));
-}
diff --git a/argparse/src/test_optional.rs b/argparse/src/test_optional.rs
deleted file mode 100644
index 5f4c35e..0000000
--- a/argparse/src/test_optional.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use parser::ArgumentParser;
-use super::StoreOption;
-use test_parser::{check_ok};
-
-fn opt(args: &[&str]) -> Option<isize> {
-    let mut val = None;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], StoreOption,
-            "Set int value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_opt() {
-    assert_eq!(opt(&["./argparse_test"]), None);
-    assert_eq!(opt(&["./argparse_test", "-s", "10"]), Some(10));
-    assert_eq!(opt(&["./argparse_test", "--set", "11"]), Some(11));
-}
-
-#[test]
-#[should_panic]
-fn test_opt_no_arg() {
-    opt(&["./argparse_test", "--set"]);
-}
-
-fn optstr(args: &[&str]) -> Option<String> {
-    let mut val = None;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], StoreOption,
-            "Set string value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_str() {
-    assert_eq!(optstr(&["./argparse_test"]), None);
-    assert_eq!(optstr(&["./argparse_test", "-s", "10"]), Some(10.to_string()));
-    assert_eq!(optstr(&["./argparse_test", "--set", "11"]),
-        Some(11.to_string()));
-}
-
-#[test]
-#[should_panic]
-fn test_str_no_art() {
-    optstr(&["./argparse_test", "--set"]);
-}
diff --git a/argparse/src/test_parser.rs b/argparse/src/test_parser.rs
deleted file mode 100644
index f60aa64..0000000
--- a/argparse/src/test_parser.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-
-use parser::ArgumentParser;
-
-pub fn check_ok(ap: &ArgumentParser, args: &[&str]) {
-    let mut stdout = Vec::<u8>::new();
-    let mut stderr = Vec::<u8>::new();
-    let mut owned_args = Vec::new();
-    for x in args.iter() {
-        owned_args.push(x.to_string());
-    }
-    let res = ap.parse(owned_args, &mut stdout, &mut stderr);
-    match res {
-        Ok(()) => return,
-        Err(x) => panic!(
-            String::from_utf8(stderr).unwrap() +
-            &format!("Expected ok, but found Exit({})", x)[..]),
-    }
-}
-
-pub fn check_exit(ap: &ArgumentParser, args: &[&str]) {
-    let mut stdout = Vec::<u8>::new();
-    let mut stderr = Vec::<u8>::new();
-    let mut owned_args = Vec::new();
-    for x in args.iter() {
-        owned_args.push(x.to_string());
-    }
-    let res = ap.parse(owned_args, &mut stdout, &mut stderr);
-    match res {
-        Err(0) => return,
-        Err(x) => panic!(format!("Expected code {} got {}", 0usize, x)),
-        Ok(()) => panic!(format!("Expected failure, got success")),
-    }
-}
-
-pub fn check_err(ap: &ArgumentParser, args: &[&str]) {
-    let mut stdout = Vec::<u8>::new();
-    let mut stderr = Vec::<u8>::new();
-    let mut owned_args = Vec::new();
-    for x in args.iter() {
-        owned_args.push(x.to_string());
-    }
-    let res = ap.parse(owned_args, &mut stdout, &mut stderr);
-    match res {
-        Err(2) => return,
-        Err(x) => panic!(format!("Expected code {} got {}", 2usize, x)),
-        Ok(()) => panic!(format!("Expected failure, got success")),
-    }
-}
-
-#[test]
-fn test_no_arg() {
-    let ap = ArgumentParser::new();
-    check_ok(&ap, &["./argparse_test"]);
-    check_err(&ap, &["./argparse_test", "a"]);
-    check_err(&ap, &["./argparse_test", "-a"]);
-    check_err(&ap, &["./argparse_test", "--an-option"]);
-}
-
-#[test]
-fn test_help() {
-    let ap = ArgumentParser::new();
-    check_ok(&ap, &["./argparse_test"]);
-    check_exit(&ap, &["./argparse_test", "--help"]);
-}
diff --git a/argparse/src/test_path.rs b/argparse/src/test_path.rs
deleted file mode 100644
index 868ae8c..0000000
--- a/argparse/src/test_path.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use std::path::PathBuf;
-use parser::ArgumentParser;
-use super::Parse;
-use test_parser::{check_ok};
-
-fn parse_str(args: &[&str]) -> PathBuf {
-    let mut val: PathBuf = From::from("");
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], Parse,
-            "Set path value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_path() {
-    assert_eq!(parse_str(&["./argparse_test", "-s", "/hello"]),
-               PathBuf::from("/hello"));
-    assert_eq!(parse_str(&["./argparse_test", "--set", "a///b/../c"]),
-               PathBuf::from("a/b/../c"));
-}
-
-#[test]
-#[should_panic]
-fn test_err() {
-    parse_str(&["./argparse_test", "--set"]);
-}
diff --git a/argparse/src/test_pos.rs b/argparse/src/test_pos.rs
deleted file mode 100644
index 2542050..0000000
--- a/argparse/src/test_pos.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-use parser::ArgumentParser;
-use super::{Store, List};
-use test_parser::{check_ok};
-
-fn parse_pos(args: &[&str]) -> isize {
-    let mut val = 0;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-            .add_argument("value", Store, "The value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-
-#[test]
-fn test_argument() {
-    assert_eq!(parse_pos(&["./argparse_test", "10"]), 10);
-}
-
-#[test]
-#[should_panic]
-fn too_much_args() {
-    parse_pos(&["./argparse_test", "10", "20"]);
-}
-
-#[test]
-#[should_panic]
-fn wrong_value() {
-    parse_pos(&["./argparse_test", "test", "20"]);
-}
-
-#[test]
-#[should_panic]
-fn float_value() {
-    parse_pos(&["./argparse_test", "1.5"]);
-}
-
-fn parse_two(args: &[&str]) -> (isize, isize) {
-    let mut val1 = 1;
-    let mut val2 = 2;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1)
-            .add_argument("v1", Store, "The value 1");
-        ap.refer(&mut val2)
-            .add_argument("v2", Store, "The value 2");
-        check_ok(&ap, args);
-    }
-    return (val1, val2);
-}
-
-#[test]
-fn test_two() {
-    assert_eq!(parse_two(&["./argparse_test", "10"]), (10, 2));
-    assert_eq!(parse_two(&["./argparse_test", "11", "21"]), (11, 21));
-}
-
-#[test]
-#[should_panic]
-fn test_two_fail_many() {
-    parse_two(&["./argparse_test", "10", "20", "30"]);
-}
-
-#[test]
-#[should_panic]
-fn test_two_fail_value() {
-    parse_two(&["./argparse_test", "test", "20"]);
-}
-
-#[test]
-#[should_panic]
-fn test_two_fail_float() {
-    parse_two(&["./argparse_test", "1.5"]);
-}
-
-fn parse_pos_opt(args: &[&str]) -> (isize, isize) {
-    let mut val1 = 1;
-    let mut val2 = 2;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1)
-            .add_option(&["--v1"], Store, "The value 1")
-            .add_argument("v1", Store, "The value 1");
-        ap.refer(&mut val2)
-            .add_argument("v2", Store, "The value 2");
-        check_ok(&ap, args);
-    }
-    return (val1, val2);
-}
-
-#[test]
-fn test_positional_optional() {
-    assert_eq!(parse_pos_opt(&["./argparse_test", "10"]), (10, 2));
-    assert_eq!(parse_pos_opt(&["./argparse_test", "11", "21"]), (11, 21));
-    assert_eq!(parse_pos_opt(&["./argparse_test", "--v1=7", "8"]), (7, 8));
-    assert_eq!(parse_pos_opt(&["./argparse_test", "10", "--v1=9"]), (9, 10));
-}
-
-#[test]
-#[should_panic]
-fn test_pos_opt_err() {
-    parse_pos_opt(&["./argparse_test", "--v1=10", "20", "30"]);
-}
-
-fn parse_pos_req(args: &[&str]) -> (isize, isize) {
-    let mut val1 = 1;
-    let mut val2 = 2;
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1)
-            .add_option(&["--v1"], Store, "The value 1")
-            .add_argument("v1", Store, "The value 1")
-            .required();
-        ap.refer(&mut val2)
-            .add_argument("v2", Store, "The value 2");
-        check_ok(&ap, args);
-    }
-    return (val1, val2);
-}
-
-#[test]
-fn test_positional_required() {
-    assert_eq!(parse_pos_req(&["./argparse_test", "10"]), (10, 2));
-    assert_eq!(parse_pos_req(&["./argparse_test", "11", "21"]), (11, 21));
-    assert_eq!(parse_pos_req(&["./argparse_test", "--v1=7"]), (7, 2));
-    assert_eq!(parse_pos_req(&["./argparse_test", "10", "--v1=9"]), (9, 10));
-}
-
-#[test]
-#[should_panic]
-fn test_pos_extra() {
-    parse_pos_req(&["./argparse_test", "--v1=10", "20", "30"]);
-}
-
-#[test]
-#[should_panic]
-fn test_pos_no_req() {
-    parse_pos_req(&["./argparse_test"]);
-}
-
-fn pos_stop(args: &[&str]) -> (isize, Vec<String>) {
-    let mut val1 = 1;
-    let mut val2 = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val1)
-            .add_option(&["--v1"], Store, "The value 1")
-            .add_argument("v1", Store, "The value 1")
-            .required();
-        ap.refer(&mut val2)
-            .add_argument("v2", List, "The value 2");
-        ap.stop_on_first_argument(true);
-        check_ok(&ap, args);
-    }
-    return (val1, val2);
-}
-
-#[test]
-fn test_pos_stop() {
-    assert_eq!(pos_stop(&["./argparse_test", "10"]), (10, vec!()));
-    assert_eq!(pos_stop(&["./argparse_test", "11", "21"]),
-        (11, vec!("21".to_string())));
-    assert_eq!(pos_stop(&["./argparse_test", "--v1=7"]), (7, vec!()));
-    assert_eq!(pos_stop(&["./argparse_test", "10", "--v1=9", "--whatever"]),
-        (10, vec!("--v1=9".to_string(), "--whatever".to_string())));
-}
-
-#[test]
-#[should_panic]
-fn test_test() {
-    pos_stop(&["./argparse_test"]);
-}
-
-fn pos_dash(args: &[&str], dash: bool) -> Vec<String> {
-    let mut val = Vec::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-            .add_argument("v1", List, "The value");
-        ap.silence_double_dash(dash);
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_pos_dash() {
-    assert_eq!(pos_dash(&["./argparse_test", "1"], true),
-        vec!("1".to_string()));
-    assert_eq!(pos_dash(&["./argparse_test", "--", "1"], true),
-        vec!("1".to_string()));
-    assert_eq!(pos_dash(&["./argparse_test", "--", "1"], false),
-        vec!("--".to_string(), "1".to_string()));
-}
diff --git a/argparse/src/test_str.rs b/argparse/src/test_str.rs
deleted file mode 100644
index 42db286..0000000
--- a/argparse/src/test_str.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use parser::ArgumentParser;
-use super::Store;
-use test_parser::{check_ok};
-
-fn parse_str(args: &[&str]) -> String {
-    let mut val: String = "".to_string();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["-s", "--set"], Store,
-            "Set string value");
-        check_ok(&ap, args);
-    }
-    return val;
-}
-
-#[test]
-fn test_str() {
-    assert_eq!(parse_str(&["./argparse_test", "-s", "10"]), "10".to_string());
-    assert_eq!(parse_str(&["./argparse_test", "--set", "value"]),
-               "value".to_string());
-}
-
-#[test]
-#[should_panic]
-fn test_err() {
-    parse_str(&["./argparse_test", "--set"]);
-}
diff --git a/argparse/src/test_usage.rs b/argparse/src/test_usage.rs
deleted file mode 100644
index efe89fe..0000000
--- a/argparse/src/test_usage.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use std::str::from_utf8;
-
-use parser::ArgumentParser;
-use super::{Store, List};
-
-#[test]
-fn test_empty() {
-    let ap = ArgumentParser::new();
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_usage("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n  ./argparse_test\n", from_utf8(&buf[..]).unwrap());
-}
-
-#[test]
-fn test_options() {
-    let mut val = 0;
-    let mut buf = Vec::<u8>::new();
-    {
-        let mut ap = ArgumentParser::new();
-        ap.refer(&mut val)
-          .add_option(&["--value"], Store,
-            "Set integer value");
-        assert!(ap.print_usage("./argparse_test", &mut buf).is_ok());
-    }
-    assert_eq!("Usage:\n  ./argparse_test [OPTIONS]\n",
-        from_utf8(&buf[..]).unwrap());
-}
-
-#[test]
-fn test_argument() {
-    let mut val = 0;
-    let mut ap = ArgumentParser::new();
-    ap.refer(&mut val)
-      .add_argument("value", Store,
-        "Integer value");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_usage("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n  ./argparse_test [VALUE]\n",
-        from_utf8(&buf[..]).unwrap());
-}
-
-#[test]
-fn test_arguments() {
-    let mut v1 = 0;
-    let mut v2 = Vec::<u32>::new();
-    let mut ap = ArgumentParser::new();
-    ap.refer(&mut v1)
-      .add_argument("v1", Store,
-        "Integer value 1");
-    ap.refer(&mut v2)
-      .add_argument("v2", List,
-        "More values");
-    let mut buf = Vec::<u8>::new();
-    assert!(ap.print_usage("./argparse_test", &mut buf).is_ok());
-    assert_eq!("Usage:\n  ./argparse_test [V1] [V2 ...]\n",
-        from_utf8(&buf[..]).unwrap());
-}
diff --git a/argparse/vagga.yaml b/argparse/vagga.yaml
deleted file mode 100644
index c6e0c52..0000000
--- a/argparse/vagga.yaml
+++ /dev/null
@@ -1,59 +0,0 @@
-containers:
-
-  build:
-    setup:
-    - !Ubuntu bionic
-    - !Install [build-essential, ca-certificates, vim]
-    - !TarInstall
-      url: https://static.rust-lang.org/dist/rust-1.28.0-x86_64-unknown-linux-gnu.tar.gz
-      # We install rustc and cargo, but skip rust-docs
-      script: "./install.sh --prefix=/usr \
-        --components=rustc,rust-std-x86_64-unknown-linux-gnu,cargo"
-    - &bulk !Tar
-      url: "https://github.com/tailhook/bulk/releases/download/v0.4.12/bulk-v0.4.12.tar.gz"
-      sha256: 7deeb4895b3909afea46194ef01bafdeb30ff89fc4a7b6497172ba117734040e
-      path: /
-    environ:
-      HOME: /work/run
-    volumes:
-      /tmp: !Tmpfs { size: 100Mi }
-
-
-commands:
-
-  make: !Command
-    description: Build the library
-    container: build
-    run: [cargo, build]
-
-  test: !Command
-    description: Run the tests
-    container: build
-    run: [cargo, test]
-
-  cargo: !Command
-    container: build
-    run: [cargo]
-
-  example-greeting: !Command
-    description: Build and run "greeting" example
-    container: build
-    accepts-arguments: true
-    run: [cargo, run, --example, greeting, "--"]
-
-  example-structure: !Command
-    description: Build and run "structure" example
-    container: build
-    accepts-arguments: true
-    run: [cargo, run, --example, structure, "--"]
-
-  example-subcommands: !Command
-    description: Build and run "subcommands" example
-    container: build
-    accepts-arguments: true
-    run: [cargo, run, --example, subcommands, "--"]
-
-  _bulk: !Command
-    description: Run `bulk` command (for version bookkeeping)
-    container: build
-    run: [bulk]
diff --git a/nitrocli/CHANGELOG.md b/nitrocli/CHANGELOG.md
index 88bb101..66fe682 100644
--- a/nitrocli/CHANGELOG.md
+++ b/nitrocli/CHANGELOG.md
@@ -3,6 +3,7 @@ Unreleased
 - Reworked argument handling:
   - Added `structopt` dependency in version `0.3.7`
   - Replaced `argparse` with `structopt`
+  - Removed the `argparse` dependency
 
 0.3.1
 -----
diff --git a/nitrocli/Cargo.lock b/nitrocli/Cargo.lock
index fc87abc..6760bb8 100644
--- a/nitrocli/Cargo.lock
+++ b/nitrocli/Cargo.lock
@@ -9,10 +9,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "argparse"
-version = "0.2.2"
-
-[[package]]
 name = "base32"
 version = "0.4.0"
 
@@ -70,7 +66,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 name = "nitrocli"
 version = "0.3.1"
 dependencies = [
- "argparse 0.2.2",
  "base32 0.4.0",
  "libc 0.2.66",
  "nitrokey 0.4.0",
diff --git a/nitrocli/Cargo.toml b/nitrocli/Cargo.toml
index 2d5f484..8127f7a 100644
--- a/nitrocli/Cargo.toml
+++ b/nitrocli/Cargo.toml
@@ -42,9 +42,6 @@ lto = true
 codegen-units = 1
 incremental = false
 
-[dependencies.argparse]
-version = "0.2.2"
-
 [dependencies.base32]
 version = "0.4.0"
 path = "../base32"
@@ -69,7 +66,6 @@ version = "0.1"
 version = "1"
 
 [patch.crates-io]
-argparse = { path = "../argparse" }
 base32 = { path = "../base32" }
 bitflags = { path = "../bitflags" }
 cc = { path = "../cc" }