Implement code expander

[manta1130]

Closes #9
Closes #34

I have developed a script to combine the code into a single file at submission.

Usage

• Import dsu

./expand.py dsu

• Import dsu,fenwicktree

./expand.py dsu fenwicktree

• Import convolution,internal_bit,modint,internal_math,internal_type_traits(Recursively resolving dependency)

./expand.py convolution

- Import dsu with comments

./expand.py --output-comment dsu

Problems

I removed the process to erase comments and test codes.
These problems were resolved.
- Removing test code
It removes the test code by looking for #[cfg(test)] on the source code and not reading after it in this implement.
Therefore,if another code exists below the test code, it will disappear.

- Removing comment
It simply looks for the // and delete the comment by not loading that line.
It can't remove multiple line comments(using /* ... */).

[qryxip]

Do you think the "problems" should be resolved in the future? They seem to be hard to resolve with naive text-processing.

Just to be sure, could you list pros & cons of text searching in Python and token parsing in Rust that you think?

[manta1130]

@qryxip

Do you think the "problems" should be resolved in the future? They seem to be hard to resolve with naive text-processing.

I think it's hard to solve the problem with a simple implement.
The process to erase comments and test codes is not important, I'm considering remove it.
I think this would obviously impose some weird constraints on the writer of the code if it's not change this script.
(e.g. The test code has to be written at the bottom of the file.)

Just to be sure, could you list pros & cons of text searching in Python and token parsing in Rust that you think?

I think the following.

Advantages of this script:

• It works with a single file.

• It can select import modules.

Disadvantages of this script:

• The dependencies of the module have to be described in the script.

[qryxip]

Here are advantages/disadvantages of Rust implementation that I thought.

1. Advantages
   1.1. In Rust, we can use proc-macro(2) and syn. That means we can easily add features in a robust way such as removing #[cfg(test)] items without imposing extra constraints.
   1.2. Written in Rust, we can provide a standalone binary that users can use without git clone, though we'd able to run Python script in it like Command::new("python").args(["-c", include_str!("../path/to/expand.py")]).

   $ cargo install ac-library-rs

   $ ac-library-rs convolution >> ./src/bin/a.rs

2. Disadvantages
   2.1. The dependencies of the each module have to be explicitly described, too. Or rather, detecting dependencies is too hard by itself.
   2.2. It needs to be build. The CI will take about 60s longer.
   2.3. Larger than Python single file.

By the way, does "It works with a single file" mean "small, so it's easy to maintain"? If so, I agree with it.

Anyway, without the "removing docs & tests" function, I think that script is reasonable to Rust implementation.

[qryxip]

Why not apply Rustfmt with subprocess.run(..)?

[manta1130]

I added the process of rustfmt.