infod 0.0.1 → 0.0.2

data/infod/Es/glob.rb

@@ -0,0 +1,22 @@
+class E
+
+  # glob :: pattern -> [E]
+  def glob p=""
+    (Pathname.glob d + p).map &:E
+  end
+
+  fn 'set/glob',->d,e=nil,_=nil{
+    [d,d.pathSegment].compact.map(&:glob).flatten[0..3e3]}
+
+  fn 'req/randomFile',->e,r{
+    g = F['set/glob'][e]
+    !g.empty? ? [302, {Location: g.random.uri}, []] : [404]}
+
+  def docs
+    doc = self if e # directly-referenced doc
+    docs = docBase.glob ".{e,html,n3,nt,owl,rdf,ttl}" # basename-sharing docs
+    dir = (d? && uri[-1]=='/' && uri.size>1) ? c : [] # trailing slash descends
+    [doc,docs,dir].flatten.compact
+  end
+
+end

data/infod/Es/grep.rb

@@ -0,0 +1,61 @@
+#watch __FILE__
+class E
+
+  fn 'set/grep',->e,q,m{
+    q['i'] ||= true # normal people want case-insensitive, i think - comment to unstick
+    q['q'].do{|query|
+      [e,e.pathSegment].compact.select(&:e).map{|e|
+        grep = "grep -rl#{q.has_key?('i') && 'i'} #{query.sh} #{e.sh}"  # ;puts grep
+        `#{grep}`}.map{|r|r.lines.to_a.map{|r|r.chomp.unpathFs}}.flatten}}
+
+  fn 'view/grep',->d,e{
+    w = e.q['q']
+    if w
+      # words supplied in query
+      w = w.scan(/[\w]+/).map(&:downcase).uniq
+
+      # word index
+      c={}
+      w.each_with_index{|w,i|
+        c[w] = i }
+
+      # OR pattern
+      a = /(#{w.join '|'})/i
+      # sequential pattern
+      p = /#{w.join '.*'}/i
+
+      [H.css('/css/search'), H.css('/css/grep'),
+       F['view/search/form'][e.q,e],
+       {_: :style, c: c.values.map{|i|
+           # word color
+           b = rand(16777216)
+           # keep text contrasty
+           f = b > 8388608 ? :black : :white
+
+           # word CSS
+           ".w#{i} {background-color: #{'#%06x' % b}; color: #{f}}\n"}},
+
+       # each resource
+       d.map{|u,r|
+         # model to text/plain
+         l = F[Render+'text/plain'][{u => r},e].gsub(/<[^>]*>/,'').lines
+
+         # try sequential match
+         g = l.grep p
+         # try OR match
+         g = l.grep a if g.empty?                           
+
+         # match?
+         !g.empty? &&                                       
+         [# link to resource
+          r.E.do{|e|{_: :a, href: e.url, c: e}}, '<br>',
+          # show 3 matches per resource
+          [g[-1*(g.size.max 3)..-1].map{|l|   
+             # exerpt
+             l[0..403].gsub(a){|g|
+               H({_: :span, class: "w w#{c[g.downcase]}",c: g})}
+           },"<br>"]]},
+       {_: :a, class: :down, href: e['REQUEST_PATH']+e.q.except('view').qs, style: "background-color: #{E.cs}",c: '&darr;'}]
+    end }
+
+end

data/infod/Es/groonga.rb

@@ -1,10 +1,51 @@
 #watch __FILE__
 class E
-
+#  ruby search-engine & column-store
 #  http://groonga.org/ http://ranguba.org/
-#  https://github.com/groonga/groonga
-#  https://github.com/ranguba/rroonga
-  # default DB
+
+  # query
+  fn 'protograph/roonga',->d,e,m{
+    ga = E.groonga
+
+    # search expression
+    q = e['q']
+
+    # context
+    g = e["context"] || d.env['SERVER_NAME']
+
+    # exec expression
+    r = q ? ga.select{|r|(r['graph'] == g) & r["content"].match(q)} : # expression if exists
+            ga.select{|r| r['graph'] == g} # ordered set (index date-range)
+
+    # offset, size
+    start = e['start'].do{|c| c.to_i.max(r.size - 1).min 0 } || 0
+    c = (e['c']||e['count']).do{|c|c.to_i.max(10000).min(0)} || 8
+
+    # are further results traversible?
+    down = r.size > start+c
+    up   = !(start<=0)
+
+    # sort results
+    r = r.sort(e.has_key?('score') ? [["_score"]] : [["time", "descending"]],:offset => start,:limit => c)
+
+    # pagination resources
+    m['prev']={'uri' => 'prev','url' => '/search','start' => start + c, 'c' => c} if down
+    m['next']={'uri' => 'next','url' => '/search','start' => start - c, 'c' => c} if up
+
+    # search-result identifiers
+    r = r.map{|r| r['.uri'].E }
+
+    # fragment identifiers
+    m['frag'] = {'uri' => 'frag', 'res' => r}
+
+    # containing documents
+    r.map(&:docs).flatten.uniq.map{|r| m[r.uri] = r.env e}
+
+    # no 404 on 0 results - searchbox view
+    m['/s']={'uri'=>'/s'} if m.empty?
+
+    F['docsID'][m]}
+
   def E.groonga
     @groonga ||= (require 'groonga'
                   E['/E/groonga'].groonga
@@ -14,7 +55,7 @@ class E
   # load or create groongaDB at URI
   def groonga
     return Groonga::Database.open d if e # open db
-    dirname.dir                          # create containing dir
+    dirname.mk                           # create containing dir
     Groonga::Database.create(:path => d) # create db
     Groonga::Schema.define{|s|           # create schema
       s.create_table("E",:type => :hash,:key_type => "ShortText"){|t|
@@ -37,11 +78,9 @@ class E
       r.uri = u            # update data
       r.graph = graph.to_s
       r.content = i.to_s
-      r.time = i[E::Date][0].to_time
+      r.time = i[E::Date].do{|t|t[0].to_time}
     }
     self
-  rescue Exception => x
-    $stderr.puts x,x.message
   end
   
   # remove
@@ -50,52 +89,4 @@ class E
     graph.keys.push(uri).map{|u|g[u].delete}
   end
 
-  # query
-  fn 'graph/roonga',->d,e,m{
-
-    # db
-    ga = E.groonga
-
-    # search expression
-    q = e['q']
-
-    # context
-    g = e["context"] || d.env['SERVER_NAME']
-
-    # offset
-    start = e['start'].do{|c|c.to_i} || 0
-
-    # number of results
-    c = e['c'].do{|c|c.to_i.max(1000).min(0)} || 8
-
-    # exec expression
-    r = q ? ga.select{|r|(r['graph'] == g) & r["content"].match(q)} : # expression if exists
-            ga.select{|r| r['graph'] == g} # ordered set (index date-range)
-
-    # are further results traversible?
-    down = r.size > start+c
-    up   = !(start<=0)
-
-    # sort results
-    r = r.sort(e.has_key?('score') ? [["_score"]] : [["time", "descending"]],:offset => start,:limit => c)
-
-    # pagination resources
-    m['prev']={'uri' => 'prev','url' => '/search','start' => start + c, 'c' => c} if down
-    m['next']={'uri' => 'next','url' => '/search','start' => start - c, 'c' => c} if up
-
-    # search-result identifiers
-    r = r.map{|r| r['.uri'].E }
-
-    # fragment identifiers
-    m['frag'] = {'uri' => 'frag', 'res' => r}
-
-    # containing documents
-    r.map(&:docs).flatten.uniq.map{|r| m[r.uri] = r.env e}
-
-    # no 404 on 0 results - searchbox view
-    m['/s']={'uri'=>'/s'} if m.empty?
-
-    m # result set
-  }
-  
 end

data/infod/Es/html.rb

@@ -0,0 +1,271 @@
+#watch __FILE__
+
+def H _
+  # Ruby object-literal syntax as HTML constructors
+  case _
+  when Hash then
+    '<'+(_[:_]||:div).to_s+(_.keys-[:_,:c]).map{|a|
+      ' '+a.to_s+'='+"'"+
+      _[a].to_s.hsub({"'"=>'%27',
+                       '>'=>'%3E',
+                       '<'=>'%3C'})+"'"}.join+'>'+
+      (_[:c] ? (H _[:c]) : '')+
+      (_[:_] == :link ? '' : ('</'+(_[:_]||:div).to_s+'>'))
+  when Array then
+    _.map{|n|H n}.join
+  else
+    _.to_s
+  end
+end
+
+class H
+
+  def H.[] h; H h end
+
+  def H.js a,inline=false
+    p=a+'.js'
+    inline ? {_: :script, c: p.E.r} :
+    {_: :script, type: "text/javascript", src: p}
+  end
+
+  def H.once e,n,*h
+    return if e[n]
+    e[n]=true
+    h
+  end
+end
+
+class Array
+  def html table=true
+    map(&:html).join ' '
+  end
+end
+
+class Object
+  def html *a
+    name = self.class
+    href = "https://duckduckgo.com/?q=ruby+#{name}"
+    "<a href=#{href}><b>#{name}</b></a>"
+  end
+end
+
+class String
+  def br
+    gsub(/\n/,"<br>\n")
+  end
+  def href name=nil
+    '<a href="'+self+'">'+(name||(Fn 'abbrURI',self))+'</a>'
+  end
+  def html
+    if match /\A(\/|http)[\S]+\Z/
+      href
+    else
+      self
+    end
+  rescue
+    self
+  end
+end
+
+class Fixnum
+  def html; H({_: :input, type: :number, value: to_s}) end
+end
+
+class Float
+  def html; H({_: :input, type: :number, value: to_s}) end
+end
+
+class TrueClass
+  def html; H({_: :input, type: :checkbox, title: :True, checked: :checked}) end
+end
+
+class FalseClass
+  def html; H({_: :input, type: :checkbox, title: :False}) end
+end
+
+class Hash
+  def html
+    H({_: :table, class: :html, c: 
+        map{|k,v|
+          {_: :tr, property: k, c:
+            [{_: :td,
+               c: {_: :a, name: k,
+                 href: (k == 'uri' ? v : k),
+                 c: (Fn 'abbrURI',k)}, class: :key},
+             {_: :td,
+               c: (case k
+                   when E::Content
+                     {_: :pre, style: "white-space: pre-wrap", c: v}
+                   when 'uri'
+                     u = v.E
+                     {_: :a, id: u, href: u.url, c: v}
+                   else
+                     v.html
+                   end), class: :val}].cr}}.cr})
+  end
+end
+
+class E
+  def html name=nil,l=false
+      (l ? url : uri).href name
+   end
+
+  def link
+    html '#',true
+  end
+
+  fn 'abbrURI',->u{
+    u.to_s.sub(/(?<scheme>[a-z]+:\/\/)?(?<abbr>.*?)(?<frag>[^#\/]*)$/,
+     '<div class="abbr"><div class="scheme">\k<scheme></div>\k<abbr></div><div class="frag">\k<frag></div>')}
+
+  fn 'head',->d,e{
+    [{_: :title, c: e.uri},
+     (Fn 'head.formats',e),
+     (Fn 'head.icon')].cr}
+
+  fn 'head.formats',->e{
+    formats = %w{text/plain text/n3 application/json+ld}
+    formats.map{|f|
+      {_: :link, rel: :meta, type: f,
+        href:'http://' + e['SERVER_NAME'] + e['REQUEST_PATH'] + e.q.merge({'format' => f}).qs}}.cr}
+
+  fn 'head.icon',->{{_: :link, href:'/css/misc/favicon.ico', rel: :icon}}
+
+  fn 'view/select',->d,e{#(Fn 'view/divine/set',d,e)||
+                  (Fn 'view/divine/files',d,e)||
+   d.values.map{|r|Fn 'view/divine/resource',r,e}}
+
+  # default view
+  F['view'] = F['view/select']
+
+  fn 'view/base',->d,e{
+    [H.once(e,'base',H.css('/css/html')),
+     d.values.map(&:html)]}
+
+  # select a view based on RDF-type majority
+  fn 'view/divine/set',->d,e{
+    # we'd be throwing away oddball resources to select one view for all of them
+    # but maybe you have a specific reason to
+    # inbuilt views support calling on set or per-resource basis, via "once" spec of set-wide components
+    # so views are selected per-resource unless you hack here..
+  }
+
+  fn 'view/divine/files',->d,e{
+    d.values.map{|e|e.E.base}.do{|b|
+      s = b.size.to_f # size of set
+      t = 0.42        # threshold, max of 0.5 as file and RDF resource are separate
+      if b.grep(/^msg\./).size / s > t
+        Fn 'view/threads',d,e
+
+      elsif b.grep(AudioFile).size / s > t
+        Fn 'view/audio', d,e
+
+      elsif b.grep(/(gif|jpe?g|png)$/i).size / s > t
+        Fn 'view/th', d,e
+
+      elsif b.grep(/\.log$/).size / s > t
+        Fn 'view/chat', d,e
+
+      else false
+      end}}
+
+  # select a view for a RDF resource
+  fn 'view/divine/resource',->r,e{
+    graph = {r.uri => r}
+    view = F['view/base']
+    # find types, skipping malformed/missing info
+    if r.class == Hash
+      r[Type].do{|types|
+        views = types.map{|t|
+          # discard non-URIs
+          t.uri if t.respond_to? :uri}.
+        compact.map{|t|
+          subtype = t
+          type = subtype.split(/\//)[-2]
+          [F['view/' + subtype],
+           F['view/' + type]]}.flatten.compact
+        view = views[0] unless views.empty?}
+    end
+    view[graph,e]}
+
+  # multiple views (comma-separated)
+  fn 'view/multi',->d,e{
+    e.q['views'].split(',').map{|v|
+      F['view/'+v].do{|f|f[d,e]}}}
+
+  def triplrBlob
+    glob.select(&:f).do{|f|f.map{|r|
+        yield r.uri,Type,E('blob')
+        yield r.uri,Content,r.r}} end
+
+  def triplrHref enc=nil
+    puts "triplrHref #{uri} #{d}"
+    yield uri,Content,(f && read).do{|r|enc ? r.force_encoding(enc).to_utf8 : r}.hrefs
+  end
+
+  fn Render+'text/html',->d,e{
+    v = e.q['view'].to_s
+    h = F['head/'+v] || F['head'] 
+    v = F['view/'+v] || F['view']
+    H(e.q.has_key?('un') ? v[d,e] :
+      ['<!DOCTYPE html>',
+       {_: :html,
+         c: [{_: :head,
+               c: ['<meta charset="utf-8" />',
+                   h[d,e]]},
+             {_: :body, c: v[d,e]}].cr}].cr)}
+
+  
+  # property-selector toolbar (requires RDFa views)
+  fn 'view/p',->d,e{
+    [H.once(e,'property.toolbar',H.once(e,'p',(H.once e,:mu,H.js('/js/mu')),
+     H.js('/js/p'),
+     H.css('/css/table')),
+     {_: :a, href: '#', c: '-', id: :hideP},
+     {_: :a, href: '#', c: '+', id: :showP},
+     {_: :span, id: 'properties',
+       c: E.graphProperties(d).map{|k|
+         {_: :a, class: :n, href: k, c: k.label+' '}}},
+       {_: :style, id: :pS},
+       {_: :style, id: :lS}),
+     (Fn 'view/'+(e.q['pv']||'table'),d,e)]}
+
+  # table-cell placement on sparse matrix of rows/columns
+  # cal.rb contains an example usage
+  fn 'view/t',->d,e,l=nil,a=nil{
+    [H.once(e,'table',H.css('/css/table')),
+     {_: :table, c:
+     {_: :tbody, c: (Fn 'table/'+(l||e.q['table']),d).do{|t|
+          rx = t.keys.max
+          rm = t.keys.min
+          c = t.values.map(&:keys)
+          cm = c.map(&:min).min
+          cx = c.map(&:max).max
+          (rm..rx).map{|r|
+            {_: :tr, c: 
+              t[r].do{|r|
+                (cm..cx).map{|c|
+                  r[c].do{|c|
+                    {_: :td, class: :cell, c:(Fn 'view/'+(a||e.q['cellview']),c,e)}
+                    }||{_: :td}}}}}}}}]}
+
+  fn 'view/table',->i,e{[H.css('/css/table'),(Fn 'table',i.values,e)]}
+
+  fn 'table',->es,q=nil{
+    ks = {} # predicate table
+    es.map{|e|e.respond_to?(:keys) &&
+              e.keys.map{|k|ks[k]=true}}
+    keys = ks.keys
+    keys.empty? ? es.html :
+    H({_: :table,:class => :tab,
+        c: [{_: :tr,
+              c: keys.map{|k|
+                {_: :th, class: :label, property: k,
+                  c: q ? {_: :a,
+                    href: q['REQUEST_PATH']+q.q.except('reverse').merge({'sort'=>k}).merge(q.q.member?('reverse') ? {} : {'reverse'=>true}).qs,
+                    c: (Fn 'abbrURI',k)} : k}}},
+            *es.map{|e|
+              {_: :tr, about: e.uri, c:
+                keys.map{|k| {_: :td, property: k, c: e[k].send(k=='uri' ? :href : :html)} }}}]})}
+
+end