verbalexpressions / implementation Goto Github PK

Deno 1.0 was recently announced. I ported the JSVerbalExpressions over. Mainly, I had to make it Strict TypeScript compliant and convert the tests into the core Deno testing framework and add the mod.ts . You can view it here: https://github.com/evosland/DenoRegularExpressions .

I didn't call it TsVerbalExpressions because it's specific to Deno and depends on some of its internals. I didn't write anything new, however. It's really a fixup of JavaScript version.

Still working on implementatin, I see the whole implementation (excepting mine, but I'm wrong to implement this before speaking about with you) uses this kind of method:

or(value)
=> ...|value

I'm afraid that this one is not very usefull. It can be ok for simple test, but what about finding:

startofline, then "foo", then "bar", endofline
OR
startofline, then "bar", then "baz". endofline

My implementation does:

StartOfLine().Then("foo").Then("bar").EndOfLine().Or().StartOfLine().Then("bar").Then("baz").EndOfLine()

That returns:

(?m)(?:^(?:foo)(?:bar)$)|(?:^(?:bar)(?:baz)$)

I only record an array of "parts" to concatanate at compile time... My unittest work as expected.

That works with simple expressions, or multiple expressions...

Find("foo").Or().Find("bar")
(?m)(?:foo)|(?:bar)

StartOfLine().Then("foo").Then("bar").EndOfLine().
Or().StartOfLine().Then("bar").Then("baz").EndOfLine().
Or().StartOfLine().Find("AAA").EndOfLine().
(?m)(?:^(?:foo)(?:bar)$)|(?:^(?:bar)(?:baz)$)|(?:^(?:AAA)$)

Testing again implementation, I've got some ideas...

We have "Find(value)" method that returns:

(?:value)

Right... but there is no method to return:

(?!value)

We've got AnythingBut and SomethingBut that works with ranges, not a word. Or maybe I misimplemented methods.

I suggest "Not(value)", are you ok with this idea ?

PS: Go cannot treat this regexp notation... I will find other way to do. But for other, can you give an opinion ?

I'm curious since these libraries are very clearly ports of the original library to what extent I have ownership of the elm-verbal-expressions repo specifically, so that I could add a code of conduct of my choosing, for example.

I've implemented VerbalExpressions in Kotlin, and I'd like to add it to the rest of the implementations. I'm just wondering what the process is for this, since I haven't found any information about it.

The repo can be found here: KotlinVerbalExpressions.

Would I be alone in thinking that having a unified, language-agnostic test suite would be beneficial?

I've recently been thinking over the issue of unit tests for the different implementations (mostly just the PHP & JS ones as you might guess). A quick google suggested that language-agnostic test suites are few & far between. So I rolled my own :P

It struck me that one would need to define a series of tests for VerbalExpressions that can be read in as many languages as possible. Parsing XML isn't exactly straight-forward in PHP or JS, so I went with JSON.

So with the test suites being defined in JSON, it would seem like a good idea to ensure that the test suites were well-defined (so each implementation would know what to expect of the structure of the files). For this we have JSON Schema and a grunt task I cooked up last night (this issue would've been posted last night, but unicorns got in the way). This allows test definers to be confident that when a new version goes out there should only be issues with implementations when the test schema changes (i.e. if grunt jsonschema fails, don't push it).

The basic schema I've implemented in the proof-of-concept examples allows for:

• multiple tests per file (no restrictions on file names beyond any silliness that would prevent an implementation from parsing it)
• abstract call stacks & arguments (only a single call stack for all languages)
• default expected output + language-specific outputs (if for whatever reason an implementation needs to generate different regex strings to be most performant whilst doing the same job)

Thoughts/comments/suggestions?

• example test suite definition.
• test suite schema
• PHP Implementation of language agnostic tests

Hi,

Is there any matrix/overview with the implementations of VerbalExpressions for various methods?

It looks that there are allot of inconsistencies among language implementations :( .

Thank you.

VerbalExpressions should have support for all the available character classes.

Should we implement those as constants or just add them like in @andrii1812 's PR to Python repo:
VerbalExpressions/PythonVerbalExpressions#16

VerEx().find(VerEx.NUMBER)

vs.

VerEx().number()

I would like to include more verbal expressions for MATLAB. Is it allowed to implement not just the required methods but additional ones?

Noticing some readmes directing people to find a list of implementations; site is empty.

Should the same series of inputs spit out exactly the same regex, or should the regex be platform-specific ?

I'm referring mostly to the differences between the PHP & JS implementations, with JS seeming to have /g by default, and multiple('') giving "(?:)*" instead of "+".

The second part of this question is "should this repo contain a machine-consumable (JSON/XML/other) list of inputs & "accptable" outputs?

These are the functions that need documentation if we consider the original JS version as the refference.

• add
• startOfLine
• endOfLine
• then
• find
• maybe
• anything
• anythingBut
• something
• somethingBut
• replace
• lineBreak
• br (shorthand for lineBreak)
• tab
• word
• anyOf
• any (shorthand for anyOf)
• range
• withAnyCase
• stopAtFirst
• searchOneLine
• multiple
• or
• begindCapture
• endCapture

KotlinVerbalExpressions only targets Kotlin/JVM, which is not a big surprise since the repo hasn't been updated since Kotlin/JS, Kotlin/Native, and Kotlin/WASM have had more prominent releases.

VerbalExpressions would be especially useful for Kotlin Multiplatform, as currently it is difficult to create Regexes that perform identically on each platform. This is because currently each Kotlin target delegates to the Regex engine available at runtime, which can differ significantly between platforms.

Update KotlinVerbalExpressions

I would like to update the KotlinVerbalExpressions repo. I propose the following updates:

• Update the Gradle version and build config
• Update Kotlin from 1.2 to 1.8 (the latest version)
• Migrate the build config to use Kotlin Multiplatform, but still target Kotlin/JVM

I have made a demonstration PR for this work: aSemy/KotlinVerbalExpressions#1

Kotlin Multiplatform

What is more difficult to determine is how to support additional Kotlin Multiplatform targets:

• Kotlin/JS
• Kotlin/Native
• Kotlin/WASM

I see two approaches:

1. VerbalExpressions can be written so that the platform's Regex engine does not have any impact.

   This would be the best solution, because then KotlinVerbalExpressions could be written in common Kotlin code, and would not need to worry about platform specific details.

   I suspect the best approach for this is to try and use JSVerbalExpressions as a basis, since Javascript are also dependent on the available Regex engine, so perhaps it has already overcome the same problem that Kotlin Multiplatform faces now?

2. KotlinVerbalExpressions uses expect/actual to delegate to platform specific VerbalExpression implementations. For Kotlin/JS and Kotlin/JVM this would be easier, since there are already VerbalExpressions implementations. However, Kotlin/Native requires a pure-C implementation, and I don't think VerbalExpressions has a pure-C implementation?

CC @zsmb13 👋, since you originally implemented KotlinVerbalExpressions way back when, and would probably be able to help with publishing a new version?

As I did on JS implementation, I recreate the issue there to discuss about "multiple" function.

Some implementation return the given value with "+", other give "{2,}"

To my side, for Go, I developped a method that have this implementation:

multiple(string value, int min, int max)

where:

• min is the minimum number of occurence to get
• maw is the maximum number of occurence to get

both argument are, IMHO, not required, default should be considered as doing "value?"

This is how I did:

// get "foo" at least one time
v.Multiple("foo")
v.Multiple("foo", 1)

// get "foo" 0 or more times
v.Multiple("foo", 0)

//get "foo" 0 or 1 times
v.Multiple("foo", 0, 1)

// get "foo" 0 to 10 times
v.Multiple("foo",0 ,10)

//get "foo" at least 10 times
v.Multiple("foo", 10)

//get "foo" exactly 10 times
v.Multiple("foo", 10, 10)

//get "foo" from 1 to 10 times
v.Multiple("foo", 1, 10)

Discussion is opened

In CSharp we have made some common regex expressions, like e-mail and url.
So e.g. one can write VerbEx something like:

verbEx.StartOfLine().Then(CommonRegex.Email);

I think this should be implemented similar across the different languages.

It's important that if we make something like default regex words like e-mail and url, that the underlying regex is equal between the different language ports.

Other examples of commonregex that could be implemented:

email
phone
url
date
ip address
rgb color hex value
decimal number
time format

See original issue in CSharp:
VerbalExpressions/CSharpVerbalExpressions#4

As implemented in Python repo's pull request by @andrii1812

VerbalExpressions/PythonVerbalExpressions#16