infod 0.0.1

data/infod/W/kv.rb

@@ -0,0 +1,66 @@
+class E
+
+  # a simple key/value RDF store on a fs
+
+  # *get*
+  # (E'http://www.kanzaki.com/ns/music#EnglishHorn')[RDFs+'comment']
+  # -> ["A double-reed woodwind instrument, larger member of the oboe family."]
+  #
+  # *set*
+  # (E'lement')['level']='trace'
+  #
+  # *update*
+  # (E'lement')['level','trace','abundant']
+  #  
+  def [] p,o=nil, v=nil
+    unless o
+      (s p).listPredicates
+    else
+      edit E(p),(o.class == E ? o : E(p).literal(o)),v
+    end
+  end
+
+  def []= p,o
+    self[p,o]
+  end
+
+  def edit p,o,v=nil
+    d=(s p).s o # object
+    if v # edit
+      if d.e
+        d.deleteNode # remove
+        indexEdit p,o,'' # unindex
+      end
+      self[p,v] unless v.empty? # add
+    else
+      unless d.e
+        indexEdit p,o,nil # index add
+        d.dir # create
+      end
+    end
+    touch if e
+  end
+
+  def triplrFsStore
+    listPredicates.map{|p|
+      self[p].map{|o|
+        yield uri, p.uri, o }}
+  end
+
+  def deletePredicate p
+    self[p].each{|o| self[p,o,'']}
+  end
+
+  # property list
+  # E -> [E]
+  def listPredicates
+    s = u.to_s.size+1
+    subtree.map{|n|n.uri[s..-1].unpath}
+   end
+
+  def literalBlob o
+    u = literalBlobURI o
+    u.w o,!o.class==String unless u.f
+  end
+
+end

data/infod/W/ls.rb

@@ -0,0 +1,50 @@
+#watch __FILE__
+class E
+
+  fn 'set/ls',->d,e,m{d.c}
+
+  # filesystem metadata only
+  fn 'graph/ls',->d,e,m{d.c.map{|c|c.fromStream m, :triplrInode, false}}
+
+  # basic directory view 
+  fn 'view/dir',->i,e{
+
+    # localize URL
+    h = 'http://' + e['SERVER_NAME'] + '/'
+    l = -> u {
+      if u.index(h) == 0
+        u # already a local link
+      else
+        # generate local link
+        Prefix + u
+      end}
+
+    # item thumbnail / link
+    a = -> i { e = i.E
+      {_: :a, href: l[e.uri],
+        c: e.uri.match(/(gif|jpe?g|png)$/i) ? {_: :img, src: i.uri+'?233x233'} :
+        e.uri.sub(/.*\//,'')
+      }}
+
+    [(H.once e, 'dir', (H.css '/css/ls')),
+     i.map{|u,r| r[Posix+'dir#child'] ? # directory?
+       {class: :dir, style: "background-color: #{E.c}", # dir wrapper
+         c: [{c: [{_: :a, href: l[r.uri]+'?graph=ls&view=ls', c: r.uri.sub( 'http://'+e['SERVER_NAME'],'')}, # link to ls
+                  {_: :a, href: l[r.uri].t, c: '/'}]},
+             r[Posix+'dir#child'].map{|c|a[c]}]} :  # children
+       a[r]}]}                               # item
+
+  F['view/'+MIMEtype+'inode/directory']=F['view/dir']
+
+  # tabular rendering
+  fn 'view/ls',->i,e{
+    [(H.css '/css/ls'),
+     {_: :a, class: :up, href: E(e['uri']).parent.url+'?graph=ls&view=ls', c: '↑'},
+     {class: :ls,
+       c: (Fn 'view/tab',i,e)},
+     {_: :a, class: :du, href: e['REQUEST_PATH'].t+'??=du', c: :du, rel: :nofollow},
+     (Fn 'view/find',i,e),'<br clear=all>',
+     {_: :a, class: :down, href: e['uri'].E.url.t, c: '&darr;'},
+    ]}
+
+end

data/infod/W/mail.rb

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+#watch __FILE__
+
+class E
+
+  # qs alias section
+  F["?"] ||= {}
+  F["?"].update({
+   'thread' =>{'graph'=>'thread',
+               'sort' => 'dc:date',
+               'reverse' => nil,
+               'view' => 'multi',
+               'views' => 'timegraph,mail',
+               'arc' => '/parent',
+               'label' => 'sioc:name'},
+      'ann' =>{'view'=>'threads',
+               'matchP' => 'dc:title',
+               'match' => /[^a-zA-Z][Aa][Nn][nN]([oO][uU]|[^a-zA-Z])/}})
+
+  def triplrMail; require 'tmail'
+
+    # read message
+    i = -> i {E i[1..-2]}                 # Message-ID -> E
+    (TMail::Mail.load node).do{|m|        # parse
+      d = m.message_id; return unless d   # parse successful?
+      e = i[d]                            # Message resource
+      e.e || (                            # Message-ID locatable?
+
+       # index previously unseen mail
+       ln e                               # create message-id path 
+       %w{in_reply_to references}.map{|p| # reference arcs
+        m.send(p).do{|o| o.map{|o|        # lookup references
+         e.index SIOC+'reply_of', i[o]}}} # index references
+       e.ln '/' + m.date.iso8601[0..12].gsub(/[^\d]/,'/') + '/' + e.uri # date/hour index tree
+       self.index Creator, m.from[0].E    # index From
+       self.index      To, m.to[0].E )    # index To
+
+      # yield triples
+      yield e.uri, Type,    E[SIOCt+'MailMessage']
+      yield e.uri, Date,    m.date.iso8601    if m.date
+      yield e.uri, Content, m.decentBody
+        [[:subject,Title],
+              [:to,To,true],
+              [:cc,To,true],
+             [:bcc,To,true],
+   [:friendly_from,SIOC+'name'],
+            [:from,Creator,true],
+        [:reply_to,'/mail/reply_to',true],
+     [:in_reply_to,'/parent',true,true],
+     [:in_reply_to,SIOC+'reply_of',true,true],
+      [:references,SIOC+'reply_of',true,true],
+        ].each{|a| m.send(a[0]).do{|o| [*o].map{|o|
+            yield e.uri,a[1],                        # skip empty String values 
+            (a[2] ? (a[3] ? i[o] : o.E) : o.to_utf8) unless o.match(/\A[, \n]*\Z/)}}}}
+
+  rescue Exception => e
+    puts [:mail,uri,e].join(' ')
+  end
+
+  fn 'graph/thread',->d,_,m{d.walk SIOC+'reply_of',m}
+
+  # overview of a message set
+  fn 'view/threads',->d,env{
+
+    # occurrence-count statistics
+    g = {}
+    d.map{|_,m|
+      m[To].map{|t|
+        g[t.uri]||=0
+        g[t.uri]=g[t.uri].succ}}
+
+    # CSS
+    [(H.css '/css/mail'),
+
+     ([{_: :a, href: '/@'+env.q['p']+'?set=indexP&view=page&v=linkPO&c=12', c: env.q['p']},
+       {_: :a, href: '/m?y=day', c: ' :: '},
+       {_: :a, href: E[env['uri']].url+'?set=indexPO&view=page&v=threads&c=32&p='+env.q['p'], c: env['uri']}
+      ] if env.q['set']=='indexPO'),
+
+     '<table>',
+
+     # subgroup by title
+     d.values.group_by{|r|[*r[Title]][0].sub(/^[rR][eE][^A-Za-z]./,'')}.
+
+     # group by recipient
+     group_by{|r,k|
+
+       # show most-popular first
+       k[0].do{|k|
+         k[To].do{|o|o.sort_by{|t|g[t.uri]}.reverse.head.uri}}}.
+
+     # display
+     map{|e|
+       # recipient-group color
+       c = '#%06x' % rand(16777216)
+       ['<tr><td class=subject>',
+        
+        # show most-popular groups first
+        e[1].sort_by{|m|m[1].size}.reverse.map{|t|
+
+          # link to thread
+          [{_: :a, property: Title, :class => 'thread', style: "border-color:#{c}", href: t[1][0].url+'??=thread',
+             c: t[0].to_s.gsub(/[<>]/,'_').gsub(/\[([a-z\-A-Z0-9]+)\]/,'<span class=g>\1</span>')},
+
+           # link to individual messages
+           (t[1].size > 1 &&
+            ['<br>', t[1].map{|s|
+
+               # author name and RDFa
+               [{_: :a, property: Creator, href: s.url+'??=thread#'+s.uri, :class => 'sender', style: 'background-color:'+c,
+                  c: s[SIOC+'name'][0].split(/\W/,2)[0]},' ']}]),'<br>']},'</td>',
+
+        # recipient group, Mailing List
+        {_: :td, class: :group, property: To,
+          c: {_: :a, :class => :to, style: 'background-color:'+c, c: e[0] && e[0].split(/@/)[0],
+            href: e[0] && e[0].E.url+'?set=indexPO&p=sioc:addressed_to&view=page&v=threads'}},
+
+        '</tr>']},'</table>',
+
+     # link to show full content of entire message-set
+     {_: :a, id: :down, c: '&darr;',href: env['REQUEST_PATH']+env.q.merge({'view'=>'page','views'=>'timegraph,mail','v'=>'multi'}).qs}]}
+
+
+  # show a set of messages
+  fn 'view/mail',->d,e{
+    title = nil
+
+    # JS/CSS dependencies
+    [(H.once e,'mail.js',
+      (H.css '/css/mail'),
+      (H.js '/js/mail'),
+      (H.once e,:mu,(H.js '/js/mu')),
+
+      # up to set-overview
+      ({_: :a, id: :up, href: e['REQUEST_PATH'] + e.q.merge({'view' => 'page', 'v' => 'threads'}).qs, c: '&uarr;'} if d.keys.size > 2),
+
+      # collapse/expand quoted content
+      {id: :showQuote, c: :quote, show: :true},{_: :style, id: :quote}),
+
+     # each message
+     d.values.map{|m|
+
+       # content available?
+       [m.class == Hash && (m.has_key? E::SIOC+'content') &&
+        
+        {:class => :mail,
+          
+          c: [# link to self
+              {_: :a, name: m.uri, href: m.url, rel: :permalink, title: :link, c: ' '},
+              
+              # To:, From: index search links
+              [['sioc:has_creator',Creator],['sioc:addressed_to',To]].map{|a|
+                m[a[1]].do{|m|
+                  m.map{|f| f.respond_to?(:uri) &&
+                    {_: :a, property: a[0], href: f.url+'?set=indexPO&p='+a[0]+'&view=page&views=timegraph,mail&v=multi&c=8', c: f.uri}}}},
+
+              # mailto URI with embedded reply metadata
+              (m['/mail/reply_to']||m[Creator]).do{|r| r[0] && r[0].respond_to?(:uri) &&
+                {_: :a, title: :reply, c: 'r',
+                  href: "mailto:#{r[0].uri}?References=<#{m.uri}>&In-Reply-To=<#{m.uri}>&Subject=#{m[Title].join}"}},'<br clear=all>',
+
+              # content
+              {_: :pre,
+                c: m[Content].map{|b|
+
+                  # line count
+                  i = 0
+
+                  # HTML message content
+                  b.class==String && b.              
+
+                  # erase empty quoted lines
+                  gsub(/^\s*(&gt;)(&gt;|\s)*\n/,"").
+
+                  # each line
+                  lines.to_a.map{|l|
+
+                    # line identifier
+                    f = m.uri + ':' + (i+=1).to_s
+                    
+                    # wrapper
+                    {_: :span, 
+                      
+                      # is line quoted?
+                      class: ((l.match /(^\s*(&gt;|On[^\n]+(said|wrote))[^\n]*)\n/) ? 'q' : 'u'), c:
+
+                      # id
+                      [{_: :a, id: f},
+
+                       # line
+                       l.chomp,
+
+                       # link
+                       (l.size > 64 &&
+                        {_: :a, class: :line, href: '#'+f,c: '↵'}),
+
+                     "\n" ]}}}}, # collate lines
+
+              # title
+              m[Title].do{|t|
+                # only show if changed from previous
+                title != t[0] && (
+                 title = t[0] # update title
+                 [{:class => :title, c: t.html, _: :a, href: m.url+'??=thread#'+m.uri, style: "color: #{E.c}"},
+                  '<br clear=all>'])}]}]}]}
+  
+  # set a default view for MIME and SIOC types
+  [MIMEtype+'message/rfc822',
+   SIOCt+'MailMessage'].
+    map{|m| F['view/'+m] = F['view/mail'] }
+
+end
+
+module TMail
+  class Mail
+    def unicode_body
+      unquoted_body.to_utf8
+    end
+    def decentBody
+      unHTML=->t{t.split(/<body[^>]*>/)[-1].split(/<\/body>/)[0]}
+      if multipart?
+        parts.collect{ |part|
+          c = part["content-type"]
+          if part.multipart?
+            part.decentBody
+          elsif header.nil?
+            ""
+          elsif !attachment?(part) && c.sub_type != 'html'
+            part.unicode_body.hrefs(true)
+          else
+            (c["name"]||'attach').do{|a|
+              message_id ? (message_id[1..-2]+'/'+a).E.do{|i|
+                i.w part.body if !i.e
+                '<a href='+i.url+'>'+(part.main_type=='image' ? '<img src="'+i.url+'">' : a)+"</a><br>\n"
+              } : ""};end
+        }.join
+
+      else
+        unicode_body.do{|b|content_type&&content_type.match(/html/) ? unHTML.(b) : b.hrefs(true)}
+      end
+    rescue
+      ''
+    end 
+  end
+end
+
+# TMail calls this nonexistent method on strings
+class String; def is_binary_data?; true; end; end

data/infod/W/page.rb

@@ -0,0 +1,30 @@
+#watch __FILE__
+class E
+  
+  fn 'head/page',->d,e{ v = e.q['v']
+    Fn 'head' + (v != 'page' && '/' + v), d, e}
+
+  fn 'view/page',->d,e{
+    # try daydirs if no pagination data provided
+    !d.has_any_key(%w{next prev}) &&
+    e['REQUEST_PATH'].match(/(.*?\/)([0-9]{4})\/([0-9]{2})\/([0-9]{2})(.*)/).do{|m|
+      t = ::Date.parse "#{m[2]}-#{m[3]}-#{m[4]}"
+      d['prev'] = {'uri' => 'prev','url' => m[1]+(t-1).strftime('%Y/%m/%d')+m[5]}
+      d['next'] = {'uri' => 'next','url' => m[1]+(t+1).strftime('%Y/%m/%d')+m[5]}}
+
+    # links
+    c=[d['prev'].do{|p| d.delete('prev') # prev
+         {_: :a, rel: :prev, style: 'float:left; font-size:2em',
+           href: [*p['url']][0]+e.q.merge(p).except('uri','url').qs,
+           title: (p['b']||p['url']), c: '←'}},
+
+       d['next'].do{|n| d.delete('next') # next
+         {_: :a, rel: :next, style: 'float:right;font-size:2em',
+           href: [*n['url']][0]+e.q.merge(n).except('uri','url').qs, 
+           title: (n['b']||n['url']), c: '→'}}]
+
+    [(H.js '/js/pager'),(H.once e,:mu,(H.js '/js/mu')), # n/p key shortcuts
+     c,(H (F['view/'+e.q['v']]||F['view']).(d,e)),      # content
+     '<br clear=all>',c]}
+  
+end

data/infod/W/pdf.rb

@@ -0,0 +1,16 @@
+class E
+
+  F["?"]||={}
+  F["?"].update({'pdf'=>
+                  {'filter'=>'p',
+                    'p'=>'uri,Author,Title,Producer,dc:date,stat:size',
+                    'sort'=>'Producer',
+                    'view'=>'tab'
+                  }})
+
+  def triplrPDF &f
+    yield uri,Content,`pdftotext #{sh}; cat #{docBase.a('.txt').sh}`
+    dateNorm :triplrStdOut,'pdfinfo', &f
+  end
+
+end

data/infod/W/post.rb

@@ -0,0 +1,9 @@
+#watch __FILE__
+class E
+
+  F['view/'+SIOC+'Post']=->g,r{
+    g.map{|u,r|
+      r[Content].do{|c|
+        [r.html]}}}
+
+end

data/infod/W/rdf.rb

@@ -0,0 +1,32 @@
+class E
+
+  def self.requireRDF; %w{n3 rdfa rdfxml turtle}.map{|r|require 'rdf/'+r}; require 'json/ld' end
+
+  def self.renderRDF d,f=:ntriples; E.requireRDF
+    RDF::Writer.for(f).buffer{|w|
+      d.values.each{|r|
+        r.triples{|s,p,o|
+#          puts :s,s,:p,p,:o,o.class,o
+          w << RDF::Statement.new(RDF::URI(s),RDF::URI(p),
+                                  (o.class==Hash||o.class==E) ?
+                                    RDF::URI(o.uri) :
+                                    RDF::Literal(o))}}}
+  rescue Exception => e
+    puts [:RDF,d.keys[0..8],f,e].join ' '
+  end
+
+  def triplrRDFformats t=nil
+    E.requireRDF
+    (t == :rdfa ? RDF::RDFa : RDF)::Reader.
+      open(e ? d : uri, :format => t){|r|
+      r.each_triple{|s,p,o|
+        yield s.to_s, p.to_s,
+        ((o.class==RDF::Node || o.class==RDF::URI) ? o.to_s.E :
+                                                     o.value.do{|v|
+                                                       v.class == String ? v.to_utf8 : v})}}
+    self
+  rescue Exception => e
+    puts [:RDF,uri,e].join ' '
+  end
+
+end

data/infod/W/schema.rb

@@ -0,0 +1,172 @@
+#watch __FILE__
+class E
+  
+  # install schema-cache
+  def E.schemaCache
+    E.schemaDocs.map &:schemaCache
+  end
+  def E.schemaUncache
+    E.schemaDocs.map &:schemaUncache
+  end
+
+  def schemaCache
+    schemaCacheDoc
+    schemaIndexDoc
+  end
+  def schemaUncache
+    schemaUnindexDoc
+    schemaUnlinkSlashURIs
+    schemaUncacheDoc
+  end
+
+  # cache schema docs
+  def schemaCacheDoc
+    if ttl.e || ef.e # already cached?
+      print "c "
+    else
+      ttl.w(`rapper -o turtle #{uri}`) # write turtle
+    end
+  end
+
+  def schemaUncacheDoc
+    ef.deleteNode  # remove JSON
+    ttl.deleteNode # remove Turtle
+  end
+  
+  # index schema docs
+  def schemaIndexDoc
+    c = E.schemaStatistics
+    if (nt.e ||                           # skip already-processed docs
+        ttl.do{|d|d.e && d.size > 256e3}) # skip huge dbpedia/wordnet dumps
+      print "e "
+    else
+      g = graph           # schema graph
+      ttl.deleteNode      # convert Turtle 
+      ef.w g,true if !ef.e# to JSON (for faster loading)
+      roonga "schema"     # index in rroonga
+      m={};      puts uri # statistics graph 
+      g.map{|u,_|         # each resource
+        c[u] &&           # do stats exist?
+        m[u] = {'uri'=>u, '/frequency' => c[u]}} # add to graph
+      nt.w E.renderRDF m  # store N-triples
+      schemaLinkSlashURIs # link "Slash-URI" resources to definer
+    end
+  end
+
+  def schemaUnindexDoc
+    unroonga
+    nt.deleteNode
+  end
+
+  # make slash-URIs resolvable
+  def schemaLinkSlashURIs undo=false
+    return if !ef.e      # cache populated?
+    graph.do{|m|                     # build graph
+      m.map{|u,r|                    # iterate through URIs
+        r[RDFs+'isDefinedBy'].do{|d| # check for DefinedBy attribute
+          t = u.E.ef     # symlink location
+          t.dirname.dir  # container dir of symlink
+          if undo
+            if t.e
+              t.deleteNode # remove link
+              puts "-#{t}"
+            end
+          else
+            unless t.e
+              ef.ln t      # add link
+              puts "#{t} -> #{ef}"
+            end
+          end
+        }}}
+    rescue Exception => e
+    puts e
+  end
+
+  def schemaUnlinkSlashURIs
+    schemaLinkSlashURIs :undo
+  end
+
+  # parse gromgull's BTC statistics
+  def E.schemaStatistics
+    @gromgull ||=
+      (data = '/predicates.2010'.E
+    (puts "curl http://data.whats-your.name/schema/gromgull.gz | zcat > predicates.2010"; exit) unless data.e
+    # occurrence count :: URI -> int
+    usage = {}
+    data.read.each_line{|e|
+      e.match(/(\d+)[^<]+<([^>]+)>/).do{|r|
+        usage[r[2]] = r[1].to_i }}
+    usage)
+  end
+  
+  # parse schema URIs
+  def E.schemaDocs
+    @docs ||=
+      (source = E['http://prefix.cc/popular/all.file.txt']
+       mirror = E['http://localhost/css/i/prefix.cc.txt']
+       schemae = (mirror.e ? mirror : source).
+       read.split("\n").           # each doc
+       grep(/^[^#]/).              # skip commented
+       map{|t|t.split(/\t/)[1].E}) # URI field
+  end
+
+  fn '/schema/GET',->e,r{
+    r.q.merge!({
+                 'graph'=>'roonga',
+                 'context'=>'schema',
+                 'view'=>'search',
+                 'filter'=>'frag',
+                 'v'=>'schema',
+                 'c'=>(r.q.has_key?('q') ? 1000 : 0)
+               })
+    e.response
+  }
+  
+  fn 'u/schema/weight',->d,e{
+    q = e.q['q']
+    d.keys.map{|k| k.class==String && d[k].class==Hash &&
+      (s=0
+       u=k.downcase
+       d[k]['/frequency'][0].to_i.do{|f|f > 0 && (s=s + (Math.log f))}
+       s=s+(u.label.match(q.downcase) && 6 || 
+            q.camelToke.map(&:downcase).map{|c|
+              u.match(c) && 3 || 0}.sum)
+       d[k]['score'] = s )}}
+  
+  fn 'view/schema',->d,e{
+    # score resources on popularity, URL friendliness 
+    Fn 'u/schema/weight',d,e
+    # sort updated response-graph based on score
+    d = d.select{|u,r|
+      r['score'] && r['score'].respond_to?(:>)
+    }.sort_by{|u,r| r['score'] }.reverse
+
+    d.size > 0 &&
+    (# fit values to CSS range
+     scale = 255 / d[0][1]['score'].do{|s|s > 0 && s || 1}
+     [(H.css '/css/schema'),'<table>',
+      d.map{|u,r|
+        # score -> normalized score
+        v = r['score'] * scale
+        # score -> greyscale value
+        f = '%02x' % v
+        # greyscale val -> full CSS
+        style = 'color:#'+(v > 128 ? '000' : 'fff')+';background-color:#'+f+f+f
+        # stats on stats
+        title = r['/frequency'][0].to_s + ' | %.3f'%r['score']
+
+        [{_: :tr, class: :overview, style: style, title: title,
+           c: [{_: :td, class: :identity,
+                 c: u.E.html},
+               {_: :td, class: :label,
+                 c: [{_: :span, class: :stats, c: title},
+                     r[RDFs+'label'][0].do{|l|
+                       {_: :a, href: r.uri,class: :label,c: l}}]}]},
+         {_: :tr, class: :details, style: style, title: title,
+           c: {_: :td, colspan: 2, class: :describe,
+             c: [r[RDFs+'comment'][0].do{|l|
+                   {_: :span,class: :comment, c: l}},' ',
+                 {_: :a, href: '/@'+u.sub('#','%23')+'?filter=frag',
+                   c: '&gt;&gt;'}]}}]},'</table>'])}
+
+end

data/infod/W/search.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,30 @@
+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