Extend ability to choose steps to run

.github/actions/prepare-environment/action.yaml

@@ -7,15 +7,17 @@ runs:
     - name: System requirements
       shell: bash
       run: |
-        sudo apt-get update & sudo apt upgrade -y
+        sudo apt-get update
         sudo apt-get install -y build-essential \
           curl \
           git
 
     - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
+      shell: bash
+      run: |
+        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+        export PATH="$HOME/.cargo/bin:$PATH"
+        echo "$HOME/.cargo/bin:$PATH" >> $GITHUB_PATH
 
     - name: Setup rust fmt
       shell: bash

actionoscope-cli/src/main.rs

@@ -4,7 +4,7 @@ use log::{error, info};
 use std::path::{Path, PathBuf};
 use std::{env, fs};
 
-use actionoscope::Workflow;
+use actionoscope::{Job, Workflow};
 
 #[derive(Debug, Parser)]
 #[command(name = "actionoscope")]
@@ -15,11 +15,11 @@ use actionoscope::Workflow;
 struct Cli {
     /// Path to the workflow YAML file
     #[arg(long, short = 'w')]
-    workflow_file: String,
+    workflow_file: Option<String>,
 
     /// Job name to run
     #[arg(long, short = 'j')]
-    job: String,
+    job: Option<String>,
 
     /// Step name or id to run
     #[arg(long, short = 's')]
@@ -28,6 +28,10 @@ struct Cli {
     /// Step name or id to start running from
     #[arg(long, short = 'f')]
     from_step: Option<String>,
+
+    /// Step name or id to start running from
+    #[arg(long, short = 't')]
+    to_step: Option<String>,
 }
 
 fn validate_workflow_file(workflows_dir: &Path, workflow_file: &str) -> Option<PathBuf> {
@@ -39,17 +43,42 @@ fn validate_workflow_file(workflows_dir: &Path, workflow_file: &str) -> Option<P
     }
 }
 
-fn find_workflow_file(workflow_file: &str) -> Option<PathBuf> {
+fn find_workflow_files(
+    workflow_file: Option<String>,
+) -> Result<Vec<PathBuf>, Box<dyn std::error::Error>> {
     let current_dir = Path::new(".");
-    let workflow_path = validate_workflow_file(&current_dir, workflow_file);
+    let workflows_dir = current_dir.join(".github").join("workflows");
+    let mut result = Vec::new();
+    if let Some(workflow_file) = workflow_file {
+        // check if the file exists in the current directory
+        let workflow_path = validate_workflow_file(current_dir, &workflow_file);
+        if let Some(path) = workflow_path {
+            result.push(path);
+            return Ok(result);
+        }
 
-    if workflow_path.is_some() {
-        return workflow_path;
+        // fallback: check if the file exists in the .github/workflows directory
+        let exists = validate_workflow_file(&workflows_dir, &workflow_file);
+        if let Some(path) = exists {
+            result.push(path);
+            return Ok(result);
+        }
+        let err = format!("Provided workflow file {} was not found", workflow_file);
+        return Err(err.into());
+    }
+    for entry in fs::read_dir(workflows_dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_file() {
+            result.push(path);
+        }
     }
 
-    let workflows_dir = current_dir.join(".github").join("workflows");
-
-    validate_workflow_file(&workflows_dir, workflow_file)
+    if !result.is_empty() {
+        Ok(result)
+    } else {
+        Err("No workflow files found in .github/workflows directory".into())
+    }
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -63,47 +92,83 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     let cli = Cli::parse();
-    if cli.step.is_none() && cli.from_step.is_none() {
-        error!("Error: Either 'step' or 'from-step' argument must be specified.");
-        std::process::exit(1);
-    }
-
-    let workflow_file = find_workflow_file(&cli.workflow_file).unwrap_or_else(|| {
-        error!("Workflow file '{}' not found", &cli.workflow_file);
-        std::process::exit(1);
-    });
 
-    info!("Found workflow file: {}", workflow_file.to_string_lossy());
+    let workflow_files = find_workflow_files(cli.workflow_file)?;
+
+    info!(
+        "Found workflow file(s): {}",
+        workflow_files
+            .iter()
+            .map(|w| w.to_string_lossy())
+            .collect::<Vec<_>>()
+            .join(", ")
+    );
+
+    for workflow_file in &workflow_files {
+        let workflow_content = fs::read_to_string(workflow_file.to_string_lossy().into_owned())
+            .unwrap_or_else(|err| {
+                error!("Failed to read the workflow file: {}", err);
+                std::process::exit(1);
+            });
 
-    let workflow_content = fs::read_to_string(workflow_file.to_string_lossy().into_owned())
-        .unwrap_or_else(|err| {
-            error!("Failed to read the workflow file: {}", err);
+        let workflow = Workflow::from_yaml(&workflow_content).unwrap_or_else(|err| {
+            error!("Failed to parse the workflow file: {}", err);
             std::process::exit(1);
         });
 
-    let workflow = Workflow::from_yaml(&workflow_content).unwrap_or_else(|err| {
-        error!("Failed to parse the workflow file: {}", err);
-        std::process::exit(1);
-    });
-
-    let job = workflow.get_job(&cli.job).unwrap_or_else(|| {
-        error!("Job '{}' not found in the workflow", cli.job);
-        std::process::exit(1);
-    });
-
-    let step_name: &str = &cli.step.as_deref().or(cli.from_step.as_deref()).unwrap();
-    let first_step = job.get_step(step_name).unwrap_or_else(|| {
-        error!("Step '{}' not found in the job '{}'", step_name, cli.job);
-        std::process::exit(1);
-    });
-
-    if cli.step.is_some() {
-        first_step.run_cmd(workflow.env.clone())?;
-    } else {
-        for step in &job.get_all_steps_since(step_name) {
-            if let Err(e) = step.run_cmd(workflow.env.clone()) {
-                error!("Error running step '{}': {}", step.get_name_or_id(), e);
+        let mut jobs: Vec<&Job> = Vec::new();
+        let mut job_names: Vec<String> = Vec::new();
+        if cli.job.is_some() {
+            let job_name = &cli.job.clone().unwrap();
+            let job = workflow.get_job(job_name).unwrap_or_else(|| {
+                error!("Job '{}' not found in the workflow", job_name);
                 std::process::exit(1);
+            });
+            job_names.push(job_name.to_string());
+            jobs.push(job);
+        } else {
+            for (name, job) in &workflow.jobs {
+                job_names.push(name.clone());
+                jobs.push(job);
+            }
+        }
+
+        for (index, job) in jobs.iter().enumerate() {
+            info!("Running job '{}'", job_names[index]);
+            if cli.step.is_some() {
+                let step_name = &cli.step.clone().unwrap();
+                let step = job.get_step(step_name).unwrap_or_else(|| {
+                    error!("Step '{}' not found in the job '{:?}'", step_name, job);
+                    std::process::exit(1);
+                });
+                step.run_cmd(workflow.env.clone())?;
+            } else {
+                if cli.from_step.is_some()
+                    && job.get_step(&cli.from_step.clone().unwrap()).is_none()
+                {
+                    error!(
+                        "from-step '{}' not found in the job '{}'",
+                        cli.from_step.clone().unwrap(),
+                        job_names[index]
+                    );
+                    std::process::exit(1);
+                }
+                if cli.to_step.is_some() && job.get_step(&cli.to_step.clone().unwrap()).is_none() {
+                    error!(
+                        "to-step '{}' not found in the job '{}'",
+                        cli.to_step.clone().unwrap(),
+                        job_names[index]
+                    );
+                    std::process::exit(1);
+                }
+                for step in
+                    &job.get_all_steps_since(cli.from_step.as_deref(), cli.to_step.as_deref())
+                {
+                    if let Err(e) = step.run_cmd(workflow.env.clone()) {
+                        error!("Error running step '{}': {}", step.get_name_or_id(), e);
+                        std::process::exit(1);
+                    }
+                }
             }
         }
     }

src/lib.rs

@@ -1,4 +1,4 @@
-use log::{error, info};
+use log::{error, info, warn};
 use serde::Deserialize;
 use std::io::{BufRead, BufReader};
 use std::process::Command;
@@ -48,17 +48,30 @@ impl Job {
             step.name.as_deref() == Some(id_or_name) || step.id.as_deref() == Some(id_or_name)
         })
     }
-    pub fn get_all_steps_since(&self, id_or_name: &str) -> Vec<&Step> {
+    pub fn get_all_steps_since(
+        &self,
+        start_step_id_or_name: Option<&str>,
+        end_step_id_or_name: Option<&str>,
+    ) -> Vec<&Step> {
         let mut steps = Vec::new();
         let mut found = false;
         for step in &self.steps {
-            if step.name.as_deref() == Some(id_or_name) || step.id.as_deref() == Some(id_or_name) {
+            if start_step_id_or_name.is_none()
+                || step.name.as_deref() == start_step_id_or_name
+                || step.id.as_deref() == start_step_id_or_name
+            {
                 found = true;
             }
 
             if found {
                 steps.push(step);
             }
+            if end_step_id_or_name.is_some()
+                && (step.name.as_deref() == end_step_id_or_name
+                    || step.id.as_deref() == end_step_id_or_name)
+            {
+                break;
+            }
         }
         steps
     }
@@ -107,16 +120,24 @@ impl Step {
     ) -> Result<(), Box<dyn std::error::Error>> {
         let step_id = self.get_name_or_id();
         if self.run.is_none() {
-            let err = format!("No run command found for step id/name '{step_id}'");
-            error!(
-                "{}; Step details are:\nname: {}\nid: {}\nuses: {}\nshell: {}",
-                err,
-                self.name.as_deref().unwrap_or("NA"),
-                self.id.as_deref().unwrap_or("NA"),
-                self.uses.as_deref().unwrap_or("NA"),
-                self.shell.as_deref().unwrap_or("NA")
-            );
-            return Err(err.into());
+            if self.uses.is_none() {
+                let err = format!("No run command found for step id/name '{step_id}'");
+                error!(
+                    "{}; Step details are:\nname: {}\nid: {}\nuses: {}\nshell: {}",
+                    err,
+                    self.name.as_deref().unwrap_or("NA"),
+                    self.id.as_deref().unwrap_or("NA"),
+                    self.uses.as_deref().unwrap_or("NA"),
+                    self.shell.as_deref().unwrap_or("NA")
+                );
+                return Err(err.into());
+            } else {
+                warn!(
+                    "Currently, 'uses' is not supported. Skipping step '{}'",
+                    step_id
+                );
+                return Ok(());
+            }
         }
 
         let command = self.run.as_deref().unwrap();

tests/workflow_tests.rs

@@ -90,7 +90,41 @@ fn test_get_all_steps_since() {
 
     let workflow = Workflow::from_yaml(yaml_data).expect("Failed to parse YAML");
     let job = workflow.get_job("test_job").expect("Job not found");
-    let steps = job.get_all_steps_since("step2");
+    let steps = job.get_all_steps_since(Some("step2"), None);
+    assert_eq!(steps.len(), 2);
+    assert_eq!(steps[0].get_name_or_id(), "Step 2");
+    assert_eq!(steps[1].get_name_or_id(), "Step 3");
+}
+
+#[test]
+fn test_get_all_steps_since_and_until() {
+    let yaml_data = r#"
+    name: Test Workflow
+    on:
+      push:
+        branches:
+          - main
+    jobs:
+      test_job:
+        runs-on: ubuntu-latest
+        steps:
+          - name: Step 1
+            id: step1
+            run: echo "Step 1"
+          - name: Step 2
+            id: step2
+            run: echo "Step 2"
+          - name: Step 3
+            id: step3
+            run: echo "Step 3"
+          - name: Step 4
+            id: step4
+            run: echo "Step 4"
+    "#;
+
+    let workflow = Workflow::from_yaml(yaml_data).expect("Failed to parse YAML");
+    let job = workflow.get_job("test_job").expect("Job not found");
+    let steps = job.get_all_steps_since(Some("step2"), Some("step3"));
     assert_eq!(steps.len(), 2);
     assert_eq!(steps[0].get_name_or_id(), "Step 2");
     assert_eq!(steps[1].get_name_or_id(), "Step 3");