up.yml

version: 1.0.0

vars:
  cached_functests_dir: ./build/functests
  cached_modtests_dir: ./build/modtests
  cases_dir: ./build/cases
  log_dir: ./reflogs
  content_dir: ./content
  content_src_dir: ./content-src
  charpter_file: /tmp/chap

dvars:
  - name: upproj_dir
    desc: default to use project build path else use the mockup testing path
    value: '{{ env "UP_PROJ_DIR" |default "/up_project/up" }}'
    flags: [vvv]

  - name: src_functests_dir
    value: '{{.upproj_dir}}/tests/functests'

  - name: src_modtests_dir
    value: '{{.upproj_dir}}/tests/modtests'

  - name: ref_dir
    value: '{{.cached_functests_dir}}'

  - name: rendered_log_dir
    value: '{{.cases_dir}}/logs'

  - name: rendered_module_log_dir
    value: '{{.content_dir}}/logs'


notes:
  - data_format:
      - page_nav_structure: |
          ~SubStep1: [printObj:  ]
            loopitem: {
              "data-nav-id": "/loop/",
              "tag": "li",
              "title": "loop",
              "children": {
                {
                  "text": "loop",
                  "href": "/loop/",
                  "tag": "a"
                },
                  {
                  "tag": "ul",
                  "children": {
                    {
                      "class": "dd-item ",
                      "data-nav-id": "/loop/c0090/",
                      "tag": "li",
                      "title": "loopitem in dvar",
                      "children": {
                        {
                          "href": "/loop/c0090/",
                          "tag": "a",
                          "text": "loopitem in dvar"
                        }
                      }
                    },
                      ...................

tasks:

  -
    name: Gen_user_manual
    desc: build chapters index
    task:
      -
        func: shell
        vars:
          page: /tmp/tmp.html
        do:
          - 'curl https://upcmd.netlify.app/usage/ -o {{.page}}'
          - |
            cat {{.page}} |pup '#sidebar > div.highlightable.ps-container.ps-theme-default > ul > li json{}'
            rm -f {{.charpter_file}}

        reg: result

      - func: cmd
        dvars:
          - name: page_json
            value: '{{ .result.Output }}'
            flags:
              - toObj
              - taskScope
        do:
          - name: printObj
            cmd: page_json_object

      - func: cmd
        dox:
          -
            name: inspect
            cmd:
              - exec_vars


      - func: block
        loop: 'page_json_object'
        do:
          - func: block
            if: '{{ne (index .loopitem "data-nav-id") "/logs/"}}'
            dvars:
              - name: charpters
                value: |
                  ### Chapter {{add .loopindex 1}} [{{- .loopitem.title}}]({{index .loopitem "data-nav-id" -}})
                  {{ print "" }}
                  {{- range $idx,$subitem :=.loopitem.children }}
                    {{- if eq $idx 1 }}
                      {{- range $id,$subchap := $subitem.children }}
                    {{add $id 1}}. [{{- $subchap.title }}]({{index $subchap "data-nav-id" -}})
                      {{- end}}
                    {{- end}}
                  {{- end}}
            do:
              - func: shell
                do: |
                  echo """{{.charpters}}"""
                  echo """{{.charpters}}""" >> {{.charpter_file}}

          - func: shell
            do: |
              cat {{.charpter_file}}

          - func: cmd
            do:
              -
                name: template
                desc: render charpters
                cmd:
                  src: ./templates/home_page.template
                  dest: '{{.content_src_dir}}/_index.md'

  -
    name: facts
    desc: gather facts
    task:
      -
        func: shell
        do:
          - uname
        reg: result

      - func: cmd
        desc: get os  - [Darwin | Linux]
        dvars:
          - name: os
            value: '{{ .result.Output }}'
            flags:
              - v
        do:
          - name: print
            cmd: 'OS: {{.os}}'
          - name: return
            cmd:
              - os

  -
    name: testingWarning
    desc: it should warn if the build task is for testing only
    task:
      - func: block
        do:
          - func: cmd
            do:
              - name: print
                cmd: 'building OS: {{.os}}'
              - name: colorPrint
                cmd:
                  msg: ?? WARN - This is a build for testing purpose only. Enter to continue!
                  fg: red
              - name: pause
        if: '{{ eq .os "Darwin" }}'

  -
    name: Build
    desc: build the showcases automatically
    task:

      - func: call
        do:
          - facts
          - testingWarning

      -
        func: shell
        desc: prepare all the self documented cases
        do:
          - 'rm -rf {{.content_dir}}'
          - 'mkdir -p {{.content_dir}}'
          - rm -rf ./build
          - mkdir -p ./build
          - 'cp -rf {{.src_functests_dir}} {{.cached_functests_dir}}'
          - 'cp -rf {{.src_modtests_dir}} {{.cached_modtests_dir}}'

      -
        func: shell
        desc: prepare the directory for the already documented cases
        do:
          - rm -rf {{.cases_dir}}
          - mkdir -p {{.cases_dir}}
          - mkdir -p {{.rendered_log_dir}}

      -
        func: call
        desc: build different types of cases of functests
        do:
          - process_main_entry
        loop:
          - c????
          - f????

      -
        func: shell
        desc: copy generated docs to publish dir
        do:
          - 'cp -rf {{.cases_dir}}/* {{.content_dir}}/'
          - 'cp -rf {{.content_src_dir}}/* {{.content_dir}}/'
          - 'rm -rf static/reflogs'
          - 'cp -rf {{.log_dir}} static/'

      -
        func: cmd
        dox:
          - name: exit

      -
        func: call
        desc: build doc for module tests
        do:
          - process_module_docs
        loop:
          - ????
          - f????

      -
        func: shell
        desc: restart hugo
        do:
          - kill `ps -ef|grep hugo|grep -v grep|tail -1|awk '{print $2}'`
        if: '{{ eq .os "Darwin" }}'

  -
    name: process_module_docs
    task:

      -
        func: shell
        desc: |
          get mod tests dirs
          ./0001
          ......
        do:
          - 'cd {{.cached_modtests_dir}}; find . -name "{{.loopitem}}" -maxdepth 1 -mindepth 1 -type d|sort|cut -d\/ -f2'
        reg: cases

      - func: cmd
        desc: debug
        dox:
          -
            name: print
            cmd: '{{.cases.Output}}'

      - func: cmd
        desc: get the case list object
        dvars:
          - name: void
            value: '{{ .cases.Output | splitLines |reg "caselist" }}'

      - func: cmd
        do:
          - name: print
            cmd: 'caselist: {{.caselist}}'

      - func: call
        do: process_each_module_case
        loop: caselist

  -
    name: process_each_module_case
    task:
      - func: cmd
        varsfile: 'doc.yml'
        refdir: '{{.cached_modtests_dir}}/{{.loopitem}}'
        dvars:
          - name: modcase
            value: '{{.loopitem}}'
            flags:
              - taskScope
        do:
          - name: print
            cmd: 'case dir: {{.modcase}}'

          -
            name: inspect
            desc: the vars in caller after invoking module task
            cmd:
              - exec_vars

          -
            name: template
            desc: render module test doco
            cmd:
              src: ./templates/module.template
              dest: '{{.content_dir}}/module/{{.modcase}}.md'

      -
        func: call
        name: loop_verbose_level
        desc: loop all different verbose level caller
        do: generate_module_log_pages
        loop:
          - v
          - vv
          - vvv
          - vvvv
          - vvvvv

  -
    name: generate_module_log_pages
    desc: generage verbose level log
    task:
      -
        func: cmd
        dvars:
          - name: logidinumber
            value: '{{ substr 1 5 .modcase | atoi |mul 100| add 100000 |add .loopindex }}'
            flags: [vvv,]

          - name: logtemplate
            value: |
              title: {{.modcase}}_{{.loopitem}}
              weight: {{.logidinumber}}
              loglevle: {{.loopitem}}
              casename: "m{{.modcase}}"
              relatedlink: ../../module/{{.modcase}}
              log_ref_file: {{.log_dir}}/m{{.modcase}}_{{.loopitem}}.log
            flags:
              - toObj
              - vvvvv
        do:
          - name: print
            cmd: '{{.logtemplate}}'
          - name: print
            cmd: '{{.loopitem}}'

          - name: template
            desc: generate the log
            cmd:
              src: ./templates/log.template
              dest: '{{.rendered_module_log_dir}}/m{{.modcase}}_{{.loopitem}}.md'
              datakey: logtemplate_object

  -
    name: process_main_entry
    task:
      -
        func: shell
        desc: prepare all the self documented cases
        do:
          - 'cd {{.cached_functests_dir}}; ls {{.loopitem}}.yml'
        reg: cases

      - func: cmd
        desc: debug
        dox:
          -
            name: print
            cmd: '{{.cases.Output}}'

      - func: cmd
        desc: get the case list object
        dvars:
          - name: void
            value: '{{ .cases.Output | splitLines |reg "caselist" }}'

      -
        func: call
        desc: filter out all cases have already got documents
        do:
          - process_case
        loop: "caselist"

  -
    name: process_case
    task:

      -
        func: cmd
        do:
          - name: reg
            cmd:
              name: casefilename
              value: '{{.loopitem}}'

          - name: reg
            cmd:
              name: casename
              value: '{{.casefilename | replace ".yml" ""}}'

          - name: print
            cmd: 'processing {{.casefilename}}'

          - name: readFile
            desc: read yml file
            cmd:
              filename: '{{.casefilename}}'
              dir: '{{.cached_functests_dir}}'
              reg: caseyml

          - name: print
            cmdx: |
              yml file content:
              {{.caseyml}}

          - name: query
            cmd:
              ymlkey: caseyml
              path: doc_meta.
              reg: docyml
            flags:
              - ymlOnly

      -
        func: call
        desc: add casename and log_dir into data model
        do: data_enrich
        if: '{{ gt (.docyml|len) 0 }}'

      -
        func: cmd
        do:

          - name: readFile
            desc: review if the file content is correct
            cmdx:
              filename: '{{.casefilename}}'
              dir: '{{.ref_dir}}'
              reg: debug_yml

          - name: print
            cmdx: |
              debug filename: {{.casefilename}}
              debug dir: {{.ref_dir}}
              content before change:
              ---
              {{.debug_yml}}
              ---

          - name: ymlDelete
            cmd:
              ymlfile: '{{.casefilename}}'
              refdir: '{{.ref_dir}}'
              path: doc_meta
            flags:
              - inplace

          - name: ymlDelete
            cmd:
              ymlfile: '{{.casefilename}}'
              refdir: '{{.ref_dir}}'
              path: notes
            flags:
              - inplace

          - name: readFile
            desc: review if the file content is correct
            cmd:
              filename: '{{.casefilename}}'
              dir: '{{.ref_dir}}'
              reg: final_yml

          - name: print
            desc: show the modified yml content
            cmdx: '{{.final_yml}}'

          - namex: exit

      -
        func: cmd
        dvars:
          - name: casedoc
            value: '{{.docyml}}'
            ex pand: 2
            flags: [toObj, reg]

      -
        func: call
        desc: create sub folders and template the docment
        do: generate_doc
        if: '{{ gt (.casedoc|len) 0 }}'

  -
    name: data_enrich
    task:
      - func: cmd
        do:
          - name: ymlWrite
            cmd:
              ymlstr: '{{.docyml}}'
              path: casename
              value: '{{.casename}}'
              reg: docyml
          - name: ymlWrite
            cmd:
              ymlstr: '{{.docyml}}'
              path: ref_dir
              value: '{{.ref_dir}}'
              reg: docyml
          - name: ymlWrite
            cmd:
              ymlstr: '{{.docyml}}'
              path: main_yml_ref_file
              value: '{{.ref_dir}}/{{.casefilename}}'
              reg: docyml
          - name: ymlWrite
            cmd:
              ymlstr: '{{.docyml}}'
              path: main_log_ref_file
              value: '{{.log_dir}}/{{.casename}}_vvv.log'
              reg: docyml

          - name: query
            cmd:
              ymlkey: docyml
              reg: weightstr
              path: weight.
            flags:
              - ymlOnly

          - name: print
            cmd: |
                existing weight: {{.weightstr}}
                weight string length: {{.weightstr|len}}

      - func: cmd
        do:
          - name: print
            cmd: 'setup weight'

          - name: ymlWrite
            cmd:
              ymlstr: '{{.docyml}}'
              path: weight
              value: '{{ substr 1 5 .casename | atoi |mul 10| add 100 }}'
              reg: docyml
        if: '{{ eq (print .weightstr|len) 0 }}'

      - func: cmd
        do:

#          - name: ymlWrite
#            cmd:
#              ymlstr: '{{.docyml}}'
#              path: page_weight
#              value: '{{ .casename |replace "c" "" |atoi}}'
#              reg: docyml
#          - name: ymlWrite
#            cmd:
#              ymlstr: '{{.docyml}}'
#              path: log_dir
#              nodevalue: '{{.log_dir}}'
#              reg: docyml

          - name: print
            cmdx: |
              ---------- docyml content---------
              {{.docyml}}

          - name: return
            cmd:
              - docyml

#          - name: exit
  -
    name: generate_doc
    task:

#      - func: shell
#        do:
#          - 'echo  "casename: {{.casename}} - folder: {{.casedoc_object.folder}}" >> debug'

      - func: cmd
        do:
          - name: reg
            cmd:
              name: target_dir
              value: '{{.cases_dir}}/{{.casedoc_object.folder}}'
#          - name: trace
#            cmd: debug ==>


#      - func: shell
#        do:
#          - 'echo  "casename: {{.casename}} - target: {{.target_dir}}" >> debug'

#      - func: cmd
#        do:
#          - name: trace
#            cmd: <== debug

      - func: shell
        do:
          - 'mkdir -p {{.target_dir}}'

      -
        func: cmd
        desc: debug and exit
        dox:
          - name: printObj
            cmd: casedoc_object
#          - name: exit
        if: '{{eq .casename "c0009"}}'

      -
        func: cmd
        desc: generate the document
        do:
          - name: printObj
            cmdx: casedoc_object

          - name: print
            desc: casedoc length
            cmd: '{{ .casedoc|len }}'

          - name: template
            desc: template the document
            cmd:
              src: ./templates/doc.template
              dest: '{{.target_dir}}/{{.casename}}.md'
              datakey: casedoc_object

      -
        func: call
        name: loop_verbose_level
        desc: loop all different verbose level caller
        do: generate_log_pages
        loop:
          - v
          - vv
          - vvv
          - vvvv
          - vvvvv

  -
    name: generate_log_pages
    desc: generage verbose level log
    task:
      -
        func: cmd
        dvars:
          - name: logidinumber
            value: '{{ substr 1 5 .casename | atoi |mul 10| add 10000 |add .loopindex }}'
            flags: [vvv,]

          - name: logtemplate
            value: |
              title: {{.casename}}_{{.loopitem}}
              weight: {{.logidinumber}}
              loglevle: {{.loopitem}}
              casename: {{.casename}}
              relatedlink: ../../{{.casedoc_object.folder}}/{{.casename}}
              log_ref_file: {{.log_dir}}/{{.casename}}_{{.loopitem}}.log
            flags:
              - toObj
              - vvvvv
        do:
          - name: print
            cmd: '{{.logtemplate}}'
          - name: print
            cmd: '{{.loopitem}}'

          - name: template
            desc: generate the log
            cmd:
              src: ./templates/log.template
              dest: '{{.rendered_log_dir}}/{{.casename}}_{{.loopitem}}.md'
              datakey: logtemplate_object