infod 0.0.1 → 0.0.2

data/infod/Es/image.rb

@@ -0,0 +1,114 @@
+#watch __FILE__
+class E
+
+  def triplrImage &f
+    triplrStdOut 'exiftool', EXIF, &f
+  end
+  
+  # export EXIF to RDF-in-JSON (recursive)
+  def exif
+    take.map{|g|
+      if g.uri.match /(jpe?g|gif|png)$/i
+        e = g.ef
+        if !e.e || e.m < g.m
+          g.ef.w g.fromStream({},:triplrImage), true
+          puts "EXIF #{g} #{g.ef.size} bytes"
+        end
+      end}
+  end
+
+  fn 'req/scaleImage',->e,r{
+    i = [e,e.pathSegment].compact.find(&:f)
+    if i && i.size > 0
+      size = r.q['px'].to_i.min(8).max(4096)
+      stat = i.node.stat
+      id = [stat.ino,stat.mtime,size].h.dive
+      path = E['/E/image/'+id+'.png']
+      if !path.e
+        path.dirname.mk
+        if i.mimeP.match(/^video/)
+          `ffmpegthumbnailer -s #{size} -i #{i.sh} -o #{path.sh}`
+        else
+          `gm convert #{i.sh} -thumbnail "#{size}x#{size}" #{path.sh}`
+        end
+      end
+      path.e ? (path.env r).getFile : F[E404][e,r]
+    else
+      F[E404][e,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{
+    i.map{|u,i| u.match(/(gif|jpe?g|png|tiff)$/i) &&
+      {_: :a, href: i.url+'?triplr=triplrImage&view=img',
+        c: {_: :img, src: i.url+'?y=scaleImage&px=233'}}}}
+
+  F['view/'+MIMEtype+'image/gif'] = F['view/th']
+  F['view/'+MIMEtype+'image/jpeg']= F['view/th']
+  F['view/'+MIMEtype+'image/png'] = F['view/th']
+
+  # display just the images found in content
+  fn 'view/imgs',->m,e{
+
+    # height argument
+    h = e.q['h'].do{|h|
+      h.match(/^[0-9]+$/).do{|_|'height:'+h+'px'}}
+
+    # visited images
+    seen={}
+
+    # extension-based filter
+    x=->i{i&&i.match(/(jpe?g|gif|png)$/i)&&i}
+
+    [(H.once e,:mu,H.js('/js/mu')),H.js('/js/images'),
+     m.values.map{|v|
+       # CSS selector-based search
+       [[*v[Content]].map{|c| c.class == String &&
+         (Nokogiri::HTML.parse(c).do{|c|
+            [# <img> elements
+             c.css('img').map{|i|i['src']}.compact,
+             # <a> elements with image extensions
+             c.css('a').map{|i|i['href']}.select(&x)]
+            })},
+        # check subject URI for image extension
+        x.(v.uri),
+        # check object URIs for image extension
+        (v.respond_to?(:values) &&
+         v.values.flatten.map{|v|
+           v.respond_to?(:uri) && v.uri
+         }.select(&x))
+       ].flatten.uniq.compact.map{|s|
+         # view 
+         {uri: s,
+           # img and  link to containing resource
+           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|
+       # show and mark as seen
+       !seen[i[:uri]] &&
+       (seen[i[:uri]] = true
+        i[:c].())}]}
+
+  def E.c; '#%06x' % rand(16777216) end
+  def E.cs; '#%02x%02x%02x' % F['color/hsv2rgb'][rand*6,1,1] end
+
+  fn 'color/hsv2rgb',->h,s,v{
+    i = h.floor
+    f = h - i
+    p = v * (1 - s)
+    q = v * (1 - (s * f))
+    t = v * (1 - (s * (1 - f)))    
+    r,g,b=[[v,t,p],
+           [q,v,p],
+           [p,v,t],
+           [p,q,v],
+           [t,p,v],
+           [v,p,q]][i].map{|q|q*255.0}}
+
+end

data/infod/Es/in.rb

@@ -0,0 +1,68 @@
+#watch __FILE__
+class E
+
+  # Graph -> tripleStream -> Graph
+  def fromStream m,*i
+    send(*i) do |s,p,o|
+      m[s] = {'uri' => s} unless m[s].class == Hash 
+      m[s][p] ||= []
+      m[s][p].push o unless m[s][p].member? o
+    end; m
+  end
+
+  # default proto-graph
+  #   mint graph identifier
+  #   any graph setup (:g variable mutation) is preserved
+  fn 'protograph/',->e,q,g{
+    set = (F['set/' + q['set']] || F['set/'])[e,q,g]
+    set.map{|u| g[u.uri] ||= u if u.class == E } if set.class == Array
+    # unique fingerprint for graph
+    [F['docsID'][g],
+     F['triplr'][e,q],
+     q.has_key?('nocache').do{|_|rand}
+    ].h}
+
+  # default graph
+  #  filesystem storage
+  fn 'graph/',->e,q,m{
+    triplr = F['triplr'][e,q]
+    m.values.map{|r|
+      (r.env e.env).graphFromFile m, triplr if r.class == E }}
+
+  fn 'docsID',->g{
+    g.sort.map{|u,r|
+      [u, r.respond_to?(:m) && r.m]}.h}
+
+  fn 'triplr',->e,q{
+    t = q['triplr']
+    t && e.respond_to?(t) && t || :triplrMIME }
+
+  # document-set
+  fn 'set/',->e,q,_{
+    s = []
+    s.concat e.docs
+    e.pathSegment.do{|p| s.concat p.docs }
+    s }
+
+  def triplrMIME &b
+    mimeP.do{|mime|
+      yield uri,E::Type,(E MIMEtype+mimeP)
+      (MIMEsource[mimeP]||
+       MIMEsource[mimeP.split(/\//)[0]]).do{|s|
+        send *s,&b }}
+  end
+
+  def graphFromFile g={}, triplr=:triplrMIME
+    g.mergeGraph r(true) if ext=='e' # JSON -> graph
+    [:triplrInode,        # filesystem data
+     triplr].# format-specific tripleStream emitter
+      each{|i| fromStream g,i } # tripleStream -> Graph
+    g
+  end
+
+  def graph g={}
+    docs.map{|d|d.graphFromFile g}  # tripleStream -> graph
+    g
+  end
+
+end

data/infod/Es/index.rb

@@ -0,0 +1,183 @@
+#watch __FILE__
+class E
+
+  # POSIX-fs based index of triples
+  # 
+
+  # index a triple 
+  def index p,o
+    p = p.E
+    indexEdit p, (o.class == E ? o : p.literal(o)), nil
+  end
+
+  # index a triple - no input type-normalization
+  def indexEdit p,o,a
+    return if @noIndex
+    p.pIndex.noIndex[o,self,a]
+  end
+  def noIndex
+    @noIndex = 1
+    self
+  end
+
+  # reachable graph along named predicate
+  def walk p, g={}, v={}
+    graph g       # cumulative graph
+    v[uri] = true # visited mark
+
+    rel = g[uri].do{|s|s[p]} ||[]
+    rev = (p.E.po self) ||[]
+
+    rel.concat(rev).map{|r|
+      v[r.uri] || (r.E.walk p,g,v)}
+
+    g
+  end
+
+  # subtree traverse
+  fn 'set/subtree',->d,r,m{
+    c =(r['c'].do{|c|c.to_i + 1} || 3).max(100) # one extra for start of next-page
+    o = r['d'] =~ /^a/ ? :asc : :desc           # direction
+    ('/'.E.take c, o, d.uri).do{|s|             # take subtree
+      desc, asc = o == :desc ?                  # orient pagination hints
+      [s.pop, s[0]] : [s[0], s.pop]
+      m['prev'] = {'uri' => 'prev', 'url' => desc.url,'d' => 'desc'}
+      m['next'] = {'uri' => 'next', 'url' => asc.url, 'd' => 'asc'}
+      s }}
+
+  # subtree traverse index on p+o cursor
+  fn 'set/index',->d,r,m,f=:rangePO{
+    top = (f == :rangeP ? d : r['p']).expand.E
+    count = r['c'] &&
+            r['c'].to_i.max(1000)+1 || 22
+    dir = r['d'] &&
+          r['d'].match(/^(a|de)sc$/) &&
+          r['d'].to_sym ||
+          :desc
+
+    (top.send f, count, dir, r['offset'],(d if f == :rangePO)).do{|s|
+      # pagination pointers
+      a,b = s[0], s.size > 1 && s.pop
+      desc,asc = r['d'] && r['d']=='asc' && [a,b]||[b,a]
+      # insert pointers in response-graph
+      m['prev']={'uri' => 'prev','url' => d.url,'d' => 'desc','offset' => desc.uri} if desc
+      m['next']={'uri' => 'next','url' => d.url,'d' => 'asc', 'offset' => asc.uri}  if asc
+      s }}
+
+  fn 'set/indexP',->d,r,m{Fn 'set/index',d,r,m,:rangeP}
+  F['set/indexPO'] = F['set/index']
+
+  # predicate index
+  def pIndex
+    prependURI '/index/'
+  end
+
+  # predicate-object index
+  def poIndex o
+    pIndex.concatURI o
+  end
+ 
+  # predicate-object index lookup
+  def po o
+    pIndex[o.class == E ? o : literal(o)]
+  end
+
+  # range query - predicate
+  def rangeP n=8,d=:desc,s=nil,o=nil
+    pIndex.subtree(n,d,s).map &:ro
+  end
+
+  # range query - predicate-object
+  def rangePO n=8,d=:desc,s=nil,o
+    poIndex(o).subtree(n,d,s).map &:ro
+  end
+
+  # E -> [node]
+  def subtree *a
+    u.take *a
+  end
+
+  # E -> [E]
+  def take *a
+    no.take(*a).map &:E
+  end
+
+  # random leaf
+  def randomLeaf
+    c.empty? && self || c.r.randomLeaf
+  end
+
+  fn 'set/randomLeaf',->d,e,m{[d.randomLeaf]}
+  fn 'req/randomLeaf',->e,r{[302, {Location: e.randomLeaf.uri},[]]}
+
+
+  # enumerate unique predicates in index
+  fn '/index/GET',->e,r{
+    e.pathSegment.uri.match(/^\/index$/) &&
+   (H [{_: :style, c: "a {font-size:3em;display:block}
+a:hover {background-color:#00f}"},
+       '/index'.E.take.map{|e|e.uri[6..-1].unpath.do{|p|{_: :a, href: '/@'+URI.escape(p.uri)+'?set=indexP&view=page&v=linkPO&c=12', c: p}}}]).hR}
+
+  # p/o index-traversal pointers
+  fn 'view/linkPO',->d,e{
+    p = e['uri']
+    [(H.css '/css/index'),(H.js '/js/search'),{_: :b, c: p},
+     # front-end to search on SIOC predicate+object URIs
+     %w{sioc:has_creator sioc:addressed_to}.member?(p).do{|_|
+       {_: :form, action: '/whois',c: [{_: :input, type: :hidden, name: :p, value: p},{_: :input, name: :q}]}
+     },
+     d.map{|u,r| {c: {_: :a, href: r.url+'?set=indexPO&p=' + (URI.escape p) + '&view=page&views=timegraph,mail&v=multi&c=8', c: u}}}]}
+
+end
+
+
+class Pathname
+
+  # take N els from fs tree in sorted, depth-first order
+  def take count=1000, direction=:desc, offset=nil
+
+    # construct offset-path
+    offset = to_s + offset.gsub(/\/+/,'/').E.path if offset
+
+    # in-range indicator
+    ok = false
+
+    # result set
+    set=[]
+
+    # asc/desc operators
+    v,m={asc:      [:id,:>=],
+        desc: [:reverse,:<=]}[direction]
+
+    # visitation function
+    visit=->nodes{
+      
+      # sort nodes in asc or desc order
+      nodes.sort_by(&:to_s).send(v).each{|n|
+        ns = n.to_s
+        # have we got enough nodes?
+        return if 0 >= count
+
+        # continue if
+        (# already in-range
+         ok ||
+         # no offset specified
+         !offset ||
+         # offset satisfies in-range operator
+         (sz = [ns,offset].map(&:size).min
+          ns[0..sz-1].send(m,offset[0..sz-1]))) && (
+         if !(c = n.c).empty? # has children?
+           visit.(c)          # visit children
+         else
+           count = count - 1 # decrement wanted-nodes count
+           set.push n        # add node to result-set
+           ok = true         # iterator is now within range
+        end )}}
+
+    visit.(c) # start 
+
+    # result set
+    set
+  end
+
+end

data/infod/{W → Es}/json.rb

@@ -1,3 +1,27 @@
+class Hash
+
+  def graph g
+    g.merge!({uri=>self})
+  end
+
+  def mergeGraph g
+    g.values.each{|r|
+      r.triples{|s,p,o|
+        self[s] = {'uri' => s} unless self[s].class == Hash 
+        self[s][p] ||= []
+        self[s][p].push o unless self[s][p].member? o }} if g
+    self
+  end
+
+  # tripleStream emitter
+  def triples
+    s = uri
+    map{|p,o|
+      o.class == Array ? o.each{|o| yield s,p,o} : yield(s,p,o) unless p=='uri'}
+  end
+
+end
+
 class E
 
   def triplrJSON
@@ -5,7 +29,7 @@ class E
   end
 
 
-  # addJSON :: tripleStream -> JSON graph (fs)
+  # tripleStream -> fs
   def addJSON i,g,p=[]
     fromStream({},i).map{|u,r| # stream -> graph
       (E u).do{|e| # resource
@@ -14,13 +38,13 @@ class E
         (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
+         # link opaque-URI docs as siblings of base-URI for doc-discoverability
          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
+  rescue Exception => e
+    puts "addJSON #{e}"
   end
 
   fn 'view/application/json',->m,e{

data/infod/Es/kv.rb

@@ -0,0 +1,60 @@
+#watch __FILE__
+class E
+
+  def []= p,o
+    self[p,o]
+  end
+
+  def [] p,o=nil, v=nil
+    if o # set
+      editFs p,o,v
+    else # get
+      (concatURI p).properties
+    end
+  end
+
+  def editFs p, o, oO=nil
+    p = p.E
+    o = p.literal o unless o.class == E
+    t = (concatURI p).concatURI o
+    if oO                # updated triple
+      if t.e             # old triple exists?
+        t.deleteNode     # remove triple
+        indexEdit p,o,'' # unindex
+      end
+      self[p,oO] unless oO.empty? # add triple
+    else
+      unless t.e          # triple exists?
+        indexEdit p,o,nil # index triple
+        if o.f            # add triple
+          # link resource
+#          puts "link #{o} #{t}"
+          o.ln t
+        elsif o.e
+          # symlink resource
+#          puts "symlink #{o} #{t}"
+          o.ln_s t
+        else
+          # name resource
+          puts "origin missing #{t} , adding URI ref"
+          t.mk
+        end
+      end
+    end
+  end
+
+  def triplrFsStore
+    properties.map{|p|
+      self[p].map{|o|
+        yield uri, p.uri, o}}
+  end
+
+  def deletePredicate p
+    self[p].each{|o|self[p,o,'']}
+  end
+
+  def properties
+    subtree.map &:ro
+   end
+
+end