Merge pull request #846 from refaktor/dotwords

testing and improving a no_peg parser

Author: refaktor

internal/parsing/01-words.rye

@@ -0,0 +1,62 @@
+; Parser tests for word types
+print "## Word Types"
+
+; Basic word
+assert\display "word" {
+	type? first { word }
+} 'word
+
+; Set-word (word:)
+assert\display "set-word" {
+	type? first { word: }
+} 'setword
+
+; Left set-word (:word)
+assert\display "lset-word" {
+	type? first { :word }
+} 'lsetword
+
+; Mod-word (word::)
+assert\display "mod-word" {
+	type? first { word:: }
+} 'modword
+
+; Left mod-word (::word)
+assert\display "lmod-word" {
+	type? first { ::word }
+} 'lmodword
+
+; Get-word (?word)
+assert\display "get-word" {
+	type? first { ?word }
+} 'getword
+
+; Tag-word ('word)
+assert\display "tag-word" {
+	type? first { 'word }
+} 'tagword
+
+; Words with special chars
+assert\display "word with hyphen" {
+	type? first { my-word }
+} 'word
+
+assert\display "word with question mark" {
+	type? first { empty? }
+} 'word
+
+assert\display "word with exclamation" {
+	type? first { inc! }
+} 'word
+
+; Words starting with underscore
+assert\display "word starting with underscore" {
+	type? first { _private }
+} 'word
+
+; Words with numbers
+assert\display "word with numbers" {
+	type? first { var1 }
+} 'word
+
+print ""

internal/parsing/02-opwords.rye

@@ -0,0 +1,112 @@
+; Parser tests for op-words (operators)
+print "## Op-words (Operators)"
+
+; Single character operators
+assert\display "plus operator" {
+	type? first { + }
+} 'opword
+
+assert\display "minus operator" {
+	type? first { - }
+} 'opword
+
+assert\display "multiply operator" {
+	type? first { * }
+} 'opword
+
+assert\display "divide operator" {
+	type? first { / }
+} 'opword
+
+assert\display "less than operator" {
+	type? first { < }
+} 'opword
+
+assert\display "greater than operator" {
+	type? first { > }
+} 'opword
+
+assert\display "equals operator" {
+	type? first { = }
+} 'opword
+
+assert\display "percent operator" {
+	type? first { % }
+} 'opword
+
+assert\display "tilde operator" {
+	type? first { ~ }
+} 'opword
+
+assert\display "exclamation operator" {
+	type? first { ! }
+} 'opword
+
+; Multi-character comparison operators
+assert\display "not-equal operator !=" {
+	type? first { != }
+} 'opword
+
+assert\display "double-equals operator ==" {
+	type? first { == }
+} 'opword
+
+assert\display "less-or-equal operator <=" {
+	type? first { <= }
+} 'opword
+
+assert\display "greater-or-equal operator >=" {
+	type? first { >= }
+} 'opword
+
+assert\display "not-equal operator <>" {
+	type? first { <> }
+} 'opword
+
+; Arrow operators
+assert\display "right arrow ->" {
+	type? first { -> }
+} 'opword
+
+assert\display "left arrow <-" {
+	type? first { <- }
+} 'opword
+
+assert\display "fat arrow =>" {
+	type? first { => }
+} 'opword
+
+assert\display "tilde arrow ~>" {
+	type? first { ~> }
+} 'opword
+
+assert\display "left tilde arrow <~" {
+	type? first { <~ }
+} 'opword
+
+; Other multi-char operators
+assert\display "range operator .." {
+	type? first { .. }
+} 'opword
+
+assert\display "increment operator ++" {
+	type? first { ++ }
+} 'opword
+
+assert\display "decrement operator --" {
+	type? first { -- }
+} 'opword
+
+assert\display "double slash //" {
+	type? first { // }
+} 'opword
+
+assert\display "shift left <<" {
+	type? first { << }
+} 'opword
+
+assert\display "shift right >>" {
+	type? first { >> }
+} 'opword
+
+print ""

internal/parsing/03-dotwords.rye

@@ -0,0 +1,73 @@
+; Parser tests for dot-words
+print "## Dot-words"
+
+; Basic dotword
+assert\display "basic dotword .word" {
+	type? first { .word }
+} 'dotword
+
+assert\display "dotword with hyphen .my-word" {
+	type? first { .my-word }
+} 'dotword
+
+assert\display "dotword .upper" {
+	type? first { .upper }
+} 'dotword
+
+assert\display "dotword .concat" {
+	type? first { .concat }
+} 'dotword
+
+; Dotwords with single-char operators
+assert\display "dotword .+" {
+	type? first { .+ }
+} 'dotword
+
+assert\display "dotword .*" {
+	type? first { .* }
+} 'dotword
+
+assert\display "dotword .>" {
+	type? first { .> }
+} 'dotword
+
+assert\display "dotword .<" {
+	type? first { .< }
+} 'dotword
+
+assert\display "dotword .=" {
+	type? first { .= }
+} 'dotword
+
+assert\display "dotword .!" {
+	type? first { .! }
+} 'dotword
+
+assert\display "dotword .?" {
+	type? first { .? }
+} 'dotword
+
+assert\display "dotword .%" {
+	type? first { .% }
+} 'dotword
+
+assert\display "dotword .-" {
+	type? first { .- }
+} 'dotword
+
+; Dotword with force modifier (*)
+assert\display "dotword with force .word*" {
+	type? first { .word* }
+} 'dotword
+
+; Single letter dotword
+assert\display "single letter dotword .x" {
+	type? first { .x }
+} 'dotword
+
+; Double dot is opword not dotword
+assert\display "double dot .. is opword" {
+	type? first { .. }
+} 'opword
+
+print ""

internal/parsing/04-pipewords.rye

@@ -0,0 +1,64 @@
+; Parser tests for pipe-words
+print "## Pipe-words"
+
+; Basic pipeword
+assert\display "basic pipeword |word" {
+	type? first { |word }
+} 'pipeword
+
+assert\display "pipeword with hyphen |my-word" {
+	type? first { |my-word }
+} 'pipeword
+
+assert\display "pipeword |print" {
+	type? first { |print }
+} 'pipeword
+
+assert\display "pipeword |concat" {
+	type? first { |concat }
+} 'pipeword
+
+; Pipewords with single-char operators
+assert\display "pipeword |+" {
+	type? first { |+ }
+} 'pipeword
+
+assert\display "pipeword |*" {
+	type? first { |* }
+} 'pipeword
+
+assert\display "pipeword |-" {
+	type? first { |- }
+} 'pipeword
+
+; Note: |/ is ambiguous - / is context path separator, so |/ starts a pipe-cpath
+; assert\display "pipeword |/" { type? first { |/ } } 'pipeword
+
+assert\display "pipeword |>" {
+	type? first { |> }
+} 'pipeword
+
+assert\display "pipeword |<" {
+	type? first { |< }
+} 'pipeword
+
+assert\display "pipeword |=" {
+	type? first { |= }
+} 'pipeword
+
+; Pipeword with force modifier (*)
+assert\display "pipeword with force |word*" {
+	type? first { |word* }
+} 'pipeword
+
+; Single letter pipeword
+assert\display "single letter pipeword |x" {
+	type? first { |x }
+} 'pipeword
+
+; Multi-char pipewords
+assert\display "pipeword |++" {
+	type? first { |++ }
+} 'pipeword
+
+print ""

internal/parsing/05-literals.rye

@@ -0,0 +1,70 @@
+; Parser tests for literal values
+print "## Literals"
+
+; Integers
+assert\display "positive integer" {
+	type? first { 123 }
+} 'integer
+
+assert\display "negative integer" {
+	type? first { -456 }
+} 'integer
+
+assert\display "zero" {
+	type? first { 0 }
+} 'integer
+
+assert\display "large integer" {
+	type? first { 999999999 }
+} 'integer
+
+; Decimals
+assert\display "decimal number" {
+	type? first { 3.14 }
+} 'decimal
+
+assert\display "negative decimal" {
+	type? first { -2.718 }
+} 'decimal
+
+assert\display "decimal with leading zero" {
+	type? first { 0.5 }
+} 'decimal
+
+; Strings
+assert\display "double-quoted string" {
+	type? first { "hello" }
+} 'string
+
+assert\display "string with spaces" {
+	type? first { "hello world" }
+} 'string
+
+assert\display "empty string" {
+	type? first { "" }
+} 'string
+
+assert\display "backtick string" {
+	type? first { `hello` }
+} 'string
+
+; String value check
+assert\display "string value" {
+	first { "hello" }
+} "hello"
+
+assert\display "string with escape" {
+	first { "line1\nline2" }
+} "line1\nline2"
+
+; Void
+assert\display "void" {
+	type? first { _ }
+} 'void
+
+; Comma
+assert\display "comma" {
+	type? first { , }
+} 'comma
+
+print ""