infod 0.0.1

data/infod/W/examine/sw.rb

@@ -0,0 +1,114 @@
+#watch __FILE__
+
+#curl http://eibispace.de/dx/sked-b11.csv > s.ssv
+#wget http://www1.m2.mediacat.ne.jp/binews/bib11.zip http://hfcc.org/data/b11/b11allx2.zip
+#unzip bia11.zip ;unzip b11allx2.zip
+#xlsx2csv 
+
+class E
+
+  F["?"]||={}
+  F["?"].update({
+                  'sw' => {
+                    'view' => 'examine',
+                    'ev'=>'sw',
+                    'a'=>'Lng:49',
+                    'minP' => 'FREQ',
+                    'maxP' => 'FREQ',
+                    'filter' => 'map',
+                    'kHz:75' => 'FREQ',
+                    'Time(UTC):93' => 'UTC',
+                    'Station:201' => 'STATION',
+                  }
+                })
+
+  fn 'view/sw/base',->d,e,c{
+    bands = {
+      120 => [2200,2500],
+      90 => [3100,3450],
+      75 => [3890,4123],
+      60 => [4740,5125],
+      49 => [800,6300],
+      40 => [7200,7600],
+      31 => [9200,9999],
+      25 => [11500,12160],
+      22 => [13500,13900],
+      19 => [15001,15900],
+      16 => [17500,17900],
+      13 => [21450,21850],
+      11 => [25700,26500],
+    }
+    band=0
+    e[:clr]={}
+    e[:fmax]=d.map{|_,r|r['FREQ'][0].to_f}.flatten.max||30000.0
+    e[:scale]=100/(e[:fmax] - (d.map{|_,r|r['FREQ'][0].to_f}.flatten.min||0))
+    [(H.css '/css/sw'),(H.js '/js/sw'),
+#    [(H.css '/css/sw',true),(H.js '/js/sw',true),
+     {id: :bands,
+       c: bands.map{|meters,bounds|
+         band += 1
+         {_: :a, class: :band,
+           style: "background-color:##{band % 2 == 0 ? 'fff' : 'cecece'}",
+           c: '<span style="font-size:1.4em">'+meters.to_s+'</span>m',
+           href: meters.to_s+'m.html'}}},
+       {id: :scales, c: %w{800 1200 1600}.map{|b|{_: :span,class: :scale, c: b}}},
+       {id: :spectrum, style: 'height:800px;position:absolute', c:
+         [{id: 't'},{class: 'loc'},{id: 'clock'},c.(),
+          (0..23).map{|h|
+            [0,15,30,45].map{|m|
+              t = h*60+m
+              left = t*4
+              utc="%02d%02d"%[h,m]
+              [(1..3).map{|l|
+                 {_: :span, class: :u, c: utc, style: "top:#{l*25}%;left:#{left-19}px;"}},
+                 {class: :s,style: "border-color:#{m==0 ? 'white' : '#666'};left:#{left}px;"}]}}]}]}
+  
+  fn 'view/sw/item',->r,x{
+    min=->t{t='%04d' % (t.class==String && t.empty? ? 0 : t)
+      t[0..1].to_i*60+t[2..3].to_i}
+    u=r['UTC'][0].match(/(\d+)-(\d+)/)    
+    b=u[1].to_i; e=u[2].to_i
+    f=r['FREQ'][0].to_f
+    fi = f.to_i
+    n = fi / 100
+    x[:clr][n] ||= '#%06x' % rand(16777216)
+    f && b && e &&
+    (bmin=min.(b); emin=min.(e)
+     top=(x[:fmax]-f)*x[:scale]
+     v=->b,e{
+       {t: r.except('uri','UTC','FREQ').values.join(' '),:class => :bar, b: b, e: e, f: fi,style:"
+background-color:#{x[:clr][n]};
+top: #{top}%;
+left: #{b*4.0}px;
+width:#{(e-b) * 4.0}px;
+",c: (e-b > 60 ?
+      ((0..(e-b)/60).map{|h|
+         {_: :span, style: "position:absolute;left:#{h*120}px;top:0",c: f}}) : f)}}
+     (bmin > emin) ? [v.(0,emin),
+                      v.(bmin,1440)] : v.(bmin,emin))}
+  
+  fn 'view/sw',->d,e{
+    i=F['view/sw/item']
+    Fn 'view/sw/base',d,e,->{d.map{|u,r|i.(r,e)}}}
+
+  fn 'filter/gh',->o,m,_{
+    m.values.map{|r|
+      r[Content].do{|c| 
+        c.join.lines.each_with_index{|l,i|
+          l.match(/^[^<]+$/) &&
+          (u=r.uri+'#'+i.to_s
+           m[u]={'uri' => u,
+             'big'=>[l.scan(/\b[A-Z][A-Z][A-Z]+\b/)],
+             Content=>[l]}
+           l.scan(/\d{4,}/){|d| d=d.to_i
+             if (d > 2400) && (d < 30000)
+               m[u]['FREQ']=[d]
+             elsif
+               m[u]['UTC']=["#{d}-#{d+30}"]
+             end}
+           m.delete u unless m[u].has_keys ['UTC','FREQ']
+           )}
+        m.delete r.uri
+      }}}
+  
+end

data/infod/W/examine/time/graph.rb

@@ -0,0 +1,86 @@
+#watch __FILE__
+class E
+
+  F["?"]||={}
+  F["?"].update({'taft'=>{
+                'graph'=>'|',
+                    '|'=>'triplrMozHist',
+                 'view'=>'page',
+                    'v'=>'timegraph',
+                  'arc'=>'referer'}})
+
+  # massage data for timegraph
+  fn 'filter/timegraph',->e,m,_{
+
+    e['timegraph'] ||= true
+
+    x = e['x'] || Date # x prop
+    y = e['y']         # y property
+
+    # 2D values
+    vX = m.map{|_,r|r[x]}.flatten.compact.map(&:to_time).map &:to_f
+    vY = m.map{|_,r|r[y]}.flatten.compact.map &:to_f
+    maxX = vX.max
+    minX = vX.min
+    maxY = vY.max
+    minY = vY.min
+
+    # scaling-ratio to normalize values to %
+    scaleX = 100/((maxX-minX).do{|v|v==0 ? 100 : v}||100)
+    scaleY = 100/((maxY-minY).do{|v|v==0 ? 100 : v}||100)
+
+    # annotate resources with positioning data
+    m.map{|u,r|
+      r['x'] = [*r[x]][0].do{|v|(maxX - v.to_time.to_f)*scaleX} || 0
+      r['y'] = y.do{|y|[*r[y]][0].do{|v|(maxY - v.to_f)*scaleY} || 0} || rand(100)}
+  }
+
+  # a linked-timeline view
+  fn 'view/timegraph',->d,e{
+    # use standard structure for examine faceted-filtering
+   i=F['view/timegraph/item']
+    Fn 'view/timegraph/base',d,e,->{d.map{|u,r|i.(r,e)}}}
+  
+  # timegraph container-element
+  fn 'view/timegraph/base',->d,e,c{
+    Fn 'filter/timegraph', e.q, d, nil unless e.q['timegraph']==true
+
+    e[:graph] = d
+    e[:group] = {}
+    e[:color] = E.c
+
+    [H.css('/css/timegraph'),{class: :timegraph, c: c.()}]}
+
+  # timegraph entry
+  fn 'view/timegraph/item',->r,x{
+    # skip resources w/o x-axis field
+    if r[x.q['x'] || Date]
+
+      labelP = x.q['label'].expand || Creator
+      label = (r[labelP][0]).do{|l|
+               l.respond_to?(:uri) ? l.uri : l.to_s}
+      lc = x[:group][label] ||= E.c
+
+      [{style: "top: #{r['x']}%; left: 0", class: :date, c: r[Date][0]},
+       {style: "top: #{r['x']}%; left: #{r['y']}%",
+         c: [{_: :a, href: r.url, c: '#', class: :link},
+             {_: :a,
+               title: r[Date][0],
+               href: '#'+r.uri,
+               class: :label,
+               style: "background-color: #{lc}",
+               c: label,
+             }]},
+       
+       # arc(s)
+       {_: :svg, c:
+         r[x.q['arc'].expand].map{|e|
+           # target resource
+           x[:graph][e.uri].do{|e|
+             # arc path
+             {_: :line, class: :arc, stroke: x[:color], 'stroke-dasharray'=>"2,2",
+               y1: e['x'].to_s+'%', x1: e['y'].to_s+'%',
+               y2: r['x'].to_s+'%', x2: r['y'].to_s+'%'}}}}]
+    end }
+  
+end

data/infod/W/examine/time/line.rb

@@ -0,0 +1,24 @@
+class E
+
+ ## SIMILE Timeline 
+ #  http://www.simile-widgets.org/
+
+  # JSON format
+  fn Render+'application/timeline',->d,e{
+    {dateTimeFormat: 'iso8601',
+      events: d.values.map{|r|
+        r[Date].do{|d|
+          {description: r.uri,
+          title: r[Title],
+          start: [*d][0],
+          link: r.url,
+        }}}.compact}.to_json}
+
+  fn 'head/timeline',->d,e{
+  ['<script>var t="'+e['REQUEST_PATH']+e.q.except('view','?').merge({format: 'application/timeline'}).qs+'"</script>',
+   (H.js '/js/timeline'),
+   (H.js 'http://api.simile-widgets.org/timeline/2.3.1/timeline-api')]}
+
+  fn 'view/timeline',->d,e{'<div id="tl" class="timeline-default" style="height: 300px;"></div>'}
+
+end

data/infod/W/feed.rb

@@ -0,0 +1,116 @@
+#watch __FILE__
+module FeedParse
+  def html; CGI.unescapeHTML self end
+  def cdata; sub /^\s*<\!\[CDATA\[(.*?)\]\]>\s*$/m,'\1'end
+  def guess; send (case self
+                   when /^\s*<\!/m
+                     :cdata
+                   when /</m
+                     :id
+                   else
+                     :html
+                   end) end
+
+  def parse # Universal feed-parser
+
+    #xml qname table
+    x={}
+    match(/<(rdf|rss|feed)([^>]+)/i)[2].scan(/xmlns:?([a-z]+)?=["']?([^'">\s]+)/){|m|x[m[0]]=m[1]}
+
+    #items
+    scan(%r{<(rss:|atom:)?(item|entry)([\s][^>]*)?>(.*?)</\1?\2>}mi){|m|
+
+      #URI
+      u = m[2] && (u=m[2].match /about=["']?([^'">\s]+)/) && u[1] ||
+          m[3] && (((u=m[3].match /<(gu)?id[^>]*>([^<]+)/) || (u=m[3].match /<(link)>([^<]+)/)) && u[2])
+      yield u,E::Type,(E::SIOC+'Post').E
+
+      #links
+      m[3].scan(%r{<(link|enclosure|media)([^>]+)>}mi){|e|
+        yield(u,                                                                       # s
+              E::Atom+'/link/'+((r=e[1].match(/rel=['"]?([^'">\s]+)/)) ? r[1] : e[0]), # p
+              e[1].match(/(href|url|src)=['"]?([^'">\s]+)/)[2].E)}                     # o
+
+      #elements
+      m[3].scan(%r{<([a-z]+:)?([a-z]+)([\s][^>]*)?>(.*?)</\1?\2>}mi){|e|
+        yield u,                           # s
+        (x[e[0]&&e[0].chop]||E::RSS)+e[1], # p
+        e[3].extend(FeedParse).guess}}     # o
+    
+    nil
+  end
+end
+
+class E
+
+  Atom = W3+'2005/Atom'
+   RSS = Purl+'rss/1.0/'
+  RSSm = RSS+'modules/'
+  Feed = (E RSS+'channel')
+
+  def listFeeds; (nokogiri.css 'link[rel=alternate]').map{|u|E (URI uri).merge(u.attr :href)} end
+  alias_method :feeds, :listFeeds
+
+  def getFeed g; addJSON :triplrFeed,g end
+  def getFeedReddit g; addJSON :triplrFeedReddit,g end
+
+  # tripleStream
+  def triplrFeed &f 
+    dateNorm :triplrFeedSIOCize,:triplrFeedRaw,&f
+  rescue Exception => x
+  end
+
+  def triplrFeedReddit &f
+    require 'nokogiri'
+    triplrFeed {|s,p,o|
+     p == Content ?
+      Nokogiri::HTML.parse(o).do{|o|
+        o.css('.md').do{|o|yield s,p,o}
+        yield s,Creator,o.css('a')[-4].child.to_s.strip
+      } : (yield s,p,o)}
+  end
+
+  # tripleStream
+  def triplrFeedRaw &f
+    read.extend(FeedParse).parse &f
+  end
+
+  # tripleStream -> tripleStream
+  def triplrFeedSIOCize *f
+    send(*f){|s,p,o|
+      yield s,
+      { Purl+'dc/elements/1.1/creator' => Creator,
+        Purl+'dc/elements/1.1/subject' => SIOC+'subject',
+        Atom+'author' => Creator,
+        RSS+'description' => Content,
+        RSS+'encoded' => Content,
+        RSSm+'content/encoded' => Content,
+        Atom+'content' => Content,
+        RSS+'title' => Title,
+        Atom+'title' => Title,
+      }[p]||p,
+      o } end
+
+
+  fn Render+'application/atom+xml',->d,e{
+    id = 'http://' + e['SERVER_NAME'] + (CGI.escapeHTML e['REQUEST_URI'])
+    H(['<?xml version="1.0" encoding="utf-8"?>',
+       {_: :feed,xmlns: 'http://www.w3.org/2005/Atom',
+         c: [{_: :id, c: id},
+             {_: :title, c: id},
+             {_: :link, rel: :self, href: id},
+             {_: :updated, c: Time.now.iso8601},
+             d.map{|u,d|
+               d[Content] &&
+               {_: :entry,
+                 c: [{_: :id, c: u},
+                     {_: :link, href: d.url},
+                     d[Date].do{|d|{_: :updated, c: d[0]}},
+                     d[Title].do{|t|{_: :title, c: t}},
+                     d[Creator].do{|c|{_: :author, c: c[0]}},
+                     {_: :content, type: :xhtml,
+                       c: {xmlns:"http://www.w3.org/1999/xhtml", c: d[Content]}}
+                    ].intersperse("\n")}
+             }.intersperse("\n")]}])}
+
+end

data/infod/W/find.rb

@@ -0,0 +1,24 @@
+#watch __FILE__
+class E
+
+  fn 'set/find',->e,q,m{
+    t=q['day'] && q['day'].match(/^\d+$/) && '-ctime -'+q['day']
+    s=q['size'] && q['size'].match(/^\d+$/) && '-size +'+q['size']+'M'
+    r=q['q'] && '-iregex ' + ('.*'+q['q']+'.*').sh
+    `find #{e.sh} #{t} #{s} #{r} | head -n 1024`.lines.map &:pathToURI}
+  
+  fn 'graph/find',->e,q,m{
+    (Fn 'set/find', e,q,m).do{|f|
+      if f.size < 256
+        f.map{|r|r.fromStream m,:triplrInode,false}
+      else
+        f.map{|r|m[r.uri]=r}
+      end}}
+
+  fn 'view/find',->i,e{
+    {_: :form, method: :GET, action: e['REQUEST_PATH'].t, style: 'float: right',
+      c: [{_: :input, name: :graph, value: :find, type: :hidden},
+          {_: :input, name: :view, value: :ls, type: :hidden},
+          {_: :input, name: :q}]}}
+
+end

data/infod/W/forum.rb

@@ -0,0 +1,3 @@
+class E
+
+end

data/infod/W/grep.rb

@@ -0,0 +1,27 @@
+#watch __FILE__
+class E
+
+  fn 'set/grep',->e,q,m{
+    `grep -rl#{q.has_key?('i') && 'i'} #{q['q'].sh} #{e.sh}`.lines.map &:pathToURI
+  }
+
+  fn 'view/grep',->d,e{
+    w=e.q['q'].scan(/[\w]+/).map(&:downcase).uniq # split/dedupe words
+    c={}; w.each_with_index{|w,i|c[w]=i}                 # word index
+    a=/(#{w.join '|'})/i                                  # OR pattern
+    p=/#{w.join '.*'}/i                                   # sequential pattern
+    [H.css('/css/search'),{_: :style, c: c.values.map{|i| # word styles
+       b = rand(16777216)                                 # random color
+       f = b > 8388608 ? :black : :white                  # keep text contrasty
+       ".w#{i} {background-color: #{'#%06x' % b}; color: #{f}}\n"}},# CSS
+     d.map{|u,r| l = r.to_s.gsub(/<[^>]*>/,'').lines      # plaintextify
+       g = l.grep p                                       # sequential match first
+       g = l.grep a if g.empty?                           # OR match second
+       !g.empty? &&                                       # find anything?
+       [r.E.do{|e|{_: :a,href: e.url,c: e}},'<br>',       # doc link
+        [g[-1*(g.size.max 3)..-1].map{|l|         # show 3 matches per doc
+           l[0..404].gsub(a){|g|                   # create exerpt
+             H({_: :span, class: "w w#{c[g.downcase]}",c: g})} # style exerpt
+         },"<br>"]]}]}
+
+end

data/infod/W/html.rb

@@ -0,0 +1,143 @@
+#watch __FILE__
+
+class Array
+  def html table=true
+    map(&:html).join ' '
+  end
+end
+
+class Object
+  def html *a
+    to_s.gsub('<','&lt;').gsub('>','&gt;')
+  end
+end
+
+class String
+  def br
+    gsub(/\n/,"<br>\n")
+  end
+  def href name=nil
+    '<a href="'+self+'">'+(name||(Fn 'abbrURI',self))+'</a>'
+  end
+  def html
+    if match /\A(https?:\/\/)[\S]+\Z/
+      href
+    else
+      self
+    end
+  rescue
+    self
+  end
+end
+
+class Hash
+  def html
+    H({_: :table, class: :html, c: 
+        map{|k,v|
+          {_: :tr, property: k, c:
+            [{_: :td,c: (Fn 'abbrURI',k), class: :key},
+             {_: :td,
+               c: (case k
+                   when E::Content
+                     {_: :pre, style: "white-space: pre-wrap", c: v}
+                   when 'uri'
+                     u = v.E
+                     {_: :a, id: u, href: u.url, c: v}
+                   else
+                     v.html
+                   end), class: :val}].cr}}.cr})
+  end
+end
+
+class E
+  def html name=nil,l=false
+      (l ? url : uri).href name
+   end
+
+  def link
+    html '#',true
+  end
+
+  fn 'abbrURI',->u{
+    u.to_s.sub(/(?<scheme>[a-z]+:\/\/)?(?<abbr>.*?)(?<frag>[^#\/]+)$/,
+               '<span class="abbr"><span class="scheme">\k<scheme></span>\k<abbr></span><span class="frag">\k<frag></span>')
+  }
+
+  fn 'head',->d,e{
+    [{_: :title, c: d.attr(Title) || e.uri},
+     (Fn 'head.formats',e),
+     (Fn 'head.icon')].cr}
+
+  fn 'head.formats',->e{
+    F.keys.grep(/^render/).map{|f|
+      f = f[7..-1]
+      {_: :link, rel: :meta, type: f, href:'http://' + e['SERVER_NAME'] + e['REQUEST_PATH'] + e.q.merge({'format' => f}).qs}}.cr}
+
+  fn 'head.icon',->{{_: :link, href:'/css/i/favicon.ico', rel: :icon}}
+
+  # domain-specific view
+  fn 'view',->d,e{( Fn 'view/divine/set',d,e)||
+    d.values.map{|r|Fn 'view/divine/item',r,e}}
+
+  # no domain-specific view
+  fn 'view/base',->d,e{[H.css('/css/html'),d.values.map(&:html)]}
+
+  # select view - filesystem hints
+  fn 'view/divine/set',->d,e{
+    d.values.map{|e|e.E.base}.do{|b|
+      s = b.size.to_f
+      t = 0.42 # threshold
+   if b.grep(/^msg\./).size / s > t # email
+      Fn 'view/threads',d,e
+elsif b.grep(/(aif|wav|flac|mp3|m4a|aac|ogg)$/i).size / s > t # audio
+      Fn 'view/audioplayer', d,e
+elsif b.grep(/(gif|jpe?g|png)$/i).size / s > t # images
+      Fn 'view/th', d,e
+elsif b.grep(/\.log$/).size / s > t
+      Fn 'view/chat', d,e
+ else false
+   end}}
+
+  Data['view/divine/item'] = "use RDF typeclass hints to choose view for a resource"
+  fn 'view/divine/item',->r,e{
+    r.class==Hash && r[Type] && r[Type][0] && r[Type][0].respond_to?(:uri) &&
+    (t = r[Type][0].uri; !t.empty? && # a RDF type
+     (F['view/'+t] ||
+      F['view/'+t.split(/\//)[-2]]).do{|f|
+       f.({r.uri => r},e)}) ||
+    [r.html,H.once(e,'css',H.css('/css/html'))] }
+
+  Data['view/select'] = "show a menu of all views available"
+  fn 'view/select',->d,e{
+    [{_: :style, c: 'a {min-width:22em;text-align:right}'},
+    F.keys.grep(/^view\/(?!application)/).map{|v|
+      [{_: :a, href: e['REQUEST_PATH']+e.q.merge({'view' => v[5..-1]}).qs,c: v},'<br>']}]}
+   F['view/?'] = F['view/select']
+
+  F['doc/view/multi'] = "display multiple comma-separated <b>views</b>"
+  fn 'view/multi',->d,e{e.q['views'].split(',').map{|v|Fn'view/'+v,d,e}}
+
+  def triplrBlob
+    glob.select(&:f).do{|f|f.map{|r|
+        yield r.uri,Type,E('blob')
+        yield r.uri,Content,r.r}} end
+  graphFromStream :triplrBlob
+
+  def triplrHref e=nil
+    yield uri,Content,read.do{|r|e ? r.force_encoding(e).to_utf8 : r}.hrefs
+  end
+
+  fn Render+'text/html',->d,e{
+    v = e.q['view'].to_s
+    h = F['head/'+v] || F['head'] 
+    v = F['view/'+v] || F['view']
+
+    H(e.q.has_key?('un') ? v.(d,e) :
+      ['<!DOCTYPE html>',
+       {_: :html,
+         c: [{_: :head,
+               c: ['<meta charset="utf-8" />',
+                   h.(d,e)]},
+             {_: :body, c: v.(d,e)}].cr}].cr)}
+
+end

data/infod/W/image.rb

@@ -0,0 +1,61 @@
+#watch __FILE__
+class E
+
+  def thumb?
+    mime.match(/^(image|video)/) && # is file an image?
+   @r.qs.match(/^[0-9]{0,3}x[0-9]{0,3}$/) && # valid dimensions?
+    base.match(/^[^.]/) # skip "invisible" images
+  end
+
+  def thumb
+    E['/E/images/'+
+      [no.stat.do{|s|
+         [s.ino,s.mtime]},
+       @r.qs].h.dive+'.png'].do{|n| n.e ||
+      (n.dirname.dir
+       mime.match(/^video/) &&
+       `ffmpegthumbnailer -s #{@r.qs.match(/[0-9]+/).to_s} -i #{sh} -o #{n.sh}` ||
+       `gm convert #{sh} -thumbnail "#{@r.qs}" #{n.sh}`)
+      n.env @r }
+  end
+  
+  fn 'view/img',->i,_{
+    [i.values.map{|i|
+       [{_: :a, href: i.url,
+          c: {_: :img,
+            style:'float:left;max-width:61.8%',
+            src: i.url}},
+        i.html]},
+     (H.css '/css/img')
+    ]}
+  
+  fn 'view/th',->i,e{
+    s=e.q['s']||'233'
+    i.map{|u,i| u.match(/(gif|jpg|png|tiff)$/i) &&
+      {_: :a, href: i.url+'?view=img',
+        c: {_: :img, src: i.url+'?'+s+'x'+s}}}}
+
+  F['view/'+MIMEtype+'image/gif'] = F['view/th']
+  F['view/'+MIMEtype+'image/jpeg']= F['view/th']
+  F['view/'+MIMEtype+'image/png'] = F['view/th']
+
+  fn 'view/imgs',->m,e{ require 'nokogiri'
+    h=e.q['h'].do{|h|h.match(/^[0-9]+$/).do{|_|'height:'+h+'px'}}
+    seen={}
+    x=->i{i&&i.match(/(jpg|gif|png)$/i)&&i}
+    [(H.once e,:mu,H.js('/js/mu')),H.js('/js/images'),
+     m.values.map{|v|
+       [[*v[Content]].map{|c|
+          c.class == String &&
+         (Nokogiri::HTML.parse(c).do{|c|
+            [c.css('img').map{|i|i['src']}.compact,
+             c.css(  'a').map{|i|i['href']}.select(&x)]
+            })},
+        x.(v.uri),
+        (v.respond_to?(:values)&&v.values.flatten.map{|v|v.respond_to?(:uri)&&v.uri}.select(&x))
+       ].flatten.uniq.compact.map{|s|
+         {s: s,c: ->{"<a href='#{v.uri.to_s.do{|u|u.path? ? u : u.E.url}}'><img style='float:left;#{h}' src='#{s}'></a>"}}}}.flatten.map{|i|
+       !seen[i[:s]] && (seen[i[:s]]=true; i[:c].())
+     }]}
+
+end

data/infod/W/json.rb

@@ -0,0 +1,44 @@
+class E
+
+  def triplrJSON
+    yield uri, '/application/json', (JSON.parse read) if e
+  end
+
+
+  # addJSON :: tripleStream -> JSON graph (fs)
+  def addJSON i,g,p=[]
+    fromStream({},i).map{|u,r| # stream -> graph
+      (E u).do{|e| # resource
+        j = e.ef   # inode
+        j.e ||     # exists?
+        (p.map{|p|r[p].do{|o|e.index p,o[0]}} # index properties
+         j.w({u => r},true) # write doc
+         puts "a #{e}"
+         # link opaque-URI docs as siblings of base-URI
+         e.a('.e').do{|u| (j.ln u) unless ((j.uri == u.uri) || u.e)  }
+         e.roonga g # index content
+         )}}
+    self
+    rescue Exception => e
+    puts :addJSON,uri,e
+  end
+
+  fn 'view/application/json',->m,e{
+    m.map{|u,j|
+      e.q['sel'].do{|s|
+        c = j['/application/json'][0]
+        s.split(/\./).map{|s|
+          s = s.to_i if s.match(/^\d$/)
+          c = c[s] }
+        [{_: :a,
+           href: u+'?q=json&view=application/json&sel='+s,
+           c: {_: :b, c: u+'#'+s}}, c.html]
+      }||[{_: :h3, c: u},j.html]}}
+  
+  def to_json *a
+    to_h.to_json *a
+  end
+
+  fn Render+'application/json',->d,_=nil{[d].to_json}
+
+end