infod 0.0.1 → 0.0.2

data/infod/W/search.rb

@@ -1,33 +0,0 @@
-class E
-  
-  fn '/search/GET',->e,r{
-    r.q['graph'] = 'roonga'
-    e.response
-  }
-
-  fn 'head/search',->d,e{[{_: :title, c: e.q['q']},(Fn 'head.formats',e)]}
-
-  fn 'view/search',->d,e{
-    [H.css('/css/search'),H.js('/js/search'),
-     (Fn 'view/search/form',e.q,e),'<br><br>',
-     (Fn 'view/page',d,e)]}
-
-  fn 'view/search/form',-> q=nil,e { q||={}
-    {:class => :form,
-      c: {_: :form, action: e['REQUEST_PATH'],
-        c: [{_: :input, name: :q, value: q['q']}, # search box
-            q.update(q['view'] ? {} : {'view' => 'search'}). # show searchbox above results unless other view specified
-            except('q','start','uri'). # new query & offset for this search
-            map{|a,s|
-              {_: :input, name:  a, value: s, :type => :hidden}}]}}}
-
-  # construct p/o index-traversal links
-  fn 'view/linkPO',->d,e{
-    ['<style>a {background-color: #000;text-decoration:none;border-style:dotted;border-width:.1em;border-color:#fff;;color:#fff;font-size:1.3em;border-radius:.62em;padding:.1em}
-div {display:block; padding:.3em}</style>',
-     {_: :h3, c: e['uri']},{_: :br},
-     d.map{|u,r|
-      {c: {_: :a, href: r.url+'?set=indexPO&p='+e['uri']+'&view=page&views=timegraph,mail&v=multi&c=8', c: u}}
-    }]}
-
-end

data/infod/W/shell.rb

@@ -1,30 +0,0 @@
-class E
-
-  class << self
-    def console; ARGV.clear; require 'irb'
-      IRB.start
-    end
-  end
-
-  # util, prefix -> tripleStream
-  def triplrStdOut e,f='/',g=nil,a=sh
-
-    # leading/trailing whitespace expression
-    g ||= /^\s*(.*?)\s*$/
-
-    # exec command
-    `#{e} #{a}|grep :`.each_line{|i|
-
-      # key/val separator
-      i = i.split /:/
-
-    yield uri, # subject
-     (f+(i[0].match(g)||[nil,i[0]])[1].gsub(/\s/,'_').gsub(/\//,'-').gsub(/[\(\)]+/,'')), # predicate
-      i.tail.join(':').strip.do{|v|v.match(/^[0-9\.]+$/) ? v.to_f : v} # object
-    }
-    nil
-  rescue
-    nil
-  end
-
-end

data/infod/W/table.rb

@@ -1,87 +0,0 @@
-#watch __FILE__
-class E
-  
-  # property selector toolbar
-  fn 'view/p',->d,e{
-    [H.once(e,'property.toolbar',H.once(e,'p',(H.once e,:mu,H.js('/js/mu')),
-     H.js('/js/p'),
-     H.css('/css/table')),
-     {_: :a, href: '#', c: '-', id: :hideP},
-     {_: :a, href: '#', c: '+', id: :showP},
-     {_: :span, id: 'properties',
-       c: E.graphProperties(d).map{|k|
-         {_: :a, class: :n, href: k, c: k.label+' '}}},
-       {_: :style, id: :pS},
-       {_: :style, id: :lS}),
-     (Fn 'view/'+(e.q['pv']||'tab'),d,e)]}
-
-  # table layout, sparse matrix of rows/cols - see table/elements for usage
-  fn 'view/t',->d,e,l=nil,a=nil{
-    [H.once(e,'table',H.css('/css/table')),
-     {_: :table, c:
-     {_: :tbody, c: (Fn 'table/'+(l||e.q['table']),d).do{|t|
-          rx = t.keys.max
-          rm = t.keys.min
-          c = t.values.map(&:keys)
-          cm = c.map(&:min).min
-          cx = c.map(&:max).max
-          (rm..rx).map{|r|
-            {_: :tr, c: 
-              t[r].do{|r|
-                (cm..cx).map{|c|
-                  r[c].do{|c|
-                    {_: :td, class: :cell, c:(Fn 'view/'+(a||e.q['cellview']),c,e)}
-                    }||{_: :td}}}}}}}}]}
-
-# a simple tabular view
-  fn 'view/table',->i,e{
-    [H.css('/css/table'),
-     (Fn 'table',i.values,e)]}
-
-  F['view/tab']=F['view/table']
-
-  fn 'table',->es,q=nil{
-    ks = {} # predicate table
-    es.map{|e|e.respond_to?(:keys) &&
-              e.keys.map{|k|ks[k]=true}}
-    keys = ks.keys
-    keys.empty? ? es.html :
-    H({_: :table,:class => :tab,
-        c: [{_: :tr,
-              c: keys.map{|k|
-                {_: :td, class: :label, property: k,
-                  c: q ? {_: :a,
-                    href: q['REQUEST_PATH']+q.q.except('reverse').merge({'sort'=>k}).merge(q.q.member?('reverse') ? {} : {'reverse'=>true}).qs,
-                    c: (Fn 'abbrURI',k)} : k}}},
-            *es.map{|e|
-              {_: :tr, about: e.uri, c:
-                keys.map{|k|
-                  {_: :td, property: k, c: e[k].do{|v|
-                      (v.class==Array ? v : [v]).map(&:html).join ' '}}}}}]})}
-  
-  fn 'table/elements',->d{ m={}
-    g='http://www.daml.org/2003/01/periodictable/PeriodicTable#group'
-    p='http://www.daml.org/2003/01/periodictable/PeriodicTable#period'
-    d.map{|u,r|
-      r[g].do{|g|   g = g[0].uri.match(/[0-9]+$/)
-        r[p].do{|p| p = p[0].uri.match(/[0-9]+$/)
-          g && p &&
-          (g = g[0].to_i
-           p = p[0].to_i
-           m[p]     ||= {}
-           m[p][g]  ||= {}
-           m[p][g][u] = r
-           )}}}
-    m}
-
-  F["?"]||={}
-  F["?"].update({'elements'=>{'view' => 'p','pv' => 't','table' => 'elements', 'cellview' => 'element'}})
-
- # element
-  fn 'view/element',->d,e{
-    l = d[d.keys[0]]
-    [H.once(e,'elements.css',H.css('/css/elements')),
-     {class: l['http://www.daml.org/2003/01/periodictable/PeriodicTable#classification'].do{|p|p[0].uri.label},
-       c: [l['http://www.daml.org/2003/01/periodictable/PeriodicTable#symbol'],(Fn 'view',d,e)]}]}
-  
-end

data/infod/W/tree.rb

@@ -1,26 +0,0 @@
-class E
-
-  fn 'view/tree',->d,e{ t={}; c={}
-    d.map{|u,r| l=t
-      u.split(/[\/#]/).
-      map{|s|
-        l=(l[s] ||= {})}
-      l['#']={u => r}}
-    r=->t,d=0{
-      t.except('#').map{|k,t_|
-        {_: :div, class: :branch,style: 'background-color:'+(c[d]||=E.c),
-         c: [t_['#'].do{|t|Fn 'view/'+e.q['treev'],t,e}||k,r.(t_,d+1)]}}}
-  [(H.once e,'tree',(H.css '/css/tree')),r.(t)]}
-
-  fn 'view/treeR',->d,e{ t={}; c={}
-   d.map{|_,r| r.map{|p,o| l = t
-     p.split(/[\/#]/).map{|s|l=(l[s]||={})}
-          l['#']||=[]
-          l['#'].push o}}
-    r=->t,d=0{
-      t.except('#').map{|k,t_|
-        {_: :div, class: :branch,style: 'background-color:'+(c[d]||=E.c),
-     c: ['<b>',k,'</b>',{class: :treeO,c: t_['#'].html},r.(t_,d+1)]}}}
-  [(H.once e,'tree',(H.css '/css/tree')),r.(t)]}
-
-end

data/infod/W/vfs.rb

@@ -1,175 +0,0 @@
-%w{date digest/sha1 fileutils json open-uri pathname}.each{|r|require(r)}
-
-class E
-
-  def d
-    node.to_s
-  end
-
-  def node
-    Pathname.new FSbase + path
-  end
-  alias_method :no, :node
-
-  # glob :: pattern -> [E]
-  def glob p=""
-    (Pathname.glob d + p).map &:E
-  end
-  fn 'set/glob',->d,e,m{d.glob}
-  fn 'graph/glob',->d,e,m{d.glob.map{|c|c.fromStream m, :triplrInode, false}}
-  
-  def parent
-    E Pathname.new(uri).parent
-  end
-
-  def siblings
-    parent.c
-  end
-
-  def jail
-    no.expand_path.to_s.index(E::FSbase)==0 && @r['PATH_INFO'] !~ /\.\./ && self
-  end
-
-  def children
-    no.c.map &:E
-  end
-  alias_method :c, :children
-
-
-  # node exists?
-  def exist?
-    no.exist?
-  end
-  alias_method :e, :exist?
-
-  # directory?
-  def d?
-    no.directory?
-  end
-
-  # file?
-  def file?
-    no.file?
-  end
-  alias_method :f, :file?
-
-  # modification time
-  def mtime
-    no.stat.mtime if e
-  end
-  alias_method :m, :mtime
-
-  def triplrInode r=true
-    e && (d? && (yield uri, Posix + 'dir#parent', parent
-                 r && c.map{|c| yield uri, Posix + 'dir#child', c})
-      node.stat.do{|s|[:size,:ftype,:mtime].map{|p|
-          yield uri,Stat+p.to_s,(s.send p)}})
-  end
-  
-  # create node
-  def dir
-    e || FileUtils.mkdir_p(d)
-    self
-  end
-
-  # create link
-  def ln t
-    t = E(t) # cast bare URI/string to resource
-    if !t.e  # destination exists?
-      t.no.dirname.dir # ensure containing dir exists
-#      puts [:ln,uri].join ' '
-      FileUtils.symlink no, t.no # create link
-    end
-  end
-
-  def touch
-    FileUtils.touch no
-    self
-  end
-    
-  def deleteNode
-    puts "-node #{d}" if e
-    no.deleteNode if e
-    self
-  end
-
-  def size
-    no.size
-  end
-
-  def read
-    f ? r : get
-  end
-
-  def get
-    (open uri).read
-  end
-
-  # read file - check if it exists & parse JSON if requested
-  def r p=false
-    if f
-      (p ? JSON.parse(readFile)[0] : readFile)
-    else
-    p ? {} : nil
-    end
-  rescue
-    p ? {} : nil
-  end
-
-  # write file - make sure dir exists & serialize JSON if requested
-  def w o,s=false
-#    puts "write #{uri} #{s}"
-    dirname.dir
-    writeFile (s ? [o].to_json : o)
-    self
-  end
-
-  def writeFile c
-    File.open(d,'w'){|f|f << c}
-  end
-
-  def readFile
-    File.open(d).read
-  end
-
-  def readlink
-    no.symlink? ? no.readlink.E : self
-  end
-
-end
-
-class Pathname
-  
-  def dir
-    mkpath unless exist? 
-  end
-
-  # append to path
-  def a s
-    Pathname.new to_s+s
-  end
-
-  # path -> E
-  def E
-    to_s.force_encoding('UTF-8').pathToURI false
-  end
-
-  def c
-    return [] unless directory?
-    children.delete_if{|n| n.basename.to_s.match /^(\.+|#{E::S})$/}
-    rescue
-      []
-  end
-  
-  def deleteNode
-    FileUtils.send file? ? :rm : :rmdir,self
-    parent.deleteNode if parent.c.empty?
-  end
-
-end
-
-class File::Stat
-  def utime
-    mtime.to_i
-  end
-end