show cmd used with --verbose (even on success); fix #783 (#781)

* show cmd used with --verbose (even on success)

* honor -p:-u:release

* address comment

* remove --showCmds flag

* remove quoteShell

* fix #783

* Revert "fix #783"

This reverts commit af0ac004c00f17e9983c63ab99e40cd38ba6aaa4.

* fix #783 by fixing the gist instead

* Revert "fix #783 by fixing the gist instead" now that upstream gist was updated with my patch

This reverts commit 8bec86039d8335af152acf238ab14d0268e003e5.

.travis.yml

@@ -1,4 +1,5 @@
 os:
+  - windows
   - linux
   - osx
 
@@ -7,23 +8,17 @@ language: c
 env:
   - BRANCH=0.19.6
   - BRANCH=0.20.2
+  - BRANCH=1.0.6
   # This is the latest working Nim version against which Nimble is being tested
-  - BRANCH=#2565d3d102efd21ba02ed1f3b96d892fe2637d2b
+  - BRANCH=#ab525cc48abdbbbed1f772e58e9fe21474f70f07
 
 cache:
   directories:
-    - "$HOME/.choosenim/toolchains/nim-0.19.6"
+    - "$HOME/.choosenim"
-    - "$HOME/.choosenim/toolchains/nim-0.20.2"
 
 install:
-  - export CHOOSENIM_CHOOSE_VERSION=$BRANCH
+  - curl https://gist.github.com/genotrance/fb53504a4fba88bc5201d3783df5c522/raw/travis.sh -LsSf -o travis.sh
-  - |
+  - source travis.sh
-      curl https://nim-lang.org/choosenim/init.sh -sSf > init.sh
-      sh init.sh -y
-
-before_script:
-  - export CHOOSENIM_NO_ANALYTICS=1
-  - export PATH=$HOME/.nimble/bin:$PATH
 
 script:
   - cd tests

changelog.markdown

@@ -3,7 +3,33 @@
 
 # Nimble changelog
 
+## 0.11.0 - 22/09/2019
+
+This is a major release containing nearly 60 commits. Most changes are
+bug fixes, but this release also includes a couple new features:
+
+- Binaries can now be built and run using the new ``run`` command.
+- The ``NimblePkgVersion`` is now defined so you can easily get the package
+  version in your source code
+  ([example](https://github.com/nim-lang/nimble/blob/4a2aaa07d/tests/nimbleVersionDefine/src/nimbleVersionDefine.nim)).
+
+Some other highlights:
+
+- Temporary files are now kept when the ``--debug`` flag is used.
+- Fixed dependency resolution issues with "#head" packages (#432 and #672).
+- The `install` command can now take Nim compiler flags via the new
+  ``--passNim`` flag.
+- Command line arguments are now passed properly to tasks (#633).
+- The ``test`` command now respects the specified backend (#631).
+- The ``dump`` command will no longer prompt and now has an implicit ``-y``.
+- Fixed bugs with the new nimscript executor (#665).
 - Fixed multiple downloads and installs of the same package (#678).
+- Nimble init no longer overwrites existing files (#581).
+- Fixed incorrect submodule version being pulled when in a non-master branch (#675).
+
+----
+
+Full changelog: https://github.com/nim-lang/nimble/compare/v0.10.2...v0.11.0
 
 ## 0.10.2 - 03/06/2019
 

readme.markdown

@@ -15,6 +15,7 @@ Interested in learning **how to create a package**? Skip directly to that sectio
   - [nimble install](#nimble-install)
   - [nimble uninstall](#nimble-uninstall)
   - [nimble build](#nimble-build)
+  - [nimble run](#nimble-run)
   - [nimble c](#nimble-c)
   - [nimble list](#nimble-list)
   - [nimble search](#nimble-search)
@@ -74,10 +75,15 @@ not need to install Nimble manually**.
 But in case you still want to install Nimble manually, you can follow the
 following instructions.
 
-There are two ways to install Nimble manually. The first is using the
+There are two ways to install Nimble manually. Using ``koch`` and using Nimble
-``koch`` tool included in the Nim distribution and
+itself.
+
+### Using koch
+
+The ``koch`` tool is included in the Nim distribution and
 [repository](https://github.com/nim-lang/Nim/blob/devel/koch.nim).
-Simply execute the following command to compile and install Nimble.
+Simply navigate to the location of your Nim installation and execute the
+following command to compile and install Nimble.
 
 ```
 ./koch nimble
@@ -86,6 +92,19 @@ Simply execute the following command to compile and install Nimble.
 This will clone the Nimble repository, compile Nimble and copy it into
 Nim's bin directory.
 
+### Using Nimble
+
+In most cases you will already have Nimble installed, you can install a newer
+version of Nimble by simply running the following command:
+
+```
+nimble install nimble
+```
+
+This will download the latest release of Nimble and install it on your system.
+
+Note that you must have `~/.nimble/bin` in your PATH for this to work, if you're
+using choosenim then you likely already have this set up correctly.
 
 ## Nimble usage
 
@@ -153,12 +172,13 @@ example:
 This is of course Git-specific, for Mercurial, use ``tip`` instead of ``head``. A
 branch, tag, or commit hash may also be specified in the place of ``head``.
 
-Instead of specifying a VCS branch, you may also specify a version range, for
+Instead of specifying a VCS branch, you may also specify a concrete version or a
-example:
+version range, for example:
 
+    $ nimble install nimgame@0.5
     $ nimble install nimgame@"> 0.5"
 
-In this case a version which is greater than ``0.5`` will be installed.
+The latter command will install a version which is greater than ``0.5``.
 
 If you don't specify a parameter and there is a ``package.nimble`` file in your
 current working directory then Nimble will install the package residing in
@@ -219,6 +239,13 @@ flags, i.e. a debug build which includes stack traces but no GDB debug
 information. The ``install`` command will build the package in release mode
 instead.
 
+### nimble run
+
+The ``run`` command can be used to build and run any binary specified in your
+package's ``bin`` list. You can pass any compilation flags you wish by specifying
+them before the ``run`` command, and you can specify arguments for your binary
+by specifying them after the ``run`` command.
+
 ### nimble c
 
 The ``c`` (or ``compile``, ``js``, ``cc``, ``cpp``) command can be used by
@@ -478,7 +505,7 @@ For a package named "foobar", the recommended project structure is the following
 └── src
     └── foobar.nim  # Imported via `import foobar`
 └── tests           # Contains the tests
-    ├── nim.cfg
+    ├── config.nims
     ├── tfoo1.nim   # First test
     └── tfoo2.nim   # Second test
 

src/nimble.nim

@@ -3,12 +3,13 @@
 
 import system except TResult
 
-import os, tables, strtabs, json, algorithm, sets, uri, sugar, sequtils
+import os, tables, strtabs, json, algorithm, sets, uri, sugar, sequtils, osproc
 import std/options as std_opt
 
 import strutils except toLower
 from unicode import toLower
 from sequtils import toSeq
+from strformat import fmt
 
 import nimblepkg/packageinfo, nimblepkg/version, nimblepkg/tools,
        nimblepkg/download, nimblepkg/config, nimblepkg/common,
@@ -200,12 +201,13 @@ proc processDeps(pkginfo: PackageInfo, options: Options): seq[PackageInfo] =
   # in the path.
   var pkgsInPath: StringTableRef = newStringTable(modeCaseSensitive)
   for pkgInfo in result:
+    let currentVer = pkgInfo.getConcreteVersion(options)
     if pkgsInPath.hasKey(pkgInfo.name) and
-       pkgsInPath[pkgInfo.name] != pkgInfo.version:
+       pkgsInPath[pkgInfo.name] != currentVer:
       raise newException(NimbleError,
         "Cannot satisfy the dependency on $1 $2 and $1 $3" %
-          [pkgInfo.name, pkgInfo.version, pkgsInPath[pkgInfo.name]])
+          [pkgInfo.name, currentVer, pkgsInPath[pkgInfo.name]])
-    pkgsInPath[pkgInfo.name] = pkgInfo.version
+    pkgsInPath[pkgInfo.name] = currentVer
 
   # We add the reverse deps to the JSON file here because we don't want
   # them added if the above errorenous condition occurs
@@ -219,7 +221,7 @@ proc buildFromDir(
   options: Options
 ) =
   ## Builds a package as specified by ``pkgInfo``.
-  let binToBuild = options.getCompilationBinary()
+  let binToBuild = options.getCompilationBinary(pkgInfo)
   # Handle pre-`build` hook.
   let realDir = pkgInfo.getRealDir()
   cd realDir: # Make sure `execHook` executes the correct .nimble file.
@@ -233,6 +235,7 @@ proc buildFromDir(
   var args = args
   let nimblePkgVersion = "-d:NimblePkgVersion=" & pkgInfo.version
   for path in paths: args.add("--path:\"" & path & "\" ")
+  var binariesBuilt = 0
   for bin in pkgInfo.bin:
     # Check if this is the only binary that we want to build.
     if binToBuild.isSome() and binToBuild.get() != bin:
@@ -248,10 +251,15 @@ proc buildFromDir(
     if not existsDir(outputDir):
       createDir(outputDir)
 
+    let input = realDir / bin.changeFileExt("nim")
+    # `quoteShell` would be more robust than `\"` (and avoid quoting when
+    # un-necessary) but would require changing `extractBin`
+    let cmd = "\"$#\" $# --noNimblePath $# $# $# \"$#\"" %
+            [getNimBin(), pkgInfo.backend, nimblePkgVersion,
+             join(args, " "), outputOpt, input]
     try:
-      doCmd("\"" & getNimBin() & "\" $# --noNimblePath $# $# $# \"$#\"" %
+      doCmd(cmd, showCmd = true)
-            [pkgInfo.backend, nimblePkgVersion, join(args, " "), outputOpt,
+      binariesBuilt.inc()
-             realDir / bin.changeFileExt("nim")])
     except NimbleError:
       let currentExc = (ref NimbleError)(getCurrentException())
       let exc = newException(BuildFailed, "Build failed for package: " &
@@ -261,6 +269,11 @@ proc buildFromDir(
       exc.hint = hint
       raise exc
 
+  if binariesBuilt == 0:
+    raiseNimbleError(
+      "No binaries built, did you specify a valid binary name?"
+    )
+
   # Handle post-`build` hook.
   cd realDir: # Make sure `execHook` executes the correct .nimble file.
     discard execHook(options, actionBuild, false)
@@ -373,7 +386,7 @@ proc installFromDir(dir: string, requestedVer: VersionRange, options: Options,
                   options.action.passNimFlags
                 else:
                   @[]
-    buildFromDir(pkgInfo, paths, flags & "-d:release", options)
+    buildFromDir(pkgInfo, paths, "-d:release" & flags, options)
 
   let pkgDestDir = pkgInfo.getPkgDest(options)
   if existsDir(pkgDestDir) and existsFile(pkgDestDir / "nimblemeta.json"):
@@ -526,9 +539,9 @@ proc build(options: Options) =
   var args = options.getCompilationFlags()
   buildFromDir(pkgInfo, paths, args, options)
 
-proc execBackend(options: Options) =
+proc execBackend(pkgInfo: PackageInfo, options: Options) =
   let
-    bin = options.getCompilationBinary().get()
+    bin = options.getCompilationBinary(pkgInfo).get()
     binDotNim = bin.addFileExt("nim")
   if bin == "":
     raise newException(NimbleError, "You need to specify a file.")
@@ -716,6 +729,11 @@ proc dump(options: Options) =
   echo "backend: ", p.backend.escape
 
 proc init(options: Options) =
+  # Check whether the vcs is installed.
+  let vcsBin = options.action.vcsOption
+  if vcsBin != "" and findExe(vcsBin, true) == "":
+    raise newException(NimbleError, "Please install git or mercurial first")
+
   # Determine the package name.
   let pkgName =
     if options.action.projName != "":
@@ -850,6 +868,17 @@ js   - Compile using JavaScript backend.""",
     pkgRoot
   )
 
+  # Create a git or hg repo in the new nimble project.
+  if vcsBin != "":
+    let cmd = fmt"cd {pkgRoot} && {vcsBin} init"
+    let ret: tuple[output: string, exitCode: int] = execCmdEx(cmd)
+    if ret.exitCode != 0: quit ret.output
+
+    var ignoreFile = if vcsBin == "git": ".gitignore" else: ".hgignore"
+    var fd = open(joinPath(pkgRoot, ignoreFile), fmWrite)
+    fd.write(pkgName & "\n")
+    fd.close()
+
   display("Success:", "Package $# created successfully" % [pkgName], Success,
     HighPriority)
 
@@ -1045,17 +1074,21 @@ proc test(options: Options) =
       if options.continueTestsOnFailure:
         inc tests
         try:
-          execBackend(optsCopy)
+          execBackend(pkgInfo, optsCopy)
         except NimbleError:
           inc failures
       else:
-        execBackend(optsCopy)
+        execBackend(pkgInfo, optsCopy)
 
       let
         existsAfter = existsFile(binFileName)
         canRemove = not existsBefore and existsAfter
       if canRemove:
-        removeFile(binFileName)
+        try:
+          removeFile(binFileName)
+        except OSError as exc:
+          display("Warning:", "Failed to delete " & binFileName & ": " &
+                  exc.msg, Warning, MediumPriority)
 
   if failures == 0:
     display("Success:", "All tests passed", Success, HighPriority)
@@ -1084,27 +1117,27 @@ proc check(options: Options) =
 
 proc run(options: Options) =
   # Verify parameters.
-  let binary = options.getCompilationBinary().get()
+  var pkgInfo = getPkgInfo(getCurrentDir(), options)
+
+  let binary = options.getCompilationBinary(pkgInfo).get("")
   if binary.len == 0:
     raiseNimbleError("Please specify a binary to run")
 
-  var pkgInfo = getPkgInfo(getCurrentDir(), options)
   if binary notin pkgInfo.bin:
     raiseNimbleError(
       "Binary '$#' is not defined in '$#' package." % [binary, pkgInfo.name]
     )
 
-  let binaryPath = pkgInfo.getOutputDir(binary)
-
   # Build the binary.
   build(options)
 
-  # Now run it.
+  let binaryPath = pkgInfo.getOutputDir(binary) 
-  let args = options.action.runFlags.join(" ")
+  let cmd = quoteShellCommand(binaryPath & options.action.runFlags)
+  displayDebug("Executing", cmd)
+  cmd.execCmd.quit
 
-  doCmd("$# $#" % [binaryPath, args], showOutput = true)
 
-proc doAction(options: Options) =
+proc doAction(options: var Options) =
   if options.showHelp:
     writeHelp()
   if options.showVersion:
@@ -1115,6 +1148,10 @@ proc doAction(options: Options) =
   if not existsDir(options.getPkgsDir):
     createDir(options.getPkgsDir)
 
+  if options.action.typ in {actionTasks, actionRun, actionBuild, actionCompile}:
+    # Implicitly disable package validation for these commands.
+    options.disableValidation = true
+
   case options.action.typ
   of actionRefresh:
     refresh(options)
@@ -1143,7 +1180,8 @@ proc doAction(options: Options) =
   of actionRun:
     run(options)
   of actionCompile, actionDoc:
-    execBackend(options)
+    var pkgInfo = getPkgInfo(getCurrentDir(), options)
+    execBackend(pkgInfo, options)
   of actionInit:
     init(options)
   of actionPublish:
@@ -1169,7 +1207,8 @@ proc doAction(options: Options) =
     var execResult: ExecutionResult[bool]
     if execCustom(options, execResult, failFast=not isPreDefined):
       if execResult.hasTaskRequestedCommand():
-        doAction(execResult.getOptionsForCommand(options))
+        var options = execResult.getOptionsForCommand(options)
+        doAction(options)
     else:
       # If there is no task defined for the `test` task, we run the pre-defined
       # fallback logic.

src/nimblepkg/common.nim

@@ -22,7 +22,8 @@ when not defined(nimscript):
       preHooks*: HashSet[string]
       name*: string
       ## The version specified in the .nimble file.Assuming info is non-minimal,
-      ## it will always be a non-special version such as '0.1.4'
+      ## it will always be a non-special version such as '0.1.4'.
+      ## If in doubt, use `getConcreteVersion` instead.
       version*: string
       specialVersion*: string ## Either `myVersion` or a special version such as #head.
       author*: string

src/nimblepkg/download.nim

@@ -300,4 +300,17 @@ when isMainModule:
     })
     doAssert expected == getVersionList(data)
 
+
+  block:
+    let data2 = @["v0.1.0", "v0.1.1", "v0.2.0",
+                 "0.4.0", "v0.4.2"]
+    let expected2 = toOrderedTable[Version, string]({
+      newVersion("0.4.2"): "v0.4.2",
+      newVersion("0.4.0"): "0.4.0",
+      newVersion("0.2.0"): "v0.2.0",
+      newVersion("0.1.1"): "v0.1.1",
+      newVersion("0.1.0"): "v0.1.0",
+    })
+    doAssert expected2 == getVersionList(data2)
+
   echo("Everything works!")

src/nimblepkg/nimscriptapi.nim

@@ -17,7 +17,7 @@ var
   author*: string      ## The package's author.
   description*: string ## The package's description.
   license*: string     ## The package's license.
-  srcdir*: string      ## The package's source directory.
+  srcDir*: string      ## The package's source directory.
   binDir*: string      ## The package's binary directory.
   backend*: string     ## The package's backend.
 
@@ -101,7 +101,7 @@ proc printPkgInfo(): string =
   printIfLen author
   printIfLen description
   printIfLen license
-  printIfLen srcdir
+  printIfLen srcDir
   printIfLen binDir
   printIfLen backend
 

src/nimblepkg/nimscriptwrapper.nim

@@ -30,6 +30,12 @@ proc needsLiveOutput(actionName: string, options: Options, isHook: bool): bool =
   let isCustomTask = isCustomTask(actionName, options)
   return isCustomTask or isHook or actionName == ""
 
+proc writeExecutionOutput(data: string) =
+  # TODO: in the future we will likely want this to be live, users will
+  # undoubtedly be doing loops and other crazy things in their top-level
+  # Nimble files.
+  display("Info", data)
+
 proc execNimscript(
   nimsFile, projectDir, actionName: string, options: Options, isHook: bool
 ): tuple[output: string, exitCode: int, stdout: string] =
@@ -135,6 +141,7 @@ proc getIniFile*(scriptName: string, options: Options): string =
 
     if exitCode == 0 and output.len != 0:
       result.writeFile(output)
+      stdout.writeExecutionOutput()
     else:
       raise newException(NimbleError, stdout & "\nprintPkgInfo() failed")
 
@@ -175,6 +182,8 @@ proc execScript(
         result.flags[flag].add val.getStr()
   result.retVal = j{"retVal"}.getBool()
 
+  stdout.writeExecutionOutput()
+
 proc execTask*(scriptName, taskName: string,
     options: Options): ExecutionResult[bool] =
   ## Executes the specified task in the specified script.

src/nimblepkg/options.nim

@@ -51,12 +51,13 @@ type
       search*: seq[string] # Search string.
     of actionInit, actionDump:
       projName*: string
+      vcsOption*: string
     of actionCompile, actionDoc, actionBuild:
       file*: string
       backend*: string
       compileOptions: seq[string]
     of actionRun:
-      runFile: string
+      runFile: Option[string]
       compileFlags: seq[string]
       runFlags*: seq[string]
     of actionCustom:
@@ -80,13 +81,19 @@ Commands:
   init         [pkgname]          Initializes a new Nimble project in the
                                   current directory or if a name is provided a
                                   new directory of the same name.
+               --git
+               --hg               Create a git or hg repo in the new nimble project.
   publish                         Publishes a package on nim-lang/packages.
                                   The current working directory needs to be the
                                   toplevel directory of the Nimble package.
   uninstall    [pkgname, ...]     Uninstalls a list of packages.
                [-i, --inclDeps]   Uninstall package and dependent package(s).
-  build        [opts, ...]        Builds a package.
+  build        [opts, ...] [bin]  Builds a package.
-  run          [opts, ...] bin    Builds and runs a package.
+  run          [opts, ...] [bin]  Builds and runs a package.
+                                  Binary needs to be specified after any
+                                  compilation options if there are several
+                                  binaries defined, any flags after the binary
+                                  or -- arg are passed to the binary when it is run.
   c, cc, js    [opts, ...] f.nim  Builds a file inside a package. Passes options
                                   to the Nim compiler.
   test                            Compiles and executes tests
@@ -197,8 +204,10 @@ proc initAction*(options: var Options, key: string) =
     else: options.action.backend = keyNorm
   of actionInit:
     options.action.projName = ""
+    options.action.vcsOption = ""
   of actionDump:
     options.action.projName = ""
+    options.action.vcsOption = ""
     options.forcePrompts = forcePromptYes
   of actionRefresh:
     options.action.optionalURL = ""
@@ -257,6 +266,12 @@ proc parseCommand*(key: string, result: var Options) =
   result.action = Action(typ: parseActionType(key))
   initAction(result, key)
 
+proc setRunOptions(result: var Options, key, val: string, isArg: bool) =
+  if result.action.runFile.isNone() and (isArg or val == "--"):
+    result.action.runFile = some(key)
+  else:
+    result.action.runFlags.add(val)
+
 proc parseArgument*(key: string, result: var Options) =
   case result.action.typ
   of actionNil:
@@ -288,10 +303,7 @@ proc parseArgument*(key: string, result: var Options) =
   of actionBuild:
     result.action.file = key
   of actionRun:
-    if result.action.runFile.len == 0:
+    result.setRunOptions(key, key, true)
-      result.action.runFile = key
-    else:
-      result.action.runFlags.add(key)
   of actionCustom:
     result.action.arguments.add(key)
   else:
@@ -345,6 +357,12 @@ proc parseFlag*(flag, val: string, result: var Options, kind = cmdLongOption) =
       result.action.passNimFlags.add(val)
     else:
       wasFlagHandled = false
+  of actionInit:
+    case f
+    of "git", "hg":
+      result.action.vcsOption = f
+    else:
+      wasFlagHandled = false
   of actionUninstall:
     case f
     of "incldeps", "i":
@@ -355,7 +373,8 @@ proc parseFlag*(flag, val: string, result: var Options, kind = cmdLongOption) =
     if not isGlobalFlag:
       result.action.compileOptions.add(getFlagString(kind, flag, val))
   of actionRun:
-    result.action.runFlags.add(getFlagString(kind, flag, val))
+    result.showHelp = false
+    result.setRunOptions(flag, getFlagString(kind, flag, val), false)
   of actionCustom:
     if result.action.command.normalize == "test":
       if f == "continue" or f == "c":
@@ -367,7 +386,8 @@ proc parseFlag*(flag, val: string, result: var Options, kind = cmdLongOption) =
   if not wasFlagHandled and not isGlobalFlag:
     result.unknownFlags.add((kind, flag, val))
 
-proc initOptions(): Options =
+proc initOptions*(): Options =
+  # Exported for choosenim
   Options(
     action: Action(typ: actionNil),
     pkgInfoCache: newTable[string, PackageInfo](),
@@ -424,7 +444,7 @@ proc parseCmdLine*(): Options =
       else:
         parseArgument(key, result)
     of cmdLongOption, cmdShortOption:
-      parseFlag(key, val, result, kind)
+        parseFlag(key, val, result, kind)
     of cmdEnd: assert(false) # cannot happen
 
   handleUnknownFlags(result)
@@ -509,15 +529,23 @@ proc getCompilationFlags*(options: Options): seq[string] =
   var opt = options
   return opt.getCompilationFlags()
 
-proc getCompilationBinary*(options: Options): Option[string] =
+proc getCompilationBinary*(options: Options, pkgInfo: PackageInfo): Option[string] =
   case options.action.typ
   of actionBuild, actionDoc, actionCompile:
     let file = options.action.file.changeFileExt("")
     if file.len > 0:
       return some(file)
   of actionRun:
-    let runFile = options.action.runFile.changeFileExt("")
+    let optRunFile = options.action.runFile
+    let runFile =
+      if optRunFile.get("").len > 0:
+        optRunFile.get()
+      elif pkgInfo.bin.len == 1:
+        pkgInfo.bin[0]
+      else:
+        ""
+
     if runFile.len > 0:
-      return some(runFile)
+      return some(runFile.changeFileExt(ExeExt))
   else:
-    discard
+    discard

src/nimblepkg/packageparser.nim

@@ -487,6 +487,15 @@ proc toFullInfo*(pkg: PackageInfo, options: Options): PackageInfo =
   else:
     return pkg
 
+proc getConcreteVersion*(pkgInfo: PackageInfo, options: Options): string =
+  ## Returns a non-special version from the specified ``pkgInfo``. If the
+  ## ``pkgInfo`` is minimal it looks it up and retrieves the concrete version.
+  result = pkgInfo.version
+  if pkgInfo.isMinimal:
+    let pkgInfo = pkgInfo.toFullInfo(options)
+    result = pkgInfo.version
+  assert(not newVersion(result).isSpecial)
+
 when isMainModule:
   validatePackageName("foo_bar")
   validatePackageName("f_oo_b_a_r")

src/nimblepkg/tools.nim

@@ -11,7 +11,7 @@ proc extractBin(cmd: string): string =
   else:
     return cmd.split(' ')[0]
 
-proc doCmd*(cmd: string, showOutput = false) =
+proc doCmd*(cmd: string, showOutput = false, showCmd = false) =
   let bin = extractBin(cmd)
   if findExe(bin) == "":
     raise newException(NimbleError, "'" & bin & "' not in PATH.")
@@ -20,7 +20,10 @@ proc doCmd*(cmd: string, showOutput = false) =
   stdout.flushFile()
   stderr.flushFile()
 
-  displayDebug("Executing", cmd)
+  if showCmd:
+    display("Executing", cmd, priority = MediumPriority)
+  else:
+    displayDebug("Executing", cmd)
   if showOutput:
     let exitCode = execCmd(cmd)
     displayDebug("Finished", "with exit code " & $exitCode)

src/nimblepkg/version.nim

@@ -147,7 +147,7 @@ proc makeRange*(version: string, op: string): VersionRange =
     result = VersionRange(kind: verEqLater)
   of "<=":
     result = VersionRange(kind: verEqEarlier)
-  of "":
+  of "", "==":
     result = VersionRange(kind: verEq)
   else:
     raise newException(ParseVersionError, "Invalid operator: " & op)
@@ -298,9 +298,10 @@ when isMainModule:
   doAssert(newVersion("0.1.0") <= newVersion("0.1"))
 
   var inter1 = parseVersionRange(">= 1.0 & <= 1.5")
-  doAssert inter1.kind == verIntersect
+  doAssert(inter1.kind == verIntersect)
   var inter2 = parseVersionRange("1.0")
   doAssert(inter2.kind == verEq)
+  doAssert(parseVersionRange("== 3.4.2") == parseVersionRange("3.4.2"))
 
   doAssert(not withinRange(newVersion("1.5.1"), inter1))
   doAssert(withinRange(newVersion("1.0.2.3.4.5.6.7.8.9.10.11.12"), inter1))

tests/issue432/issue432.nimble

@@ -0,0 +1,15 @@
+# Package
+
+version       = "0.1.0"
+author        = "Dominik Picheta"
+description   = "A new awesome nimble package"
+license       = "MIT"
+srcDir        = "src"
+
+
+
+# Dependencies
+
+requires "nim >= 0.16.0"
+requires "https://github.com/nimble-test/packagea#head",
+         "https://github.com/nimble-test/packagebin2"

tests/issue432/src/issue432.nim

@@ -0,0 +1,7 @@
+# This is just an example to get you started. A typical library package
+# exports the main API in this file. Note that you cannot rename this file
+# but you can remove it if you wish.
+
+proc add*(x, y: int): int =
+  ## Adds two files together.
+  return x + y

tests/issue564/issue564.nimble

@@ -0,0 +1,14 @@
+# Package
+
+version       = "0.1.0"
+author        = "Dominik Picheta"
+description   = "A new awesome nimble package"
+license       = "MIT"
+srcDir = "src"
+bin           = @["issue564/issue564build"]
+
+
+
+# Dependencies
+
+requires "nim >= 0.16.0"

tests/issue564/src/issue564/issue564build.nim

@@ -0,0 +1,5 @@
+# This is just an example to get you started. A typical binary package
+# uses this file as the main entry point of the application.
+
+when isMainModule:
+  echo("Hello, World!")

tests/issue708/issue708.nimble

@@ -0,0 +1,17 @@
+# Package
+
+version       = "0.1.0"
+author        = "Dominik Picheta"
+description   = "A new awesome nimble package"
+license       = "MIT"
+srcDir        = "src"
+
+
+
+# Dependencies
+
+requires "nim >= 0.16.0"
+
+
+echo "hello"
+echo "hello2"

tests/issue708/src/issue708.nim

@@ -0,0 +1,7 @@
+# This is just an example to get you started. A typical library package
+# exports the main API in this file. Note that you cannot rename this file
+# but you can remove it if you wish.
+
+proc add*(x, y: int): int =
+  ## Adds two files together.
+  return x + y

tests/recursive/recursive.nimble

@@ -9,10 +9,9 @@ license       = "BSD"
 
 requires "nim >= 0.12.1"
 
-when defined(windows):
+let
-  let callNimble = "..\\..\\src\\nimble.exe"
+  callNimble = getEnv("NIMBLE_TEST_BINARY_PATH")
-else:
+doAssert callNimble.len != 0, "NIMBLE_TEST_BINARY_PATH not set"
-  let callNimble = "../../src/nimble"
 
 task recurse, "Level 1":
   echo 1

tests/tester.nim

@@ -12,6 +12,9 @@ var installDir = rootDir / "tests" / "nimbleDir"
 const path = "../src/nimble"
 const stringNotFound = -1
 
+# Set env var to propagate nimble binary path
+putEnv("NIMBLE_TEST_BINARY_PATH", nimblePath)
+
 # Clear nimble dir.
 removeDir(installDir)
 createDir(installDir)
@@ -35,7 +38,7 @@ proc execNimble(args: varargs[string]): tuple[output: string, exitCode: int] =
   var quotedArgs = @args
   quotedArgs.insert("--nimbleDir:" & installDir)
   quotedArgs.insert(nimblePath)
-  quotedArgs = quotedArgs.map((x: string) => ("\"" & x & "\""))
+  quotedArgs = quotedArgs.map((x: string) => x.quoteShell)
 
   let path {.used.} = getCurrentDir().parentDir() / "src"
 
@@ -79,6 +82,21 @@ proc hasLineStartingWith(lines: seq[string], prefix: string): bool =
       return true
   return false
 
+test "issue 708":
+  cd "issue708":
+    # TODO: We need a way to filter out compiler messages from the messages
+    # written by our nimble scripts.
+    var (output, exitCode) = execNimble("install", "-y", "--verbose")
+    check exitCode == QuitSuccess
+    let lines = output.strip.processOutput()
+    check(inLines(lines, "hello"))
+    check(inLines(lines, "hello2"))
+
+test "issue 564":
+  cd "issue564":
+    var (_, exitCode) = execNimble("build")
+    check exitCode == QuitSuccess
+
 test "depsOnly + flag order test":
   var (output, exitCode) = execNimble(
     "--depsOnly", "install", "-y", "https://github.com/nimble-test/packagebin2"
@@ -465,17 +483,17 @@ test "issue #349":
   ]
 
   proc checkName(name: string) =
-    when defined(windows):
-      if name.toLowerAscii() in @["con", "nul"]:
-        return
     let (outp, code) = execNimble("init", "-y", name)
     let msg = outp.strip.processOutput()
     check code == QuitFailure
     check inLines(msg,
       "\"$1\" is an invalid package name: reserved name" % name)
-    removeFile(name.changeFileExt("nimble"))
+    try:
-    removeDir("src")
+      removeFile(name.changeFileExt("nimble"))
-    removeDir("tests")
+      removeDir("src")
+      removeDir("tests")
+    except OSError:
+      discard
 
   for reserved in reservedNames:
     checkName(reserved.toUpperAscii())
@@ -915,7 +933,8 @@ suite "nimble run":
         "blahblah", # The command to run
       )
       check exitCode == QuitFailure
-      check output.contains("Binary 'blahblah' is not defined in 'run' package.")
+      check output.contains("Binary '$1' is not defined in 'run' package." %
+                            "blahblah".changeFileExt(ExeExt))
 
   test "Parameters passed to executable":
     cd "run":
@@ -927,9 +946,54 @@ suite "nimble run":
         "check" # Second argument passed to the executed command.
       )
       check exitCode == QuitSuccess
-      check output.contains("tests/run/run --debug check")
+      check output.contains("tests$1run$1$2 --debug check" %
+                            [$DirSep, "run".changeFileExt(ExeExt)])
       check output.contains("""Testing `nimble run`: @["--debug", "check"]""")
 
+  test "Parameters not passed to single executable":
+    cd "run":
+      var (output, exitCode) = execNimble(
+        "--debug", # Flag to enable debug verbosity in Nimble
+        "run", # Run command invokation
+        "--debug" # First argument passed to the executed command
+      )
+      check exitCode == QuitSuccess
+      check output.contains("tests$1run$1$2 --debug" %
+                            [$DirSep, "run".changeFileExt(ExeExt)])
+      check output.contains("""Testing `nimble run`: @["--debug"]""")
+
+  test "Parameters passed to single executable":
+    cd "run":
+      var (output, exitCode) = execNimble(
+        "--debug", # Flag to enable debug verbosity in Nimble
+        "run", # Run command invokation
+        "--", # Flag to set run file to "" before next argument
+        "--debug", # First argument passed to the executed command
+        "check" # Second argument passed to the executed command.
+      )
+      check exitCode == QuitSuccess
+      check output.contains("tests$1run$1$2 --debug check" %
+                            [$DirSep, "run".changeFileExt(ExeExt)])
+      check output.contains("""Testing `nimble run`: @["--debug", "check"]""")
+
+  test "Executable output is shown even when not debugging":
+    cd "run":
+      var (output, exitCode) =
+        execNimble("run", "run", "--option1", "arg1")
+      check exitCode == QuitSuccess
+      check output.contains("""Testing `nimble run`: @["--option1", "arg1"]""")
+
+  test "Quotes and whitespace are well handled":
+    cd "run":
+      var (output, exitCode) = execNimble(
+        "run", "run", "\"", "\'", "\t", "arg with spaces"
+      )
+      check exitCode == QuitSuccess
+      check output.contains(
+        """Testing `nimble run`: @["\"", "\'", "\t", "arg with spaces"]"""
+      )
+
+
 test "NimbleVersion is defined":
   cd "nimbleVersionDefine":
     var (output, exitCode) = execNimble("c", "-r", "src/nimbleVersionDefine.nim")
@@ -940,6 +1004,11 @@ test "NimbleVersion is defined":
     check output2.contains("0.1.0")
     check exitCode2 == QuitSuccess
 
+test "issue 432":
+  cd "issue432":
+    check execNimble("install", "-y", "--depsOnly").exitCode == QuitSuccess
+    check execNimble("install", "-y", "--depsOnly").exitCode == QuitSuccess
+
 test "compilation without warnings":
   const buildDir = "./buildDir/"
   const filesToBuild = [