mdextab 0.1.0 → 0.1.3

data/bin/makemdtab

@@ -1,304 +1,67 @@
 #!/usr/bin/env ruby
-# -*- coding: utf-8 -*-
 
-require 'bundler/setup'
-require 'mdextab'
-require 'digest'
+require "bundler/setup"
+require "mdextab"
+require "messagex"
 
-require 'simpleoptparse'
-require 'byebug'
+require "simpleoptparse"
 
-EXIT_CODE_NORMAL_EXIT=0
-EXIT_CODE_CANNOT_FILE_FILE=101
-EXIT_CODE_CANNOT_WRITE_FILE=102
-EXIT_CODE_ARGV_SIZE=103
-EXIT_CODE_MISSING_REQUIRED_ARGUMENT=104
-EXIT_CODE_CANNOTFIND_YAMLFILE_OR_EMPTY=105
-EXIT_CODE_YAMLFILE_IS_EMPTY=106
-EXIT_CODE_CANNOTFIND_ERUBYFILE_OR_EMPTY=107
-EXIT_CODE_ERUBYFILE_IS_EMPTY=108
-EXIT_CODE_CANNOTFIND_MDFILE_OR_EMPTY=109
-EXIT_CODE_MDFILE_IS_EMPTY=110
-
-class Makemdtab
-  def initialize(opts, erubyfnames)
-    @dataop=opts["dataop"]
-    @datayamlfname=opts["data"]
-    @yamlop=opts["yamlop"]
-    @yamlfname=opts["setting"]
-    @auxyamlfname=opts["auxsetting"]
-    @erubyfnames=erubyfnames
-    @outputfname=opts["output"]
-
-    @exit_cannot_find_file=1
-    @exit_cannot_write_file=2
-
-    @erubies = {}
-
-    @logger=Logger.new(STDOUT)
-    @logger.level = Logger::INFO
-    @logger.level = Logger::DEBUG if opts["debug"]
-    @logger.formatter = proc do |severity, datetime, progname, msg|
-      "#{msg}\n"
-    end
-
-    [@datayamlfname, @yamlfname, @auxyamlfname, @erubyfnames].flatten.each do |fname|
-      next if File.exist?(fname)
-
-      mes="Can't find #{fname}"
-      outputError(mes)
-      exit(EXIT_CODE_CANNOT_FILE_FILE)
-    end
-
-    begin
-      @output = File.open(@outputfname, 'w')
-    rescue RuntimeError => ex
-      mes2 = "Can't write #{@outputfname}"
-      outputError(mes2)
-      exit(EXIT_CODE_CANNOT_WRITE_FILE)
-    end
-  end
-
-  def outputError(mes)
-    if @logger
-      @logger.error(mes)
-    else
-      STDERR.puts(mes)
-    end
-  end
-
-  def makeMd()
-    load(@dataop, @datayamlfname, @yamlop, @auxyamlfname, @yamlfname, @erubyfnames).map{|x| 
-      @output.puts(x)
-    }
-  end
-
-  def load(dataop, datayamlfname, yamlop, auxyamlfname, yamlfname, erubyfnames)
-    eruby0 = nil
-    eruby1 = nil
-    obj = {}
-    obj0 = YAML.load_file(auxyamlfname) if auxyamlfname
-    obj = obj0 if obj0
-
-    case yamlop
-    when :MERGE
-      obj2 = YAML.load_file(yamlfname)
-      if obj2
-        if obj
-          objx = obj.merge(obj2) 
-        else
-          objx = obj2
-        end
-      else
-        objx = obj
-      end
-    when :REPLACE
-      str = File.read(yamlfname)
-      str2 = Erubis::Eruby.new(str).result(obj)
-      objx0 = YAML.load(str2)
-      if objx0
-        objx = objx
-      else
-        objx = {}
-      end
-    else
-      # do nothing
-    end
-
-    erubystr=erubyfnames.map{|x| checkAndLoadErubyfile(x)}.join("\n")
-    if @dataop == :PATTERN_FOUR
-      mdfname=datayamlfname
-      objx["PARENT_DIR"] = ENV['MDEXTAB_MAKE']
-
-      mdstr=checkAndLoadMdfile(mdfname)
-
-      dx = [erubystr, mdstr].join("\n")
-      @erubies[mdfname] ||= Erubis::Eruby.new(dx)
-      array=[@erubies[mdfname].result(objx)]
-    else
-      puts "datayamlfname=#{datayamlfname}"
-      strdata2=checkAndExpandYamlfile(datayamlfname, objx) 
-      data = YAML.load(strdata2)
-if data.class != Hash
-  puts "strdata2=#{strdata2}"
-  p data
-  exit(300)
+opts = {}
+banner = "Usage: bundle exec ruby bin/makemdtab [--debug|--verbose] (-o|--output) outfname (-d|--data) datafname  yamlfname --dataop (fileinclude|yamltomd) -es erubystatic -ev erubyvariable *]"
+if ARGV.empty?
+  puts(banner)
+  exit(@mes.ec("EXIT_CODE_ARGV"))
 end
-      erubyfname=erubyfnames.last
-      case dataop
-      when :PATTERN_ONE
-        array=loadWithPattern1(data, erubyfname, erubystr)
-      when :PATTERN_TWO
-        array=loadWithPattern2(data, erubyfname, erubystr)
-      when :PATTERN_THREE
-        dir=File.dirname(datayamlfname)
-        array=loadWithPattern3(data, erubyfname, erubystr, dir)
-      else
-        array=[]
-        # do nothing
-      end
-    end
-    array
-  end
 
-  def checkAndLoadErubyfile(erubyfname)
-    size=File.size?(erubyfname)
-    if size and size > 0
-      erubystr=File.read(erubyfname)
+Simpleoptparse::Simpleoptparse.parse(ARGV, opts, banner, Mdextab::VERSION, nil) do |parser|
+  parser.on("--debug") {|_x| opts["debug"] = true }
+  parser.on("--verbose") {|_x| opts["verbose"] = true }
+  parser.on("--es path") {|x| opts["fnameStatic"] = x }
+  parser.on("--ev path") {|x| opts["fnameVariable"] = x }
+  parser.on("-t path", "--template") {|x| opts["template"] = opts["t"] = x }
+  parser.on("-y path", "--yaml") {|x| opts["yaml"] = opts["y"] = x }
+  parser.on("-o path", "--output") {|x| opts["output"] = opts["o"] = x }
+  parser.on("-d path", "--data") {|x| opts["data"] = opts["d"] = x }
+  parser.on("--dataop op") do |x|
+    if /^f/.match?(x.downcase)
+      opts["dataop"] = :FILE_INCLUDE
     else
-      mes=%Q!Can not find #{erubyfname} or is empty!
-      outputError(mes)
-      exit(EXIT_CODE_CANNOTFIND_ERUBYFILE_OR_EMPTY)
+      opts["dataop"] = :YAML_TO_MD
     end
-    if erubystr.strip.empty?
-      mes=%Q!#{erubyfname} is empty!
-      outputError(mes)
-      exit(EXIT_CODE_ERUBYFILE_IS_EMPTY)
-    end
-    erubystr
-  end
-
-  def checkAndLoadMdfile(mdfname) 
-    size2=File.size?(mdfname)
-    if size2 and size2 > 0
-      mdstr=File.read(mdfname)
-    else
-      mes=%Q!Can not find #{mdfname} or is empty!
-      outputError(mes)
-      exit(EXIT_CODE_CANNOTFIND_MDFILE_OR_EMPTY)
-    end
-    if mdstr.strip.empty?
-      mes=%Q!#{mdfname} is empty!
-      outputError(mes)
-      exit(EXIT_CODE_MDFILE_IS_EMPTY)
-    end
-    mdstr
-  end
-
-  def checkAndExpandYamlfile(yamlfname, objx) 
-    size=File.size?(yamlfname)
-    if size and size > 0
-      puts File.mtime(yamlfname)
-      strdata = File.read(yamlfname)
-    else
-      mes=%Q!Can not find #{yamlfname} or is empty!
-      outputError(mes)
-      exit(EXIT_CODE_CANNOTFIND_YAMLFILE_OR_EMPTY)
-    end
-
-    if strdata.strip.empty?
-      mes=%Q!#{yamlfname} is empty!
-      outputError(mes)
-      exit(EXIT_CODE_YAMLFILE_IS_EMPTY)
-    else
-      puts Digest::MD5.hexdigest(strdata)
-      #
-      strdata2 = Erubis::Eruby.new(strdata).result(objx)
-    end
-
-    strdata2
-  end
- 
-  def loadWithPattern1(data, erubyfname, erubystr)
-    @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
-    [@erubies[erubyfname].result(data)]
-  end
-
-  def loadWithPattern2(data, erubyfname, erubystr)
-    data.map{ |x|
-      @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
-      @erubies[erubyfname].result(x)
-    }
-  end
-
-  def loadWithPattern3(data, erubyfname, erubystr, dir)
-    hs={}
-    data.each do |k,v|
-      if /items/.match(k)
-        hs[k]=[]
-        v.each do |v2|
-          if /^path=(.*)/.match(v2)
-            hs[k] << File.join(dir, $1)
-          else
-            hs[k] << v2
-          end
-        end
-      else
-        hs[k]=v
-      end
-    end
-    @erubies[erubyfname] ||= Erubis::Eruby.new(erubystr)
-    [@erubies[erubyfname].result(hs)]
   end
+end
 
-  def postProcess
-    @output.close if @output
-    @output = nil
-  end
+if opts["debug"]
+  mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0, :debug)
+elsif opts["verbose"]
+  mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0, :verbose)
+else
+  mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0)
 end
 
-opts = {}
-banner = "Usage: bundle exec ruby bin/makemdtab [--contest] [--debug] -o outfname -d datafname --y merge|replace -p pattern_one|pattern_two|pattern_three -s yamlfname [-a auxyamlfname] erubyfname [erubyfname2 *]"
-if ARGV.size == 0
+unless opts["data"]
+  puts("Not specified -data")
   puts(banner)
-  exit(EXIT_CODE_ARGV_SIZE)
+  exit(mes.ec("EXIT_CODE_ARGV_ERROR"))
 end
 
-Simpleoptparse::Simpleoptparse.parse(ARGV , opts , banner , Mdextab::VERSION , nil){ |parser|
-  parser.on('--debug'  ) {|x| opts["debug"] = true}
-  parser.on('--contest'  ) {|x| opts["kind"] = :contest}
-  parser.on('-d value', '--data' ,'data file') {|x| opts["data"] = x}
-  parser.on('-s value', '--setting') {|x| opts["setting"] = x}
-  parser.on('-a [value]', '--auxsetting') {|x| opts["auxsetting"] = x}
-  parser.on('-o value', '--output') {|x| opts["output"] = x}
-  parser.on('-y value', '--yamlop') {|x| 
-                                         case x.upcase
-                                         when /^MERGE/
-                                         opts["yamlop"] = :MERGE
-                                         when /^REPLACE/
-                                         opts["yamlop"] = :REPLACE
-                                         else
-                                           # do nothing
-                                         end
-                                       }
-  parser.on('-p value', '--dataop') {|x| 
-                                         case x.upcase
-                                         when /^PATTERN_ONE/
-                                           opts["dataop"] = :PATTERN_ONE
-                                         when /^PATTERN_TWO/
-                                           opts["dataop"] = :PATTERN_TWO
-                                         when /^PATTERN_THREE/
-                                           opts["dataop"] = :PATTERN_THREE
-                                         when /^PATTERN_FOUR/
-                                           opts["dataop"] = :PATTERN_FOUR
-                                         else
-                                           # do nothing
-                                         end
-                                       }
-}
-
-unless opts["output"] and opts["yamlop"] and opts["dataop"]
+unless opts["output"]
+  puts("Not specified -oputut")
   puts(banner)
-  puts "don't be specified -d output" unless opts["output"]
-  puts "don't be specified -y value" unless opts["yamlop"]
-  puts "don't be specified -p value" unless opts["dataop"]
-  p ARGV
-  p opts
-  exit(EXIT_CODE_MISSING_REQUIRED_ARGUMENT)
+  exit(mes.ec("EXIT_CODE_ARGV_ERROR"))
 end
 
-puts "# makemdtab Start #"
-puts "|||||||||||| opts['output']=#{opts['output']}"
-puts "|||||||||||| ARGV=#{ARGV}"
-opts.each do |k,v|
-  puts "|||||||||||| opts[#{k}]=#{v}"
+opts["data"] = File.expand_path(opts["data"])
+opts["output"] = File.expand_path(opts["output"])
+opts["yaml"] = File.expand_path(opts["yaml"]) if opts["yaml"]
+
+if opts["yaml"]
+  auxhs = Filex::Filex.checkAndLoadYamlfile(opts["yaml"], mes)
+else
+  auxhs = {}
 end
 
-x=Makemdtab.new(opts, ARGV)
-x.makeMd()
+x.makeMd2(opts["template"], auxhs)
 x.postProcess
-puts "# makemdtab End #"
-exit(EXIT_CODE_NORMAL_EXIT)
-
-
-
+mes.outputInfo("# makemdtab End #")
+exit(mes.ec("EXIT_CODE_NORMAL_EXIT"))

data/bin/mdextab

@@ -1,28 +1,20 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup'
-require 'mdextab'
+require "bundler/setup"
+require "mdextab"
 
-require 'simpleoptparse'
+require "simpleoptparse"
 
-opts = {  }
+opts = {}
 banner = "Usage: bundle exec ruby bin/mdextab in_md_fname out_md_fname settng_yaml auxiliary_setting_yaml"
 
-Simpleoptparse::Simpleoptparse.parse(ARGV , opts , banner , Mdextab::VERSION , nil){|parser|
-    parser.on('-d', '--debug'  ) {|x| opts["debug"] = true }
-}
+Simpleoptparse::Simpleoptparse.parse(ARGV, opts, banner, Mdextab::VERSION, nil) do |parser|
+  parser.on("-d", "--debug") {|_x| opts["debug"] = true }
+end
 
 fname = ARGV[0]
-oFname = ARGV[1]
-yamlFname = ARGV[2]
-auxiliaryYamlFname = ARGV[3]
-m = Mdextab::Mdextab.new(opts,fname,oFname,yamlFname,auxiliaryYamlFname)
-m.parse
-m.end
-
-puts "##### Mdextab fname=#{fname}"
-puts "##### Mdextab oFname=#{oFname}"
-puts "##### Mdextab yamlFname=#{yamlFname}"
-puts "##### Mdextab auxiliaryYamlFname=#{auxiliaryYamlFname}"
-
-exit(0)
+o_fname = ARGV[1]
+yaml_fname = ARGV[2]
+opts["yaml_fname"] = yaml_fname
+m = Mdextab::Mdextab.new(opts, fname, o_fname)
+m.parse2(yaml_fname)

data/lib/mdextab/layer.rb

@@ -0,0 +1,157 @@
+module Mdextab
+  class Layer
+    attr_accessor :return_from_nested_env, :cur_layer, :size
+
+    def initialize(mes, output)
+      @mes = mes
+      @output = output
+      @return_from_nested_env = false
+
+      @layer_struct = Struct.new(:table, :star, :cur_state, :fname, :lineno)
+      @cur_layer = nil
+      @layers = []
+    end
+
+    def cur_state=(val)
+      # raise if val.class != Symbol
+      @cur_layer.cur_state = val
+    end
+
+    def cur_state
+      raise if @cur_layer.cur_state.class != Symbol
+      @cur_layer.cur_state
+    end
+
+    def table
+      @cur_layer.table
+    end
+
+    def table=(val)
+      @cur_layer.table = val
+    end
+
+    def star=(val)
+      @cur_layer.star = val
+    end
+
+    def star
+      @cur_layer.star
+    end
+
+    def add_layer(fname, lineno, state=:START)
+      new_layer = @layer_struct.new(nil, nil, nil, fname, lineno)
+      @layers << new_layer
+      @size = @layers.size
+      # raise if state.class != Symbol
+      new_layer.cur_state = state
+      if @cur_layer
+        new_layer.star = @cur_layer.star
+      else
+        new_layer.star = false
+      end
+      @cur_layer = new_layer
+    end
+
+    def pop_prev_layer
+      tmp_ = @layers.pop
+      @size = @layers.size
+      @cur_layer = @layers.last
+
+      tmp_
+    end
+
+    def peek_prev_layer
+      return nil unless @layers.size > 1
+
+      @layers[@layers.size - 2]
+    end
+
+    def process_nested_table_start(token, lineno, fname)
+      if table.tbody.nil?
+        table.add_tbody(lineno)
+      end
+      @mes.output_debug("B process_nested_table_start 1 @cur_layer.table=#{@cur_layer.table.object_id} token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} cur_state=#{@cur_layer.cur_state}")
+      add_layer(fname, lineno, :OUT_OF_TABLE)
+      @cur_layer.table = Table.new(token.opt[:lineno], @mes, token.opt[:attr])
+      @mes.output_debug("process_nested_table_start 3 token.kind=#{token.kind} cur_state=#{@cur_layer.cur_state}")
+    end
+
+    def process_table_end(token)
+      prev_layer = peek_prev_layer
+      if prev_layer
+        process_table_end_for_prev_env(token, prev_layer)
+      end
+    end
+
+    def process_table_end_for_prev_env(token, prev_layer)
+      tmp_table = @cur_layer.table
+      pop_prev_layer
+      @return_from_nested_env = true
+
+      case @cur_layer.cur_state
+      when :IN_TD
+        prev_layer.table.td_append(tmp_table, prev_layer.star)
+      when :IN_TD_NO_TBODY
+        prev_layer.table.td_append(tmp_table, prev_layer.star)
+      when :IN_TH
+        prev_layer.table.th_append(tmp_table, prev_layer.star)
+      when :IN_TH_NO_TBODY
+        prev_layer.table.th_append(tmp_table, prev_layer.star)
+      when :IN_TABLE
+        if prev_layer.table.nil?
+          @mes.output_debug("In process_nested_table_env_for_prev_env: table=nil token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} cur_state=#{@cur_layer.cur_state}")
+          raise
+        end
+        prev_layer.table.add(tmp_table)
+      when :IN_TABLE_BODY
+        prev_layer.table.add(tmp_table)
+      when :START
+        @mes.output_debug("In process_nested_table_env_for_prev_env: table=nil token.kind=#{token.kind} token.opt[:lineno]=#{token.opt[:lineno]} cur_state=#{@cur_layer.cur_state}")
+        raise
+      else
+        v = prev_layer.cur_state || "nil"
+        @mes.output_fatal("E100 cur_state=#{v}")
+        @mes.output_fatal("table=#{prev_layer.table}")
+        @mes.output_fatal("IllegalState(#{@cur_layer.cur_state} in process_table_end(#{token})")
+        exit(@mes.ec("EXIT_CODE_TABLE_END"))
+      end
+    end
+
+    def check_layers(fname)
+      case @cur_layer.cur_state
+      when :OUT_OF_TABLE
+        if @layers.size > 1
+          @mes.output_fatal("illeagal nested env after parsing|:OUT_OF_TABLE")
+          @mes.output_fatal("@layers.size=#{@layers.size} :TABLE_START #{fname} #{table.lineno}")
+          @layers.map {|x| @mes.output_debug("== @layers.cur_state=#{x.cur_state} :TABLE_START #{fname} #{x.table.lineno}") }
+          @mes.output_debug("== table")
+          @mes.output_info(table)
+          exit(@mes.ec("EXIT_CODE_EXCEPTION"))
+        end
+      when :START
+        if @layers.size > 1
+          @mes.output_fatal("illeagal nested env after parsing|:START")
+          @mes.output_fatal("@layers.size=#{@layers.size}")
+          @layers.map {|x| @mes.output_error("== @layers.cur_state=#{x.cur_state} :TABLE_START #{fname} #{x.table.lineno}") }
+          @mes.output_error("== table")
+          @mes.output_error(table)
+          exit(@mes.ec("EXIT_CODE_EXCEPTION"))
+        end
+      else
+        @mes.output_fatal("illeagal state after parsing(@cur_layer.cur_state=#{@cur_layer.cur_state}|fname=#{fname}")
+        @mes.output_fatal("@layers.size=#{@layers.size}")
+        @mes.output_error("== cur_state=#{@cur_layer.cur_state}")
+        @layers.map {|x| @mes.output_error("== @layers.cur_state=#{x.cur_state} #{fname}:#{x.table.lineno}") }
+        @mes.output_error("")
+        exit(@mes.ec("EXIT_CODE_ILLEAG<AL_STATE"))
+      end
+    end
+
+    def debug(nth, token)
+      @mes.output_debug("***#{nth}")
+      @layers.each_with_index {|_x, ind| @mes.output_debug("@layers[#{ind}]=#{@layers[ind]}") }
+      @mes.output_debug("******#{nth}")
+      @mes.output_debug("Layer#debug 1 token.kind=#{token.kind} @layer.cur_state=#{@cur_layer.cur_state}")
+    end
+  end
+end

data/lib/mdextab/makemdtab.rb

@@ -0,0 +1,119 @@
+module Mdextab
+  require "digest"
+  require "pp"
+  require "filex"
+
+  class Makemdtab
+    def initialize(opts, eruby_variable_str, eruby_static_str, obj_by_yaml, mes=nil)
+      @yamlfiles = {}
+      @str_yamlfiles = {}
+      @str_mdfiles = {}
+      @str_erubyfiles = {}
+      @dataop = opts["dataop"]
+      @datayamlfname = opts["data"]
+      @eruby_variable_str = eruby_variable_str
+      @eruby_static_str = eruby_static_str
+      @outputfname = opts["output"]
+      @obj_by_yaml = obj_by_yaml
+
+      @exit_cannot_find_file = 1
+      @exit_cannot_write_file = 2
+
+      @mes = mes
+      unless @mes
+        if opts["debug"]
+          @mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0, :debug)
+        elsif opts["verbose"]
+          @mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0, :verbose)
+        else
+          @mes = Messagex::Messagex.new("EXIT_CODE_NORMAL_EXIT", 0)
+        end
+      end
+      @mes.add_exitcode("EXIT_CODE_ILLEGAL_DATAOP")
+      Filex::Filex.setup(@mes)
+
+      @output = @mes.exc_file_write(@outputfname) { File.open(@outputfname, "w") }
+    end
+
+    def self.create(opts, fname_variable, fname_static, root_settingfile, mes)
+      Filex::Filex.setup(mes)
+
+      unless File.exist?(opts["output"])
+        mes.output_fatal("Can't find #{opts['output']}")
+        exit(mes.ec("EXIT_CODE_CANNOT_FIND_FILE"))
+      end
+      obj_by_yaml = Filex::Filex.check_and_load_yamlfile(root_settingfile, mes)
+
+      str_variable = Filex::Filex.check_and_load_file(fname_variable, mes) if fname_variable
+      str_static = ["<% ", Filex::Filex.check_and_expand_file(fname_static, obj_by_yaml, mes), "%>"].join("\n") if fname_static
+
+      Makemdtab.new(opts, str_variable, str_static, obj_by_yaml, mes)
+    end
+
+    def make_md2(root_dir, templatefile=nil, auxhs={})
+      objx = @obj_by_yaml.merge(auxhs)
+      case @dataop
+      when :FILE_INCLUDE
+        array = load_file_include(root_dir, @datayamlfname, objx)
+      when :YAML_TO_MD
+        unless templatefile
+          @mes.output_fatal("Not specified templatefile")
+          exit(@mes.ec("EXIT_CODE_NOT_SPECIFIED_FILE"))
+        end
+        if templatefile.strip.empty?
+          @mes.output_fatal("Not specified templatefile")
+          exit(@mes.ec("EXIT_CODE_NOT_SPECIFIED_FILE"))
+        end
+
+        array = load_yaml_to_md(@datayamlfname, templatefile, objx)
+      else
+        array = []
+      end
+      array.map {|x| @mes.exc_file_write(@outputfname) { @output.puts(x) } }
+    end
+
+    def load_file_include(root_dir, datayamlfname, objx)
+      mdfname = datayamlfname
+      objy = { "parentDir" => "%q!" + root_dir + "!" }
+      eruby_exanpded_str = ""
+      if @eruby_variable_str
+        if @eruby_variable_str.empty?
+          eruby_exanpded_str = ""
+        else
+          eruby_exanpded_str = ["<% ", Filex::Filex.expand_str(@eruby_variable_str, objy, @mes), " %>"].join("\n")
+        end
+      end
+      mbstr = Filex::Filex.check_and_load_file(mdfname, @mes)
+      dx = [eruby_exanpded_str, @eruby_static_str, mbstr].join("\n")
+      if dx.strip.empty?
+        puts "empty mdfname=#{mdfname}"
+      else
+        array = [Filex::Filex.expand_str(dx, objx, @mes, { "mdfname" => mdfname })]
+      end
+
+      array
+    end
+
+    def load_yaml_to_md(datayamlfname, templatefile, objx)
+      @mes.output_debug("datayamlfname=#{datayamlfname}")
+      @mes.output_debug("objx=#{objx}")
+
+      objy = Filex::Filex.check_and_expand_yamlfile(datayamlfname, objx, @mes)
+      @mes.output_debug("objy=#{objy}")
+      @mes.output_debug("templatefile=#{templatefile}")
+
+      erubystr = Filex::Filex.check_and_load_file(templatefile, @mes)
+      @mes.output_debug("erubystr=#{erubystr}")
+      dx = [@eruby_static_str, erubystr].join("\n")
+      @mes.output_debug("dx=#{dx}")
+      array = [Filex::Filex.expand_str(dx, objy, @mes, { "datayamlfname" => datayamlfname, "templatefile" => templatefile })]
+
+      array
+    end
+
+    def post_process
+      @mes.exc_file_close(@outputfname) { @output&.close }
+      @output = nil
+    end
+  end
+end