cc 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8386675ee1a8b68cb73c020b620f2b314b0778a15c22a852bc230955155275f
-  data.tar.gz: 58d7146b6769792681d5454bb665fd9f7694c85b56ea2d2c4b91d6a519839173
+  metadata.gz: 560df541d3d489827cf9873d8ad9b78efb20e454824728462dff70fd955b477a
+  data.tar.gz: 235e3d4bc81f79b5bc3eb72303ef4df9ae1f724753a7484f451fff75b9f7bb53
 SHA512:
-  metadata.gz: 946c2bc2b698b1a4e05e03224005038281f57712a228c82ff6d9ff635a3d34921741969ce058c75716dbd9ee9823d16f2224214b71bec7904ec8c8314ed481df
-  data.tar.gz: c77d03c47b193c321a22f52b23841be5b5284b91839309294d93a48bc577bd1a31ca2375befba9576c9e8cbd91b212140e6a397a1c99c18c75722b51d1828a16
+  metadata.gz: 90a657521953f6e3a9b69b7aef92f41f2f10c5e87faa858717df4f6551cf06e7a83d16836c2fb5aab053254b48be0281908707ea6073acdc03e3c5de7b42f858
+  data.tar.gz: 2c250b3c62437a27116357cc331947cac3532691f2dcbb116d7814ff1c8e5fb9f585301498933e84f711471a1f8e34b6f9528b8448682622ce32903fded145cf

data/README.md

@@ -1,3 +1,29 @@
-# custom-core
-
-CC
+# custom-core
+
+CC
+
+## textmind（text-tools / text-server / text-client）
+
+移植自 imdoc/TextUtils 的文本直觉操作族，v1.4.0 起随 cc 自带，三个文件各司其职：
+
+- **text-tools.rb** —— 操作库本体：`TextAbstract` 模块函数（draw_fragments / match_paragraph /
+  match_cascade / match_html_tag）+ String/Array/Hash 的直觉操作扩展
+  （`head?` `tail?` `matches` `cut` `-` `/` `exchange` `catch` `match` `sub` `get` `set` `+` …）。
+  加载方式：`require 'cc'; CC.use 'text-tools'`
+
+- **text-server.rb** —— **S 端**：命令行启动解析服务（原 config.ru 的改造版）。
+  `ruby text-server.rb [--port 9292] [--host 0.0.0.0]`，
+  40 个 POST 端点（/type/* /text/* /list/* /tree/*），路由与参数名和原服务一致，
+  原 Postman 集合可继续使用；CORS 由 rack-cors 依赖改为手工响应头。
+
+- **text-client.rb** —— **C 端**：命令行传入解析。
+  `ruby text-client.rb <ns> <op> [参数...]`，默认本地执行（不依赖服务），
+  `--remote URL` 时改走 S 端，本地/远程结果一致；数据走 `--text/--list/--tree` 或管道 stdin。
+
+```shell
+ruby text-client.rb type int --radix 2 --text 100        # => 4
+echo "abedef" | ruby text-client.rb text exchange --oldtext e --newtext z
+ruby text-client.rb list map --func "proc{|c| c * 2}" --list '[1,2,3]'
+```
+
+测试：`ruby -I . tests/text_tools_test.rb`（另有 text_server_test / text_client_test）

data/cc.rb

@@ -14,6 +14,7 @@ $modlist = [
   'number',
   'regexp',
   'string',
+  'text-tools',
   'tree',
   'trace',
   'logic'

data/text-client.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/env ruby
+#coding:utf-8
+
+############################################################################################################
+# text-client —— C 端：textmind 命令行传入解析                                                            #
+#                                                                                                          #
+# 移植改造自 imdoc/TextUtils 的 tm CLI 与 config.ru 使用方式：                                              #
+#   - 默认本地执行（加载同目录 text-tools.rb，不依赖任何网络与服务）                                        #
+#   - --remote URL 时走 S 端（text-server.rb）服务解析，本地/远程结果一致                                    #
+#   - 操作名与参数名和 S 端 URL 路由一一对应，Postman 集合里的用法可原样翻译成命令行                        #
+#                                                                                                          #
+# 用法：                                                                                                   #
+#   ruby text-client.rb <namespace> <op> [参数...]                                                        #
+#     namespace: type | text | list | tree                                                                 #
+#     op: 操作名（可含子路径，如 match/paragraph、draw/lines）                                             #
+#                                                                                                          #
+#   数据输入：                                                                                             #
+#     --text "字符串"     文本/类型操作输入（或 --file PATH，或管道 stdin）                                 #
+#     --list '[1,2,3]'    列表操作输入（JSON 数组）                                                         #
+#     --tree '{"a":1}'    树操作输入（JSON 对象）                                                           #
+#     布尔开关（如 --strip）出现即置 true；--patterns/--attaches/--oprands/--oprand 若以 [ 或 { 开头按 JSON  #
+#     解析，与 S 端 JSON 请求体语义对齐                                                                     #
+#                                                                                                          #
+#   通用：                                                                                                 #
+#     --remote http://127.0.0.1:9292   改走 S 端服务解析                                                   #
+#     --help                           帮助                                                                #
+#                                                                                                          #
+#   输出：JSON（与 S 端响应一致）；用法/连接错误输出到 stderr 并返回 1                                       #
+#                                                                                                          #
+# 示例：                                                                                                   #
+#   ruby text-client.rb type int --radix 2 --text 100                      # => 4                          #
+#   ruby text-client.rb text head --prefix aa --text aabbcc                # => true                       #
+#   ruby text-client.rb text match/paragraph --start a --finish b --text a1a2b3                            #
+#   echo "abedef" | ruby text-client.rb text exchange --oldtext e --newtext z                             #
+#   ruby text-client.rb list map --func "proc{|c| c * 2}" --list '[1,2,3]'  # => [2,4,6]                   #
+#   ruby text-client.rb tree + --oprand '[1,3,5]' --tree '{"a":1}'          # => {"a":1,"0":1,"1":3,"2":5}  #
+#   ruby text-client.rb --remote http://127.0.0.1:9292 text head --prefix aa --text aabbcc                  #
+############################################################################################################
+
+require_relative 'text-tools'
+require 'json'
+require 'net/http'
+
+module TextClient
+  # 结构化参数键：这些键的值以 [ 或 { 开头时按 JSON 解析（与 S 端 JSON 请求体语义对齐），
+  # 其余一律保持字符串（数字/布尔由操作端自行 to_i/判断，与 S 端一致）。
+  STRUCTURED_KEYS = %w{list tree oprand oprands patterns attaches item val}
+
+  module_function
+
+  # 结构化参数解析：结构化键的值尝试按 JSON 解析（数字/布尔/数组/对象），解析失败保持原串。
+  #
+  # @param name [String] 参数名
+  # @param value [String] 命令行参数值
+  # @return [Object] 解析结果
+  def coerce name, value
+    return value unless STRUCTURED_KEYS.include?(name) && value.is_a?(String)
+    JSON.parse(value)
+  rescue JSON::ParserError
+    value
+  end
+
+  # 解析命令行参数：--key value 成对（也接受 --key=value 写法），
+  # 值缺失或下一个也是 --开关 时视为布尔 true。
+  #
+  # @param argv [Array<String>] 参数（不含 namespace/op）
+  # @return [Hash{String => Object}] 参数表
+  def parse_params argv
+    params = {}
+    i = 0
+    while i < argv.size
+      key = argv[i]
+      if key.start_with?('--')
+        name, inline = key[2..-1].split('=', 2)
+        value = inline || argv[i+1]
+        if value.nil? || (!inline && value.start_with?('--'))
+          params[name] = true
+        else
+          params[name] = coerce(name, value)
+          i += 1 unless inline
+        end
+      end
+      i += 1
+    end
+    params
+  end
+
+  # 取文本输入：--text > --file > 管道 stdin。
+  #
+  # @param params [Hash] 参数表
+  # @return [String, nil] 文本输入
+  def fetch_text params
+    return params['text'] if params['text']
+    return File.read(params['file']) if params['file']
+    return $stdin.read unless $stdin.tty?
+    nil
+  end
+
+  # 本地执行：直接调用 text-tools 的操作符（与 S 端路由同参数同缺省）。
+  #
+  # @param ns [String] namespace（type/text/list/tree）
+  # @param op [String] 操作名（可含子路径）
+  # @param params [Hash] 参数表
+  # @return [Object] 计算结果
+  def dispatch_local ns, op, params
+    case "#{ns}/#{op}"
+    # ---- type ----
+    when 'type/int'
+      fetch_text(params).int(params['radix'] ? params['radix'].to_i : 10)
+    when 'type/float'
+      fetch_text(params).float(params['tail'] ? params['tail'].to_i : 2)
+    when 'type/precent'
+      fetch_text(params).precent(params['tail'] ? params['tail'].to_i : 2)
+    when 'type/text'
+      fetch_text(params).text((params['format'] || 'raw').to_sym)
+    when 'type/bool'
+      fetch_text(params).bool
+    # ---- text ----
+    when 'text/head'
+      fetch_text(params).head?(params['prefix'], params['strip'] || false)
+    when 'text/tail'
+      fetch_text(params).tail?(params['postfix'], params['strip'] || false)
+    when 'text/include'
+      fetch_text(params).include?(params['pattern'])
+    when 'text/empty'
+      fetch_text(params).empty?
+    when 'text/length'
+      fetch_text(params).length
+    when 'text/strip'
+      flag = (params['flag'] || 'both').to_s.downcase.to_sym
+      text = fetch_text(params)
+      flag==:both ? text.strip : flag==:left ? text.lstrip : flag==:right ? text.rstrip : text
+    when 'text/join'
+      fetch_text(params).join(params['attaches'] || [])
+    when 'text/+'
+      fetch_text(params) + (params['oprand'] || '')
+    when 'text/-'
+      fetch_text(params) - (params['oprand'] || '')
+    when 'text/*'
+      fetch_text(params) * (params['oprand'] || 1).to_s.to_i
+    when 'text/split'
+      fetch_text(params) / (params['oprand'] || ' ')
+    when 'text/cut'
+      fetch_text(params).cut(params['lidx'] ? params['lidx'].to_i : 1, params['ridx'] ? params['ridx'].to_i : 0)
+    when 'text/match'
+      text = fetch_text(params)
+      patterns = params['patterns'] || []
+      mode = (params['mode'] || 'one').to_s.downcase.to_sym
+      [:one, :all].include?(mode) ? (!patterns.first.to_s.empty? ? text.matches(patterns.first.to_s,mode) : text) :
+        text.matches(patterns,mode)
+    when 'text/exchange'
+      repeat = (params['repeat'] || 'all').to_s
+      repeat = repeat.include?('all') ? repeat.to_sym : repeat.to_i
+      fetch_text(params).exchange(params['oldtext'], params['newtext'], repeat)
+    when 'text/draw/lines'
+      rests, content = fetch_text(params).draw_lines(Regexp.new(params['preflag'].to_s), Regexp.new(params['postflag'].to_s))
+      [content, rests]
+    when 'text/match/paragraph'
+      fetch_text(params).match_paragraph(params['start'].to_s, params['finish'].to_s)
+    when 'text/match/cascade'
+      fetch_text(params).match_cascade(params['start'].to_s, params['finish'].to_s)
+    when 'text/match/xml'
+      fetch_text(params).match_xml(params['tag'].to_s)
+    # ---- list ----
+    when 'list/pop'
+      params['list'].pop
+    when 'list/push'
+      params['list'].push(params['item'])
+    when 'list/shift'
+      params['list'].shift
+    when 'list/unshift'
+      params['list'].unshift(params['item'])
+    when 'list/+'
+      params['list'] + (params['oprand'] || [])
+    when 'list/-'
+      params['list'] - (params['oprand'] || [])
+    when 'list/catch'
+      params['list'].catch(params['oprands'] || [])
+    when 'list/sub'
+      params['list'].sub(params['lidx'] ? params['lidx'].to_i : 1, params['ridx'] ? params['ridx'].to_i : 0)
+    when 'list/match'
+      repeat = params['repeat'] || 1
+      repeat = :all if repeat.to_s == 'all'
+      repeat = repeat.to_i unless repeat == :all
+      params['list'].match(repeat, &eval(params['func']))
+    when 'list/map'
+      params['list'].map(&eval(params['func']))
+    when 'list/reduce'
+      sectors = params['init'].to_s.split(":")
+      type = sectors.last.strip
+      init = sectors[0..-2].join(':')
+      iv = case type
+        when 'text';    init.strip.to_s
+        when 'integer'; init.strip.to_i
+        when 'float';   init.strip.to_f
+        when 'list';    eval(init)
+        when 'tree';    eval(init)
+        end
+      params['list'].reduce(iv, &eval(params['func']))
+    # ---- tree ----
+    when 'tree/keys'
+      params['tree'].keys
+    when 'tree/values'
+      params['tree'].values
+    when 'tree/get'
+      params['tree'][params['key'].to_s]
+    when 'tree/set'
+      params['tree'][params['key']] = params['val']
+      params['tree']
+    when 'tree/+'
+      params['tree'] + params['oprand']
+    end
+  end
+
+  # 远程执行：POST JSON 参数到 S 端（路径与操作名一致）。
+  #
+  # @param base [String] S 端地址（如 http://127.0.0.1:9292）
+  # @param ns [String] namespace
+  # @param op [String] 操作名
+  # @param params [Hash] 参数表
+  # @return [Object] 解析结果
+  def dispatch_remote base, ns, op, params
+    uri = URI("#{base}/#{ns}/#{op}")
+    body = params.reject{|k,_| %w{remote help}.include?(k) }.to_json
+    response = Net::HTTP.post(uri, body, 'Content-Type' => 'application/json')
+    raise "S 端响应 #{response.code}" unless response.code == '200'
+    JSON.parse(response.body)
+  end
+
+  # 帮助文本。
+  #
+  # @return [String]
+  def help
+    <<~HELP
+      text-client —— textmind 命令行解析（C 端）
+
+      用法: ruby text-client.rb <namespace> <op> [参数...]
+        namespace: type | text | list | tree
+        op: 操作名（可含子路径，如 match/paragraph、draw/lines）
+
+      数据输入:
+        --text "字符串"   文本/类型操作输入（或 --file PATH，或管道 stdin）
+        --list '[...]'    列表操作输入（JSON 数组）
+        --tree '{...}'    树操作输入（JSON 对象）
+
+      通用:
+        --remote URL      改走 S 端服务解析（默认本地执行）
+        --help            本帮助
+
+      示例:
+        ruby text-client.rb type int --radix 2 --text 100
+        ruby text-client.rb text head --prefix aa --text aabbcc
+        ruby text-client.rb text exchange --oldtext e --newtext z --text abedef
+        ruby text-client.rb list map --func "proc{|c| c * 2}" --list '[1,2,3]'
+        ruby text-client.rb tree + --oprand '[1,3,5]' --tree '{"a":1}'
+        echo "a1a2b3" | ruby text-client.rb text match/paragraph --start a --finish b
+        ruby text-client.rb --remote http://127.0.0.1:9292 text head --prefix aa --text aabbcc
+    HELP
+  end
+
+  # C 端命令行入口（可测试：传入 argv 与 io）。
+  #
+  # --remote 可出现在任意位置（--remote URL 或 --remote=URL 两种写法），
+  # 抽取后剩余参数的前两个位置量即 namespace 与 op。
+  #
+  # @param argv [Array<String>] 命令行参数
+  # @param io [IO] 结果输出流，默认 $stdout
+  # @return [Integer] 进程退出码
+  def run argv, io: $stdout
+    return (io.puts help; 0) if argv.empty? || argv.include?('--help')
+
+    # 归一化 --remote=URL 写法，再整对抽取 --remote，避免挤占 ns/op 位置
+    argv = argv.flat_map{|arg| arg.start_with?('--remote=') ? ['--remote', arg.split('=', 2)[1]] : [arg] }
+    remote = nil
+    if i = argv.index('--remote')
+      remote = argv[i+1]
+      argv = argv.dup.tap{|a| a.slice!(i, 2) }
+    end
+
+    ns, op, *raw_params = argv
+    return (io.puts help; 1) unless ns && op && !ns.start_with?('--')
+    params = parse_params(raw_params)
+
+    begin
+      result = remote ? dispatch_remote(remote, ns, op, params) : dispatch_local(ns, op, params)
+      io.puts result.to_json
+      return 0
+    rescue => e
+      warn "text-client: #{e.class}: #{e.message}"
+      return 1
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  exit(TextClient.run(ARGV))
+end

data/text-server.rb

@@ -0,0 +1,403 @@
+#!/usr/bin/env ruby
+#coding:utf-8
+
+############################################################################################################
+# text-server —— S 端：textmind 解析服务（命令行启动）                                                    #
+#                                                                                                          #
+# 移植改造自 imdoc/TextUtils/config.ru：                                                                   #
+#   - 原 `rackup config.ru` 部署方式 -> `ruby text-server.rb`（或安装后 require）命令行直接启动             #
+#   - 原依赖 gem:rack-cors -> 手工 CORS 响应头（放行规则与原配置一致，少一个依赖）                           #
+#   - 修正原 config.ru 三处失效缺省：                                                                       #
+#       r.params['radix'].to_i || 10   （nil.to_i==0 恒真，缺省 10 从未生效 -> 缺省 10）                     #
+#       r.params['format'].to_sym     （缺省会 nil.to_sym 崩溃 -> 缺省 :raw）                               #
+#       r.params['flag'].to_s.downcase.to_sym || :both（:"" 恒真 -> 缺省 :both；mode 同理缺省 :one）        #
+#   - 路由路径与参数名与原服务完全一致，原 Postman 集合（imdoc/TextUtils/doc/）无需改动即可继续使用          #
+#                                                                                                          #
+# 接口（JSON 请求体，POST）：                                                                              #
+#   /type/{int,float,precent,text,bool}                                                                    #
+#   /text/{head,tail,include,empty,length,strip,join,+, -, *,split,cut,match,exchange,draw/lines,          #
+#          match/paragraph, match/cascade, match/xml}                                                      #
+#   /list/{pop,push,shift,unshift,+, -,catch,sub,match,map,reduce}                                         #
+#   /tree/{keys,values,get,set,+}                                                                          #
+#   注意：list 的 match/map/reduce 接收 ruby 代码串并 eval（内部信任工具，请勿暴露到不可信网络）            #
+#                                                                                                          #
+# 启动：                                                                                                   #
+#   ruby text-server.rb                 # 127.0.0.1:9292                                                  #
+#   ruby text-server.rb --port 9293      # 指定端口                                                        #
+#   ruby text-server.rb --host 0.0.0.0   # 监听所有网卡（原 CORS 允许的 192.168.0.x 前端即此场景）           #
+#                                                                                                          #
+# 配套：C 端 text-client.rb（本地解析或 --remote 调用本服务）                                              #
+############################################################################################################
+
+require_relative 'text-tools'
+require 'roda'
+
+module TextServer
+  # 原 rack-cors 放行来源（与 config.ru 一致）：本地 9200 前端与 192.168.0.x 内网前端
+  ALLOWED_ORIGINS = ['localhost:9200', '127.0.0.1:9200']
+  ALLOWED_ORIGIN_PATTERN = /\Ahttp:\/\/192\.168\.0\.\d{1,3}(:\d+)?\z/
+
+  module_function
+
+  # 判断 Origin 是否在 CORS 放行名单内。
+  #
+  # @param origin [String, nil] 请求 Origin 头
+  # @return [Boolean]
+  def allowed_origin? origin
+    return false unless origin
+    ALLOWED_ORIGINS.include?(origin) || ALLOWED_ORIGIN_PATTERN.match?(origin)
+  end
+
+  # S 端启动入口：解析 --host/--port 并拉起 Rack 服务。
+  #
+  # @param argv [Array<String>] 命令行参数
+  # @return [void]
+  def run! argv
+    host, port = '127.0.0.1', 9292
+    argv.each_slice(2) do|key, value|
+      case key
+      when '--host' then host = value || host
+      when '--port' then port = (value || port).to_i
+      end
+    end
+    require 'rackup'
+    puts "textmind S 端启动: http://#{host}:#{port}  (POST /type|/text|/list|/tree/*)"
+    Rackup::Server.start(app: App.freeze.app, Host: host, Port: port)
+  end
+end
+
+# textmind 解析服务（Roda 应用）。
+class App < Roda
+  plugin :json_parser     # 解析 JSON 请求体到 r.params
+  plugin :request_headers # 读取请求头（CORS Origin）
+  plugin :all_verbs       # 全动词路由（GET/POST/PUT/…/OPTIONS）
+
+  route do |r|
+    # ---- 手工 CORS：按原 rack-cors 规则放行并回写响应头 ----
+    if origin = r.headers['Origin'] and TextServer.allowed_origin?(origin)
+      response['Access-Control-Allow-Origin']  = origin
+      response['Access-Control-Allow-Methods'] = 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD'
+      response['Access-Control-Allow-Headers'] = 'x-domain-token, Content-Type'
+      response['Access-Control-Expose-Headers'] = 'Some-Custom-Response-Header'
+      response['Access-Control-Max-Age'] = '600'
+    end
+
+    # CORS 预检（OPTIONS）直接放行
+    r.options do
+      ''
+    end
+
+    # ---- 类型操作：字符串 -> 目标类型 ----
+    r.on 'type' do
+      # POST /type/int radix=2, text="100" => 4
+      r.post 'int' do
+        text = r.params['text']
+        radix = r.params['radix'] ? r.params['radix'].to_i : 10
+        text.int(radix).to_json
+      end
+
+      # POST /type/float tail=2, text="3.1415926" => 3.14
+      r.post 'float' do
+        text = r.params['text']
+        tail = r.params['tail'] ? r.params['tail'].to_i : 2
+        text.float(tail).to_json
+      end
+
+      # POST /type/precent tail=2, text="0.8675309" => "86.75%"
+      r.post 'precent' do
+        text = r.params['text']
+        tail = r.params['tail'] ? r.params['tail'].to_i : 2
+        text.precent(tail).to_json
+      end
+
+      # POST /type/text format=meta, text="hello world" => JSON 编码
+      r.post 'text' do
+        text = r.params['text']
+        format = (r.params['format'] || 'raw').to_sym
+        text.text(format).to_json
+      end
+
+      # POST /type/bool text="true" => true
+      r.post 'bool' do
+        text = r.params['text']
+        text.bool.to_json
+      end
+    end
+
+    # ---- 文本操作 ----
+    r.on 'text' do
+      # POST /text/head prefix="aa", strip=false, text="aabbcc"
+      r.post 'head' do
+        text = r.params['text']
+        prefix = r.params['prefix']
+        strip = r.params['strip'] || false
+        text.head?(prefix, strip).to_json
+      end
+
+      # POST /text/tail postfix="cc", strip=false, text="aabbcc"
+      r.post 'tail' do
+        text = r.params['text']
+        postfix = r.params['postfix']
+        strip = r.params['strip'] || false
+        text.tail?(postfix, strip).to_json
+      end
+
+      # POST /text/include pattern="bb", text="aabbcc"
+      r.post 'include' do
+        text = r.params['text']
+        pattern = r.params['pattern']
+        text.include?(pattern).to_json
+      end
+
+      # POST /text/empty text=""
+      r.post 'empty' do
+        text = r.params['text']
+        text.empty?.to_json
+      end
+
+      # POST /text/length text="aabbcc"
+      r.post 'length' do
+        text = r.params['text']
+        text.length.to_json
+      end
+
+      # POST /text/strip flag=both, text="  aa  "
+      r.post 'strip' do
+        text = r.params['text']
+        flag = (r.params['flag'] || 'both').to_s.downcase.to_sym
+        result = flag==:both ? text.strip : flag==:left ? text.lstrip : flag==:right ? text.rstrip : text
+        result.to_json
+      end
+
+      # POST /text/join attaches=["22345678","32345678"], text="aa"
+      r.post 'join' do
+        text = r.params['text']
+        attaches = r.params['attaches'] || []
+        text.join(attaches).to_json
+      end
+
+      # POST /text/+ oprand="bb", text="aa" => "aabb"
+      r.post '+' do
+        text = r.params['text']
+        oprand = r.params['oprand'] || ''
+        (text + oprand).to_json
+      end
+
+      # POST /text/- oprand="bc", text="aabbcc" => "aa"（从首次出现处截断）
+      r.post '-' do
+        text = r.params['text']
+        oprand = r.params['oprand'] || ''
+        (text - oprand).to_json
+      end
+
+      # POST /text/* oprand=3, text="ab" => "ababab"
+      r.post '*' do
+        text = r.params['text']
+        oprand = (r.params['oprand'] || 1).to_s.to_i
+        (text * oprand).to_json
+      end
+
+      # POST /text/split oprand=" ", text="a b"  （缺省 ' '，原文标注 DIFF: '' <=> ' '）
+      r.post 'split' do
+        text = r.params['text']
+        oprand = r.params['oprand'] || ' ' # DIFF: '' <=> ' '
+        (text / oprand).to_json
+      end
+
+      # POST /text/cut lidx=1, ridx=0, text="abcdef"（1 起数闭区间，0 取到末尾）
+      r.post 'cut' do
+        text = r.params['text']
+        lidx = r.params['lidx'] || 1
+        ridx = r.params['ridx'] || 0
+        text.cut(lidx, ridx).to_json
+      end
+
+      # POST /text/match patterns=["a\\d","c\\d"], mode=one|all|union, text="a1b2c3"
+      r.post 'match' do
+        text = r.params['text']
+        patterns = r.params['patterns'] || []
+        mode = (r.params['mode'] || 'one').to_s.downcase.to_sym
+        ([:one, :all].include?(mode) ? (!patterns.first.to_s.empty? ? text.matches(patterns.first.to_s,mode) : text) :
+        text.matches(patterns,mode)).to_json
+      end
+
+      # POST /text/exchange oldtext="e", newtext="z", repeat=all, text="abedef"
+      r.post 'exchange' do
+        text = r.params['text']
+        oldtext = r.params['oldtext']
+        newtext = r.params['newtext']
+        repeat = (r.params['repeat'] || 'all').to_s
+        repeat = repeat.include?('all') ? repeat.to_sym : repeat.to_i
+        text.exchange(oldtext, newtext, repeat).to_json
+      end
+
+      # POST /text/draw/lines preflag="a", postflag="b", text="1111\na\n2222\nb\n3333"
+      r.post 'draw/lines' do
+        text = r.params['text']
+        preflag = Regexp.new r.params['preflag'].to_s
+        postflag = Regexp.new r.params['postflag'].to_s
+        rests, content = text.draw_lines(preflag, postflag)
+        [content, rests].to_json
+      end
+
+      # POST /text/match/paragraph start="a", finish="b", text="a1a2b3a4b"
+      r.post 'match/paragraph' do
+        text = r.params['text']
+        start = r.params['start'].to_s
+        finish = r.params['finish'].to_s
+        text.match_paragraph(start, finish).to_json
+      end
+
+      # POST /text/match/cascade start="a", finish="b", text="a1{a2}b3"
+      r.post 'match/cascade' do
+        text = r.params['text']
+        start = r.params['start'].to_s
+        finish = r.params['finish'].to_s
+        text.match_cascade(start, finish).to_json
+      end
+
+      # POST /text/match/xml tag="a", text="<a>1<a>2</a>3</a>"
+      r.post 'match/xml' do
+        text = r.params['text']
+        tag = r.params['tag'].to_s
+        text.match_xml(tag).to_json
+      end
+    end
+
+    # ---- 列表操作 ----
+    r.on 'list' do
+      # POST /list/pop list=[1,2,3]
+      r.post 'pop' do
+        list = r.params['list']
+        list.pop.to_json
+      end
+
+      # POST /list/push item="x", list=[1,2,3]
+      r.post 'push' do
+        list = r.params['list']
+        item = r.params['item']
+        list.push(item).to_json
+      end
+
+      # POST /list/shift list=[1,2,3]
+      r.post 'shift' do
+        list = r.params['list']
+        list.shift.to_json
+      end
+
+      # POST /list/unshift item="x", list=[1,2,3]
+      r.post 'unshift' do
+        list = r.params['list']
+        item = r.params['item']
+        list.unshift(item).to_json
+      end
+
+      # POST /list/+ oprand=[4,5], list=[1,2,3]
+      r.post '+' do
+        list = r.params['list']
+        alt = r.params['oprand'] || []
+        (list + alt).to_json
+      end
+
+      # POST /list/- oprand=[2], list=[1,2,3]
+      r.post '-' do
+        list = r.params['list']
+        alt = r.params['oprand'] || []
+        (list - alt).to_json
+      end
+
+      # POST /list/catch oprands=[["a","b"],["c"]], list=[1,2,3]
+      r.post 'catch' do
+        list = r.params['list']
+        alts = r.params['oprands'] || []
+        list.catch(alts).to_json
+      end
+
+      # POST /list/sub lidx=1, ridx=0, list=[1,2,3]
+      r.post 'sub' do
+        list = r.params['list']
+        lidx = r.params['lidx'] || 1
+        ridx = r.params['ridx'] || 0
+        list.sub(lidx, ridx).to_json
+      end
+
+      # POST /list/match func="proc{|c| c >= 'b'}", repeat=1, list=["a","b","c"]
+      #   repeat: 0 只判存在 / 1 取首个 / "all" 取全部 / n 取前 n 个
+      r.post 'match' do
+        list = r.params['list']
+        repeat = r.params['repeat'] || 1
+        repeat = :all if repeat.to_s == 'all'
+        func = eval(r.params['func'])
+        list.match(repeat, &func).to_json
+      end
+
+      # POST /list/map func="proc{|c| c * 2}", list=[1,2,3]
+      r.post 'map' do
+        list = r.params['list']
+        func = eval(r.params['func'])
+        list.map(&func).to_json
+      end
+
+      # POST /list/reduce func="proc{|a,b| a+b}", init="0:integer", list=[1,2,3]
+      #   init 形如 "初值:类型"，类型支持 text/integer/float/list/tree
+      r.post 'reduce' do
+        list = r.params['list']
+        func = eval(r.params['func'])
+        sectors = r.params['init'].to_s.split(":")
+        type = sectors.last.strip
+        init = sectors[0..-2].join(':')
+        iv = case type
+          when 'text';    init.strip.to_s
+          when 'integer'; init.strip.to_i
+          when 'float';   init.strip.to_f
+          when 'list';    eval(init)
+          when 'tree';    eval(init)
+        end
+        list.reduce(iv,&func).to_json
+      end
+    end
+
+    # ---- 树操作 ----
+    r.on 'tree' do
+      # POST /tree/keys tree={"a":1}
+      r.post 'keys' do
+        tree = r.params['tree']
+        tree.keys.to_json
+      end
+
+      # POST /tree/values tree={"a":1}
+      r.post 'values' do
+        tree = r.params['tree']
+        tree.values.to_json
+      end
+
+      # POST /tree/get key="a", tree={"a":1}
+      r.post 'get' do
+        tree = r.params['tree']
+        get_key = r.params['key'].to_s
+        tree[get_key].to_json
+      end
+
+      # POST /tree/set key="a", val=2, tree={"a":1}
+      r.post 'set' do
+        tree = r.params['tree']
+        set_key = r.params['key']
+        set_val = r.params['val']
+        tree[set_key]=set_val
+        tree.to_json
+      end
+
+      # POST /tree/+ oprand={"b":2}|[1,3,5]|"x", tree={"a":1}
+      r.post '+' do
+        tree = r.params['tree']
+        alt = r.params['oprand'] # DIFF: "num" <=> num
+        (tree + alt).to_json
+      end
+    end
+
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  TextServer.run! ARGV
+end

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cc
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Matt
@@ -34,6 +34,9 @@ files:
 - regexp.rb
 - shell-tools.rb
 - string.rb
+- text-client.rb
+- text-server.rb
+- text-tools.rb
 - trace.rb
 - tree.rb
 homepage: https://github.com/ChenMeng1365/custom-core
@@ -54,7 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.19
 specification_version: 4
 summary: custom core
 test_files: []