infod 0.0.3.2 → 0.0.3.3

data/infod/microblog.rb

@@ -1,5 +1,5 @@
 #watch __FILE__
-class E
+class R
 
   # sprintf() formats in <https://github.com/infodaemon/www/blob/60a9b5f51cf15d5723afd9172767843d97190d8f/css/i/lotek.theme>
   def triplrIRC &f
@@ -17,27 +17,27 @@ class E
         yield s, SIOCt+'ChatChannel', channel
         yield s, Creator,             m[2]
         yield s, Content,             m[3].hrefs(true)
-        yield s, Type,                E[SIOCt+'InstantMessage']
-        yield s, Type,                E[SIOC+'Post']
+        yield s, Type,                R[SIOCt+'InstantMessage']
+        yield s, Type,                R[SIOC+'Post']
         yield s, SIOC+'link',        (m[3].match(/http:\//) ? 'true' : 'false')
       } rescue nil
     }
   end
 
   def tw g
-    no.readlines.shuffle.each_slice(22){|s|
-      E['https://twitter.com/search/realtime?q='+s.map{|u|'from:'+u.chomp}.intersperse('+OR+').join].addDocs :triplrTweets, g, nil, FeedArchiver}
+    node.readlines.shuffle.each_slice(22){|s|
+      R['https://twitter.com/search/realtime?q='+s.map{|u|'from:'+u.chomp}.intersperse('+OR+').join].addDocs :triplrTweets, g, nil, FeedArchiver}
   end
 
   def triplrTweets
     base = 'http://twitter.com'
     nokogiri.css('div.tweet').map{|t|
       s = base + t.css('a.details').attr('href') # subject URI
-      yield s, Type, E[SIOCt+'MicroblogPost']
-      yield s, Type, E[SIOC+'Post']
-      yield s, Creator, E(base+'/'+t.css('.username b')[0].inner_text)
+      yield s, Type, R[SIOCt+'MicroblogPost']
+      yield s, Type, R[SIOC+'Post']
+      yield s, Creator, R(base+'/'+t.css('.username b')[0].inner_text)
       yield s, Name,t.css('.fullname')[0].inner_text
-      yield s, Atom+"/link/image", E(t.css('.avatar')[0].attr('src'))
+      yield s, Atom+"/link/image", R(t.css('.avatar')[0].attr('src'))
       yield s, Date, Time.at(t.css('[data-time]')[0].attr('data-time').to_i).iso8601
       content = t.css('.tweet-text')[0]
       content.css('a').map{|a|
@@ -48,10 +48,10 @@ class E
   end
 
   fn 'view/chat',->d,e{
-    Fn'baseview/chat',d,e,->{d.map{|u,r|Fn 'itemview/chat',r,e}}}
+    F['baseview/chat'][d, e, ->{d.map{|u,r|F['itemview/chat'][r,e]}}]}
 
   fn 'itemview/chat',->r,e{
-    r[Type] && [*r[Type]].map{|t|t.respond_to?(:uri) && t.uri}.include?(SIOCt+'MailMessage') && r[:mail]=true
+    r[Type] && [*r[Type]].map(&:maybeURI).include?(SIOCt+'MailMessage') && r[:mail]=true
     r[Content] && r[Date] && r[Date][0] &&
     [r[Date][0].match(/T([0-9:]{5})/).do{|m|m[1]},
      {_: :span, :class => :nick, c: {_: :a, href: r[Atom+'/link/alternate'].do{|a|a[0].uri}||r.url,
@@ -69,7 +69,7 @@ class E
         c: F['itemview/chat'][r,e]}}}
 
   fn 'baseview/chat',->d,e,c{
-    [(H.once e,'chat.head',(H.css '/css/tw'),{_: :style, c: "body {background-color: #{E.c}}\n"}),c.()]}
+    [(H.once e,'chat.head',(H.css '/css/tw'),{_: :style, c: "body {background-color: #{R.c}}\n"}),c.()]}
 
   F['view/'+SIOCt+'InstantMessage']=F['view/chat']
   F['view/'+SIOCt+'MicroblogPost']=F['view/chat']

data/infod/mime.rb

@@ -1,5 +1,5 @@
 #watch __FILE__
-class E
+class R
 
   # no link-follow
   def mime
@@ -10,12 +10,12 @@ class E
          "inode/symlink"
        elsif d?
          "inode/directory"
+       elsif base.index('msg.')==0 # how to make procmail append a non-gibberish extension?
+         "message/rfc822"
        elsif MIME[t]
          MIME[t]
        elsif Rack::Mime::MIME_TYPES[t='.'+t.to_s]
          Rack::Mime::MIME_TYPES[t]
-       elsif base.index('msg.')==0
-         "message/rfc822"
        elsif e
          `file --mime-type -b #{sh}`.chomp
        else
@@ -33,12 +33,12 @@ class E
          t = ((File.extname p).tail || '').downcase.to_sym
          if p.directory?
            "inode/directory"
+         elsif (File.basename p).index('msg.')==0
+           "message/rfc822"
          elsif MIME[t]
            MIME[t]
          elsif Rack::Mime::MIME_TYPES[t='.'+t.to_s]
            Rack::Mime::MIME_TYPES[t]
-         elsif (File.basename p).index('msg.')==0
-           "message/rfc822"
          else
            `file --mime-type -b #{Shellwords.escape p.to_s}`.chomp
          end
@@ -155,25 +155,18 @@ class E
     'text/x-tex'=>true,
   }
 
-  # cache triplr output
-  MIMEcache={
-    'audio' => true,
-    'image' => true,
-#    '' => 
-  }
-
   %w{c c++ fortran haskell makefile pascal perl php python ruby}.map{|t|
     %w{application/ text/x-}.map{|m|
       MIMEcook[m+t] = true
   }}
 
-  def render mime,   graph, e
-   E[Render+ mime].y graph, e
+  def render mime, graph, e
+    F[Render+mime][graph, e]
   end
 
   def triplrMIME &b
     mimeP.do{|mime|
-      yield uri, E::Type, (E MIMEtype+mimeP)
+      yield uri, R::Type, (R MIMEtype+mimeP)
       (MIMEsource[mimeP]||
        MIMEsource[mimeP.split(/\//)[0]]).do{|s|
         send *s,&b }}

data/infod/names.rb

@@ -1,75 +1,65 @@
-%w{cgi shellwords}.each{|r|require(r)}
+class R
+
+  def appendURI u; R uri + u.to_s end
+  def appendSlashURI u; R uri.t + u.to_s end
+  def basename; File.basename path end
+  def barename; basename.sub(/\.#{ext}$/,'') rescue basename end
+  def cascade; [self].concat parents end
+  def children; node.c.map &:R end
+  def container; @u ||= R[f ? dirname + '/.' + (File.basename path) : path] end
+  def d;        node.to_s end
+  def delete;   node.deleteNode if e; self end
+  def dirname;  node.dirname.do{|d| d.to_s.size <= BaseLen ? '/' : d }.R end
+  def docBase;  uri.split(/#/)[0].R.do{|d| d.dirname.as d.bare } end
+  def d?;       node.directory? end
+  def env r=nil;r ? (@r = r; self) : @r end
+  def exist?;   node.exist? end
+  def expand;   uri.expand.R end
+  def ext;      File.extname(uri).tail||'' end
+  def file?;    node.file? end
+  def frag;     uri.frag end
+  def get;      open(uri).read end
+  def glob p=""; (Pathname.glob d + p).map &:R end
+  def hostURL e; host='http://'+e['SERVER_NAME']; (uri.index('/') == 0 ? host : '') + uri end
+  def inside;   node.expand_path.to_s.index(FSbase) == 0 end
+  def label;    uri.label end
+  def mk;       e || FileUtils.mkdir_p(d); self end
+  def mtime;    node.stat.mtime if e end
+  def node;     Pathname.new FSbase + path end
+  def parent;   R Pathname.new(uri).parent end
+  def parents;  parent.do{|p|p.uri.match(/^[.\/]+$/) ? [p] : [p].concat(p.parents)} end
+  def path;     uri.match(/^\//) ? uri : ('/'+uri) end
+  def pathSegment; uri.match(/^([a-z]+:\/\/[^\/]+)?(\/.*)/).do{|p|p[2]&&p[2].R}||nil end
+  def predicatePath p,s=true; container.as s ? p.R.shorten : p end
+  def predicates; container.c.map{|c|c.base.expand.R} end
+  def prependURI u; R u.to_s + uri end
+  def read;     f ? readFile : get end
+  def readFile; File.open(d).read end
+  def realpath; node.realpath rescue Errno::ENOENT end
+  def shorten;  uri.shorten.R end
+  def siblings; parent.c end
+  def size;     node.size end
+  def == u;     to_s == u.to_s end
+  def <=> c;    to_s <=> c.to_s end
+  def sh;       d.force_encoding('UTF-8').sh end
+  def to_s;     uri end
+  def to_h;    {'uri' => uri} end
+  def touch;    FileUtils.touch node; self end
+  def writeFile c; File.open(d,'w'){|f|f << c} end
 
-class E
-
-  attr_reader :uri
-  alias_method :url, :uri
-  alias_method :maybeURI, :uri
-
-  def env r=nil
-    r ? (@r = r
-         self) : @r
-  end
-
-  def == u
-      to_s == u.to_s
-  end
-
-  def basename
-    File.basename path
-  end
+  alias_method :+, :appendURI
+  alias_method :a, :appendURI
+  alias_method :as, :appendSlashURI
   alias_method :base, :basename
-
-  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 docBase
-    !uri.empty? && uri.split(/#/)[0].do{|u|u.E.do{|d| d.dirname.as d.bare }} || E['']
-  end
-
-  def frag
-    uri.frag
-  end
-
-  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
-    n = node.dirname
-    n = '/' if n.to_s.size <= BaseLen
-    n.E
-  end
+  alias_method :c, :children
   alias_method :dir, :dirname
+  alias_method :e, :exist?
+  alias_method :f, :file?
+  alias_method :m, :mtime
+  alias_method :maybeURI, :uri
+  alias_method :url, :uri
 
-  # add hostname to URI (if missing)
-  def hostURL e
-    host = 'http://'+e['SERVER_NAME']
-    if uri.index('/') == 0 
-      host + uri
-    else
-      uri
-    end
-  end
-
-  # pointer to local data about global URI
   def localURL e
     if uri.index('/') == 0
       uri             # already a local path
@@ -80,203 +70,67 @@ class E
     end
   end
 
-  def pathSegment
-    m = uri.match(/^([a-z]+:\/\/[^\/]+)?(\/.*)/)
-    m && m[2] && m[2].E || nil
-  end
-
-  def ext
-    File.extname(uri).tail||''
-  end
-
-  def label
-    uri.label
-  end
-
-  def expand
-    uri.expand.E
-  end
-
-  def shorten
-    uri.shorten.E
-  end
-
-  def prependURI u
-    E u.to_s + uri
-  end
-
-  def appendURI u
-    E uri + u.to_s
-  end
-
-  def appendSlashURI u
-    E uri.t + u.to_s
-  end
-
-  def concatURI b
-    u.appendURI b.E.shortPath
-  end
-
-  alias_method :a, :appendURI
-  alias_method :+, :appendURI
-  alias_method :as, :appendSlashURI
-
-  def shortPath
-    @shortPath ||=
-      (if uri.match /^\//
-         uri
-       else
-         '/' + uri.shorten
-       end)
-  end
-
-  def path
-    if uri.match /^\//
-      uri
-    else
-      '/' + uri
-    end
-  end
-
-  def u
-    # path for data about this resource
-    @u ||= E (f ? dirname + '/.' + (File.basename path) : path.t + '._')
-  end
-
-  # (_ _ o) -> o
-  def innerPath
-    (uri.split S)[-1].unpath
-  end
-  alias_method :ro, :innerPath
-
-  def sh
-    d.force_encoding('UTF-8').sh
-  end
-
-  def E.literal o
-    ''.E.literal o
-  end
-
-  def literal o
-    return o if o.class == E
-    u = (if o.class == String
-           E "/E/blob/"+o.h.dive
+  def objectPath o
+    p,v=(if o.class == R
+           [o.path, nil]
          else
-           E "/E/json/"+[o].to_json.h.dive
+           literal o
          end)
-    u.w o, !o.class == String unless u.f
-    u
+    [(a p), v]
   end
 
-  # spaceship comparison-operator
-  def <=> c
-    to_s <=> c.to_s
-  end
-
-  def to_s
-    uri
-  end
-
-  def to_h
-   {'uri' => uri}
+  def literal o
+    str = nil
+    ext = nil
+    if o.class == String
+      str = o;         ext='.txt'
+    else
+      str = o.to_json; ext='.json'
+    end
+    ['/'+str.h+ext, str]
   end
 
-  # internal pathnames not on the web (cached representations, index databases)
-  F['/E/GET'] = F[E404]
-
 end
 
 class Hash
-  def uri
-    self["uri"]||""
-  end
+  def R; R.new uri end
+  def uri; self["uri"]||"" end
+  def label; uri.label end
   alias_method :url, :uri
   alias_method :maybeURI, :uri
-  def label
-    self[E::Label] || uri.label
-  end
-  def E
-    E.new uri
-  end
-end
-
-class Array
-  def E
-    self[0].E if self[0].class==Hash
-  end
 end
 
 class String
-  def dive
-    self[0..1]+'/'+
-    self[2..3]+'/'+
-    self[4..-1]
-  end
 
-  # expand qname/CURIE-style identifier to URI
+  def dive; self[0..2]+'/'+self[3..-1] end
+
+  # expand possibly CURIE entryname
   Expand={}
   def expand
    (Expand.has_key? self) ?
     Expand[self] :
    (Expand[self] =
      match(/([^:]+):([^\/].*)/).do{|e|
-      ( E::Prefix[e[1]] || e[1]+':' )+e[2]} || 
-     self )
+      ( R::Prefix[e[1]] || e[1]+':' )+e[2]} || 
+     gsub('|','/'))
   end
 
-  # shrink URI to qname/CURIE/prefixed identifier
+  # shrink to entryname, CURIE if possible
   def shorten
-    E::Prefix.map{|p,f|
+    R::Prefix.map{|p,f|
       return p + ':' + self[f.size..-1]  if (index f) == 0
     }
-    self
-  end
-
-  def sh
-    Shellwords.escape self
-  end
-
-  def unpathFs
-    self[E::BaseLen..-1].do{|p|
-      (p.match(/^\/([a-z]+:)\/+(.*)/).do{|m|m[1]+'//'+m[2]}||p).E}
+    gsub('/','|')
   end
 
-  # path -> URI || literal
-  def unpath
-
-    # HTTP URI
-    if m = (match /^\/([a-z]+:)\/+(.*)/)
-      (m[1] + '//' + m[2]).E
-
-    # prefix-shortened URI
-    elsif m = (match /^\/([^\/:]+:[^\/]+)/)
-      m[1].expand.E
-
-    # String literal
-    elsif match /^\/E\/blob/
-      self.E.r
-
-    # JSON literal
-    elsif match /^\/E\/json/
-      self.E.r true
-
-    # plain path
-    else
-      self.E
-    end
-
-  end
-  
-  def E
-    E.new self
+  def unpath skip = R::BaseLen
+    self[skip..-1].do{|p|
+      (p.match(/^\/([a-z]+:)\/+(.*)/).do{|m|m[1]+'//'+m[2]}||p).R}
   end
 
-  def frag
-    split(/#/).pop()
-  end
-
-  def label
-    split(/[\/#]/)[-1]
-  end
+  def R; R.new self end
+  def frag; split(/#/).pop() end
+  def label; split(/[\/#]/)[-1] end
+  def sh; Shellwords.escape self end
 
 end