infod 0.0.2 → 0.0.3.0

data/infod/{Es/image.rb → image.rb}

@@ -2,20 +2,9 @@
 class E
 
   def triplrImage &f
+    yield uri,Type,E[DC+'Image']
     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)
@@ -38,17 +27,15 @@ class E
     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.values.select{|v|v.class==Hash}.map{|i|
+       i[Type] && (i[Type].class==Array ? i[Type] : [i[Type]]).map{|t|t.respond_to?(:uri) && t.uri}.include?(DC+'Image') &&
+       [{_: :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',
+    i.map{|u,i| u && u.match(/(gif|jpe?g|png|tiff)$/i) &&
+      {_: :a, href: i.url+'?view=img',
         c: {_: :img, src: i.url+'?y=scaleImage&px=233'}}}}
 
   F['view/'+MIMEtype+'image/gif'] = F['view/th']
@@ -56,40 +43,43 @@ class E
   F['view/'+MIMEtype+'image/png'] = F['view/th']
 
   # display just the images found in content
-  fn 'view/imgs',->m,e{
+  fn 'view/imgs',->m, e { seen = {}
 
-    # height argument
+    # optional height argument
     h = e.q['h'].do{|h|
-      h.match(/^[0-9]+$/).do{|_|'height:'+h+'px'}}
-
-    # visited images
-    seen={}
+      h.match(/^[0-9]+$/).do{|_|'height:'+h+'px'}}||''
 
     # 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
+       # CSS-selector search inside content
        [[*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

data/infod/{Es/index.rb → index.rb}

@@ -1,18 +1,19 @@
-#watch __FILE__
+watch __FILE__
 class E
 
   # POSIX-fs based index of triples
   # 
 
-  # index a triple 
+  # 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
+  # index a triple - no type-normalization
   def indexEdit p,o,a
     return if @noIndex
+#    puts "index #{p} #{o} #{a}"
     p.pIndex.noIndex[o,self,a]
   end
   def noIndex
@@ -22,6 +23,7 @@ class E
 
   # reachable graph along named predicate
   def walk p, g={}, v={}
+#    puts "walk #{uri}"
     graph g       # cumulative graph
     v[uri] = true # visited mark
 
@@ -38,38 +40,47 @@ class E
   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'}
+      u = m['#']
+      u[Type] = E[HTTP+'Response']
+      u[Prev] = {'uri' => desc.url + {'d' => 'desc'}.qs} if desc
+      u[Next] = {'uri' => asc.url  + {'d' => 'asc'}.qs} if 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
+  fn 'set/index',->d,r,m{
+    top = 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 }}
+            r['c'].to_i.max(1000) || 8
+    dir = r['d'] && r['d'].match(/^(a|de)sc$/) &&
+          r['d'].to_sym || :desc
+
+    (top.rangePO count+1, dir, r['offset'], r['o']).do{|s|
+      # orient pagination pointers
+      ascending = r['d'].do{|d| d == 'asc' }
+      first, last = s[0], s.size > 1 && s.pop
+      desc, asc = ascending && [first,last] || [last,first]
+      # response description
+      u = m['#']
+      u[RDFs+'member'] = s
+      u[Prev] = {'uri' => '/index/' + r['p'] + '/' + CGI.escape(r['o']) + {'offset' => desc.uri, 'c' => count}.qs } if desc
+      u[Next] = {'uri' => '/index/' + r['p'] + '/' + CGI.escape(r['o']) + {'offset' => asc.uri, 'c' => count}.qs } if asc
+
+      s.map(&:docs).flatten.uniq }}
 
-  fn 'set/indexP',->d,r,m{Fn 'set/index',d,r,m,:rangeP}
-  F['set/indexPO'] = F['set/index']
+  fn '/index/GET',->e,r{
+    a = e.pathSegment.uri[7..-1].split '/',2
+    r.q['set'] = 'index'
+    r.q['p'] = a[0]
+    r.q['o'] = CGI.unescape a[1]
+    e.response}
 
   # predicate index
   def pIndex
-    prependURI '/index/'
+    shorten.prependURI '/index/'
   end
 
   # predicate-object index
@@ -83,8 +94,8 @@ class E
   end
 
   # range query - predicate
-  def rangeP n=8,d=:desc,s=nil,o=nil
-    pIndex.subtree(n,d,s).map &:ro
+  def rangeP size=8, dir=:desc, offset=nil, object=nil
+    pIndex.subtree(size,dir,offset).map &:ro
   end
 
   # range query - predicate-object
@@ -102,32 +113,17 @@ class E
     no.take(*a).map &:E
   end
 
-  # random leaf
   def randomLeaf
     c.empty? && self || c.r.randomLeaf
   end
 
+  def E.graphProperties g
+    g.values.select{|v|v.respond_to? :keys}.map(&:keys).flatten.uniq
+  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
 
 
@@ -137,7 +133,7 @@ class Pathname
   def take count=1000, direction=:desc, offset=nil
 
     # construct offset-path
-    offset = to_s + offset.gsub(/\/+/,'/').E.path if offset
+    offset = (to_s + offset).gsub(/\/+/,'/').E.path if offset
 
     # in-range indicator
     ok = false
@@ -151,7 +147,7 @@ class Pathname
 
     # visitation function
     visit=->nodes{
-      
+
       # sort nodes in asc or desc order
       nodes.sort_by(&:to_s).send(v).each{|n|
         ns = n.to_s
@@ -174,8 +170,7 @@ class Pathname
            ok = true         # iterator is now within range
         end )}}
 
-    visit.(c) # start 
-
+    visit.(c) # start
     # result set
     set
   end

data/infod/infod.rb

@@ -1,12 +1,51 @@
-
-# the table of elements
-
-# Es infrastructure
-# H  HTML
-# K  constants
-# N  naming
-# Rb Ruby native-types
-# Th HTTP
-# Y  lambdas
-
-%w{Y K Rb N Es H Th}.map{|e| require 'infod/' + e}
+%w{
+constants
+lambda
+mime
+404
+500
+audio
+blog
+cal
+code
+css
+csv
+du
+edit
+facets
+feed
+find
+forum
+fs
+GET
+glob
+graph
+grep
+groonga
+HEAD
+histogram
+html
+HTTP
+image
+index
+json
+kv
+ls
+mail
+man
+microblog
+names
+page
+PATCH
+POST
+postscript
+rdf
+ruby
+schema
+search
+sh
+text
+threads
+time
+wiki
+}.map{|e|require_relative e}

data/infod/json.rb

@@ -0,0 +1,38 @@
+class Hash
+
+  def graph g
+    g.merge!({uri=>self})
+  end
+
+  def mergeGraph g
+    g.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
+
+  # self -> tripleStream
+  def triples &f
+    map{|s,r|
+      r.map{|p,o|
+        o.class == Array ? o.each{|o| yield s,p,o} : yield(s,p,o) unless p=='uri'} if r.class == Hash
+    }
+  end
+
+end
+
+class E
+
+  def triplrJSON
+    yield uri, '/application/json', (JSON.parse read) if e
+  rescue Exception => e
+  end
+
+  def to_json *a
+    to_h.to_json *a
+  end
+
+  fn Render+'application/json',->d,_=nil{[d].to_json}
+
+end

data/infod/{Es/kv.rb → kv.rb}

@@ -27,17 +27,11 @@ class E
       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
+          o.ln t          # hard link
         elsif o.e
-          # symlink resource
-#          puts "symlink #{o} #{t}"
-          o.ln_s t
+          o.ln_s t        # symbolic link
         else
-          # name resource
-          puts "origin missing #{t} , adding URI ref"
-          t.mk
+          t.mk            # dir entry
         end
       end
     end

data/infod/{Y.rb → lambda.rb}

@@ -5,6 +5,20 @@ def watch f
 
 class E
 
+  def initialize uri
+    @uri = uri.to_s
+  end
+
+  def E arg=nil
+    if arg
+      E.new arg
+    else
+      self
+    end
+  end
+
+  def E.[] u; u.E end
+
   F={}
   Watch={}
 
@@ -29,6 +43,9 @@ def fn u,y
 end
 
 def Fn a,*g
-  puts "missing #{a} from #{caller[0]}" unless E::F[a]
   E::F[a][*g]
 end
+
+def E e
+  E.new e
+end

data/infod/ls.rb

@@ -0,0 +1,49 @@
+#watch __FILE__
+class E
+
+  fn 'view/dir',->i,e{
+    a = -> i { i = i.E
+      {_: :a, href: i.localURL(e), c: i.uri.match(/(gif|jpe?g|png)$/i) ? {_: :img, src: i.uri+'?y=scaleImage&px=233'} : i.uri.sub(/.*\//,'')}}
+
+    [(H.once e, 'dir', (H.css '/css/ls')),
+     i.map{|u,r|
+       url = r.E.localURL e
+       {class: :dir, style: "background-color: #{E.cs}",    # dir wrapper
+         c: [{c: [{_: :a, href: url.t + '?view=ls', c: r.uri.sub('http://'+e['SERVER_NAME'],'')},
+                  {_: :a, href: url.t, c: '/'}]},
+             r[Posix+'dir#child'].do{|c|c.map{|c|a[c]}}]}}]}
+
+  F['view/'+MIMEtype+'inode/directory'] = F['view/dir']
+
+  fn 'view/ls',->i,e{
+    dir = e['uri'].E
+    path = dir.pathSegment
+    up = (!path || path.uri == '/') ? '/' : dir.parent.url
+    i = i.dup
+    i.delete_if{|u,r|!r[Stat+'ftype']}
+    f = {}
+    ['uri', Posix+'dir#child', Stat+'ftype', Stat+'mtime', Stat+'size'].map{|p|f[p] = true}
+    i.values.map{|r|
+      r.class==Hash &&
+      r.delete_if{|p,o|!f[p]}}
+    [(H.css '/css/ls'),
+     {_: :a, class: :up, href: up+'?view=ls', c: '↑'},
+     {class: :ls, c: (Fn 'view/table',i,e)},'<br clear=all>',
+     {_: :a, class: :down, href: e['uri'].E.url.t, c: '&darr;'}]}
+  
+  # user-patchable default-handler
+  fn '/GET',->e,r{
+    x = 'index.html'
+    i = [e,e.pathSegment].compact.map{|e|e.as x}.find &:e
+    if i
+      if e.uri[-1] == '/' # inside dir?
+        i.env(r).getFile  # show index
+      else                # descend to indexed dir
+        [301, {Location: e.uri.t}, []]
+      end
+    else
+      # default handler
+      e.response
+    end}
+
+end