dyndoc-ruby-core 1.2.6 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 959ac04a47a0a747a74d9fc9412693de2f16e3bb
-  data.tar.gz: 1656c0ea29f80098f637aaf16b66774728e6d59a
+SHA256:
+  metadata.gz: b302bae638dbe8908415fc844db0b81321c5cbbd3b07307d84d13c6ece678a6c
+  data.tar.gz: f72741abff2e5aee2568dbef254fa683eb3edd352838b10cc185bbd242dcdb2f
 SHA512:
-  metadata.gz: 92513ff73b9d2028e87848b27b8b8a9124d1a0c80e1c36574d3caf3cb9b1da7e942c8d6c549d8ee0bb972a1bbabcbb82bbc268fa10f4d78a56b3052789a61e83
-  data.tar.gz: 2e0f677656d6b279cc85d4b7eda91740ee774b25702f01070e7b435fca73fe4df12993195a474600b6b050ba5df037f405b40b0093ae6be1e8295b3a209aeaa1
+  metadata.gz: 45a49451d506304d9ff93149507eb7da54122923d62b2fcd6af9fa7604c341f1c95eeac9521c18f4e123ac67df2d65b6c3850898942ac6d3989d9f7b42b109ea
+  data.tar.gz: ea013b177b66156fe1fc9c262e9d8d812db0e71987b696d022a0f485a78ec3bbfe23ba9f1c4d5b5e153e4e881bf2f2839ba8d842de2a5abd965b76d145f9310e

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 => ""
 
@@ -61,7 +63,7 @@ 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-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 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,:"=",:"-",:+,:"%",:"tex=",:"tex+",:"md=",:"md+",:"adoc=",:"adoc+",:"html=",:"html+",:"rb=",:"rb+",:"R=",:"R+",:"jl=",:"jl+",:"txtl=",:"txtl+"]
+    @@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=>{

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

@@ -89,16 +89,17 @@ module Dyndoc
       # 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 << "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 << "include(\""+File.join(Dyndoc.cfg_dir[:gem_path],"share","julia","dynArray.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 << "using Main.Dyndoc"
       Dyndoc.logger.info "initJulia: using Dyndoc"
-      Julia << "Ruby.alive(true)"
+      Julia << "Dyndoc.Ruby.alive(true)"
       #Julia << "global const _dynArray=DynArray()"
       Dyndoc.logger.info "Julia initialized inside dyndoc!"
 
@@ -120,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

@@ -29,7 +29,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)
@@ -482,7 +482,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,7 +498,7 @@ 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
@@ -1056,7 +1056,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)
@@ -2138,6 +2138,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
@@ -2161,7 +2162,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
@@ -2171,6 +2172,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/share/julia/dynArray.jl

@@ -1,9 +1,12 @@
-# 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
 
@@ -11,11 +14,11 @@ export DynVector,DynArray,getindex,setindex!,show,Vector,sync,getkey
 # when change on the vector occurs
 
 
-type DynVector
+mutable struct DynVector
 	ary::Vector
 	key::String
 
-	DynVector(a::Vector,k::String)=(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)
@@ -31,13 +34,12 @@ function setindex!(dynvect::DynVector,value,i::Integer)
 	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
 

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,7 +1,7 @@
 
 
 module Ruby
-
+	using Libdl
 	librb=Libdl.dlopen(("JULIA_RUBYLIB_PATH" in keys(ENV)) ? ENV["JULIA_RUBYLIB_PATH"] : "/usr/lib/libruby")
 
 	export start,stop,run,alive
@@ -9,20 +9,20 @@ module Ruby
 	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}),string(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.6
+  version: 1.4.1
 platform: ruby
 authors:
 - CQLS
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-11 00:00:00.000000000 Z
+date: 2019-11-08 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,23 +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/Dyn/.postload
-- dyndoc/Dyn/.preload
-- dyndoc/Tex/.postload
-- dyndoc/Tex/.preload
+- 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: []
@@ -202,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