dyndoc-ruby-core 1.0.0

data/lib/dyndoc/init/home.rb

@@ -0,0 +1,9 @@
+module Dyndoc
+	def Dyndoc.home
+		dyndoc_home = File.join(ENV['HOME'],'dyndoc')
+		dyndoc_home =  File.read(File.join(ENV['HOME'],'.dyndoc_home')).strip if File.exists? File.join(ENV['HOME'],'.dyndoc_home')
+		dyndoc_home = File.expand_path(dyndoc_home)
+		#puts "dyndoc_home: "+ dyndoc_home
+		dyndoc_home
+	end
+end

data/lib/dyndoc/plugins/tex.rb

@@ -0,0 +1,4 @@
+require "dyndoc/plugins/tex/tex_eval"
+require "dyndoc/plugins/tex/tex_parse_do"
+#require "dyndoc/plugins/tex/beamer"
+#require "dyndoc/plugins/tex/tex_user_tag"

data/lib/dyndoc/plugins/tex/beamer.rb

@@ -0,0 +1,208 @@
+def When(actor,dec)
+  from=CqlsBeamer::Actor[actor.to_s]
+  from=( from ? from.when : eval(actor.to_s) ).to_i
+  dec.gsub(/(\d*)/){|e| (e.to_i+from-1).to_s unless e.empty?}
+end
+
+module CqlsBeamer
+
+  def CqlsBeamer.defCpt
+    @@defCpt
+  end
+
+  def CqlsBeamer.defCpt=(val)
+    @@defCpt=val
+  end
+
+  def CqlsBeamer.when(quand,scene=CqlsBeamer::Scene.current)
+    from,from2=quand.split(":")
+    from=nil unless from2
+    #puts "quand";p quand
+    if from
+      from,quand=( (from.empty? and scene) ? scene.cpt[0] : CqlsBeamer::Actor[from].when),from2 
+      quand=quand.gsub!(/[0-9]+/){|e| e.to_i+from-1}
+    end
+    quand
+  end
+
+  def CqlsBeamer.where(where,scene=nil)
+    #Dyndoc.warn "xy",where
+    from,ou=where.split(":")
+    ou,from=from,ou unless ou
+    if from
+      from,scene=from.split("$") unless scene
+      from,scene=scene,from unless scene
+    end
+    ou.gsub!(/\([^\(]*\)/){|elt| eval(elt) }
+    if from
+      fromKey=from.strip
+      actorFrom=CqlsBeamer::Actor[fromKey]
+      from=eval("["+actorFrom.where+"]")
+      #puts "xy";p ou
+      ou ="0.0,0.0" if !ou #and ou.empty?
+      if actorFrom.isR
+        # R4rb.eval("ou<-xyPercent(c("+ou+"),'#{fromKey}')")   
+        # ou=[] < :ou
+        # Replacement of previous 2 lines failing now!
+        ou = "xyPercent(c("+ou+"),'#{fromKey}')"
+        ou = ou.to_R
+        zoom=actorFrom.isR.dup
+        dim=CqlsBeamer::Scene[scene].dim
+        ou[0] /= dim[2].to_f
+        ou[1] /= dim[3].to_f
+      else
+        ou=eval("["+ou+"]")
+      end
+      ou="#{from[0]+ou[0]*zoom[0]},#{from[1]+ou[1]*zoom[1]}"
+    end
+#puts "last in xy";p ou
+    ou
+  end
+
+  class Scene
+    attr_accessor :name, :scene, :dim, :txt, :unit, :fg, :bg, :rounded, :framed, :cpt
+    #default values for actors in its scene
+    attr_accessor :minipage, :align
+  
+    @@scenes={}
+    @@curScene=nil
+
+    def Scene.[]=(key,val)
+      @@scenes[key]=val
+    end
+
+    def Scene.[](key)
+      @@scenes[key]
+    end
+
+    def Scene.current
+      @@curScene
+    end
+
+    def initialize(name,dim)
+      @name=name
+      @scene=Group.new
+      @unit="cm"
+      @dim=dim.map{|e| e.to_s}
+      @txt=""
+      #default values
+      @align="left,top"
+      @minipage=""
+      Scene[name]=self
+      @@curScene=self
+    end
+
+    def init
+      @scene.init
+      @txt=""
+      @cpt[0]=1
+    end
+
+    def append(obj)
+      @@curScene=self
+      @scene.append(obj)
+    end
+
+    alias << append
+
+    def first
+      txt=""
+      txt += "\\setbeamercolor{#{@name}color}{fg=#{fg},bg=#{@bg}}\n\\begin{beamercolorbox}[wd=#{dim[2]+@unit},ht=#{dim[3]+@unit},rounded=#{@rounded}]{#{@name}color}" if @framed
+      txt+="\\pgfsetxvec{\\pgfpoint{#{dim[2]+@unit}}{0cm}}\n\\pgfsetyvec{\\pgfpoint{0cm}{#{dim[3]+@unit}}}\n\\begin{pgfpicture}{#{dim[0]+@unit}}{#{dim[1]+@unit}}{#{dim[2]+@unit}}{#{dim[3]+@unit}}\n"
+      return txt
+    end
+
+    def last
+      txt="\\end{pgfpicture}\n"
+      txt += "\\end{beamercolorbox}" if @framed
+      return txt
+    end
+
+    def output
+      @scene.output(@txt)
+      return @txt
+    end
+    
+  end
+
+  class Actor
+    attr_accessor :what, :when, :where, :align, :mode, :minipage, :isR, :isRaw
+    @@actors={}
+
+    def Actor.[]=(key,val)
+      @@actors[key]=val
+    end
+
+    def Actor.[](key)
+      @@actors[key]
+    end
+    
+    def initialize(qui,quoi,quand,ou,align="left,top",mode=:only) #align=(left-center-right,bottom-base-center-top)
+      quoi=quoi.join("\n") if quoi.is_a? Array
+      @what,@when,@where,@align,@mode=quoi,quand,ou,align,mode
+      @minipage=""
+      Actor[qui]=self
+    end
+
+    def output(txt,local={})
+      local[:where]=@where unless local[:where]
+      local[:when]=@when unless local[:when]
+      local[:align]=@align unless local[:align]
+      local[:what]=@what unless local[:what]
+      local[:mode]=@mode unless local[:mode]
+      local[:minipage]=@minipage unless local[:minipage]
+      #Dyndoc.warn  :outputInRuby, local[:what]
+      local[:what]='\begin{minipage}{'+local[:minipage]+'}'+local[:what]+'\end{minipage}' unless local[:minipage].empty?
+      #Dyndoc.warn  :outputInRuby2, local[:what]
+      if @isRaw or !local[:where]
+        txt << "\\#{local[:mode]}<#{local[:when]}>{\n #{local[:what]}}\n"
+      else
+        txt << "\\#{local[:mode]}<#{local[:when]}>{\n\\pgfputat{\\pgfxy(#{local[:where]})}{\\pgfbox[#{local[:align]}]{#{local[:what]}}}}\n"
+      end
+    end
+    
+  end
+
+  class Group
+    attr_accessor :list
+    
+    def initialize
+      @list=[]
+    end
+
+    def init
+      @list=[]
+    end
+
+    def append(actor)
+      @list << ( (actor.is_a? Array) ? [Actor[actor[0]],actor[1]] : Actor[actor] )
+    end
+
+    alias << append
+
+    def insert(actor,i=-1)
+      if i<0
+        append(actor)
+      else
+        @list=@list[0...i]+Actor[actor]+@list[i..-1]
+      end
+    end
+
+    def move_last(actor)
+      elt=@list.delete( (actor.is_a? String) ? Actor[actor] : actor)
+      @list << elt if elt
+    end
+
+    def output(txt)
+      @list.each{|e|
+        if e.is_a? Array
+          e[0].output(txt,e[1])
+        else
+          e.output(txt)
+        end
+      }
+    end
+    
+  end
+
+end

data/lib/dyndoc/plugins/tex/tex_eval.rb

@@ -0,0 +1,69 @@
+
+BEGINVERB="\\begin{Verbatim}[frame=leftline,fontfamily=tt,fontshape=n,numbers=left]"
+ENDVERB="\\end{Verbatim}"
+
+module Dyndoc
+
+  @@mode=:tex
+
+  module Ruby
+  class TemplateManager
+    
+    def echo_verb(txt,verbatim=true,env="Global")
+      txtout=Dyndoc::RServer.echo(txt,env)
+      header= verbatim and txtout.length>0
+      out=""
+      out << BEGINVERB << "\n" if header
+      out << txtout
+      out << ENDVERB << "\n" if header
+      out
+    end
+
+    def make_outR(tex,b,i,splitter,filter,header=true)
+      normal= splitter.key[i].nil?
+      if !normal
+        filename=filter.apply(splitter.key[i]).strip 
+        normal =  ["#","%"].include? filename[0,1]
+      end
+      if normal
+        txt=filter.apply(b[1...-1].map{|l| l.strip}.join("\n"))
+        txt=echo_verb(txt,header)
+      else    
+        filename=File.expand_path(filename)
+        if (!File.exists?(filename))
+          require 'fileutils'
+          tmp=File.dirname(filename)
+          FileUtils.mkdir_p(tmp) unless File.exists? tmp
+          f=File.open(filename,"w")
+          txt=filter.apply(b[1...-1].join("\n"))
+          txt=echo_verb(txt,header)
+          f << txt
+          f.close
+        else 
+          txt=File.read(filename)
+        end 
+      end
+      tex << "%%" << b[0] << "\n" if @echo>0
+      tex << txt unless @echo<0
+      tex << "%%" << b[-1] << "\n" if @echo>0  
+    end
+
+    def eval_TEX_TITLE(filter)
+      ## _BEGINDOC_ already declared in DefaultPre_tmpl.tex
+      if  filter.envir.global["_BEGINDOC_"] and filter.envir.global["_BEGINDOC_"][:val][0].scan(/\\maketitle/).empty?
+        filter.envir.global["_BEGINDOC_"][:val][0] << "\n" unless filter.envir.global["_BEGINDOC_"][:val][0].empty?
+        filter.envir.global["_BEGINDOC_"][:val][0] << "\\maketitle"
+      end
+    end
+
+    def append_to_begin_document(filter,content)
+      ## _BEGINDOC_ already declared in DefaultPre_tmpl.tex
+      if  filter.envir.global["_BEGINDOC_"]
+        filter.envir.global["_BEGINDOC_"][:val][0] << "\n" unless filter.envir.global["_BEGINDOC_"][:val][0].empty?
+        filter.envir.global["_BEGINDOC_"][:val][0] << content
+      end
+    end
+
+  end
+  end
+end

data/lib/dyndoc/plugins/tex/tex_parse_do.rb

@@ -0,0 +1,25 @@
+ 
+module Dyndoc
+  module Ruby
+  class TemplateManager
+    
+    @@cmd=["title",""]+@@cmd
+
+    def do_title(tex,blck,filter)
+=begin
+      mode=""
+      mode=filter.apply(splitter.key[i].strip).downcase if splitter.key[i]
+      ## apply R filtering
+      txt=filter.apply(b[1...-1].join("\n"))
+      ## _TITLE_ is redefined!
+      eval_TITLE(txt,filter,mode)
+=end
+    end
+
+    def do_list(tex,blck,filter)
+
+    end
+    
+  end
+  end
+end

data/lib/dyndoc/plugins/tex/tex_user_tag.rb

@@ -0,0 +1,32 @@
+ 
+module Dyndoc
+ 
+  class UserTag
+
+    @@tags_tex=["rtex","rverb","title","preamble","usepackage","postamble","begindoc","enddoc"]
+    ## update @@tags
+    @@tags += @@tags_tex
+    @@tex_vars={"usepackage"=>"_USEPACKAGE_","preamble"=>"_PREAMBLE_","postamble"=>"_POSTAMBLE_","begindoc"=>"_BEGINDOC_","enddoc"=>"_ENDDOC_"}
+
+
+    def parseUserTexTags(tex,code,filter)
+      case @type
+      when "rverb","rtex"
+        @out_type="#r"
+        header= @type=="rverb"
+        tex << @tmpl.echo_verb(filter.apply(code.strip),header).lstrip
+      when "title"
+        mode= (@modifier=="!" ? "" : "+")
+        @tmpl.eval_TITLE(filter.apply(code.strip),filter,mode)
+      when "preamble","usepackage","postamble","begindoc","enddoc"
+        mode= "+"
+        if @modifier=="!"
+          mode = ""
+        end 
+        @tmpl.eval_TEXVAR(@@tex_vars[@type],filter.apply(code.strip),filter,mode)
+      end
+    end
+    
+  end
+
+end

data/share/R/dyndocMsys2.R

@@ -0,0 +1,5 @@
+.dyndocMsys2 <- new.env()
+
+source("tools/dynMsys2.R",local=.dyndocMsys2)
+
+attach(.dyndocMsys2,name="dyndoc:msys2",pos=length(search())-1)

data/share/R/dyndocTools.R

@@ -0,0 +1,9 @@
+require(rb4R)
+
+
+.dyndocEnvir <- new.env()
+
+source("tools/dynArray.R",local=.dyndocEnvir)
+source("tools/dynCapture.R",local=.dyndocEnvir)
+
+attach(.dyndocEnvir,name="dyndoc:tools")

data/share/R/test.R

@@ -0,0 +1,14 @@
+toto <-list(vars=list())
+class(toto)<-'TOTO'
+"[[<-.TOTO" <- function(obj,key,value) {
+	obj$vars[[key]] <- value
+	cat("inside []<-\n")
+	obj
+}
+
+"[[.TOTO" <- function(obj,key) {
+	cat("inside []\n")
+	obj$vars[[key]]
+}
+
+toto[["titi"]] <- "TUTU"

data/share/R/tools/dynArray.R

@@ -0,0 +1,34 @@
+# stuff specific to dyndoc
+## Not supposed to be used by the user
+
+require(rb4R)
+
+init.dynArray <- function() {
+  local({
+    # envir and not list to immediate sync in  "[[<-.dynArray"
+		Dyndoc.Vec<-list(vars=new.env())
+		class(Dyndoc.Vec)<-"dynArray"
+	},globalenv())
+}
+
+#<- "[.dynArray" <- "$.dynArray" 
+"[.dynArray"  <- function(obj,key) {
+  if(inherits(key,"formula")) key<-as.character(key)[[2]]
+  .rb(paste("Dyndoc::Vector[\"",key,"\"].sync(:r)",sep=""))
+  obj$vars[[key]]
+}
+
+# <- "[<-.dynArray" <- "$<-.dynArray" 
+"[<-.dynArray" <-function(obj,key,value) {
+  if(inherits(key,"formula")) key<-as.character(key)[[2]]
+  obj$vars[[key]] <- value
+  #if(sync) { # Easily convertible to Julia!  
+    # Clever: no need to convert ruby object in R object (done in the ruby part!)
+    ##cat("sync",key,"\n")
+    .rb(paste("Dyndoc::Vector[\"",key,"\"].sync(:r)",sep=""))
+    #cat("sync",key,"\n")
+  #}
+  obj   
+}
+
+init.dynArray()

data/share/R/tools/dynCapture.R

@@ -0,0 +1,84 @@
+
+capture.output.cqls<-function(code) {
+	res2<-try.cqls(res<-capture.output(code),TRUE)
+	if(inherits(res2,"try-error")) {
+	  res2
+	} else res
+}
+
+capture.output.protected<-function(code) {
+	res2<-try(res<-capture.output(code),TRUE)
+	if(inherits(res2,"try-error")) {
+	  res2
+	} else res
+}
+
+try.cqls<-function (expr, silent = FALSE)
+{
+    tryCatch(expr, error = function(e) {
+        call <- conditionCall(e)
+        if (!is.null(call)) {
+            if (identical(call[[1]], quote(doTryCatch)))
+                call <- sys.call(-4)
+            dcall <- deparse(call)[1]
+	    if( (substr(dcall,1,7)=="try.cqls(") || dcall=="eval.with.vis(expr, pf, baseenv())" || dcall=="eval(expr, envir, enclos)" ) prefix <- 
+"Erreur : "
+            else prefix <- paste("Erreur dans", dcall, ": ")
+            LONG <- 75
+            msg <- conditionMessage(e)
+            sm <- strsplit(msg, "\n")[[1]]
+            if (14 + nchar(dcall, type = "w") + nchar(sm[1],
+                type = "w") > LONG)
+                prefix <- paste(prefix, "\n  ", sep = "")
+        }
+        else prefix <- "Erreur : "
+        msg <- paste(prefix, conditionMessage(e), "\n", sep = "")
+        .Internal(seterrmessage(msg[1]))
+        if (!silent && identical(getOption("show.error.messages"),
+            TRUE)) {
+            cat(msg, file = stderr())
+            .Internal(printDeferredWarnings())
+        }
+        invisible(structure(msg, class = "try-error"))
+    })
+}
+
+init.filter.capture<-function(in.filter,out.filter) {
+        if(!missing(in.filter)) .filter.capture[[1]]<<-in.filter
+        if(!missing(out.filter)) .filter.capture[[2]]<<-out.filter
+        #print(.filter.capture)
+        return(invisible())
+}
+
+filter.capture.output<-function (...,filter=.filter.capture) {
+        args <- substitute(list(...))[-1]
+        file <- textConnection("res.val","w",local=TRUE)
+        sink(file)
+        pf <- parent.frame()
+        evalVis <- function(expr) .Internal(eval.with.vis(expr, pf, baseenv()))
+        expr <- args[[1]]
+        if (mode(expr) == "expression")
+          tmp <- lapply(expr, evalVis)
+        else if (mode(expr) == "call")
+          tmp <- list(evalVis(expr))
+        else if (mode(expr) == "name")
+          tmp <- list(evalVis(expr))
+        else stop("bad argument")
+        for (item in tmp) {if(item$visible)  res<-item$value}
+        print(res)
+        sink()
+        close(file)
+        if(!is.null(filter[[1]])) {
+          res.in<-if(is.function(filter[[1]])) sapply(res,filter[[1]]) else filter[[1]]
+          tmp<-strsplit(paste(res.val,collapse=" [LiNe]")," ")[[1]]
+          tmp2<-(regexpr('^\\[.*\\]$',tmp)!=1 & tmp!="" )
+          new<-tmp[tmp2]
+          new[res.in]<-sapply(new[res.in],filter[[2]])
+          tmp[tmp2]<-new
+          return(paste(strsplit(paste(tmp,collapse=" "), " \\[LiNe\\]" )[[1]],collapse="\n"))
+        } else return(res.val)
+}
+
+local({
+    if(!exists(".filter.capture")) .filter.capture <-list(NULL,function(x) paste("\\textcolor{blue}{",x,"}",sep=""))
+},.GlobalEnv)