caset 1.0.0

data/lib/casetdown/support/simtab.rb

@@ -0,0 +1,372 @@
+#coding:utf-8
+require 'csv'
+
+#------------------------------------------------------------------------------
+# 二维表处理工具（SimTab）
+#------------------------------------------------------------------------------
+# 移植自 imdoc/Tabot/simtab，用于符合人类直觉的二维表处理，方便处理报表。
+#
+# 一般格式是 [[表头], [记录], ...]，所有的操作处理都是针对记录、不针对表头的；
+# 表头的格式由人主观决定，只提供绑定方法。
+#
+# 本模块通过扩展 Array 使任意二维数组获得表格操作能力，
+# casetdown 的表格导入导出（casetable.rb）与脚本数据绑定（EnData）都依赖它。
+#------------------------------------------------------------------------------
+module SimTab
+  ##################################################################
+  # 说明
+  # 这个模块用于符合人类直觉的二维表处理,方便处理报表
+  # 一般格式是 [[表头], [记录], ...]
+  # 所有的操作处理都是针对记录不针对表头的
+  # 表头的格式由人主观决定,只提供绑定方法
+  ##################################################################
+
+  ##################################################################
+  # 读取报表
+  ##################################################################
+
+  # 读取分隔符文本报表为二维表。
+  #
+  # 默认按 Tab 分隔；UTF-8 读取失败时按 GBK 转码重读。
+  #
+  # @param 路径 [String] 报表文件路径
+  # @param 分隔符 [String] 列分隔符，默认 "\t"
+  # @return [Array<Array<String>>] 二维表
+  def self.读取报表 路径,分隔符="\t"
+    begin
+      File.read(路径).gsub("\r","").split("\n").map{|l|l.split(分隔符)}
+    rescue
+      File.read(路径).force_encoding('GBK').encode("UTF-8").gsub("\r","").split("\n").map{|l|l.split(分隔符)}
+    end
+  end
+
+  # 读取 CSV 报表为二维表（UTF-8 优先，GBK 兼容回退，自动剥离 BOM）。
+  #
+  # @param 路径 [String] CSV 文件路径
+  # @param format [Symbol] :raw 原始二维数组 / :csv 带表头解析
+  # @return [Array<Array>] 绑定表头后的二维表
+  def self.读取csv 路径,format=:raw
+    require 'csv'
+    raw = File.binread(路径)
+    raw = raw.sub(/\A\xEF\xBB\xBF/n, '') # 剥离 UTF-8 BOM
+    csv = raw.dup.force_encoding('UTF-8')
+    csv = raw.dup.force_encoding('GBK').encode('UTF-8') unless csv.valid_encoding?
+    content = CSV.parse(csv, headers:(format==:csv))
+    table = content.绑定表头 content[0]
+    return table
+  end
+
+  # 读取 HTML 文档中的表格为二维表。
+  #
+  # 原版基于 Nokogiri；本移植为零依赖实现，使用宽松正则扫描
+  # <table>/<tr>/<td|th> 结构，适用于常规表格型 HTML（含 markdown 渲染产物）。
+  #
+  # @param 文档 [String] HTML 文档文本
+  # @return [Array<Array<String>>] 所有表格行拼接成的二维表
+  def self.读取html 文档
+    table = []
+    文档.scan(/<table[^>]*>(.*?)<\/table>/mi).each do|tmatch|
+      tbody = tmatch[0]
+      tbody.scan(/<tr[^>]*>(.*?)<\/tr>/mi).each do|rmatch|
+        tr = rmatch[0]
+        record = tr.scan(/<(?:td|th)[^>]*>(.*?)<\/(?:td|th)>/mi).map{|c|c[0].gsub(/<[^>]+>/,'').strip}
+        table << record
+      end
+    end
+    return table
+  end
+
+  ##################################################################
+  # 表头
+  # 如果已有表头,只需要'#绑定表头'指定表头即可
+  # 如果没有表头,可以'#表头'自动生成表头,也可以指定'#生成表头'再'#绑定表头'
+  ##################################################################
+
+  # 按当前最大列数自动生成表头（"0","1","2"...），并插入为首行。
+  #
+  # @param 前缀 [String] 表头前缀（历史遗留参数，原实现未使用，保持不动）
+  # @return [Array<String>] 生成的表头
+  def 生成表头 前缀=''
+    max = self.inject(0){|max,item|(max < item.size ? item.size : max)}
+    @表头 = Array.new(max){|i|i.to_s}
+    self.unshift @表头
+    @表头
+  end
+
+  # 绑定表头到当前表，并递归绑定每条记录的内联表头。
+  #
+  # @param 表头 [Array] 表头数组；非数组入参将被忽略
+  # @return [Array] 当前表自身
+  def 绑定表头 表头
+    @表头 = 表头 if 表头.instance_of?(Array)
+    self.each do|记录|
+      记录.绑定表头 表头 if 记录.instance_of?(Array)
+    end
+  end
+
+  # 读取表头；未绑定时自动生成并绑定（注意会修改当前表）。
+  #
+  # @return [Array] 表头
+  def 表头
+    @表头 ||= []
+    if !@表头 or @表头.empty?
+      自定义表头 = 生成表头
+      绑定表头 自定义表头
+    end
+    @表头
+  end
+
+  # 去掉形式上的表头（首行），记录的内联表头保留以便恢复。
+  #
+  # 如想彻底去掉每条记录的表头，可再绑定一个空表头。
+  #
+  # @return [Array] 当前表自身
+  def 去掉表头
+    @表头 = []
+    self.shift
+    self
+  end
+
+  # 展示表头与列号的对应关系（"00: 名称" 每行一条）。
+  #
+  # @return [String] 多行文本
+  def 展示表头
+    索引表 = []
+    @表头.each_with_index{|c,i|索引表 << "#{"%02s"%i}: #{c}"}
+    索引表.join("\n")
+  end
+
+  # 特殊的双层表头，计算时转化为单层（原单层不变）。
+  #
+  # 复合表头形如 ["上层#下层", ...]，双层列表转为 "上层#下层" 单层数组。
+  #
+  # @param 列表 [Array<Array<String>>] 双层表头
+  # @return [Array] 单层复合表头
+  def self.解析双层表头 列表
+    return 列表 unless 列表[0].instance_of?(Array)
+    表头 = []
+    列表[0].each_with_index do|item,index|
+      item=='' and index==0 and head = ''
+      item=='' and index >0 and head = 表头[-1].split("#")[0]
+      item!='' and head = item
+      表头 << [head, 列表[1][index]].join("#")
+    end if 列表.size == 2 && 列表[0].instance_of?(Array)
+    if 列表[0].size < 列表[1].size
+      num = 列表[1].size - 列表[0].size
+      head = 表头[-1].split("#")[0]
+      表头 += 列表[1][-1*num..-1].map{|i|"#{head}##{i}"}
+    end
+    return 表头
+  end
+
+  # 特殊的双层表头，输出前转化为多层（原单层不变）。
+  #
+  # @param 列表 [Array<String>] 单层复合表头
+  # @return [Array<Array<String>>] 双层表头
+  def self.生成双层表头 列表
+    表头 = 列表.map{|复合表头|复合表头.split("#")}
+    return [列表] if 表头[0].size==1
+    row1,row2 = [],[]
+    表头.each do|items|
+      row1 << items[0]
+      row2 << items[1]
+    end
+    return [row1,row2]
+  end
+
+  ##################################################################
+  # 查询（行）、选择（列）、排序
+  # 这里的计算结果都是生成新表
+  ##################################################################
+
+  # 按字段值等值查询，生成新表。
+  #
+  # @param 字段 [String] 表头字段名
+  # @param 内容 [String] 期望的字段值
+  # @return [Array<Array>] 查询结果新表（携带表头）
+  def 字段查询 字段,内容
+    索引 = self.表头.index(字段)
+    新表 = [self.表头]+self.select{|c|c[索引]==内容}
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 按 block 条件查询记录，生成新表。
+  #
+  # @yield [记录] 对每条记录求值，真值保留
+  # @return [Array<Array>] 查询结果新表（携带表头）
+  def 查询
+    结果 = []
+    self[1..-1].each do|记录|
+      yield(记录) and (结果.push 记录)
+    end
+    新表 = [self.表头]+结果
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 按 block 生成的键自定义排序，生成新表。
+  #
+  # yield 返回 [键, 逆序标志]，逆序标志为 :reverse 时结果取逆。
+  #
+  # @yield [记录] 返回 [排序键, :reverse或nil]
+  # @return [Array<Array>] 排序结果新表（携带表头）
+  def 自定义排序
+    字典,逆序,counter = {},nil,0
+    self[1..-1].each_with_index do|记录,索引|
+      键,逆序 = yield(记录)
+      字典[键+"_#{"%010d"%counter}"] = 索引+1
+      counter += 1
+    end
+    结果 = 字典.keys.sort.inject([]) do|结果,键|
+      结果 << self[字典[键]]
+      结果
+    end
+    逆序==:reverse and 结果.reverse!
+    新表 = [self[0]]+结果
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 按记录自然顺序排序，生成新表。
+  #
+  # @return [Array<Array>] 排序结果新表（携带表头）
+  def 排序
+    新表 = [self[0]]+self[1..-1].sort
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 记录逆序，生成新表。
+  #
+  # @return [Array<Array>] 逆序新表（携带表头）
+  def 逆序
+    新表 = [self[0]]+self[1..-1].reverse
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 可以使用“.字段(index|"column"|...)”查询，找不到查询名称的场合用名称做占位符。
+  #
+  # 提取若干列：按列号或表头名取列；找不到名称时该列输出字段名本身作占位。
+  # 单字段返回该列数组，多字段返回新表。
+  #
+  # @param 属性表 [Integer, String, ...] 列号或字段名
+  # @return [Array<Array>, Array] 多字段返回新表，单字段返回列数组
+  def 字段 *属性表
+    字段表,新表头 = [],[]
+    属性表.each do|属性|
+      if 索引 = self.表头.index(属性)
+        字段表 << self[索引]
+        新表头 << 属性
+      else
+        字段表 << 属性
+        新表头 << 属性.to_s
+      end
+    end
+    if 字段表.size>1
+      字段表.绑定表头 新表头
+      字段表
+    else
+      字段表[0]
+    end
+  end
+
+  # 列投影：按列号或表头名选择若干列，生成新表（找不到名称的场合用名称做占位符）。
+  #
+  # select 在集合中指选择符合条件的某些元素，在SQL中指投影到具体的列上，
+  # 这里偏向后者，前者可以对应查询。
+  #
+  # @param 字段列表 [Integer, String, ...] 列号或表头名
+  # @return [Array<Array>] 投影结果新表（携带新表头）
+  def 选择 *字段列表 # col_num or 'col_name' or filler
+    字段索引 = 字段列表.map{|f|r = f.instance_of?(Integer) ?  f : self.表头.index(f); r ? r : f }
+    新表头 = 字段列表.map{|f|r = f.instance_of?(Integer) ?  self.表头[f] : f; r ? f : r }
+    新表 = [新表头]+self[1..-1].map{|记录|字段索引.map{|索引|索引.instance_of?(Integer) ? 记录[索引] : 索引}}
+    新表.绑定表头 新表头
+    新表
+  end
+
+  # 笛卡尔拼接两张表（行对行叉积），生成新表。
+  #
+  # @param 另一个表 [Array<Array>] 右表
+  # @return [Array<Array>] 拼接结果新表（携带合并表头）
+  def 拼接 另一个表
+    新表头 = self.表头 + 另一个表.表头
+    新表 = [新表头]+self[1..-1].product(另一个表[1..-1]).map{|t1,t2|t1+t2}
+    新表.绑定表头(新表头)
+    return 新表
+  end
+
+  ##################################################################
+  # 统计
+  ##################################################################
+
+  # 按字段值分组统计，返回 字段值 => 记录数组 的哈希。
+  #
+  # @param 字段 [String] 表头字段名
+  # @return [Hash{String => Array<Array>}] 分组结果
+  def 统计 字段
+    结果 = {}
+    索引 = self[0].index(字段)
+    self[1..-1].each do|记录|
+      结果[ 记录[索引] ] ||= []
+      结果[ 记录[索引] ] << 记录
+    end if 索引
+    结果
+  end
+
+  # 按字段做唯一值/条目数统计，并把结果写入文件。
+  #
+  # 生成 "<路径>/字段唯一统计.txt" 与 "<路径>/字段数值统计/<字段>(<n>).txt"。
+  #
+  # @param 路径 [String] 统计输出目录，默认 '.'
+  # @return [void]
+  def 字段条目数统计 路径='.'
+    字段唯一统计 = []
+    Dir.mkdir(路径) unless File.exist?(路径)
+    self[0].each do|字段|
+      统计表 = self.统计 字段
+      字段数值统计 = []
+      统计表.each do|字段值,条目|
+        字段数值统计 << "#{字段值}\t:\t#{条目.size}"
+      end
+      字段唯一统计 << "#{字段}\t:\t#{统计表.keys.size}"
+      Dir.mkdir("#{路径}/字段数值统计") unless File.exist?("#{路径}/字段数值统计")
+      File.write "#{路径}/字段数值统计/#{字段}(#{统计表.keys.size}).txt", 字段数值统计.join("\n")
+    end
+    File.write "#{路径}/字段唯一统计.txt", 字段唯一统计.join("\n")
+  end
+
+  # 把表格档案化为对象数组（每条记录带 'row' 行号与各字段键值）。
+  #
+  # @return [Array<Hash>] 档案数组
+  def 建立档案
+    文档 = []
+    self[1..-1].each_with_index do|记录,记录索引|
+      record = {'row' => 记录索引+1 }
+      记录.each_with_index do|字段,字段索引|
+        record[ self.表头[字段索引] ] = 字段
+      end
+      文档 << record
+    end
+    return 文档
+  end
+
+  ##################################################################
+  # 排版
+  ##################################################################
+
+  # 以 Tab 连接各列、换行连接各行，展示表格。
+  #
+  # @return [String] 多行文本
+  def 展示列表
+    self.map{|记录|记录.join("\t")}.join("\n")
+  end
+
+end
+
+class Array
+  attr_reader :表头
+  include SimTab
+end

data/lib/casetdown/support/text_abstract.rb

@@ -0,0 +1,124 @@
+#coding:utf-8
+
+#------------------------------------------------------------------------------
+# 文本段落抽取工具（TextAbstract）
+#------------------------------------------------------------------------------
+# 移植自 imdoc/TextUtils/text_abstract，为 casetdown 提供标记段落定位能力：
+# - search_output 依赖 match_paragraph 在文档中查找 "#output>xxx" 代码块
+# - draw_fragments / match_cascade / match_html_tag 保留原模块完整功能
+#
+# 本文件为零依赖纯 Ruby 实现，随 caset gem 一起发布。
+#------------------------------------------------------------------------------
+module TextAbstract
+  module_function
+
+  # 按前置/后置标记抽取文本片段（特定环境遗留方法，不推荐常用）。
+  #
+  # 遇到 pre_flag 匹配行时开始收集，遇到 post_flag 匹配行时结束；
+  # 标记行本身包含在片段内，未闭合的片段追加到上下文。
+  #
+  # @param text [String] 原始文本
+  # @param pre_flag [Regexp] 开始标记（行级正则）
+  # @param post_flag [Regexp] 结束标记（行级正则）
+  # @return [Array<String>] 二元组 [上下文文本, 片段数组]
+  def draw_fragments text,pre_flag,post_flag
+    context,fragments = [],[]
+    temp,flag = "",false
+    text.each_line do|line|
+      if pre_flag.match(line)
+        temp = String.new if flag == false
+        flag = true
+      end
+      if flag == true
+        temp << line # base on line!
+      else
+        context << line
+      end
+      if post_flag.match(line)
+        flag = false
+        fragments << temp
+        temp = String.new
+      end
+    end
+    context << temp if flag == true # exist pre_flag but no post_flag
+    fragments.delete("")
+    return context.join(),fragments
+  end
+
+  # 严格顺序匹配开始/结束标记之间的段落。
+  #
+  # start 和 finish 有严格先后顺序：一段未结束不开启另一段。
+  # 返回匹配到的段落正文数组（不含首尾标记本身）。
+  #
+  # @param text [String] 完整文档文本
+  # @param start [String] 开始标记（严格字符串包含匹配）
+  # @param finish [String] 结束标记（严格字符串包含匹配）
+  # @return [Array<String>] 段落正文列表
+  # @example
+  #   TextAbstract.match_paragraph("```shell\n#out>a\nX\n```", "```shell\n#out>a", "```")
+  #   # => ["\nX\n"]
+  def match_paragraph text,start,finish
+    paragraphs,current_text = [],text.clone
+    until current_text==""
+      return paragraphs unless current_text.include?(start) # 严格匹配开始
+      start_split = current_text.split(start)
+      current_text = start_split[1..-1].join(start)
+      return paragraphs unless current_text.include?(finish) # 严格匹配结束
+      finish_split = current_text.split(finish)
+      context = finish_split[0]
+      current_text = finish_split[1..-1].join(finish)+(text[-1*finish.size..-1]==finish ? finish : "")
+      paragraphs << context
+    end
+    return paragraphs
+  end
+
+  # 可嵌套匹配开始/结束标记，返回树状段落结构。
+  #
+  # start 和 finish 可以嵌套（一个 start/finish 包含在另一个内部），
+  # 但全局上仍保持顺序。返回嵌套数组：字符串为内容，数组为下一层级。
+  #
+  # @param text [String] 完整文档文本
+  # @param start [String] 开始标记
+  # @param finish [String] 结束标记
+  # @return [Array] 树状段落结构
+  def match_cascade text,start,finish
+    paragraphs,current_text = [],text
+    return paragraphs unless text.include?(start) or text.include?(finish)
+    current_pos,parent_pos = paragraphs,[paragraphs]
+    until current_text==""
+      st_pos = (current_text.include?(start) ? current_text.split(start)[0] : current_text).size
+      fn_pos = (current_text.include?(finish) ? current_text.split(finish)[0] : current_text).size
+      if fn_pos==st_pos # 无标志或标志互包含
+        current_pos << current_text
+        current_text = ""
+      end
+      if fn_pos < st_pos # 结束在前
+        csp = current_text.split(finish)
+        current_pos << csp[0]
+        current_pos << finish # 本级完成
+        cur_parent = parent_pos.pop # 取回上一级
+        current_pos = cur_parent # 返回上一级
+        current_text = current_text.sub(csp[0],"").sub(finish,"")
+      end
+      if st_pos < fn_pos # 开始在前
+        csp = current_text.split(start)
+        current_pos << csp[0] unless csp[0]=="" # 本级内容加入
+        current_pos << [start] # 下一级内容加入
+        parent_pos << current_pos # 本级加入上下文
+        current_pos = current_pos[-1]
+        current_text = current_text.sub(csp[0],"").sub(start,"")
+      end
+    end
+    return paragraphs
+  end
+
+  # 匹配 HTML 标签的嵌套结构（<tag ...> ... </tag>）。
+  #
+  # @param html [String] HTML 文本
+  # @param tag [String] 标签名（如 "table"、"div"）
+  # @return [Array] 树状段落结构
+  def match_html_tag html,tag
+    paragraphs = self.match_cascade(html,"<#{tag}","</#{tag}>")
+  end
+
+end

data/lib/casetdown/support/tintext.rb

@@ -0,0 +1,141 @@
+#coding:utf-8
+require 'erb'
+
+#------------------------------------------------------------------------------
+# 模板替换工具（TinText / Tum / Replacement）
+#------------------------------------------------------------------------------
+# 移植自 imdoc/TinText（tintext.rb + tin_text.rb + tum.rb + cache.rb），
+# 为 casetdown 的执行脚本提供轻量模板展开能力：
+#
+#   TinText.instance(raw) 展开两类标记：
+#     ((名称)) / ${名称}  =>  查 Replacement 字典，未命中输出 ((名称)) 原样
+#     <<..>> => <%=..%>，{{..}} => <%..%>，[[..]] => <%..%>..<%end%>
+#
+#   Tum       文本展开方法（repeat / iterate）
+#   Replacement 轻量字典缓存（EnData::ApiRequest.bind 亦会使用）
+#------------------------------------------------------------------------------
+
+# 轻量字典缓存：名称 => 替换文本。
+module Replacement
+  # 初始化（清空）字典。
+  def self.init
+    @dictionary = {}
+  end
+
+  # 重置字典（等价 init）。
+  def self.reset
+    init
+  end
+
+  # 读取替换文本。
+  #
+  # @param index [Object] 名称
+  # @return [String, nil] 替换文本，未初始化时返回 nil
+  def self.[] index
+    @dictionary[index]
+  end
+
+  # 写入替换文本。
+  #
+  # @param index [Object] 名称
+  # @param replacement [String] 替换文本
+  # @return [String] 写入的替换文本
+  def self.[]= index,replacement
+    @dictionary[index]= replacement
+  end
+
+  # 批量合并哈希到字典。
+  #
+  # @param hash [Hash{Object => String}] 名称 => 替换文本
+  # @return [Hash] 合并后的字典
+  def self.merge hash
+    @dictionary.merge! hash
+  end
+end
+
+# TinText 模板展开。
+module TinText
+  # 查字典翻译单个名称，未命中时返回 "((名称))" 原样占位。
+  #
+  # @param word [Object] 名称
+  # @return [String] 替换文本或原样占位
+  def self.translate word
+    unless Replacement[word]==nil
+      return Replacement[word]
+    else
+      return "((#{word}))"
+    end
+  end
+
+  # 展开 ERB 扩展记法：
+  #
+  #   <<..>>          => <%=..%>
+  #   {{..}}          => <%..%>
+  #   [[..\n....]]    => <%..%>..<%end%>
+  #
+  # @param raw [String] 原始文本
+  # @return [String] ERB 源码文本
+  def self.unfolder raw
+    # <<..>> => <%=..%>
+    # {{..}} => <%..%>
+    # [[..\n....]] => <%..%>..<%end%>
+    raw.gsub(/\<\<\s*(.+?)\s*\>\>/,"<%=\\1%>")
+       .gsub(/\{\{\s*(.+?)\s*\}\}/,"<%\\1%>")
+       .gsub(/\{\{\s*(.+?)\s*/,"<%\\1").gsub(/\s*\}\}/,"\\1%>")
+       .gsub(/\[\[\s*(.+?)\s*\n/,"<%\\1%>").gsub(/\]\]/,"<%end%>")
+  end
+
+  # 把 ((名称)) / ${名称} 翻译为 ERB 输出表达式（查 Replacement 字典）。
+  #
+  # @param raw [String] 原始文本
+  # @return [String] ERB 源码文本
+  def self.template raw
+    # ${..} ((...)) => <%=...%>
+    raw.gsub(/\(\(\s*(.+?)\s*\)\)/,"<%=TinText::translate('\\1')%>").gsub(/\$\{\s*(.+?)\s*\}/,"<%=TinText::translate('\\1')%>")
+  end
+
+  # 模板实例化：先模板替换再 ERB 渲染（tag=:pre），或反之（tag=:post）。
+  #
+  # @param raw [String] 原始文本
+  # @param tag [Symbol] :pre 先 ((..)) 后 <<..>>；:post 反序
+  # @return [String] 渲染结果文本
+  def self.instance raw,tag=:pre
+    if tag==:pre
+      a = self.template raw
+      b = ERB.new(a).result
+      c = self.unfolder b
+      ERB.new(c).result
+    else # :post
+      a = self.unfolder raw
+      b = ERB.new(a).result
+      c = self.template b
+      ERB.new(c).result
+    end
+  end
+
+  # template 的短别名。
+  def self.tt raw;self.template raw;end
+  # instance 的短别名。
+  def self.ti fla;self.instance fla;end
+end
+
+# Tum = Text Unfold Method，文本展开方法。
+module Tum
+  # 把语句重复 times 次并逐行拼接。
+  #
+  # @param statement [String] 语句文本
+  # @param times [Integer] 重复次数
+  # @return [String] 多行文本
+  def self.repeat statement, times
+    Array.new(times,statement).join("\n")
+  end
+
+  # 把语句中的 @var 依次替换为 range 各项并逐行拼接。
+  #
+  # @param statement [String] 含 @var 占位的语句
+  # @param range [Enumerable] 取值范围
+  # @return [String] 多行文本
+  def self.iterate statement, range
+    range.collect{|item| statement.gsub("@var",item.to_s) }.join("\n")
+  end
+end

data/lib/casetdown.rb

@@ -0,0 +1,48 @@
+#coding:utf-8
+
+#------------------------------------------------------------------------------
+# casetdown.rb - 入口文件
+#------------------------------------------------------------------------------
+# casetdown：可执行 Markdown 文档框架（caset 的文档执行面）。
+#
+# 依赖说明：
+#   - markdown 解析 / XML 解析 / XLSX 读写  -> gem:manticore-smash (require 'manticore')
+#     （XMLUtils、Tabot(Excel)、rdiscount 的重写版，见 manticore 项目）
+#   - 二维表操作 / 文本段落抽取 / 内嵌数据绑定 / 模板替换
+#     -> lib/casetdown/support/*（随本 gem 自带，零第三方依赖）
+#
+# 引用方式：
+#   require 'casetdown'           # cm / cml 与执行脚本统一走此入口
+#
+# 子模块地图：
+#   casetdown/casetter    文档加载与解析（ReDiscount -> XmlParser）
+#   casetdown/casetdoc    文档结构检查（CasetDown::Check）
+#   casetdown/casetcode   代码块提取与执行引擎（含 ToErlang）
+#   casetdown/casetable   表格导入导出与渲染
+#   casetdown/cli         cm 命令实现
+#   casetdown/live        cml 命令实现（文件监听渲染）
+#   casetdown/support     TextAbstract / SimTab / EnData / TinText / ApiRequest
+#------------------------------------------------------------------------------
+
+require 'manticore'
+
+[
+  'casetdown/support/text_abstract',
+  'casetdown/support/simtab',
+  'casetdown/support/endata',
+  'casetdown/support/tintext',
+  'casetdown/casetter',
+  'casetdown/casetdoc',
+  'casetdown/casetcode',
+  'casetdown/casetable',
+  'casetdown/cli',
+  'casetdown/live'
+].each{|lib|require_relative lib}
+
+begin
+  # EnData::ApiRequest（API-Request 扩展）依赖外部 gem webot（提供 weboot 接口）。
+  # 未安装 webot 时跳过，不影响 cm / cml 与数据绑定主功能。
+  require_relative 'casetdown/support/api_app'
+rescue LoadError
+  # webot 未安装：EnData::ApiRequest 扩展不可用
+end