omr-bumper 0.3.16-dev

An opiniated version bumper for releases. Works for us.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Does all the necessary preparation to have github build a release.
//!
//! - Prepare release
//!		- Checks workspace/git is clean
//!		- Removes -dev from version, and replaces by alpha/beta/[none]
//!		- Update Cargo.lock `cargo update --workspace --dry-run --verbose`
//!		- Commmits Cargo.toml (and other files as needed)
//!		- Pushes to git
//!		- Tags the release
//!		- Pushes the tag
//! - Prepare to continue with development
//!		- Bumps the local version patch/minor/major
//!		- Commits Cargo.toml
//!		- Pushes to git

use anyhow::bail;
use clap::Parser;
use omr_bumper::Release;

const VERSION: &str = env!("CARGO_PKG_VERSION");

#[derive(Parser)]
#[command(name = "omr-bumper")]
#[command(author = "Andreas N. <andreas@omni-mad.com")]
#[command(version = VERSION)]
#[command(about = "Bump version, and push to git with tag", long_about = None)]
struct Cli {
	#[arg(short = 'r', long)]
	pre_release_suffix: Option<String>,
	#[arg(short = 'b', long)]
	bump_level:         Option<String>,
	#[arg(long)]
	allow_dirty:        bool,
	#[arg(long)]
	skip_git:           bool,
	#[arg(long)]
	skip_push:          bool,
	#[arg(long)]
	skip_tag:           bool,
	#[arg(long)]
	skip_all:           bool,
	#[arg(long)]
	path:               Option<String>,
}

pub fn main() -> anyhow::Result<()> {
	tracing_subscriber::fmt::init();

	let cli = Cli::parse();
	let pre_release_suffix = cli
		.pre_release_suffix
		.unwrap_or(String::from("alpha"))
		.to_string();
	let bump_level = cli.bump_level.unwrap_or(String::from("patch")).to_string();
	let allow_dirty = cli.allow_dirty;
	let skip_git = cli.skip_git;
	let skip_push = cli.skip_push;
	let skip_tag = cli.skip_tag;
	let skip_all = cli.skip_all;
	let path = cli.path.unwrap_or(String::from(".")).to_string();

	if ![
		"patch".to_string(),
		"minor".to_string(),
		"major".to_string(),
	]
	.contains(&bump_level)
	{
		println!(
			"Error: Invalid bump level {} should be patch/minor/major",
			&bump_level
		);
		bail!("Usage Error");
	};

	println!("Pre Release Suffix : {}", pre_release_suffix);
	println!("Bump Level         : {}", bump_level);
	//	println!( "Allow Dirty        : {}", allow_dirty?"yes":"no" );
	println!(
		"Allow Dirty        : {}",
		if allow_dirty { "yes" } else { "no" }
	);
	println!(
		"Skip Git           : {}",
		if skip_git { "yes" } else { "no" }
	);
	println!(
		"Skip Push          : {}",
		if skip_push { "yes" } else { "no" }
	);
	println!(
		"Skip Tag           : {}",
		if skip_tag { "yes" } else { "no" }
	);
	println!(
		"Skip All           : {}",
		if skip_all { "yes" } else { "no" }
	);
	println!("Path               : {}", path);

	let mut release = Release::new();

	release.set_pre_release_suffix(&pre_release_suffix);
	release.set_bump_level(&bump_level)?;
	release.set_allow_dirty(allow_dirty);
	release.set_skip_git(skip_git);
	release.set_skip_push(skip_push);
	release.set_skip_tag(skip_tag);
	release.set_skip_all(skip_all);
	release.set_path(&path);

	//	dbg!( &release );

	match release.run() {
		Ok(_) => {},
		Err(e) => {
			println!("Error: {}", e);
		},
	};
	Ok(())
}