Use structopt and refactor

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!

[Fierthraix]

This commit changes loop to use structopt. This is a wrapper around clap that serializes all of the matches into one static struct. This adds a lot of static typing benefits over using the traditional ArgMatches clap provides. This commit has 100% equivalent functionality with the loops before while simplifying the codebase.

Detailed changes

All of the design decisions for the commit are detailed in github comments here: Fierthraix@1d1c0b0#diff-639fbc4ef05b315af92b4d836c31b023

structopt

Now everything that relies on parsing possibly faulty user input (like parse_rfc3339_weak) is handled behind the scenes, negating the need for a lot of user code. All standard library types (like float) are autoconverted, saving you from manually changing them from strings. bools are determined from the presence of a flag as well. Things likes regexes are compiled when parsed as well, saving you from doing it manually or forgetting and having it compile every loop iteration. This removes a lot of serialization code in the main function.

using Option

The code has also been refactored to a significant degree. The started with using Option<T> to encode the presence of a flag instead of having both a bool and a variable for the type (as mentioned here). As this is now parsed with structopt, all variables related to cli flags are now encoded in a single struct, making for far fewer variables actually declared.

Custom iterator

Instead of doing a C-style imperative for loop, this has been changed to a more rustic iterator struct. This struct had to be hand-rolled to handle floating point numbers passed with --count-by. The benefit of using the iterator is that the looping logic is separate from the loop, allowing you to check its veracity independently. As well, everything the iterator produces is immutable and prevents accidental iterator invalidation.

[Fierthraix]

Detailed all of the design decisions.

[Miserlou]

Woah, this is huge! Awesome! It's gonna take me a little while to review and digest all this but looks good!