infod 0.0.3.2 → 0.0.3.3

data/infod/facets.rb

@@ -1,5 +1,5 @@
 #watch __FILE__
-class E
+class R
 =begin
    faceted-filter, implemented via dynamically-generated style-sheets
 
@@ -58,11 +58,11 @@ class E
   
   fn 'view/facetSelect',->m,e{
     [(H.js '/js/facets.select'),(H.js '/js/mu'),(H.css '/css/facets'),
-     E.graphProperties(m).map{|e|[{c: e},' ']},
+     R.graphProperties(m).map{|e|[{c: e},' ']},
      {_: 'button', c: 'Go'}]}
 
   fn 'view/facets',->m,e{
-    e.q['a'].do{|a|Fn 'facets',a,m,e} ||
-                  (Fn 'view/facetSelect',m,e)}
+    e.q['a'].do{|a|F['facets'][a,m,e]} ||
+    F['view/facetSelect'][m,e]}
 
 end

data/infod/feed.rb

@@ -34,20 +34,20 @@ module FeedParse
           puts "no HTTP URIs found #{u}"
           u = '/junk/'+u.gsub('/','.')
         end
-        yield u, E::Type, (E::SIOCt+'BlogPost').E
-        yield u, E::Type, (E::SIOC+'Post').E
+        yield u, R::Type, (R::SIOCt+'BlogPost').R
+        yield u, R::Type, (R::SIOC+'Post').R
         
         #links
         inner.scan(%r{<(link|enclosure|media)([^>]+)>}mi){|e|
           e[1].match(/(href|url|src)=['"]?([^'">\s]+)/).do{|url|
-            yield(u,E::Atom+'/link/'+((r=e[1].match(/rel=['"]?([^'">\s]+)/)) ? r[1] : e[0]), url[2].E)}}
-        
+            yield(u,R::Atom+'/link/'+((r=e[1].match(/rel=['"]?([^'">\s]+)/)) ? r[1] : e[0]), url[2].R)}}
+
         #elements
         inner.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
+          (x[e[0]&&e[0].chop]||R::RSS)+e[1], # p
           e[3].extend(FeedParse).guess.do{|o|# o
-            o.match(/\A(\/|http)[\S]+\Z/) ? o.E : E::F['cleanHTML'][o]
+            o.match(/\A(\/|http)[\S]+\Z/) ? o.R : R::F['cleanHTML'][o]
           }}
       else
         puts "no post-identifiers found #{u}"
@@ -58,19 +58,19 @@ module FeedParse
   end
 end
 
-class E
+class R
 
   Atom = W3+'2005/Atom'
    RSS = Purl+'rss/1.0/'
   RSSm = RSS+'modules/'
-  Feed = (E RSS+'channel')
+  Feed = (R RSS+'channel')
 
-  def listFeeds; (nokogiri.css 'link[rel=alternate]').map{|u|E (URI uri).merge(u.attr :href)} end
+  def listFeeds; (nokogiri.css 'link[rel=alternate]').map{|u|R (URI uri).merge(u.attr :href)} end
   alias_method :feeds, :listFeeds
 
   # add existing resources to index
   #
-  # 'http:/'.E.take.select{|e|e.ext=='e'}.map{|r|E::FeedArchiver[r,r.graph,'localhost']}
+  # 'http:/'.R.take.select{|e|e.ext=='e'}.map{|r|R::FeedArchiver[r,r.graph,'localhost']}
 
   FeedArchiver = -> doc, graph, host {
     doc.roonga host
@@ -79,7 +79,7 @@ class E
         t = t[0].gsub(/[-T]/,'/').sub /(.00.00|Z)$/, '' # trim normalized timezones and non-unique symbols
         stop = /\b(at|blog|com(ments)?|html|info|org|photo|p|post|r|status|tag|twitter|wordpress|www|1999|2005)\b/
         b = (u.sub(/http:\/\//,'.').gsub(/\W/,'..').gsub(stop,'').sub(/\d{12,}/,'')+'.').gsub /\.+/,'.'
-        doc.ln E["http://#{host}/news/#{t}#{b}e"]}}
+        doc.ln R["http://#{host}/news/#{t}#{b}e"]}}
   doc}
 
   GREP_DIRS.push /^\/news\/\d{4}/
@@ -97,7 +97,7 @@ class E
       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,Type,(SIOCt+'BoardPost').E
+        yield s,Type,(SIOCt+'BoardPost').R
       } : (yield s,p,o)}
   end
 

data/infod/forum.rb

@@ -1,4 +1,4 @@
-class E
+class R
 
 =begin
 

data/infod/fs.rb

@@ -1,119 +1,83 @@
 #watch __FILE__
+class R
 
-%w{date digest/sha1 fileutils json open-uri pathname}.each{|r|require(r)}
-
-class E
-
-  def d
-    node.to_s
-  end
-
-  def node
-    Pathname.new FSbase + path
-  end
-  alias_method :no, :node
-
-  def inside
-    node.expand_path.to_s.index(FSbase) == 0
-  end
-
-  def siblings
-    parent.c
-  end
-
-  def children
-    node.c.map &:E
-  end
-  alias_method :c, :children
-
-
-  # node exists?
-  def exist?
-    node.exist?
-  end
-  alias_method :e, :exist?
-
-  # directory?
-  def d?
-    node.directory?
+  def [] p; predicate p end
+  def []= p,o
+    if o
+      setFs p,o
+    else
+      (predicate p).map{|o|
+        unsetFs p,o}
+    end
   end
 
-  # file?
-  def file?
-    node.file?
+  def predicate p, short = true
+    p = predicatePath p, short
+    p.node.take.map{|n|
+      if n.file? # literal
+        o = n.R
+        case o.ext
+        when "json"
+          o.r true
+        else
+          o.r
+        end
+      else # resource
+       R[n.to_s.unpath p.d.size]
+      end}
+  end
+
+  def setFs p, o, undo = false, short = true
+    p = predicatePath p, short # s+p URI
+    t,literal = p.objectPath o # s+p+o URI
+    puts "#{undo ? :- : :+} <#{t}>"
+    if o.class == R # resource
+      if undo
+        t.delete if t.e # undo
+      else
+        unless t.e
+          if o.f    # file?
+            o.ln t  # link
+          else
+            t.mk    # dirent
+          end
+        end
+      end
+    else # literal
+      if undo
+        t.delete if t.e  # remove 
+      else
+        t.w literal unless t.e # write
+      end
+    end
   end
-  alias_method :f, :file?
 
-  # modification time
-  def mtime
-    node.stat.mtime if e
-  end
-  alias_method :m, :mtime
+  def unsetFs p,o; setFs p,o,true end
 
   def triplrInode
     if d?
       yield uri, Posix+'dir#parent', parent
-      c.map{|c| yield uri, Posix + 'dir#child', E[c.uri.gsub('?','%3F').gsub('#','23')]}
+      c.map{|c| yield uri, Posix + 'dir#child', R[c.uri.gsub('?','%3F').gsub('#','23')]}
     end
     node.stat.do{|s|[:size,:ftype,:mtime].map{|p| yield uri, Stat+p.to_s, (s.send p)}}
   end
   
   def triplrSymlink
     realpath.do{|t|
-      target = t.to_s.index(FSbase)==0 ? t.E : t.to_s
+      target = t.to_s.index(FSbase)==0 ? t.R : t.to_s
       yield uri, '/linkTarget', target }
   end
-  
-  def realpath
-    node.realpath
-  rescue Errno::ENOENT
-    nil
-  end
-
-  def mk
-    e || FileUtils.mkdir_p(d)
-    self
-  end
 
-  # create link
-  def ln t
-    t = t.E # cast bare URI/string to resource
+  def ln t, y=:link
+    t = t.R
+    t = t.uri[0..-2].R if t.uri[-1] == '/'
     if !t.e # destination exist?
       t.dirname.mk
-      FileUtils.link node, t.node
+      FileUtils.send y, node, t.node
     end
   end
 
-  # create symlink
-  def ln_s t
-    t = t.E # cast bare URI/string to resource
-    if !t.e # destination exist?
-      t.dirname.mk
-      FileUtils.symlink node, t.node
-    end
-  end
-
-  def touch
-    FileUtils.touch node
-    self
-  end
-    
-  def deleteNode
-    node.deleteNode if e
-    self
-  end
-
-  def size
-    node.size
-  end
-
-  def read
-    f ? r : get
-  end
-
-  def get
-    (open uri).read
-  end
+  def ln_s t; ln t, :symlink end
 
   def r p=false
     if f
@@ -131,21 +95,11 @@ class E
     self
   end
 
-  def writeFile c
-    File.open(d,'w'){|f|f << c}
-  end
-
-  def readFile
-    File.open(d).read
-  end
-
 end
 
 class Pathname
 
-  def E
-    to_s.force_encoding('UTF-8').unpathFs
-  end
+  def R; to_s.force_encoding('UTF-8').unpath end
 
   def c
     return [] unless directory?
@@ -160,9 +114,3 @@ class Pathname
   end
 
 end
-
-class File::Stat
-  def utime
-    mtime.to_i
-  end
-end

data/infod/graph.rb

@@ -1,15 +1,15 @@
 #watch __FILE__
-class E
+class R
 =begin
   graph construction is two-pass:
 
- the first-pass will signify if the second-pass needs to be run. an eTag is be derived from the return-value, ideal fingerprint sources include filestats, mtime checks, extremely trivial SPARQL queries, SHA160 hashes of in-RAM entities.. <http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-25#section-2.3>
+ the first-pass will signify if the second-pass needs to be run. an ETag is be derived from the return-value, ideal fingerprint sources include filestats, mtime checks, extremely trivial SPARQL queries, SHA160 hashes of in-RAM entities.. <http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-25#section-2.3>
 
-   second-pass might fetch RDF from a SPARQL store. this lib was developed as an alternative to relying on (large, hard-to-implement, must be running, configured & connectable) SPARQL stores by using the filesystem as much as possible, to experiment with hybrids like SPARQLING up a set of files to be returned in standard Apache-as-static-fileserver fashion, and to webize all sorts of non-RDF like email, directories, plain-text etc
+   second-pass might fetch RDF from a SPARQL store. this lib was developed as an alternative to relying on (large, hard-to-implement, must be running, configured & connectable) SPARQL stores by using the filesystem as much as possible, to experiment with hybrids like SPARQLING up a set of files to be returned in standard Apache-as-static-fileserver fashion, and to webize non-RDF filesystem-content like email, directories, URLs in plain-text etc
 
   triple streams - a source function yields triples up to the caller as it finds them,
-  a function providing just a block (consume yielded values) is a sink, both is a filter 
-  these can be stacked into pipelines. see the data-massaging stream-processors in feed.rb
+  a function providing a block (consumes yielded values) is a sink, both is a filter 
+  these can be stacked into pipelines. see the data-massaging stream-processing in feed.rb
 
 =end
 
@@ -31,7 +31,7 @@ class E
     graph = fromStream({},triplr)
     docs = {}
     graph.map{|u,r|
-      e = u.E                 # resource
+      e = u.R                 # resource
       doc = e.ef              # doc
       doc.e ||                # exists - we're nondestructive here
       (docs[doc.uri] ||= {}   # init doc-graph
@@ -40,7 +40,7 @@ class E
          r[p].do{|v|v.map{|o| # values exist?
              e.index p,o}}})} # index triple
     docs.map{|d,g|            # resources in docs
-      d = d.E; puts "+doc #{d}"
+      d = d.R; puts "<#{d.docBase}>"
       d.w g,true              # write
       hook[d,g,host] if hook} # insert-hook
     graph.triples &b if b     # emit triples
@@ -56,7 +56,7 @@ class E
       g.delete '#'
     else
       g['#'][RDFs+'member'] = set
-      g['#'][Type] = E[HTTP+'Response']
+      g['#'][Type] = R[HTTP+'Response']
       set.map{|u| g[u.uri] = u } # thunk
     end
     F['docsID'][g,q]}
@@ -71,8 +71,8 @@ class E
       t = ::Date.parse "#{m[2]}-#{m[3]}-#{m[4]}"
       pp = m[1] + (t-1).strftime('%Y/%m/%d') + m[5]
       np = m[1] + (t+1).strftime('%Y/%m/%d') + m[5]
-      u[Prev] = {'uri' => pp} if pp.E.e || E['http://' + e.env['SERVER_NAME'] + pp].e
-      u[Next] = {'uri' => np} if np.E.e || E['http://' + e.env['SERVER_NAME'] + np].e }
+      u[Prev] = {'uri' => pp} if pp.R.e || R['http://' + e.env['SERVER_NAME'] + pp].e
+      u[Next] = {'uri' => np} if np.R.e || R['http://' + e.env['SERVER_NAME'] + np].e }
     s }
 
   # fs-derived ID for a resource-set
@@ -86,30 +86,44 @@ class E
   # update configuration such as q['graph'] = 'hexastore' and return false or call #response..
   fn 'graph/',->e,q,m{
     # force thunks
-    m.values.map{|r|(r.env e.env).graphFromFile m if r.class == E }
+    m.values.map{|r|(r.env e.env).graphFromFile m if r.class == R }
     # cleanup unexpanded thunks
-    m.delete_if{|u,r|r.class==E}}
+    m.delete_if{|u,r|r.class==R}}
 
   def graphFromFile g={}
     return unless e
     doc = self
     unless ext=='e' # already native-format
-      triplr = @r.do{|r|r.q['triplr'].do{|t| (respond_to? t) && t }} || :triplrMIME
-      doc = E '/E/rdf/' + [triplr,uri].h.dive
-      unless doc.e && doc.m > m; # freshness check
+      doc = R '/cache/RDF/' + uri.h.dive
+      unless doc.e && doc.m > m # up-to-date?
         graph = {}
-        [:triplrInode,triplr].each{|t| fromStream graph, t }
+        [:triplrInode,:triplrMIME].map{|t| fromStream graph, t}
         doc.w graph, true
       end
     end
     g.mergeGraph doc.r true
   end
 
+  def ef;  @ef ||= docBase.a('.e') end
+
   def graph g={}
     docs.map{|d|d.graphFromFile g}  # tripleStream -> graph
     g
   end
 
+  def docs
+    base = docBase
+    [(base if pathSegment!='/' && base.e),         # doc-base
+     (self if base != self && e && uri[-1]!='/'),  # requested path
+     base.glob(".{e,html,n3,nt,owl,rdf,ttl,txt}"), # docs
+     ((d? && uri[-1]=='/' && uri.size>1) ? c : []) # trailing slash -> child resources
+    ].flatten.compact
+  end
+
+  def triplrDoc &f; docBase.glob('#*').map{|s| s.triplrResource &f} end
+
+  def triplrResource; predicates.map{|p| self[p].map{|o| yield uri, p.uri, o}} end
+
   def triplrJSON
     yield uri, '/application/json', (JSON.parse read) if e
   rescue Exception => e
@@ -119,12 +133,18 @@ class E
     to_h.to_json *a
   end
 
-  fn Render+'application/json',->d,_=nil{[d].to_json}
+  fn Render+'application/json',->d,_=nil{d.to_json}
 
 end
 
 class Hash
 
+  def except *ks
+    clone.do{|h|
+      ks.map{|k|h.delete k}
+      h}
+  end
+
   def graph g
     g.merge!({uri=>self})
   end

data/infod/grep.rb

@@ -1,16 +1,16 @@
 #watch __FILE__
-class E
+class R
 
   fn 'view/'+Posix+'util#grep',-> d,e {{_: :form, c: [{_: :input, name: :q, style: 'font-size:2em'},{_: :input, type: :hidden, name: :set, value: :grep}]}}
 
   GREP_DIRS=[]
 
   fn 'set/grep',->e,q,m{
-    q['q'].do{|query| m[e.uri+'#grep'] = {Type => E[Posix+'util#grep']}
+    q['q'].do{|query| m[e.uri+'#grep'] = {Type => R[Posix+'util#grep']}
       path = e.pathSegment
       GREP_DIRS.find{|p|path.uri.match p}.do{|allow|
         [e,path].compact.select(&:e).map{|e|
-          `grep -irl #{query.sh} #{e.sh} | head -n 200`}.map{|r|r.lines.to_a.map{|r|r.chomp.unpathFs}}.flatten
+          `grep -irl #{query.sh} #{e.sh} | head -n 200`}.map{|r|r.lines.to_a.map{|r|r.chomp.unpath}}.flatten
       }||(puts "no grep available on #{path}")}}
 
   fn 'view/grep',->d,e{
@@ -52,7 +52,7 @@ class E
          # match?
          !g.empty? &&                                       
          [# link to resource
-          r.E.do{|e|{_: :a, href: e.url, c: e}}, '<br>',
+          r.R.do{|e|{_: :a, href: e.url, c: e}}, '<br>',
           # show 3 matches per resource
           [g[-1*(g.size.max 3)..-1].map{|l|   
              # exerpt