cc 1.2.1 → 1.4.0

data/text-tools.rb

@@ -0,0 +1,418 @@
+#coding:utf-8
+require 'json'
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'text-tools' # immediately when loading this file
+
+  # 类型操作
+  p "100".int(2), "3.14159".float(3), "0.86".precent, "true".bool
+
+  # 文本操作
+  p "aaabbb".head? "aa"
+  p "cccddd".tail? "dd"
+  p "abcdef" - "c"
+  p "abcdef" / "c"
+  p "abedef".exchange "e", 'z'
+  p "a11111a2222b3333b4444a5555b".match_paragraph('a','b')
+  p "<a>1<a><a>2</a>3</a>".match_xml('a')
+
+  # 列表操作
+  p ['a','b','c'].match(1){|c| c >= 'b'}
+  p ['a','b','c'].catch('d')
+
+  # 树操作
+  p ({a: 1, b: 2} + [1, 3, 5]).keys
+  p ({a: 1}).get :a
+=end
+
+############################################################################################################
+# text-tools —— 文本/列表/树的人类直觉操作扩展（移植自 imdoc/TextUtils/text_mind + text_abstract）        #
+#                                                                                                          #
+# 组成（单一文件自带全部依赖，零第三方依赖）：                                                              #
+#   TextAbstract（模块函数）：draw_fragments / match_paragraph / match_cascade / match_html_tag              #
+#     —— 复杂文本的特征字段摘取与采集（段落/级联/标签结构匹配）                                             #
+#   TextAbstract::Type        -> String   类型转换（int / float / precent / text / bool）                   #
+#   TextAbstract::TextOperator -> String  文本操作（head? / tail? / matches / join / cut / - / / …）        #
+#   TextAbstract::ListOperator -> Array   列表操作（catch / match / sub）                                   #
+#   TextAbstract::TreeOperator -> Hash    树操作（get / set / +）                                           #
+#                                                                                                          #
+# 配套工具：                                                                                               #
+#   text-server.rb —— S 端：命令行启动 HTTP 解析服务（本文件的 HTTP 包装）                                  #
+#   text-client.rb —— C 端：命令行传入解析（本地执行本文件，或 --remote 走 S 端服务）                       #
+############################################################################################################
+
+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>] 段落正文列表
+  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
+
+module TextAbstract
+
+  # 类型操作模块：把字符串按目标类型转换/格式化。
+  module Type
+    # 按进制字符串转整数。
+    #
+    # @param radix [Integer] 进制，默认 10
+    # @return [Integer]
+    def int radix=10
+      self.to_i(radix)
+    end
+
+    # 转浮点并保留 tail 位小数。
+    #
+    # @param tail [Integer] 保留位数，默认 2
+    # @return [Float]
+    def float tail=2
+      self.to_f.round(tail)
+    end
+
+    # 转百分比字符串（乘 100 保留 tail 位 + "%"）。
+    #
+    # @param tail [Integer] 保留位数，默认 2
+    # @return [String]
+    def precent tail=2
+      (self.to_f*100).round(tail).to_s+"%"
+    end
+
+    # 原样或 JSON 化输出。
+    #
+    # @param format [Symbol] :raw 原样 / :meta JSON 编码
+    # @return [String]
+    def text format=:raw
+      return self         if format==:raw
+      return self.to_json if format==:meta
+    end
+
+    # 转布尔：'true'/'false' 按字面，其余按是否为空。
+    #
+    # @return [Boolean]
+    def bool
+      return true   if self.downcase=='true'
+      return false  if self.downcase=='false'
+      return self.empty?
+    end
+  end
+
+  # 文本操作模块：常见文本加工的直觉操作符。
+  module TextOperator
+    # 判断是否以 prefix 开头。
+    #
+    # @param prefix [String] 前缀
+    # @param strip [Boolean] 是否先去除两端空白
+    # @return [Boolean]
+    def head? prefix, strip=false #=> bool
+      left = strip ? self.strip : self
+      left[0..(prefix.length-1)]==prefix
+    end
+
+    # 判断是否以 postfix 结尾。
+    #
+    # @param postfix [String] 后缀
+    # @param strip [Boolean] 是否先去除两端空白
+    # @return [Boolean]
+    def tail? postfix, strip=false #=> bool
+      left = strip ? self.strip : self
+      left[(-1*postfix.length)..-1]==postfix
+    end
+
+    # include? / empty? 由 Ruby 核心提供，不再重复定义。
+
+    # 按模式匹配文本。
+    #
+    # @param pattern [String, Array<String>] 模式：单模式传字符串，多模式传数组
+    # @param mode [Symbol] :one 取首个匹配 / :all 全部匹配 / :union 多模式并集
+    # @return [MatchData, Array]
+    def matches pattern, mode=:one #=> match
+      return self.match(Regexp.new pattern) if mode==:one
+      return self.scan(Regexp.new pattern)  if mode==:all
+      return self.scan(Regexp.union *pattern.map{|pat|Regexp.new(pat)})  if mode==:union
+    end
+
+    # 按前置/后置标记抽行片段（draw_fragments 的字符串包装）。
+    #
+    # @param preflag [Regexp] 开始标记
+    # @param postflag [Regexp] 结束标记
+    # @return [Array<String>] 二元组 [上下文文本, 片段数组]
+    def draw_lines preflag, postflag #=> text, list
+      restext, contexts = TextAbstract.draw_fragments self, preflag, postflag
+    end
+
+    # 严格顺序匹配段落（match_paragraph 的字符串包装）。
+    #
+    # @param start [String] 开始标记
+    # @param finish [String] 结束标记
+    # @return [Array<String>] 段落正文列表
+    def match_paragraph start, finish #=> list
+      paragraphs = TextAbstract.match_paragraph self, start, finish
+    end
+
+    # 可嵌套匹配（match_cascade 的字符串包装）。
+    #
+    # @param start [String] 开始标记
+    # @param finish [String] 结束标记
+    # @return [Array] 树状段落结构
+    def match_cascade start, finish #=> list
+      paragraphs = TextAbstract.match_cascade self, start, finish
+    end
+
+    # 匹配 HTML 标签嵌套结构（match_html_tag 的字符串包装）。
+    #
+    # @param tag [String] 标签名
+    # @return [Array] 树状段落结构
+    def match_xml tag #=> tree
+      document = TextAbstract.match_html_tag self,tag
+    end
+
+    # length / size / strip / lstrip / rstrip 由 Ruby 核心提供。
+
+    # 把后续文本依次拼接在自身后面。
+    #
+    # @param texts [String...] 待拼接文本
+    # @return [String]
+    def join *texts #=> text
+      self+texts.map{|t|t}.join
+    end
+
+    # 按人类直觉截取（1 起数的闭区间，ridx=0 表示取到末尾）。
+    #
+    # @param index1 [Integer] 起始序号（1 起）
+    # @param index2 [Integer] 结束序号，0 表示末尾
+    # @return [String]
+    def cut index1, index2=0 #=> text
+      self[(index1-1)..(index2-1)]
+    end
+
+    # +（拼接）与 *（重复）由 Ruby 核心提供。
+
+    # 从首次出现 text 的位置截断（含 text），未出现则原样返回。
+    #
+    # @param text [String] 截断标记
+    # @return [String]
+    def - text #=> text
+      self.include?(text) ? self.split(text).first : self
+    end
+
+    # 按分隔符切分为列表（即 split 的直觉别名）。
+    #
+    # @param text [String] 分隔符
+    # @return [Array<String>]
+    def / text #=> list
+      self.split(text)
+    end
+
+    # 按模式替换：oldtext 匹配处替换为 newtext，最多 num 次。
+    #
+    # @param text [String] 匹配模式（正则源文本）
+    # @param newtext [String] 替换文本
+    # @param num [Integer, Symbol] 次数上限，:all 表示全部
+    # @return [String]
+    def exchange text, newtext, num=:all #=> text
+      num = 65535 if num==:all
+      count = 0
+      self.gsub(Regexp.new(text)) do |match|
+        count += 1
+        count <= num ? newtext : text
+      end
+    end
+  end
+
+  # 列表操作模块：列表加工的直觉操作符。
+  #
+  # pop/push/shift/unshift/+/-/find/select/filter/map/collect/reduce/inject
+  # 均由 Ruby 核心提供，不再重复定义。
+  module ListOperator
+    # 把自身挂到列表头部，返回新列表。
+    #
+    # @param list [Array] 待挂接的元素序列
+    # @return [Array] 新列表
+    def catch *list #=> list(list)
+      list.unshift(self)
+    end
+
+    # 按条件块检索。
+    #
+    # @param num [Integer, Symbol] 0 只判存在 / 1 取首个 / :all 取全部 / n>1 取前 n 个
+    # @yield [item] 匹配条件
+    # @return [Boolean, Object, Array]
+    def match num=1, &block #=> bool | item | list
+      return self.find(&block).nil?           if num ==0
+      return self.find(&block)                if num ==1
+      return self.select(&block)              if num ==:all
+      return self.select(&block)[0..(num-1)]  if num > 1
+    end
+
+    # 按人类直觉截取（1 起数的闭区间，index2=0 表示取到末尾）。
+    #
+    # @param index1 [Integer] 起始序号（1 起）
+    # @param index2 [Integer] 结束序号，0 表示末尾
+    # @return [Array]
+    def sub index1, index2=0 #=> list
+      self[(index1-1)..(index2-1)]
+    end
+  end
+
+  # 树操作模块：散列表的直觉操作符。
+  #
+  # keys/values/[]/[]= 由 Ruby 核心提供，不再重复定义。
+  module TreeOperator
+    # 取键值（[] 的直觉别名）。
+    #
+    # @param key [Object] 键
+    # @return [Object]
+    def get key #=> item
+      self[key]
+    end
+
+    # 写键值（[]= 的直觉别名）。
+    #
+    # @param key [Object] 键
+    # @param value [Object] 值
+    # @return [Object] 写入的值
+    def set key, value #=> item
+      self[key] = value
+    end
+
+    # 合并树/列表/单值为新树。
+    #
+    # Hash 深合并；Array 按现有最大整数键续排；单值追加为下一个整数键。
+    #
+    # @param oprand [Hash, Array, Object] 待合并对象
+    # @return [Hash] 合并结果新树
+    def + oprand #=> tree
+      index = self.keys.filter{|k|k.instance_of?(Integer)}.max
+      index = index ? index+1 : 0
+      if oprand.instance_of?(Hash)
+        self.merge(oprand)
+      elsif oprand.instance_of?(Array)
+        self.merge oprand.reduce({}){|tr,op|index+=1;tr.merge({(index-1)=>op})}
+      else
+        self.merge({index=>oprand})
+      end
+    end
+  end
+
+end
+
+class String
+  include TextAbstract::Type
+  include TextAbstract::TextOperator
+end
+
+class Array
+  include TextAbstract::ListOperator
+end
+
+class Hash
+  include TextAbstract::TreeOperator
+end