infod 0.0.1 → 0.0.2

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

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

@@ -1,24 +0,0 @@
-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/find.rb

@@ -1,24 +0,0 @@
-#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/grep.rb

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

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

@@ -1,61 +0,0 @@
-#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/kv.rb

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

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