ekkolon/licensa

Seamless source code license management from your command line

licensa's Issues

feat: improve output statistics for `verify` command

feat(cli): add utilities to find license candidates

refactor: remove unused tools and licenses directory

feat(cli): add basic `apply` subcommand functionality

build: remove unused crates

fix: remove null values before saving `.licensarc` JSON

test(cli): add various source files

style(repo): align with recommended Rust style guide

Add various README sections (usage, examples, etc)

feat: use spdx crate to verify and render spdx expressions

Description

Right now, we are only handling license IDs from the choosealicense repository, yet we could use the spdx crate for that. Additionally, the approach used right now isn't robust and fails validation even though license expressions provided by the user are valid SPDX expressions.

For example, executing the following command fails:

licensa apply --type "MIT or Apache-2.0"

We should allow the user to provide 'imprecise' license ids, since the spdx crate provides a nice function to infer valid SPDX ids from them.

In cases where the user supplies an imprecise license ID for which one or more valid SPDX ids can be inferred, we should prompt the user to select and confirm the valid license id.

This could look like this:

licensa apply --type "BSD"
...

# Select and confirm license id 

Which kind of BSD license would you like to use?:

- BSD-1-Clause
- BSD-2-Clause
- BSD-3-Clause
...etc

Tasks

• Add function that takes as input a string and returns a result containing the list of inferred license ids. An error indicates that the provided id is invalid
• Add prompt functionality using the inquirer crate

bug: missing `.licensaignore` generation logic executing `init` command

feat: use template engine to render license headers

feat: add `--include` flag to `verify` and `apply` subcommands

feat(cli): add CLI `--dry-run` flag

Description:

Objective:
Implement a --dry-run flag in the CLI to allow users to simulate the licensing process without making actual changes to files.

Features:

• Introduce a --dry-run flag for the CLI.
• When the --dry-run flag is used, the CLI should output the intended changes without applying them.
• Ensure that the dry run accurately reflects the actions that would be taken during a regular run.

Motivation:

• Users may want to preview the changes the CLI will make before applying them.
• Enhances user confidence in the licensing process.

Tasks:

• CLI Modification:

  • Add support for the --dry-run flag in the CLI parsing logic.

• Simulation Output:

  • Implement the logic to simulate the licensing process without actually modifying files.
  • Output the intended changes to the console.

• Documentation:

  • Update the CLI documentation to include information about the new --dry-run flag.
  • Provide examples and usage instructions.

• Testing:

  • Create test cases to ensure that the --dry-run flag functions as expected.
  • Include tests for various scenarios, including different licensing configurations.

bug(cli): don't raise interpolation error when license year is None

build: sign release build with my GPG key

bug: invalid type null error when running `apply` command

This is caused by the exclude flag: when it's not present in the .licensarc config file or is not provided

ci: add release workflow

bug: `--exclude` flag does not have any effect

bug(cli): invalid year range error when using 'to present' format (e.g 2023-present)

Add cross-platform install script

Tasks

• Add install script for Windows platforms
• Add install script for Linux
• Add install script for MacOS

bug: Windows PowerShell script incorrectly exits instead returning after its done

feat: improve output statistics for `apply` command

refactor(cli): improve code organization

Right now, we have functionality split all over the place. Although this is fine for the moment, due to the many changes that are made rapidly to the repo, this is not a viable option for the future.

We should split our code into logical units to reduce complexcity and ultimately improve maintainability.

feat(repo): add Rust CI workflow