dyndoc-ruby-core 1.2.6 → 1.5.0

data/lib/dyndoc/base/utils.rb

@@ -119,7 +119,7 @@ module Dyndoc
     end
 
     def Utils.protect_extraction(str)
-      str.gsub(/(?:\#|\#\#|@|#F|#R|#r|\:R|\:r|#Rb|#rb|\:|\:Rb|\:rb)+\{/) {|e| "\\"+e}
+      str.gsub(/(?:\#|\:dyn|\#\#|@|#F|#R|#r|\:R|\:r|#Rb|#rb|\:|\:Rb|\:rb)+\{/) {|e| "\\"+e}
     end
 
     ## the scanner converts automatically  {#toto#} in {#toto][#} and   {@toto@} in {@toto][#}

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