casetdown 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7db61cc282539ad38b94b953931b8801cc91dbd43c1bfe2941c7a56fce92abaa
+  data.tar.gz: 79034f081e7a5bcc75b0e00a579ed5c26c312a4acfc909457c0247b5cb806052
+SHA512:
+  metadata.gz: f6a439b490240278afb3e86d3f6061b3b8115023d6daada7f5075ad3ceb6f304a671332b45089904ac571892078598db3e0e757cab62d08f979e4abfdd794981
+  data.tar.gz: d0c622a8dde0dbe7457ba7909bfa82bf8a8a25fda7275eceaed39589bb4070dcbe7d2637a770d2698c428de7e9322158a2e9873bd1cbea9c44e604e599ab5d10

data/CasetDown/bin/cm

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+#coding:utf-8
+require 'CasetDown/casetdown'
+
+pool,check,source = ARGV,false,false
+
+if pool.include?('-h') or pool.include?('--help')
+  puts %Q{<<LIST>>
+  cm [options] <filename>[.md]
+
+  options:
+  --help     查看帮助
+  --check    检查文档结构
+  --source   查看文档中的源代码
+  --rtab     导入外部表格到文档中
+  --wtab     导出内部表格到外部文件
+  --input    导出源代码文件并渲染文档
+  --output   导出代码运行结果
+  --all      导出源代码和运行结果(input+output)
+  --preview  预览渲染文档(不生成渲染结果)
+  --debug    调试开关, 不删除中间代码
+  --rendfile 渲染文档并生成一个时间戳(默认)
+};exit
+end
+
+if pool.include?('--check')
+  check = true
+  pool.delete '--check'
+end
+if pool.include?('--source')
+  source = true
+  pool.delete '--source'
+end
+
+table,file = [],[]
+['--rtab','--wtab'].each do|tag|
+  if pool.include?(tag)
+    table << tag
+    pool.delete tag
+  end
+end
+['--input','--output','--all','--preview','--debug'].each do|tag|
+  if pool.include?(tag)
+    file << tag
+    pool.delete tag
+  end
+end
+
+path = pool.last
+path = Dir["./*.md"].last unless path
+exit unless path
+
+if File.exist?(path)
+  cds = CasetDown.load path
+elsif File.exist?("#{path}.md")
+  cds = CasetDown.load "#{path}.md"
+else
+  puts "File #{path} not exist.";exit
+end
+
+if check
+  puts "checking>>>>"
+  pp CasetDown::Check.all(cds)
+  exit
+end
+if source
+  puts "source>>>>"
+  pp CasetDown.search_codes(cds)
+  exit
+end
+
+tmp = CasetDown.render_table(cds, opt: table.map{|i|i[2..-1].to_sym})
+CasetDown.run_to_file cds, stream: tmp[:text], data: tmp[:data], fact: tmp[:fact], file: file.map{|i|i[2..-1].to_sym}+[:rendfile]

data/CasetDown/bin/cml

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+#coding:utf-8
+require 'digest'
+require 'fileutils'
+
+if ARGV.empty?
+	cd = Dir.pwd
+	fs = '*'
+else
+	cd = ARGV.first
+	fs = ARGV.size>1 ? ARGV.last : '*'
+	(warn "No file(#{cd}/#{fs}) exist.";exit) unless File.exist?("#{cd}/#{fs}")
+end
+
+warn "DONT USE POSTFIX .latest.md, FILENAME.latest.md WONT BE UPDATED!"
+
+table = {}
+loop do
+	Dir["#{cd}/#{fs}"].each do|path|
+		next unless path[-3..-1]=='.md'
+		next if path[-10..-1]=='.latest.md'
+		unless table[path]
+			table[path] = [File.stat(path).atime, File.stat(path).size, Digest::MD5.hexdigest(File.read(path))]
+		end
+		otime, osize, odigest = table[path]
+		atime = File.stat(path).atime
+		asize = File.stat(path).size
+		if atime>otime # && (asize != osize || asize == osize)
+			adigest = Digest::MD5.hexdigest File.read(path)
+			if adigest!= odigest
+				`cm #{path}`
+				table[path] = [atime, asize, adigest]
+				latpath = (Dir["#{path[0..-4]}.*.md"] - ["#{path[0..-4]}.latest.md"]).max
+				File.delete("#{path[0..-4]}.latest.md")
+				puts ">#{path} changed -> #{latpath}(#{adigest}).";$stdout.flush
+				FileUtils.copy_file(latpath, "#{path[0..-4]}.latest.md")
+			end
+		end
+	end
+	sleep 1
+end

data/CasetDown/casetable.rb

@@ -0,0 +1,80 @@
+#coding:utf-8
+require 'csv'
+
+module CasetDown
+  module_function
+
+  # handle table
+  def loadcsv path,format=:raw
+    begin
+      csv = File.read(path).force_encoding("GBK").encode("UTF-8")
+    rescue
+      csv = File.read(path).encode("UTF-8")
+    end
+    content = CSV.parse(csv, headers:(format==:csv))
+    table = content.绑定表头 content[0]
+    return table
+  end
+  
+  def maketab table
+    printab = table.map{|row|"|"+row.join("|")+"|"}
+    printab.insert 1, Array.new(table[0].size, '|---').join+"|"
+    return printab.join("\n")
+  end
+
+  def render_table cds, option={ stream: nil, opt: []} # empty, :wtab, :rtab, :rendfile
+    $_tmp_endata_ = {}
+    # write table to csv file
+    docs = CasetDown::Check.all(cds)
+    docs.each_with_index do|doc,index|
+      if doc[:name]=='table'
+        table_name = ( index-1 >= 0 && docs[index-1][:name]=='p' && docs[index-1][:text].strip[0..1]=='(('  && docs[index-1][:text].strip[-2..-1]=='))' ) ? docs[index-1][:text][2..-3].strip : 'Anonymous'
+        table_body = [doc[:head]]+doc[:body]
+        $_tmp_endata_["[table@endata ~]$ruby #{table_name}"] = table_body.to_s
+        CSV.open(table_name+".csv","w")do|writer|
+          table_body.each do|record|
+            writer << record
+          end
+        end if option[:opt].include?(:wtab)
+      end
+    end
+
+    # load table from csv file
+    result = {}
+    codtab = docs.select{|doc|doc[:name]=='code'}
+    codtab.each do|code|
+      interpreter, namespace, config, target, flow, segment, input, output, rows, cols = magic_head code
+      next unless output.to_s[-4..-1]=='.csv'
+      tab = loadcsv(output)
+      seltab = rows.inject([tab[0]]) do|seltab,row|
+        seltab += [tab[row]] if row.is_a?(Integer)
+        seltab += tab[row]   if row.is_a?(Range)
+        seltab
+      end
+      seltab.绑定表头 seltab[0]
+      newtab = seltab.选择(*cols)
+      result[output] = maketab(newtab)
+      $_tmp_endata_["[table@endata ~]$ruby #{output}"] = newtab.to_s
+    end
+
+    $_tmp_endata_.each do|head, table|
+      ($_scr_tail_ ||= "__END__") << "\n#{head}\n#{table}\n"
+      ($_erl_tail_ ||= "") << "\n\n"+ToErlang.fact(head.split('$ruby ')[1], ToErlang.table(eval(table)))
+    end
+    origin_text = option[:stream] || cds[:doc].text
+    result.each do|output, newtab|
+      wrapped = "((#{output}))\n\n#{newtab}"
+      origins = CasetDown.search_output(origin_text, output)
+      origins.each do|origin|
+        origin_text = origin_text.gsub(origin, wrapped)
+      end
+    end if option[:opt].include?(:rtab)
+
+    if option[:opt].include?(:rendfile)
+      pazz = cds[:path].split('.')
+      pazz.insert(-2,Time.new.strftime("%Y%m%d%H%M%S"))
+      File.write pazz.join('.'), origin_text
+    end
+    return { text: origin_text, data: $_scr_tail_, fact: ($_erl_tail_||nil)}
+  end
+end

data/CasetDown/casetcode.rb

@@ -0,0 +1,228 @@
+#coding:utf-8
+
+module CasetDown
+  module_function
+
+  def textchange text
+    text.gsub('&gt;','>').gsub('&lt;','<')
+  end
+
+  def wrap_output text, id, tag='output'
+    output_start = "```shell\n##{tag}>#{id}"
+    output_finish= "```"
+    return [output_start, text, output_finish].join("\n")
+  end
+
+  def search_output text, id, tag='output'
+    # [TODO] REFACTORING for recognition between '#output>path' and '#output> path'
+    output_start = "```shell\n##{tag}>#{id}"
+    output_finish= "```"
+    match = TextAbstract.match_paragraph text, output_start, output_finish
+    return match.map{|m|[output_start, m, output_finish].join}
+  end
+
+  def magic_head code
+    states = textchange(code[:code]).split("\n")
+    interpreter = code[:class]
+    script = states.find{|s|s[0..4]=='#src>'||s[0..7]=='#script>'}.to_s.split('>')[1]
+    interpreter = script if script # :default
+
+    namespace = states.find{|s|s[0..3]=='#ns>'||s[0..10]=='#namespace>'}.to_s.split('>')[1] || :ns
+    config = states.find{|s|s[0..5]=='#conf>'||s[0..7]=='#config>'}.to_s.split('>')[1] || :conf
+    target = states.find{|s|s[0..4]=='#dst>'||s[0..7]=='#target>'}.to_s.split('>')[1]
+
+    flow = states.find{|s|s[0..5]=='#flow>'||s[0..5]=='#step>'}.to_s.split('>')[1] || :flow
+    segment = states.find{|s|s[0..4]=='#seg>'||s[0..8]=='#segment>'}.to_s.split('>')[1] || :seg
+
+    input = states.find{|s|s[0..3]=='#in>'||s[0..6]=='#input>'}.to_s.split('>')[1] || :in
+    output = states.find{|s|s[0..4]=='#out>'||s[0..7]=='#output>'}.to_s.split('>')[1] || :out
+
+    [interpreter, namespace, target, flow, segment, input, output].each{|tag|tag.strip! if tag.instance_of?(String)}
+
+    rows = if row = states.find{|s|s[0..4]=='#row>'}.to_s.split('>')[1]
+      row.gsub('~','..').split(',').map{|r|eval(r)}
+    else
+      :rows
+    end
+    cols = if col = states.find{|s|s[0..4]=='#col>'}.to_s.split('>')[1]
+      col.split(',').map{|c|
+        c.split('').inject(true){|f,chr|
+          f&&(('0'..'9').to_a+['-','~']).include?(chr)
+        } ? eval(c.gsub('~','..')) : c.strip
+      }
+    else
+      :cols
+    end
+
+    return interpreter, namespace, config, target, flow, segment, input, output, rows, cols
+  end
+
+  def search_codes cds
+    codes = CasetDown::Check.all(cds).select{|cd|cd[:name]=='code'}
+
+    table = codes.inject({}) do|table, code|
+      interpreter, namespace, config, target, flow, segment, input, output, rows, cols = magic_head code
+
+      content = textchange(code[:code]).split("\n")[1..-1].select{|s|
+        !['#ns>','#in>'].include?(s[0..3]) &&
+        !['#out>','#src>','#dst>','#seg>','#row>','#col>'].include?(s[0..4]) &&
+        !['#flow>','#step>','#conf>'].include?(s[0..5]) &&
+        !['#input>'].include?(s[0..6]) &&
+        !['#script>','#target>','#output>','#config>'].include?(s[0..7]) &&
+        !['#segment>'].include?(s[0..8]) &&
+        !['#namespace>'].include?(s[0..10])
+      }.join("\n")
+      table[[code.object_id, interpreter, namespace, config, target, [rows,cols], flow, segment, input, output]] = content
+      table
+    end
+    return table
+  end
+
+  def run cds
+    table = CasetDown.search_codes(cds)
+    $_tmp_global_ = {}
+    $_scr_head_ = ['#coding:utf-8','["EnData/endata","EnData/endata-app","TinText/tum","TinText/cache","TinText/tin_text","TinText/tintext","Tabot/newtab","Tabot/simtab"].each{|mod|require(mod)}'].join("\n")
+    result = {}
+    table.each do|key, text|
+      oid, interpreter, ns, conf, target, range, flow, seg, input, output = key
+      unless conf==:conf # 注意全局配置累积生效，所以有先后顺序
+        $_tmp_global_.merge!(
+          (File.exist?(conf)           ? YAML.load(File.read conf)           : {}) ||
+          (File.exist?("#{conf}.yml")  ? YAML.load(File.read "#{conf}.yml")  : {}) ||
+          (File.exist?("#{conf}.yaml") ? YAML.load(File.read "#{conf}.yaml") : {})
+        )
+        $_scr_tail_ = "\n__END__\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}"
+        $_erl_tail_ = $_tmp_global_.empty? ? '' : ToErlang.fact('global', (ToErlang.hash($_tmp_global_)) )
+      end
+      if interpreter=='shell' || interpreter==:default
+        if RUBY_PLATFORM.include?('mingw')
+        else
+          File.write "./~tmp.sh",text
+          running = `bash ./~tmp.sh`
+          File.delete "./~tmp.sh"
+        end
+      elsif interpreter=='ruby'
+        File.write "./~tmp.rb","#{$_scr_head_}\n\n#{text}\n\n#{$_scr_tail_}"
+        running = `ruby ./~tmp.rb`
+        File.delete "./~tmp.rb"
+      elsif interpreter=='erlang' || interpreter=='erl'
+        File.write "./_tmp.erl","-module(_tmp).\n-export([main/1]).\n\n#{text}\n\n#{$_erl_tail_}\n\nfact(UnknownMessage)->\n  io:format(\"~p\",[UnknownMessage])."
+        running = `escript ./_tmp.erl`
+        File.delete "./_tmp.erl"
+      elsif interpreter=='python3' || interpreter=='python'
+        File.write "./~tmp.py",text
+        running = `python ./~tmp.py`
+        File.delete "./~tmp.py"
+      elsif interpreter=='lms'
+        running = `lms "#{text}"`
+      elsif interpreter=='lmx'
+        running = `lmx "#{text}"`
+      else
+      end
+      result[input] = running
+    end
+    return result
+  end
+
+  def run_to_file cds,option={stream: nil, data: nil, fact: nil,file:[]} # empty, :input, :output, :all
+    $_tmp_global_ = {}
+    $_scr_head_ = ['#coding:utf-8','["EnData/endata","EnData/endata-app","TinText/tum","TinText/cache","TinText/tin_text","TinText/tintext","Tabot/newtab","Tabot/simtab"].each{|mod|require(mod)}'].join("\n")
+    $_scr_tail_ = option[:data] ? option[:data] : ''
+    $_erl_tail_ = option[:fact] ? option[:fact] : ''
+
+    table = CasetDown.search_codes(cds)
+    result = {}
+    table.each do|key, text|
+      oid, interpreter, ns, conf, target, range, flow, seg, input, output = key
+      unless conf==:conf # 注意全局配置累积生效，所以有先后顺序
+        $_tmp_global_.merge!(
+          (File.exist?(conf)           ? YAML.load(File.read conf)           : {}) ||
+          (File.exist?("#{conf}.yml")  ? YAML.load(File.read "#{conf}.yml")  : {}) ||
+          (File.exist?("#{conf}.yaml") ? YAML.load(File.read "#{conf}.yaml") : {})
+        )
+        $_scr_tail_ = $_scr_tail_.empty? ? "\n__END__\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}" : "#{$_scr_tail_}\n[global@endata ~]$ruby global\n#{$_tmp_global_.to_s}"
+        $_erl_tail_ = $_tmp_global_.empty? ? $_erl_tail_ : $_erl_tail_+"\n\n"+ToErlang.fact('global', (ToErlang.hash($_tmp_global_)) )
+      end
+      if interpreter==:default
+        # NOTHING
+      elsif interpreter=='shell' || interpreter=='bash'
+        if RUBY_PLATFORM.include?('mingw')
+        else
+          File.write "./~tmp.sh",text
+          running = `bash ./~tmp.sh`
+          File.delete "./~tmp.sh" unless option[:file].include?(:debug)
+        end
+      elsif interpreter=='ruby'
+        File.write "./~tmp.rb","#{$_scr_head_}\n\n#{text}\n\n#{$_scr_tail_}"
+        running = `ruby ./~tmp.rb`
+        File.delete "./~tmp.rb" unless option[:file].include?(:debug)
+      elsif interpreter=='erlang' || interpreter=='erl'
+        File.write "./_tmp.erl","-module(_tmp).\n-export([main/1]).\n\n#{text}\n\n#{$_erl_tail_}\n\nfact(UnknownMessage)->\n  io:format(\"~p\",[UnknownMessage])."
+        running = `escript ./_tmp.erl`
+        File.delete "./_tmp.erl" unless option[:file].include?(:debug)
+      elsif interpreter=='python3' || interpreter=='python'
+        File.write "./~tmp.py",text
+        running = `python ./~tmp.py`
+        File.delete "./~tmp.py" unless option[:file].include?(:debug)
+      elsif interpreter=='lms'
+        running = `lms "#{text}"`
+      elsif interpreter=='lmx'
+        running = `lmx "#{text}"`
+      else
+      end
+      result[input] = running
+      File.write input, text if !(option[:file] & [:input, :all]).empty? && input.instance_of?(String)
+    end
+
+    origin_text = option[:stream] || cds[:doc].text
+    result.each do|input, running| # input == output
+      File.write input, running if !(option[:file] & [:output, :all]).empty? && input.instance_of?(String)
+      origins = CasetDown.search_output(origin_text, input)
+      wrapped = CasetDown.wrap_output(running,input)
+      if origins.empty?
+        origins = CasetDown.search_output(origin_text, input, 'out')
+        wrapped = CasetDown.wrap_output(running,input, 'out')
+      end
+      origins.each do|origin|
+        # [TODO] 无法解决不同后缀的前置匹配替换问题，待修复
+        origin_text = origin_text.gsub(origin, wrapped)
+      end
+    end
+
+    if option[:file].include?(:rendfile)
+      if option[:file].include?(:preview)
+        prvw = cds[:path].split('.')
+        prvw.insert(-2,'preview')
+        File.write prvw.join('.'), origin_text
+      else
+        pazz = cds[:path].split('.')
+        pazz.insert(-2,Time.new.strftime("%Y%m%d%H%M%S"))
+        File.write pazz.join('.'), origin_text
+      end
+    end
+    return origin_text
+  end
+end
+
+module ToErlang
+	module_function
+
+	def table data
+		fields = data.first
+		erlang_data = data.drop(1).map do |row|
+			row_data = fields.zip(row).map do |field, value|
+				"{\"#{field}\", \"#{value}\"}"
+			end.join(",")
+			"{#{row_data}}"
+		end
+		"[#{erlang_data.join(", ")}]"
+	end
+
+  def hash data
+    "{"+data.map{|k,v|"{\"#{k}\", \"#{v}\"}"}.join(",")+"}"
+  end
+
+	def fact name, body
+		"fact(\"#{name.to_s}\")->\n  #{body};"
+	end
+end

data/CasetDown/casetdoc.rb

@@ -0,0 +1,117 @@
+#coding:utf-8
+
+module CasetDown
+  module Check
+    module_function
+
+    def all cds
+      epool = cds[:src].stack.inject([]) do|epool, cd|
+        res = nil
+        [:head, :table, :para, :pre, :list, :quote].each do|tag|
+          res ||= CasetDown::Check.send tag, cd
+        end
+        epool += res.instance_of?(Array) ? res : [res]
+      end.compact
+    end
+
+    def head cd
+      if %w{h1 h2 h3 h4 h5 h6}.include? cd.name
+        unless cd.elements.empty?
+          ha = {name: cd.name, text: cd.attributes[:text], inline: [] }
+          cd.elements.each{|sub|ha[:inline]<<(sub.name=='a' ? a(sub) : {})}
+          ha
+        else
+          {name: cd.name, text: cd.attributes[:text] }
+        end
+      else
+        nil
+      end
+    end
+
+    def table cd
+      if cd.name=='table'
+        hd = cd.to_doc['table'][1]['thead'][1]['tr'][1..-1].map{|th|th['th'][0][:text]}
+        bd = cd.to_doc['table'][2]['tbody'][1..-1].map{|tr|tr['tr'][1..-1].map{|td|td['td'][0][:text]}}
+        {name: 'table', head: hd, body: bd}
+      else
+        nil
+      end
+    end
+
+    def para cd
+      if cd.name=='p'
+        cur = []
+        cur << (cd.attributes[:text] ? {name: 'p', text: cd.attributes[:text]||cd.attributes["text"]} : nil)
+        cd.elements.each do|cs|
+          cur << code(cs)
+          cur << img(cs)
+          cur << a(cs)
+        end
+        return cur
+      else
+        nil
+      end
+    end
+
+    def img cd
+      if cd.name=='img'
+        {name: 'img', src: cd.attributes['src'], alt: cd.attributes['alt']}
+      else
+        nil
+      end
+    end
+
+    def a cd
+      if cd.name=='a'
+        {name: 'a', href: cd.attributes['href'], text: cd.attributes[:text]}
+      else
+        nil
+      end
+    end
+
+    def pre cd
+      if cd.name=='pre'
+        code(cd.elements.first)
+      else
+        nil
+      end
+    end
+
+    def code cd
+      if cd.name=='code'
+        {name: 'code', class: (cd.attributes['class'] ? cd.attributes['class'] : :default), code: cd.attributes[:text]}
+      else
+        nil
+      end
+    end
+
+    def list cd
+      # TODO: ONLY TOP LEVEL, PENDING TO RECURSION
+      if cd.name=='ul'
+        subs = cd.elements.inject([]) do|subs, li|
+          sub = {name: 'li', text: li.attributes[:text]}
+          li.elements.each do|subsub|
+            sub.merge!(inline: quote(subsub)) if subsub.name=='blockquote'
+            sub.merge!(inline: code(subsub)) if subsub.name=='code'
+            sub.merge!(inline: img(subsub)) if subsub.name=='img'
+            sub.merge!(inline: a(subsub)) if subsub.name=='a'
+          end
+          subs << sub
+        end
+        {name: 'ul', list: subs}
+      else
+        nil
+      end
+    end
+
+    def quote cd
+      # TODO: ONLY TOP LEVEL, PENDING TO RECURSION
+      if cd.name=='blockquote'
+        {name: 'blockquote', quote: cd.to_doc['blockquote'][1]['p'][0][:text]}
+      else
+        nil
+      end
+    end
+
+  end
+end

data/CasetDown/casetdown.rb

@@ -0,0 +1,13 @@
+#coding:utf-8
+#USE: XMLUtils/XmlUtils
+#USE: TextUtils/text_abstract
+#USE: Tabot/simtab
+
+[
+  'EnData/endata', 'EnData/endata-app',
+  'Tabot/newtab', 'Tabot/simtab',
+  'TextUtils/text_abstract', 'TextUtils/text_absparser', 'TextUtils/text_mind',
+  'TinText/tum', 'TinText/cache', 'TinText/tin_text', 'TinText/tintext',
+  'XMLUtils/XmlUtils',
+  'CasetDown/casetter', 'CasetDown/casetdoc', 'CasetDown/casetcode', 'CasetDown/casetable'
+].each{|lib|require lib}

data/CasetDown/casetter.rb

@@ -0,0 +1,72 @@
+#coding:utf-8
+require 'rdiscount'
+
+module CasetDown
+  module_function
+  
+  #################################################################################################
+  # Loader                                                                                        #
+  #################################################################################################
+  def load path, option={}
+    args = {path: path}.merge(option)
+    text = (File.read path).gsub("\r","").split("\n").map{|line|line.rstrip}.join("\n")
+    return self.parse(text, args)
+  end
+
+  #################################################################################################
+  # InlineStructs                                                                                 #
+  #################################################################################################
+  def parse text, option={}
+    args = {
+      parser: RDiscount, # parser := {Kramdown::Document | RDiscount} ★ Kramdown::Document无法处理好多重空行问题
+      doc: true,
+      tree: true,
+      src: true,
+      path: 'tmp'
+    }.merge(option)
+    document = args[:parser].new(text)
+    html = "<html>"+document.to_html+"</html>"
+    script, tree = [],{}
+    XmlParser.parse(html).elements.each do|node|
+      doc = node.to_a
+      script << node
+      tree[doc[0]] ||= []
+      tree[doc[0]] << node
+    end
+    result = {path: args[:path]}
+    result[:src]  = Script.new(native: script) if args[:src]
+    result[:tree] = Tree.new(native: tree)     if args[:tree]
+    result[:doc]  = document                   if args[:doc]
+    return result
+  end
+  
+  class Tree
+    def initialize options={}
+      @content ||= options[:native]
+      @content ||= JSON.parse(options[:json]) if options[:json]
+      @content ||= CasetDown.load(options[:path])[-1] if options[:path]
+      @content ||= CasetDown.parse(options[:doc])[-1] if options[:doc]
+      @content ||= {}
+    end
+    
+    def nodes &block
+      block = lambda{|content|content} unless block
+      block.call(@content)
+    end
+  end
+  
+  class Script
+    def initialize options={}
+      @content ||= options[:native]
+      @content ||= JSON.parse(options[:json]) if options[:json]
+      @content ||= CasetDown.load(options[:path])[0] if options[:path]
+      @content ||= CasetDown.parse(options[:doc])[0] if options[:doc]
+      @content ||= []
+    end
+
+    def stack &block
+      block = lambda{|content|content} unless block
+      block.call(@content)
+    end
+  end
+end