Implement builtin glob function

src/modules/expression/expr.rs

@@ -44,6 +44,7 @@ use super::typeop::{
 use super::parentheses::Parentheses;
 use crate::modules::variable::get::VariableGet;
 use super::ternop::ternary::Ternary;
+use crate::modules::function::glob::GlobInvocation;
 use crate::modules::function::invocation::FunctionInvocation;
 use crate::modules::builtin::nameof::Nameof;
 use crate::{document_expression, parse_expr, parse_expr_group, translate_expression};
@@ -71,6 +72,7 @@ pub enum ExprType {
  Neq(Neq),
  Not(Not),
  Ternary(Ternary),
+ GlobInvocation(GlobInvocation),
  FunctionInvocation(FunctionInvocation),
  Command(Command),
  Array(Array),
@@ -148,6 +150,8 @@ impl SyntaxModule<ParserMetadata> for Expr {
  // Literals
  Parentheses, Bool, Number, Text,
  Array, Null, Nameof, Status,
+ // Builtin invocation
+ GlobInvocation,
  // Function invocation
  FunctionInvocation, Command,
  // Variable access
@@ -176,12 +180,21 @@ impl TranslateModule for Expr {
  Not, Neg, Nameof,
  // Literals
  Parentheses, Bool, Number, Text, Array, Null, Status,
+ // Builtin invocation
+ GlobInvocation,
  // Function invocation
  FunctionInvocation, Command,
  // Variable access
  VariableGet
  ])
  }
+
+ fn conditional(&self, name: &str) -> Option<String> {
+ match &self.value {
+ Some(ExprType::GlobInvocation(value)) => value.conditional(name),
+ _ => None,
+ }
+ }
 }
 
 impl DocumentationModule for Expr {
@@ -201,6 +214,8 @@ impl DocumentationModule for Expr {
  Not, Neg, Nameof,
  // Literals
  Parentheses, Bool, Number, Text, Array, Null, Status,
+ // Builtin invocation
+ GlobInvocation,
  // Function invocation
  FunctionInvocation, Command,
  // Variable access

src/modules/expression/literal/text.rs

@@ -9,6 +9,7 @@ use super::{parse_interpolated_region, translate_interpolated_region};
 pub struct Text {
  strings: Vec<String>,
  interps: Vec<Expr>,
+ escaped: bool,
 }
 
 impl Typed for Text {
@@ -24,11 +25,13 @@ impl SyntaxModule<ParserMetadata> for Text {
  Text {
  strings: vec![],
  interps: vec![],
+ escaped: false,
  }
  }
 
  fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
  (self.strings, self.interps) = parse_interpolated_region(meta, '"')?;
+ self.escaped = meta.context.is_escaped_ctx;
  Ok(())
  }
 }
@@ -39,8 +42,13 @@ impl TranslateModule for Text {
  let interps = self.interps.iter()
  .map(|item| item.translate(meta))
  .collect::<Vec<String>>();
- let quote = meta.gen_quote();
- format!("{quote}{}{quote}", translate_interpolated_region(self.strings.clone(), interps, true))
+ let strings = translate_interpolated_region(self.strings.clone(), interps, true);
+ if self.escaped {
+ strings.replace(" ", "\\ ").replace(";", "\\;")
+ } else {
+ let quote = meta.gen_quote();
+ format!("{quote}{strings}{quote}")
+ }
  }
 }
 

src/modules/function/glob.rs

@@ -0,0 +1,68 @@
+use std::mem::swap;
+
+use heraclitus_compiler::prelude::*;
+use itertools::Itertools;
+use crate::docs::module::DocumentationModule;
+use crate::modules::expression::expr::Expr;
+use crate::modules::types::{Type, Typed};
+use crate::translate::module::TranslateModule;
+use crate::utils::metadata::{ParserMetadata, TranslateMetadata};
+
+#[derive(Debug, Clone)]
+pub struct GlobInvocation {
+ args: Vec<Expr>,
+}
+
+impl Typed for GlobInvocation {
+ fn get_type(&self) -> Type {
+ Type::Array(Box::new(Type::Text))
+ }
+}
+
+impl SyntaxModule<ParserMetadata> for GlobInvocation {
+ syntax_name!("Glob Invocation");
+
+ fn new() -> Self {
+ GlobInvocation {
+ args: vec![],
+ }
+ }
+
+ fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+ token(meta, "glob")?;
+ token(meta, "(")?;
+ let mut new_is_escaped_ctx = true;
+ swap(&mut new_is_escaped_ctx, &mut meta.context.is_escaped_ctx);
+ loop {
+ let tok = meta.get_current_token();
+ let mut arg = Expr::new();
+ syntax(meta, &mut arg)?;
+ if arg.get_type() != Type::Text {
+ return error!(meta, tok, "Expected string");
+ }
+ self.args.push(arg);
+ match token(meta, ")") {
+ Ok(_) => break,
+ Err(_) => token(meta, ",")?,
+ };
+ }
+ swap(&mut new_is_escaped_ctx, &mut meta.context.is_escaped_ctx);
+ Ok(())
+ }
+}
+
+impl TranslateModule for GlobInvocation {
+ fn translate(&self, meta: &mut TranslateMetadata) -> String {
+ self.args.iter().map(|arg| arg.translate(meta)).join(" ")
+ }
+
+ fn conditional(&self, name: &str) -> Option<String> {
+ Some(format!("[ -e \"${{{}}}\" ]", name))
+ }
+}
+
+impl DocumentationModule for GlobInvocation {
+ fn document(&self, _meta: &ParserMetadata) -> String {
+ "".to_string()
+ }
+}

src/modules/function/mod.rs

@@ -1,5 +1,6 @@
 pub mod declaration;
 pub mod declaration_utils;
+pub mod glob;
 pub mod invocation;
 pub mod invocation_utils;
 pub mod ret;

src/modules/loops/iter_loop.rs

@@ -80,22 +80,48 @@ impl TranslateModule for IterLoop {
  meta.increase_indent();
  let indent = meta.gen_indent();
  meta.decrease_indent();
- [
- format!("{index}=0;"),
- format!("for {name} in {expr}"),
- "do".to_string(),
- self.block.translate(meta),
- format!("{indent}(( {index}++ )) || true"),
- "done".to_string(),
- ].join("\n")
+ if let Some(conditional) = self.iter_expr.conditional(name) {
+ [
+ format!("{index}=0;"),
+ format!("for {name} in {expr}"),
+ "do".to_string(),
+ format!("if {conditional}"),
+ "then".to_string(),
+ self.block.translate(meta),
+ format!("{indent}(( {index}++ )) || true"),
+ "fi".to_string(),
+ "done".to_string(),
+ ].join("\n")
+ } else {
+ [
+ format!("{index}=0;"),
+ format!("for {name} in {expr}"),
+ "do".to_string(),
+ self.block.translate(meta),
+ format!("{indent}(( {index}++ )) || true"),
+ "done".to_string(),
+ ].join("\n")
+ }
  },
  None => {
- [
- format!("for {name} in {expr}"),
- "do".to_string(),
- self.block.translate(meta),
- "done".to_string(),
- ].join("\n")
+ if let Some(conditional) = self.iter_expr.conditional(name) {
+ [
+ format!("for {name} in {expr}"),
+ "do".to_string(),
+ format!("if {conditional}"),
+ "then".to_string(),
+ self.block.translate(meta),
+ "fi".to_string(),
+ "done".to_string(),
+ ].join("\n")
+ } else {
+ [
+ format!("for {name} in {expr}"),
+ "do".to_string(),
+ self.block.translate(meta),
+ "done".to_string(),
+ ].join("\n")
+ }
  },
  }
  }

src/tests/validity/glob_absolute_missing_file.ab

@@ -0,0 +1,32 @@
+import * from "std/text"
+
+// Output
+// ===
+// ===
+// ===
+
+main {
+ let tmpdir = unsafe $ mktemp -d $
+ unsafe {
+ $ touch {tmpdir}/1st\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/2nd\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/file1.txt $
+ $ touch {tmpdir}/file2.txt $
+ $ touch {tmpdir}/other1.csv $
+ $ touch {tmpdir}/other2.csv $
+ }
+
+ echo "==="
+ loop file in glob("{tmpdir}/missing*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo file
+ }
+ echo "==="
+ loop index, file in glob("{tmpdir}/missing*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo "{index}: {file}"
+ }
+ echo "==="
+
+ unsafe $ rm -rf {tmpdir} $
+}

src/tests/validity/glob_absolute_multiple_globs.ab

@@ -0,0 +1,40 @@
+import * from "std/text"
+
+// Output
+// ===
+// /tmp/tmpdir/file1.txt
+// /tmp/tmpdir/file2.txt
+// /tmp/tmpdir/other1.csv
+// /tmp/tmpdir/other2.csv
+// ===
+// 0: /tmp/tmpdir/file1.txt
+// 1: /tmp/tmpdir/file2.txt
+// 2: /tmp/tmpdir/other1.csv
+// 3: /tmp/tmpdir/other2.csv
+// ===
+
+main {
+ let tmpdir = unsafe $ mktemp -d $
+ unsafe {
+ $ touch {tmpdir}/1st\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/2nd\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/file1.txt $
+ $ touch {tmpdir}/file2.txt $
+ $ touch {tmpdir}/other1.csv $
+ $ touch {tmpdir}/other2.csv $
+ }
+
+ echo "==="
+ loop file in glob("{tmpdir}/missing*", "{tmpdir}/file*", "{tmpdir}/*.csv") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo file
+ }
+ echo "==="
+ loop index, file in glob("{tmpdir}/missing*", "{tmpdir}/file*", "{tmpdir}/*.csv") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo "{index}: {file}"
+ }
+ echo "==="
+
+ unsafe $ rm -rf {tmpdir} $
+}

src/tests/validity/glob_absolute_no_spaces.ab

@@ -0,0 +1,36 @@
+import * from "std/text"
+
+// Output
+// ===
+// /tmp/tmpdir/file1.txt
+// /tmp/tmpdir/file2.txt
+// ===
+// 0: /tmp/tmpdir/file1.txt
+// 1: /tmp/tmpdir/file2.txt
+// ===
+
+main {
+ let tmpdir = unsafe $ mktemp -d $
+ unsafe {
+ $ touch {tmpdir}/1st\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/2nd\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/file1.txt $
+ $ touch {tmpdir}/file2.txt $
+ $ touch {tmpdir}/other1.csv $
+ $ touch {tmpdir}/other2.csv $
+ }
+
+ echo "==="
+ loop file in glob("{tmpdir}/file*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo file
+ }
+ echo "==="
+ loop index, file in glob("{tmpdir}/file*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo "{index}: {file}"
+ }
+ echo "==="
+
+ unsafe $ rm -rf {tmpdir} $
+}

src/tests/validity/glob_absolute_with_spaces.ab

@@ -0,0 +1,36 @@
+import * from "std/text"
+
+// Output
+// ===
+// /tmp/tmpdir/1st file with spaces.txt
+// /tmp/tmpdir/2nd file with spaces.txt
+// ===
+// 0: /tmp/tmpdir/1st file with spaces.txt
+// 1: /tmp/tmpdir/2nd file with spaces.txt
+// ===
+
+main {
+ let tmpdir = unsafe $ mktemp -d $
+ unsafe {
+ $ touch {tmpdir}/1st\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/2nd\ file\ with\ spaces.txt $
+ $ touch {tmpdir}/file1.txt $
+ $ touch {tmpdir}/file2.txt $
+ $ touch {tmpdir}/other1.csv $
+ $ touch {tmpdir}/other2.csv $
+ }
+
+ echo "==="
+ loop file in glob("{tmpdir}/*with spaces*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo file
+ }
+ echo "==="
+ loop index, file in glob("{tmpdir}/*with spaces*") {
+ file = replace_regex(file, tmpdir, "/tmp/tmpdir", true)
+ echo "{index}: {file}"
+ }
+ echo "==="
+
+ unsafe $ rm -rf {tmpdir} $
+}