cc 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fc0484d6d2387f8043520b7981b52be8968f1a233cf5e110395a2dcc9ab5fa8
-  data.tar.gz: 88f19e9a08e517ccdebb8d9f5d8dbb8afec0dd675d6b0c6df057c40703d75993
+  metadata.gz: 560df541d3d489827cf9873d8ad9b78efb20e454824728462dff70fd955b477a
+  data.tar.gz: 235e3d4bc81f79b5bc3eb72303ef4df9ae1f724753a7484f451fff75b9f7bb53
 SHA512:
-  metadata.gz: 371bdf3d14c78623c029bd58aff0002383f256dc9346ab5f6586b0ad7920690c9698338d1d73ccbffcab07019d0c9a132ced0365d6f7198c3c7040371329900e
-  data.tar.gz: 874c41883cb25ddf44790b37d8b7589ef5ff87bb07e25d5d7908f2553dedb3b9cc96af751a7886902839e3e7084931cdd1a30b547c8c6c43a63721bf0b4af6b8
+  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/monkey-patch.rb

@@ -4,7 +4,7 @@
 # HOW TO USE                                                                                               #
 ############################################################################################################
 
-=begin
+=begin # 旧版
   require 'cc'
   CC.use 'monkey-patch'
 
@@ -50,6 +50,380 @@
   p a.compize(Object), a.mod1, a.mod2, a.mod1_20110101
 =end
 
+=begin # 新版
+  puts "=" * 60
+  puts "模块级方法版本控制系统 v4 演示"
+  puts "=" * 60
+
+  # ========================================
+  # 定义版本化模块
+  # ========================================
+  module Calculator
+    include MonkeyPatch
+
+    # 方式1: 传统 block
+    ADD_V1 = defv(:add) { |a, b| a + b }
+    puts "[方式1] 定义 add v1, 签名: #{ADD_V1}"
+
+    ADD_V2 = defv(:add) { |a, b| 
+      result = a + b
+      puts "[v2] 计算 #{a} + #{b} = #{result}"
+      result 
+    }
+    puts "[方式1] 定义 add v2, 签名: #{ADD_V2}"
+  end
+
+  # 方式2: 从外部数组批量生成
+  EXTERNAL_SPECS = [
+    [:greet, "World", proc { |name| "Hello, #{name}!" }],
+    [:multiply, 1, proc { |a, b| a * b }],
+  ]
+
+  module GreetingService
+    include MonkeyPatch
+
+    EXTERNAL_SPECS.each do |spec|
+      name, default, body = spec
+      sig = defv(name, default, body)
+      puts "[方式2] 定义 #{name}, 默认=#{default.inspect}, 签名: #{sig}"
+    end
+  end
+
+  # ========================================
+  # 测试 module_function 效果
+  # ========================================
+  puts "\n" + "-" * 50
+  puts "测试 module_function 效果（v4 核心特性）"
+  puts "-" * 50
+
+  # 实例调用
+  obj = Object.new.extend(Calculator)
+  puts "obj.add(2, 3) = #{obj.add(2, 3)}"
+
+  # 模块方法调用（module_function 效果）
+  puts "Calculator.add(10, 20) = #{Calculator.add(10, 20)}"
+  puts "Calculator.send(:add, 5, 7) = #{Calculator.send(:add, 5, 7)}"
+
+  # 模块方法也走版本控制
+  puts "\n--- 模块方法版本切换 ---"
+  puts "当前默认: Calculator.add(1, 1) = #{Calculator.add(1, 1)}"
+
+  Calculator.rollback_to(:add, Calculator::ADD_V1)
+  puts "回滚到 v1: Calculator.add(1, 1) = #{Calculator.add(1, 1)}"
+
+  Calculator.rollback_to(:add, Calculator::ADD_V2)
+  puts "恢复 v2: Calculator.add(1, 1) = #{Calculator.add(1, 1)}"
+
+  # 实例调用同步受影响（共享版本库）
+  puts "obj.add(1, 1) = #{obj.add(1, 1)}  (与模块方法同步)"
+
+  # ========================================
+  # 测试 GreetingService
+  # ========================================
+  puts "\n" + "-" * 50
+  puts "测试 GreetingService（方式2 + module_function）"
+  puts "-" * 50
+
+  puts "GreetingService.greet = #{GreetingService.greet}"
+  puts 'GreetingService.greet("Alice") = ' + GreetingService.greet("Alice").to_s
+  puts "GreetingService.multiply(3, 4) = #{GreetingService.multiply(3, 4)}"
+
+  # 实例调用
+  g = Object.new.extend(GreetingService)
+  puts "g.greet = #{g.greet}"
+  puts 'g.greet("Bob") = ' + g.greet("Bob").to_s
+
+  # ========================================
+  # 版本历史
+  # ========================================
+  puts "\n" + "-" * 50
+  puts "版本历史"
+  puts "-" * 50
+
+  Calculator.version_history(:add).each do |v|
+    puts "  Calculator.add: #{v[:signature]} @ #{v[:timestamp]}"
+  end
+
+  GreetingService.version_history(:greet).each do |v|
+    puts "  GreetingService.greet: #{v[:signature]} @ #{v[:timestamp]}"
+  end
+
+  # ========================================
+  # 跨模块隔离
+  # ========================================
+  puts "\n" + "=" * 60
+  puts "跨模块隔离测试"
+  puts "=" * 60
+  puts "Calculator 版本库: #{Calculator.versioned_methods.inspect}"
+  puts "GreetingService 版本库: #{GreetingService.versioned_methods.inspect}"
+
+  # ========================================
+  # 全局注册表
+  # ========================================
+  puts "\n" + "=" * 60
+  puts "全局注册表结构"
+  puts "=" * 60
+  MonkeyPatch::VERSION_REGISTRY.each do |mod, methods|
+    puts "模块: #{mod}"
+    methods.each do |name, versions|
+      puts "  方法: #{name}"
+      versions.each do |sig, vm|
+        next if sig == :__latest__
+        puts "    [#{sig}] => #{vm}"
+      end
+      puts "    [LATEST] => #{versions[:__latest__]}"
+    end
+  end
+=end
+
+
+# ============================================================
+# 新版本MonkeyPatch
+# 模块级方法版本控制系统 (Module Method Versioning) - v4
+# ============================================================
+# 特性：
+#   1. 模块作为方法仓库，每个方法名对应一个版本链
+#   2. 支持按签名回溯历史版本
+#   3. 不传签名时默认调取最新版本
+#   4. 模块间版本隔离，互不干扰
+#   5. 支持两种调用方式：
+#      - 传统 block: defv(:name) { |a| ... }
+#      - 数组重构:   defv(:name, default_param, proc)
+#   6. module_function 支持：模块方法也走版本控制
+#      - obj.a 和 A.a 共享同一个版本库
+# ============================================================
+
+module MonkeyPatch
+  VERSION_REGISTRY = {}
+  SIGNATURE_COUNTER = Hash.new(0)
+
+  class VersionedMethod
+    attr_reader :name, :signature, :body, :timestamp, :module_ref
+
+    def initialize(name:, signature:, body:, module_ref:)
+      @name = name
+      @signature = signature
+      @body = body
+      @timestamp = Time.now
+      @module_ref = module_ref
+    end
+
+    def call(*args)
+      outer_block = block_given? ? Proc.new : nil
+      if outer_block
+        @module_ref.instance_exec(*args, outer_block, &@body)
+      else
+        @module_ref.instance_exec(*args, &@body)
+      end
+    end
+
+    def to_s
+      "#<VersionedMethod #{@module_ref}##{@name}@#{@signature} #{@timestamp}>"
+    end
+    alias inspect to_s
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # ----------------------------------------------------------
+  # 类方法接口
+  # ----------------------------------------------------------
+  module ClassMethods
+    def define_versioned_method(name, *args, signature: nil, &block)
+      if block_given?
+        _register_version(name, signature: signature, body: block)
+      elsif args.size >= 2 && args[1].is_a?(Proc)
+        default_param = args[0]
+        body_proc = args[1]
+
+        wrapped = proc { |*call_args|
+          if call_args.empty?
+            body_proc.call(default_param)
+          else
+            body_proc.call(*call_args)
+          end
+        }
+        _register_version(name, signature: signature, body: wrapped)
+      else
+        raise ArgumentError, "必须提供方法块，或传入 (name, default_param, proc)"
+      end
+    end
+
+    def defv(name, *args, &block)
+      if block_given?
+        define_versioned_method(name, *args, &block)
+      elsif args.size >= 1 && args[-1].is_a?(Proc)
+        if args.size >= 2 && args[0].is_a?(String) && args[1].is_a?(Proc)
+          define_versioned_method(name, *args)
+        elsif args.size == 1
+          define_versioned_method(name, nil, args[0])
+        else
+          define_versioned_method(name, *args)
+        end
+      else
+        raise ArgumentError, "defv 需要 block 或 (default_param, proc)"
+      end
+    end
+
+    def get_versioned_method(name, signature = nil)
+      versions = _method_versions[name]
+      return nil unless versions
+
+      sig = signature || versions[:__latest__]
+      return nil unless sig
+
+      versions[sig]
+    end
+
+    def call_versioned(name, signature = nil, *args, &block)
+      vm = get_versioned_method(name, signature)
+      raise NameError, "方法 `#{name}` 版本 `#{signature || 'latest'}` 不存在" unless vm
+
+      vm.call(*args, &block)
+    end
+
+    def method_versions(name)
+      versions = _method_versions[name] || {}
+      versions.reject { |k, _| k == :__latest__ }.transform_values(&:to_s)
+    end
+
+    def versioned_methods
+      _method_versions.keys
+    end
+
+    def version_history(name)
+      return [] unless _method_versions[name]
+
+      _method_versions[name]
+        .reject { |k, _| k == :__latest__ }
+        .map { |sig, vm| { signature: sig, timestamp: vm.timestamp, method: vm } }
+        .sort_by { |h| h[:timestamp] }
+    end
+
+    def rollback_to(name, signature)
+      versions = _method_versions[name]
+      raise NameError, "方法 `#{name}` 不存在" unless versions
+      raise KeyError, "签名 `#{signature}` 不存在" unless versions[signature]
+
+      versions[:__latest__] = signature
+      signature
+    end
+
+    def remove_version(name, signature)
+      versions = _method_versions[name]
+      return false unless versions&.key?(signature)
+
+      if versions.reject { |k, _| k == :__latest__ }.size <= 1
+        raise "不能删除方法 `#{name}` 的唯一版本"
+      end
+
+      versions.delete(signature)
+
+      if versions[:__latest__] == signature
+        latest = versions.reject { |k, _| k == :__latest__ }.keys.last
+        versions[:__latest__] = latest
+      end
+
+      true
+    end
+
+    def clear_versions(name)
+      _method_versions.delete(name)
+      if method_defined?(name)
+        remove_method(name)
+      end
+      if singleton_class.method_defined?(name)
+        singleton_class.remove_method(name)
+      end
+    end
+
+    private
+
+    def _register_version(name, signature: nil, body:)
+      sig = signature || _generate_signature(name)
+
+      if _method_versions[name]&.key?(sig)
+        raise ArgumentError, "方法 `#{name}` 的签名 `#{sig}` 已存在"
+      end
+
+      versioned = VersionedMethod.new(
+        name: name,
+        signature: sig,
+        body: body,
+        module_ref: self
+      )
+
+      _method_versions[name] ||= {}
+      _method_versions[name][sig] = versioned
+      _method_versions[name][:__latest__] = sig
+
+      # 安装实例方法调度器（首次定义时）
+      unless method_defined?(name) || private_method_defined?(name)
+        _install_instance_dispatcher(name)
+      end
+
+      # 安装模块方法调度器（首次定义时）
+      unless singleton_class.method_defined?(name)
+        _install_module_dispatcher(name)
+      end
+
+      sig
+    end
+
+    def _generate_signature(name)
+      SIGNATURE_COUNTER[name] += 1
+      "#{name}_v#{SIGNATURE_COUNTER[name]}_#{Time.now.to_i}"
+    end
+
+    def _method_versions
+      VERSION_REGISTRY[self] ||= {}
+    end
+
+    # 实例方法调度器：obj.a 调用时路由到最新版本
+    def _install_instance_dispatcher(name)
+      define_method(name) do |*args, &block|
+        mod = self.class.ancestors.find { |m| m.respond_to?(:get_versioned_method) }
+        mod ||= self.singleton_class.ancestors.find { |m| m.respond_to?(:get_versioned_method) }
+
+        versions = MonkeyPatch::VERSION_REGISTRY[mod]&.[](name)
+        unless versions
+          raise NoMethodError, "未找到版本化方法 `#{name}`"
+        end
+
+        latest_sig = versions[:__latest__]
+        latest = versions[latest_sig]
+
+        unless latest
+          raise NoMethodError, "方法 `#{name}` 没有可用版本"
+        end
+
+        latest.call(*args, &block)
+      end
+    end
+
+    # 模块方法调度器：A.a 调用时路由到最新版本
+    def _install_module_dispatcher(name)
+      singleton_class.send(:define_method, name) do |*args, &block|
+        # 模块方法直接在当前模块上调用 call_versioned
+        call_versioned(name, nil, *args, &block)
+      end
+    end
+  end
+
+  # 实例方法接口
+  def call_version(name, signature = nil, *args, &block)
+    mod = self.class.ancestors.find { |m| m.respond_to?(:call_versioned) }
+    mod&.call_versioned(name, signature, *args, &block)
+  end
+end
+
+
+# ============================================================
+# 旧版本MonkeyPatch
+# ============================================================
+
 class Object
   attr_accessor :main_version, :versions