infod 0.0.1 → 0.0.2

data/infod/H/who.rb

@@ -0,0 +1,30 @@
+#watch __FILE__
+class E
+
+  fn '/whois/GET',->e,r{
+    [302,{Location: '/' + ( r.q['p'].match(/to$/) ? 'to' : 'from' ) + '/' + (URI.escape r.q['q'])},[]]
+  }
+
+  fn '/to/GET',->e,r{
+    name = e.pathSegment.uri.sub('/to/','/').tail
+    if !name || name.empty?
+      false
+    else
+      H({style: 'text-align: center',
+          c: [To.E.rangeP.map(&:uri).grep(/#{name}/).map{|n|
+                {_: :a,href: n.E.url+'?set=indexPO&p=sioc:addressed_to&view=page&v', c: n}},
+              {_: :style, c: "a {display:block;text-decoration:none}"}]}).hR
+    end}
+
+  fn '/from/GET',->e,r{
+    name = e.pathSegment.uri.sub('/from/','/').tail
+    if !name || name.empty?
+      false
+    else
+      H({style: 'text-align: center',
+          c: [Creator.E.rangeP(1e4).map(&:uri).grep(/#{name}/).map{|n|
+                {_: :a,href: n.E.url+'?set=indexPO&p=sioc:has_creator&view=page&v', c: n}},
+              {_: :style, c: "a {display:block;text-decoration:none}"}]}).hR
+    end}
+  
+end

data/infod/K.rb

@@ -1,10 +1,10 @@
+#watch __FILE__
 class E
 
-  FSbase   = `pwd`.chomp
-  Prefix   = '/@' # resolver for non-local and non-HTTP URIs
-  S        = '<>' # path separator
+  FSbase = `pwd`.chomp ;  BaseLen = FSbase.size
+  Prefix = '/@'  # non-HTTP URI path resolution-prefix
+  S      = /\._/ # data path-separator
 
-  # frequently-used URIs
   W3    = 'http://www.w3.org/'
   Purl  = 'http://purl.org/'
   FOAF  = "http://xmlns.com/foaf/0.1/"
@@ -22,13 +22,17 @@ class E
   Type     = W3   + "1999/02/22-rdf-syntax-ns#type"
   RDFs     = W3   + '2000/01/rdf-schema#'
   HTTP     = W3   + '2011/http#'
+  Header   = W3   + '2011/http-headers#'
   Posix    = W3   + 'ns/posix/'
   Stat     = Posix + 'stat#'
   Label    = RDFs + 'label'
   EXIF     = 'http://www.w3.org/2003/12/exif/ns#'
   Audio    = 'http://www.semanticdesktop.org/ontologies/nid3/#'
+  Edit     = 'http://buzzword.org.uk/rdf/personal-link-types#edit'
+  Render = 'render/'
+  Apache = ENV['apache']
+  Nginx  = ENV['nginx']
 
-  # file-name extension -> MIME type
   MIME={
     aif: 'audio/aif',
     ans: 'text/ansi',
@@ -58,12 +62,13 @@ class E
     mp3: 'audio/mpeg',
     mp4: 'video/mp4',
     mpg: 'video/mpg',
-    n3: 'text/rdf+n3',
+    n3: 'text/n3',
     nfo: 'text/nfo',
     nt:  'text/ntriples',
     ntriples:  'text/ntriples',
     owl: 'application/rdf+xml',
     pdf: 'application/pdf',
+    pl:  'application/perl',
     png: 'image/png',
     py:  'application/python',
     rb:  'application/ruby',
@@ -76,17 +81,20 @@ class E
     ttl: 'text/turtle',
     txt: 'text/plain',
     u: 'application/uri',
+    url: 'text/plain',
     wav: 'audio/wav',
     wmv: 'video/wmv',
     xlsx: 'application/excel',
   }
 
-  # MIME type -> triplrFn
+  VideoFile = /(avi|flv|mkv|mpg|mp4|wmv)$/i
+  AudioFile = /(aif|wav|flac|mp3|m4a|aac|ogg)$/i
+
   MIMEsource={
     'application/atom+xml' => [:triplrFeed],
     'application/markdown' => [:triplrMarkdown],
     'application/org'      => [:triplrOrg],
-    'application/rdf+xml'  => [:triplrRDFformats,:rdfxml],
+    'application/rdf+xml'  => [:triplrRDF,:rdfxml],
     'application/json'     => [:triplrJSON],
     'application/pdf'      => [:triplrPDF],
     'application/textile'  => [:triplrTextile],
@@ -95,51 +103,44 @@ class E
     'audio/mp4'            => [:triplrStdOut,'faad -i',Audio],
     'audio/mpeg'           => [:triplrStdOut,'id3info',Audio,/\((.*?)\)$/],
     'audio'                => [:triplrStdOut,'sndfile-info',Audio],
-    'image'                => [:triplrStdOut,'exiftool',EXIF],
+    'inode/symlink'        => [:triplrSymlink],
     'message/rfc822'       => [:triplrMail],
     'text/ansi'            => [:triplrANSI],
     'text/comma-separated-values'=>[:triplrCSV,/,/],
-    'text/html'            => [:triplrRDFformats, :rdfa],
-    'text/log'             => [:triplrLog],
+    'text/log'             => [:triplrIRC],
+    'text/man'             => [:triplrMan],
     'text/nfo'             => [:triplrHref,'cp437'],
-    'text/ntriples'        => [:triplrRDFformats, :ntriples],
+    'text/ntriples'        => [:triplrRDF, :ntriples],
     'text/plain'           => [:triplrHref],
     'text/rtf'             => [:triplrRTF],
     'text/semicolon-separated-values'=>[:triplrCSV,/;/],
     'text/tab-separated-values'=>[:triplrCSV,/\t/],
-    'text/turtle'          => [:triplrRDFformats,:turtle],
+    'text/turtle'          => [:triplrRDF,:turtle],
   }
 
-  # MIME type -> formatted content
-     Render='render/'
-  fn Render+'application/ld+json',->d,_=nil{E.renderRDF d, :jsonld}
-  fn Render+'application/rdf+xml',->d,_=nil{E.renderRDF d, :rdfxml}
-  fn Render+'text/ntriples',->d,_=nil{E.renderRDF d, :ntriples}
-  fn Render+'text/turtle',  ->d,_=nil{E.renderRDF d, :turtle}
-  fn Render+'text/rdf+n3',  ->d,_=nil{E.renderRDF d, :n3}
-  fn Render+'text/n3',      ->d,_=nil{E.renderRDF d, :n3}
-
-  # render a view even if requested file exists
+  # prefer a view even if requested file exists
   MIMEcook={
     'application/atom+xml' => true,
     'application/markdown' => true,
-    'application/json' => true,
     'application/json+rdf' => true,
     'application/org' => true,
     'application/textile' => true,
+    'application/uri' => true,
     'application/word' => true,
+    'inode/symlink' => true,
     'message/rfc822'=> true,
     'text/ansi'=>true,
     'text/log'=>true,
+    'text/man'=>true,
     'text/nfo'=>true,
     'text/rtf'=>true,
   }
-  %w{c ruby haskell php python}.map{|t|
+
+  %w{c c++ fortran haskell makefile pascal perl php python ruby}.map{|t|
     %w{application/ text/x-}.map{|m|
       MIMEcook[m+t] = true
   }}
 
-  # short -> full URI
   Abbrev={
     "dc" => DC,
     "foaf" => FOAF,
@@ -149,7 +150,7 @@ class E
     "stat" => Stat,
   }
   
-  # expose these literals as a path-name 
+  # literal to pathname types
   Literal={}
    [Purl+'dc/elements/1.1/date',
     Date,
@@ -157,41 +158,8 @@ class E
     Modified,
    ].map{|f|Literal[f]=true}
 
-  def mime
-    @mime ||= (# dereferenced symlink
-               f = readlink
-
-               # filename extension
-               x = f.ext.downcase.to_sym
-
-               # directory?
-               if d?
-                 "inode/directory"
-               # local MIME-types table
-               elsif MIME[x]
-#                 puts "found mime for #{x} -> #{MIME[x]}"
-                 MIME[x]
-               # Rack MIME-types table
-               elsif Rack::Mime::MIME_TYPES[t = '.' + x.to_s]
-                 Rack::Mime::MIME_TYPES[t]
-               # procmail uses a prefix not an extension
-               elsif f.base.index('msg.')==0
-                 "message/rfc822"
-               # ask FILE(1)
-               elsif f.e
-                 `file --mime-type -b #{f.sh}`.chomp
-               # default
-               else
-                 "application/octet-stream"
-               end)
-  end
-
   def == u
       to_s == u.to_s
   end
 
-  Nginx = ENV['nginx']
-  Apache = ENV['apache']
-  Version = 'http://web.whats-your.name/www/'
-
 end

data/infod/N.rb

@@ -1,39 +1,49 @@
 %w{base64 cgi shellwords}.each{|r|require(r)}
 
 def E e
-  return e if e.class == E
-  return e unless e
   E.new e
 end
 
 class E
-  def E.[] u; E u end
-  def E e=uri; super e end
 
-                      attr_reader :uri
-  def initialize uri; @uri = uri.to_s end
+  def E.[] u; u.E end
+
+  def E arg=nil
+    if arg
+      E.new arg
+    else
+      self
+    end
+  end
   
-  def base
-    File.basename path
+  attr_reader :uri
+
+  def initialize uri
+    @uri = uri.to_s
   end
 
-  def bare
-    base.sub(/\.#{ext}$/,'')
-    rescue
-    base
+  def basename
+    File.basename path
   end
+  alias_method :base, :basename
 
-  def docBase
-    readlink.uri.
-      split(/#/)[0].E.
-      do{|d|
-        d.dirname.as d.bare}
+  def barename
+    basename.sub(/\.#{ext}$/,'')
+  rescue
+    basename
   end
+  alias_method :bare, :barename
 
-    def ef;  @ef ||= docBase.a('.e') end
-    def nt;  @nt ||= docBase.a('.nt') end
-   def ttl; @ttl ||= docBase.a('.ttl') end
+  def ef;  @ef ||= docBase.a('.e') end
+  def nt;  @nt ||= docBase.a('.nt') end
+  def ttl; @ttl||= docBase.a('.ttl') end
 
+  def docBase
+    uri.split(/#/)[0].E.do{|d|
+      d.dirname.as d.bare }
+  end
+  
+  # same as above, but w/ URI errors
   def docBaseURI
     u = URI uri
     s = u.scheme
@@ -49,21 +59,50 @@ class E
     uri.frag
   end
 
-  def docs
-    (e ? [self] : []). # directly-referenced
-      concat(docBase.glob ".{e,html,n3,nt,owl,rdf,ttl}"). # docs
-      concat((d? && uri[-1]=='/') ? c : []) # trailing slash -> children
+  def parent
+    E Pathname.new(uri).parent
+  end
+
+  def parents
+    parent.do{|p|
+      p.uri.match(/^[.\/]+$/) ? [p] : [p].concat(p.parents)}
+  end
+
+  def cascade
+    [self].concat parents
   end
 
   def dirname
-    no.dirname.E
+    n = node.dirname
+    n = '/' if n.to_s.size <= BaseLen
+    n.E
   end
-  
-  # generate URL for non-URL identifier (mail ID, Tag URI..)
+  alias_method :dir, :dirname
+
+  # local URL from unlocatable identifier (mail MSGID, etc)
   def url
     path? ? uri : Prefix + (CGI.escape uri)
-   end
-  
+  end
+
+  # local URL even if locatable-identifier
+  def localURL e
+    # path
+    if uri.index('/') == 0
+      uri
+    # host match
+    elsif uri.index('http://'+e['SERVER_NAME']+'/') == 0
+      pathSegment.uri
+    # non-local
+    else
+      Prefix + (CGI.escape uri)
+    end
+  end
+
+  def pathSegment
+    m = uri.match(/^([a-z]+:\/\/[^\/]+)?(\/.*)/)
+    m && m[2] && m[2].E || nil
+  end
+
   # URI extension :: E -> string
   def ext
     File.extname(uri).tail||''
@@ -77,84 +116,115 @@ class E
     uri.expand.E
   end
 
-  # concatenate URIs with separator
-  # s :: E -> E
-  def s b
-    u.a E(b).path
+  def prependURI u
+    E u.to_s + uri
   end
 
-  def prependURI s
-    (s + uri).E
+  def appendURI u
+    E uri + u.to_s
   end
 
-  def appendURI s
-    (uri + s).E
+  def appendSlashURI u
+    E uri.t + u.to_s
   end
-  alias_method :a, :appendURI
-  alias_method :+, :appendURI
 
-  def appendSlashURI s
-    E uri.t + s
+  def concatURI b
+    u.appendURI b.E.path
   end
+
+  alias_method :a, :appendURI
+  alias_method :+, :appendURI
   alias_method :as, :appendSlashURI
 
-  # path? :: E -> Bool
   def path?
     uri.path?
   end
 
-  # path :: E -> String
+  # URI -> path
   def path
     @path ||=
-      path? ? (uri.match(/^\//) ? 
-               uri : '/'+uri) :
-      '/E/'+uri.h.dive[0..5]+(Base64.urlsafe_encode64 uri)
+      (if path?
+         if uri.match /^\//
+           uri
+         else
+           '/' + uri
+         end
+       else
+         '/E/' + uri.h.dive[0..5] + (Base64.urlsafe_encode64 uri)
+       end)
   end
 
   def u
-    @u ||= E (f ? dirname + '/.' + File.basename(path) : path.t + E::S)
+    # data-storage path for resource
+    @u ||= E (f ? dirname + '/.' + (File.basename path) : path.t + '._')
   end
 
-  # E (_ _ o) -> E o
-  def ro
-    uri.split(/#{E::S}\//)[-1].unpath false
+  # (_ _ o) -> o
+  def innerPath
+    (uri.split S)[-1].unpath
   end
+  alias_method :ro, :innerPath
 
   def sh
     d.force_encoding('UTF-8').sh
   end
 
-  # literal -> URI
+  # literals to URIs
+
+  def E.literal o
+    E['/'].literal o
+  end
+
   def literal o
+
+    # already a URI
+    return self if o.class == E
+
+    # blob for non-strings
     return literalBlob o unless o.class == String
+
+    # whitelisted predicateURIs to paths
     return literalURI o if (Literal[uri] || o.size<=88) && !o.match(/\//)
+
+    # string matches URI format
     return E o if o.match %r{\A[a-z]+://[^\s]+\Z}
+
+    # blob
     literalBlob o
+
   end
 
   # pathname for short literals
   def literalURI o
-    E "/u/"+(Literal[uri] && o.gsub(/[\.:\-T+]/,'/'))+'/'+o
+    E "/l/"+(Literal[uri] && o.gsub(/[\.:\-T+]/,'/'))+'/'+o
   end
  
   def literalBlobURI o
     if o.class == String
-      E "/blob/"+o.h.dive
+      E "/E/blob/"+o.h.dive
     else
-      E "/json/"+[o].to_json.h.dive
+      E "/E/json/"+[o].to_json.h.dive
     end
   end
 
+  def literalBlob o
+    u = literalBlobURI o
+    u.w o, !o.class == String unless u.f
+  end
+
   # spaceship
   def <=> c
     to_s <=> c.to_s
   end
 
-  # example: E('wiggly').to_s -> "wiggly"
-  def to_s # string
+  def to_s
     uri
   end
 
+  def to_h
+   {'uri' => uri}
+  end
+
 end
 
 class Hash
@@ -199,34 +269,41 @@ class String
     Shellwords.escape self
   end
 
-  BaseLen  = E::FSbase.size.succ
-
-  def pathToURI          r = true
-    self[BaseLen..-1].unpath r
+  def unpathFs
+    self[E::BaseLen..-1].do{|p|
+      (p.match(/^\/([a-z]+:)\/+(.*)/).do{|m|m[1]+'//'+m[2]}||p).E}
   end
 
-  # string -> E || literal
-  def unpath r=true # dereference literal? 
+  # path -> URI || literal
+  def unpath
 
-    if m=(match /^([a-z]+:)\/+(.*)/) # URL
-      (m[1]+'//'+m[2]).E
+    # URI with scheme
+    if m = (match /^\/([a-z]+:)\/+(.*)/)
+      (m[1] + '//' + m[2]).E
 
-    elsif match /^blob/ # string
-      r ? ('/'+self).E.r : ('/'+self).E
+    # String literal in store
+    elsif match /^\/E\/blob/
+      self.E.r
 
-    elsif match /^json/ # JSON
-      r ? (('/'+self).E.r true) : ('/'+self).E
+    # JSON literal in store
+    elsif match /^\/E\/json/
+      self.E.r true
 
-    elsif match /^u\// # trie
-      r ? (File.basename self) : ('/'+self).E
+    # String literal in basename
+    elsif match /^\/l\//
+      File.basename self
 
-    elsif match /^E\/..\/..\// # !fs-compatible URI
-      self[8..-1].match(/([^.]+)(.*)/).do{|c|
+    # URI (opaque)
+    elsif match /^\/E\/..\//
+      self[9..-1].match(/([^.]+)(.*)/).do{|c|
         (Base64.urlsafe_decode64 c[1]) + c[2]
       }.E
-    else # path
-      ('/'+self).E
+
+    # path
+    else
+      self.E
     end
+
   end
   
   def E