cc 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fc0484d6d2387f8043520b7981b52be8968f1a233cf5e110395a2dcc9ab5fa8
-  data.tar.gz: 88f19e9a08e517ccdebb8d9f5d8dbb8afec0dd675d6b0c6df057c40703d75993
+  metadata.gz: f8386675ee1a8b68cb73c020b620f2b314b0778a15c22a852bc230955155275f
+  data.tar.gz: 58d7146b6769792681d5454bb665fd9f7694c85b56ea2d2c4b91d6a519839173
 SHA512:
-  metadata.gz: 371bdf3d14c78623c029bd58aff0002383f256dc9346ab5f6586b0ad7920690c9698338d1d73ccbffcab07019d0c9a132ced0365d6f7198c3c7040371329900e
-  data.tar.gz: 874c41883cb25ddf44790b37d8b7589ef5ff87bb07e25d5d7908f2553dedb3b9cc96af751a7886902839e3e7084931cdd1a30b547c8c6c43a63721bf0b4af6b8
+  metadata.gz: 946c2bc2b698b1a4e05e03224005038281f57712a228c82ff6d9ff635a3d34921741969ce058c75716dbd9ee9823d16f2224214b71bec7904ec8c8314ed481df
+  data.tar.gz: c77d03c47b193c321a22f52b23841be5b5284b91839309294d93a48bc577bd1a31ca2375befba9576c9e8cbd91b212140e6a397a1c99c18c75722b51d1828a16

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
   

data/tree.rb

@@ -1,184 +1,184 @@
-#coding:utf-8
-
-############################################################################################################
-# The Class Tree is a recursive hash-generator based on Hash.                                              #
-#                                                                                                          #
-# HOW TO USE                                                                                               #
-############################################################################################################
-
-=begin
-  require 'cc'
-  CC.use 'tree'
-
-  # 奇怪的数据结构增加了!!!
-  a = Tree.init
-
-  # 逐个赋值
-  a[1][2][3] = :'4'
-  a['1']['2']['3']=4
-  p a
-  puts Array.new(32,'-').join
-
-  # 直接挂载
-  a.mount '1/2/3/4/5/6', '7'
-  p a
-  a['1/2/3'] = 4
-  p a
-  puts Array.new(32,'-').join
-
-  # 不能给根目录赋值
-  begin
-    a['/'] = :root
-  rescue Tree::PathError => exception
-    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
-  end
-  begin
-    a.mount '/', :home
-  rescue Tree::PathError => exception
-    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
-  end
-  p a.route('/')==a['/']
-  puts Array.new(32,'-').join
-
-  # 合并到某分支，连接到路径
-  b = Tree.init
-  b['a/b/c'] = :d
-  a.emerge '1/2/3', b['a']
-  p a # a['1/2/b'].parent==a['1/2/3'].parent # a['1/2/3'] is 4 and not respond to parent
-  begin
-    a.contact '1/2/3', b['a']
-  rescue Tree::PathError => exception
-    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
-  end
-  a.contact '1/2', b
-  p a
-  puts Array.new(32,'-').join
-
-  # 回溯父节点
-  t = Tree.init
-  p t['a/b/c'] = :d
-  p t
-  puts Array.new(32,'-').join
-  p '1:',t['1'],t['1/'].parent
-  puts Array.new(32,'-').join
-  p '1/2:',t['/1/2'],t['1/2'].parent
-  puts Array.new(32,'-').join
-  p '1/2/3:',t['1/2/3/'],t['1/2/3'].parent
-  puts Array.new(32,'-').join
-  p '1/2/3/4:',t['1/2/3/4'],t['1/2/3/4'].parent
-  puts Array.new(32,'-').join
-  p 'a:',t['a'],t['a'].parent
-  puts Array.new(32,'-').join
-  p 'a/b:',t['a/b'],t['a/b'].parent
-  puts Array.new(32,'-').join
-  require './exception'
-  p 'a/b/c:',t['a/b/c'],t['/a/b/c'].try(:parent)
-  puts Array.new(32,'-').join
-  p 'a/b/c/d:',(begin;t['a/b/c/d'];rescue(Exception);'cant pass path="a/b/c/d" with leaf["a/b/c"]';end)
-  puts Array.new(32,'-').join
-=end
-
-class Tree < Hash
-  VERSION = '0.2.0'
-
-  def self.init
-    Tree.new{|tree, path|tree[path] = Tree.new(tree,&tree.default_proc) }
-  end
-
-  def self.clear
-    self.init
-  end
-
-  attr_accessor :parent
-
-  def initialize parent=nil
-    @parent=parent
-    super()
-  end
-
-  def [] key
-    unless key.instance_of?(String) && key.include?('/')
-      child = super(key)
-      child.parent = self if child.respond_to? :parent
-      return child
-    end
-    key.include?('/') ? send(:route,key) : super(key)
-  end
-
-  def []= key, value
-    unless key.instance_of?(String) && key.include?('/')
-      super(key,value)
-      child = self[key]
-      child.parent = self if child.respond_to? :parent
-      return child
-    end
-    key.include?('/') ? (key=='/' ? (raise PathError, "Class Tree can't use '/' as a key except rootself.") : send(:mount,key,value)) : super(key,value)
-  end
-
-  def route path
-    unless path.instance_of?(String) && path.include?('/')
-      post = self[path]
-      post.parent = self if post.respond_to? :parent
-      return post
-    end
-    return self if path=='/'
-    hops = path.split('/')
-    hops.delete ''
-    curr = hops.shift
-    if hops.empty?
-      self[curr]
-    else
-      # if a leaf exists, any path walkthrough leaf would not pass;
-      # if no leaf exists, any path walkthrough could be pass.
-      raise PathError, "The current expected path`#{path}` not exist." unless self[curr].respond_to? :route
-      self[curr].send "route", hops.join('/')
-    end
-  end
-
-  # Caution: #mount will arrive the deepest leaf and change the passthrough
-  def mount path, store
-    unless path.instance_of?(String) && path.include?('/')
-      self[path]=store
-      post = self[path]
-      post.parent = self if post.respond_to? :parent
-      return post
-    end
-    raise PathError, "Class Tree can't mount an value on the root." if path=='/'
-    hops = path.split('/')
-    hops.delete ''
-    curr = hops.shift
-    if hops.empty?
-      self[curr]=store
-      self.delete nil # except ['/']=store to {nil=>store}
-    else
-      self[curr]=Tree.init
-      # self[curr].send "route", hops.join('/')
-      self[curr].send "mount", hops.join('/'), store
-    end
-  end
-
-  # Caution: #emerge can adapt on HashObject but loose the tree-ability
-  def emerge path, tree
-    if tree.is_a?(Hash)
-      hops = path.split("/")
-      popz = hops.pop
-      curr = hops.join('/')
-      target = hops.empty? ? self[popz] : self.route(curr)
-      raise PathError, "The current node [\"#{path}\"]=>#{target} not respond to contact/merge." unless target.respond_to? :route
-      target.merge!(tree)
-      return target
-    end
-  end
-
-  def contact path, tree
-    if tree.is_a?(Tree)
-      target = self.route path
-      raise PathError, "The current node [\"#{path}\"]=>#{target} not respond to contact/merge." unless target.respond_to? :route
-      target.merge!(tree)
-      tree.parent = target
-    end
-  end
-
-  class PathError < Exception
-  end
-end
+#coding:utf-8
+
+############################################################################################################
+# The Class Tree is a recursive hash-generator based on Hash.                                              #
+#                                                                                                          #
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'tree'
+
+  # 奇怪的数据结构增加了!!!
+  a = Tree.init
+
+  # 逐个赋值
+  a[1][2][3] = :'4'
+  a['1']['2']['3']=4
+  p a
+  puts Array.new(32,'-').join
+
+  # 直接挂载
+  a.mount '1/2/3/4/5/6', '7'
+  p a
+  a['1/2/3'] = 4
+  p a
+  puts Array.new(32,'-').join
+
+  # 不能给根目录赋值
+  begin
+    a['/'] = :root
+  rescue Tree::PathError => exception
+    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
+  end
+  begin
+    a.mount '/', :home
+  rescue Tree::PathError => exception
+    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
+  end
+  p a.route('/')==a['/']
+  puts Array.new(32,'-').join
+
+  # 合并到某分支，连接到路径
+  b = Tree.init
+  b['a/b/c'] = :d
+  a.emerge '1/2/3', b['a']
+  p a # a['1/2/b'].parent==a['1/2/3'].parent # a['1/2/3'] is 4 and not respond to parent
+  begin
+    a.contact '1/2/3', b['a']
+  rescue Tree::PathError => exception
+    puts "#{exception.class}: #{exception.message}\n  #{exception.backtrace.join("\n  ")}"
+  end
+  a.contact '1/2', b
+  p a
+  puts Array.new(32,'-').join
+
+  # 回溯父节点
+  t = Tree.init
+  p t['a/b/c'] = :d
+  p t
+  puts Array.new(32,'-').join
+  p '1:',t['1'],t['1/'].parent
+  puts Array.new(32,'-').join
+  p '1/2:',t['/1/2'],t['1/2'].parent
+  puts Array.new(32,'-').join
+  p '1/2/3:',t['1/2/3/'],t['1/2/3'].parent
+  puts Array.new(32,'-').join
+  p '1/2/3/4:',t['1/2/3/4'],t['1/2/3/4'].parent
+  puts Array.new(32,'-').join
+  p 'a:',t['a'],t['a'].parent
+  puts Array.new(32,'-').join
+  p 'a/b:',t['a/b'],t['a/b'].parent
+  puts Array.new(32,'-').join
+  require './exception'
+  p 'a/b/c:',t['a/b/c'],t['/a/b/c'].try(:parent)
+  puts Array.new(32,'-').join
+  p 'a/b/c/d:',(begin;t['a/b/c/d'];rescue(Exception);'cant pass path="a/b/c/d" with leaf["a/b/c"]';end)
+  puts Array.new(32,'-').join
+=end
+
+class Tree < Hash
+  VERSION = '0.2.0'
+
+  def self.init
+    Tree.new{|tree, path|tree[path] = Tree.new(tree,&tree.default_proc) }
+  end
+
+  def self.clear
+    self.init
+  end
+
+  attr_accessor :parent
+
+  def initialize parent=nil
+    @parent=parent
+    super()
+  end
+
+  def [] key
+    unless key.instance_of?(String) && key.include?('/')
+      child = super(key)
+      child.parent = self if child.respond_to? :parent
+      return child
+    end
+    key.include?('/') ? send(:route,key) : super(key)
+  end
+
+  def []= key, value
+    unless key.instance_of?(String) && key.include?('/')
+      super(key,value)
+      child = self[key]
+      child.parent = self if child.respond_to? :parent
+      return child
+    end
+    key.include?('/') ? (key=='/' ? (raise PathError, "Class Tree can't use '/' as a key except rootself.") : send(:mount,key,value)) : super(key,value)
+  end
+
+  def route path
+    unless path.instance_of?(String) && path.include?('/')
+      post = self[path]
+      post.parent = self if post.respond_to? :parent
+      return post
+    end
+    return self if path=='/'
+    hops = path.split('/')
+    hops.delete ''
+    curr = hops.shift
+    if hops.empty?
+      self[curr]
+    else
+      # if a leaf exists, any path walkthrough leaf would not pass;
+      # if no leaf exists, any path walkthrough could be pass.
+      raise PathError, "The current expected path`#{path}` not exist." unless self[curr].respond_to? :route
+      self[curr].send "route", hops.join('/')
+    end
+  end
+
+  # Caution: #mount will arrive the deepest leaf and change the passthrough
+  def mount path, store
+    unless path.instance_of?(String) && path.include?('/')
+      self[path]=store
+      post = self[path]
+      post.parent = self if post.respond_to? :parent
+      return post
+    end
+    raise PathError, "Class Tree can't mount an value on the root." if path=='/'
+    hops = path.split('/')
+    hops.delete ''
+    curr = hops.shift
+    if hops.empty?
+      self[curr]=store
+      self.delete nil # except ['/']=store to {nil=>store}
+    else
+      self[curr]=Tree.init
+      # self[curr].send "route", hops.join('/')
+      self[curr].send "mount", hops.join('/'), store
+    end
+  end
+
+  # Caution: #emerge can adapt on HashObject but loose the tree-ability
+  def emerge path, tree
+    if tree.is_a?(Hash)
+      hops = path.split("/")
+      popz = hops.pop
+      curr = hops.join('/')
+      target = hops.empty? ? self[popz] : self.route(curr)
+      raise PathError, "The current node [\"#{path}\"]=>#{target} not respond to contact/merge." unless target.respond_to? :route
+      target.merge!(tree)
+      return target
+    end
+  end
+
+  def contact path, tree
+    if tree.is_a?(Tree)
+      target = self.route path
+      raise PathError, "The current node [\"#{path}\"]=>#{target} not respond to contact/merge." unless target.respond_to? :route
+      target.merge!(tree)
+      tree.parent = target
+    end
+  end
+
+  class PathError < Exception
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cc
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Matt
@@ -54,7 +54,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: custom core
 test_files: []