Merge pull request #44 from Clonkk/devel

Devel

Author: Clonkk

changelog.md

@@ -1,5 +1,32 @@
 Changelog for Nimjl. Date in format YYYY_MM_DD
 
+Release v0.7.4 - 2022_06_08
+===========================
+* Improve Pkg template to handle version, url etc; parameters :
+* See ex11
+  ```nim
+    Julia.init(1):
+      Pkg:
+        add(name="Polynomials", version="3.0.0")
+        add(name="LinearAlgebra")
+        add("DSP")
+      Embed:
+        file("myfile.jl")
+  ```
+
+Release v0.7.3 - 2022_01_04
+===========================
+* Bugfix related to JULIA_PATH not being defined
+
+Release v0.7.2 - 2022_01_04
+===========================
+* Add nthreads argument to Julia.init() to start the Julia VM on multiple threads
+
+Release v0.7.1 - 2022_01_04
+===========================
+* Normalize path during compilation
+* Various docs improvements
+
 Release v0.7.0 - 2022_01_04
 ===========================
 * Add Julia.useModule alias for jlUseModule

examples/ex11_external_deps.nim

@@ -0,0 +1,9 @@
+import nimjl
+
+## See https://pkgdocs.julialang.org/dev/api/#Pkg.add for more info
+Julia.init(1):
+  Pkg:
+    add(name="Polynomials", version="3.0.0")
+    add(name="LinearAlgebra")
+    add("DSP")
+    add(name="Wavelets", version="0.9.4")

nimjl/cores.nim

@@ -12,6 +12,7 @@ proc jlExceptionHandler*() =
    ## Convert a Julia exception to Nim exception
   if not isNil(excpt):
     let msg = $(jl_exception_message())
+    echo "->", msg, "<-"
     raise newException(JlError, msg)
   else:
     discard
@@ -21,6 +22,11 @@ proc jlEval*(code: string): JlValue =
   result = jl_eval_string(code)
   jlExceptionHandler()
 
+proc jlTopLevelEval*(x: JlValue) : JlValue =
+  ## Only use it if you know what you're doing
+  result = jl_toplevel_eval(JlMain, x)
+  jlExceptionHandler()
+
 proc jlInclude*(filename: string) =
   ## Include Julia file
   let tmp = jlEval(&"include(\"{filename}\")")
@@ -132,3 +138,4 @@ proc jlEmbedFile*(filename: static[string]) =
   ## Embed specific Julia file
   const jlContent = staticRead(getProjectPath() / filename)
   staticContents[filename] = jlContent
+

nimjl/glucose.nim

@@ -1,6 +1,6 @@
 # This file is named glucose because it gives you sugar ;)
 # It contains most syntactic sugar to ease using Julia inside Nim
-import std/os
+import std/[os, strutils, strformat]
 import ./types
 import ./cores
 import ./functions
@@ -13,16 +13,63 @@ type Julia* = object
 proc init*(jl: type Julia, nthreads: int = 1) =
   jlVmInit(nthreads)
 
+# This should only be used to generate Expr() in order to use named argument in Pkg interface
+proc fmtJlExpr(val: string): string =
+  result = ""
+  if val[0] == ':' or val.startsWith("Expr") or val.startsWith("QuoteNode"):
+    result.add(val)
+  else:
+    result.addQuoted(val)
+
+proc jlExpr(head: string, vals: varargs[string]): string =
+  result = "Expr("
+  result &= fmtJlExpr(head)
+
+  for val in vals:
+    if not val.isEmptyorWhitespace():
+      result &= ", "
+      result &= fmtJlExpr(val)
+  result &= ")"
+
+type
+  JlPkgSpec = object
+    name, url, path, subdir, rev, version, mode, level: string
+  JlPkgs = seq[JlPkgSpec]
+
+# Workaround because named parameters do not work inside closure for proc defined in template
+# TODO : Should string be static ?
+proc addImpl(pkgs: var JlPkgs, name: static string, url: static string = "", path: static string = "", subdir: static string = "", rev: static string = "", version: static string = "", mode: static string = "", level: static string = "") =
+  if not jlVmIsInit():
+    pkgs.add(JlPkgSpec(name: name, url: url, path: path, subdir: subdir, rev: rev, version: version, mode: mode, level: level))
+
+template add*(name: static string, url: static string = "", path: static string = "", subdir: static string = "", rev: static string = "", version: static string = "", mode: static string = "", level: static string = "") =
+  ## Nim native way of calling Julia Pkg.add during Julia.init()
+  ##
+  ## See https://pkgdocs.julialang.org/dev/api/#Pkg.add for more info
+  ## Pkg.add("Example") # Add a package from registry
+  ## Pkg.add("Example"; preserve=Pkg.PRESERVE_ALL) # Add the `Example` package and preserve existing dependencies
+  ## Pkg.add(name="Example", version="0.3") # Specify version; latest release in the 0.3 series
+  ## Pkg.add(name="Example", version="0.3.1") # Specify version; exact release
+  ## Pkg.add(url="https://github.com/JuliaLang/Example.jl", rev="master") # From url to remote gitrepo
+  ## Pkg.add(url="/remote/mycompany/juliapackages/OurPackage") # From path to local gitrepo
+  ## Pkg.add(url="https://github.com/Company/MonoRepo", subdir="juliapkgs/Package.jl)") # With subdir
+  when declared(jl_pkg_private_scope):
+    addImpl(jl_pkg_private_scope, name, url, path, subdir, rev, version, mode, level)
+  else:
+    {.error: "Pkg: add() can only be called during Julia.init() scope"}
+
 template init*(jl: type Julia, nthreads: int, body: untyped) =
   ## Init Julia VM
-  var packages: seq[string]
-  template Pkg(innerbody: untyped) =
-    ## Pkg installation API
-    proc add(pkgname: string) =
-      packages.add pkgname
-    innerbody
-
-  template Embed(innerbody: untyped) =
+  var packages :JlPkgs
+  template Pkg(innerbody: untyped) {.used.} =
+    block:
+      # Technically accessible but since the type are not exported, what are you going to do with it ?
+      # It's good enough : the API is simple and close to Julia native for people not to get confused
+      var jl_pkg_private_scope {.inject.}: JlPkgs
+      innerbody
+      packages = jl_pkg_private_scope
+
+  template Embed(innerbody: untyped) {.used.} =
     ## Emded Julia file explicitly of from a directory
     template file(filename: static[string]) =
       ## Embed file
@@ -47,10 +94,19 @@ template init*(jl: type Julia, nthreads: int, body: untyped) =
     jl_init()
     # Module installation
     Julia.useModule("Pkg")
-    let pkg = Julia.getModule("Pkg")
-    for pkgname in packages:
-      discard jlCall(pkg, "add", pkgname)
-      jlUsing(pkgname)
+    for pkgspec in packages:
+      var exprs: seq[string] = @[jlExpr(":.", ":Pkg", "QuoteNode(:add)")]
+      for key, field in pkgspec.fieldPairs():
+        let fname =  ":" & key
+        if not isEmptyOrWhitespace(field):
+          exprs.add jlExpr(":kw", fname, field)
+      let strexpr = jlExpr(":call", exprs)
+      var jlexpr = jlEval(strexpr)
+      # Will crash if version are invalid
+      discard jlTopLevelEval(jlexpr)
+      # TODO : handle precompilation ?
+      # Julia.precompile()
+      jlUsing(pkgspec.name)
 
     # Eval Julia code embedded
     loadJlRessources()

nimjl/private/jlcores.nim

@@ -11,13 +11,18 @@ type jl_func *{.importc: "jl_function_t", pure, final.} = object
 type jl_module *{.importc: "jl_module_t", pure, final.} = object
 type jl_datatype*{.importc: "jl_datatype_t", pure, final.} = object
 type jl_sym*{.importc: "jl_sym_t", pure, final.} = object
+type jl_expr*{.importc: "jl_expr_t", pure, final.} = object
+  # head: ptr jl_sym
+  # args: ptr jl_array
 {.pop.}
 
 {.push nodecl, header: JuliaHeader, dynlib: JuliaLibName.}
 proc jl_symbol*(symname: cstring): ptr jl_sym {.importc: "jl_symbol".}
 
 proc jl_eval_string*(code: cstring): ptr jl_value {.importc: "jl_eval_string".}
 
+proc jl_toplevel_eval*(m: ptr jl_module, expr: ptr jl_value): ptr jl_value {.importc: "jl_toplevel_eval".}
+
 # Error handler
 proc jl_exception_occurred*(): ptr jl_value {.importc: "jl_exception_occurred".}
 

nimjl/types.nim

@@ -8,6 +8,7 @@ type
   JlArray*[T] = ptr jl_array
   JlSym* = ptr jl_sym
   JlDataType* = ptr jl_datatype
+  JlExpr* = ptr jl_expr
 
 type
   JlError* = object of IOError

readme.md

@@ -61,6 +61,7 @@ Mostly quality-of-life improvements, especially when handling arrays.
 * Linux / WSL supports only
   * Windows dynamic library linking is different than Linux.
   * If you need Windows support, consider opening an issue or a PR :).
+  * Otherwise, just use WSL
 
 # Examples
 
@@ -77,19 +78,19 @@ echo res # 2.0
 
 ```
 
-## New in version 0.7.0
+## New in version 0.7.4
 
-It is now possible to embed Julia files inside a Nim compiled binary to easily distribute Julia code. To make distribution possible, an API to call ``Pkg.add("...")`` has also been added.
+It is now possible to embed Julia files inside a Nim compiled binary to easily distribute Julia code. To make distribution possible, an API to call ``Pkg.add("...")`` has also been added **with version number easy to specify**.
 
 ```nim
 import nimjl
 
 Julia.init:
   Pkg:
+    add(name="Polynomials", version="3.0.0")
+    add(name="LinearAlgebra")
     add("DSP")
-    add("Wavelets")
-    add("LinearAlgebra")
-    add("Statistics")
+    add(name="Wavelets", version="0.9.4")
 
   Embed:
     # embed all files with '*.jl' extension in folder ``JuliaToolBox/``