md2site 0.1.2

data/lib/md2site/make.rb

@@ -0,0 +1,295 @@
+module Md2site
+  #
+  # makeサブコマンドクラス
+  #
+  class Make
+    #
+    # 初期化
+    # @param env [Env] Envクラスのインスタンス
+    # @param mes [Messagex] Messagexクラスのインスタンス
+    # @param verbose [Boolean] FileUtilsクラスのメソッドのverbose引数に与える値
+    # @param str_variable [String] 2段階の変数置換が必要なeRubyスクリプト（一度置換をし、さらにもう一度置換が必要なeRubyスクリプト）
+    # @param str_static [String] 1段階の変数置換のみが必要なeRubyスクリプト（一度置換をしたら、その後は置換が必要ないeRubyスクリプト）
+    # @param obj_by_yaml [Hash] 変数置換に用いるハッシュ
+    def initialize(env, mes, verbose, str_variable, str_static, obj_by_yaml)
+      @env = env
+      @mes = mes
+      @verbose = verbose
+      @str_variable = str_variable
+      @str_static = str_static
+      @obj_by_yaml = obj_by_yaml
+      @template_dir = @env.conf_hs["TEMPLELATE_DIR"]
+      @default_table_template = @env.conf_hs["DEFAULT_TABLE_TEMPLATE"] # 5col_no_attr_b.erb
+    end
+
+    #
+    # 引数optionでの指定に従いサブコマンドを実行
+    # @param target_command [String] ターゲットコマンド名
+    # @param subtarget_command [String] サブターゲットコマンド名
+    def execute_subcommand(target_command, subtarget_command)
+      if subtarget_command == SUB_TARGET_COMMAND_OF_ALL
+        do_multiple_commands(target_command)
+      else
+        do_single_command(target_command, subtarget_command)
+      end
+    end
+
+    #
+    # 指定ターゲットコマンドに属する全サブターゲットコマンドを順次実行する
+    # @param target_command [String] ターゲットコマンド名
+    def do_multiple_commands(target_command)
+      ary = @env.get_subtarget_commands(target_command)
+      if !ary.empty?
+        ary.map do |subtarget_command, _v|
+          @mes.output_info("#{target_command} #{subtarget_command}")
+          do_single_command(target_command, subtarget_command)
+        end
+      else
+        @mes.output_fatal("Illeagel targetcommand(#{target_command}")
+        exit(@mes.ec("EXIT_CODE_ILLEAGAL_TARGETCOMMAND"))
+      end
+    end
+
+    private
+
+    #
+    # ターゲットコマンド名、サブターゲットコマンド名の組み合わせを実行する
+    # @param target_command [String] ターゲットコマンド名
+    # @param subtarget_command [String] サブターゲットコマンド名
+    def do_single_command(target_command, subtarget_command)
+      target, subtarget = @env.get_target_and_subtarget(target_command, subtarget_command)
+      @mes.output_info(%Q(target=#{target}))
+      @mes.output_info(%Q(subtarget=#{subtarget}))
+      unless target
+        @mes.output_fatal(%Q(Cannot find target by #{target_command}))
+        exit(@mes.ec("EXIT_CODE_BY_CANNOT_FIND_TARGET"))
+      end
+
+      unless subtarget
+        @mes.output_fatal(%Q(Cannot find subtarget by #{subtarget_command}))
+        exit(@mes.ec("EXIT_CODE_BY_CANNOT_FIND_SUBTARGET"))
+      end
+
+      execute_single_command(target, subtarget)
+    end
+
+    #
+    # 指定パスが有効なファイルであるか調べる
+    # @param fname [String] ファイルのパス
+    # @return [Boolean] true:有効なファイルパスである　false:有効なファイルパスでない
+    def check_valid_src_file(fname)
+      valid_src_file = true
+
+      ret = FileTest.size?(fname)
+      if !ret || (ret == 0)
+        valid_src_file = false
+      elsif FileTest.directory?(fname)
+        valid_src_file = false
+      elsif File.read(fname).strip.empty?
+        valid_src_file = false
+      end
+      valid_src_file
+    end
+
+    #
+    # eRubyスクリプトを用いてMarkdown形式ファイルを生成
+    # @param target_struct [Struct] ターゲットストラクト
+    # @param template_struct [Struct] テンプレートストラクト
+    def execute_single_command_for_template(target_struct, template_struct)
+      # 既存のファイルを読み込む
+      if template_struct.kind == :INCLUDE
+        dataop = :FILE_INCLUDE
+        # 読み込み元のファイルが存在しなければ、あらかじめ作成する
+        unless check_valid_src_file(template_struct.datafname)
+          src_subtarget = @env.get_sub_target(target_struct.name, template_struct.src_subtarget_name)
+          execute_single_command(target_struct, src_subtarget)
+        end
+        command_make_md(@env.absolutepath_root, template_struct.datafname, template_struct.outputfname, dataop, nil, { template_struct.macroname => template_struct.datafname })
+      # YAML形式ファイルを、eRubyスクリプトを用いて、Markdown形式ファイルに変換する
+      else
+        dataop = :YAML_TO_MD
+        command_make_md(@env.absolutepath_root, template_struct.datafname, template_struct.outputfname, dataop, template_struct.templatefname, { template_struct.macroname => template_struct.outputfname })
+      end
+    end
+
+    #
+    # Markdown形式ファイルをeRubyスクリプトを用いて
+    # @param target_struct [Struct] ターゲットストラクト
+    # @param subtarget_struct [Struct] サブターゲットストラクト
+    def execute_single_command(target_struct, subtarget_struct)
+      # 設定されていれば、全テンプレートストラクトに対して、テンプレートを用いてMarkdown形式ファイルを生成
+      unless subtarget_struct.templates.empty?
+        subtarget_struct.templates.each do |template_struct|
+          execute_single_command_for_template(target_struct, template_struct)
+        end
+      end
+      # eRubyスクリプト内でファイルを表すマクロ名と実際のファイルパスの対応をハッシュで実現
+      ary = subtarget_struct.templates.map {|x| [x.macroname, x.outputfname] }.flatten
+      hash = Hash[*ary]
+      # Markdown形式ファイルから生成するHTMLファイルは、HTMLのbodyタグ内の部分である
+      # HTMLの先頭から<body>の直前までと、</body>から最後までを別途取得して、最終的にそれらを結合してHTMLファイルにする。
+      parta_html = get_part_html(target_struct, subtarget_struct, :partA)
+      partc_html = get_part_html(target_struct, subtarget_struct, :partC)
+
+      datafile = subtarget_struct.filedir.input_md
+      outputfile = subtarget_struct.filedir.output_md
+      dataop = :FILE_INCLUDE
+      templatefile = nil
+      # HTMLファイルに変換する元となるMarkdown形式ファイル生成
+      command_make_md(@env.absolutepath_root, datafile, outputfile, dataop, templatefile, hash)
+
+      outputfile_md = subtarget_struct.filedir.output_md
+      root_output_md = subtarget_struct.filedir.root_output_md
+      out_htmlfname = subtarget_struct.filedir.html_output
+      # Markdown形式ファイルをHTMLに変換、結合して最終的なHTMLファイルを生成
+      command_make_html(@env.absolutepath_root, outputfile_md, root_output_md, parta_html, partc_html, out_htmlfname)
+    end
+
+    #
+    # サブターゲットでエイリアスが指定されていれば、エイリアスを生成するサブターゲットを得る
+    # @param target_struct [Struct] ターゲットストラクト
+    # @param subtarget_struct [Struct] サブターゲットストラクト
+    # @return [Struct] 有効なサブターゲットストラクト
+    def get_effective_subtarget(target_struct, subtarget_struct)
+      if subtarget_struct.aliashtmldir == ""
+        if subtarget_struct.aliashtmlfile == ""
+          htmlfpath = nil
+        else
+          htmlfpath = subtarget_struct.aliashtmlfile
+        end
+      else
+        htmlfpath = File.join(subtarget_struct.aliashtmldir, subtarget_struct.aliashtmlfile)
+      end
+
+      if htmlfpath
+        subtarget_struct_x = @env.get_subtarget_by_htmlfile(target_struct.name, htmlfpath)
+      else
+        subtarget_struct_x = subtarget_struct
+      end
+
+      subtarget_struct_x
+    end
+
+    #
+    # 指定されたパートに対応するHTMLファイルパスを得る
+    # @param target_struct [Struct] ターゲットストラクト
+    # @param subtarget_struct [Struct] サブターゲットストラクト
+    # @param kind [Symbol] :partA パートA :partB パートB
+    def get_part_html(target_struct, subtarget_struct, kind)
+      subtarget_x = get_effective_subtarget(target_struct, subtarget_struct)
+
+      path = ""
+      case kind
+      when :partA
+        path = subtarget_x.filedir.partAhtml
+      when :partC
+        path = subtarget_x.filedir.partChtml
+      end
+
+      path
+    end
+
+    def command_make_md(src_dir, datafile, outputfile, dataop, templatefile, auxhs={})
+      @mes.output_info(%Q!command_make_md(#{datafile}, #{outputfile}, #{dataop}, #{templatefile},  #{auxhs}!)
+      if src_dir
+        datafile = File.join(src_dir, datafile) if datafile
+        outputfile = File.join(src_dir, outputfile) if outputfile
+      end
+      optsx = {}
+      optsx["data"] = datafile
+      optsx["output"] = outputfile
+      optsx["dataop"] = dataop
+
+      mmt = Mdextab::Makemdtab.new(optsx, @str_variable, @str_static, @obj_by_yaml, @mes)
+      if templatefile
+        if src_dir
+          template_fullpath = File.join(src_dir, @template_dir, templatefile)
+        else
+          template_fullpath = File.join(@template_dir, templatefile)
+        end
+      else
+        template_fullpath = @default_table_template
+      end
+
+      mmt.make_md2(src_dir, template_fullpath, auxhs)
+      mmt.post_process
+    end
+
+    def simple_md2html(inputmd, output_htmlfname)
+      @mes.output_info(%Q(pandoc -o #{output_htmlfname} -t html5 #{inputmd}))
+      ret = false
+      _, _, s = Open3.capture3(%Q(pandoc -o #{output_htmlfname} -t html5 #{inputmd}))
+
+      if s.exited?
+        if s.exitstatus == 0
+          ret = true
+        else
+          @mes.output_error("Can't convert from md to html by pandoc(exit_code=#{s.exitstatus})")
+          exit(@mes.ec("EXIT_CODE_CANNOT_CONVERT_FROM_MD_TO_HTML"))
+        end
+      else
+        @mes.output_error("Pandoc exit abnormally")
+        exit(@mes.ec("EXIT_CODE_PANDOC_EXIT_ABNORMALLY"))
+      end
+
+      ret
+    end
+
+    def output_html(out_htmlfname, mode, parta, content, partb)
+      File.open(out_htmlfname, mode) do |f|
+        f.write(parta)
+        f.write(content)
+        f.write(partb)
+      end
+    end
+
+    def md2html(root_outputmd, out_htmlfname, parta, partb)
+      tmpdir = File.dirname(out_htmlfname)
+      tmpbasename = File.basename(out_htmlfname)
+
+      content_htmlfname = File.join(tmpdir, tmpbasename + ".tmp")
+      unless root_outputmd
+        @mes.output_fatal("Can't find file(=#{root_outputmd}")
+        exit(@mes.ec("EXIT_CODE_CANNOT_FIND_FILE"))
+      end
+      @mes.output_debug("root_outputmd=#{root_outputmd}")
+      @mes.output_debug("content_htmlfname=#{content_htmlfname}")
+      ret = simple_md2html(root_outputmd, content_htmlfname)
+      return unless ret
+
+      ret = simple_md2html(root_outputmd, "x.html")
+      unless ret
+        tmpf.close(true)
+        return
+      end
+
+      content = ""
+      @mes.exc_file_read(content_htmlfname) { content = File.readlines(content_htmlfname).join }
+      @mes.output_debug("file_read #{content_htmlfname}")
+#      @mes.output_debug("content #{content}")
+      @mes.exc_file_write(out_htmlfname) { output_html(out_htmlfname, "w", parta, content, partb) }
+      @mes.output_debug("file_write #{out_htmlfname}")
+#      File.unlink(content_htmlfname)
+    end
+
+    def command_make_html(src_dir, outputfile_md, root_output_md, parta_html, partc_html, out_htmlfname)
+      @mes.output_info(%Q!command_makehtml(#{outputfile_md}, #{root_output_md}, #{parta_html} #{partc_html} #{out_htmlfname}!)
+      if src_dir
+        outputfile_md = File.join(src_dir, outputfile_md) if outputfile_md
+        root_output_md = File.join(src_dir, root_output_md) if root_output_md
+        parta_html = File.join(src_dir, parta_html) if parta_html
+        partc_html = File.join(src_dir, partc_html) if partc_html
+        out_htmlfname = File.join(src_dir, out_htmlfname) if out_htmlfname
+      end
+
+      optsx = {}
+      m = Mdextab::Mdextab.new(optsx, outputfile_md, root_output_md, @mes)
+      m.parse(@obj_by_yaml)
+      m.post_process
+
+      parta = Filex::Filex.check_and_load_file(parta_html, @mes)
+      partc = Filex::Filex.check_and_load_file(partc_html, @mes)
+      md2html(root_output_md, out_htmlfname, parta, partc)
+    end
+  end
+end    

data/lib/md2site/nkfguess.rb

@@ -0,0 +1,33 @@
+module Md2site
+  module Nkfguess
+    require "nkf"
+
+    def self.guess_file(fname, mes)
+      str = nil
+      mes.exc_file_read(fname) { File.open(fname) {|f| str = f.gets(nil) } }
+      if str.nil?
+        encoding = nil
+      else
+        case NKF.guess(str)
+        when NKF::JIS
+          encoding = "ISO-2022-JP"
+        when NKF::EUC
+          encoding = "eucJP"
+        when NKF::SJIS
+          encoding = "CP932"
+        when NKF::UTF8
+          encoding = "UTF-8"
+        when NKF::BINARY
+          encoding = "ASCII-8BIT"
+        when NKF::ASCII
+          encoding = "ASCII-8BIT"
+        when NKF::UNKNOWN
+          encoding = "ASCII-8BIT"
+        else
+          encoding = "ASCII-8BIT"
+        end
+      end
+      encoding
+    end
+  end
+end

data/lib/md2site/setup.rb

@@ -0,0 +1,358 @@
+module Md2site
+  #
+  # setupサブコマンドクラス
+  #
+  class Setup
+    # WEBサイトへのアクセス待ち時間(秒単位)
+    ACCESS_WAIT_SEC = 10
+    # ACCESS_WAIT_SEC=5
+    # ACCESS_WAIT_SEC=1
+
+    require "faraday_middleware"
+    require "faraday"
+    require "date"
+    require "open3"
+    require "uri"
+    require "digest"
+    require "messagex"
+    require "md2site/statusfile"
+    require "md2site/listfile"
+
+    #
+    # 初期化
+    # @param env [Env] Envクラスのメソッド
+    # @param mes [Messagex] Messagexクラスのインスタンス
+    def initialize(env, mes)
+      @env = env
+      @mes = mes
+      @category = @env.category
+      @category_x = @env.category_x
+      absolute_path_status_file = env.conf_hs["ABSOLUTE_PATH_STATUS_FILE"]
+      @url = @env.conf_hs["URL"]
+      @res = {}
+
+      @mes.add_exitcode("EXIT_CODE_BY_EXCEPTION")
+      @mes.add_exitcode("EXIT_CODE_EXECUTE_SETUP_BEFORE_UPDATE_HTMLFILES")
+      @mes.add_exitcode("EXIT_CODE_CANNOT_FIND_DEST_DIR")
+      @mes.add_exitcode("EXIT_CODE_CANNOT_CONVERT_FROM_HTML_TO_MD")
+      @mes.add_exitcode("EXIT_CODE_PANDOC_EXIT_ABNORMALLY")
+      @status_file = StatusFile.new(absolute_path_status_file, @url, @mes)
+    end
+
+    #
+    # サブコマンド実行
+    # @param option [String] サブコマンドのオプション
+    def execute_subcommand(option)
+      case option.name
+      when "contentUpdate"
+        update_htmlfiles
+      when "zcontents"
+        dir = @env.get_filepath(option.value)
+        unless dir
+          @mes.exc_make_directory(option.value) { FileUtils.mkdir_p(option.value) }
+          dir = @env.get_filepath(option.value)
+        end
+        unless dir || FileTest.directory?(dir)
+          @mes.output_fatal("Can't find drectory(=#{dir}")
+          exit(@mes.ec("EXIT_CODE_CANNOT_FIND_DIRECTORY"))
+        end
+        get_remote_contents(dir)
+      when "getfiles"
+        dir = @env.get_filepath(option.value)
+        get_remote_file_headers(dir)
+      end
+    end
+
+    private
+
+    #
+    # リモートサイトのファイル取得
+    # @param url [String] 取得先URL
+    # @return [Array] 第0要素:Datetime 第1要素:UNIXタイム 第2要素:HTTPボディ
+    def get_remote_file(url)
+      connection = Faraday.new(url) do |conn|
+        conn.use(FaradayMiddleware::FollowRedirects)
+        conn.adapter(:net_http)
+      end
+      @mes.output_debug("url=#{url}")
+      res = connection.get(url)
+      datetime_str, datetime_unix_time = get_modified_in_datetime_or_date_in_datetime_from_header(res.headers)
+      [datetime_str, datetime_unix_time, res.body]
+    end
+
+    #
+    # HTTPヘッダの指定フィールドの値を文字列とUNITタイムで取得する
+    # @param headers [Hash] HTTPヘッダを表すハッシュ
+    # @param key [String] HTTPヘッダのフィールドを指定するキー
+    # @return [Array] 第0要素: 指定フィールドの値(String) 第1要素: 指定フィールドの値(UNIXタイム)
+    def get_header_value_of_datetime(headers, key)
+      @res[key] ||= Regexp.compile(Regexp.escape(key))
+      keys = headers.keys.select {|x| @res[key].match?(x.downcase) }
+
+      if keys.size == 1
+        k = keys.first
+        s = headers[k]
+        begin
+          dt = DateTime.httpdate(s)
+          unixtime = dt.to_time.to_i
+        rescue ArgumentError => e
+          @mes.output_exception(e)
+          @mes.output_fatal("s=#{s}")
+          exit(@mes.ec("EXIT_CODE_BY_EXCEPTION"))
+        rescue Error => e
+          @mes.output_exception(e)
+          @mes.output_fatal("s=#{s}")
+          exit(@mes.ec("EXIT_CODE_BY_EXCEPTION"))
+        end
+      else
+        s = nil
+        unixtime = nil
+      end
+      [s, unixtime]
+    end
+
+    #
+    # HTTPヘッダのlast-modifiedフィールドの値を文字列とUNITタイムで取得
+    # @param headers [Hash] HTTPヘッダを表すハッシュ
+    # @return [Array] 第0要素: 指定フィールドの値(String) 第1要素: 指定フィールドの値(UNIXタイム)
+    def get_modified_in_datetime_from_header(headers)
+      get_header_value_of_datetime(headers, "last-modified")
+    end
+
+    #
+    # HTTPヘッダのdateフィールドの値を文字列とUNITタイムで取得
+    # @param headers [Hash] HTTPヘッダを表すハッシュ
+    # @return [Array] 第0要素: 指定フィールドの値(String) 第1要素: 指定フィールドの値(UNIXタイム)
+    def get_date_in_datetime_from_header(headers)
+      get_header_value_of_datetime(headers, "date")
+    end
+
+    #
+    # HTTPヘッダから時刻を表すlast-modifiedフィールドまたはdateフィールのの値を文字列とUNIXタイムで取得
+    # @param headers [Hash] HTTPヘッダを表すハッシュ
+    # @return [Array] 第0要素: 指定フィールドの値(String) 第1要素: 指定フィールドの値(UNIXタイム)
+    def get_modified_in_datetime_or_date_in_datetime_from_header(headers)
+      ary = get_modified_in_datetime_from_header(headers)
+      unless ary.all?
+        ary = get_date_in_datetime_from_header(headers)
+      end
+      ary
+    end
+
+    #
+    # 指定URLのHTTPヘッダから時刻を表すlast-modifiedフィールドまたはdateフィールのの値を文字列とUNIXタイムで取得
+    # @param url [String] HTTPヘッダを取得したいURL
+    # @return [Array] 第0要素: 指定フィールドの値(String) 第1要素: 指定フィールドの値(UNIXタイム)
+    def get_modified_in_datetime_or_date_in_datetime(url)
+      connection = Faraday.new(url) do |conn|
+        conn.use(FaradayMiddleware::FollowRedirects)
+        conn.adapter(:net_http)
+      end
+      @mes.output_debug("url=#{url}")
+      res = connection.head(url)
+      get_modified_in_datetime_or_date_in_datetime_from_header(res.headers)
+    end
+
+    #
+    # 時刻を"年月日-時分秒"の形式の文字列にする
+    # @param datetime [Datetime] Datetimeクラスのインスタンス
+    # @return [String] "年月日-時分秒"の形式の文字列
+    def get_datestring(datetime)
+      datetime.strftime("%Y%m%d-%H%M%S")
+    end
+
+    #
+    # 現在時刻をDatetimeクラスのインスタンスと文字列にする
+    # @return [Array] 第0要素: Datetimeクラスのインスタンス 第1要素: "年月日-時分秒"の形式の文字列
+    def current_time
+      datetime = DateTime.now
+      datetimestr = get_datestring(datetime)
+      [datetime, datetimestr]
+    end
+
+    #
+    # 指定サイトでダウンロード指定された全URLのHTTPヘッダの時刻を取得して一覧をファイルに保存
+    # @param dir [String] HTTPヘッダ時刻一覧ファイルの保存先ディレクトリ
+    # @return [Array] 第0要素: Datetimeクラスのインスタンス 第1要素: "年月日-時分秒"の形式の文字列
+    # @note 一覧を保存するファイルのファイル名はsite-年月日-時分秒.tsvである
+    def get_remote_file_headers(dir)
+      _, datetimestr = current_time
+
+      fname = %Q(site-#{datetimestr}.tsv)
+      fpath = File.join(dir, fname)
+
+      @mes.exc_file_write(fpath) do
+        File.open(fpath, "w") do |ofile|
+          @category_x[:category].each do |_k, v|
+            v.each do |_k2, v2|
+              filename = v2[@env.htmlfile_index]
+              next if v2[@env.alias_htmlfile_index]
+
+              if %r{/$}.match?(@url)
+                file_url = URI.join(@url, filename)
+              else
+                file_url = URI.join(@url, "/", filename)
+              end
+              ary = get_modified_in_datetime_or_date_in_datetime(file_url)
+              unless ary.all?
+                @mes.output_error("Can't find last-modified header from #{@url}")
+              end
+              v2.concat(ary)
+
+              ofile.puts(v2.join("\t"))
+            end
+          end
+        end
+      end
+      @status_file.fname = fname
+      @status_file.fpath = fpath
+      @status_file.last_datetime = datetimestr
+      @status_file.update
+    end
+
+    #
+    # 引数で指定したファイルが書込み可能であるように書込み先ディレクトリを作成
+    # @param dir [String] ディレクトリ
+    # @param filename [String] ファイルへのパス（ファイル名のみも可）
+    def prepare_new_write_path(dir, filename)
+      dirname = File.dirname(filename)
+      if dirname != "."
+        dirpath = File.join(dir, dirname)
+        @mes.exc_make_directory(dirpath) { FileUtils.mkdir_p(dirpath) }
+        basename = File.basename(filename)
+        fpath = File.join(dirpath, basename)
+      else
+        fpath = File.join(dir, filename)
+      end
+      fpath
+    end
+
+    def get_remote_contents_sub(target_hash, listfile, last_contents_path)
+      target_hash.each do |_, target_def|
+        filename = target_def[@env.htmlfile_index]
+        next if target_def[@env.alias_htmlfile_index]
+
+        if %r{/$}.match?(@url)
+          file_url = URI.join(@url, filename)
+        else
+          file_url = URI.join(@url, "/", filename)
+        end
+        remote_datetime_str, remote_datetime_unixtime, content = get_remote_file(file_url)
+        unless [remote_datetime_str, remote_datetime_unixtime].all?
+          @mes.output_error("Can't get content from #{file_url}")
+          listfile.add([filename, remote_datetime_str, remote_datetime_unixtime, nil])
+
+          sleep(ACCESS_WAIT_SEC)
+          next
+        end
+        fpath = prepare_new_write_path(last_contents_path, filename)
+
+        @mes.exc_file_write(fpath) do
+          File.open(fpath, "w") do |ofile|
+            if content
+              ofile.puts(content)
+            end
+          end
+        end
+        listfile.add([filename, remote_datetime_str, remote_datetime_unixtime, Digest::MD5.hexdigest(content)])
+      end
+    end
+
+    def get_remote_contents(dir)
+      _, datetimestr = current_time
+
+      @mes.output_info("dir=#{dir}")
+      @mes.output_info("datetimestr=#{datetimestr}")
+
+      last_contents_path = File.absolute_path(File.join(dir, datetimestr))
+      @mes.exc_make_directory(last_contents_path) { FileUtils.mkdir_p(last_contents_path) }
+
+      lf = ListFile.new(last_contents_path, @mes)
+      @category_x[:category].each do |_, target_hash|
+        get_remote_contents_sub(target_hash, lf, last_contents_path)
+      end
+      lf.close
+      @status_file.last_contents_path = last_contents_path
+      @status_file.update
+    end
+
+    def update_htmlfiles_subtarget(subtarget, src_fpath)
+      dest_fpath = prepare_new_write_path(@env.absolutepath_root, subtarget.filedir.html_input)
+      unless dest_fpath
+        dir = File.dirname(subtarget.filedir.html_input)
+        path = File.join(@env.absolutepath_root, dir)
+        @mes.exc_make_directory(path) { FileUtils.mkdir_p(path) }
+        dest_fpath2 = prepare_new_write_path(@env.absolutepath_root, subtarget.filedir.html_input)
+        if dest_fpath2
+          dest_fpath = dest_fpath2
+        else
+          @mes.output_fatal("Can't find dest dir(#{path})")
+          exit(@mes.ec("EXIT_CODE_CANNOT_FIND_DEST_DIR"))
+        end
+      end
+
+      @mes.exc_file_copy(src_fpath, dest_fpath) { FileUtils.cp(src_fpath, dest_fpath) }
+      @mes.output_info("HtmlUtils.divideHtml dest_fpath=#{dest_fpath}")
+      ary = HTMLUtils.new(dest_fpath, @mes).divide_html
+      dir = File.dirname(dest_fpath)
+      (0..2).each do |x|
+        ofname = File.join(dir, %Q(#{x}.html))
+        @mes.exc_file_write(ofname) { File.open(ofname, "w") {|f| f.puts(ary[x]) } }
+      end
+      in_html = File.join(dir, %Q(1.html))
+      unless File.exist?(in_html)
+        @mes.output_fatal("Can't find file(=#{in_html}")
+        exit(@mes.ec("EXIT_CODE_CANNOT_FIND_FILE"))
+      end
+      out_md = prepare_new_write_path(@env.absolutepath_root, subtarget.filedir.input_md)
+      simple_html2md(in_html, out_md)
+
+      path = File.join(@env.absolutepath_root, subtarget.workDir)
+      @mes.exc_make_directory(subtarget.workDir) { FileUtils.mkdir_p(path) }
+    end
+
+    def update_htmlfiles
+      if @status_file.nil? || @status_file.last_contents_path.nil? || @status_file.last_contents_path.empty?
+        @mes.output_info("@status_file=#{@status_file}")
+        unless @status_file.nil?
+          @mes.output_info("@status_file.last_contents_path=#{@status_file.last_contents_path}")
+        end
+        exit(@mes.ec("EXIT_CODE_EXECUTE_SETUP_BEFORE_UPDATE_HTMLFILES"))
+      else
+        @category.each do |_name, category_struct|
+          category_struct.subTargets.each do |_k, v|
+            next unless v.aliashtmlfile.empty?
+            filename = v.htmlfile
+            next if filename.empty?
+
+            src_fpath = File.join(@status_file.last_contents_path, filename)
+            unless File.exist?(src_fpath)
+              @mes.output_info("#{src_fpath} doesn't exist")
+              next
+            end
+            update_htmlfiles_subtarget(v, src_fpath)
+          end
+        end
+      end
+    end
+
+    def simple_html2md(input_htmlfname, outputmd)
+      ret = false
+      _, _, s = Open3.capture3(%Q(pandoc -o #{outputmd} -t markdown #{input_htmlfname}))
+
+      if s.exited?
+        if s.exitstatus == 0
+          ret = true
+        else
+          @mes.output_error("Can't convert from html to md by pandoc(IN:#{input_htmlfname} OUT:#{outputmd}(exit_code=#{s.exitstatus})")
+          exit(@mes.ec("EXIT_CODE_CANNOT_CONVERT_FROM_HTML_TO_MD"))
+        end
+      else
+        @mes.output_error("Pandoc exit abnormally")
+        exit(@mes.ec("EXIT_CODE_PANDOC_EXIT_ABNORMALLY"))
+      end
+
+      ret
+    end
+  end
+end