dyndoc-ruby-core 1.0.0

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

@@ -0,0 +1,337 @@
+module Dyndoc
+
+
+  module Ruby
+
+
+  #this is an attempt to offer an interface for running on a block tree.
+  #usefull for user adding dtag.
+  class BlckMngr
+
+    attr_reader :children, :blck, :tmplMngr, :filter
+
+    def initialize(tmplMngr,blck,tex,filter)
+      @tmplMngr,@blck,@pos=tmplMngr,blck,0
+      @tex,@filter=tex,filter
+      @children=[] #the blocks
+    end
+
+    def parse_child(filter=@filter)
+      @tmplMngr.parse(child,filter)
+    end
+
+    def parse(blck=@blck,filter=@filter)
+      ##Dyndoc.warn "parse!!!",blck
+      res=@tmplMngr.parse(blck,filter)
+      ##Dyndoc.warn "result parse",res
+      res
+    end
+
+    def parse!(blck=@blck,filter=@filter)
+      self << parse(blck,filter)
+    end
+
+    def <<(content)
+      @tex << content
+      return self
+    end
+
+    def pos=(i)
+      @pos=i
+    end
+
+    def pos
+      @pos
+    end
+
+    def length
+      @blck.length
+    end
+
+    def at_end?
+      @pos == @blck.length-1
+    end
+
+    def next_at_end?
+      @pos == @blck.length-2
+    end
+
+    def [](i)
+      @blck[i]
+    end
+
+    def tag
+      @blck[@pos]
+    end
+
+    def next_tag
+      @blck[@pos+1]
+    end
+
+    def next_tag!
+      @blck[@pos+=1]
+    end
+
+    def child(i=-1)
+      @children[i]
+    end
+
+    def next_child_at(pos)
+      b,i=[],pos
+      while (i+1<@blck.length and @blck[i+1].is_a? Array)
+        i+=1
+        b << @blck[i]
+      end
+      return b
+    end
+
+    def next_child
+      b=next_child_at(@pos)
+      @gone=nil
+      return b
+    end
+
+    def goto_next_child!
+      unless @gone
+        @pos+=@children[-1].length
+        @gone=true #only once!
+      end
+    end
+
+    def next_child!
+      @children << next_child
+      goto_next_child!
+      return child
+    end
+
+    def next_child_until(tagset)
+      b,i=[],@pos
+      #p @blck
+      while (i+1<@blck.length and !(tagset.include? @blck[i+1]))
+       i += 1
+       b << @blck[i]
+      end
+      @gone=nil
+      return b
+    end
+
+    def next_child_until!(tagset)
+      @children << next_child_until(tagset)
+      goto_next_child!
+      return child
+    end
+
+    def next_child_while(tagset)
+      b,i=[],@pos
+      while (i+1<@blck.length and (tagset.include? @blck[i+1]))
+       i+=1
+       b << @blck[i]
+      end
+      @gone=nil
+      return b
+    end
+
+    def next_child_while!(tagset)
+      @children << next_child_while(tagset)
+      goto_next_child!
+      return child
+    end
+
+    def child_as_var
+      b=@tmplMngr.make_var_block(child.unshift(:var),@filter)
+      @tmplMngr.eval_VARS(b,@filter)
+    end
+
+  end
+
+  class TemplateManager
+
+    @@newBlcks={}
+
+    def do_newBlck(tex,b,filter)
+      blckMngr=BlckMngr.new(self,b,tex,filter)
+      blckname=b[1][1].strip
+      ##p blckname
+      if ["saved"].include? blckname
+        Dyndoc.warn "Warning: Impossible to redefine an existing instruction!"
+      end
+      #puts "new_blck:b";p b
+      blckMngr.pos=1
+      items=[]
+      return unless [:blck,:aggregate].include? blckMngr.next_tag
+      @@newBlcks[blckname]={}
+      if blckMngr.next_tag==:aggregate
+        blckMngr.next_tag!
+        @@newBlcks[blckname][:aggregate]= blckMngr.next_tag![1].strip.split(",")
+      end
+      while blckMngr.next_tag! == :blck and !blckMngr.at_end?
+        items << (item=blckMngr.next_tag![1].strip)
+        blcks=[]
+        while (blckMngr.next_tag != :blck) and !blckMngr.at_end?
+          blcks << blckMngr.next_tag!
+        end
+        if [":pre",":post"].include? item
+          @@newBlcks[blckname][item]=blcks
+        else
+          i,subBlcks=-1,{}
+          while ([:pre,:post,:do_code].include? blcks[i+1]) and !(i==blcks.length-1)
+
+            subname=blcks[i+=1]
+            subBlcks[subname]=[]
+            while !([:pre,:post,:do_code].include? blcks[i+1]) and !(i==blcks.length-1)
+              subBlcks[subname] << blcks[i+=1]
+            end
+          end
+          @@newBlcks[blckname][item]=subBlcks
+        end
+
+      end
+
+      ## declare the new block!
+      add_dtag({
+      :instr=>[blckname],
+      :keyword_reg=>{
+        blckname.to_sym=> '[%.\w,><?=+:-]+'
+      },
+      :with_tagblck=>[blckname.to_sym],
+      },"blck") #alias of blck!
+#=begin
+      (items-[":pre",":post"]).each do |item|
+        #p @@newBlcks[blckname][item]
+
+        if @@newBlcks[blckname][item][:do_code]
+          blckRbCode=
+%Q[def do_blck_#{blckname}_#{item}(tex,blck,filter)
+##Dyndoc.warn :newBlck, blck
+  blckMngr=BlckMngr.new(self,blck,tex,filter)
+  ## the next code is automatically generated!
+  #{@@newBlcks[blckname][item][:do_code][0][1]}
+end]
+          #Dyndoc.warn :blckRbCode, blckRbCode
+          Dyndoc::Ruby::TemplateManager.module_eval(blckRbCode)
+          #Dyndoc.warn :methods, methods.sort
+        end
+      end
+#=end
+      #p methods.sort
+      #Dyndoc.warn "newBlck[\"#{blckname}\"]",@@newBlcks[blckname]
+    end
+
+    def blckMode_normal?
+      (@@newBlcks.keys & @blckDepth).empty?
+    end
+
+    def aggregate_newBlck(blck,aggrItems,allAggrItems,from)
+      res,newBlck=blck[0...from],nil
+      ##puts "debut aggr";p res;p aggrItems;p allAggrItems
+      resAggr=[] #to save the different elements in the right order
+      (from..(blck.length-1)).each do |i|
+        if newBlck
+          if allAggrItems.include? blck[i]
+            if aggrItems.include? blck[i]
+              resAggr << (newBlck={:tag=>blck[i],:blck=>[:blck]})
+            else
+              newBlck = nil
+              resAggr << blck[i]
+            end
+          else
+            newBlck[:blck] << blck[i]
+          end
+        else
+          if aggrItems.include? blck[i]
+            resAggr << (newBlck={:tag=>blck[i],:blck=>[:blck]})
+          else
+            resAggr << blck[i]
+          end
+        end
+      end
+
+      ## if defaultFmtCotainer defined use it as block starter!
+      start=@defaultFmtContainer ? @defaultFmtContainer : :>
+      ##puts "start";p start
+      #puts "resAggr";p resAggr
+      resAggr.each {|e|
+        if e.is_a? Hash
+          res << e[:tag] << ((e[:blck][1].is_a? Symbol) ? e[:blck] : [:blck,start]+e[:blck][1..-1])
+        else
+          res << e
+        end
+      }
+      ##puts "result";p res
+      res
+
+    end
+
+    def completed_newBlck(cmd,blckname,blck,filter)
+      ### IMPORTANT: blckname==nil means inside sub-blck :blckAnyTag and then no init performed as :pre and :post preprocess!
+      ## As in [#rb>] for (i in 1..3) {#>][#bar]....[#} !!!! No blckname here!
+      if blckname
+        filter.envir["blckname"]=blckname
+      end
+      #Dyndoc.warn "completed_newBlck: blck init",[blckname,blck]
+      i=(blckname ? 2 : 1)
+      ## blckAnyTag behaves like the previous tag in @@newBlcks.keys (all the user-defined commands)
+      cmd=@blckDepth.reverse.find{|e| @@newBlcks.keys.include? e} if cmd=="blckAnyTag"
+      #Dyndoc.warn "extension",[i,cmd,@@newBlcks[cmd],@blckDepth]
+      items=(@@newBlcks[cmd].keys)-[":pre",":post",:aggregate]
+      #Dyndoc.warn "completed:items",items
+      if @@newBlcks[cmd][:aggregate] #and blckname
+        blck=aggregate_newBlck(blck,@@newBlcks[cmd][:aggregate].map{|e| e.to_sym},items.map{|e| e.to_sym},i)
+        ##Dyndoc.warn "aggregate",blck
+      end
+      ## first replace :"," by :"="
+      while blck[i]==:","
+        blck[i]= :"="
+        i+=2
+      end
+      ## prepend the pre code if it exists!
+      ##Dyndoc.warn "blck.length(BEFORE pre)",[blckname,cmd,blck.length,blck]
+      if @@newBlcks[cmd][":pre"] and blckname
+        blck.insert(i,*(@@newBlcks[cmd][":pre"]))
+        i+=@@newBlcks[cmd][":pre"].length
+      end
+      ##Dyndoc.warn "blck.length",[blck.length,blck]
+      while i < blck.length-1
+        item=blck[i].to_s
+        #Dyndoc.warn "item",[cmd,item]
+        if items.include? item
+          if @@newBlcks[cmd][item][:pre]
+            blck.insert(i,*(@@newBlcks[cmd][item][:pre]))
+            i+=@@newBlcks[cmd][item][:pre].length
+          end
+          if @@newBlcks[cmd][item][:do_code] and blck[i+1].respond_to? "[]" and blck[i+1][0]==:named
+            blck.insert(i,blck[i+1])
+            blck.insert(i,:"=")
+            i+=2
+          elsif !@@newBlcks[cmd][item][:do_code]
+            blck[i]=(blck[i+1][0]==:named ? :"=" : :">")
+          end
+          i+=2
+          if @@newBlcks[cmd][item][:post]
+            #puts "post";p blck[i-1];p blck[i];p blck[i+1];p *(@@newBlcks[cmd][item][:post])
+            blck.insert(i,*(@@newBlcks[cmd][item][:post]))
+            i+=@@newBlcks[cmd][item][:post].length
+          end
+        else
+          i+=1
+        end
+        #Dyndoc.warn "completed_newBlck: blck iter",blck
+      end
+      #Dyndoc.warn "completed_newBlck: blck before end",blck
+      ## prepend the pre code if it exists!
+      if @@newBlcks[cmd][":post"] and blckname
+        blck.insert(i+1,*(@@newBlcks[cmd][":post"]))
+        i+=@@newBlcks[cmd][":post"].length
+      end
+      #p blck
+      ## find tag
+      #p @@newBlcks[cmd]
+      #Dyndoc.warn "completed_newBlck: blck end",blck
+      return blck
+    end
+
+  end
+
+  end
+
+end

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

@@ -0,0 +1,450 @@
+# encoding: UTF-8
+
+module Dyndoc
+
+  @@tmpl_mngr=nil
+
+  ##need to point to the current TemplateManager
+  def Dyndoc.tmpl_mngr
+    @@tmpl_mngr
+  end
+
+  def Dyndoc.tmpl_mngr=(tmpl_mngr)
+    @@tmpl_mngr = tmpl_mngr
+  end
+
+  ## Make more readable the creation of newBlck
+  def Dyndoc.cache(cache_={})
+    return Dyndoc.tmpl_mngr.vars[Dyndoc.tmpl_mngr.blckName[-1]] if cache_.empty?
+    Dyndoc.tmpl_mngr.vars[Dyndoc.tmpl_mngr.blckName[-1]]=cache_
+  end
+
+  def Dyndoc.extract_var(id)
+    Dyndoc.tmpl_mngr.vars.extract(id)
+  end
+
+  module Ruby
+
+  class TemplateManager
+
+    attr_accessor :global, :filterGlobal, :filter, :vars, :libs , :tmpl , :blocks, :calls, :args, :envirs, :fmt, :Fmt, :fmtContainer, :fmtOutput, :dyndocMode ,:echo, :filename, :tags, :strip
+    attr_accessor :tmpl_cfg, :cfg_tmpl, :cfg, :doc
+    attr_accessor :rbEnvir, :rbEnvirs,  :rEnvir
+    attr_accessor :rbBlock
+    attr_reader :scan, :blckName
+    ### attr_accessor :mark
+
+    @@interactive=nil
+
+    def TemplateManager.interactive
+      @@interactive=Dyndoc.cfg_dyn[:dyndoc_session]==:interactive unless @@interactive
+      @@interactive
+    end
+
+    # Maybe better located inside server.rb
+    def TemplateManager.initR
+      first=require "R4rb" #save if it the first initialization!
+      Dyndoc.warn "FIRST INIT OF R!!!! => #{first}"
+      Array.initR
+      TemplateManager.interactive
+      #p "client";p Dyndoc.cfg_dyn;p interactive
+      R4rb << "rm(list=ls(all=TRUE))" if !first and !@@interactive #remove all initial variables if previous documents session
+      R4rb << ".dynStack<-new.env()" #used for R variables used by dyndoc
+      RServer.init_envir
+      RServer.init_filter
+      ## ruby and R init for dynArray stuff
+      require "dyndoc/common/dynArray"
+      dyndocToolsR = File.join(Dyndoc.cfg_dir[:gem_path],"share","R","dyndocTools.R").gsub('\\','/')
+      ## WD is introduced by Msys and ConEmuDir by ConEmu
+      dyndocToolsRoot = RUBY_PLATFORM =~ /msys/ ? (ENV['WD'] || ENV['ConEmuDir']).split('\\')[0...-2].join(File::Separator) : ""
+      R4rb << "source('"+dyndocToolsRoot+dyndocToolsR+"',chdir=TRUE)"
+      if RUBY_PLATFORM =~ /msys/
+        dyndocMsys2R = File.join(Dyndoc.cfg_dir[:gem_path],"share","R","dyndocMsys2.R").gsub('\\','/')
+        R4rb << "source('"+dyndocToolsRoot+dyndocMsys2R+"',chdir=TRUE)"
+      end
+      if RUBY_PLATFORM =~ /mingw/
+        require File.join(ENV["DYNDOC_HOME"],"bin","msys2","file_tools.rb")
+      end
+    end
+
+    def TemplateManager.initJulia
+      first=require "jl4rb" #save if it the first initialization!
+      Julia.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")+"\")"
+      #-| 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 << "global const _dynArray=DynArray()"
+      Dyndoc.warn "Julia initialized inside dyndoc!"
+
+    end
+
+    def TemplateManager.attr
+      attr={:cmd => @@cmd,:cmdAlias => @@cmdAlias, :argsSep => @@argsSep, :tags => @@tags,:prefix => @@prefix, :tagSearch => @@tagSearch, :tagModifiers => @@tagModifiers}
+      attr[:tags_tex],attr[:tex_vars] = @@tags_tex,@@tex_vars if TemplateManager.class_variables.include? "@@tag_tex"
+      attr
+    end
+
+    def initialize(tmpl_cfg={},with=true)
+      # just in case it is not yet initialized!
+      (Dyndoc.cfg_dyn[:langs] << :R).uniq! if with==true
+
+#puts "DEBUT INIT TemplateManager"
+      @tmpl_cfg=tmpl_cfg
+=begin
+      @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
+      rbenvir_init(binding)
+      @rEnvir=["Global"]
+      @envirs={}
+      @fmtContainer=[]
+      @echo=1
+      @strip=true
+#puts "FIN INIT TemplateManager"
+      if Dyndoc.cfg_dyn[:devel_mode]==:test
+        puts "DYNDOC SEARCH PATH:"
+        puts Dyndoc.get_pathenv(Dyndoc.cfg_dyn[:root_doc]).join(":")
+      end
+    end
+
+    ## Make more readable the creation of newBlck
+    def cache(cache_={})
+      return @vars[blckName[-1]] if cache_.empty?
+      @vars[blckName[-1]]=cache_
+    end
+
+    def extract_var(id)
+      @vars.extract(id)
+    end
+
+    ## equivalent to :pre_doc for not interactive document
+    def require_first
+      require_dyndoc_libs("Dyn/Base")
+    end
+
+    def require_dyndoc_libs(libs)
+      libs="{#require]\n"+libs.split("\n").map{|lib| lib.split(",")}.flatten.uniq.join("\n")+"\n[#}\n"
+      parse(libs,@filterGlobal)
+    end
+
+    ## to set the current tmpl_mngr as the default one accessed via Dyndoc.tmpl_mngr
+    ## and used in #R> #rb> block
+    def as_default_tmpl_mngr!
+      Dyndoc.tmpl_mngr=self unless Dyndoc.tmpl_mngr == self
+    end
+
+    def init_doc(doc_cfg)
+      @cfg=doc_cfg
+      # register format
+      @fmt=@cfg[:format_doc].to_s.downcase
+      @Fmt=@fmt.capitalize
+      ##Dyndoc.warn "@cfg",@cfg
+      @fmtOutput=@cfg[:format_output].to_s if @cfg[:format_output]
+      @fmtOutput=@fmt if @fmt and ["html","tex","odt","tm"].include? @fmt
+      @dyndocMode=:cmdline
+      @global={}
+      @filterGlobal=FilterManager.global(self) #global filter needed to affect object before parsing the main document!
+      @blocks,@libs,@calls,@args,@meths,@def_blck={},{},{},{},[],[]
+      CallFilter.init(self,@calls,@args,@meths)
+      @filter=nil
+      @tags=[]
+      @keys={}
+      @alias={}
+      @savedBlocks={}
+      require_first if @@interactive
+    end
+
+    def format_output=(format)
+      @fmtOutput=format
+    end
+
+    def dyndoc_mode=(mode)
+      @dyndocMode=mode
+    end
+
+    def reinit
+      @blocks,@libs={},{}
+    end
+
+    ## init output
+    def init_path(input)
+       ##read in the main doc paths to include!
+      Dyndoc.setRootDoc(@cfg[:rootDoc],input.scan(/%%%path\((.*)\)/).flatten.map{|e| e.split(",")}.flatten.map{|e| e.strip.downcase}.join(":"))
+      p @cfg[:rootDoc] if @cfg[:cmd]==:cfg
+    end
+
+    def init_tags(input)
+      ## read the global aliases (config files alias)
+      TagManager.global_alias(@alias) # @alias increased
+      ## read the local aliases (in the main doc)
+      TagManager.local_alias(@alias,input) # @alias increased
+      #init @partTag
+      @tags=TagManager.init_input_tags(([@fmt]+@cfg[:tag_doc]+@tmpl_cfg[:tag_tmpl]).uniq)
+#p @alias
+#
+Dyndoc.warn "init_tags",@tags
+      #To deal later: TagManager.apply_alias(@tags,@alias)
+      p [:init_tags, @tags] if @cfg[:cmd]==:cfg
+    end
+
+    def init_keys
+      @init_keys=KeysManager.init_keys((@cfg[:keys_doc]+@tmpl_cfg[:keys_tmpl]).uniq)
+#puts "Manager:init_keys";p @init_keys
+    end
+
+
+    def init_model(input)
+      @pre_doc,@post_doc,@pre_model,@post_model=[],[],[],[]
+      if @cfg[:model_doc] and Dyndoc.cfg_dir[:tmpl_path][@cfg[:format_doc]]
+        @cfg[:model_doc]="Default" if @cfg[:model_doc].downcase=="default"
+        model_doc=File.join("Model",Dyndoc.cfg_dir[:tmpl_path][ @cfg[:format_doc]],@cfg[:model_doc])
+        @pre_model << File.read(Dyndoc.doc_filename(model_doc+"Pre"))
+        @post_model = [File.read(Dyndoc.doc_filename(model_doc+"Post"))]
+#p @pre_model
+#p @post_model
+      end
+
+      ## sort with respect to priority number and filter
+      @cfg[:pre_doc] += input.scan(/\[\#(?:plugin|preload)\]([^\[]*)/m).flatten.map{|e| e.strip.split("\n").map{|e2| e2.strip}}.flatten
+#p @cfg[:pre_doc]
+      input.gsub!(/\[\#(?:plugin|preload)\][^\[]*/m,"")
+      @cfg[:pre_doc].sort!.map!{|e| e.scan(/^\d*(.*)/)}.flatten!
+      ## sort with respect to priority number and filter
+      @cfg[:post_doc] += input.scan(/\[\#(?:postload)\]([^\[]*)/m).flatten.map{|e| e.strip.split("\n").map{|e2| e2.strip}}.flatten
+      input.gsub!(/\[\#(?:postload)\][^\[]*/m,"")
+      @cfg[:post_doc].sort!.map!{|e| e.scan(/^\d*(.*)/)}.flatten!
+
+#p @cfg[:pre_doc]
+      if @cfg[:pre_doc]
+        @cfg[:pre_doc].uniq.each{|t|
+          @pre_doc << File.read(Dyndoc.doc_filename(t))
+        }
+      end
+#p @pre_doc
+
+      if @cfg[:post_doc]
+        @cfg[:post_doc].uniq.each{|t|
+          @post_doc << File.read(Dyndoc.doc_filename(t))
+        }
+      end
+
+    end
+
+    def output_pre_model
+      #pre_doc
+      out_pre=""
+      unless @pre_model.empty?
+        pre_model=@pre_model.join("\n") + "\n"
+        txt= pre_model
+        out_pre << parse(txt)
+      end
+      unless @pre_doc.empty?
+        pre_doc=@pre_doc.join("\n") + "\n"
+        txt= pre_doc
+        parse(txt,@filterGlobal) ##Style declares objects before compiling the document! Object are created in the global envir!
+      end
+##p [:out_pre,out_pre]
+      return out_pre
+    end
+=begin
+      input = pre_doc.join("\n") + "\n" + input unless pre_doc.empty?
+      input = input + "\n" + post_doc.join("\n") unless post_doc.empty?
+      return input
+=end
+
+    def output_post_model
+     #post_doc
+      out_post=""
+      #puts "output_post_model:post doc";p @post_doc
+      unless @post_doc.empty?
+        post_doc="\n"+@post_doc.join("\n")
+        txt= post_doc
+        parse(txt)
+      end
+      unless @post_model.empty?
+        post_model="\n"+@post_model.join("\n")
+        txt= post_model
+        out_post << parse(txt)
+      end
+#p [:out_post,out_post]
+      return out_post
+    end
+
+
+    ## TO REMOVE????
+    def init_dtag(tmpl)
+      dtag=tmpl.scan(/(?:#{@cfg[:dtags].map{|e| "_#{e}_" }.join("|")})/)[0]
+#p dtag
+      return @dtag=(dtag ? dtag[1...-1].to_sym : @cfg[:dtag])
+    end
+
+    def prepare_output(txt)
+      ## parse the content txt
+      out=output_pre_model
+#p out
+#p Dyndoc.dyn_block[:first]
+      ## dyn_block[:first] called in preloaded libraries!
+      out << parse(Dyndoc.dyn_block[:first]) if Dyndoc.dyn_block[:first]
+#puts "prepare_output";p out
+      out << parse(txt)
+#puts "prepare_output";p out
+      ## dyn_block[:last] (for example, used to record some information)
+      out << parse(Dyndoc.dyn_block[:last]) if Dyndoc.dyn_block[:last]
+      out << output_post_model
+      ## escape=true at the end in order to transform undefined variables in Latex!!!
+##puts "prepare output: BEFORE apply";puts out
+      out=@filter.apply(out,:post,false,true) if [:tex,:odt,:ttm,:html].include? @cfg[:format_doc]
+##p [:prepare_output, out]
+      #escape accolade!
+      Utils.escape!(out,CHARS_SET_LAST)
+##puts "prepare output: AFTER Utils.escape!";puts out
+      out=Utils.unprotect_format_blocktext(out)
+##p [:prepare_output, out]
+      return out
+    end
+
+    ##only once!!! Not like prepare_output which is called in {#dyn]pre:
+    def prepare_last_output(out)
+      #puts "DYNDOC_RAW_TEXT! BEFORE";p out
+      #p Utils.dyndoc_raw_text
+      Utils.dyndoc_raw_text!(out,:clean=>true)
+      #puts "DYNDOC_RAW_TEXT! AFTER";p out
+      return out
+    end
+
+    def clean_as_is(out)
+      out.gsub!(Dyndoc::AS_IS,"")
+    end
+
+    def prepare_user_input
+      ##puts "input";p @cfg[:input];p Dyndoc.cfg_dyn[:user_input]
+      if @cfg[:input]
+        @global["_"]={} unless @global["_"]
+        @cfg[:input].each{|k,v|
+          @global["_"][k.to_s] = {:val=>[v]}
+        }
+      end
+      if Dyndoc.cfg_dyn[:user_input]
+        @global["_"]={} unless @global["_"]
+        Dyndoc.cfg_dyn[:user_input].each{|k,v|
+          @global["_"][k.to_s] = {:val=>[v]}
+        }
+      end
+    end
+
+    ## output the result after parsing txt
+    def output(input,fromfile=nil)
+      @filename=@tmpl_cfg[:filename_tmpl]
+      input=Dyndoc.input_from_file(@filename=input) if fromfile
+      input=@tmpl_cfg[:lib_dyn_content]+"[#main][#>]"+input unless @tmpl_cfg[:lib_dyn_content].empty?
+      ## fetch the contents of all saved variables! This fasten the compilation!
+      Utils.saved_content_fetch_variables_from_file(@filename,self)
+
+#p @filename
+      init_path(input)
+      init_tags(input)
+      init_keys
+      init_model(input)
+#p input
+      ## add the tag document in order to replace the user tag preamble and etc. Introduction of styles because of the odt format and the new convention in general to use styles even in latex.
+      #txt="{#document][#content]"+input+"[#}"
+      txt=input
+#p txt
+      prepare_user_input
+      ## parse the content txt
+      out=prepare_output(txt)
+      prepare_last_output(out)
+      clean_as_is(out)
+##p [:output,out]
+      return out
+    end
+
+=begin
+    ## DONE: put in Document class
+    ## writing in final file
+    def write(file)
+      #@cfg[:append]="" unless @cfg[:append]
+      out = output(file,true)
+#puts out
+      f=File.open(@cfg[:filename_doc],"w")
+      f << out
+      f.close
+    end
+=end
+
+    def query_library(libname)
+      init_doc({:format_doc=>:tex})
+      parse(Dyndoc.input_from_file(libname))
+      p @calls.keys.sort
+      p @meths.sort
+    end
+
+  end
+
+  end
+end
+
+# String helpers ######################
+
+class String
+
+  def to_keys
+    Dyndoc::Envir.to_keys(self)
+  end
+
+  def to_dyn
+    if Dyndoc.tmpl_mngr
+      return Dyndoc.tmpl_mngr.parse_string(self)
+    else
+      return self
+    end
+  end
+
+  def to_var
+    if Dyndoc.tmpl_mngr and (res=Dyndoc.tmpl_mngr.vars.extract(self))
+      res
+    else
+      self
+    end
+  end
+
+  def to_var=(val)
+    if Dyndoc.tmpl_mngr
+      Dyndoc.tmpl_mngr.vars[self]=val
+    end
+  end
+
+end
+
+# Symbol helpers ##################################
+
+class Symbol
+
+  def to_keys
+    to_s.to_keys
+  end
+
+  def to_var
+    if Dyndoc.tmpl_mngr and (res=Dyndoc.tmpl_mngr.vars.extract(self.to_s))
+      res
+    else
+      self
+    end
+  end
+
+  def to_var=(val)
+    if Dyndoc.tmpl_mngr
+      Dyndoc.tmpl_mngr.vars[self.to_s]=val
+    end
+  end
+
+end