0.5.0: Major Overhaul

0.5.0: Input Disk Buffering; Error Handling; & More

This release required a ton of work to accomplish, and about two
weeks of my life, as I wanted to ensure that I wrote it as
efficiently as possible. Additional performance optimizations
will be performed in the future.

There are a significant number of changes in this release, but for
the end user this will mainly improve performance, drastically
reduce memory consumption, and fix the bug that causes the program
to hang when spawning a large number of processes. This bug was
caused by spawned children not automatically releasing their handles
as intended. Errors will now also be logged and re-printed at the
end of the program.

With this release, arguments will first be efficiently buffered
to the disk using a custom `DiskBufferWriter` structure that
works entirely with a fixed-size 8K byte array. The structures
is created from a `DiskBuffer` which transforms into either a
`DiskBufferReader` or a `DiskBufferWriter` depending upon whether
the `read()` or `write()` method was called. When the byte array is
full, the data will be written to the disk. This is significantly
more efficient than using the default BufWriter structure, consuming
far less syscalls.

Once all arguments have been written to the disk, the tokenizer
will generate tokens from the command argument if one was given,
but will now instantly replace instances of `JobTotal` and
`Number` tokens during the tokenizing phase, because this
information is known during initialization.

The end of the initialization phase is now marked by the creation
of an `InputIterator` structure, which contains an `InputBuffer`
with higher level information on an internal `DiskBufferReader`.
The iterator is wrapped inside of an atomic reference-counted
mutex and shared among threads. Threads will continue to consume
from the iterator until the iterator returns `None`.

Finally, the entirety of the codebase was refactored into smaller
modules, which took a large amount of time, but the result is
code being easier to read and manage.

0.4.1: Bug Fix to Permutation Update

Resolves panic when no arguments are provided, and adds a help message for when parsing errors occur.

0.4.0: Permutation Support

This change adds support for permutating inputs when there are multiple input lists provided to the program. Input modes have been updated to work precisely as they do in GNU Parallel, with ::: creating a new list with new input arguments, :::+ appending arguments to the current list, :::: creating a new list with inputs from files, and ::::+ appending inputs from files to the current list.

Update: Found a bug, will update release with fixed packages soon.
Update2: Updated release here

0.3.0: {N} Token Support

With this new major release, Rust Parallel has gained the ability of supporting {N} tokens, which is a placeholder for the Nth input in the input list. The support for this feature was made possible through recursion and pattern matching in the tokenizer() function. The Token::Number token was added, which contains both a number and a Token itself. Pattern matching is done to ensure that the embedded token is not an invalid Token, such as putting a Token::Number inside of a Token::Number.

Additionally, I've made a number of bug fixes along with a newly-added unit test.

0.2.3: File Input Support

This change will modify the parsing code to use an enum for switching between modes, and the new input mode being added is support for files that contain inputs as input arguments. This will also enable support for the abili

seq 1 10 > list
parallel 'echo {}' ::: starting :::: list ::: done

0.2.2: Bug Fixes

0.2.2: Fix Bugs with Verbose & Ungrouped

I swapped the values for the number of threads and inputs in verbose mode. I also caused ungrouped mode to be utterly incapable of executing. This will fix that.

0.2.1: Feature Addition & Bug Fix

This change will fix the test units, add a new test unit, and allow for the parsing of arguments when using --no-shell mode. Before, when using --no-shell, arguments with spaces would be interpreted as completely separate arguments. Now, arguments can contain spaces if they are double quoted, or if the space follows a backslash.

0.2.0: Feature Overhaul

• Added ability to disable the platform's shell with -n or --no-shell.
• Added ability to print verbose information with -v or --verbose.
• When grouping is enabled, the child processes will have their standard output and error piped.
  • Messages will be printed to standard output/error on demand as soon as they become available.

0.1.1: Feature Addition

Runs commands within the operating system's shell to allow for multiple commands within a command:

parallel 'cd {}; echo ==={}===; ls' ::: $(find -type d)

0.1.0: First Release

0.1.0 Release