infod 0.0.1 → 0.0.2

data/infod/W/mail.rb

@@ -1,248 +0,0 @@
-# -*- coding: utf-8 -*-
-#watch __FILE__
-
-class E
-
-  # qs alias section
-  F["?"] ||= {}
-  F["?"].update({
-   'thread' =>{'graph'=>'thread',
-               'sort' => 'dc:date',
-               'reverse' => nil,
-               'view' => 'multi',
-               'views' => 'timegraph,mail',
-               'arc' => '/parent',
-               'label' => 'sioc:name'},
-      'ann' =>{'view'=>'threads',
-               'matchP' => 'dc:title',
-               'match' => /[^a-zA-Z][Aa][Nn][nN]([oO][uU]|[^a-zA-Z])/}})
-
-  def triplrMail; 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
-      e.e || (                            # Message-ID locatable?
-
-       # index previously unseen mail
-       ln e                               # create message-id path 
-       %w{in_reply_to references}.map{|p| # reference arcs
-        m.send(p).do{|o| o.map{|o|        # lookup references
-         e.index SIOC+'reply_of', i[o]}}} # index references
-       e.ln '/' + m.date.iso8601[0..12].gsub(/[^\d]/,'/') + '/' + e.uri # date/hour index tree
-       self.index Creator, m.from[0].E    # index From
-       self.index      To, m.to[0].E )    # index To
-
-      # yield triples
-      yield e.uri, Type,    E[SIOCt+'MailMessage']
-      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
-
-  fn 'graph/thread',->d,_,m{d.walk SIOC+'reply_of',m}
-
-  # overview of a message set
-  fn 'view/threads',->d,env{
-
-    # occurrence-count statistics
-    g = {}
-    d.map{|_,m|
-      m[To].map{|t|
-        g[t.uri]||=0
-        g[t.uri]=g[t.uri].succ}}
-
-    # CSS
-    [(H.css '/css/mail'),
-
-     ([{_: :a, href: '/@'+env.q['p']+'?set=indexP&view=page&v=linkPO&c=12', c: env.q['p']},
-       {_: :a, href: '/m?y=day', c: ' :: '},
-       {_: :a, href: E[env['uri']].url+'?set=indexPO&view=page&v=threads&c=32&p='+env.q['p'], c: env['uri']}
-      ] if env.q['set']=='indexPO'),
-
-     '<table>',
-
-     # subgroup by title
-     d.values.group_by{|r|[*r[Title]][0].sub(/^[rR][eE][^A-Za-z]./,'')}.
-
-     # group by recipient
-     group_by{|r,k|
-
-       # show most-popular first
-       k[0].do{|k|
-         k[To].do{|o|o.sort_by{|t|g[t.uri]}.reverse.head.uri}}}.
-
-     # display
-     map{|e|
-       # recipient-group color
-       c = '#%06x' % rand(16777216)
-       ['<tr><td class=subject>',
-        
-        # show most-popular groups first
-        e[1].sort_by{|m|m[1].size}.reverse.map{|t|
-
-          # link to thread
-          [{_: :a, property: Title, :class => 'thread', style: "border-color:#{c}", href: t[1][0].url+'??=thread',
-             c: t[0].to_s.gsub(/[<>]/,'_').gsub(/\[([a-z\-A-Z0-9]+)\]/,'<span class=g>\1</span>')},
-
-           # link to individual messages
-           (t[1].size > 1 &&
-            ['<br>', t[1].map{|s|
-
-               # author name and RDFa
-               [{_: :a, property: Creator, href: s.url+'??=thread#'+s.uri, :class => 'sender', style: 'background-color:'+c,
-                  c: s[SIOC+'name'][0].split(/\W/,2)[0]},' ']}]),'<br>']},'</td>',
-
-        # recipient group, Mailing List
-        {_: :td, class: :group, property: To,
-          c: {_: :a, :class => :to, style: 'background-color:'+c, c: e[0] && e[0].split(/@/)[0],
-            href: e[0] && e[0].E.url+'?set=indexPO&p=sioc:addressed_to&view=page&v=threads'}},
-
-        '</tr>']},'</table>',
-
-     # link to show full content of entire message-set
-     {_: :a, id: :down, c: '&darr;',href: env['REQUEST_PATH']+env.q.merge({'view'=>'page','views'=>'timegraph,mail','v'=>'multi'}).qs}]}
-
-
-  # show a set of messages
-  fn 'view/mail',->d,e{
-    title = nil
-
-    # JS/CSS dependencies
-    [(H.once e,'mail.js',
-      (H.css '/css/mail'),
-      (H.js '/js/mail'),
-      (H.once e,:mu,(H.js '/js/mu')),
-
-      # up to set-overview
-      ({_: :a, id: :up, href: e['REQUEST_PATH'] + e.q.merge({'view' => 'page', 'v' => 'threads'}).qs, c: '&uarr;'} if d.keys.size > 2),
-
-      # collapse/expand quoted content
-      {id: :showQuote, c: :quote, show: :true},{_: :style, id: :quote}),
-
-     # each message
-     d.values.map{|m|
-
-       # content available?
-       [m.class == Hash && (m.has_key? E::SIOC+'content') &&
-        
-        {:class => :mail,
-          
-          c: [# link to self
-              {_: :a, name: m.uri, href: m.url, rel: :permalink, title: :link, c: ' '},
-              
-              # To:, From: index search links
-              [['sioc:has_creator',Creator],['sioc:addressed_to',To]].map{|a|
-                m[a[1]].do{|m|
-                  m.map{|f| f.respond_to?(:uri) &&
-                    {_: :a, property: a[0], href: f.url+'?set=indexPO&p='+a[0]+'&view=page&views=timegraph,mail&v=multi&c=8', c: f.uri}}}},
-
-              # mailto URI with embedded reply metadata
-              (m['/mail/reply_to']||m[Creator]).do{|r| r[0] && r[0].respond_to?(:uri) &&
-                {_: :a, title: :reply, c: 'r',
-                  href: "mailto:#{r[0].uri}?References=<#{m.uri}>&In-Reply-To=<#{m.uri}>&Subject=#{m[Title].join}"}},'<br clear=all>',
-
-              # content
-              {_: :pre,
-                c: m[Content].map{|b|
-
-                  # line count
-                  i = 0
-
-                  # HTML message content
-                  b.class==String && b.              
-
-                  # erase empty quoted lines
-                  gsub(/^\s*(&gt;)(&gt;|\s)*\n/,"").
-
-                  # each line
-                  lines.to_a.map{|l|
-
-                    # line identifier
-                    f = m.uri + ':' + (i+=1).to_s
-                    
-                    # wrapper
-                    {_: :span, 
-                      
-                      # is line quoted?
-                      class: ((l.match /(^\s*(&gt;|On[^\n]+(said|wrote))[^\n]*)\n/) ? 'q' : 'u'), c:
-
-                      # id
-                      [{_: :a, id: f},
-
-                       # line
-                       l.chomp,
-
-                       # link
-                       (l.size > 64 &&
-                        {_: :a, class: :line, href: '#'+f,c: '↵'}),
-
-                     "\n" ]}}}}, # collate lines
-
-              # title
-              m[Title].do{|t|
-                # only show if changed from previous
-                title != t[0] && (
-                 title = t[0] # update title
-                 [{:class => :title, c: t.html, _: :a, href: m.url+'??=thread#'+m.uri, style: "color: #{E.c}"},
-                  '<br clear=all>'])}]}]}]}
-  
-  # set a default view for MIME and SIOC types
-  [MIMEtype+'message/rfc822',
-   SIOCt+'MailMessage'].
-    map{|m| F['view/'+m] = F['view/mail'] }
-
-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
-
-# TMail calls this nonexistent method on strings
-class String; def is_binary_data?; true; end; end

data/infod/W/pdf.rb

@@ -1,16 +0,0 @@
-class E
-
-  F["?"]||={}
-  F["?"].update({'pdf'=>
-                  {'filter'=>'p',
-                    'p'=>'uri,Author,Title,Producer,dc:date,stat:size',
-                    'sort'=>'Producer',
-                    'view'=>'tab'
-                  }})
-
-  def triplrPDF &f
-    yield uri,Content,`pdftotext #{sh}; cat #{docBase.a('.txt').sh}`
-    dateNorm :triplrStdOut,'pdfinfo', &f
-  end
-
-end

data/infod/W/post.rb

@@ -1,9 +0,0 @@
-#watch __FILE__
-class E
-
-  F['view/'+SIOC+'Post']=->g,r{
-    g.map{|u,r|
-      r[Content].do{|c|
-        [r.html]}}}
-
-end

data/infod/W/rdf.rb

@@ -1,32 +0,0 @@
-class E
-
-  def self.requireRDF; %w{n3 rdfa rdfxml turtle}.map{|r|require 'rdf/'+r}; require 'json/ld' end
-
-  def self.renderRDF d,f=:ntriples; E.requireRDF
-    RDF::Writer.for(f).buffer{|w|
-      d.values.each{|r|
-        r.triples{|s,p,o|
-#          puts :s,s,:p,p,:o,o.class,o
-          w << RDF::Statement.new(RDF::URI(s),RDF::URI(p),
-                                  (o.class==Hash||o.class==E) ?
-                                    RDF::URI(o.uri) :
-                                    RDF::Literal(o))}}}
-  rescue Exception => e
-    puts [:RDF,d.keys[0..8],f,e].join ' '
-  end
-
-  def triplrRDFformats t=nil
-    E.requireRDF
-    (t == :rdfa ? RDF::RDFa : RDF)::Reader.
-      open(e ? d : uri, :format => t){|r|
-      r.each_triple{|s,p,o|
-        yield s.to_s, p.to_s,
-        ((o.class==RDF::Node || o.class==RDF::URI) ? o.to_s.E :
-                                                     o.value.do{|v|
-                                                       v.class == String ? v.to_utf8 : v})}}
-    self
-  rescue Exception => e
-    puts [:RDF,uri,e].join ' '
-  end
-
-end

data/infod/W/schema.rb

@@ -1,172 +0,0 @@
-#watch __FILE__
-class E
-  
-  # install schema-cache
-  def E.schemaCache
-    E.schemaDocs.map &:schemaCache
-  end
-  def E.schemaUncache
-    E.schemaDocs.map &:schemaUncache
-  end
-
-  def schemaCache
-    schemaCacheDoc
-    schemaIndexDoc
-  end
-  def schemaUncache
-    schemaUnindexDoc
-    schemaUnlinkSlashURIs
-    schemaUncacheDoc
-  end
-
-  # cache schema docs
-  def schemaCacheDoc
-    if ttl.e || ef.e # already cached?
-      print "c "
-    else
-      ttl.w(`rapper -o turtle #{uri}`) # write turtle
-    end
-  end
-
-  def schemaUncacheDoc
-    ef.deleteNode  # remove JSON
-    ttl.deleteNode # remove Turtle
-  end
-  
-  # index schema docs
-  def schemaIndexDoc
-    c = E.schemaStatistics
-    if (nt.e ||                           # skip already-processed docs
-        ttl.do{|d|d.e && d.size > 256e3}) # skip huge dbpedia/wordnet dumps
-      print "e "
-    else
-      g = graph           # schema graph
-      ttl.deleteNode      # convert Turtle 
-      ef.w g,true if !ef.e# to JSON (for faster loading)
-      roonga "schema"     # index in rroonga
-      m={};      puts uri # statistics graph 
-      g.map{|u,_|         # each resource
-        c[u] &&           # do stats exist?
-        m[u] = {'uri'=>u, '/frequency' => c[u]}} # add to graph
-      nt.w E.renderRDF m  # store N-triples
-      schemaLinkSlashURIs # link "Slash-URI" resources to definer
-    end
-  end
-
-  def schemaUnindexDoc
-    unroonga
-    nt.deleteNode
-  end
-
-  # make slash-URIs resolvable
-  def schemaLinkSlashURIs undo=false
-    return if !ef.e      # cache populated?
-    graph.do{|m|                     # build graph
-      m.map{|u,r|                    # iterate through URIs
-        r[RDFs+'isDefinedBy'].do{|d| # check for DefinedBy attribute
-          t = u.E.ef     # symlink location
-          t.dirname.dir  # container dir of symlink
-          if undo
-            if t.e
-              t.deleteNode # remove link
-              puts "-#{t}"
-            end
-          else
-            unless t.e
-              ef.ln t      # add link
-              puts "#{t} -> #{ef}"
-            end
-          end
-        }}}
-    rescue Exception => e
-    puts e
-  end
-
-  def schemaUnlinkSlashURIs
-    schemaLinkSlashURIs :undo
-  end
-
-  # parse gromgull's BTC statistics
-  def E.schemaStatistics
-    @gromgull ||=
-      (data = '/predicates.2010'.E
-    (puts "curl http://data.whats-your.name/schema/gromgull.gz | zcat > predicates.2010"; exit) unless data.e
-    # occurrence count :: URI -> int
-    usage = {}
-    data.read.each_line{|e|
-      e.match(/(\d+)[^<]+<([^>]+)>/).do{|r|
-        usage[r[2]] = r[1].to_i }}
-    usage)
-  end
-  
-  # parse schema URIs
-  def E.schemaDocs
-    @docs ||=
-      (source = E['http://prefix.cc/popular/all.file.txt']
-       mirror = E['http://localhost/css/i/prefix.cc.txt']
-       schemae = (mirror.e ? mirror : source).
-       read.split("\n").           # each doc
-       grep(/^[^#]/).              # skip commented
-       map{|t|t.split(/\t/)[1].E}) # URI field
-  end
-
-  fn '/schema/GET',->e,r{
-    r.q.merge!({
-                 'graph'=>'roonga',
-                 'context'=>'schema',
-                 'view'=>'search',
-                 'filter'=>'frag',
-                 'v'=>'schema',
-                 'c'=>(r.q.has_key?('q') ? 1000 : 0)
-               })
-    e.response
-  }
-  
-  fn 'u/schema/weight',->d,e{
-    q = e.q['q']
-    d.keys.map{|k| k.class==String && d[k].class==Hash &&
-      (s=0
-       u=k.downcase
-       d[k]['/frequency'][0].to_i.do{|f|f > 0 && (s=s + (Math.log f))}
-       s=s+(u.label.match(q.downcase) && 6 || 
-            q.camelToke.map(&:downcase).map{|c|
-              u.match(c) && 3 || 0}.sum)
-       d[k]['score'] = s )}}
-  
-  fn 'view/schema',->d,e{
-    # score resources on popularity, URL friendliness 
-    Fn 'u/schema/weight',d,e
-    # sort updated response-graph based on score
-    d = d.select{|u,r|
-      r['score'] && r['score'].respond_to?(:>)
-    }.sort_by{|u,r| r['score'] }.reverse
-
-    d.size > 0 &&
-    (# fit values to CSS range
-     scale = 255 / d[0][1]['score'].do{|s|s > 0 && s || 1}
-     [(H.css '/css/schema'),'<table>',
-      d.map{|u,r|
-        # score -> normalized score
-        v = r['score'] * scale
-        # score -> greyscale value
-        f = '%02x' % v
-        # greyscale val -> full CSS
-        style = 'color:#'+(v > 128 ? '000' : 'fff')+';background-color:#'+f+f+f
-        # stats on stats
-        title = r['/frequency'][0].to_s + ' | %.3f'%r['score']
-
-        [{_: :tr, class: :overview, style: style, title: title,
-           c: [{_: :td, class: :identity,
-                 c: u.E.html},
-               {_: :td, class: :label,
-                 c: [{_: :span, class: :stats, c: title},
-                     r[RDFs+'label'][0].do{|l|
-                       {_: :a, href: r.uri,class: :label,c: l}}]}]},
-         {_: :tr, class: :details, style: style, title: title,
-           c: {_: :td, colspan: 2, class: :describe,
-             c: [r[RDFs+'comment'][0].do{|l|
-                   {_: :span,class: :comment, c: l}},' ',
-                 {_: :a, href: '/@'+u.sub('#','%23')+'?filter=frag',
-                   c: '&gt;&gt;'}]}}]},'</table>'])}
-
-end