dyndoc-ruby-core 1.2.3 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 96cc8056fc32b8e3e88f8f689d8cc5c923fc563c
-  data.tar.gz: 3ecb5ff17a16a5bf8f528f2bbd6b09a031e61ec3
+SHA256:
+  metadata.gz: 43743c1ff1beb4c4f53a80874dda62d41be396be2358a723805a6137895a8519
+  data.tar.gz: a9b1266ed703968a8ffad14deff056e9ed8de134355b73b47aa21fa3718e52a1
 SHA512:
-  metadata.gz: cdd8fd694820fd0591568af526139adb363a25d633f1d4eee7eea06e84bdb4ce198e3f87d3700d0dc68e58bf3925842748b2095cfa35aeebb7fb1e12b8fc7a7b
-  data.tar.gz: 7321db26f0dc1f66954e34e982ed852a7230afc031c54cf37789461dd21ace084ff5ef95c0c9547f9350248d6ab1e658115ed30290123a64f6675cc3a719dd4f
+  metadata.gz: 557f72a70d51e5d0d533f2ccc5f9047f5e07659ecb744e642a95c7cc518c6f9db674f8be84746230437fc32829cfc910f398b1b0b18072f8174b847e0bd6010e
+  data.tar.gz: 601fe0897cdeb6a832c0eb1f5d19d70e7e361cd3917917ebdeb31501f229266168203119b2dbaed705cc9201f2055d99d6dbb800de55e0474e5c8b7b984313b2

data/dyndoc/Tools/julia/Fig.dyn

@@ -0,0 +1,28 @@
+[#rb<]
+  $jlfig=0
+  $jlfig_exts={:png=>".png",:jpeg =>".jpg",:pdf=>".pdf"}
+[#<]
+
+{#def]imgJL[#,] jlcode[] [#,] img[]
+[#,] widthR[15] [#,] heightR[15][#,] unitR[cm][#,] resR[72][#,] optR[]
+[#,] optTex[scale=0.75]
+[#,] newR[TRUE]
+[#=]delete[FALSE]
+[#?]Dyndoc.tmpl_mngr.fmtOutput == "tex"[#<]
+  {#if]#{0?img}[#=]img[:{File.join($dyn_rsrc,"img","jlfig_:{$jlfig+=1}:{$jlfig_exts[:png]}")}]
+  [#else][#<]
+    {#if]File.dirname(#{=img})=="."[#>]img[:{File.join($dyn_rsrc,"img",#{=img})}][#if}
+  [#if}
+[#?]Dyndoc.tmpl_mngr.fmtOutput == "html"[#<]
+  {#if]#{0?img}[#=]img[#r{gsub("\\\\","/",tempfile(fileext=".png"))}][#=]delete[TRUE][#if}
+[#?]#{+?jlcode}[#<]#{jlcode}[#?]end
+[#R<]require(base64)
+#print(#{=img})
+codeimg<-img(#{=img})
+#print(codeimg)
+if(#{delete}) unlink(#{=img})
+[#?]Dyndoc.tmpl_mngr.fmtOutput == "html"
+[#>][#r{codeimg}]
+[#?]Dyndoc.tmpl_mngr.fmtOutput == "tex"
+[#>][\includegraphics[#{optTex}]{#{img}}]
+[#}

data/lib/dyndoc-core.rb

@@ -30,6 +30,7 @@ Settings.define 'cfg_dyn.cmd_pandoc_options', :type => Array, :default => []
 Settings.define 'cfg_dyn.options.pdflatex_nb_pass', :type => Integer, :default => 1
 Settings.define 'cfg_dyn.options.pdflatex_echo', :type => :boolean, :default => false
 Settings.define 'cfg_dyn.debug', :type => :boolean, :default => false
+Settings.define 'cfg_dyn.ruby_only', :type => :boolean, :default => false
 
 Settings.define 'cfg_dyn.dyndoc_session', :type => Symbol, :default => :normal #or :interactive
 
@@ -44,6 +45,7 @@ Settings.define 'cfg_dyn.devel_mode', :type=> Symbol, :default=> :none
 Settings.define 'cfg_dyn.ruby_debug', :type=> Symbol, :default=> :none
 
 Settings.define 'cfg_dyn.model_doc', :default => "default"
+Settings.define 'cfg_dyn.exec_mode', :default => "no"
 Settings.define 'cfg_dyn.format_doc', :default => :tex
 Settings.define 'cfg_dyn.pandoc_filter', :default => ""
 
@@ -60,5 +62,8 @@ Settings.resolve!
 require 'dyndoc/init/config'
 Dyndoc.init_dyndoc_library_path
 Dyndoc.init_rootDoc
+Dyndoc.add_logger
+## Dyndoc.logger.info("dyndoc-core loaded!")
+## Dyndoc.logger.info(".dyndoc.yml: "+File.join(ENV["HOME"],".dyndoc.yml"))
 
 CqlsDoc=Dyndoc #for compatibity

data/lib/dyndoc/base/filter/server.rb

@@ -104,10 +104,30 @@ module Dyndoc
       	out
     end
 
+    def RbServer.redirect
+      if block_given?
+        require 'stringio'
+        begin
+          # redirect output to StringIO objects
+          oldstdout,oldstderr=$stdout, $stderr
+          stdout, stderr = StringIO.new, StringIO.new
+          $stdout, $stderr = stdout, stderr
+          yield
+        ensure
+          # restore normal output
+          $stdout, $stderr = oldstdout,oldstderr
+        end
+        return {stdout: stdout.string, stderr: stderr.string}
+      else
+        return {stdout: "", stderr: ""}
+      end
+
+    end
+
     def RbServer.capture(code,rbEnvir=nil)
 
     	require 'stringio'
-		require 'ostruct'
+		  require 'ostruct'
 
 		begin
 		    # redirect output to StringIO objects
@@ -273,10 +293,10 @@ module Dyndoc
 		      short[0]=short[0].to_i
 		      short[2]=short[2].to_i
 		      ## Dyndoc.warn "short",[short,txt]
-		      (0...short[0]).each{|i| txtout << txt[i].force_encoding("utf-8") << "\n"}
+		      (0...short[0]).each{|i| txtout << (txt[i] ? txt[i].force_encoding("utf-8") : "") << "\n"}
 		      txtout << short[1] << "\n"
 		      le = txt.length
-		      ((le-short[2])...le).each{|i| txtout << txt[i].force_encoding("utf-8") << "\n"}
+		      ((le-short[2])...le).each{|i| txtout << (txt[i] ? txt[i].force_encoding("utf-8") : "") << "\n"}
 		    else
 		    	txt=txt.map{|e| e.force_encoding("utf-8")}
 		      txtout << txt.join("\n")
@@ -808,59 +828,73 @@ module Dyndoc
 	@@initVerb=nil
 
 	def JLServer.initVerb
-		Julia << "include(\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","dyndoc.jl")+"\")"
-		@@initVerb=true
+		Julia << "Base.include(@__MODULE__,\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","dyndoc.jl")+"\")"
+    Julia << "push!(Libdl.DL_LOAD_PATH,\"/usr/lib\");push!(Libdl.DL_LOAD_PATH,\"/usr/local/lib\")"
+  	@@initVerb=true
 	end
 
 	def JLServer.inputsAndOutputs(code,hash=true)
 		JLServer.initVerb unless @@initVerb
-		res=(Julia << 'capture_julia('+code.strip.inspect+')')
-		## Dyndoc.warn "JLServer.inputsAndOutputs",res
-		res.map!{|input,output,output2,error,error2|
+    Dyndoc.logger.info("JLServer.inputsAndOutputs: "+code.strip)
+  	res=(Julia << 'capture_output_julia('+code.strip.inspect.gsub("$","\\$")+')')
+    Dyndoc.logger.info("JLServer.inputsAndOutputs:"+res.inspect)
+    res.map!{|input,output,output2,error,error2|
 			{:input=>input,:output=>output,:output2=>output2,:error=>error,:error2=>error2}
-		} if hash
+		} if res and hash
 		res
 	end
 
 	def JLServer.eval(code)
-		Julia.eval(code)
+		Julia.eval("capture_output_julia("+code.strip.inspect.gsub("$","\\$")+")")
 	end
 
 	def JLServer.output(code,opts={})
-		opts={:print=>true}.merge(opts)
+		#opts={:print=>true}.merge(opts)
 		## Dyndoc.warn "jlserv",code+"|"+Julia.eval(code,:print=>opts[:print]).to_s
-		Julia.eval(code,:print=>opts[:print]).to_s
+		#Julia.eval(code,:print=>opts[:print]).to_s
+		
+		res=JLServer.inputsAndOutputs(code,false)
+		Dyndoc.warn "jlserv.output",[code,res]
+		return "" unless res
+		res=res.map{|input,output,output2,error,error2|
+			#Dyndoc.warn "output",output
+			output
+		}
+		res.length==0 ? "" : res[-1] 
 	end
 
 	def JLServer.outputs(code,opts={}) #may have more than one lines in code
 		## Dyndoc.warn "JLServer.outputs opts",opts
-		## Dyndoc.warn "JLServer code",code
+		## 
+		Dyndoc.warn "JLServer code",code
+		res=JLServer.inputsAndOutputs(code,false)
 		if opts[:block]
-			res=JLServer.inputsAndOutputs(code,false)
 			return "" unless res
 			res.map{|input,output,output2,error,error2|
 				## Dyndoc.warn "output2",output2
-				output2
+				output
 			}.join("\n")
-		else
-			JLServer.eval(code)
 		end
 	end
 
 	def JLServer.echo(code,prompt="julia> ",tab=2)
 		out=""
 		res=JLServer.inputsAndOutputs(code)
-		## Dyndoc.warn "JLServer",res
+		## 
+		Dyndoc.warn "JLServer",res
+    return "Error when executing: "+code unless res
 		res.each do |cmd|
 			## Dyndoc.warn "input",cmd
 		 	out << prompt+ cmd[:input].split("\n").each_with_index.map{|e,i| i==0 ? e : " "*(prompt.length)+e}.join("\n").gsub(/\t/," "*tab)
-			out << "\n"
+			out << "\n" unless cmd[:input].strip[-1]==";"
 			## Dyndoc.warn "output1",out
-			out << cmd[:output2]
-			out << (cmd[:output]=="nothing"  ? "" : cmd[:output])
-			## Dyndoc.warn "output2",out
-			out << cmd[:error]!=""  ? cmd[:error] : ""
-			out << (cmd[:output]=="nothing"  ? "" : "\n\n")
+      if cmd[:error]==""
+  			out << ((cmd[:output]=="nothing" or (cmd[:input].strip)[-1]==";")  ? "" : cmd[:output])
+        out << ((cmd[:output2]=="nothing" or (cmd[:input].strip)[-1]==";")  ? "" : cmd[:output2]) #cmd[:output2]
+  		else
+			  out << cmd[:error]
+      end
+			out << (cmd[:output]=="nothing" ? "" : "\n")
 			## Dyndoc.warn "output3",out
 		end
 		out

data/lib/dyndoc/base/scanner.rb

@@ -219,7 +219,7 @@ module Dyndoc
         #IMPORTANT: process has to have as the second argument e[:type] corresponding to the inside_type and as the third argument res[:type] corresponding to the out_type
 ##Dyndoc.warn "scan",txt2,e[:type],res[:type],(filter ? filter.process(txt2,e[:type],res[:type]) : txt2)
         txt2=((filter and !(txt2=~/\[HTML\]/)) ? filter.process(txt2,e[:type],res[:type]) : txt2)
-##p txt2
+##p [:txt2,txt2]
         txt << txt2
       end
 #puts "txt";p txt
@@ -275,7 +275,7 @@ module Dyndoc
       init_tag(@tag_type) if [:dtag].include? @tag_type
     end
 
-    @@tagblck_set=[:<<,:<,:do,:>>,:>,:">!",:out,:nl,:"\\n",:"r<",:"R<",:"rb<",:"m<",:"M<",:"jl<",:"r>>",:"R>>",:rverb,:"rb>>",:rbverb,:"jl>>",:jlverb,:rout,:"r>",:"R>",:"rb>",:"m>",:"M>",:"jl>",:"_<",:"_>",:"__>",:"html>",:"tex>",:"txtl>",:"ttm>",:"md>",:"adoc>",:tag,:"??",:"?",:yield,:"=",:"-",:+,:"%"]
+    @@tagblck_set=[:<<,:<,:do,:>>,:>,:">!",:out,:nl,:"\\n",:"r<",:"R<",:"rb<",:"m<",:"M<",:"jl<",:"sh<",:"r>>",:"R>>",:rverb,:"rb>>",:rbverb,:"jl>>",:jlverb,:rout,:"r>",:"R>",:"rb>",:"m>",:"M>",:"jl>",:"_<",:"_>",:"__>",:"html>",:"tex>",:"txtl>",:"ttm>",:"md>",:"adoc>",:tag,:"??",:"?",:yield,:"=",:"-",:+,:"%",:"tex=",:"tex+",:"md=",:"md+",:"adoc=",:"adoc+",:"html=",:"html+",:"rb=",:"rb+",:"R=",:"R+",:"jl=",:"jl+",:"txtl=",:"txtl+"]
     #Rmk: when a symbol is included in another one, you have to place it before! Ex: :>> before :> and also :<< before :<
 
     @@tagblck_dyndoc_set = [:main,:content,:before,:after,:require,:helpers,:preamble,:postamble,:style,:title,:path,:first,:last,:default,:cfg]
@@ -302,6 +302,7 @@ module Dyndoc
           :"rb<" => [:blck, :"rb<"],
           :"R<" =>  [:blck, :"R<"],
           :"jl<" => [:blck, :"jl<"],
+          :"sh<" => [:blck, :"sh<"],
           :"r>>" => [:blck, :"r>>"],
           :"R>>" => [:blck, :"r>>"],
           :"*<" =>  [:blck, :"*<"],
@@ -366,7 +367,7 @@ module Dyndoc
       	},
         :mode_arg=>:next_block,
         :tag_code=>[:code,:<,:>,:<<,:txt], #used for arg mode!
-        :arg=>[:if,:unless,:elsif,:for,:case,:def,:func,:meth,:new,:super,:call,:input,:when,:break,:set,:style,:keys,:"?",:"rb<",:"r<",:"R<",:"m<",:"M<",:"jl<"],
+        :arg=>[:if,:unless,:elsif,:for,:case,:def,:func,:meth,:new,:super,:call,:input,:when,:break,:set,:style,:keys,:"?",:"rb<",:"r<",:"R<",:"m<",:"M<",:"jl<",:"sh<"],
         :blck=>{
           :instr=>[:document,:if,:unless,:case,:loop,:set,:tag,:keys,:rverb,:rbverb,:jlverb,:for],
           :keyword=>{
@@ -512,7 +513,7 @@ module Dyndoc
       	else
       	  @dtag[:named_tag][key][:tag].sub("_TAG_",Regexp.escape( key.to_s ))
       	end
-            else
+      else
       	return Regexp.escape(key.to_s)
       end
     end

data/lib/dyndoc/base/tmpl/manager.rb

@@ -77,23 +77,31 @@ module Dyndoc
       if RUBY_PLATFORM =~ /mingw/
         require File.join(ENV["DYNDOC_HOME"],"bin","msys2","file_tools.rb") if ENV["DYNDOC_HOME"]
       end
+      Dyndoc.logger.info "R initialized inside dyndoc!"
     end
 
     def TemplateManager.initJulia
+      Dyndoc.logger.info "initJulia: first"
       first=require "jl4rb" #save if it the first initialization!
+      Dyndoc.logger.info "initJulia: require"
       Julia.init
+      Dyndoc.logger.info "initJulia: init"
       # init rb4jl stuff
       # since inside ruby, no need Ruby.start and Ruby.stop like in rb4R.
       # sort of equivalent of JLServer.init_filter (but not yet defined)!
-      Julia << "include(\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","ruby.jl")+"\")"
-      Julia << "include(\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","dynArray.jl")+"\")"
+      #Julia << "Base.include(@__MODULE__,\"ruby.jl\")"
+      Julia << "Base.include(@__MODULE__,\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","ruby.jl")+ "\")"
+      Dyndoc.logger.info "initJulia: ruby.jl"
+      Julia << "Base.include(@__MODULE__,\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","dynArray.jl")+ "\")"
+      Dyndoc.logger.info "initJulia: dynArray.jl"
       #-| To debug ruby.jl and dynArray.jl => uncomment below and commnt above
       # Julia << "include(\""+File.expand_path("~/Github/dyndoc/share/julia/ruby.jl")+"\")"
       # Julia << "include(\""+File.expand_path("~/Github/dyndoc/share/julia/dynArray.jl")+"\")"
-      Julia << "using Dyndoc"
-      Julia << "Ruby.alive(true)"
+      Julia << "using Main.Dyndoc"
+      Dyndoc.logger.info "initJulia: using Dyndoc"
+      Julia << "Dyndoc.Ruby.alive(true)"
       #Julia << "global const _dynArray=DynArray()"
-      Dyndoc.warn "Julia initialized inside dyndoc!"
+      Dyndoc.logger.info "Julia initialized inside dyndoc!"
 
     end
 
@@ -113,8 +121,10 @@ module Dyndoc
       @cfg[:part_tag][0]=@cfg[:part_tag][0][1..-1] if !(@cfg[:part_tag].empty?) and (@partTag_add= (@cfg[:part_tag][0][0,1]=="+"))
 =end
       ## default system root appended
-      TemplateManager.initR if Dyndoc.cfg_dyn[:langs].include? :R
-      TemplateManager.initJulia if Dyndoc.cfg_dyn[:langs].include? :jl
+      unless  Dyndoc.cfg_dyn[:ruby_only]
+        TemplateManager.initR if Dyndoc.cfg_dyn[:langs].include? :R
+        TemplateManager.initJulia if Dyndoc.cfg_dyn[:langs].include? :jl
+      end
       rbenvir_init(binding)
       @rEnvir=["Global"]
       @envirs={}

data/lib/dyndoc/base/tmpl/parse_do.rb

@@ -1,5 +1,7 @@
 # encoding: UTF-8
 
+require 'securerandom'
+
 ## TODO: .force_encoding("utf-8") needs to be added (see server.rb)
 module Dyndoc
 
@@ -29,7 +31,7 @@ module Dyndoc
 
     @@cmd=["newBlck","input","require","def","func","meth","new","super","blck","do","if","for","case", "loop","r","renv","rverb","rbverb","jlverb","rout","rb","var","set","hide","format","txt","code","<","<<",">","eval","ifndef","tags","keys","opt","document","yield","get","part","style"]
     ## Alias
-    @@cmdAlias={"unless"=>"if","out"=>"do","r<"=>"r","R<"=>"R","rb<"=>"rb","r>"=>"r","R>"=>"R","rb>"=>"rb","m<"=>"m","M<"=>"m","m>"=>"m","M>"=>"m","jl>"=>"jl","jl<"=>"jl","<"=>"txt","<<"=>"txt",">"=>"txt","code"=>"txt","dyn"=>"eval","r>>"=>"rverb","R>>"=>"rverb","rout"=>"rverb","rb>>" => "rbverb","jl>>" => "jlverb","saved"=>"blck","blckAnyTag"=>"blck"}
+    @@cmdAlias={"unless"=>"if","out"=>"do","r<"=>"r","R<"=>"R","rb<"=>"rb","r>"=>"r","R>"=>"R","rb>"=>"rb","m<"=>"m","M<"=>"m","m>"=>"m","M>"=>"m","jl>"=>"jl","jl<"=>"jl","sh<"=>"sh","<"=>"txt","<<"=>"txt",">"=>"txt","code"=>"txt","dyn"=>"eval","r>>"=>"rverb","R>>"=>"rverb","rout"=>"rverb","rb>>" => "rbverb","jl>>" => "jlverb","saved"=>"blck","blckAnyTag"=>"blck"}
     @@cmd += @@cmdAlias.keys
 
     def add_dtag(dtag,cmdAlias=nil)
@@ -65,9 +67,9 @@ module Dyndoc
         Utils.escape!(texblock,CHARS_SET_FIRST)
         Utils.clean_bom_utf8!(texblock)
         Utils.silence_warnings do
-          texblock=@scan.process("{#document][#content]" + texblock + "[#}")
+          texblock=@scan.process("{#document][#content]" + texblock + "[#document}")
         end
-        ## Dyndoc.warn "parsed",texblock
+        ##Dyndoc.warn "parsed",texblock
       end
 #p "texblock";p texblock
       unless filterLoc
@@ -404,7 +406,7 @@ p [vars,b2]
         if @@newBlcks.keys.include? @blckDepth[-1]
           @blckName ||= []
           tmp=blck[1][1].strip
-          @blckName << (tmp.empty? ? `uuidgen`.strip : tmp)
+          @blckName << (tmp.empty? ? SecureRandom.uuid.strip : tmp)
           #puts "blckNAME";p @blckName
         end
 
@@ -482,7 +484,7 @@ p [vars,b2]
           when :do,:<
             i,*b2=next_block(blck,i)
             parse(b2,filter) if cond_tag and cond
-          when :"r<",:"rb<",:"R<",:"m<",:"M<",:"jl<"
+          when :"r<",:"rb<",:"R<",:"m<",:"M<",:"jl<",:"sh<"
             # if current_block_tag==:"jl<"
             #   ##p "iciiiii"
             # end
@@ -498,11 +500,12 @@ p [vars,b2]
                 b2=[code.unshift(newblck)]
     ##puts "r<;rb<";p b2
                 filter.outType=":"+(blck[i].to_s)[0...-1]
-                #p filter.outType
+                #Dyndoc.warn "rb,jl,R block",filter.outType
                 parse(b2,filter)
                 filter.outType=nil
         	    end
-      	  when :"=" #equivalent of :var but DO NOT USE :var
+          #equivalent of :var but DO NOT USE :var
+        when :"=",:"tex=",:"md=",:"adoc=",:"txtl=",:"html=",:"rb=",:"R=",:"jl="
       	    i,*b2=next_block(blck,i)
       	    if cond_tag and cond
       #puts "=:b2";p b2
@@ -516,7 +519,7 @@ p [vars,b2]
       #puts "-:b2"
               parse(b2,filter).strip.split(",").each{|key| @vars.remove(key)}
       	    end
-      	  when :+
+      	  when :+,:"tex+",:"md+",:"adoc+",:"txtl+",:"html+",:"rb+",:"R+",:"jl+"
       ##Dyndoc.warn "+:-1:block",[i,blck]
       	    i,*b2=next_block(blck,i)
       ##Dyndoc.warn "+:0:i,b2",[i,b2]
@@ -569,7 +572,7 @@ p [vars,b2]
       #puts "varNew:#{var}";p @vars.extract_raw(var)
       	      end
       	    end
-           when :out,:>,:">!" # :>! is in some sense equivalent of :set
+          when :out,:>,:">!" # :>! is in some sense equivalent of :set
                   i,*b2=next_block(blck,i)
       #puts "block >, cond_tag, cond";p cond_tag ;p cond
       	     if cond_tag and cond and !b2.empty?
@@ -1055,7 +1058,7 @@ p [vars,b2]
           when :binding
             i,*b2=next_block(blck,i)
             rbEnvir=b2[0][1].strip
-          when :do,:<,:out,:>,:"r<",:"rb<",:"r>",:"R>",:"R<",:"r>>",:rverb,:"rb>>",:rbverb,:"jl>>",:jlverb,:"rb>",:"?",:tag,:"??",:yield,:>>,:"=",:"+",:<<,:"txtl>",:"md>",:"adoc>",:"ttm>",:"html>",:"tex>",:"_>"
+          when :do,:<,:out,:>,:"r<",:"rb<",:"r>",:"R>",:"R<",:"r>>",:rverb,:"rb>>",:rbverb,:"jl>>",:jlverb,:"jl>",:"jl<",:"sh<",:"rb>",:"?",:tag,:"??",:yield,:>>,:"=",:"+",:<<,:"txtl>",:"md>",:"adoc>",:"ttm>",:"html>",:"tex>",:"_>"
             code = blck[i..-1].unshift(:blck)
           when :","
             i,*b2=next_block(blck,i)
@@ -1231,6 +1234,8 @@ p call
 #p var
         end
       end while i<blck.length-1
+      ## IMPORTANT: special treatment for default empty block to avoid infinit loop
+      code["default"] << :out << [:main,""] if code["default"].length==1
       code.each_key{|k| code.delete(k) if code[k].length==1 }
       return [var,code]
     end
@@ -2135,6 +2140,7 @@ p call
     def do_jl(tex,blck,filter)
       return unless Dyndoc.cfg_dyn[:langs].include? :jl
       ## jlBlock stuff
+      ## Dyndoc.warn "do_jl",blck
       as_default_tmpl_mngr! if
       dynBlock=dynBlock_in_doLangBlock?(blck)
       if dynBlock
@@ -2158,7 +2164,7 @@ p call
         as_default_tmpl_mngr!
         tex << JLServer.outputs(code,:block => true)
       else
-        JLServer.eval(code)
+        JLServer.outputs(code)
       end
       ## revert all the stuff
       if dynBlock
@@ -2168,6 +2174,15 @@ p call
       filter.outType=nil
     end
 
+    def do_sh(tex,blck,filter)
+#Dyndoc.warn "do_sh: blck ";p blck[1..-1]
+      filter.outType="none"
+      code=parse(blck[1..-1],filter)
+      %x[ #{code} ]
+#Dyndoc.warn "do_sh: code ";p code
+      filter.outType=nil
+    end
+
     def do_m(tex,blck,filter)
       newblck=blck[0]
 # Dyndoc.warn "do_m";p blck

data/lib/dyndoc/init/config.rb

@@ -19,7 +19,7 @@ module Dyndoc
   }
 
   require 'logger'
-  @@dyn_logger = Logger.new @@cfg_dir[:log_file], 7, 1048576
+  @@dyn_logger = nil
 
   def Dyndoc.cfg_dir
     @@cfg_dir
@@ -29,10 +29,18 @@ module Dyndoc
     Settings[:cfg_dyn]
   end
 
+  def Dyndoc.add_logger
+    @@dyn_logger = Logger.new(@@cfg_dir[:log_file], 7, 1048576)
+  end
+
   def Dyndoc.logger
     @@dyn_logger
   end
 
+  def Dyndoc.logger_info(txt)
+    @@dyn_logger.info(txt)
+  end
+
   @@dyn_block={}
 
   def Dyndoc.dyn_block

data/share/julia/dynArray.jl

@@ -1,21 +1,24 @@
-# include("ruby.jl")
+
 
 module Dyndoc
 
-import Base.setindex!,Base.getindex,Base.IO,Base.show,Base.showarray
-importall Ruby
+
+using Main.Ruby
+
+import Base.setindex!,Base.getindex,Base.IO,Base.show #,Base.showarray
+import Main.Ruby.start,Main.Ruby.stop,Main.Ruby.run,Main.Ruby.alive
 
 export DynVector,DynArray,getindex,setindex!,show,Vector,sync,getkey
 
 # this is just a wrapper of Vector type with update of all connected vectors
-# when change on the vector occurs 
+# when change on the vector occurs
 
 
-type DynVector
+mutable struct DynVector
 	ary::Vector
-	key::ASCIIString
+	key::String
 
-	DynVector(a::Vector,k::ASCIIString)=(x=new();x.ary=a;x.key=k;x)
+	#DynVector(a::Vector,k::String)=(x=new();x.ary=a;x.key=k;x)
 end
 
 function getindex(dynvect::DynVector,i::Integer)
@@ -26,35 +29,34 @@ end
 function setindex!(dynvect::DynVector,value,i::Integer)
 	dynvect.ary[i]=value
 	## println("inisde vect:",Ruby.alive())
-	if Ruby.alive() 
-		Ruby.run("Dyndoc::Vector[\""*dynvect.key*"\"].sync(:jl)") 
+	if Ruby.alive()
+		Ruby.run("Dyndoc::Vector[\""*dynvect.key*"\"].sync(:jl)")
 	end
 end
 
-show(io::IO,dynvect::DynVector)=showarray(io,dynvect.ary)
+show(io::IO,dynvect::DynVector)=show(io,dynvect.ary)
 
 # gather all the julia vectors connected to dyndoc.
 
-type DynArray
+mutable struct DynArray
 	vars::Dict
-
 	DynArray()=(x=new();x.vars=Dict();x)
 end
 
 global const Vec=DynArray()
 
-function getindex(dynary::DynArray,key::ASCIIString)
+function getindex(dynary::DynArray,key::String)
 	#println("getindex(" * key * ")->todo")
 	#if Ruby.alive()
 		#println("getindex(" * key * ")->to sync")
-		#Ruby.run("Dyndoc::Vector[\""*key*"\"].sync_to(:jl)") 
+		#Ruby.run("Dyndoc::Vector[\""*key*"\"].sync_to(:jl)")
 	#end
 	#println("getindex(" * key * ")->done")
 	dynary.vars[key]
 end
 getindex(dynary::DynArray,key::Symbol)=getindex(dynary,string(key))
 
-function setindex!(dynary::DynArray,value,key::ASCIIString)
+function setindex!(dynary::DynArray,value,key::String)
 	#println("key:" * key)
 	#println(keys(dynary.vars))
 	if(haskey(dynary.vars,key))
@@ -65,7 +67,7 @@ function setindex!(dynary::DynArray,value,key::ASCIIString)
 	end
 
 	## println("inside array:",Ruby.alive())
-	
+
 	if Ruby.alive()
 		Ruby.run("Dyndoc::Vector[\""*key*"\"].sync(:jl)")
 	end
@@ -73,13 +75,13 @@ end
 setindex!(dynary::DynArray,value,key::Symbol)=setindex!(dynary,value,string(key))
 
 
-sync(dynary::DynArray,key::ASCIIString)= if Ruby.alive() Ruby.run("Dyndoc::Vector[\""*key*"\"].sync(:jl)") end
+sync(dynary::DynArray,key::String)= if Ruby.alive() Ruby.run("Dyndoc::Vector[\""*key*"\"].sync(:jl)") end
 
 show(io::IO,dynary::DynArray)=show(io,dynary.vars)
 
 # NO MORE KEY WITH THE FORM "<name>@<ruby id object>"
 # function getkey(dynary::DynArray,k::Symbol)
-# 	for k2 in keys(dynary.vars)  
+# 	for k2 in keys(dynary.vars)
 # 	 	if split(k2,"@")[1] == string(k)
 # 	 		return k2
 # 	 	end
@@ -90,4 +92,3 @@ show(io::IO,dynary::DynArray)=show(io,dynary.vars)
 # setindex!(dynary::DynArray,value,key::Symbol)=setindex!(dynary,value,getkey(dynary,key))
 
 end
-

data/share/julia/dyndoc.jl

@@ -1,87 +1,55 @@
-#cmd="a=1\n(a)\nfor i in 1:3\nprintln(i)\nend"
-
-# # Unused! See capture_julia
-# function capture_cmd(cmd::AbstractString)
-# 	add,cmd0=true,AbstractString[]
-# 	res=Any[] #Dict{AbstractString,Any}()
-# 	for l=split(cmd,"\n")
-# 		#println("l => ",l)
-# 		push!(cmd0,l)
-# 		pcmd0=Base.parse_input_line(join(cmd0,"\n"))
-# 		#print(join(cmd0,"\n")*":");println(pcmd0)
-# 		add = typeof(pcmd0)==Expr && pcmd0.head == :continue
-# 		if !add
-# 			#print("ici:")
-# 			#println(Base.eval(pcmd0))
-# 			push!(res,(join(cmd0,"\n"),eval(pcmd0)))
-# 			cmd0=AbstractString[]
-# 		end
-# 		#println(res)
-# 	end
-# 	res
-# end
-
-module DyndocSandbox
-	importall Ruby
-	importall Dyndoc
+module Dyndoc2Sandbox
+	import Main.Ruby.run,Main.Ruby.alive
+	import Main.Dyndoc.DynVector,Main.Dyndoc.DynArray,Main.Dyndoc.getindex,Main.Dyndoc.setindex!,Main.Dyndoc.show,Main.Dyndoc.Vector,Main.Dyndoc.sync,Main.Dyndoc.getkey
+	using InteractiveUtils
+end
 
-    # Replace OUTPUT_STREAM references so we can capture output.
-    OUTPUT_STREAM = IOBuffer()
-    print(x) = Base.print(OUTPUT_STREAM, x)
-    println(x) = Base.println(OUTPUT_STREAM, x)
 
-    # Output
-    MIME_OUTPUT = Array(Tuple, 0)
-    emit(mime, data) = push!(MIME_OUTPUT, (mime, data))
+function replace_dyndoc2sandbox(txt)
+	replace(replace(txt,"Main.Dyndoc2Sandbox." => ""),"Main.Dyndoc2Sandbox" => "Main")
 end
 
-function get_stdout_iobuffer()
-	#seek(DyndocSandbox.OUTPUT_STREAM, 0)
-	#jl4rb_out =
-	takebuf_string(DyndocSandbox.OUTPUT_STREAM)
-	#truncate(DyndocSandbox.OUTPUT_STREAM, 0)
-	#jl4rb_out
+function echo_repl_julia(res)
+#	buf = IOBuffer();
+#	td = TextDisplay(buf);
+#	display(td, res);
+#	takebuf_string(buf)
+#println(typeof(res))
+	replace_dyndoc2sandbox(repr("text/plain",res))
 end
 
-function get_stderr_iobuffer()
-	#jl4rb_out = takebuf_string(STDERR.buffer)
-	#jl4rb_out
-	## THIS FAILS WHEN DYNDOC DAEMONIZED SO AUTOMATIC EMPTY RESULT for now
-	## MAYBE TO DELETE SOON!
-	""
+## Rmk: The process is based on what is done in weave.jl (src/run.jl)
+getstdout() = stdout #Base.STDOUT
+function capture_output_expr(expr)
+    #oldSTDOUT = STDOUT
+    oldSTDOUT = getstdout()
+    out = nothing
+    obj = nothing
+    rw, wr = redirect_stdout()
+    reader = @async read(rw, String) # @async readstring(rw)
+    try
+        obj = Core.eval(Dyndoc2Sandbox, expr)
+        obj != nothing && display(obj)
+	#catch E
+    #    throw_errors && throw(E)
+    #    display(E)
+    #    @warn("ERROR: $(typeof(E)) occurred, including output in Weaved document")
+    
+    finally
+        redirect_stdout(oldSTDOUT)
+        close(wr)
+        out = fetch(reader) #wait(reader)
+        close(rw)
+    end
+    return (obj, out)
 end
 
-# export weave
-# module DyndocSandbox
-#     # Copied from Gadfly.jl/src/weave.jl
-#     # Replace OUTPUT_STREAM references so we can capture output.
-#     OUTPUT_STREAM = IOString()
-#     print(x) = Base.print(OUTPUT_STREAM, x)
-#     println(x) = Base.println(OUTPUT_STREAM, x)
-
-#     function eval(expr)
-#     	result = try
-#             Base.eval(DyndocSandbox, expr)
-#             seek(DyndocSandbox.OUTPUT_STREAM, 0)
-#         	output = takebuf_string(DyndocSandbox.OUTPUT_STREAM)
-#         	truncate(DyndocSandbox.OUTPUT_STREAM, 0)
-#         	output
-#         catch e
-#             io = IOBuffer()
-#             print(io, "ERROR: ")
-#             Base.error_show(io, e)
-#             tmp = bytestring(io)
-#             close(io)
-#             tmp
-#         end
-#         result
-#     end
-# end
-
-function capture_julia(cmd::AbstractString)
+function capture_output_julia(cmd::AbstractString)
 	add,cmd0=true,AbstractString[]
 	res=Any[] #Dict{AbstractString,Any}()
 	#println(cmd)
+	#cmd=replace(cmd,r"\$","\$")
+
 	for l=split(cmd,"\n")
 		#println("l => ",l)
 		push!(cmd0,l)
@@ -91,17 +59,18 @@ function capture_julia(cmd::AbstractString)
 		if !add
 			#print("ici:")
 			#println(Base.eval(pcmd0))
-			result,error = "",""
+			result,error,out = "","",""
 			try
-				result=eval(DyndocSandbox, pcmd0)
+				result,out=capture_output_expr(pcmd0)
 			catch e
-	            #io = IOBuffer()
-	            #print(io, "ERROR: ")
-	            #Base.error_show(io, e)
-	            error = "Error: $(string(e))"
-	            #close(io)
-	        end
-			push!(res,(join(cmd0,"\n"),string(result),get_stdout_iobuffer(),error,get_stderr_iobuffer()))
+				#io = IOBuffer()
+				#print(io, "ERROR: ")
+				#Base.error_show(io, e)
+				error = "ERROR: $(sprint(showerror,e))"
+				#close(io)
+			end
+			println(l)
+			push!(res,(join(cmd0,"\n"), echo_repl_julia(result),replace_dyndoc2sandbox(out),replace_dyndoc2sandbox(error),""))
 			cmd0=AbstractString[]
 		end
 		#println(res)

data/share/julia/dyndocOLD.jl

@@ -0,0 +1,192 @@
+#cmd="a=1\n(a)\nfor i in 1:3\nprintln(i)\nend"
+
+# # Unused! See capture_julia
+# function capture_cmd(cmd::AbstractString)
+# 	add,cmd0=true,AbstractString[]
+# 	res=Any[] #Dict{AbstractString,Any}()
+# 	for l=split(cmd,"\n")
+# 		#println("l => ",l)
+# 		push!(cmd0,l)
+# 		pcmd0=Base.parse_input_line(join(cmd0,"\n"))
+# 		#print(join(cmd0,"\n")*":");println(pcmd0)
+# 		add = typeof(pcmd0)==Expr && pcmd0.head == :continue
+# 		if !add
+# 			#print("ici:")
+# 			#println(Base.eval(pcmd0))
+# 			push!(res,(join(cmd0,"\n"),eval(pcmd0)))
+# 			cmd0=AbstractString[]
+# 		end
+# 		#println(res)
+# 	end
+# 	res
+# end
+
+module DyndocSandbox
+	import Main.Ruby.start,Main.Ruby.stop,Main.Ruby.run,Main.Ruby.alive
+	import Main.Dyndoc.DynVector,Main.Dyndoc.DynArray,Main.Dyndoc.getindex,Main.Dyndoc.setindex!,Main.Dyndoc.show,Main.Dyndoc.Vector,Main.Dyndoc.sync,Main.Dyndoc.getkey
+
+    # Replace OUTPUT_STREAM references so we can capture output.
+    OUTPUT_STREAM = IOBuffer()
+    print(x) = Base.print(OUTPUT_STREAM, x)
+    println(x) = Base.println(OUTPUT_STREAM, x)
+
+    # Output
+    MIME_OUTPUT = Array(Tuple, 0)
+    emit(mime, data) = push!(MIME_OUTPUT, (mime, data))
+end
+
+function get_stdout_iobuffer()
+	#seek(DyndocSandbox.OUTPUT_STREAM, 0)
+	#jl4rb_out =
+	takebuf_string(DyndocSandbox.OUTPUT_STREAM)
+	#truncate(DyndocSandbox.OUTPUT_STREAM, 0)
+	#jl4rb_out
+end
+
+function get_stderr_iobuffer()
+	#jl4rb_out = takebuf_string(STDERR.buffer)
+	#jl4rb_out
+	## THIS FAILS WHEN DYNDOC DAEMONIZED SO AUTOMATIC EMPTY RESULT for now
+	## MAYBE TO DELETE SOON!
+	""
+end
+
+# export weave
+# module DyndocSandbox
+#     # Copied from Gadfly.jl/src/weave.jl
+#     # Replace OUTPUT_STREAM references so we can capture output.
+#     OUTPUT_STREAM = IOString()
+#     print(x) = Base.print(OUTPUT_STREAM, x)
+#     println(x) = Base.println(OUTPUT_STREAM, x)
+
+#     function eval(expr)
+#     	result = try
+#             Base.eval(DyndocSandbox, expr)
+#             seek(DyndocSandbox.OUTPUT_STREAM, 0)
+#         	output = takebuf_string(DyndocSandbox.OUTPUT_STREAM)
+#         	truncate(DyndocSandbox.OUTPUT_STREAM, 0)
+#         	output
+#         catch e
+#             io = IOBuffer()
+#             print(io, "ERROR: ")
+#             Base.error_show(io, e)
+#             tmp = bytestring(io)
+#             close(io)
+#             tmp
+#         end
+#         result
+#     end
+# end
+
+
+function capture_julia(cmd::AbstractString)
+	add,cmd0=true,AbstractString[]
+	res=Any[] #Dict{AbstractString,Any}()
+	#println(cmd)
+	#cmd=replace(cmd,r"\$","\$")
+	# for standard redirection
+	##OUT: (outRead, outWrite) = redirect_stdout()
+	for l=split(cmd,"\n")
+		#println("l => ",l)
+		push!(cmd0,l)
+		pcmd0=Base.parse_input_line(join(cmd0,"\n"))
+		#print(join(cmd0,"\n")*":");println(pcmd0)
+		add = typeof(pcmd0)==Expr && pcmd0.head == :incomplete
+		if !add
+			#print("ici:")
+			#println(Base.eval(pcmd0))
+			result,error = "",""
+			try
+				result=eval(DyndocSandbox, pcmd0)
+			catch e
+          #io = IOBuffer()
+          #print(io, "ERROR: ")
+          #Base.error_show(io, e)
+          error = "Error: $(string(e))"
+          #close(io)
+      end
+
+			##OUT: data_out = readavailable(outRead)
+
+			##OUT: push!(res,(join(cmd0,"\n"),echo_repl_julia(result),get_stdout_iobuffer(),data_out,error,get_stderr_iobuffer()))
+			push!(res,(join(cmd0,"\n"),echo_repl_julia(result),get_stdout_iobuffer(),error,get_stderr_iobuffer()))
+			cmd0=AbstractString[]
+		end
+		#println(res)
+	end
+	##OUT: close(outWrite);close(outRead)
+	res
+end
+
+
+module Dyndoc2Sandbox
+	import Main.Ruby.run,Main.Ruby.alive
+	import Main.Dyndoc.DynVector,Main.Dyndoc.DynArray,Main.Dyndoc.getindex,Main.Dyndoc.setindex!,Main.Dyndoc.show,Main.Dyndoc.Vector,Main.Dyndoc.sync,Main.Dyndoc.getkey
+end
+
+function echo_repl_julia(res)
+	buf = IOBuffer();
+	td = TextDisplay(buf);
+	display(td, res);
+	takebuf_string(buf)
+end
+
+## Rmk: The process is based on what is done in weave.jl (src/run.jl)
+getstdout() = stdout #Base.STDOUT
+function capture_output_expr(expr)
+    #oldSTDOUT = STDOUT
+    oldSTDOUT = getstdout()
+    out = nothing
+    obj = nothing
+    rw, wr = redirect_stdout()
+    reader = @async read(rw, String) # @async readstring(rw)
+    try
+        obj = eval(Dyndoc2Sandbox, expr)
+        obj != nothing && display(obj)
+	catch E
+        throw_errors && throw(E)
+        display(E)
+        @warn("ERROR: $(typeof(E)) occurred, including output in Weaved document")
+    
+    finally
+        redirect_stdout(oldSTDOUT)
+        close(wr)
+        out = wait(reader)
+        close(rw)
+    end
+    return (obj, out)
+end
+
+function capture_output_julia(cmd::AbstractString)
+	add,cmd0=true,AbstractString[]
+	res=Any[] #Dict{AbstractString,Any}()
+	#println(cmd)
+	#cmd=replace(cmd,r"\$","\$")
+
+	for l=split(cmd,"\n")
+		#println("l => ",l)
+		push!(cmd0,l)
+		pcmd0=Base.parse_input_line(join(cmd0,"\n"))
+		#print(join(cmd0,"\n")*":");println(pcmd0)
+		add = typeof(pcmd0)==Expr && pcmd0.head == :incomplete
+		if !add
+			#print("ici:")
+			#println(Base.eval(pcmd0))
+			result,error,out = "","",""
+			try
+				result,out=capture_output_expr(pcmd0)
+			catch e
+          #io = IOBuffer()
+          #print(io, "ERROR: ")
+          #Base.error_show(io, e)
+          error = "Error: $(string(e))"
+          #close(io)
+      end
+
+			push!(res,(join(cmd0,"\n"),echo_repl_julia(result),out,error,""))
+			cmd0=AbstractString[]
+		end
+		#println(res)
+	end
+	res
+end

data/share/julia/dynreport.jl

@@ -0,0 +1,127 @@
+
+## Inspired from the excellent weave.jl
+
+using Compat
+
+#Contains report global properties
+mutable struct DyndocReport <: AbstractDisplay
+  #cwd::AbstractString
+  #basename::AbstractString
+  #formatdict::Dict{Symbol,Any}
+  #pending_code::AbstractString
+  #cur_result::AbstractString
+  #rich_output::AbstractString
+  fignum::Int
+  figures::Array{AbstractString}
+  #term_state::Symbol
+  #cur_chunk
+  mimetypes::Array{AbstractString}
+#  first_plot::Bool
+  #header_script::String
+  #throw_errors::Bool
+end
+
+#function Report(cwd, basename, formatdict, mimetypes, throw_errors)
+#    Report(cwd, basename, formatdict, "", "", "", 1, AbstractString[], :text, nothing,
+#        mimetypes, true, "", throw_errors)
+#end
+
+
+#Default mimetypes in order, can be overridden for some inside `run method` formats
+const default_mime_types = ["image/svg+xml", "image/png", "text/html", "text/plain"]
+#const default_mime_types = ["image/png", "image/svg+xml", "text/html", "text/plain"]
+#From IJulia as a reminder
+#const supported_mime_types = [ "text/html", "text/latex", "image/svg+xml", "image/png", "image/jpeg", "text/plain", "text/markdown" ]
+
+function Base.display(report::DyndocReport, data)
+    #Set preferred mimetypes for report based on format
+    for m in report.mimetypes
+        if showable(m, data)
+            try
+                if !istextmime(m)
+                    Compat.invokelatest(display, report, m, data)
+                elseif report.cur_chunk.options[:term]
+                    Compat.invokelatest(display, report, "text/plain", data)
+                else
+                    Compat.invokelatest(display, report, m, data)
+                end
+            catch e
+                throw(e)
+                @warn("Failed to display data in \"$m\" format")
+                continue
+            end
+            break
+        end
+    end
+end
+
+function Base.display(report::DyndocReport, m::MIME"image/png", data)
+    figname = add_figure(report, data, m, ".png")
+end
+
+function Base.display(report::DyndocReport, m::MIME"image/svg+xml", data)
+    figname = add_figure(report, data, m, ".svg")
+end
+
+function Base.display(report::DyndocReport, m::MIME"application/pdf", data)
+    figname = add_figure(report, data, m, ".pdf")
+end
+
+#Text is written to stdout, called from "term" mode chunks
+function Base.display(report::DyndocReport, m::MIME"text/plain", data)
+    io = PipeBuffer()
+    show(IOContext(io, :limit => true), m, data)
+    flush(io)
+    s = read(io, String)
+    close(io)
+    println(s)
+end
+
+function Base.display(report::DyndocReport, m::MIME"text/plain", data::Exception)
+    println("Error: " * sprint(showerror, data))
+end
+
+function Base.display(report::DyndocReport, m::MIME"text/html", data::Exception)
+    report.rich_output = sprint(show, m, data)
+end
+
+function Base.show(io, m::MIME"text/html", data::Exception)
+    println(io ,"<pre class=\"julia-error\">")
+    println(io, Markdown.htmlesc("ERROR: " * sprint(showerror, data)))
+    println(io ,"</pre>")
+end
+
+#Catch "rich_output"
+function Base.display(report::DyndocReport, m::MIME"text/html", data)
+    s = repr(m, data)
+    report.rich_output *= "\n" * s
+end
+
+#Catch "rich_output"
+function Base.display(report::DyndocReport, m::MIME"text/markdown", data)
+    s = repr(m, data)
+    report.rich_output *= "\n" * s
+end
+
+function Base.display(report::DyndocReport, m::MIME"text/latex", data)
+    s = repr(m, data)
+    report.rich_output *= "\n" * s
+end
+
+"""Add saved figure name to results and return the name"""
+function add_figure(report::DyndocReport, data, m, ext)
+  chunk = report.cur_chunk
+  full_name, rel_name = get_figname(report, chunk, ext = ext)
+
+  open(full_name, "w") do io
+      if ext == ".pdf"
+          write(io, repr(m, data))
+      else
+          show(io, m, data)
+      end
+  end
+
+  push!(report.figures, rel_name)
+  report.fignum += 1
+  return full_name
+end

data/share/julia/ruby.jl

@@ -1,28 +1,28 @@
 
 
 module Ruby
-
-	librb=Libdl.dlopen(("JULIA_RUBYLIB_PATH" in keys(ENV)) ? ENV["JULIA_RUBYLIB_PATH"] : "libruby")
+	using Libdl
+	librb=Libdl.dlopen(("JULIA_RUBYLIB_PATH" in keys(ENV)) ? ENV["JULIA_RUBYLIB_PATH"] : "/usr/lib/libruby")
 
 	export start,stop,run,alive
 
 	global ruby_alive=false
 
 	function start()
-		ccall(Libdl.dlsym(librb,:ruby_init),Void,())
-		ccall(Libdl.dlsym(librb,:ruby_init_loadpath),Void,())
+		ccall(Libdl.dlsym(librb,:ruby_init),Cvoid,())
+		ccall(Libdl.dlsym(librb,:ruby_init_loadpath),Cvoid,())
 		ruby_alive=true
 	end
 
 	function stop()
-		ccall(Libdl.dlsym(librb,:ruby_finalize),Void,())
+		ccall(Libdl.dlsym(librb,:ruby_finalize),Cvoid,())
 		ruby_alive=false
 	end
 
 	function run(code::AbstractString)
 		state=1 #not modified then
 		##println(code)
-		res=ccall(Libdl.dlsym(librb,:rb_eval_string_protect),Ptr{UInt64},(Ptr{UInt8},Ptr{UInt32}),bytestring(code),&state)
+		res=ccall(Libdl.dlsym(librb,:rb_eval_string_protect),Ptr{UInt64},(Ptr{UInt8},Ref{UInt32}),string(code),state)
 	 	return nothing
 	end
 

metadata

@@ -1,98 +1,63 @@
 --- !ruby/object:Gem::Specification
 name: dyndoc-ruby-core
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.4.2
 platform: ruby
 authors:
 - CQLS
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-20 00:00:00.000000000 Z
+date: 2020-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: configliere
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.4'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.18
 - !ruby/object:Gem::Dependency
   name: ultraviolet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.0
-description: |2
-    Provide templating in text document.
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: "  Provide templating in text document.\n"
 email: rdrouilh@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/dyndoc-core.rb
-- lib/dyndoc/base/envir.rb
-- lib/dyndoc/base/filter/call.rb
-- lib/dyndoc/base/filter/filter_mngr.rb
-- lib/dyndoc/base/filter/server.rb
-- lib/dyndoc/base/filters.rb
-- lib/dyndoc/base/helpers.rb
-- lib/dyndoc/base/helpers/core.rb
-- lib/dyndoc/base/helpers/parser.rb
-- lib/dyndoc/base/scanner.rb
-- lib/dyndoc/base/tags.rb
-- lib/dyndoc/base/tags/keys_mngr.rb
-- lib/dyndoc/base/tags/part_tag.rb
-- lib/dyndoc/base/tags/tag_mngr.rb
-- lib/dyndoc/base/tags/user_tag.rb
-- lib/dyndoc/base/tmpl.rb
-- lib/dyndoc/base/tmpl/eval.rb
-- lib/dyndoc/base/tmpl/extension.rb
-- lib/dyndoc/base/tmpl/manager.rb
-- lib/dyndoc/base/tmpl/oop.rb
-- lib/dyndoc/base/tmpl/parse_do.rb
-- lib/dyndoc/base/tmpl/rbenvir.rb
-- lib/dyndoc/base/utils.rb
-- lib/dyndoc/common/dynArray.rb
-- lib/dyndoc/common/file.rb
-- lib/dyndoc/common/init.rb
-- lib/dyndoc/common/tilt.rb
-- lib/dyndoc/common/utils.rb
-- lib/dyndoc/common/uv.rb
-- lib/dyndoc/init/config.rb
-- lib/dyndoc/init/home.rb
-- lib/dyndoc/plugins/tex.rb
-- lib/dyndoc/plugins/tex/beamer.rb
-- lib/dyndoc/plugins/tex/tex_eval.rb
-- lib/dyndoc/plugins/tex/tex_parse_do.rb
-- lib/dyndoc/plugins/tex/tex_user_tag.rb
+- dyndoc/Dyn/.postload
+- dyndoc/Dyn/.preload
 - dyndoc/Dyn/After.dyn
 - dyndoc/Dyn/Base.dyn
 - dyndoc/Dyn/Minimum.dyn
@@ -130,6 +95,8 @@ files:
 - dyndoc/Style/Text/StdAlias.dyn
 - dyndoc/Style/Text/StdTex.dyn
 - dyndoc/Style/Text/Txt.dyn
+- dyndoc/Tex/.postload
+- dyndoc/Tex/.preload
 - dyndoc/Tex/10pt_tmpl.tex
 - dyndoc/Tex/11pt_tmpl.tex
 - dyndoc/Tex/12pt_tmpl.tex
@@ -178,26 +145,58 @@ files:
 - dyndoc/Tools/Web/TabBar.dyn
 - dyndoc/Tools/Web/Ttm.dyn
 - dyndoc/Tools/Web/Txtl.dyn
-- share/julia/dynArray.jl
-- share/julia/dyndoc.jl
-- share/julia/ruby.jl
+- dyndoc/Tools/julia/Fig.dyn
+- lib/dyndoc-core.rb
+- lib/dyndoc/base/envir.rb
+- lib/dyndoc/base/filter/call.rb
+- lib/dyndoc/base/filter/filter_mngr.rb
+- lib/dyndoc/base/filter/server.rb
+- lib/dyndoc/base/filters.rb
+- lib/dyndoc/base/helpers.rb
+- lib/dyndoc/base/helpers/core.rb
+- lib/dyndoc/base/helpers/parser.rb
+- lib/dyndoc/base/scanner.rb
+- lib/dyndoc/base/tags.rb
+- lib/dyndoc/base/tags/keys_mngr.rb
+- lib/dyndoc/base/tags/part_tag.rb
+- lib/dyndoc/base/tags/tag_mngr.rb
+- lib/dyndoc/base/tags/user_tag.rb
+- lib/dyndoc/base/tmpl.rb
+- lib/dyndoc/base/tmpl/eval.rb
+- lib/dyndoc/base/tmpl/extension.rb
+- lib/dyndoc/base/tmpl/manager.rb
+- lib/dyndoc/base/tmpl/oop.rb
+- lib/dyndoc/base/tmpl/parse_do.rb
+- lib/dyndoc/base/tmpl/rbenvir.rb
+- lib/dyndoc/base/utils.rb
+- lib/dyndoc/common/dynArray.rb
+- lib/dyndoc/common/file.rb
+- lib/dyndoc/common/init.rb
+- lib/dyndoc/common/tilt.rb
+- lib/dyndoc/common/utils.rb
+- lib/dyndoc/common/uv.rb
+- lib/dyndoc/init/config.rb
+- lib/dyndoc/init/home.rb
+- lib/dyndoc/plugins/tex.rb
+- lib/dyndoc/plugins/tex/beamer.rb
+- lib/dyndoc/plugins/tex/tex_eval.rb
+- lib/dyndoc/plugins/tex/tex_parse_do.rb
+- lib/dyndoc/plugins/tex/tex_user_tag.rb
 - share/R/dyndocMsys2.R
 - share/R/dyndocTools.R
 - share/R/test.R
 - share/R/tools/dynArray.R
 - share/R/tools/dynCapture.R
 - share/R/tools/dynMsys2.R
-- dyndoc/.DS_Store
-- dyndoc/Dyn/.postload
-- dyndoc/Dyn/.preload
-- dyndoc/Tex/.postload
-- dyndoc/Tex/.preload
-- dyndoc/Tools/.DS_Store
-- dyndoc/Tools/Web/.DS_Store
+- share/julia/dynArray.jl
+- share/julia/dyndoc.jl
+- share/julia/dyndocOLD.jl
+- share/julia/dynreport.jl
+- share/julia/ruby.jl
 homepage: http://cqls.upmf-grenoble.fr
 licenses:
 - MIT
-- GPL-2
+- GPL-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -205,18 +204,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
 - none
-rubyforge_project: 
-rubygems_version: 2.0.14.1
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: R and Ruby in text document