infod 0.0.3.2 → 0.0.3.3

data/infod/groonga.rb

@@ -1,5 +1,5 @@
 #watch __FILE__
-class E
+class R
 =begin
       gem install rroonga
       a ruby full-text searcher & column-store
@@ -9,12 +9,12 @@ class E
   fn 'view/'+Search+'Groonga',-> d,e {{_: :form, action: '/', c: [{_: :input, name: :q, style: 'font-size:2em'},{_: :input, type: :hidden, name: :graph, value: :groonga}]}}
 
   fn 'protograph/groonga',->d,e,m{
-    E.groonga.do{|ga|
+    R.groonga.do{|ga|
     q = e['q']                               # search expression
     g = e["context"] || d.env['SERVER_NAME'] # context
 
     begin
-      m['/'] = {Type => E[Search+'Groonga']} # add a groonga resource to the graph
+      m['/'] = {Type => R[Search+'Groonga']} # add a groonga resource to the graph
 
       r = (q && !q.empty?) ? ga.select{|r|(r['graph'] == g) & r["content"].match(q)} : # expression if exists
         ga.select{|r| r['graph'] == g}                                                 # or just an ordered set
@@ -24,25 +24,25 @@ class E
       down = r.size > start+c                                        # prev
       up   = !(start<=0)                                             # next
       r = r.sort(e.has_key?('best') ? [["_score"]]:[["time","descending"]],:offset =>start,:limit =>c) # sort
-      r = r.map{|r| r['.uri'].E }                                    # URI
+      r = r.map{|r|r['.uri'].R}                                      # read URI
       (r.map &:docs).flatten.uniq.map{|r|m[r.uri] = r.env e}         # set resource thunks
 
-      m['#'] = {'uri' => '#', RDFs+'member' => r, Type=>E[HTTP+'Response']} # add pagination data to request-graph
+      m['#'] = {'uri' => '#', RDFs+'member' => r, Type=>R[HTTP+'Response']} # add pagination data to request-graph
       m['#'][Prev]={'uri' => '/' + {'graph' => 'groonga', 'q' => q, 'start' => start + c, 'c' => c}.qs} if down
       m['#'][Next]={'uri' => '/' + {'graph' => 'groonga', 'q' => q, 'start' => start - c, 'c' => c}.qs} if up
 
     rescue Groonga::SyntaxError => x
-      m['#'] = {Type => E[COGS+'Exception'], Title => "invalid expr", Content => CGI.escapeHTML(x.message)}
+      m['#'] = {Type => R[COGS+'Exception'], Title => "invalid expr", Content => CGI.escapeHTML(x.message)}
       e['nocache']=true
     end
 
     F['docsID'][m,e]}}
 
-  def E.groonga
+  def R.groonga
     @groonga ||=
       (begin require 'groonga'
-         E['/E/groonga'].groonga
-         Groonga["E"]
+         R['/index/groonga'].groonga
+         Groonga["R"]
        rescue LoadError => e; end)
   end
 
@@ -52,7 +52,7 @@ class E
     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|
+      s.create_table("R",:type => :hash,:key_type => "ShortText"){|t|
         t.short_text "uri"
         t.short_text "graph"
         t.text "content"
@@ -61,25 +61,25 @@ class E
                      :type => :patricia_trie,
                      :key_normalize => true,
                      :default_tokenizer => "TokenBigram"){|t|
-                                  %w{graph content}.map{|c| t.index("E." + c) }}}
+                                  %w{graph content}.map{|c| t.index("R." + c) }}}
   end
   
   # add
   def roonga graph="global", m = self.graph
-   E.groonga.do{|g|
+   R.groonga.do{|g|
     m.map{|u,i|
       r = g[u] || g.add(u) # create or load entry
       r.uri = u            # update data
       r.graph = graph.to_s
       r.content = i.to_s
-      r.time = i[E::Date].do{|t|t[0].to_time}
+      r.time = i[R::Date].do{|t|t[0].to_time}
     }}
     self
   end
   
   # remove
   def unroonga
-    g = E.groonga
+    g = R.groonga
     graph.keys.push(uri).map{|u|g[u].delete}
   end
 

data/infod/histogram.rb

@@ -1,9 +1,9 @@
 #watch __FILE__
-class E
+class R
 
   fn 'view/histogram',->m,e{
-    e.q['a'].do{|a|Fn 'histogram/main',m,e} ||
-    (Fn 'view/facetSelect',m,e)}
+    e.q['a'].do{|a|F['histogram/main'][m,e]} ||
+    (F['view/facetSelect'][m,e])}
 
   fn 'histogram/main',->d,e{
 
@@ -17,10 +17,10 @@ class E
     v = F['view/'+(e.q['hv']||'title')]
 
     # construct histogram bins
-    (Fn 'histogram/bins',d,a,n).do{|h,m|
+    F['histogram/bins'][d,a,n].do{|h,m|
       
       [H.css('/css/hist'),%w{mu hist}.map{|s|H.js('/js/'+s)},
-       (Fn 'histogram',h),{style: "width: 100%; height: 5em"},
+       F['histogram'][h],{style: "width: 100%; height: 5em"},
        h.map{|b,r|
          # skip empty bins
          r.empty? ? ' ' :

data/infod/html.rb

@@ -1,6 +1,5 @@
 #watch __FILE__
 
-# (H) templates
 def H _
   case _
   when Hash
@@ -21,14 +20,14 @@ class H
 
   def H.js a,inline=false
     p = a + '.js'
-    inline ? {_: :script, c: p.E.r} :
+    inline ? {_: :script, c: p.R.r} :
     {_: :script, type: "text/javascript", src: p}
   end
 
   def H.css a,inline=false
     p = a + '.css'
-    inline ? {_: :style, c: p.E.r} :
-    {_: :link, href: p, rel: :stylesheet, type: E::MIME[:css]}
+    inline ? {_: :style, c: p.R.r} :
+    {_: :link, href: p, rel: :stylesheet, type: R::MIME[:css]}
   end
 
   def H.once e,n,*h
@@ -39,17 +38,19 @@ class H
 end
 
 class Array
-  def html v=nil,g=nil
-    map{|e|e.html v,g}.join ' '
+  def cr; intersperse "\n" end
+  def head; self[0] end
+  def html v=nil,g=nil; map{|e|e.html v,g}.join ' ' end
+  def h; join.h end
+  def intersperse i
+    inject([]){|a,b|a << b << i}[0..-2]
   end
+  def tail; self[1..-1] end
+  def justArray; self 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
+  def html *a; self.class end
 end
 
 class String
@@ -69,10 +70,14 @@ end
 
 class Fixnum
   def html e=nil,g=nil; to_s end
+  def max i; i > self ? self : i end
+  def min i; i < self ? self : i end
 end
 
 class Float
   def html e=nil,g=nil; to_s end
+  def max i; i > self ? self : i end
+  def min i; i < self ? self : i end
 end
 
 class TrueClass
@@ -98,10 +103,10 @@ class Hash
       H({_: :table, class: :html, c: map{|k,v|
             unless k == 'uri' && (v.match IsBnode)
               {_: :tr, property: k, c:
-                [k == E::Content ? {_: :td, class: :val, colspan: 2, c: v} :
+                [k == R::Content ? {_: :td, class: :val, colspan: 2, c: v} :
                  [
-                  ({_: :td, c: [{_: :a, name: k, href: (k == 'uri' ? v : k), c: k.to_s.abbrURI}], class: :key} if key),
-                  {_: :td, c: k == 'uri' ? v.E.do{|u| {_: :a, id: u, href: u.url, c: v}} : v.html(e,g), class: :val},
+                  ({_: :td, c: [{_: :a, name: k, href: (k == 'uri' ? (v.R.docBase.localURL e)+'?graph=edit' : k), c: k.to_s.abbrURI}], class: :key} if key),
+                  {_: :td, c: k == 'uri' ? v.R.do{|u| {_: :a, id: u, href: u.url, c: v}} : v.html(e,g), class: :val},
                  ]]}
             end
           }})
@@ -109,34 +114,31 @@ class Hash
   end
 end
 
-class E
+class R
 
   def html *a
     url.href
   end
 
-  fn 'view',->d,e{
+  F['view']=->d,e{
     d.values.select{|r|
       !r.has_key?('uri') || # URI field missing
       !r.uri.match(IsBnode) # blank node
       true
     }.
     sort_by{|r| r[Date].do{|d| d[0].to_s} || ''}.reverse.
-    map{|r| Fn 'view/select',r,e,d}}
+    map{|r| F['view/select'][r,e,d]}}
 
-  fn 'view/base',->d,e,k=true,graph=nil{
+  F['view/base']=->d,e,k=true,graph=nil{
     [H.once(e,'base',H.css('/css/html')),
      d.values.map{|v|v.html e,graph,k}]}
 
-  fn 'view/select',->r,e,d{
+  F['view/select']=->r,e,d=nil{
     graph = {r.uri => r}
     view = nil
     if r.class == Hash
       (r[Type].class==Array ? r[Type] : [r[Type]]).do{|types|
-        views = types.map{|t|
-          # discard non-URIs
-          t.uri if t.respond_to? :uri}.
-        compact.map{|t|
+        views = types.map(&:maybeURI).compact.map{|t|
           subtype = t
           type = subtype.split(/\//)[-2]
           [F['view/' + subtype],
@@ -150,12 +152,6 @@ class E
       view[graph,e]
     end}
 
-  # enumerate available views
-  fn 'view/?',->d,e{
-    F.keys.grep(/^view\/(?!application|text\/x-)/).map{|v|
-      v = v[5..-1] # eat selector
-      [{_: :a, href: e['REQUEST_PATH']+e.q.merge({'view'=>v}).qs, c: v},"<br>\n"]}}
-
   def triplrBlob
     glob.select(&:f).do{|f|f.map{|r|
         yield r.uri,Type,E('blob')
@@ -165,7 +161,6 @@ class E
     yield uri,Content,(f && read).do{|r|enc ? r.force_encoding(enc).to_utf8 : r}.hrefs
   end
 
-  require 'nokogiri'
   def nokogiri;  Nokogiri::HTML.parse read end
 
   F['HTMLbody'] = -> b {
@@ -179,6 +174,14 @@ class E
     h.to_s
   }
 
+  fn 'view/'+HTTP+'Response',->d,e{
+    d['#'].do{|u|
+      [u[Prev].do{|p|{_: :a, rel: :prev, href: p.uri, c: '&larr;',style: 'color:#fff;background-color:#000;font-size:2.4em;float:left;clear:both'}},
+       u[Next].do{|n|{_: :a, rel: :next, href: n.uri, c: '&rarr;',style: 'color:#000;background-color:#fff;font-size:2.4em;float:right;clear:both;'}},
+       {_: :a, rel: :nofollow, href: e['REQUEST_PATH'].sub(/\.html$/,'') + e.q.merge({'view'=>'data'}).qs, # data browser
+         c: {_: :img, src: '/css/misc/cube.png', style: 'height:2em;background-color:white;padding:.54em;border-radius:1em;margin:.2em'}},
+       (H.js '/js/pager'),(H.once e,:mu,(H.js '/js/mu'))]}} # (n)ext (p)rev key binding
+
   def contentURIresolve *f
     send(*f){|s,p,o|
       yield s, p, p == Content ?
@@ -210,11 +213,11 @@ class E
      {_: :a, href: '#', c: '-', id: :hideP},
      {_: :a, href: '#', c: '+', id: :showP},
      {_: :span, id: 'properties',
-       c: E.graphProperties(d).map{|k|
+       c: R.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)]}
+     F['view/'+(e.q['pv']||'table')][d,e]]}
 
   # table-cell placement on sparse matrix of rows/columns
   # cal.rb contains an example usage
@@ -223,7 +226,7 @@ class E
     if layout
       [H.once(e,'table',H.css('/css/table')),
        {_: :table, c:
-         {_: :tbody, c: (Fn 'table/'+layout,d).do{|t|
+         {_: :tbody, c: F['table/'+layout][d].do{|t|
              rx = t.keys.max
              rm = t.keys.min
              c = t.values.map(&:keys)
@@ -234,15 +237,15 @@ class E
                  t[r].do{|r|
                    (cm..cx).map{|c|
                      r[c].do{|c|
-                       {_: :td, class: :cell, c:(Fn 'view/'+(a||e.q['cellview']||'title'),c,e)}
-                     }||{_: :td}}}}} || ''
-           }}}]
+                       {_: :td, class: :cell, c:F['view/'+(a||e.q['cellview']||'title')][c,e]}} ||
+                     {_: :td}}}}} ||
+             '' }}}]
     else
       "table= layout arg required"
     end}
 
   fn 'view/table',->g,e{
-    keys = E.graphProperties g
+    keys = R.graphProperties g
     v = g.values
     e.q['sort'].do{|p|
       p = p.expand
@@ -253,6 +256,6 @@ class E
     [H.css('/css/table'),
      {_: :table,:class => :tab,
        c: [{_: :tr, c: keys.map{|k|{_: :th, class: :label, property: k, c: k.abbrURI}}},
-           v.map{|e|{_: :tr, about: e.uri, c: keys.map{|k| {_: :td, property: k, c: k=='uri' ? e.E.html : e[k].html}}}}]}]}
+           v.map{|e|{_: :tr, about: e.uri, c: keys.map{|k| {_: :td, property: k, c: k=='uri' ? e.R.html : e[k].html}}}}]}]}
 
 end

data/infod/image.rb

@@ -1,8 +1,8 @@
 #watch __FILE__
-class E
+class R
 
   def triplrImage &f
-    yield uri,Type,E[DC+'Image']
+    yield uri,Type,R[DC+'Image']
     triplrStdOut 'exiftool', EXIF, &f
   end
 
@@ -12,7 +12,7 @@ class E
       size = r.q['px'].to_i.min(8).max(4096)
       stat = i.node.stat
       id = [stat.ino,stat.mtime,size].h.dive
-      path = E['/E/image/'+id+'.png']
+      path = R['/cache/thumbnail/'+id+'.png']
       if !path.e
         path.dirname.mk
         if i.mimeP.match(/^video/)
@@ -28,7 +28,7 @@ class E
 
   fn 'view/img',->i,_{
     [i.values.select{|v|v.class==Hash}.map{|i|
-       i[Type] && (i[Type].class==Array ? i[Type] : [i[Type]]).map{|t|t.respond_to?(:uri) && t.uri}.include?(DC+'Image') &&
+       i[Type] && (i[Type].class==Array ? i[Type] : [i[Type]]).map(&:maybeURI).include?(DC+'Image') &&
        [{_: :a, href: i.url, c: {_: :img, style:'float:left;max-width:61.8%', src: i.url}},
         i.html]},
      (H.css '/css/img')]}
@@ -70,9 +70,7 @@ class E
 
         # check object URIs for image extension
         (v.respond_to?(:values) &&
-         v.values.flatten.map{|v|
-           v.respond_to?(:uri) && v.uri
-         }.select(&x))
+         v.values.flatten.map(&:maybeURI).select(&x))
 
        ].flatten.uniq.compact.map{|s|
          # view 
@@ -85,8 +83,8 @@ class E
        (seen[i[:uri]] = true
         i[:c].())}]}
 
-  def E.c; '#%06x' % rand(16777216) end
-  def E.cs; '#%02x%02x%02x' % F['color/hsv2rgb'][rand*6,1,1] end
+  def R.c; '#%06x' % rand(16777216) end
+  def R.cs; '#%02x%02x%02x' % F['color/hsv2rgb'][rand*6,1,1] end
 
   fn 'color/hsv2rgb',->h,s,v{
     i = h.floor

data/infod/index.rb

@@ -1,24 +1,12 @@
 #watch __FILE__
-class E
+class R
 
   # POSIX-fs based index of triples
   # 
 
-  # index a triple
   def index p,o
-    p = p.E
-    indexEdit p, (o.class == E ? o : p.literal(o)), nil
-  end
-
-  # index a triple - no type-normalization
-  # we jsut rotate them, use existing k/v store and set @noIndex to stop looping infinitely to index the index..
-  def indexEdit p,o,a
-    return if @noIndex
-    p.pIndex.noIndex[o,self,a]
-  end
-  def noIndex
-    @noIndex = 1
-    self
+    return unless o.class == R
+    p.R.indexPath.setFs o,self,false,false
   end
 
   # reachable graph along named predicate
@@ -28,10 +16,10 @@ class E
     v[uri] = true # visited mark
 
     rel = g[uri].do{|s|s[p]} ||[]
-    rev = (p.E.po self) ||[]
+    rev = (p.R.po self) ||[]
 
     rel.concat(rev).map{|r|
-      v[r.uri] || (r.E.walk p,g,v)}
+      v[r.uri] || (r.R.walk p,g,v)}
 
     g
   end
@@ -40,51 +28,34 @@ class E
     global = !r.has_key?('local')
     p = global ? d.pathSegment : d
     loc = global ? '' : '&local'
-    c = ((r['c'].do{|c|c.to_i} || 12) + 1).max(128) # an extra for next-page pointer
+    c = ((r['c'].do{|c|c.to_i} || 12) + 1).max(1024) # an extra for next-page pointer
     o = r['d'] =~ /^a/ ? :asc : :desc            # direction
-    (p.take c, o, r['offset'].do{|o|o.E}).do{|s| # take subtree
+    (p.take c, o, r['offset'].do{|o|o.R}).do{|s| # take subtree
       first, last = s[0], s.size > 1 && s.pop
       desc, asc = o == :asc ? [first,last] : [last,first]
       u = m['#']
-      u[Type] = E[HTTP+'Response']
+      u[Type] = R[HTTP+'Response']
       u[Prev] = {'uri' => d.uri + "?set=depth&c=#{c-1}&d=desc#{loc}&offset=" + (URI.escape desc.uri)} if desc
       u[Next] = {'uri' => d.uri + "?set=depth&c=#{c-1}&d=asc#{loc}&offset=" + (URI.escape asc.uri)} if asc
       s }}
 
-  def pIndex
-    shorten.prependURI '/index/'
-  end
-
-  def poIndex o
-    pIndex.concatURI o
-  end
- 
-  # predicate+object pair lookup
   def po o
-    pIndex[o.class == E ? o : literal(o)]
+    indexPath.predicate o, false
   end
 
-  def rangeP size=8, dir=:desc, offset=nil, object=nil
-    pIndex.subtree(size,dir,offset).map &:ro
-  end
-
-  def rangePO n=8,d=:desc,s=nil,o
-    poIndex(o).subtree(n,d,s).map &:ro
-  end
-
-  def subtree *a
-    u.take *a
+  def indexPath
+    shorten.prependURI '/index/'
   end
 
   def take *a
-    no.take(*a).map &:E
+    node.take(*a).map &:R
   end
 
   def randomLeaf
     c.empty? && self || c.r.randomLeaf
   end
 
-  def E.graphProperties g
+  def R.graphProperties g
     g.values.select{|v|v.respond_to? :keys}.map(&:keys).flatten.uniq
   end
 
@@ -108,7 +79,6 @@ class Pathname
       nodes.sort_by(&:to_s).send(v).each{|n|
         ns = n.to_s
         return if 0 >= count
-
         (ok || # already in-range
          !offset || # no offset required
          (sz = [ns,offset].map(&:size).min