casetdown 0.9.0

data/EnData/api-app.rb

@@ -0,0 +1,89 @@
+#coding:utf-8
+
+##################################################################################################################
+# APPLICATION FOR WEBOOT API CALLING
+##################################################################################################################
+require 'weboot'
+
+def cmds tabname
+  return EnData.get_body(tabname).join(";")
+end
+
+def run tables, bind_table
+  EnData::ApiRequest.run tables, bind_table
+end
+
+##################################################################################################################
+#
+# EnData::ApiRequest
+#
+# API:   template1 # an example of templates
+# API:   bind      # single bind
+# API:   send      # single send
+# API:   make      # batch bind
+# API:   handle    # batch send
+# API:   run       # make + handle
+#
+# Step1: EnData::ApiRequest.make
+# CASE:  table1 × table2 × ... >--(join)--> task_table + bind_table(ref,val) >--eval(binding)--> task_instances
+# USE:   EnData.join_table() |> EnData.make_ref |> EnData.make_doc |> EnData::ApiRequest.bind
+#
+# Step2: EnData::ApiRequest.handle
+# CASE:  task_instances >--(API CALLING)--> running_results
+# USE:   EnData::ApiRequest.send
+#
+##################################################################################################################
+module EnData
+  module ApiRequest
+    module_function
+
+    def template1
+%Q|POST ${path} HTTP/1.1
+Host: ${server}
+Accept: */*
+Content-Type: application/json
+
+{
+  "protocol": "${protocol}",
+  "host": "${device}",
+  "user": "${access-key}",
+  "app-key": "${app-key}",
+  "cmds": "${operations}",
+  "method": "${processes}"
+}|
+    end
+
+    def bind options, template=EnData::ApiRequest.template1
+      Replacement.init
+      ['path','server','protocol','device','access-key','app-key','operations','processes'].each do|key|
+        Replacement[key] = options[key].to_s
+      end
+      return TinText.instance(template)
+    end
+
+    def send context
+      request = Weboot.request context
+      response = Weboot.construct request
+      report = JSON.parse(response['body'])['content']
+    end
+
+    def make tables, bind_table
+      # Please don't join too much tables
+      tasks = tables.shift
+      tasks = EnData.join_table(tasks, tables.shift) until tables.empty?
+      bind_table.each{|refname, reftext|tasks = EnData.make_ref(tasks, refname, reftext)}
+      binds = EnData.make_doc(tasks)
+      instances = binds.map{|binding|EnData::ApiRequest.bind binding} # with EnData::ApiRequest.template
+    end
+
+    def handle instances
+      instances.map{|instance| EnData::ApiRequest.send instance}
+    end
+
+    def run tables, bind_table
+      instances = EnData::ApiRequest.make tables, bind_table
+      EnData::ApiRequest.handle(instances)
+    end
+
+  end
+end

data/EnData/endata-app.rb

@@ -0,0 +1,62 @@
+#coding:utf-8
+
+##################################################################################################################
+#
+# EnData
+#
+# CASE: table from DATA
+# USE:  EnData.table(table_name)
+# 
+# CASE: table1 × table2
+# USE:  EnDataApp.join_table(table_name1, table_name2)
+#
+# CASE: table[head|body] >--(cut-head)--> table[body]
+# USE: EnDataApp.get_body(table_name)
+#
+# CASE: table[head=[field*], record=[value*]] >----> tree{field=>value, ...}
+# USE:  EnDataApp.make_doc(table)
+#
+# CASE: ${refname} >--(replace)--> reftext
+# USE:  EnDataApp.make_ref(table, refname, reftext)
+#
+##################################################################################################################
+
+module EnData
+  module_function
+
+  # [CUSTOM_YOUR_NAME@endata CUSTOM_YOUR_PATH]$ruby table
+  def table name='table'
+    EnData.load()
+    EnData.parse()
+    EnData.run(EnData.source (EnData.select name: name))
+  end
+
+  def join_table name1, name2
+    table1 = EnData.table(name1)
+    table2 = EnData.table(name2)
+    table1.绑定表头 table1.first
+    table2.绑定表头 table2.first
+    return table1.拼接 table2
+  end
+
+  def get_body name
+    EnData.table(name)[1..-1]
+  end
+
+  def make_doc table
+    return table[1..-1].inject([]) do|doc, record|
+      rec = {}
+      record.each_with_index{|value, index|rec[table[0][index]] = value}
+      doc.push rec; doc
+    end
+  end
+
+  def make_ref table, refname, reftext
+    return table.inject([]) do|newtab, record|
+      newrec = []
+      record.each{|field|newrec << (field=="${#{refname}}" ? reftext : field)}
+      newtab.push newrec; newtab
+    end
+  end
+
+end

data/EnData/endata.rb

@@ -0,0 +1,81 @@
+#coding:utf-8
+
+require 'yaml'
+require 'json'
+
+module EnData
+  extend self
+  
+  def load
+    @__EnData__ ||= DATA.read
+    return @__EnData__
+  end
+  
+  # ['username'@EnData 'workpath']$ 'command' 'scriptname' 'argument1#' ...
+  def parse data=@__EnData__
+    @__datalist__ = {}
+    temp = {
+      'user' => '',
+      'path' => '',
+      'handler' => '',
+      'name' => '',
+      'arguments' => [],
+      'context' => []
+    }
+    data.split("\n").each do|line|
+      if matcher = /^\[[\w|\s]*\@endata[\w|\s|\/|\~]*\]\$/.match(line)
+        @__datalist__[temp['name']] = temp
+        front, back = line.split("@endata")
+        usr = front.sub("[",'').strip
+        pwd = back.split("]")[0].strip
+        cmd = back.split("]$")[-1].split(" ")
+        handler, name, arguments = cmd[0], cmd[1], cmd[2..-1]
+        context = ''
+        temp = {
+          'user' => usr,
+          'path' => pwd,
+          'handler' => handler,
+          'name' => name,
+          'arguments' => arguments,
+          'context' => []
+        }
+      else
+        temp['context'] << line
+      end
+    end
+    @__datalist__[temp['name']] = temp
+    return @__datallist__
+  end
+  
+  def select options={}
+    if name = options[:name]
+      @__datalist__[name]
+    else
+      sets = @__datalist__.values
+      options.each do|key, val|
+        sets = sets.select{|s|s[key.to_s]==val.to_s}
+      end
+      sets.first
+    end
+  end
+  
+  def source script
+    return nil unless script && script['context']
+    context = script['context'].join("\n")
+    case script['handler']
+    when 'ruby'
+      context
+    when 'yaml'
+      YAML.load context
+    when 'json'
+      JSON.parse context
+    else # plaintext
+      context
+    end
+  end
+  
+  # ruby inline
+  def run scripts=nil, &script_block
+    scripts ? self.module_eval(scripts) : self.module_eval(&script_block)
+  end
+end

data/Tabot/newtab.rb

@@ -0,0 +1,14 @@
+#coding:utf-8
+require 'json'
+
+module Newtab
+  module_function
+
+  def trans_table file, sheet, env='conda activate py311', temp='_temp.json'
+    table = %Q|python -c "import pandas as pd;pd.read_excel('#{file}',sheet_name='#{sheet}').to_json('#{temp}',orient='records',force_ascii=False)"|
+    system("#{env} && #{table}")
+    doc = JSON.parse File.read(temp)
+    File.delete(temp)
+    return doc
+  end
+end

data/Tabot/simtab.rb

@@ -0,0 +1,258 @@
+#coding:utf-8
+
+module SimTab
+  ##################################################################
+  # 说明
+  # 这个模块用于符合人类直觉的二维表处理,方便处理报表
+  # 一般格式是 [[表头], [记录], ...]
+  # 所有的操作处理都是针对记录不针对表头的
+  # 表头的格式由人主观决定,只提供绑定方法
+  ##################################################################
+
+  ##################################################################
+  # 读取报表
+  ##################################################################
+  
+  def self.读取报表 路径,分隔符="\t"
+    begin
+      File.read(路径).gsub("\r","").split("\n").map{|l|l.split(分隔符)}
+    rescue
+      File.read(路径).force_encoding('GBK').encode("UTF-8").gsub("\r","").split("\n").map{|l|l.split(分隔符)}
+    end
+  end
+
+  def self.读取csv 路径,format=:raw
+    require 'csv'
+    csv = File.read(路径).force_encoding("GBK").encode("UTF-8")
+    content = CSV.parse(csv, headers:(format==:csv))
+    table = content.绑定表头 content[0]
+    return table
+  end
+
+  def self.读取html 文档
+    doc = Nokogiri::HTML(文档)
+    table = []
+    doc.css("table").css("tr").each do|tr|
+      record = []
+      tr.css("td").each do|td|
+        record << td.text
+      end
+      table << record
+    end
+    return table
+  end
+
+  ##################################################################
+  # 表头
+  # 如果已有表头,只需要'#绑定表头'指定表头即可
+  # 如果没有表头,可以'#表头'自动生成表头,也可以指定'#生成表头'再'#绑定表头'
+  ##################################################################
+
+  def 生成表头 前缀=''
+    max = self.inject(0){|max,item|(max < item.size ? item.size : max)}
+    @表头 = Array.new(max){|i|i.to_s}
+    self.unshift @表头
+    @表头
+  end
+
+  def 绑定表头 表头
+    @表头 = 表头 if 表头.instance_of?(Array)
+    self.each do|记录|
+      记录.绑定表头 表头 if 记录.instance_of?(Array)
+    end
+  end
+
+  def 表头
+    @表头 ||= []
+    if !@表头 or @表头.empty?
+      自定义表头 = 生成表头
+      绑定表头 自定义表头
+    end
+    @表头
+  end
+  
+  def 去掉表头
+    @表头 = []
+    self.shift # 只去掉形式上的表头,不会去掉记录的内联表头,以便恢复; 如想彻底去掉每条记录的表头,可绑定一个空表头
+    self
+  end
+
+  def 展示表头
+    索引表 = []
+    @表头.each_with_index{|c,i|索引表 << "#{"%02s"%i}: #{c}"}
+    索引表.join("\n")
+  end
+
+  # 特殊的双层表头，计算时转化为单层（原单层不变）
+  def self.解析双层表头 列表
+    return 列表 unless 列表[0].instance_of?(Array)
+    表头 = []
+    列表[0].each_with_index do|item,index|
+      item=='' and index==0 and head = ''
+      item=='' and index >0 and head = 表头[-1].split("#")[0]
+      item!='' and head = item
+      表头 << [head, 列表[1][index]].join("#")
+    end if 列表.size == 2 && 列表[0].instance_of?(Array)
+    if 列表[0].size < 列表[1].size
+      num = 列表[1].size - 列表[0].size
+      head = 表头[-1].split("#")[0]
+      表头 += 列表[1][-1*num..-1].map{|i|"#{head}##{i}"}
+    end
+    return 表头
+  end
+
+  # 特殊的双层表头，输出前转化为多层（原单层不变）
+  def self.生成双层表头 列表
+    表头 = 列表.map{|复合表头|复合表头.split("#")}
+    return [列表] if 表头[0].size==1
+    row1,row2 = [],[]
+    表头.each do|items|
+      row1 << items[0]
+      row2 << items[1]
+    end
+    return [row1,row2]
+  end
+
+  ##################################################################
+  # 查询（行）、选择（列）、排序
+  # 这里的计算结果都是生成新表
+  ##################################################################
+  
+  def 字段查询 字段,内容
+    索引 = self.表头.index(字段)
+    新表 = [self.表头]+self.select{|c|c[索引]==内容}
+    新表.绑定表头 self.表头
+    新表
+  end
+  
+  def 查询
+    结果 = []
+    self[1..-1].each do|记录|
+      yield(记录) and (结果.push 记录)
+    end
+    新表 = [self.表头]+结果
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  def 自定义排序
+    字典,逆序,counter = {},nil,0
+    self[1..-1].each_with_index do|记录,索引|
+      键,逆序 = yield(记录)
+      字典[键+"_#{"%010d"%counter}"] = 索引+1
+      counter += 1
+    end
+    结果 = 字典.keys.sort.inject([]) do|结果,键|
+      结果 << self[字典[键]]
+      结果
+    end
+    逆序==:reverse and 结果.reverse!
+    新表 = [self[0]]+结果
+    新表.绑定表头 self.表头
+    新表
+  end
+  
+  def 排序
+    新表 = [self[0]]+self[1..-1].sort
+    新表.绑定表头 self.表头
+    新表
+  end
+  
+  def 逆序
+    新表 = [self[0]]+self[1..-1].reverse
+    新表.绑定表头 self.表头
+    新表
+  end
+
+  # 可以使用“.字段(index|"column"|...)”查询，找不到查询名称的场合用名称做占位符
+  def 字段 *属性表
+    字段表,新表头 = [],[]
+    属性表.each do|属性|
+      if 索引 = self.表头.index(属性)
+        字段表 << self[索引]
+        新表头 << 属性
+      else
+        字段表 << 属性
+        新表头 << 属性.to_s
+      end
+    end
+    if 字段表.size>1
+      字段表.绑定表头 新表头
+      字段表
+    else
+      字段表[0]
+    end
+  end
+
+  # select 在集合中指选择符合条件的某些元素，在SQL中指投影到具体的列上，这里偏向后者，前者可以对应查询
+  def 选择 *字段列表 # col_num or 'col_name' or filler
+    字段索引 = 字段列表.map{|f|r = f.instance_of?(Integer) ?  f : self.表头.index(f); r ? r : f }
+    新表头 = 字段列表.map{|f|r = f.instance_of?(Integer) ?  self.表头[f] : f; r ? f : r }
+    新表 = [新表头]+self[1..-1].map{|记录|字段索引.map{|索引|索引.instance_of?(Integer) ? 记录[索引] : 索引}}
+    新表.绑定表头 新表头
+    新表
+  end
+
+  def 拼接 另一个表
+    新表头 = self.表头 + 另一个表.表头
+    新表 = [新表头]+self[1..-1].product(另一个表[1..-1]).map{|t1,t2|t1+t2}
+    新表.绑定表头(新表头)
+    return 新表
+  end
+
+  ##################################################################
+  # 统计
+  ##################################################################
+
+  def 统计 字段
+    结果 = {}
+    索引 = self[0].index(字段)
+    self[1..-1].each do|记录|
+      结果[ 记录[索引] ] ||= []
+      结果[ 记录[索引] ] << 记录
+    end if 索引
+    结果
+  end
+
+  def 字段条目数统计 路径='.'
+    字段唯一统计 = []
+    Dir.mkdir(路径) unless File.exist?(路径)
+    self[0].each do|字段|
+      统计表 = self.统计 字段
+      字段数值统计 = []
+      统计表.each do|字段值,条目|
+        字段数值统计 << "#{字段值}\t:\t#{条目.size}"
+      end
+      字段唯一统计 << "#{字段}\t:\t#{统计表.keys.size}"
+      Dir.mkdir("#{路径}/字段数值统计") unless File.exist?("#{路径}/字段数值统计")
+      File.write "#{路径}/字段数值统计/#{字段}(#{统计表.keys.size}).txt", 字段数值统计.join("\n")
+    end
+    File.write "#{路径}/字段唯一统计.txt", 字段唯一统计.join("\n")
+  end
+
+  def 建立档案
+    文档 = []
+    self[1..-1].each_with_index do|记录,记录索引|
+      record = {'row' => 记录索引+1 }
+      记录.each_with_index do|字段,字段索引|
+        record[ self.表头[字段索引] ] = 字段
+      end
+      文档 << record
+    end
+    return 文档
+  end
+
+  ##################################################################
+  # 排版
+  ##################################################################
+
+  def 展示列表
+    self.map{|记录|记录.join("\t")}.join("\n")
+  end
+
+end
+
+class Array
+  attr_reader :表头
+  include SimTab
+end

data/TextUtils/text_absparser.rb

@@ -0,0 +1,42 @@
+#coding:utf-8
+# require 'custom-core/string'
+
+module ABString
+  # {:;} = Left Colon and Semicolon to Right Brace(LCSRB)
+  # {name : params ; body}
+  def parse_lcsrb string
+    head = "{"
+    tail = "}"
+    sequences = TextAbstract.match_cascade(string.gsub("\r",""),head,tail)
+    blocks = sequences.select{|i|i.instance_of?(Array)}
+    
+    blocks.inject({}) do|table,block|
+      prename,prebody = block[1..-2].join.split(":")
+      name = diet(prename)
+      if prebody.include?(';')
+        preparams,postbody = prebody.split(";")
+        params = preparams.to_s.split(",").map{|r|diet(r)}
+      else
+        params,postbody = [],prebody
+      end
+      body = diet(postbody).split("\n").map{|line|diet(line)}.join("\n")
+      table[name] = [name,params,body]
+      table
+    end
+  end
+
+  def parse string,option
+    case option
+    when :lcsrb
+      parse_lcsrb(string)
+    else
+      string
+    end
+  end
+
+  def diet string
+    string.strip.gsub("\t"," ")
+  end
+
+  module_function :parse,:diet,:parse_lcsrb
+end

data/TextUtils/text_abstract.rb

@@ -0,0 +1,84 @@
+#coding:utf-8
+
+module TextAbstract
+
+  # 移植以前的facility/helpers/String::draw_fragments
+  # 特定环境下的遗留方法，不推荐常用
+  def self.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
+
+  # 用来重写以前的facility/helpers/String::match_fragments
+  # start和finish有严格的先后顺序，一段不完不起另一段
+  def self.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包含在另一个start和finish内，但在全局上还是顺序的
+  def self.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
+  
+  def self.match_html_tag html,tag
+    paragraphs = self.match_cascade(html,"<#{tag}","</#{tag}>")
+  end
+  
+end