goscript 0.0.38 → 0.0.40

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

@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest'
+import {
+  Base,
+  Dir,
+  Ext,
+  Clean,
+  Join,
+  Split,
+  IsAbs,
+  ToSlash,
+  FromSlash,
+  VolumeName,
+  IsLocal,
+  SplitList,
+  HasPrefix,
+  Abs,
+  Rel,
+  EvalSymlinks,
+  Separator,
+  ListSeparator,
+} from './path.js'
+
+describe('path/filepath - Path manipulation functions', () => {
+  describe('Base', () => {
+    it('should return the last element of path', () => {
+      expect(Base('dir/subdir/file.txt')).toBe('file.txt')
+      expect(Base('/usr/bin/ls')).toBe('ls')
+      expect(Base('file.txt')).toBe('file.txt')
+      expect(Base('/')).toBe('/')
+      expect(Base('')).toBe('.')
+      expect(Base('//')).toBe('/')
+      expect(Base('dir/')).toBe('dir')
+      expect(Base('dir//')).toBe('dir')
+    })
+  })
+
+  describe('Dir', () => {
+    it('should return directory portion of path', () => {
+      expect(Dir('dir/subdir/file.txt')).toBe('dir/subdir')
+      expect(Dir('/usr/bin/ls')).toBe('/usr/bin')
+      expect(Dir('file.txt')).toBe('.')
+      expect(Dir('/')).toBe('/')
+      expect(Dir('')).toBe('.')
+      expect(Dir('/file')).toBe('/')
+      expect(Dir('dir/')).toBe('.')
+    })
+  })
+
+  describe('Ext', () => {
+    it('should return file extension', () => {
+      expect(Ext('file.txt')).toBe('.txt')
+      expect(Ext('file.tar.gz')).toBe('.gz')
+      expect(Ext('file')).toBe('')
+      expect(Ext('.hidden')).toBe('')
+      expect(Ext('dir/file.txt')).toBe('.txt')
+      expect(Ext('')).toBe('')
+    })
+  })
+
+  describe('Clean', () => {
+    it('should clean up path by resolving . and .. elements', () => {
+      expect(Clean('dir//subdir/../subdir/./file.txt')).toBe(
+        'dir/subdir/file.txt',
+      )
+      expect(Clean('/dir/../file')).toBe('/file')
+      expect(Clean('./file')).toBe('file')
+      expect(Clean('../file')).toBe('../file')
+      expect(Clean('dir/..')).toBe('.')
+      expect(Clean('/dir/..')).toBe('/')
+      expect(Clean('')).toBe('.')
+      expect(Clean('/')).toBe('/')
+      expect(Clean('///')).toBe('/')
+    })
+  })
+
+  describe('Join', () => {
+    it('should join path elements with separator', () => {
+      expect(Join('dir', 'subdir', 'file.txt')).toBe('dir/subdir/file.txt')
+      expect(Join('/usr', 'bin', 'ls')).toBe('/usr/bin/ls')
+      expect(Join('', 'file')).toBe('file')
+      expect(Join('dir', '', 'file')).toBe('dir/file')
+      expect(Join()).toBe('')
+      expect(Join('', '', '')).toBe('')
+    })
+  })
+
+  describe('Split', () => {
+    it('should split path into directory and file', () => {
+      expect(Split('dir/subdir/file.txt')).toEqual(['dir/subdir/', 'file.txt'])
+      expect(Split('/usr/bin/ls')).toEqual(['/usr/bin/', 'ls'])
+      expect(Split('file.txt')).toEqual(['', 'file.txt'])
+      expect(Split('/')).toEqual(['/', ''])
+      expect(Split('')).toEqual(['', ''])
+    })
+  })
+
+  describe('IsAbs', () => {
+    it('should check if path is absolute', () => {
+      expect(IsAbs('/absolute/path')).toBe(true)
+      expect(IsAbs('relative/path')).toBe(false)
+      expect(IsAbs('/')).toBe(true)
+      expect(IsAbs('')).toBe(false)
+      expect(IsAbs('./relative')).toBe(false)
+    })
+  })
+
+  describe('ToSlash', () => {
+    it('should preserve path on Unix systems (backslashes are regular chars)', () => {
+      // On Unix systems, ToSlash doesn't convert backslashes because they're not separators
+      expect(ToSlash('dir\\subdir\\file.txt')).toBe('dir\\subdir\\file.txt')
+      expect(ToSlash('dir/subdir/file.txt')).toBe('dir/subdir/file.txt')
+      expect(ToSlash('')).toBe('')
+    })
+  })
+
+  describe('FromSlash', () => {
+    it('should preserve path on Unix systems', () => {
+      // On Unix systems, FromSlash doesn't change anything because separator is already '/'
+      expect(FromSlash('dir/subdir/file.txt')).toBe('dir/subdir/file.txt')
+      expect(FromSlash('')).toBe('')
+    })
+  })
+
+  describe('VolumeName', () => {
+    it('should return empty string on Unix systems', () => {
+      expect(VolumeName('C:\\Windows\\System32')).toBe('')
+      expect(VolumeName('/usr/local')).toBe('')
+      expect(VolumeName('')).toBe('')
+    })
+  })
+
+  describe('IsLocal', () => {
+    it('should check if path is local (not escaping)', () => {
+      expect(IsLocal('file.txt')).toBe(true)
+      expect(IsLocal('dir/file.txt')).toBe(true)
+      expect(IsLocal('../file.txt')).toBe(false)
+      expect(IsLocal('/absolute/path')).toBe(false)
+      expect(IsLocal('')).toBe(false)
+      expect(IsLocal('dir/../file')).toBe(true)
+      expect(IsLocal('dir/../../file')).toBe(false)
+    })
+  })
+
+  describe('SplitList', () => {
+    it('should split PATH-style lists', () => {
+      expect(SplitList('/usr/bin:/usr/local/bin:/bin')).toEqual([
+        '/usr/bin',
+        '/usr/local/bin',
+        '/bin',
+      ])
+      expect(SplitList('')).toEqual([])
+      expect(SplitList('/single/path')).toEqual(['/single/path'])
+      expect(SplitList('a:b:c')).toEqual(['a', 'b', 'c'])
+    })
+  })
+
+  describe('HasPrefix', () => {
+    it('should check if path has prefix', () => {
+      expect(HasPrefix('/usr/local/bin', '/usr/local')).toBe(true)
+      expect(HasPrefix('/usr/local', '/usr/local')).toBe(true)
+      expect(HasPrefix('/usr/local/bin', '/usr/bin')).toBe(false)
+      expect(HasPrefix('relative/path', 'relative')).toBe(true)
+      expect(HasPrefix('file.txt', '')).toBe(true)
+      expect(HasPrefix('', 'prefix')).toBe(false)
+    })
+  })
+
+  describe('Abs', () => {
+    it('should handle absolute paths', () => {
+      const [result1, err1] = Abs('/absolute/path')
+      expect(err1).toBeNull()
+      expect(result1).toBe('/absolute/path')
+
+      const [result2, err2] = Abs('relative/path')
+      expect(err2).toBeNull()
+      expect(result2).toBe('/relative/path')
+    })
+  })
+
+  describe('Rel', () => {
+    it('should calculate relative path', () => {
+      const [result1, err1] = Rel('/usr/local', '/usr/local')
+      expect(err1).toBeNull()
+      expect(result1).toBe('.')
+
+      const [result2, err2] = Rel('/usr/local', '/usr/local/bin')
+      expect(err2).toBeNull()
+      expect(result2).toBe('bin')
+
+      const [result3, err3] = Rel('/usr/local', '/other/path')
+      expect(err3).toBeNull()
+      expect(result3).toBe('/other/path')
+    })
+  })
+
+  describe('EvalSymlinks', () => {
+    it('should return cleaned path (stubbed)', () => {
+      const [result, err] = EvalSymlinks('/path/with/../dots')
+      expect(err).toBeNull()
+      expect(result).toBe('/path/dots')
+    })
+  })
+
+  describe('Constants', () => {
+    it('should have correct separator constants', () => {
+      expect(Separator).toBe('/')
+      expect(ListSeparator).toBe(':')
+    })
+  })
+})
+
+describe('Complex path operations', () => {
+  it('should handle edge cases correctly', () => {
+    // Test Clean with complex paths
+    expect(Clean('/a/b/../c/./d/')).toBe('/a/c/d')
+    expect(Clean('a/b/../../c')).toBe('c')
+    expect(Clean('../../a/b')).toBe('../../a/b')
+
+    // Test Join with various inputs
+    expect(Join('/a', '../b', 'c')).toBe('/b/c')
+    expect(Join('a', '/b', 'c')).toBe('/b/c')
+
+    // Test Split edge cases
+    expect(Split('/a/')).toEqual(['/a/', ''])
+    expect(Split('//a')).toEqual(['//', 'a'])
+  })
+
+  it('should maintain path consistency', () => {
+    const testPaths = [
+      'simple/path',
+      '/absolute/path',
+      'path/with/../dots',
+      './relative/path',
+      '../../parent/path',
+    ]
+
+    for (const path of testPaths) {
+      const cleaned = Clean(path)
+      const [dir, file] = Split(cleaned)
+      const rejoined = dir + file
+
+      // Split and rejoin should preserve the cleaned path
+      expect(rejoined).toBe(cleaned)
+    }
+  })
+})

package/gs/path/filepath/path.ts

@@ -0,0 +1,328 @@
+// Package filepath implements utility routines for manipulating filename paths
+// in a way compatible with the target operating system-defined file paths.
+
+// Path separator constants
+export const Separator = '/'
+export const ListSeparator = ':'
+
+// Error constants
+export const SkipDir = new Error('skip this directory')
+export const SkipAll = new Error('skip everything and stop the walk')
+
+// Base returns the last element of path.
+// Trailing path separators are removed before extracting the last element.
+// If the path is empty, Base returns ".".
+// If the path consists entirely of separators, Base returns a single separator.
+export function Base(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  // Strip trailing slashes
+  path = path.replace(/\/+$/, '')
+
+  if (path === '') {
+    return '/'
+  }
+
+  // Find the last slash
+  const i = path.lastIndexOf('/')
+  if (i >= 0) {
+    return path.substring(i + 1)
+  }
+
+  return path
+}
+
+// Dir returns all but the last element of path, typically the path's directory.
+// After dropping the final element, Dir calls Clean on the path and trailing
+// slashes are removed. If the path is empty, Dir returns ".".
+// If the path consists entirely of separators, Dir returns a single separator.
+export function Dir(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  // Strip trailing slashes
+  path = path.replace(/\/+$/, '')
+
+  if (path === '') {
+    return '/'
+  }
+
+  // Find the last slash
+  const i = path.lastIndexOf('/')
+  if (i >= 0) {
+    const dir = path.substring(0, i)
+    return Clean(dir === '' ? '/' : dir)
+  }
+
+  return '.'
+}
+
+// Ext returns the file name extension used by path.
+// The extension is the suffix beginning at the final dot
+// in the final element of path; it is empty if there is no dot.
+export function Ext(path: string): string {
+  const base = Base(path)
+
+  // Handle special case: if the base starts with a dot and has no other dots,
+  // it's a hidden file with no extension
+  if (base.startsWith('.') && base.indexOf('.', 1) === -1) {
+    return ''
+  }
+
+  const i = base.lastIndexOf('.')
+  if (i >= 0) {
+    return base.substring(i)
+  }
+  return ''
+}
+
+// Clean returns the shortest path name equivalent to path
+// by purely lexical processing.
+export function Clean(path: string): string {
+  if (path === '') {
+    return '.'
+  }
+
+  const isAbs = path.startsWith('/')
+  const segments = path
+    .split('/')
+    .filter((segment) => segment !== '' && segment !== '.')
+  const result: string[] = []
+
+  for (const segment of segments) {
+    if (segment === '..') {
+      if (result.length > 0 && result[result.length - 1] !== '..') {
+        result.pop()
+      } else if (!isAbs) {
+        result.push('..')
+      }
+    } else {
+      result.push(segment)
+    }
+  }
+
+  let cleaned = result.join('/')
+  if (isAbs) {
+    cleaned = '/' + cleaned
+  }
+
+  return (
+    cleaned === '' ?
+      isAbs ? '/'
+      : '.'
+    : cleaned
+  )
+}
+
+// Join joins any number of path elements into a single path,
+// separating them with an OS specific Separator. Empty elements
+// are ignored. The result is Cleaned. However, if the argument
+// list is empty or all its elements are empty, Join returns
+// an empty string.
+export function Join(...elem: string[]): string {
+  if (elem.length === 0) {
+    return ''
+  }
+
+  // Filter out empty elements but handle absolute paths
+  const parts: string[] = []
+
+  for (const e of elem) {
+    if (e === '') {
+      continue
+    }
+
+    // If this element is absolute, start over from here
+    if (IsAbs(e)) {
+      parts.length = 0 // Clear previous parts
+      parts.push(e)
+    } else {
+      parts.push(e)
+    }
+  }
+
+  if (parts.length === 0) {
+    return ''
+  }
+
+  return Clean(parts.join('/'))
+}
+
+// Split splits path immediately following the final Separator,
+// separating it into a directory and file name component.
+// If there is no Separator in path, Split returns an empty dir
+// and file set to path. The returned values have the property
+// that path = dir+file.
+export function Split(path: string): [string, string] {
+  const i = path.lastIndexOf('/')
+  if (i < 0) {
+    return ['', path]
+  }
+  return [path.substring(0, i + 1), path.substring(i + 1)]
+}
+
+// IsAbs reports whether the path is absolute.
+export function IsAbs(path: string): boolean {
+  return path.startsWith('/')
+}
+
+// ToSlash returns the result of replacing each separator character
+// in path with a slash ('/') character. Multiple separators are
+// replaced by multiple slashes.
+export function ToSlash(path: string): string {
+  // On Unix-like systems (including our JS environment), the separator is already '/'
+  // so backslashes are just regular characters and should not be converted
+  // This matches Go's behavior on Unix systems
+  return path
+}
+
+// FromSlash returns the result of replacing each slash ('/') character
+// in path with a separator character. Multiple slashes are replaced
+// by multiple separators.
+export function FromSlash(path: string): string {
+  // On Unix-like systems (including our JS environment), separator is '/'
+  // so no conversion needed
+  return path
+}
+
+// VolumeName returns leading volume name.
+// Given "C:\foo\bar" it returns "C:" on Windows.
+// Given "\\host\share\foo" it returns "\\host\share".
+// On other systems, it returns "".
+export function VolumeName(_path: string): string {
+  // In our JS environment, we don't have volume names
+  return ''
+}
+
+// IsLocal reports whether path, using lexical analysis only,
+// has all of these properties:
+//   - is within the subtree rooted at the directory in which path is evaluated
+//   - is not an absolute path
+//   - is not empty
+//   - on Windows, is not a reserved name such as "NUL"
+export function IsLocal(path: string): boolean {
+  if (path === '' || IsAbs(path)) {
+    return false
+  }
+
+  // Check for .. components that would escape
+  const segments = path.split('/')
+  let depth = 0
+
+  for (const segment of segments) {
+    if (segment === '..') {
+      depth--
+      if (depth < 0) {
+        return false
+      }
+    } else if (segment !== '.' && segment !== '') {
+      depth++
+    }
+  }
+
+  return true
+}
+
+// SplitList splits a list of paths joined by the OS-specific ListSeparator,
+// usually found in PATH or GOPATH environment variables.
+// Unlike strings.Split, SplitList returns an empty slice when passed an empty string.
+export function SplitList(path: string): string[] {
+  if (path === '') {
+    return []
+  }
+  return path.split(ListSeparator)
+}
+
+// HasPrefix tests whether the path p begins with prefix.
+export function HasPrefix(p: string, prefix: string): boolean {
+  if (prefix === '') {
+    return true
+  }
+
+  // Normalize both paths
+  const normalP = Clean(p)
+  const normalPrefix = Clean(prefix)
+
+  if (normalP === normalPrefix) {
+    return true
+  }
+
+  // Check if p starts with prefix followed by a separator
+  if (normalP.startsWith(normalPrefix)) {
+    const remaining = normalP.substring(normalPrefix.length)
+    return remaining.startsWith('/')
+  }
+
+  return false
+}
+
+// Stubs for functions that require filesystem operations
+// These are simplified implementations for compatibility
+
+export function Abs(path: string): [string, Error | null] {
+  if (IsAbs(path)) {
+    return [Clean(path), null]
+  }
+  // In a real implementation, this would resolve relative to current working directory
+  // For our purposes, we'll just prepend a fake absolute path
+  return ['/' + Clean(path), null]
+}
+
+export function Rel(
+  basepath: string,
+  targpath: string,
+): [string, Error | null] {
+  // Simplified implementation - in reality this is much more complex
+  const base = Clean(basepath)
+  const targ = Clean(targpath)
+
+  if (base === targ) {
+    return ['.', null]
+  }
+
+  // Very basic relative path calculation
+  if (targ.startsWith(base + '/')) {
+    return [targ.substring(base.length + 1), null]
+  }
+
+  return [targ, null]
+}
+
+export function EvalSymlinks(path: string): [string, Error | null] {
+  // No filesystem support, just return the cleaned path
+  return [Clean(path), null]
+}
+
+export function Glob(_pattern: string): [string[], Error | null] {
+  // No filesystem support, return empty array
+  return [[], null]
+}
+
+// WalkFunc is the type of the function called for each file or directory
+// visited by Walk. The path argument contains the argument to Walk as a
+// prefix; that is, if Walk is called with "dir" and finds a file "a"
+// in that directory, the walk function will be called with argument
+// "dir/a". The info argument is the fs.FileInfo for the named path.
+export type WalkFunc = (
+  path: string,
+  info: any,
+  err: Error | null,
+) => Error | null
+
+export function Walk(root: string, walkFn: WalkFunc): Error | null {
+  // No filesystem support, just call the function with the root
+  return walkFn(root, null, new Error('filesystem not supported'))
+}
+
+export function WalkDir(_root: string, _walkFn: any): Error | null {
+  // No filesystem support
+  return new Error('filesystem not supported')
+}
+
+// Localize is a stub - in Go it's used for Windows path localization
+export function Localize(path: string): [string, Error | null] {
+  return [path, null]
+}

package/gs/path/metadata.go

@@ -0,0 +1,8 @@
+package path
+
+// GsDependencies lists the import paths that this gs/ package requires
+// These dependencies will be automatically copied when this package is included
+var GsDependencies = []string{
+	"errors",
+	"unicode/utf8",
+}

package/gs/reflect/deepequal.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest'
+import { DeepEqual } from './deepequal.js'
+import { Value, BasicType, Int, String as StringType } from './type.js'
+
+describe('DeepEqual', () => {
+  it('should compare primitive values correctly', () => {
+    expect(DeepEqual(5, 5)).toBe(true)
+    expect(DeepEqual(5, 10)).toBe(false)
+
+    expect(DeepEqual('hello', 'hello')).toBe(true)
+    expect(DeepEqual('hello', 'world')).toBe(false)
+
+    expect(DeepEqual(true, true)).toBe(true)
+    expect(DeepEqual(true, false)).toBe(false)
+
+    expect(DeepEqual(null, null)).toBe(true)
+    expect(DeepEqual(undefined, undefined)).toBe(true)
+    expect(DeepEqual(null, undefined)).toBe(false)
+  })
+
+  it('should compare arrays correctly', () => {
+    expect(DeepEqual([1, 2, 3], [1, 2, 3])).toBe(true)
+    expect(DeepEqual([1, 2, 3], [1, 2, 4])).toBe(false)
+    expect(DeepEqual([1, 2, 3], [1, 2])).toBe(false)
+  })
+
+  it('should compare objects correctly', () => {
+    expect(DeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true)
+    expect(DeepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false)
+    expect(DeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false)
+  })
+
+  it('should compare Value objects correctly', () => {
+    const v1 = new Value(42, new BasicType(Int, 'int'))
+    const v2 = new Value(42, new BasicType(Int, 'int'))
+    const v3 = new Value('hello', new BasicType(StringType, 'string'))
+
+    expect(DeepEqual(v1, v2)).toBe(true)
+    expect(DeepEqual(v1, v3)).toBe(false)
+  })
+})

package/gs/reflect/deepequal.ts

@@ -49,7 +49,12 @@
 // values that have been compared before, it treats the values as
 // equal rather than examining the values to which they point.
 // This ensures that DeepEqual terminates.
-export function DeepEqual(x: null | any, y: null | any): boolean {
+import { ReflectValue } from './types.js'
+
+export function DeepEqual(
+  x: ReflectValue | null | undefined,
+  y: ReflectValue | null | undefined,
+): boolean {
   // Handle null/undefined cases
   if (x === y) {
     return true
@@ -112,7 +117,12 @@ export function DeepEqual(x: null | any, y: null | any): boolean {
 
         // Compare elements
         for (let i = 0; i < xMeta.length; i++) {
-          if (!DeepEqual(xMeta.backing[i], yMeta.backing[i])) {
+          if (
+            !DeepEqual(
+              xMeta.backing[i] as ReflectValue,
+              yMeta.backing[i] as ReflectValue,
+            )
+          ) {
             return false
           }
         }
@@ -127,7 +137,10 @@ export function DeepEqual(x: null | any, y: null | any): boolean {
       return false
     }
     for (const [key, value] of x) {
-      if (!y.has(key) || !DeepEqual(value, y.get(key))) {
+      if (
+        !y.has(key) ||
+        !DeepEqual(value as ReflectValue, y.get(key) as ReflectValue)
+      ) {
         return false
       }
     }
@@ -142,7 +155,9 @@ export function DeepEqual(x: null | any, y: null | any): boolean {
       return false
     }
     for (const key of keysX) {
-      if (!keysY.includes(key) || !DeepEqual(x[key], y[key])) {
+      const xObj = x as Record<string, ReflectValue>
+      const yObj = y as Record<string, ReflectValue>
+      if (!keysY.includes(key) || !DeepEqual(xObj[key], yObj[key])) {
         return false
       }
     }