webbdays•8mo ago

regex pattern in rust

I need help with regex pattern making. lets say there are some files with .md but i should not match .skip.md Help me with this negations pattern.

13 Replies

Deno AI Helper•8mo ago

In Rust, regex patterns follow a similar syntax to many other languages with Perl-compatible regular expressions (PCRE). To create a regex pattern that matches .md files but excludes those ending with .skip.md, you can use a negative lookbehind assertion. However, it's important to note that the regex engine used in Rust's regex crate does not support lookbehind assertions due to their potential for unpredictable performance. That said, you can achieve the desired effect by matching strings that end with .md and do not have .skip.md at the end. Here's a pattern that would work assuming the regex engine supported lookbehind, which is for illustrative purposes only:

(?<!\.skip)\.md$

(?<!\.skip)\.md$

Since Rust's regex engine doesn't support lookbehind, you would typically work around this limitation by matching all .md files and then filtering out the .skip.md files using Rust's own string methods or by checking the matches in a separate step. Here's an example of how you might do it in Rust code:

use regex::Regex;

fn main() {
    let re = Regex::new(r"\.md$").unwrap();
    let filenames = vec!["example.md", "test.skip.md", "tutorial.md"];

    for filename in filenames {
        if re.is_match(filename) && !filename.ends_with(".skip.md") {
            println!("Matched: {}", filename);
        }
    }
}

use regex::Regex;

fn main() {
    let re = Regex::new(r"\.md$").unwrap();
    let filenames = vec!["example.md", "test.skip.md", "tutorial.md"];

    for filename in filenames {
        if re.is_match(filename) && !filename.ends_with(".skip.md") {
            println!("Matched: {}", filename);
        }
    }
}

In this code, we first match all filenames that end with .md, and then we manually exclude those that end with .skip.md using the ends_with method. Remember, the documentation for Deno does not provide specific guidance on Rust regex patterns, so the above example is a general Rust solution and not specific to Deno. If you're working within the Deno environment and need to match files with a specific pattern, you would use

Deno AI Helper•8mo ago

JavaScript/TypeScript regex patterns and Deno's file system APIs to filter your files accordingly. 🦕

Helpful Links: Handling complex routes | Fresh docs Deno Docs Deno Docs Deno Docs /semver/mod.ts | std@0.207.0 | Deno Deno Docs Deno 1.10 Release Notes

webbdaysOP•8mo ago

thanks. its clear now. @Deno AI Helper how about i handle a list of files names and filter them out with another regex. now. we have list of files names without those ending with .skip.md now make a regex pattern using these file names.

Deno AI Helper•8mo ago

If you have a list of filenames and you've already filtered out the ones ending with .skip.md, you can create a regex pattern that matches any of the remaining filenames. To do this, you would typically join the filenames into a single pattern, separating them with the | (alternation) operator, which acts like a logical OR in regex. Here's a general approach in Rust, assuming you have a vector of filenames that don't end with .skip.md:

use regex::Regex;

fn main() {
    let filenames = vec!["example.md", "tutorial.md"]; // already filtered list
    let pattern = filenames.join("|"); // Join filenames with the regex OR operator
    let re = Regex::new(&pattern).unwrap();

    // Test the regex pattern
    let test_filenames = vec!["example.md", "tutorial.md", "test.skip.md", "another_example.md"];
    for test_filename in test_filenames {
        if re.is_match(test_filename) {
            println!("Matched: {}", test_filename);
        }
    }
}

use regex::Regex;

fn main() {
    let filenames = vec!["example.md", "tutorial.md"]; // already filtered list
    let pattern = filenames.join("|"); // Join filenames with the regex OR operator
    let re = Regex::new(&pattern).unwrap();

    // Test the regex pattern
    let test_filenames = vec!["example.md", "tutorial.md", "test.skip.md", "another_example.md"];
    for test_filename in test_filenames {
        if re.is_match(test_filename) {
            println!("Matched: {}", test_filename);
        }
    }
}

In this example, filenames is a vector of strings that contains the filenames you want to match. We join them into a single string with the join method, using the | operator as the separator. This creates a pattern like example.md|tutorial.md, which will match any string that is exactly example.md or tutorial.md. Please note that this approach assumes that the filenames do not contain any characters that would have special meaning in a regex pattern (such as ., which means "any character" in regex). If they do, you'll need to escape those characters. Since this is a general Rust solution and not specific to Deno, please ensure that it fits your use case and double-check the accuracy of the advice given. If you're working within Deno, you would use JavaScript/TypeScript to construct your

Deno AI Helper•8mo ago

regex patterns and work with the file system.

Helpful Links: Handling complex routes | Fresh docs Operations | Deno Docs Deno Docs Deno Docs Deno Docs Routing | Fresh docs Deno 1.34: deno compile supports npm packages

webbdaysOP•8mo ago

@Deno AI Helper i am talking here about regex pattern in the datatest-stable for file based testing here....

Deno AI Helper•8mo ago

I apologize for the confusion earlier. In Deno's datatest-stable module, which is used for file-based testing, you can specify a regex pattern to match the files you want to include in your tests. If you have already filtered out filenames that end with .skip.md and you want to create a regex pattern to match the remaining filenames for your tests, you can do so by constructing a regex pattern that matches the exact filenames you want to test. Here's an example of how you might use a regex pattern in a Deno datatest-stable test:

import { datatest } from "https://deno.land/x/datatest/mod.ts";

// Assuming `fileNames` is an array of filenames you want to test
const fileNames = ["example.md", "tutorial.md"];
const pattern = fileNames.map((f) => f.replace(/\./g, '\\.')).join("|");

datatest({
  pattern: new RegExp(pattern),
  // ... other options
}, (filename) => {
  // Your test code here
});

import { datatest } from "https://deno.land/x/datatest/mod.ts";

// Assuming `fileNames` is an array of filenames you want to test
const fileNames = ["example.md", "tutorial.md"];
const pattern = fileNames.map((f) => f.replace(/\./g, '\\.')).join("|");

datatest({
  pattern: new RegExp(pattern),
  // ... other options
}, (filename) => {
  // Your test code here
});

In this example, fileNames is an array of filenames that you want to include in your tests. We map over the fileNames array to escape any dots, as they have a special meaning in regex (they match any character). Then we join the escaped filenames with the | operator to create a pattern that matches any of the filenames in the list. Please note that this advice is not based on the Deno documentation, and you should double-check the accuracy of the advice given. Make sure to test your regex pattern to ensure it matches exactly the files you intend to include in your tests.

Helpful Links: Handling complex routes | Fresh docs Deno Docs Deno Docs Deno 1.10 Release Notes Deno Docs Deno 1.37: Modern JavaScript in Jupyter Notebooks

webbdaysOP•8mo ago

is it in deno? @Deno AI Helper

Deno AI Helper•8mo ago

I wasn't able to find the answer to your question in the official Deno documentation. However, based on your message, if you're looking to create a regex pattern for use with datatest-stable in Deno, you would typically construct a regex that matches the filenames you're interested in testing. From your message, it seems you want to create a regex pattern from a list of filenames that have already been filtered to exclude those ending with .skip.md. If you're constructing a regex pattern from an array of strings in TypeScript, remember to escape any special regex characters in those strings. For example, the dot (.) should be escaped because it has a special meaning in regex (it matches any single character). Here's a general approach to creating a regex pattern from an array of filenames:

const fileNames = ["example.md", "tutorial.md"]; // Your filtered list of filenames
const escapedFileNames = fileNames.map(fn => fn.replace(/\./g, '\\.'));
const pattern = new RegExp(escapedFileNames.join("|"));

const fileNames = ["example.md", "tutorial.md"]; // Your filtered list of filenames
const escapedFileNames = fileNames.map(fn => fn.replace(/\./g, '\\.'));
const pattern = new RegExp(escapedFileNames.join("|"));

In this snippet, fileNames is your array of filenames. We use map to create a new array escapedFileNames, where each filename has its dots escaped with a backslash (\\.). Then we join these escaped filenames with the pipe character (|) to create a pattern that matches any of the filenames in the list. Please note that this advice is not based on the Deno documentation, and you should double-check the accuracy of the advice given. Make sure to test your regex pattern to ensure it matches exactly the files you intend to include in your tests.

Helpful Links: How to Build a CRUD API with Oak and Deno KV Operations | Deno Docs How Deco.cx, Brazil's top frontend platform, uses Deno Subhosting to move fast and serve their clients' storefronts even faster Deno 1.4 Release Notes Deno 1.10 Release Notes

webbdaysOP•8mo ago

not particular in deno. @Deno AI Helper any alternative to datatest-stable crate to run test per a file.

Deno AI Helper•8mo ago

In Deno, if you're looking for an alternative to the datatest-stable crate for running tests per file, you can use Deno's built-in testing API to create your own file-based tests. Deno's standard library provides utilities for working with the file system, which you can use to read directories and iterate over files to create tests dynamically. Here's a basic example of how you might write a script to run a test for each file in a directory, excluding files that end with .skip.md:

import { walk } from "https://deno.land/std/fs/mod.ts";
import { assert } from "https://deno.land/std/testing/asserts.ts";

for await (const entry of walk("./testfiles", { exts: [".md"], match: [/^(?!.*\.skip\.md$).*$/] })) {
  Deno.test(`Testing file: ${entry.name}`, async () => {
    // Your test logic here, for example:
    const content = await Deno.readTextFile(entry.path);
    assert(content.length > 0, "File content should not be empty");
    // More assertions and test logic...
  });
}

import { walk } from "https://deno.land/std/fs/mod.ts";
import { assert } from "https://deno.land/std/testing/asserts.ts";

for await (const entry of walk("./testfiles", { exts: [".md"], match: [/^(?!.*\.skip\.md$).*$/] })) {
  Deno.test(`Testing file: ${entry.name}`, async () => {
    // Your test logic here, for example:
    const content = await Deno.readTextFile(entry.path);
    assert(content.length > 0, "File content should not be empty");
    // More assertions and test logic...
  });
}

In this example, we use the walk function from Deno's standard library to iterate over Markdown files in the ./testfiles directory. We use the exts option to filter for files with the .md extension and the match option with a regex pattern to exclude files ending with .skip.md. For each file, we create a test case using Deno.test. Please note that this is a general approach and not a direct alternative to datatest-stable. You may need to adjust the logic to fit your specific use case. Additionally, this advice is not based on the Deno documentation, so you should double-check the accuracy of the advice given and ensure it meets your requirements.

Helpful Links: Deno Docs Deno Docs Deno 1.10 Release Notes Deno 1.4 Release Notes Deno Docs Deno 1.24 Release Notes

webbdaysOP•8mo ago

dont want to use deno💯 any rust way? @Deno AI Helper

Deno AI Helper•8mo ago

I wasn't able to find the answer to your question in the official Deno documentation. However, based on your message, if you're looking for an alternative to the datatest-stable crate for running tests per file, you might consider using Deno's built-in testing functionality along with file system operations to iterate over files and create tests dynamically. The example provided in the previous message is a general approach to creating file-based tests in Deno using its standard library. It's important to note that the advice is not based on the Deno documentation, and you should double-check the accuracy of the advice given. Make sure to test the implementation to ensure it works as expected for your use case.