caset 1.0.0

data/lib/casetdown/casetcode.rb

@@ -0,0 +1,345 @@
+#coding:utf-8
+
+
+#------------------------------------------------------------------------------
+# 代码块执行引擎与语言适配器
+#------------------------------------------------------------------------------
+module CasetDown
+  module_function
+
+  # 将 HTML 实体转义还原为原始字符。
+  #
+  # 处理 &gt; → > 和 &lt; → < 的转换。
+  #
+  # @param text [String] 包含 &gt;、&lt; 的文本
+  # @return [String] 还原后的原始文本
+  def textchange text
+    text.gsub('&gt;','>').gsub('&lt;','<')
+  end
+
+  # 将输出文本包装为 Markdown 代码块格式。
+  #
+  # 生成格式：```shell\n#output>id\ntext\n```
+  #
+  # @param text [String] 输出内容
+  # @param id [String] 输出标识符
+  # @param tag [String] 标签前缀，默认为 'output'
+  # @return [String] 包装后的 Markdown 代码块字符串
+  def wrap_output text, id, tag='output'
+    output_start = "```shell\n##{tag}>#{id}"
+    output_finish= "```"
+    return [output_start, text, output_finish].join("\n")
+  end
+
+  # 在文本中搜索特定输出标记段落。
+  #
+  # 匹配 ```shell\n#output>id ... ``` 格式的代码块。
+  # 注意：TODO 存在 #output>path 和 #output> path 的识别问题。
+  #
+  # @param text [String] 完整文档文本
+  # @param id [String] 输出标识符
+  # @param tag [String] 标签前缀，默认为 'output'
+  # @return [Array<String>] 匹配到的输出内容列表
+  def search_output text, id, tag='output'
+    # [TODO] REFACTORING for recognition between '#output>path' and '#output> path'
+    output_start = "```shell\n##{tag}>#{id}"
+    output_finish= "```"
+    match = TextAbstract.match_paragraph text, output_start, output_finish
+    return match.map{|m|[output_start, m, output_finish].join}
+  end
+
+  # 从代码块头部魔法注释提取元数据。
+  #
+  # 支持的魔法注释及其含义：
+  #   #src> / #script>     → interpreter（解释器类型）
+  #   #ns> / #namespace>   → namespace（命名空间）
+  #   #conf> / #config>    → config（配置文件）
+  #   #dst> / #target>     → target（目标文件）
+  #   #flow> / #step>      → flow（流程标识）
+  #   #seg> / #segment>    → segment（分段标识）
+  #   #in> / #input>       → input（输入文件）
+  #   #out> / #output>     → output（输出文件）
+  #   #row>                → rows（行范围，支持 ~ 展开为 ..）
+  #   #col>                → cols（列选择，支持 ~ 展开为 ..）
+  #
+  # @param code [Hash] 代码块结构，必须包含 :code 和 :class 键
+  # @option code [String] :code 代码文本内容
+  # @option code [String, Symbol] :class 代码语言类，默认 :default
+  # @return [Array] 元数据数组
+  #   [0] interpreter [String, Symbol] 解释器类型
+  #   [1] namespace [String, Symbol] 命名空间
+  #   [2] config [String, Symbol] 配置文件
+  #   [3] target [String, Symbol] 目标文件
+  #   [4] flow [String, Symbol] 流程标识
+  #   [5] segment [String, Symbol] 分段标识
+  #   [6] input [String, Symbol] 输入文件
+  #   [7] output [String, Symbol] 输出文件
+  #   [8] rows [Array, Symbol] 行范围数组或 :rows
+  #   [9] cols [Array, Symbol] 列选择数组或 :cols
+  def magic_head code
+    states = textchange(code[:code]).split("\n")
+    interpreter = code[:class]
+    script = states.find{|s|s[0..4]=='#src>'||s[0..7]=='#script>'}.to_s.split('>')[1]
+    interpreter = script if script # :default
+
+    namespace = states.find{|s|s[0..3]=='#ns>'||s[0..10]=='#namespace>'}.to_s.split('>')[1] || :ns
+    config = states.find{|s|s[0..5]=='#conf>'||s[0..7]=='#config>'}.to_s.split('>')[1] || :conf
+    target = states.find{|s|s[0..4]=='#dst>'||s[0..7]=='#target>'}.to_s.split('>')[1]
+
+    flow = states.find{|s|s[0..5]=='#flow>'||s[0..5]=='#step>'}.to_s.split('>')[1] || :flow
+    segment = states.find{|s|s[0..4]=='#seg>'||s[0..8]=='#segment>'}.to_s.split('>')[1] || :seg
+
+    input = states.find{|s|s[0..3]=='#in>'||s[0..6]=='#input>'}.to_s.split('>')[1] || :in
+    output = states.find{|s|s[0..4]=='#out>'||s[0..7]=='#output>'}.to_s.split('>')[1] || :out
+
+    [interpreter, namespace, target, flow, segment, input, output].each{|tag|tag.strip! if tag.instance_of?(String)}
+
+    rows = if row = states.find{|s|s[0..4]=='#row>'}.to_s.split('>')[1]
+      row.gsub('~','..').split(',').map{|r|eval(r)}
+    else
+      :rows
+    end
+    cols = if col = states.find{|s|s[0..4]=='#col>'}.to_s.split('>')[1]
+      col.split(',').map{|c|
+        c.split('').inject(true){|f,chr|
+          f&&(('0'..'9').to_a+['-','~']).include?(chr)
+        } ? eval(c.gsub('~','..')) : c.strip
+      }
+    else
+      :cols
+    end
+
+    return interpreter, namespace, config, target, flow, segment, input, output, rows, cols
+  end
+
+  # 从文档中提取所有代码块，按元数据分组为哈希表。
+  #
+  # 过滤掉魔法注释行，只保留实际代码内容。
+  #
+  # @param cds [Hash] 解析结果，包含文档结构
+  # @return [Hash] 代码块映射表
+  #   键：[object_id, interpreter, namespace, config, target, [rows, cols], flow, segment, input, output]
+  #   值：String 代码内容（已过滤魔法注释）
+  def search_codes cds
+    codes = CasetDown::Check.all(cds).select{|cd|cd[:name]=='code'}
+
+    table = codes.inject({}) do|table, code|
+      interpreter, namespace, config, target, flow, segment, input, output, rows, cols = magic_head code
+
+      content = textchange(code[:code]).split("\n")[1..-1].select{|s|
+        !['#ns>','#in>'].include?(s[0..3]) &&
+        !['#out>','#src>','#dst>','#seg>','#row>','#col>'].include?(s[0..4]) &&
+        !['#flow>','#step>','#conf>'].include?(s[0..5]) &&
+        !['#input>'].include?(s[0..6]) &&
+        !['#script>','#target>','#output>','#config>'].include?(s[0..7]) &&
+        !['#segment>'].include?(s[0..8]) &&
+        !['#namespace>'].include?(s[0..10])
+      }.join("\n")
+      table[[code.object_id, interpreter, namespace, config, target, [rows,cols], flow, segment, input, output]] = content
+      table
+    end
+    return table
+  end
+
+  # 执行文档中所有代码块，支持多种编程语言。
+  #
+  # 支持解释器：shell/bash, ruby, erlang/erl, python3/python, lms, lmx
+  # 全局配置按代码块顺序累积生效（$_tmp_global_）。
+  #
+  # @param cds [Hash] 解析结果
+  # @return [Hash] 执行结果映射
+  #   键：input [String, Symbol] 输入标识
+  #   值：running_output [String] 代码执行输出
+  # @note Windows 平台（mingw）shell 执行暂为空实现
+  def run cds
+    table = CasetDown.search_codes(cds)
+    $_tmp_global_ = {}
+    $_scr_head_ = ['#coding:utf-8','require "casetdown"'].join("\n")
+    result = {}
+    table.each do|key, text|
+      oid, interpreter, ns, conf, target, range, flow, seg, input, output = key
+      unless conf==:conf # 注意全局配置累积生效，所以有先后顺序
+        $_tmp_global_.merge!(
+          (File.exist?(conf)           ? YAML.load(File.read conf)           : {}) ||
+          (File.exist?("#{conf}.yml")  ? YAML.load(File.read "#{conf}.yml")  : {}) ||
+          (File.exist?("#{conf}.yaml") ? YAML.load(File.read "#{conf}.yaml") : {})
+        )
+        $_scr_tail_ = "\n__END__\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}"
+        $_erl_tail_ = $_tmp_global_.empty? ? '' : ToErlang.fact('global', (ToErlang.hash($_tmp_global_)) )
+      end
+      if interpreter=='shell' || interpreter==:default
+        if RUBY_PLATFORM.include?('mingw')
+        else
+          File.write "./~tmp.sh",text
+          running = `bash ./~tmp.sh`
+          File.delete "./~tmp.sh"
+        end
+      elsif interpreter=='ruby'
+        File.write "./~tmp.rb","#{$_scr_head_}\n\n#{text}\n\n#{$_scr_tail_}"
+        running = `ruby -I"#{CasetDown.home}" ./~tmp.rb`
+        File.delete "./~tmp.rb"
+      elsif interpreter=='erlang' || interpreter=='erl'
+        File.write "./_tmp.erl","-module(_tmp).\n-export([main/1]).\n\n#{text}\n\n#{$_erl_tail_}\n\nfact(UnknownMessage)->\n  io:format(\"~p\",[UnknownMessage])."
+        running = `escript ./_tmp.erl`
+        File.delete "./_tmp.erl"
+      elsif interpreter=='python3' || interpreter=='python'
+        File.write "./~tmp.py",text
+        running = `python ./~tmp.py`
+        File.delete "./~tmp.py"
+      elsif interpreter=='lms'
+        running = `lms "#{text}"`
+      elsif interpreter=='lmx'
+        running = `lmx "#{text}"`
+      else
+      end
+      result[input] = running
+    end
+    return result
+  end
+
+  # 执行代码块并将结果回写到 Markdown 文档。
+  #
+  # 支持将执行结果替换回原始文档中的 #output 标记位置。
+  #
+  # @param cds [Hash] 解析结果
+  # @param option [Hash] 控制选项
+  # @option option [String] :stream 覆盖原始文档文本
+  # @option option [String] :data 附加到 Ruby 脚本尾部（$_scr_tail_）
+  # @option option [String] :fact 附加到 Erlang 脚本尾部（$_erl_tail_）
+  # @option option [Array<Symbol>] :file 文件控制标志
+  #   - :input    保存输入脚本到文件
+  #   - :output   保存执行输出到文件
+  #   - :all      保存输入和输出
+  #   - :debug    保留临时文件不删除
+  #   - :rendfile 保存为带时间戳的新文件
+  #   - :preview  保存为 preview 版本文件
+  # @return [String] 回写后的完整文档文本
+  # @note :file 为 [] 时只执行不保存文件
+  def run_to_file cds,option={stream: nil, data: nil, fact: nil,file:[]} # empty, :input, :output, :all
+    $_tmp_global_ = {}
+    $_scr_head_ = ['#coding:utf-8','require "casetdown"'].join("\n")
+    $_scr_tail_ = option[:data] ? option[:data] : ''
+    $_erl_tail_ = option[:fact] ? option[:fact] : ''
+
+    table = CasetDown.search_codes(cds)
+    result = {}
+    table.each do|key, text|
+      oid, interpreter, ns, conf, target, range, flow, seg, input, output = key
+      unless conf==:conf # 注意全局配置累积生效，所以有先后顺序
+        $_tmp_global_.merge!(
+          (File.exist?(conf)           ? YAML.load(File.read conf)           : {}) ||
+          (File.exist?("#{conf}.yml")  ? YAML.load(File.read "#{conf}.yml")  : {}) ||
+          (File.exist?("#{conf}.yaml") ? YAML.load(File.read "#{conf}.yaml") : {})
+        )
+        $_scr_tail_ = $_scr_tail_.empty? ? "\n__END__\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}" : "#{$_scr_tail_}\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}"
+        $_erl_tail_ = $_tmp_global_.empty? ? $_erl_tail_ : $_erl_tail_+"\n\n"+ToErlang.fact('global', (ToErlang.hash($_tmp_global_)) )
+      end
+      if interpreter==:default
+        # NOTHING
+      elsif interpreter=='shell' || interpreter=='bash'
+        if RUBY_PLATFORM.include?('mingw')
+        else
+          File.write "./~tmp.sh",text
+          running = `bash ./~tmp.sh`
+          File.delete "./~tmp.sh" unless option[:file].include?(:debug)
+        end
+      elsif interpreter=='ruby'
+        File.write "./~tmp.rb","#{$_scr_head_}\n\n#{text}\n\n#{$_scr_tail_}"
+        running = `ruby -I"#{CasetDown.home}" ./~tmp.rb`
+        File.delete "./~tmp.rb" unless option[:file].include?(:debug)
+      elsif interpreter=='erlang' || interpreter=='erl'
+        File.write "./_tmp.erl","-module(_tmp).\n-export([main/1]).\n\n#{text}\n\n#{$_erl_tail_}\n\nfact(UnknownMessage)->\n  io:format(\"~p\",[UnknownMessage])."
+        running = `escript ./_tmp.erl`
+        File.delete "./_tmp.erl" unless option[:file].include?(:debug)
+      elsif interpreter=='python3' || interpreter=='python'
+        File.write "./~tmp.py",text
+        running = `python ./~tmp.py`
+        File.delete "./~tmp.py" unless option[:file].include?(:debug)
+      elsif interpreter=='lms'
+        running = `lms "#{text}"`
+      elsif interpreter=='lmx'
+        running = `lmx "#{text}"`
+      else
+      end
+      result[input] = running
+      File.write input, text if !(option[:file] & [:input, :all]).empty? && input.instance_of?(String)
+    end
+
+    origin_text = option[:stream] || cds[:doc].text
+    result.each do|input, running| # input == output
+      File.write input, running if !(option[:file] & [:output, :all]).empty? && input.instance_of?(String)
+      origins = CasetDown.search_output(origin_text, input)
+      wrapped = CasetDown.wrap_output(running,input)
+      if origins.empty?
+        origins = CasetDown.search_output(origin_text, input, 'out')
+        wrapped = CasetDown.wrap_output(running,input, 'out')
+      end
+      origins.each do|origin|
+        # [TODO] 无法解决不同后缀的前置匹配替换问题，待修复
+        origin_text = origin_text.gsub(origin, wrapped)
+      end
+    end
+
+    if option[:file].include?(:rendfile)
+      if option[:file].include?(:preview)
+        prvw = cds[:path].split('.')
+        prvw.insert(-2,'preview')
+        File.write prvw.join('.'), origin_text
+      else
+        pazz = cds[:path].split('.')
+        pazz.insert(-2,Time.new.strftime("%Y%m%d%H%M%S"))
+        File.write pazz.join('.'), origin_text
+      end
+    end
+    return origin_text
+  end
+end
+
+# Erlang 数据格式生成模块
+module ToErlang
+	module_function
+
+  # 将二维数据转换为 Erlang 列表记录格式。
+  #
+  # 第一行作为字段名，后续行作为数据。
+  # 每个字段生成 {"field", "value"} 元组，每行生成 {..., ...} 元组。
+  #
+  # @param data [Array<Array>] 二维数据，第一行为字段名
+  # @return [String] Erlang 列表字符串
+  # @example
+  #   ToErlang.table([["name", "age"], ["Alice", "30"]])
+  #   # => "[{{\"name\", \"Alice\"}, {\"age\", \"30\"}}]"
+  def table data
+		fields = data.first
+		erlang_data = data.drop(1).map do |row|
+			row_data = fields.zip(row).map do |field, value|
+				"{\"#{field}\", \"#{value}\"}"
+			end.join(",")
+			"{#{row_data}}"
+		end
+		"[#{erlang_data.join(", ")}]"
+	end
+
+  # 将 Hash 转换为 Erlang 键值列表格式。
+  #
+  # @param data [Hash] 键值对数据
+  # @return [String] Erlang 键值列表字符串
+  # @example
+  #   ToErlang.hash({name: "Alice", age: 30})
+  #   # => "{{\"name\", \"Alice\"}, {\"age\", \"30\"}}"
+  def hash data
+    "{"+data.map{|k,v|"{\"#{k}\", \"#{v}\"}"}.join(",")+"}"
+  end
+
+  # 生成 Erlang fact 函数子句。
+  #
+  # @param name [String, Symbol] 函数名
+  # @param body [String] 函数体
+  # @return [String] Erlang 函数子句代码
+  # @example
+  #   ToErlang.fact("global", "{\"key\", \"value\"}")
+  #   # => "fact(\"global\")->\n  {\"key\", \"value\"};"
+	def fact name, body
+		"fact(\"#{name.to_s}\")->\n  #{body};"
+	end
+end

data/lib/casetdown/casetdoc.rb

@@ -0,0 +1,241 @@
+#coding:utf-8
+
+#------------------------------------------------------------------------------
+# 文档结构检查与解析
+#------------------------------------------------------------------------------
+module CasetDown
+  module Check
+    module_function
+
+    # 遍历文档所有节点，按类型分发到各检查方法，收集并返回结果。
+    #
+    # 会依次调用 head, table, para, pre, list, quote 等方法处理每个节点。
+    #
+    # @param cds [Hash] 解析结果，必须包含 :src 键（Script 实例）
+    # @return [Array<Hash>] 所有节点解析后的结构化数据列表
+    # @example
+    #   cds = CasetDown.load("example.md")
+    #   elements = CasetDown::Check.all(cds)
+    def all cds
+      epool = cds[:src].stack.inject([]) do|epool, cd|
+        res = nil
+        [:head, :table, :para, :pre, :list, :quote].each do|tag|
+          res ||= CasetDown::Check.send tag, cd
+        end
+        epool += res.instance_of?(Array) ? res : [res]
+      end.compact
+    end
+
+    # 解析标题节点（h1 ~ h6）。
+    #
+    # 支持内联链接元素（<a> 标签）的提取。
+    #
+    # @param cd [Node] 标题 DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 标签名 'h1' ~ 'h6'
+    #   - :text [String] 标题文本
+    #   - :inline [Array<Hash>] 内联链接元素（可选）
+    # @return [nil] 如果节点不是标题类型
+    def head cd
+      if %w{h1 h2 h3 h4 h5 h6}.include? cd.name
+        unless cd.elements.empty?
+          ha = {name: cd.name, text: cd.attributes[:text], inline: [] }
+          cd.elements.each{|sub|ha[:inline]<<(sub.name=='a' ? a(sub) : {})}
+          ha
+        else
+          {name: cd.name, text: cd.attributes[:text] }
+        end
+      else
+        nil
+      end
+    end
+
+    # 解析表格节点。
+    #
+    # 将表格转换为 head（表头）和 body（数据行）结构。
+    #
+    # @param cd [Node] 表格 DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'table'
+    #   - :head [Array<String>] 表头列名数组
+    #   - :body [Array<Array<String>>] 数据行二维数组
+    # @return [nil] 如果节点不是表格类型
+    def table cd
+      if cd.name=='table'
+        hd = cd.to_doc['table'][1]['thead'][1]['tr'][1..-1].map{|th|th['th'][0][:text].strip}
+        bd = cd.to_doc['table'][2]['tbody'][1..-1].map{|tr|tr['tr'][1..-1].map{|td|td['td'][0][:text].strip}}
+        {name: 'table', head: hd, body: bd}
+      else
+        nil
+      end
+    end
+
+    # 解析段落节点，支持内联代码、图片、链接元素。
+    #
+    # 段落文本存储在 attributes[:text] 中，内联元素通过子节点遍历提取。
+    #
+    # @param cd [Node] 段落 DOM 节点
+    # @return [Array<Hash>, nil] 段落内容及其内联元素数组
+    #   - 首元素通常为 {name: 'p', text: String}
+    #   - 后续元素为内联的 code, img, a 等
+    # @return [nil] 如果节点不是段落类型
+    def para cd
+      if cd.name=='p'
+        cur = []
+        cur << (cd.attributes[:text] ? {name: 'p', text: cd.attributes[:text]||cd.attributes["text"]} : nil)
+        cd.elements.each do|cs|
+          cur << code(cs)
+          cur << img(cs)
+          cur << a(cs)
+        end
+        return cur
+      else
+        nil
+      end
+    end
+
+    # 解析图片节点。
+    #
+    # @param cd [Node] 图片 DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'img'
+    #   - :src [String] 图片 URL
+    #   - :alt [String] 替代文本
+    # @return [nil] 如果节点不是图片类型
+    def img cd
+      if cd.name=='img'
+        {
+          name: 'img', 
+          src: (cd.attributes['src'] || cd.attributes[:src]), 
+          alt: (cd.attributes['alt'] || cd.attributes[:alt])
+        }
+      else
+        nil
+      end
+    end
+
+    # 解析链接节点。
+    #
+    # @param cd [Node] 链接 DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'a'
+    #   - :href [String] 链接目标 URL
+    #   - :text [String] 链接显示文本
+    # @return [nil] 如果节点不是链接类型
+    def a cd
+      if cd.name=='a'
+        {
+          name: 'a', 
+          href: (cd.attributes['href'] || cd.attributes[:href]), 
+          text: cd.attributes[:text]
+        }
+      else
+        nil
+      end
+    end
+
+    # 解析代码块容器 <pre> 节点。
+    #
+    # 实际调用 code 方法处理内部 <code> 子节点。
+    #
+    # @param cd [Node] <pre> DOM 节点
+    # @return [Hash, nil] code 方法的返回结果
+    # @return [nil] 如果节点不是 <pre> 类型
+    def pre cd
+      if cd.name=='pre'
+        return {
+          name: 'pre',
+          text: cd.to_doc['pre'][0][:text]
+        } if cd.to_doc['pre'][0][:text]
+        return code(cd.elements.first) if cd.elements.first.name=='code'
+      else
+        nil
+      end
+    end
+
+    # 解析内联/块级代码节点。
+    #
+    # @param cd [Node] <code> DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'code'
+    #   - :class [String, Symbol] 代码语言类，默认 :default
+    #   - :code [String] 代码文本内容
+    # @return [nil] 如果节点不是 <code> 类型
+    def code cd
+      if cd.name=='code'
+        {
+          name: 'code', 
+          class: ( 
+            cd.attributes['class'] ? cd.attributes['class'] : 
+            cd.attributes[:class] ? cd.attributes[:class] : 
+            :default
+          ), 
+          code: cd.attributes[:text].strip
+        }
+      else
+        nil
+      end
+    end
+
+    # 解析无序列表节点 <ul> 和 有序列表节点 <ol>。
+    #
+    # 注意：当前仅支持顶层列表，子列表递归处理待实现。
+    # 列表项支持内联的 blockquote、code、img、a 等元素。
+    #
+    # @param cd [Node] <ul> <ol> DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'ul' 'ol'
+    #   - :list [Array<Hash>] 列表项数组，每项包含 :name, :text, :inline
+    # @return [nil] 如果节点不是 <ul> <ol> 类型
+    def list cd
+      # TODO: ONLY TOP LEVEL, PENDING TO RECURSION
+      if cd.name=='ul'
+        subs = cd.elements.inject([]) do|subs, li|
+          sub = {name: 'li', text: (li.attributes[:text] ? li.attributes[:text].strip : li.attributes['text'] ? li.attributes['text'].strip : nil)}
+          li.elements.each do|subsub|
+            sub.merge!(inline: quote(subsub)) if subsub.name=='blockquote'
+            sub.merge!(inline: code(subsub)) if subsub.name=='code'
+            sub.merge!(inline: pre(subsub)) if subsub.name=='pre'
+            sub.merge!(inline: img(subsub)) if subsub.name=='img'
+            sub.merge!(inline: a(subsub)) if subsub.name=='a'
+          end
+          subs << sub
+        end
+        {name: 'ul', list: subs}
+      elsif cd.name=='ol'
+        subs = cd.elements.inject([]) do|subs, li|
+          sub = {name: 'li', text: (li.attributes[:text] ? li.attributes[:text].strip : li.attributes['text'] ? li.attributes['text'].strip : nil)}
+          li.elements.each do|subsub|
+            sub.merge!(inline: quote(subsub)) if subsub.name=='blockquote'
+            sub.merge!(inline: code(subsub)) if subsub.name=='code'
+            sub.merge!(inline: pre(subsub)) if subsub.name=='pre'
+            sub.merge!(inline: img(subsub)) if subsub.name=='img'
+            sub.merge!(inline: a(subsub)) if subsub.name=='a'
+          end
+          subs << sub
+        end
+        {name: 'ol', list: subs}
+      else
+        nil
+      end
+    end
+
+    # 解析引用块 <blockquote>。
+    #
+    # 注意：当前仅支持顶层引用，嵌套处理待实现。
+    #
+    # @param cd [Node] <blockquote> DOM 节点
+    # @return [Hash, nil] 解析结果
+    #   - :name [String] 'blockquote'
+    #   - :quote [String] 引用文本内容
+    # @return [nil] 如果节点不是 <blockquote> 类型
+    def quote cd
+      # TODO: ONLY TOP LEVEL, PENDING TO RECURSION
+      if cd.name=='blockquote' 
+        {name: 'blockquote', quote: cd.to_doc['blockquote'][0][:text].to_s.strip}
+      else
+        nil
+      end
+    end
+  end
+end