goscript 0.0.39 → 0.0.41

package/gs/path/filepath/index.ts

@@ -0,0 +1,27 @@
+export { ErrBadPattern, Glob, Match } from './match.js'
+export {
+  Abs,
+  Base,
+  Clean,
+  Dir,
+  EvalSymlinks,
+  Ext,
+  FromSlash,
+  IsAbs,
+  IsLocal,
+  Join,
+  ListSeparator,
+  Localize,
+  Rel,
+  Separator,
+  SkipAll,
+  SkipDir,
+  Split,
+  SplitList,
+  ToSlash,
+  VolumeName,
+  Walk,
+  WalkDir,
+  HasPrefix,
+} from './path.js'
+export type { WalkFunc } from './path.js'

package/gs/path/filepath/match.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect } from 'vitest'
+import { Match, Glob, ErrBadPattern } from './match.js'
+
+describe('path/filepath - Pattern matching functions', () => {
+  describe('Match', () => {
+    describe('Basic patterns', () => {
+      it('should match exact strings', () => {
+        const [matched, err] = Match('file.txt', 'file.txt')
+        expect(err).toBeNull()
+        expect(matched).toBe(true)
+
+        const [notMatched, err2] = Match('file.txt', 'other.txt')
+        expect(err2).toBeNull()
+        expect(notMatched).toBe(false)
+      })
+
+      it('should handle empty patterns and names', () => {
+        const [empty1, err1] = Match('', '')
+        expect(err1).toBeNull()
+        expect(empty1).toBe(true)
+
+        const [empty2, err2] = Match('', 'file')
+        expect(err2).toBeNull()
+        expect(empty2).toBe(false)
+
+        const [empty3, err3] = Match('pattern', '')
+        expect(err3).toBeNull()
+        expect(empty3).toBe(false)
+      })
+    })
+
+    describe('Wildcard patterns', () => {
+      it('should match with * (star)', () => {
+        const [match1, err1] = Match('*.txt', 'file.txt')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('*.txt', 'file.doc')
+        expect(err2).toBeNull()
+        expect(match2).toBe(false)
+
+        const [match3, err3] = Match('file.*', 'file.txt')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+
+        const [match4, err4] = Match('*', 'anything')
+        expect(err4).toBeNull()
+        expect(match4).toBe(true)
+
+        const [match5, err5] = Match('*', '')
+        expect(err5).toBeNull()
+        expect(match5).toBe(true)
+      })
+
+      it('should match with ? (question mark)', () => {
+        const [match1, err1] = Match('file?.txt', 'file1.txt')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('file?.txt', 'fileAB.txt')
+        expect(err2).toBeNull()
+        expect(match2).toBe(false)
+
+        const [match3, err3] = Match('?', 'a')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+
+        const [match4, err4] = Match('?', '')
+        expect(err4).toBeNull()
+        expect(match4).toBe(false)
+
+        const [match5, err5] = Match('?', 'ab')
+        expect(err5).toBeNull()
+        expect(match5).toBe(false)
+      })
+    })
+
+    describe('Character classes', () => {
+      it('should match character ranges', () => {
+        const [match1, err1] = Match('[a-z]', 'c')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('[a-z]', 'Z')
+        expect(err2).toBeNull()
+        expect(match2).toBe(false)
+
+        const [match3, err3] = Match('[0-9]', '5')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+      })
+
+      it('should match specific characters', () => {
+        const [match1, err1] = Match('[abc]', 'b')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('[abc]', 'd')
+        expect(err2).toBeNull()
+        expect(match2).toBe(false)
+      })
+
+      it('should handle negated character classes', () => {
+        const [match1, err1] = Match('[^abc]', 'd')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('[^abc]', 'a')
+        expect(err2).toBeNull()
+        expect(match2).toBe(false)
+
+        const [match3, err3] = Match('[^a-z]', '1')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+
+        const [match4, err4] = Match('[^a-z]', 'c')
+        expect(err4).toBeNull()
+        expect(match4).toBe(false)
+      })
+    })
+
+    describe('Escaped characters', () => {
+      it('should handle escaped special characters', () => {
+        const [match1, err1] = Match('\\*', '*')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('\\?', '?')
+        expect(err2).toBeNull()
+        expect(match2).toBe(true)
+
+        const [match3, err3] = Match('\\[', '[')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+      })
+
+      it('should handle escaped characters in character classes', () => {
+        const [match1, err1] = Match('[\\-]', '-')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('[\\]]', ']')
+        expect(err2).toBeNull()
+        expect(match2).toBe(true)
+      })
+    })
+
+    describe('Complex patterns', () => {
+      it('should match complex combinations', () => {
+        const [match1, err1] = Match('dir/*', 'dir/file.txt')
+        expect(err1).toBeNull()
+        expect(match1).toBe(true)
+
+        const [match2, err2] = Match('*.{txt,doc}', 'file.txt')
+        expect(err2).toBeNull()
+        // This pattern is not supported in our implementation, should not match
+        expect(match2).toBe(false)
+
+        const [match3, err3] = Match('file[0-9].txt', 'file5.txt')
+        expect(err3).toBeNull()
+        expect(match3).toBe(true)
+
+        const [match4, err4] = Match('*.[tT][xX][tT]', 'file.TXT')
+        expect(err4).toBeNull()
+        expect(match4).toBe(true)
+      })
+
+      it('should not match across path separators with ?', () => {
+        const [match1, err1] = Match('dir?file', 'dir/file')
+        expect(err1).toBeNull()
+        expect(match1).toBe(false)
+      })
+    })
+
+    describe('Error cases', () => {
+      it('should return error for malformed patterns', () => {
+        const [_unclosed, err1] = Match('[unclosed', 'test')
+        expect(err1).toBe(ErrBadPattern)
+
+        const [_trailing, err2] = Match('trailing\\', 'test')
+        expect(err2).toBe(ErrBadPattern)
+
+        const [_bracket, err3] = Match('[', 'test')
+        expect(err3).toBe(ErrBadPattern)
+      })
+    })
+
+    describe('Real-world examples', () => {
+      it('should match common file patterns', () => {
+        // JavaScript files
+        const [js1, _js1] = Match('*.js', 'app.js')
+        expect(js1).toBe(true)
+
+        const [js2, _js2] = Match('*.js', 'app.jsx')
+        expect(js2).toBe(false)
+
+        // Backup files
+        const [bak1, _bak1] = Match('*.bak', 'file.txt.bak')
+        expect(bak1).toBe(true)
+
+        // Hidden files
+        const [hidden1, _hidden1] = Match('.*', '.hidden')
+        expect(hidden1).toBe(true)
+
+        const [hidden2, _hidden2] = Match('.*', 'visible')
+        expect(hidden2).toBe(false)
+
+        // Version numbers
+        const [ver1, _ver1] = Match('v[0-9]*', 'v1.2.3')
+        expect(ver1).toBe(true)
+
+        const [ver2, _ver2] = Match('v[0-9]*', 'version')
+        expect(ver2).toBe(false)
+      })
+    })
+  })
+
+  describe('Glob', () => {
+    it('should validate patterns but return empty results (no filesystem)', () => {
+      // Valid patterns should not error
+      const [files1, err1] = Glob('*.txt')
+      expect(err1).toBeNull()
+      expect(files1).toEqual([])
+
+      const [files2, err2] = Glob('dir/*')
+      expect(err2).toBeNull()
+      expect(files2).toEqual([])
+
+      // Invalid patterns should error
+      const [files3, err3] = Glob('[unclosed')
+      expect(err3).toBe(ErrBadPattern)
+      expect(files3).toEqual([])
+    })
+  })
+
+  describe('Pattern edge cases', () => {
+    it('should handle patterns at string boundaries', () => {
+      const [match1, _edge1] = Match('*txt', 'file.txt')
+      expect(match1).toBe(true)
+
+      const [match2, _edge2] = Match('file*', 'file.txt')
+      expect(match2).toBe(true)
+
+      const [match3, _edge3] = Match('*file*', 'myfile.txt')
+      expect(match3).toBe(true)
+    })
+
+    it('should handle multiple stars', () => {
+      const [match1, _star1] = Match('**', 'anything')
+      expect(match1).toBe(true)
+
+      const [match2, _star2] = Match('*.*.*', 'a.b.c')
+      expect(match2).toBe(true)
+
+      const [match3, _star3] = Match('*.*.*', 'a.b')
+      expect(match3).toBe(false)
+    })
+
+    it('should handle character class edge cases', () => {
+      // Empty character class (should be invalid)
+      const [_empty, err1] = Match('[]', 'test')
+      expect(err1).toBe(ErrBadPattern)
+
+      // Character class with dash
+      const [match1, err2] = Match('[a-]', 'a')
+      expect(err2).toBeNull()
+      expect(match1).toBe(true)
+
+      const [match2, err3] = Match('[a-]', '-')
+      expect(err3).toBeNull()
+      expect(match2).toBe(true)
+    })
+  })
+})

package/gs/path/filepath/match.ts

@@ -0,0 +1,249 @@
+// Pattern matching functions for filepath
+
+export const ErrBadPattern = new Error('syntax error in pattern')
+
+// Match reports whether name matches the shell file name pattern.
+// The pattern syntax is:
+//
+//	pattern:
+//		{ term }
+//	term:
+//		'*'         matches any sequence of non-Separator characters
+//		'?'         matches any single non-Separator character
+//		'[' [ '^' ] { character-range } ']'
+//		            character class (must be non-empty)
+//		c           matches character c (c != '*', '?', '\\', '[')
+//		'\\' c      matches character c
+//
+//	character-range:
+//		c           matches character c (c != '\\', '-', ']')
+//		'\\' c      matches character c
+//		lo '-' hi   matches character c for lo <= c <= hi
+//
+// Match requires pattern to match all of name, not just a substring.
+// The only possible returned error is ErrBadPattern, when pattern
+// is malformed.
+export function Match(pattern: string, name: string): [boolean, Error | null] {
+  try {
+    // Validate pattern first
+    validatePattern(pattern)
+    return [matchPattern(pattern, name), null]
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (err) {
+    return [false, ErrBadPattern]
+  }
+}
+
+function validatePattern(pattern: string): void {
+  let i = 0
+
+  while (i < pattern.length) {
+    const char = pattern[i]
+
+    switch (char) {
+      case '\\':
+        // Must be followed by another character
+        i++
+        if (i >= pattern.length) {
+          throw new Error('bad pattern')
+        }
+        i++
+        break
+
+      case '[': {
+        // Must have a properly closed character class
+        i++
+        let foundContent = false
+        let foundClose = false
+
+        // Skip negation
+        if (i < pattern.length && pattern[i] === '^') {
+          i++
+        }
+
+        while (i < pattern.length) {
+          if (pattern[i] === ']') {
+            foundClose = true
+            i++
+            break
+          }
+
+          foundContent = true
+
+          if (pattern[i] === '\\') {
+            i++ // Skip escape character
+            if (i >= pattern.length) {
+              throw new Error('bad pattern')
+            }
+          }
+          i++
+        }
+
+        if (!foundClose || !foundContent) {
+          throw new Error('bad pattern')
+        }
+        break
+      }
+
+      default:
+        i++
+        break
+    }
+  }
+}
+
+function matchPattern(pattern: string, name: string): boolean {
+  let patternIndex = 0
+  let nameIndex = 0
+
+  while (patternIndex < pattern.length && nameIndex < name.length) {
+    const p = pattern[patternIndex]
+
+    switch (p) {
+      case '*':
+        // Handle star - match any sequence of characters
+        patternIndex++
+        if (patternIndex >= pattern.length) {
+          // Pattern ends with *, matches rest of name
+          return true
+        }
+
+        // Try to match the rest of the pattern with remaining name
+        for (let i = nameIndex; i <= name.length; i++) {
+          if (
+            matchPattern(pattern.substring(patternIndex), name.substring(i))
+          ) {
+            return true
+          }
+        }
+        return false
+
+      case '?':
+        // Match any single character except separator
+        if (name[nameIndex] === '/') {
+          return false
+        }
+        patternIndex++
+        nameIndex++
+        break
+
+      case '[': {
+        // Character class
+        const [matched, newPatternIndex] = matchCharClass(
+          pattern,
+          patternIndex,
+          name[nameIndex],
+        )
+        if (!matched) {
+          return false
+        }
+        patternIndex = newPatternIndex
+        nameIndex++
+        break
+      }
+
+      case '\\':
+        // Escaped character (pattern already validated)
+        patternIndex++
+        if (pattern[patternIndex] !== name[nameIndex]) {
+          return false
+        }
+        patternIndex++
+        nameIndex++
+        break
+
+      default:
+        // Literal character
+        if (p !== name[nameIndex]) {
+          return false
+        }
+        patternIndex++
+        nameIndex++
+        break
+    }
+  }
+
+  // Handle any remaining stars in pattern
+  while (patternIndex < pattern.length && pattern[patternIndex] === '*') {
+    patternIndex++
+  }
+
+  // Both pattern and name should be fully consumed
+  return patternIndex >= pattern.length && nameIndex >= name.length
+}
+
+function matchCharClass(
+  pattern: string,
+  start: number,
+  char: string,
+): [boolean, number] {
+  let index = start + 1
+  let negated = false
+
+  // Check for negation
+  if (index < pattern.length && pattern[index] === '^') {
+    negated = true
+    index++
+  }
+
+  let matched = false
+
+  while (index < pattern.length) {
+    if (pattern[index] === ']') {
+      index++
+      break
+    }
+
+    if (pattern[index] === '\\') {
+      // Escaped character
+      index++
+      if (pattern[index] === char) {
+        matched = true
+      }
+      index++
+    } else if (
+      index + 2 < pattern.length &&
+      pattern[index + 1] === '-' &&
+      pattern[index + 2] !== ']'
+    ) {
+      // Character range
+      const lo = pattern[index]
+      const hi = pattern[index + 2]
+      if (char >= lo && char <= hi) {
+        matched = true
+      }
+      index += 3
+    } else {
+      // Single character
+      if (pattern[index] === char) {
+        matched = true
+      }
+      index++
+    }
+  }
+
+  if (negated) {
+    matched = !matched
+  }
+
+  return [matched, index]
+}
+
+// Glob returns the names of all files matching pattern or null
+// if there is no matching file. The syntax of patterns is the same
+// as in Match. The pattern may describe hierarchical names such as
+// /usr/*/bin/ed (assuming the Separator is '/').
+//
+// Glob ignores file system errors such as I/O errors reading directories.
+// The only possible returned error is ErrBadPattern, when pattern is malformed.
+export function Glob(pattern: string): [string[], Error | null] {
+  try {
+    // Validate the pattern using the same logic as Match
+    validatePattern(pattern)
+    // We don't have filesystem access, so return empty array
+    return [[], null]
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  } catch (err) {
+    return [[], ErrBadPattern]
+  }
+}