dyndoc-ruby-core 1.2.5 → 1.4.8

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