Add readme to tests. Add fileDir option to testament & create nimble test.

compiler/nimblecmd.nim

@@ -9,7 +9,7 @@
 
 ## Implements some helper procs for Nimble (Nim's package manager) support.
 
-import parseutils, strutils, strtabs, os, options, msgs
+import parseutils, strutils, strtabs, os, options, msgs, sequtils
 
 proc addPath*(path: string, info: TLineInfo) =
   if not options.searchPaths.contains(path):
@@ -21,45 +21,59 @@ proc versionSplitPos(s: string): int =
   while result > 1 and s[result] != '-': dec result
   if s[result] != '-': result = s.len
 
-const
+type
-  latest = ""
+  Version = distinct string
 
-proc `<.`(a, b: string): bool =
+proc `$`(ver: Version): string {.borrow.}
-  # wether a has a smaller version than b:
+
-  if a == latest: return true
+proc newVersion(ver: string): Version =
-  elif b == latest: return false
+  doAssert(ver.len == 0 or ver[0] in {'#', '\0'} + Digits,
-  var i = 0
+           "Wrong version: " & ver)
-  var j = 0
+  return Version(ver)
-  var verA = 0
+
-  var verB = 0
+proc isSpecial(ver: Version): bool =
-  while true:
+  return ($ver).len > 0 and ($ver)[0] == '#'
-    let ii = parseInt(a, verA, i)
+
-    let jj = parseInt(b, verB, j)
+proc `<`(ver: Version, ver2: Version): bool =
-    if ii <= 0 or jj <= 0:
+  ## This is synced from Nimble's version module.
-      # if A has no number and B has but A has no number whatsoever ("#head"),
+
-      # A is preferred:
+  # Handling for special versions such as "#head" or "#branch".
-      if ii > 0 and jj <= 0 and j == 0: return true
+  if ver.isSpecial or ver2.isSpecial:
-      if ii <= 0 and jj > 0 and i == 0: return false
+    if ver2.isSpecial and ($ver2).normalize == "#head":
-      # if A has no number left, but B has, B is preferred:  0.8 vs 0.8.3
+      return ($ver).normalize != "#head"
-      return jj > 0
+
-    if verA < verB: return true
+    if not ver2.isSpecial:
-    elif verA > verB: return false
+      # `#aa111 < 1.1`
-    # else: same version number; continue:
+      return ($ver).normalize != "#head"
-    inc i, ii
+
-    inc j, jj
+  # Handling for normal versions such as "0.1.0" or "1.0".
-    if a[i] == '.': inc i
+  var sVer = string(ver).split('.')
-    if b[j] == '.': inc j
+  var sVer2 = string(ver2).split('.')
+  for i in 0..max(sVer.len, sVer2.len)-1:
+    var sVerI = 0
+    if i < sVer.len:
+      discard parseInt(sVer[i], sVerI)
+    var sVerI2 = 0
+    if i < sVer2.len:
+      discard parseInt(sVer2[i], sVerI2)
+    if sVerI < sVerI2:
+      return true
+    elif sVerI == sVerI2:
+      discard
+    else:
+      return false
 
 proc addPackage(packages: StringTableRef, p: string) =
   let x = versionSplitPos(p)
   let name = p.substr(0, x-1)
-  let version = if x < p.len: p.substr(x+1) else: ""
+  let version = newVersion(if x < p.len: p.substr(x+1) else: "")
-  if packages.getOrDefault(name) <. version:
+  if packages.getOrDefault(name).newVersion < version or
-    packages[name] = version
+     (not packages.hasKey(name)):
+    packages[name] = $version
 
 iterator chosen(packages: StringTableRef): string =
   for key, val in pairs(packages):
-    let res = if val == latest: key else: key & '-' & val
+    let res = if val.len == 0: key else: key & '-' & val
     yield res
 
 proc addNimblePath(p: string, info: TLineInfo) =
@@ -82,7 +96,17 @@ proc nimblePath*(path: string, info: TLineInfo) =
   addNimblePath(path, info)
 
 when isMainModule:
+  proc v(s: string): Version = s.newVersion
+  # #head is special in the sense that it's assumed to always be newest.
+  doAssert v"1.0" < v"#head"
+  doAssert v"1.0" < v"1.1"
+  doAssert v"1.0.1" < v"1.1"
+  doAssert v"1" < v"1.1"
+  doAssert v"#aaaqwe" < v"1.1" # We cannot assume that a branch is newer.
+  doAssert v"#a111" < v"#head"
+
   var rr = newStringTable()
+  addPackage rr, "irc-#a111"
   addPackage rr, "irc-#head"
   addPackage rr, "irc-0.1.0"
   addPackage rr, "irc"
@@ -93,5 +117,6 @@ when isMainModule:
   addPackage rr, "ab-0.1"
   addPackage rr, "justone"
 
-  for p in rr.chosen:
+  doAssert toSeq(rr.chosen) ==
-    echo p
+    @["irc-#head", "another-0.1", "ab-0.1.3", "justone"]
+

tests/nimble/nimbleDir/simplePkgs/pkgA-0.1.0/pkgA/module.nim

@@ -0,0 +1 @@
+proc pkgATest*(): int = 1

tests/nimble/nimbleDir/simplePkgs/pkgB-#head/pkgB/module.nim

@@ -0,0 +1 @@
+proc pkgBTest*(): int64 = 0xDEADBEEF

tests/nimble/nimbleDir/simplePkgs/pkgB-0.1.0/pkgB/module.nim

@@ -0,0 +1 @@
+proc pkgBTest*(): int64 = 0

tests/nimble/nimbleDir/simplePkgs/pkgC-#aa11/pkgC/module.nim

@@ -0,0 +1 @@
+proc pkgCTest*(): int64 = 1

tests/nimble/nimbleDir/simplePkgs/pkgC-#head/pkgC/module.nim

@@ -0,0 +1 @@
+proc pkgCTest*(): int64 = 0xDEADBEEF

tests/nimble/readme.md

@@ -0,0 +1,2 @@
+This directory contains tests for the --nimblePath feature.
+

tests/nimble/tnimblepath.nim

@@ -0,0 +1,11 @@
+discard """
+  action: run
+  cmd: "nim $target --nimblePath:$fileDir/nimbleDir/simplePkgs $options $file"
+"""
+import pkgA/module as A
+import pkgB/module as B
+import pkgC/module as C
+
+doAssert pkgATest() == 1, "Simple pkgA-0.1.0 wasn't added to path correctly."
+doAssert pkgBTest() == 0xDEADBEEF, "pkgB-#head wasn't picked over pkgB-0.1.0"
+doAssert pkgCTest() == 0xDEADBEEF, "pkgC-#head wasn't picked over pkgC-#aa11"

tests/readme.md

@@ -0,0 +1,62 @@
+This directory contains the test cases.
+
+Each test must have a filename of the form: ``t*.nim``
+
+**Note:** Tests are only compiled by default. In order to get the tester to
+execute the compiled binary, you need to specify a spec with an ``action`` key
+(see below for details).
+
+# Specs
+
+Each test can contain a spec in a ``discard """ ... """`` block.
+
+**Check out the [``parseSpec`` procedure](https://github.com/nim-lang/Nim/blob/devel/tests/testament/specs.nim#L124) in the ``specs`` module for a full and reliable reference**
+
+## action
+
+Specifies what action this test should take.
+
+**Default: compile**
+
+Options:
+
+* ``compile`` - compiles the module and fails the test if compilations fails.
+* ``run`` - compiles and runs the module, fails the test if compilation or
+            execution of test code fails.
+* ``reject`` - compiles the module and fails the test if compilation succeeds.
+
+There are certain spec keys that imply ``run``, including ``output`` and
+``outputsub``.
+
+## cmd
+
+Specifies the Nim command to use for compiling the test.
+
+There are a number of variables that are replaced in this spec option:
+
+* ``$target`` - the compilation target, e.g. ``c``.
+* ``$options`` - the options for the compiler.
+* ``$file`` - the filename of the test.
+* ``$filedir`` - the directory of the test file.
+
+Example:
+
+```nim
+discard """
+  cmd: "nim $target --nimblePath:./nimbleDir/simplePkgs $options $file"
+"""
+```
+
+# Categories
+
+Each folder under this directory represents a test category, which can be
+tested by running `koch tests cat <category>`.
+
+The folder ``rodfiles`` contains special tests that test incremental
+compilation via symbol files.
+
+The folder ``dll`` contains simple DLL tests.
+
+The folder ``realtimeGC`` contains a test for validating that the realtime GC
+can run properly without linking against the nimrtl.dll/so. It includes a C
+client and platform specific build files for manual compilation.

tests/readme.txt

@@ -1,13 +0,0 @@
-This directory contains the test cases.
-Each test must have a filename of the form: ``t*.nim``
-
-Each test can contain a spec in a ``discard """"""`` block.
-
-The folder ``rodfiles`` contains special tests that test incremental
-compilation via symbol files.
-
-The folder ``dll`` contains simple DLL tests.
-
-The folder ``realtimeGC`` contains a test for validating that the realtime GC
-can run properly without linking against the nimrtl.dll/so. It includes a C
-client and platform specific build files for manual compilation.

tests/testament/tester.nim

@@ -70,10 +70,17 @@ proc normalizeMsg(s: string): string =
     if result.len > 0: result.add '\L'
     result.add x.strip
 
+proc getFileDir(filename: string): string =
+  result = filename.splitFile().dir
+  if not result.isAbsolute():
+    result = getCurrentDir() / result
+
 proc callCompiler(cmdTemplate, filename, options: string,
                   target: TTarget): TSpec =
   let c = parseCmdLine(cmdTemplate % ["target", targetToCmd[target],
-                       "options", options, "file", filename.quoteShell])
+                       "options", options, "file", filename.quoteShell,
+                       "filedir", filename.getFileDir()])
+  echo(c)
   var p = startProcess(command=c[0], args=c[1.. ^1],
                        options={poStdErrToStdOut, poUsePath})
   let outp = p.outputStream
@@ -118,7 +125,8 @@ proc callCompiler(cmdTemplate, filename, options: string,
 proc callCCompiler(cmdTemplate, filename, options: string,
                   target: TTarget): TSpec =
   let c = parseCmdLine(cmdTemplate % ["target", targetToCmd[target],
-                       "options", options, "file", filename.quoteShell])
+                       "options", options, "file", filename.quoteShell,
+                       "filedir", filename.getFileDir()])
   var p = startProcess(command="gcc", args=c[5.. ^1],
                        options={poStdErrToStdOut, poUsePath})
   let outp = p.outputStream

tests/untestable/readme.markdown

@@ -0,0 +1,2 @@
+This directory contains tests which are not automatically executed
+for various reasons. Mainly due to dependencies on external services.