casetdown 0.9.0

data/TextUtils/text_mind.rb

@@ -0,0 +1,180 @@
+#coding:utf-8
+
+module TextAbstract
+
+  module Type
+    def int radix=10
+      self.to_i(radix)
+    end
+
+    def float tail=2
+      self.to_f.round(tail)
+    end
+
+    def precent tail=2
+      (self.to_f*100).round(tail).to_s+"%"
+    end
+
+    def text format=:raw
+      return self         if format==:raw
+      return self.to_json if format==:meta
+    end
+
+    def bool
+      return true   if self.downcase=='true'
+      return false  if self.downcase=='false'
+      return self.empty?
+    end
+  end
+
+  module TextOperator
+    def head? prefix, strip=false #=> bool
+      left = strip ? self.strip : self
+      left[0..(prefix.length-1)]==prefix
+    end
+
+    def tail? postfix, strip=false #=> bool
+      left = strip ? self.strip : self
+      left[(-1*postfix.length)..-1]==postfix
+    end
+
+    # def include? text #=> bool
+
+    # def empty? #=> bool
+
+    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
+
+    def draw_lines preflag, postflag #=> text, list
+      restext, contexts = TextAbstract.draw_fragments self, preflag, postflag
+    end
+
+    def match_paragraph start, finish #=> list
+      paragraphs = TextAbstract.match_paragraph self, start, finish
+    end
+
+    def match_cascade start, finish #=> list
+      paragraphs = TextAbstract.match_cascade self, start, finish
+    end
+
+    def match_xml tag #=> tree
+      document = TextAbstract.match_html_tag self,tag
+    end
+
+    # def length #=> int
+    # def size #=> int
+
+    # def strip #=> text
+    # def lstrip #=> text
+    # def rstrip #=> text
+
+    def join *texts #=> text
+      self+texts.map{|t|t}.join
+    end
+
+    def cut index1, index2=0 #=> text
+      self[(index1-1)..(index2-1)]
+    end
+
+    # def + text #=> concat text
+
+    # def * text #=> repeat text
+
+    def - text #=> text
+      self.include?(text) ? self.split(text).first : self
+    end
+
+    def / text #=> list
+      self.split(text)
+    end
+
+    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
+
+  module ListOperator
+    # def pop           #=> item
+    # def push text     #=> list
+    # def shift         #=> item
+    # def unshift text  #=> list
+    
+    # def + list        #=> list
+    # def - list        #=> list
+
+    def catch *list #=> list(list)
+      list.unshift(self)
+    end
+  
+    # def find &block   #=> item
+    # def select &block #=> list
+    # def filter &block #=> list
+    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
+
+    def sub index1, index2=0 #=> list
+      self[(index1-1)..(index2-1)]
+    end
+
+    # def map &block      #=> list
+    # def collect &block  #=> list
+
+    # def reduce(c) &block #=> item
+    # def inject(c) &block #=> item
+    # def join text #=> concat item ※ join(c) == reduce{|a,b|a+c+b}
+  end
+
+  module TreeOperator
+    # def keys    #=> list
+    # def values  #=> list
+
+    # def [] key #=> item
+    def get key #=> item
+      self[key]
+    end
+
+    # def []= key, value #=> item
+    def set key, value #=> item
+      self[key] = value
+    end
+
+    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
+

data/TinText/cache.rb

@@ -0,0 +1,24 @@
+#coding:utf-8
+
+# a light cache
+module Replacement
+  def self.init
+    @dictionary = {}
+  end
+  
+  def self.reset
+    init
+  end
+
+  def self.[] index
+    @dictionary[index]
+  end
+  
+  def self.[]= index,replacement
+    @dictionary[index]= replacement
+  end
+  
+  def self.merge hash
+    @dictionary.merge! hash
+  end
+end

data/TinText/tin_text.rb

@@ -0,0 +1,44 @@
+#coding:utf-8
+require 'erb'
+
+module TinText
+  def self.translate word
+    unless Replacement[word]==nil
+      return Replacement[word]
+    else
+      return "((#{word}))"
+    end
+  end
+
+  def self.unfolder raw
+    # <<..>> => <%=..%>
+    # {{..}} => <%..%>
+    # [[..\n....]] => <%..%>..<%..%>
+    raw.gsub(/\<\<\s*(.+?)\s*\>\>/,"<%=\\1%>")
+       .gsub(/\{\{\s*(.+?)\s*\}\}/,"<%\\1%>")
+       .gsub(/\{\{\s*(.+?)\s*/,"<%\\1").gsub(/\s*\}\}/,"\\1%>")
+       .gsub(/\[\[\s*(.+?)\s*\n/,"<%\\1%>").gsub(/\]\]/,"<%end%>")
+  end
+
+  def self.template raw
+    # ${..} ((...)) => <%=...%>
+    raw.gsub(/\(\(\s*(.+?)\s*\)\)/,"<%=TinText::translate('\\1')%>").gsub(/\$\{\s*(.+?)\s*\}/,"<%=TinText::translate('\\1')%>")
+  end
+  
+  def self.instance raw,tag=:pre
+    if tag==:pre
+      a = self.template raw
+      b = ERB.new(a).result
+      c = self.unfolder b
+      ERB.new(c).result
+    else # :post
+      a = self.unfolder raw
+      b = ERB.new(a).result
+      c = self.template b
+      ERB.new(c).result
+    end
+  end
+  
+  def self.tt raw;self.template raw;end
+  def self.ti fla;self.instance fla;end
+end

data/TinText/tintext.rb

@@ -0,0 +1,4 @@
+#coding:utf-8
+[
+  'TinText/tum', 'TinText/cache', 'TinText/tin_text'
+].each{|lib|require lib}

data/TinText/tum.rb

@@ -0,0 +1,13 @@
+#coding:utf-8
+
+# Tum = Text Unfold Method
+module Tum
+  def self.repeat statement, times
+    Array.new(times,statement).join("\n")
+  end
+  
+  # statement = '... @var ...', var in range
+  def self.iterate statement, range
+    range.collect{|item| statement.gsub("@var",item.to_s) }.join("\n")
+  end
+end

data/XMLUtils/XmlUtils.rb

@@ -0,0 +1,207 @@
+#coding:utf-8
+# REPLICA FROM IMDOC/XMLUTILS
+%w{rexml/parsers/sax2parser rexml/sax2listener rexml/document json yaml}.each{|mod|require mod}
+
+class XmlNode
+  attr_accessor :name, :attributes, :elements, :parent, :next, :prev
+
+  def initialize(option = {})
+    args = {parent: nil, attributes: {}, elements: [], prev: [], next: []}.merge(option)
+    @name = args[:name] || "OID:#{self.object_id}"
+    @attributes = args[:attributes]
+    @parent, @elements, @prev, @next = args[:parent], args[:elements], args[:prev], args[:next]
+    
+    if @parent
+      @prev << @parent unless @prev.include?(@parent)
+      @parent.elements << self unless @parent.elements.include?(self)
+      @parent.next << self unless @parent.next.include?(self)
+    end
+  end
+
+  #####################################################################################################
+  # format                                                                                            #
+  #####################################################################################################
+
+  # 三元组 ([name, attributes, [name, attributes, ...]])
+  def to_triad
+    attrs,elems = {},[]
+    @attributes.each do|k,v|
+      unless k == :text
+        attrs[k] = v
+      else
+        elems += [v].flatten
+      end
+    end
+    elems += @elements.map{|c|c.to_triad}
+    [@name, attrs, elems]
+  end
+  alias :to_a :to_triad
+
+  # 文档化 ({name: [attributes, {name: [...]}]})
+  def to_doc
+    doc = {}
+    doc[@name] = []
+    doc[@name] << @attributes #@attributes.each{|k,v|doc[@name] << {k=> v}}
+    @elements.each{|e|doc[@name] << e.to_doc}
+    return doc
+  end
+
+  # 对象化 (like js: {obj: {'-attr': val, '#text': text, obj: {...}}})
+  def to_obj
+    doc = {}
+    @attributes.each do|k,v|
+      h = k==:text ? '#' : '-'
+      doc["#{h}#{k}"] = v
+    end
+    @elements.each do|elem|
+      doc.merge! elem.to_obj
+    end
+    return {@name => doc}
+  end
+
+  # XML
+  def to_xml
+    attrs, content = '', ''
+    @attributes.each do |k,v|
+      if k == :text
+        content += "#{[v].flatten.join("\n")}"
+      elsif k == :namespace && !v
+        next
+      else
+        attrs += " #{k}=\"#{v}\""
+      end
+    end
+    return "<#{@name}#{attrs}/>" if @elements.size==0 && !@attributes[:text]
+    @elements.each do|e|
+      content += if e.is_a?(XmlNode)
+        e.to_xml
+      elsif e.instance_of?(String)
+        "#{e}"
+      end
+    end
+    return "<#{@name}#{attrs}>#{content}</#{@name}>"
+  end
+
+  def pretty format, method, indent=2
+    case method
+    when :xml
+      pretty_xml = ""
+      REXML::Document.new(self.send(format), { :raw => :all }).write(pretty_xml, indent)
+      return pretty_xml
+    when :json
+      return JSON.pretty_generate(self.send(format))
+    end
+  end
+
+  def self.make_str_from xml
+    text = xml
+    ['&lt;','&gt;','&amp;','&apos;','&quot;'].zip(["<",">","&",%{'},%{"}]) do|xstr,str| text.gsub!(xstr,str) end
+    return text
+  end
+  
+  def self.make_xml_from string
+    xml = string
+    # 注意：'&'要最先被替换
+    ['&','<','>',%{'},%{"}].zip(['&amp;','&lt;','&gt;','&apos;','&quot;']) do|str,xstr| xml.gsub!(str,xstr) end
+    return xml
+  end
+
+  #####################################################################################################
+  # attributes operation                                                                              #
+  #####################################################################################################
+
+  def add_attributes hash
+    (@attributes[:text] ||= []) << hash[:text] if hash[:text]# 文本的特殊处理
+    hash.delete(:text)
+    @attributes.merge!(hash)
+  end
+
+  def modify_attributes hash
+    add_attributes hash
+  end
+
+  def delete_attribute key
+    @attributes.delete(key) unless key==:text # 元素的内容不删除
+  end
+
+  #####################################################################################################
+  # content operation                                                                                 #
+  #####################################################################################################
+
+  def add_content content
+    #@attributes[:text] += content
+    @elements << content
+  end
+
+  def modify_content content
+    @attributes[:text] = []
+    @elements.delete_if{|e|e.is_a?(String)}
+    @elements << content
+  end
+
+  def delete_content
+    #@attributes.delete(:text)
+    @elements = @elements.find_all{|c|!c.instance_of?(XmlNode)}
+  end
+
+  def add_element elem
+    if elem.is_a?(XmlNode)
+      @elements << elem unless @elements.include?(elem)
+      @next << elem unless @next.include?(elem)
+      elem.parent = self
+      elem.prev << self unless elem.prev.include?(self)
+    end
+  end
+
+  def search_elements &block
+    return ( block ? @elements.find_all(&block) : [] )
+  end
+
+  def delete_elements &block
+    elems = search_elements(&block) if block
+    elems.each{|elem|@elements.delete(elem)}
+    return elems
+  end
+
+  # [???] I dont know what happen
+  def self.copy node
+    duplicate=XmlNode.new(name: node.name, parent: nil, attributes: node.attributes)
+    node.elements.map{|subnode|self.copy(subnode)}.each do|subnode|
+      duplicate.add_element subnode
+    end
+    return duplicate
+  end
+end
+
+
+module XmlParser
+  def self.load(filepath)
+    return File.exist?(filepath) ? XmlParser.parse(open(filepath){|f| f.read}) : nil
+  end
+
+  def self.parse(s)
+    parser = REXML::Parsers::SAX2Parser.new(s)
+    root,current = nil,nil
+
+    parser.listen(:start_element) do |url, local, qname, attributes|
+      current = XmlNode.new(parent: current, name: local, attributes: attributes)
+      current.attributes[:namespace]=url
+      root ||= current
+    end
+
+    parser.listen(:end_element) do |url, local, qname, attributes|
+      current = current.parent
+    end
+
+    parser.listen(:characters) do |text|
+      t = text.strip
+      if t.size > 0
+        current.attributes[:text] ||=""
+        current.attributes[:text] += t
+      end
+    end
+
+    parser.parse
+    return root
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: casetdown
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Matt
+bindir: CasetDown/bin
+cert_chain: []
+date: 2025-03-13 00:00:00.000000000 Z
+dependencies: []
+description: casetdown is a test tool of markdown document
+email:
+- matthrewchains@gmail.com
+executables:
+- cm
+- cml
+extensions: []
+extra_rdoc_files: []
+files:
+- CasetDown/bin/cm
+- CasetDown/bin/cml
+- CasetDown/casetable.rb
+- CasetDown/casetcode.rb
+- CasetDown/casetdoc.rb
+- CasetDown/casetdown.rb
+- CasetDown/casetter.rb
+- EnData/api-app.rb
+- EnData/endata-app.rb
+- EnData/endata.rb
+- Tabot/newtab.rb
+- Tabot/simtab.rb
+- TextUtils/text_absparser.rb
+- TextUtils/text_abstract.rb
+- TextUtils/text_mind.rb
+- TinText/cache.rb
+- TinText/tin_text.rb
+- TinText/tintext.rb
+- TinText/tum.rb
+- XMLUtils/XmlUtils.rb
+homepage: http://127.0.0.1
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: test-tool
+test_files: []