infod 0.0.2 → 0.0.3.0

data/infod/Es/in.rb

@@ -1,68 +0,0 @@
-#watch __FILE__
-class E
-
-  # Graph -> tripleStream -> Graph
-  def fromStream m,*i
-    send(*i) do |s,p,o|
-      m[s] = {'uri' => s} unless m[s].class == Hash 
-      m[s][p] ||= []
-      m[s][p].push o unless m[s][p].member? o
-    end; m
-  end
-
-  # default proto-graph
-  #   mint graph identifier
-  #   any graph setup (:g variable mutation) is preserved
-  fn 'protograph/',->e,q,g{
-    set = (F['set/' + q['set']] || F['set/'])[e,q,g]
-    set.map{|u| g[u.uri] ||= u if u.class == E } if set.class == Array
-    # unique fingerprint for graph
-    [F['docsID'][g],
-     F['triplr'][e,q],
-     q.has_key?('nocache').do{|_|rand}
-    ].h}
-
-  # default graph
-  #  filesystem storage
-  fn 'graph/',->e,q,m{
-    triplr = F['triplr'][e,q]
-    m.values.map{|r|
-      (r.env e.env).graphFromFile m, triplr if r.class == E }}
-
-  fn 'docsID',->g{
-    g.sort.map{|u,r|
-      [u, r.respond_to?(:m) && r.m]}.h}
-
-  fn 'triplr',->e,q{
-    t = q['triplr']
-    t && e.respond_to?(t) && t || :triplrMIME }
-
-  # document-set
-  fn 'set/',->e,q,_{
-    s = []
-    s.concat e.docs
-    e.pathSegment.do{|p| s.concat p.docs }
-    s }
-
-  def triplrMIME &b
-    mimeP.do{|mime|
-      yield uri,E::Type,(E MIMEtype+mimeP)
-      (MIMEsource[mimeP]||
-       MIMEsource[mimeP.split(/\//)[0]]).do{|s|
-        send *s,&b }}
-  end
-
-  def graphFromFile g={}, triplr=:triplrMIME
-    g.mergeGraph r(true) if ext=='e' # JSON -> graph
-    [:triplrInode,        # filesystem data
-     triplr].# format-specific tripleStream emitter
-      each{|i| fromStream g,i } # tripleStream -> Graph
-    g
-  end
-
-  def graph g={}
-    docs.map{|d|d.graphFromFile g}  # tripleStream -> graph
-    g
-  end
-
-end

data/infod/Es/json.rb

@@ -1,68 +0,0 @@
-class Hash
-
-  def graph g
-    g.merge!({uri=>self})
-  end
-
-  def mergeGraph g
-    g.values.each{|r|
-      r.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
-
-  # tripleStream emitter
-  def triples
-    s = uri
-    map{|p,o|
-      o.class == Array ? o.each{|o| yield s,p,o} : yield(s,p,o) unless p=='uri'}
-  end
-
-end
-
-class E
-
-  def triplrJSON
-    yield uri, '/application/json', (JSON.parse read) if e
-  end
-
-
-  # tripleStream -> fs
-  def addJSON i,g,p=[]
-    fromStream({},i).map{|u,r| # stream -> graph
-      (E u).do{|e| # resource
-        j = e.ef   # inode
-        j.e ||     # exists?
-        (p.map{|p|r[p].do{|o|e.index p,o[0]}} # index properties
-         j.w({u => r},true) # write doc
-         puts "a #{e}"
-         # link opaque-URI docs as siblings of base-URI for doc-discoverability
-         e.a('.e').do{|u| (j.ln u) unless ((j.uri == u.uri) || u.e)  }
-         e.roonga g # index content
-         )}}
-    self
-  rescue Exception => e
-    puts "addJSON #{e}"
-  end
-
-  fn 'view/application/json',->m,e{
-    m.map{|u,j|
-      e.q['sel'].do{|s|
-        c = j['/application/json'][0]
-        s.split(/\./).map{|s|
-          s = s.to_i if s.match(/^\d$/)
-          c = c[s] }
-        [{_: :a,
-           href: u+'?q=json&view=application/json&sel='+s,
-           c: {_: :b, c: u+'#'+s}}, c.html]
-      }||[{_: :h3, c: u},j.html]}}
-  
-  def to_json *a
-    to_h.to_json *a
-  end
-
-  fn Render+'application/json',->d,_=nil{[d].to_json}
-
-end

data/infod/Es/ls.rb

@@ -1,58 +0,0 @@
-#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

@@ -1,87 +0,0 @@
-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/mime.rb

@@ -1,59 +0,0 @@
-#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

@@ -1,52 +0,0 @@
-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/Es/pager.rb

@@ -1,34 +0,0 @@
-#watch __FILE__
-class 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
-    !d.has_any_key(%w{next prev}) &&
-    e['REQUEST_PATH'].match(/(.*?\/)([0-9]{4})\/([0-9]{2})\/([0-9]{2})(.*)/).do{|m|
-      t = ::Date.parse "#{m[2]}-#{m[3]}-#{m[4]}"
-      d['prev'] = {'uri' => 'prev','url' => m[1]+(t-1).strftime('%Y/%m/%d')+m[5]}
-      d['next'] = {'uri' => 'next','url' => m[1]+(t+1).strftime('%Y/%m/%d')+m[5]}}
-
-    # links
-    c=[d['prev'].do{|p| d.delete('prev') # prev
-         {_: :a, rel: :prev, style: 'float:left; font-size:2em',
-           href: [*p['url']][0]+e.q.merge(p).except('uri','url').qs,
-           title: (p['b']||p['url']), c: '←'}},
-
-       d['next'].do{|n| d.delete('next') # next
-         {_: :a, rel: :next, style: 'float:right;font-size:2em',
-           href: [*n['url']][0]+e.q.merge(n).except('uri','url').qs, 
-           title: (n['b']||n['url']), c: '→'}}]
-
-    [(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>',{class: :bottom, c: c}]}
-  
-end

data/infod/Es/pdf.rb

@@ -1,19 +0,0 @@
-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