infod 0.0.1 → 0.0.2

data/infod/Es/ls.rb

@@ -0,0 +1,58 @@
+#watch __FILE__
+class E
+
+  fn 'view/dir',->i,e{
+
+    # item link + preview
+    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|
+       if r[Posix+'dir#child']
+         url = r.E.localURL e
+         {class: :dir, style: "background-color: #{E.cs}",    # dir wrapper
+           c: [{c: [{_: :a, href: url.t+'?view=ls&triplr=id', # link to "ls"
+                      c: r.uri.sub( 'http://'+e['SERVER_NAME'],'')},
+                    {_: :a, href: url.t, c: '/'}]},
+               r[Posix+'dir#child'].map{|c|a[c]}]}
+       else
+         a[r]
+       end
+     }]}
+
+  F['view/'+MIMEtype+'inode/directory'] = F['view/dir']
+
+  fn 'view/ls',->i,e{
+    dir = e['uri'].E
+    path = dir.pathSegment
+    up = (if !path || path.uri == '/'
+            '/'
+          else
+            dir.parent.url.t+'?view=ls&triplr=id'
+          end)
+
+    [(H.css '/css/ls'),
+     {_: :a, class: :up, href: up, c: '↑'},
+     {class: :ls,
+       c: (Fn 'view/table',i,e)},
+     (Fn 'view/find',i,e),'<br clear=all>',
+     {_: :a, class: :down, href: e['uri'].E.url.t + e.q.except('triplr','view').qs, 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

data/infod/Es/mail.rb

@@ -0,0 +1,87 @@
+class E
+  
+  # TMail version: 1.2.7.1-4 from:
+  # apt-get install ruby-tmail
+
+  def triplrTmail                         ; require 'tmail'
+
+    # read message
+    i = -> i {E i[1..-2]}                 # Message-ID -> E
+    (TMail::Mail.load node).do{|m|        # parse
+      d = m.message_id; return unless d   # parse successful?
+      e = i[d]                            # Message resource
+
+      # index previously unseen mail
+      e.e || (                            # Message-ID locatable?
+       ln e                               # create message-id path 
+       self.index Creator,  m.from[0].E   # index From
+       m.to.do{|t|self.index To, t[0].E}  # index To
+
+       %w{in_reply_to references}.map{|p| m.send(p).do{|os| os.map{|o|
+        e.index SIOC+'reply_of', i[o]}}}) # index references
+
+      # yield triples
+      yield e.uri, Type,    E[SIOCt + 'MailMessage']
+      yield e.uri, Type,    E[SIOC  + 'Post']
+      yield e.uri, Date,    m.date.iso8601    if m.date
+      yield e.uri, Content, m.decentBody
+        [[:subject,Title],
+              [:to,To,true],
+              [:cc,To,true],
+             [:bcc,To,true],
+   [:friendly_from,SIOC+'name'],
+            [:from,Creator,true],
+        [:reply_to,'/mail/reply_to',true],
+     [:in_reply_to,'/parent',true,true],
+     [:in_reply_to,SIOC+'reply_of',true,true],
+      [:references,SIOC+'reply_of',true,true],
+        ].each{|a| m.send(a[0]).do{|o| [*o].map{|o|
+            yield e.uri,a[1],                        # skip empty String values 
+            (a[2] ? (a[3] ? i[o] : o.E) : o.to_utf8) unless o.match(/\A[, \n]*\Z/)}}}}
+
+  rescue Exception => e
+    puts [:mail,uri,e].join(' ')
+  end
+
+  alias_method :triplrMail, :triplrTmail
+
+  # pure-ruby mail is only 10x (vs 100x) slower than C-ext based TMail w/ new parser
+  # API is mostly identical, URIs strings arent <>-wrapped
+  # TODO replace this msg with triplrMail if anyone wants it
+
+end
+
+module TMail
+  class Mail
+    def unicode_body
+      unquoted_body.to_utf8
+    end
+    def decentBody
+      unHTML=->t{t.split(/<body[^>]*>/)[-1].split(/<\/body>/)[0]}
+      if multipart?
+        parts.collect{ |part|
+          c = part["content-type"]
+          if part.multipart?
+            part.decentBody
+          elsif header.nil?
+            ""
+          elsif !attachment?(part) && c.sub_type != 'html'
+            part.unicode_body.hrefs(true)
+          else
+            (c["name"]||'attach').do{|a|
+              message_id ? (message_id[1..-2]+'/'+a).E.do{|i|
+                i.w part.body if !i.e
+                '<a href='+i.url+'>'+(part.main_type=='image' ? '<img src="'+i.url+'">' : a)+"</a><br>\n"
+              } : ""};end
+        }.join
+
+      else
+        unicode_body.do{|b|content_type&&content_type.match(/html/) ? unHTML.(b) : b.hrefs(true)}
+      end
+    rescue
+      ''
+    end 
+  end
+end
+
+class String; def is_binary_data?; true; end; end

data/infod/Es/man.rb

@@ -0,0 +1,112 @@
+#watch __FILE__
+class E
+  
+  fn '/man/GET',->e,r{
+    manPath = '/usr/share/man'
+
+    # eat selector
+    name = e.pathSegment.uri.sub('/man/','/').tail
+
+    # section requested?
+    section = nil
+    name.match(/^([0-9])(\/|$)/).do{|p|
+      section = p[1]
+      name = p.post_match }
+
+    if !name || name.empty? || name.match(/\//)
+      if section
+        # enumerate section children
+        (H [H.css('/css/man'),{_: :style, c: "a {background-color: #{E.cs}}"},
+            Pathname(manPath+'/man'+section).c.map{|p|
+              n = p.basename.to_s.sub /\.[0-9][a-z]*\...$/,''
+            }.group_by{|e|e[0].match(/[a-zA-Z]/) ? e[0].downcase : '0-9'}.sort.map{|g,m|
+              [{_: :h3, c: g},
+               m.map{|n|[{_: :a, href: '/man/'+section+'/'+n, c: n },' ']}]}
+           ]).hR
+      else
+        e.response
+      end
+    else
+      acceptLang = r['HTTP_ACCEPT_LANGUAGE'].do{|a|a.split(/,/)[0]}
+      lang = r.q['lang'] || acceptLang
+      superLang = lang.do{|l| (l.split /[_-]/)[0] }
+      langSH = lang.do{|l| '-L ' + l.sub('-','_').sh }
+      man = `man #{langSH} -w #{section} #{name.sh}`.chomp      
+
+      if man.empty?
+        return false
+      else
+
+        roff = man.E
+        htmlBase = roff.dir.to_s.sub(/.*\/share/,'').E
+        html = htmlBase.as roff.bare + '.html'
+        cached = html.e && html.m > (Pathname man).stat.mtime
+
+        if !cached
+
+          locales = Pathname(manPath).c.select{|p|p.basename.to_s.do{|b| !b.match(/^man/) && !b.match(/\./) }}.map{|p|File.basename p}
+          localesAvail = locales.select{|l|
+            File.exist? manPath + '/' + l + '/' + roff.uri.split('/')[-2..-1].join('/')}
+
+          imagePath = htmlBase.d + '/images'
+          FileUtils.mkdir_p imagePath unless File.exist? imagePath
+
+          preconv = %w{hu pt tr}.member?(superLang) ? "" : "-k"
+          pageCmd = "zcat #{man} | groff #{preconv} -T html -man -P -D -P #{imagePath}"
+          page = `#{pageCmd}`#.to_utf8
+
+          [[:name,name],
+           [:acceptLang,acceptLang],
+           [:lang, lang],
+           [:langSH, langSH],
+           [:superLang, superLang],
+           [:roff,man],
+           [:htmlBase,htmlBase.d],
+           [:imagePath,imagePath],
+           [:localizations,localesAvail],
+           [:pageCmd,pageCmd]].map{|p| puts [" "*(13-p[0].size),*p].join ' ' }
+          
+          page = Nokogiri::HTML.parse page
+          body = page.css('body')[0]
+          
+          # add CSS link
+          body.add_child H H.css('/css/man')
+          body.add_child H[{_: :style, c: "a {background-color:#{E.cs}}"}]
+          
+          # add localization links
+          (body.css('h1')[0] ||
+           body.css('p')[0]
+           ).add_previous_sibling H localesAvail.map{|l|
+            {_: :a, class: :lang, href: r['REQUEST_PATH']+'?lang='+l, c: l}}
+          
+          # webize image paths
+          body.css('img').map{|i|
+            p = (i.attr 'src').unpathFs
+            i.replace H[{_: :img, src: p}]}
+
+          # inspect plaintext
+          #  HTMLize hyperlinks
+          #  markup commands
+          body.xpath('//text()').map{|a|
+            a.replace a.to_s.gsub('&gt;','>').hrefs.gsub /\b([^<>\s(]+)\(/mi, '<b>\1</b>('
+          }
+          
+          qs = r['QUERY_STRING'].do{|q| q.empty? ? '' : '?' + q}
+          # href-ize commands
+          body.css('b').map{|b|
+            b.next.do{|n|
+              n.to_s.match(/\(([0-9])\)(.*)/).do{|section|
+                name, s = b.inner_text, section[1]
+                n.replace section[2]
+                b.replace " <a href='/man/#{s}/#{name}#{qs}'><b>#{name}</b>(#{s})</a>"}}}
+
+          html.w page
+        end
+        
+        # response
+        html.env(r).getFile
+      end
+    end
+  }
+
+end

data/infod/Es/mime.rb

@@ -0,0 +1,59 @@
+#watch __FILE__
+class E
+
+  # MIME-type, no link-following
+  def mime
+    @mime ||=
+      (t = ext.downcase.to_sym
+
+       if node.symlink?
+         "inode/symlink"
+
+       elsif d?
+         "inode/directory"
+
+       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
+         "application/octet-stream"
+       end)
+  end
+
+  # MIME-type of recursively-dereferenced path
+  def mimeP
+    @mime ||=
+      (p = realpath
+
+       unless p
+         nil
+       else
+         t = ((File.extname p).tail || '').downcase.to_sym
+
+         if p.directory?
+           "inode/directory"
+
+         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
+       end )
+  end
+end

data/infod/Es/out.rb

@@ -0,0 +1,52 @@
+class E
+
+  def render mime,   graph, e
+   E[Render+ mime].y graph, e
+  end
+
+  fn '/E/GET',->e,r{[301,{Location: '/'},[]]}
+
+  def response
+
+    q = @r.q       # query-string
+    g = q['graph'] # graph-function selector
+
+    # empty response graph
+    m = {}
+
+    # identify graph
+    graphID = (F['protograph/' + g] || F['protograph/'])[self,q,m]
+
+    return F[E404][self,@r] if m.empty?
+
+    # identify response
+    @r['ETag'] ||= [graphID, q, @r.format, Watch].h
+
+    maybeSend @r.format, ->{
+      
+      # response
+      r = E'/E/req/' + @r['ETag'].dive
+      if r.e # response exists
+        r    # cached response
+      else
+        
+        # graph
+        c = E '/E/graph/' + graphID.dive
+        if c.e # graph exists
+          m.merge! c.r true
+        else
+          # construct graph
+          (F['graph/' + g] || F['graph/'])[self,q,m]
+          # cache graph
+          c.w m,true
+        end
+
+        # graph sort/filter
+        E.filter q, m, self
+
+        # cache response
+        r.w render @r.format, m, @r
+      end }
+  end
+
+end

data/infod/{W/page.rb → Es/pager.rb}

@@ -1,8 +1,12 @@
 #watch __FILE__
 class E
   
-  fn 'head/page',->d,e{ v = e.q['v']
-    Fn 'head' + (v != 'page' && '/' + v), d, e}
+  fn 'head/page',->d,e{
+    v = e.q['v']
+    unless v == 'page'
+      h = F['head/'+v] || F['head'] 
+      h[d,e]
+    end}
 
   fn 'view/page',->d,e{
     # try daydirs if no pagination data provided
@@ -25,6 +29,6 @@ class E
 
     [(H.js '/js/pager'),(H.once e,:mu,(H.js '/js/mu')), # n/p key shortcuts
      c,(H (F['view/'+e.q['v']]||F['view']).(d,e)),      # content
-     '<br clear=all>',c]}
+     '<br clear=all>',{class: :bottom, c: c}]}
   
 end

data/infod/Es/pdf.rb

@@ -0,0 +1,19 @@
+class E
+
+  def triplrPDF &f
+
+    text = docBase.a '.txt'
+    unless text.e && text.m > m
+      puts "PDF #{uri}"
+      `pdftotext #{sh}`
+    end
+
+    # metadata
+    triplrStdOut 'pdfinfo', &f
+
+    # body
+    yield uri, Content, `cat #{text.sh}`
+
+  end
+
+end

data/infod/Es/rdf.rb

@@ -0,0 +1,35 @@
+#watch __FILE__
+class E
+
+  def self.renderRDF d,f
+    require 'linkeddata'
+    (RDF::Writer.for f).buffer{|w|
+      d.values.each{|r| r.triples{|s,p,o|
+          s = RDF::URI s
+          p = RDF::URI p
+          o = ([E,Hash].member?(o.class) ? (RDF::URI o.uri) : (RDF::Literal o)) rescue nil
+          (w << (RDF::Statement.new s,p,o) if o ) rescue nil
+        }}}
+  end
+
+  def triplrRDF format=:rdfa, localFile=true  ; require 'linkeddata'
+    location = (localFile && f) ? d : uri
+    puts [:RDF,location].join ' '
+    RDF::Reader.open(location, :format => format){|r|
+      r.each_triple{|s,p,o|
+        yield s.to_s, p.to_s, [RDF::Node, RDF::URI].member?(o.class) ? E(o) : o.value.do{|v|v.class == String ? v.to_utf8 : v}}}
+  end
+
+  [['application/ld+json',:jsonld],
+   ['application/json+ld',:jsonld],
+   ['application/jsonld',:jsonld],
+   ['application/rdf+xml',:rdfxml],
+   ['application/rdfxml',:rdfxml],
+   ['text/ntriples',:ntriples],
+   ['text/turtle',:turtle],
+   ['text/rdf+n3',:n3],
+   ['text/n3',:n3]
+  ].map{|mime|
+    F[Render+mime[0]] = ->d,a=nil{E.renderRDF d, mime[1]}}
+
+end