Skip to content

feat: add ExtraMojo #40

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 14 commits into from
Jan 21, 2025
Merged

feat: add ExtraMojo #40

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
14 commits
Select commit Hold shift + click to select a range
d63f533
feat: add ExtraMojo
sstadick Jan 3, 2025
aa2a4e0
fix: update name and latest version
sstadick Jan 6, 2025
4211ef3
Merge branch 'main' into add_extramojo
sstadick Jan 6, 2025
411e6b5
fix: update tests
sstadick Jan 6, 2025
96ce060
fix: pin max host version
sstadick Jan 9, 2025
941593e
Merge branch 'main' into add_extramojo
sstadick Jan 9, 2025
49148fa
fix: pin max version to 24.6
sstadick Jan 11, 2025
bae819f
Merge branch 'main' into add_extramojo
carolinefrasca Jan 14, 2025
16f3468
Merge branch 'main' into add_extramojo
sstadick Jan 14, 2025
72278f5
fix: max pin version
sstadick Jan 15, 2025
c4b7128
Merge branch 'main' into add_extramojo
carolinefrasca Jan 17, 2025
1ba8508
fix: update to v0.8.0 and lowercase project name
sstadick Jan 17, 2025
b4e76f1
fix: remove trailing whitespace
sstadick Jan 21, 2025
77fc647
Merge branch 'main' into add_extramojo
carolinefrasca Jan 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
57 changes: 57 additions & 0 deletions recipes/ExtraMojo/recipe.yaml
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,57 @@
context:
version: "0.8.0"

package:
name: "extramojo"
version: ${{ version }}

source:
- git: https://github.com/ExtraMojo/ExtraMojo.git
rev: 263006acc60d64a2f21958e9bb6298cc5a0da8c2

build:
number: 0
script:
- mojo package ExtraMojo -o ${{ PREFIX }}/lib/mojo/ExtraMojo.mojopkg
requirements:
host:
- max =24.6
run:
- max =24.6
- ${{ pin_compatible('max') }}

tests:
- script:
- if: unix
then:
- mojo run -I ${{ PREFIX }}/lib/mojo/ExtraMojo.mojopkg tests/test_file.mojo
- mojo test -I ${{ PREFIX }}/lib/mojo/ExtraMojo.mojopkg tests/test_regex.mojo
- mojo test -I ${{ PREFIX }}/lib/mojo/ExtraMojo.mojopkg tests/test_bstr.mojo
requirements:
run:
- max =24.6
files:
recipe:
- tests/test_file.mojo
- tests/test_regex.mojo
- tests/test_bstr.mojo

about:
homepage: https://github.com/ExtraMojo/ExtraMojo
# Remember to specify the license variants for BSD, Apache, GPL, and LGPL.
# Use the SPDX identifier, e.g: GPL-2.0-only instead of GNU General Public License version 2.0
# See https://spdx.org/licenses/
license: "Unlicense OR MIT"
# It is strongly encouraged to include a license file in the package,
# (even if the license doesn't require it) using the license_file entry.
# See https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html#license-file
license_file:
- LICENSE-MIT
- UNLICENSE
summary: Extra functionality not yet in the standard library, mostly focused on strings and file IO.
repository: https://github.com/ExtraMojo/ExtraMojo

extra:
maintainers:
- sstadick
project_name: extramojo
292 changes: 292 additions & 0 deletions recipes/ExtraMojo/tests/test_bstr.mojo
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,292 @@
from ExtraMojo.bstr.bstr import (
SplitIterator,
find,
to_ascii_lowercase,
to_ascii_uppercase,
)
from ExtraMojo.bstr.memchr import memchr, memchr_wide
from memory import Span
from testing import *


fn s(bytes: Span[UInt8]) -> String:
"""Convert bytes to a String."""
var buffer = String()
buffer.write_bytes(bytes)
return buffer


# Sometimes useful for digging into the memchr function
# from ir_utils.dump import dump_ir
# fn main() raises:
# var static_str = "hi"
# dump_ir[
# find_chr_next_occurrence[__origin_of(static_str)],
# "find_chr_next_occurrence",
# ]()
# test_find_chr_next_occurance()


fn test_memchr() raises:
var cases = List[(StringLiteral, Int)](
(
"enlivened,unleavened,Arnulfo's,Unilever's,unloved|Anouilh,analogue,analogy",
49,
),
(
"enlivened,unleavened,Arnulfo's,Unilever's,unloved,Anouilh,analogue,analogy,enlivened,unleavened,Arnulfo's,Unilever's,unloved|Anouilh,analogue,analogy",
124,
),
)

for kase in cases:
var index = memchr(kase[][0].as_bytes(), ord("|"))
assert_equal(
index,
kase[][1],
"Expected "
+ str(kase[][1])
+ " Found "
+ str(index)
+ " in "
+ kase[][0],
)


fn test_memchr_wide() raises:
var cases = List[(StringLiteral, Int)](
(
"enlivened,unleavened,Arnulfo's,Unilever's,unloved|Anouilh,analogue,analogy",
49,
),
(
"enlivened,unleavened,Arnulfo's,Unilever's,unloved,Anouilh,analogue,analogy,enlivened,unleavened,Arnulfo's,Unilever's,unloved|Anouilh,analogue,analogy",
124,
),
)

for kase in cases:
var index = memchr_wide(kase[][0].as_bytes(), ord("|"))
assert_equal(
index,
kase[][1],
"Expected "
+ str(kase[][1])
+ " Found "
+ str(index)
+ " in "
+ kase[][0],
)


fn test_lowercase_short() raises:
var example = List("ABCdefgHIjklmnOPQRSTUVWXYZ".as_bytes())
var answer = "abcdefghijklmnopqrstuvwxyz"
to_ascii_lowercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_uppercase_short() raises:
var example = List("ABCdefgHIjklmnOPQRSTUVWXYZ".as_bytes())
var answer = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
to_ascii_uppercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_lowercase() raises:
var example = List(
"ABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZ"
.as_bytes()
)
var answer = "abcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyz"
to_ascii_lowercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_uppercase() raises:
var example = List(
"ABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZ"
.as_bytes()
)
var answer = "ABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZ"
to_ascii_uppercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_lowercase_long() raises:
var example = List(
"ABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZ"
.as_bytes()
)
var answer = "abcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;abcdefghijklmnopqrstuvwxyz"
to_ascii_lowercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_uppercase_long() raises:
var example = List(
"ABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZABCdefgHIjklmnOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCdefgHIjklmnOPQRSTUVWXYZ"
.as_bytes()
)
var answer = "ABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ABCDEFGHIJKLMNOPQRSTUVWXYZ"
to_ascii_uppercase(example)
assert_equal(s(example), s(answer.as_bytes()))


fn test_find_short() raises:
var haystack = "ABCDEFGhijklmnop".as_bytes()
var expected = 4
var answer = find(haystack, "EFG".as_bytes()).value()
assert_equal(answer, expected)


fn test_find_medium() raises:
var haystack = "ABCDEFGhijklmnop0123456789TheKindIguana\nJumpedOver the angry weird fense as it ran away from the seething moon that was swooping down to scoop it up and bring it to outer space.".as_bytes()
var expected = 171
var answer = find(haystack, "space".as_bytes()).value()
assert_equal(answer, expected)


fn test_find_long() raises:
var haystack = "ABCDEFGhijklmnop0123456789TheKindIguana\nJumpedOver the angry weird fense as it ran away from the seething moon that was swooping down to scoop it up and bring it to outer space.\nThen a really weird thing happened and suddenly 64 moons were swooping down at the Iguana. It tried to turn and tell them it was scalar, but they didn't care all tried to scoop it at once, which resulted in a massive Iguana lock contention.".as_bytes()
var expected = 373
var answer = find(haystack, "result".as_bytes()).value()
assert_equal(answer, expected)


fn test_find_long_variable_start() raises:
var haystack = "ABCDEFGhijklmnop0123456789TheKindIguana\nJumpedOver the angry weird fense as it ran away from the seething moon that was swooping down to scoop it up and bring it to outer space.\nThen a really weird thing happened and suddenly 64 moons were swooping down at the Iguana. It tried to turn and tell them it was scalar, but they didn't care all tried to scoop it at once, which resulted in a massive IguanaZ lock contention.".as_bytes()
for i in range(0, len(haystack)):
var answer = memchr(haystack, ord("Z"), i)
if i <= 401:
assert_equal(401, answer)
else:
assert_equal(-1, answer)
# assert_equal(answer, expected)


fn test_spilt_iterator() raises:
var input = "ABCD\tEFGH\tIJKL\nMNOP".as_bytes()
var expected = List(
"ABCD".as_bytes(), "EFGH".as_bytes(), "IJKL\nMNOP".as_bytes()
)
var output = List[Span[UInt8, StaticConstantOrigin]]()
for value in SplitIterator(input, ord("\t")):
output.append(value)
for i in range(len(expected)):
assert_equal(s(output[i]), s(expected[i]), "Not equal")


fn test_spilt_iterator_peek() raises:
var input = "ABCD\tEFGH\tIJKL\nMNOP".as_bytes()
var expected = List(
"ABCD".as_bytes(), "EFGH".as_bytes(), "IJKL\nMNOP".as_bytes()
)
var iter = SplitIterator(input, ord("\t"))
var first = iter.__next__()
var peek = iter.peek()
var second = iter.__next__()
assert_equal(s(peek.value()), s(second))
assert_equal(s(first), s(expected[0]))
assert_equal(s(second), s(expected[1]))


fn test_spilt_iterator_long() raises:
var input = "ABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ\tABCD\tEFGH\tIJKL\nMNOP\tQRST\tUVWXYZ".as_bytes()
var expected = List(
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
"ABCD".as_bytes(),
"EFGH".as_bytes(),
"IJKL\nMNOP".as_bytes(),
"QRST".as_bytes(),
"UVWXYZ".as_bytes(),
)
var output = List[Span[UInt8, StaticConstantOrigin]]()
for value in SplitIterator(input, ord("\t")):
output.append(value)
for i in range(len(expected)):
assert_equal(s(output[i]), s(expected[i]), "Not equal")
Loading
Loading