cc 1.1.0

data/file.rb

@@ -0,0 +1,253 @@
+#coding:utf-8
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'file'
+
+  puts "The current directory:"
+  pp '..'.directory
+
+  puts '',"The filepaths under current directory:"
+  pp '..'.directory.paths
+  
+  puts '',"The current directory whether include somewhere part of pathname:"
+  pp '..'.directory.find?(__FILE__)
+
+  tab1 = File.read("1/1.txt")
+  tab2 = File.read("2/1.txt")
+  text1 = Diff.shift tab1, 2.row, 1.row
+  text1 = Diff.shift text1, 5.line, 1.row
+  text1 = Diff.shift text1, 8.line, 2.rows
+  text2 = Diff.shift tab2, 7.row, 1.line
+  text2 = Diff.shift text2, 11.row, 1.line
+  tab = Diff.show text1, text2
+  File.write "tab.txt", tab.map{|t|t.join("|")}.join("\n")
+
+  File.diff('1/1.txt', '2/1.txt', 'tmp.diff', 'git diff')
+  File.diffs('1', '2', 'tmp.diff', 'git diff').save_into 'diff.txt'
+=end
+
+class String
+  # "PathString" => {FolderTree}
+  def directory_detection
+    folder = {}
+    Dir["#{self}/*"].each do|path|
+      next if ["..","."].include?(path)
+      epath = File.expand_path(path)
+      pathname = epath.split("/")[-1]
+      if File.directory?(epath)
+        sub = epath.directory_detection
+        folder.merge!(pathname=>sub) # epath
+      else
+        folder[pathname] = "file" # epath
+      end
+    end
+    return folder
+  end
+
+  alias :directory :directory_detection
+
+  def self.load_from path
+    buffer = File.open(path,'r'){|f|f.read}
+    if buffer.encoding=="GBK"
+      begin
+        return buffer.encode("UTF-8") 
+      rescue Encoding::UndefinedConversionError=>e
+        if e.message.include?("from GBK to UTF-8")
+          buffer.force_encoding("UTF-8")
+        else
+          raise "#{e.message} (#{e.class})"
+        end
+      end
+    end
+    return buffer
+  end
+  
+  def save_into path
+    File.open(path,'w'){|f|f.write(self)}
+  end
+  
+  def save_binary_into path
+    File.open(path,'wb'){|f|f.write(self)}
+  end
+
+  def append_into path
+    unless File.exist?(path)
+      save_into(path)
+    else
+      File.open(path,'a'){|f|f.write(self)}
+    end
+  end
+end
+
+class Hash
+  # {FolderTree} => ["PathString"List]
+  def paths
+    traces = []
+    self.each do|name,tag|
+      traces << [name]
+    end
+    self.each do|name,tag|
+      if tag.is_a?(Hash)
+        subs = tag.paths
+        new_traces = []
+        traces.each do |trace|
+          if trace[-1] == name
+            new_sub = []
+            subs.each{|vector|new_sub << trace + vector}
+            new_traces += new_sub
+          else
+            new_traces << trace
+          end
+        end
+        traces = new_traces
+      end
+    end
+    return traces
+  end
+  
+  def find_path nodename
+    result = []
+    self.paths.each do|path|
+      result << path.join("/") if path.join("/").include?(nodename)
+    end
+    return result
+  end
+
+  alias :"find?" :find_path
+end
+
+load('json.rb') # require 'json'
+load('yaml.rb') # require 'yaml'
+
+class File
+  def self.load_json filepath
+    path = filepath.include?('.json') ? filepath : filepath+".json"
+    context = File.open(path,'r'){|f|f.read}.force_encoding("UTF-8")
+    JSON.parse(context)
+  end
+  
+  # ...
+  # yaml = YAML.dump( obj )
+  # obj = YAML.load( yaml )
+  # File.open( 'path.yaml', 'w' ) do |out| YAML.dump( obj, out ) end
+  # obj = YAML.load_file("path.yaml")
+  def self.load_yaml filepath
+    path = filepath.include?('.yml') ? filepath : filepath+".yml"
+    context = File.open(path,'r'){|f|f.read}.force_encoding("UTF-8")
+    YAML.load(context)
+  end
+
+  # 这个方法保证对象中的unicode被正确转换为YAML内容（已过时）
+  # eg. File.open('temp.yml','w'){|f|f.write [ "alphabet",{:symbol=>123.321},'"其♂ 他·文♀字"' ].to_yaml.unicode}
+  # def unicode
+  #   yaml_string = self#.to_yaml # only valid for yaml string!
+  #   yml_unic = begin
+  #     str = (/\"(.+)\"/.match yaml_string)[0]
+  #     yaml_string.gsub(str,eval(":#{str}").to_s)
+  #   rescue
+  #     yaml_string
+  #   end
+  #   return yml_unic
+  # end
+
+  def self.clear_edit_backfile path
+    if File.exist?(path) && path[-1]=='~'
+      File.delete(path)
+      puts "Delete #{path} successfully!"
+    else
+      puts "Cannot delete #{path}, just pass away!"
+    end
+  end
+
+  def self.clear_edit_backfile_path path='.'
+    Dir["#{path}/*~"].each do|path|
+      begin
+        File.delete(path)
+        puts "Delete #{path} successfully!"
+      rescue
+        puts "Cannot delete #{path}, just pass away!"
+      end
+    end
+  end
+
+  def self.diff left_path, right_path, report_path='tmp.diff', selector='diff'
+    `echo "\n#{Array.new(64,'-').join}\n" >> #{report_path}`
+    `echo "<< #{left_path} <=> #{right_path} >>\n" >> #{report_path}`
+    `#{selector} #{left_path} #{right_path} >> #{report_path}`
+  end
+
+  def self.diffs adir, bdir, head='.',selector='diff'
+    alist = (head+'/'+adir).directory_detection.paths.map{|path|path.join('/')}
+    blist = (head+'/'+bdir).directory_detection.paths.map{|path|path.join('/')}
+
+    onlyalist = alist - blist
+    onlyblist = blist - alist
+    commnlist = alist & blist
+
+    report = []
+    unless onlyalist.empty?
+      report << "only #{adir} exist files:\n"
+      report += onlyalist.map{|path|path}
+      report << '' << Array.new(64,'=').join
+    end
+
+    unless onlyblist.empty?
+      report << "\nonly #{bdir} exist files:\n"
+      report += onlyblist.map{|path|path}
+      report << '' << Array.new(64,'=').join
+    end
+
+    unless commnlist.empty?
+      report << "\ncommon files comparison:"
+      commnlist.each do|path|
+        self.diff("#{head}/#{adir}/#{path}", "#{head}/#{bdir}/#{path}", 'diff.tmp', selector)
+      end
+      File.exist?('diff.tmp') and report << File.read('diff.tmp')
+      File.exist?('diff.tmp') and File.delete('diff.tmp')
+    end
+
+    return report.join("\n")
+  end
+end
+
+module Diff
+  module_function
+
+  # 该方法只用来排成两列显示, 并不真正执行比较, 已经有File.diff/File.diffs完成该工作
+  def show text1, text2, shift=0
+    list1 = text1.instance_of?(String) ? text1.split("\n") : text1
+    list2 = text2.instance_of?(String) ? text2.split("\n") : text2
+    max1 = list1.map{|r|r.length}.max
+    max2 = list2.map{|r|r.length}.max
+    shift > 0 and (list1 = Array.new(shift, "")+list1) #and (list2 += Array.new(shift, ""))
+    shift <= 0 and (list2 = Array.new(shift, "")+list2)# and (list1 += Array.new(shift, ""))
+    size = [list1.size, list2.size].max+(shift>0 ? shift : shift*(-1))
+    rows = []
+    size.times.each do|index|
+      rows << [
+        list1[index].to_s+Array.new(max1 - list1[index].to_s.length, " ").join, 
+        list2[index].to_s+Array.new(max2 - list2[index].to_s.length, " ").join
+      ]
+    end
+    return rows
+  end
+  
+  def shift text, index, shift=1
+    list = text.instance_of?(String) ? text.split("\n") : text
+    shift.times.each do list.insert(index,"") end
+    return list.join("\n")
+  end
+end
+
+class Integer
+  # 数字计量单位
+  def line;return self;end
+  def lines;return self;end
+  def row;return self;end
+  def rows;return self;end
+end

data/kernel.rb

@@ -0,0 +1,227 @@
+#coding:utf-8
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'kernel' # immediately when loading this file
+
+  uses 'number', 'string'
+  reloads 'number','string'
+
+  module AModule
+    def a_method;'a';end
+  end
+  module BModule
+    def b_method;'b';end
+  end
+  class AClass
+    includes AModule, BModule
+  end
+  obj1 = AClass.new
+  p obj1.respond_to?(:a_method), obj1.respond_to?(:b_method)
+
+  obj2 = Object.new
+  p obj2.respond_to?(:a_method), obj2.respond_to?(:b_method)
+  obj2.extends AModule, BModule
+  p obj2.respond_to?(:a_method), obj2.respond_to?(:b_method)
+
+  class A1
+    def a2; A2.new; end
+  end
+  class A2
+    def a3; A3.new; end
+  end
+  class A3
+    def a4; A4.new; end
+  end
+  class A4
+    def a5; false; end
+  end
+  class String
+    def to_bill; return false; end
+  end
+
+  puts "a.sends(:b,:c,:d) => #{A1.new.sends(:a2,Proc.new{|i|i.send :a3},:a4)} #=> #<A4 ...>"
+  # a.sends(:b,:c,:d) => #<A4:0x0000000006425648> #=> #<A4 ...>
+
+  puts "a.cond_insect(:b,:c,:d) => #{A1.new.cond_insect(:a2,lambda{|s|s.send :a3},:a4 ) ? :true : :false}"
+  # a.cond_insect(:b,:c,:d) => true
+
+  puts "a.cond_union(:b,:c,:d) => #{A3.new.cond_union(:a4,Proc.new{|s|s.a5},:to_s,'to_bill' ) ? :true : :false} #=> #<A4 ...> "
+  # a.cond_union(:b,:c,:d) => true #=> #<A4 ...> 
+
+  puts "a.mapr(fun1, fun2, fun3) => #{"15a".mapr(lambda{|s|s.to_i+1}, lambda{|s|s.to_s+"b"}, lambda{|s|s[-1]}).last}"
+  # a.mapr(fun1, fun2, fun3) => b
+
+  puts "a.check_insect(cond1, cond2, cond3) => #{"15a".check_insect( lambda{|s|s.to_i < 20}, lambda{|s|s.to_i > 10}, lambda{|s|s.size==3} )}"
+  # a.check_insect(cond1, cond2, cond3) => true
+
+  puts "a.check_union(cond1, cond2, cond3) => #{"15a".check_union( lambda{|s|s.is_a?(Symbol)}, lambda{|s|s.respond_to?(:to_json)}, lambda{|s|s.instance_of?(Module)} )}"
+  # a.check_union(cond1, cond2, cond3) => false
+=end
+
+module Kernel
+  def requires *script_names
+    script_names.each do|script_name|
+      use script_name#.encode('GBK')
+    end
+  end
+
+  def use script_path
+    if File.exist?(script_path)
+      require_relative script_path
+    elsif File.exist?(script_path+'.rb')
+      require_relative script_path+'.rb'
+    else
+      warn "无法找到路径: #{script_path}"
+    end
+  end
+
+  alias :uses :requires
+  
+  def reloads *script_paths
+    script_paths.each do|script_path|
+      reload script_path
+    end
+  end
+
+  def reload script_path
+    if File.exist?(script_path)
+      load script_path
+    elsif File.exist?(script_path+'.rb')
+      load script_path+'.rb'
+    else
+      warn "无法找到路径: #{script_path}"
+    end
+  end
+
+  def includes *modules
+    modules.each do|mod|
+      include mod
+    end
+  end
+end
+
+class Object
+  def extends *modules
+    modules.each do|mod|
+      extend mod
+    end
+  end
+
+  #######################################################
+  # walkthrough function-chain
+  #######################################################
+  
+  # CALL: obj.sends(func1, func2, func3, ...)
+  # RETN: obj.func1.func2.func3...
+  def sends *funcs
+    target = self
+    funcs.each do|func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        target = target.send(*func)
+      elsif func.is_a?(Array)
+        target = target.send(*func)
+      elsif func.instance_of?(Proc)
+        target = func.call(*target)
+      end
+    end
+    return target
+  end
+  
+  # CALL: obj.maps(func1, func2, func3, ...)
+  # REPR: ... func3.call( func2.call( func1.call(obj) ) )
+  # RETN: [stack1, stack2, stack3, ...]
+  def mapr *funcs
+    red, target = [], self
+    funcs.each do|func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        target = target.send(*func)
+      elsif func.is_a?(Array)
+        target = target.send(*func)
+      elsif func.instance_of?(Proc)
+        target = func.call(*target)
+      end
+      red << target
+    end
+    return red
+  end
+  
+  # CALL: obj.cond_ins(attr1, attr2, attr3, ...)
+  # REPR: obj.attr1 && obj.attr1.attr2 && obj.attr1.attr2.attr3... 
+  # RETN: obj.attr1...attrn/false (false must be specified literally)
+  def cond_insect *funcs
+    target = self
+    flag = funcs.inject(true) do|flag, func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        target = target.send(*func)
+      elsif func.is_a?(Array)
+        target = target.send(*func)
+      elsif func.instance_of?(Proc)
+        target = func.call(*target)
+      end
+      flag && target
+    end
+  end
+
+  # CALL: obj.cond_union(attr1, attr2, attr3, ...)
+  # REPR: obj.attr1 || obj.attr1.attr2 || obj.attr1.attr2.attr3...
+  # RETN: obj.attrX (Y>X, when obj.attrY is false/not exist, obj.attrX is the first not false)
+  def cond_union *funcs
+    target = self
+    flag = funcs.inject(false) do|flag, func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        target = target.send(*func)
+      elsif func.is_a?(Array)
+        target = target.send(*func)
+      elsif func.instance_of?(Proc)
+        target = func.call(*target)
+      end
+      flag || target
+    end
+  end
+  
+  #######################################################
+  # map-reverse function-chain
+  # 
+  # Tips:
+  # map := obj.map{|o|func(o)}
+  # map-reverse := funcs.map{|func|func(obj)}
+  #######################################################
+
+  # CALL: obj.check_insect(cond1, cond2, cond3, ...)
+  # REPR: cond1(obj) && cond2(obj) && cond3(obj) ...
+  # RETN: blockn(obj)/false (false must be specified)
+  def check_insect *funcs
+    flag = funcs.inject(true) do|flag, func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        flag && self.send(func)
+      elsif func.is_a?(Array)
+        flag && self.send(*func)
+      else
+        flag && func.call(*self)
+      end
+    end
+  end
+  
+  # CALL: obj.check_union(cond1, cond2, cond3, ...)
+  # REPR: cond1(obj) || cond2(obj) || cond3(obj) ...
+  # RETN: true/false
+  def check_union *funcs
+    flag = funcs.inject(false) do|flag, func|
+      if func.is_a?(Symbol) or func.is_a?(String)
+        flag || self.send(func)
+      elsif func.is_a?(Array)
+        flag || self.send(*func)
+      else
+        flag || func.call(*self)
+      end
+    end
+  end
+
+end
+
+

data/monkey-patch.rb

@@ -0,0 +1,116 @@
+#coding:utf-8
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'monkey-patch'
+
+  class A1
+    def a1; :a1; end
+  end
+
+  class A2 < A1
+    def a2; :a2; end
+  end
+
+  module Mod1
+    def mod1; :mod1; end
+  end
+
+  module Mod2
+    def mod2; :mod2; end
+  end
+
+  class A1
+    include Mod1
+  end
+
+  a = A2.new
+  a.extend Mod2
+
+  puts '',"一个实例的独有方法 = 它的基类实例方法 - 它的父类实例方法 = 本级实例方法 + 本实例扩展方法"
+  p a.unique_methods == a.compize(A1)
+
+  puts '',"一个实例的独有方法 根据它选择的基类不同而不同"
+  p a.compize(Object), a.compize(A1), a.compize(A2)
+
+  puts '',"但不基于模块方法"
+  p a.compize(Mod1), a.compize(Mod2)
+
+  puts '',"打标签备份方法"
+  p a.compize(Object), a.mod1, a.mod2
+  class << a
+    verize :mod1, "20110101"
+    revise :mod1, :mod2
+    def mod1; :mod3; end
+  end
+  p a.compize(Object), a.mod1, a.mod2, a.mod1_20110101
+=end
+
+class Object
+  attr_accessor :main_version, :versions
+  
+  def versions
+    @versions ||= []
+  end
+
+  def versions= newver
+    @versions ||= []
+    @versions << newver unless @versions.include?(newver)
+    @main_version = newver
+    return newver
+  end
+
+  def revise method1,method2
+    alias_method "tempfunc1",method1
+    alias_method "tempfunc2",method2
+    alias_method method1, "tempfunc2"
+    alias_method method2, "tempfunc1"
+  end
+  
+  def compize klass=nil
+    return self.methods - self.class.superclass.instance_methods if klass.nil?
+    return self.methods - klass.instance_methods
+  end
+  
+  def verize name, tag=nil
+    tag = Time.new.strftime("%Y%m%d%H%M%S") unless tag
+    new_name, old_name = "#{name}_#{tag}",name
+    alias_method new_name, old_name
+  end
+  
+  def verize_all tag=nil
+    tag = Time.new.strftime("%Y%m%d%H%M%S") unless tag
+    unique_methods.each do|um|
+      new_name, old_name = "#{um}_#{tag}", um
+      alias_method new_name, old_name
+    end
+  end
+  
+  def unique_methods
+    self.methods - self.class.superclass.instance_methods
+  end
+
+  def defm name, &block
+    @____ ||= Hash.new
+    @____[name] = block
+  end
+  
+  def callm name, *args
+    @____[name].call(*args)
+  end
+end
+
+module Kernel
+  def defp name, &block
+    @____ ||= Hash.new
+    @____[name] = block
+  end
+  
+  def callp name, *args
+    @____[name].call(*args)
+  end
+end

data/number.rb

@@ -0,0 +1,105 @@
+#coding:utf-8
+
+############################################################################################################
+# HOW TO USE                                                                                               #
+############################################################################################################
+
+=begin
+  require 'cc'
+  CC.use 'number' # immediately when loading this file
+
+  puts "Float to percentage:"
+  p 0.5.to_percentage, 0.55.to_percentage, 0.555.to_percentage, 0.5555.to_percentage
+
+  puts '',"Float to binary and hexadecimal:"
+  p 1102274184.317453.binform, 1102274184.317453.hexform
+
+  puts '',"Binary and Hexadecimal String to float:"
+  p "41b35e88.514498".as_hexnum, "1000001101100110101111010001000.010100010100010010011".as_binnum
+
+  puts '',"The Integral:"
+  include Math
+  def 积分函数(x,y);x-y;end
+  def f(x);x;end
+  p a = ∫(5,30,1000.0){|x|积分函数(x, 5)}
+  p b = 积分(5,30){|x|f(x)}
+=end
+
+class Float
+  def to_percentage tail=2
+    "#{(self*100).round(tail)}%"
+  end
+  
+  def binform d=100
+    mant = self%1
+    unless mant==0
+      list,cnt = [],0
+      while cnt<d && mant%1!=0
+        result = (mant%1)*2
+        list << "%b"%result.to_i
+        mant = result%1
+        cnt += 1
+      end
+      return "%b"%(self.to_i)+'.'+list.join
+    else
+      return "%b"%self
+    end
+  end
+
+  def hexform d=100
+    mant = self%1
+    unless mant==0
+      list,cnt = [],0
+      while cnt<d && mant%1!=0
+        result = (mant%1)*16
+        list << "%x"%result.to_i
+        mant = result%1
+        cnt += 1
+      end
+      return "%x"%(self.to_i)+'.'+list.join
+    else
+      return "%x"%self
+    end
+  end
+end
+
+class Integer
+  def to_percentage tail=2
+    "#{(self/100.0).round(tail)}%"
+  end
+end
+
+class String
+  def to_float
+    self.include?("%") ? self.split("%")[0].to_f/100 : self.to_f
+  end
+
+  def as_hexnum
+    int, float = self.split('.')
+    int10, float10 = eval("0x"+int), 0
+    float.split('').each_with_index{|f,i|float10 += eval("0x"+f)*16**(-1*(i+1))}
+    return (int10+float10).to_f
+  end
+  
+  def as_binnum
+    int, float = self.split('.')
+    int2, float2 = eval("0b"+int), 0
+    float.split('').each_with_index{|f,i|float2 += eval("0b"+f)*2**(-1*(i+1))}
+    return (int2+float2).to_f
+  end
+end
+
+module Math
+  def ∫(下限,上限,等分数=1000)
+    sum, x, dx = 0, 下限, (上限-下限)/(等分数*1.0)
+    loop do
+      y = yield(x)
+      sum += dx * y
+      x += dx
+      break if x>上限
+    end
+    return sum
+  end
+
+  alias :积分 :∫
+end