infod 0.0.3.1 → 0.0.3.2

data/infod/groonga.rb

@@ -1,66 +1,52 @@
 #watch __FILE__
 class E
+=begin
+      gem install rroonga
+      a ruby full-text searcher & column-store
+      http://groonga.org/
+=end
+  
+  fn 'view/'+Search+'Groonga',-> d,e {{_: :form, action: '/', c: [{_: :input, name: :q, style: 'font-size:2em'},{_: :input, type: :hidden, name: :graph, value: :groonga}]}}
 
-#  adaptor for ruby text-search-engine & column-store
-#  http://groonga.org/ http://ranguba.org/
-
-  # query
-  fn 'protograph/roonga',->d,e,m{
-
-    # groonga engine
-    ga = E.groonga
-
-    # search expression
-    q = e['q']
-
-    # context
-    g = e["context"] || d.env['SERVER_NAME']
+  fn 'protograph/groonga',->d,e,m{
+    E.groonga.do{|ga|
+    q = e['q']                               # search expression
+    g = e["context"] || d.env['SERVER_NAME'] # context
 
     begin
-      # execute
-      r = (q && !q.empty?) ? 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
+      m['/'] = {Type => E[Search+'Groonga']} # add a groonga resource to the graph
 
-      # 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)
+      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
 
-      # results -> graph
-      r = r.map{|r| r['.uri'].E }
-      (r.map &:docs).flatten.uniq.map{|r| m[r.uri] = r.env e}
+      start = e['start'].do{|c| c.to_i.max(r.size - 1).min 0 } || 0  # offset
+      c = (e['c']||e['count']).do{|c|c.to_i.max(10000).min(0)} || 16 # count
+      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.map &:docs).flatten.uniq.map{|r|m[r.uri] = r.env e}         # set resource thunks
 
-      m['#'] = {'uri' => '#',
-        RDFs+'member' => r,
-        Type=>E[HTTP+'Response']}
-      m['#'][Prev]={'uri' => '/search' + {'q' => q, 'start' => start + c, 'c' => c}.qs} if down
-      m['#'][Next]={'uri' => '/search' + {'q' => q, 'start' => start - c, 'c' => c}.qs} if up
-      m['/search'] = {Type => E[Search]}
+      m['#'] = {'uri' => '#', RDFs+'member' => r, Type=>E[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['/search'] = {Type => E[Search]}
-      m['#'] = {
-        Type => E[COGS+'Exception'],
-        Title => "bad expression",
-        Content => CGI.escapeHTML(x.message)}
+      m['#'] = {Type => E[COGS+'Exception'], Title => "invalid expr", Content => CGI.escapeHTML(x.message)}
       e['nocache']=true
     end
 
-    F['docsID'][m,e]}
+    F['docsID'][m,e]}}
 
   def E.groonga
-    @groonga ||= (require 'groonga'
-                  E['/E/groonga'].groonga
-                  Groonga["E"] )
+    @groonga ||=
+      (begin require 'groonga'
+         E['/E/groonga'].groonga
+         Groonga["E"]
+       rescue LoadError => e; end)
   end
 
-  # load or create groongaDB at URI
+  # init groongaDB
   def groonga
     return Groonga::Database.open d if e # open db
     dirname.mk                           # create containing dir
@@ -78,17 +64,16 @@ class E
                                   %w{graph content}.map{|c| t.index("E." + c) }}}
   end
   
-  # index resource 
+  # add
   def roonga graph="global", m = self.graph
-#    puts "text #{graph} < #{uri} #{m.keys.join ' '}"
-    g = E.groonga          # db
+   E.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}
-    }
+    }}
     self
   end
   

data/infod/html.rb

@@ -1,6 +1,6 @@
 #watch __FILE__
 
-# Ruby to HTML
+# (H) templates
 def H _
   case _
   when Hash
@@ -20,11 +20,17 @@ class H
   def H.[] h; H h end
 
   def H.js a,inline=false
-    p=a+'.js'
+    p = a + '.js'
     inline ? {_: :script, c: p.E.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]}
+  end
+
   def H.once e,n,*h
     return if e[n]
     e[n]=true
@@ -33,8 +39,8 @@ class H
 end
 
 class Array
-  def html v=nil
-    map{|e|e.html v}.join ' '
+  def html v=nil,g=nil
+    map{|e|e.html v,g}.join ' '
   end
 end
 
@@ -54,49 +60,52 @@ class String
     '<a href="'+self+'">' + (name||abbrURI) + '</a>'
   end
   def abbrURI
-    sub /(?<scheme>[a-z]+:\/\/)?(?<abbr>.*?)(?<frag>[^#\/]*)$/,
-    '<span class="abbr"><span class="scheme">\k<scheme></span>\k<abbr></span><span class="frag">\k<frag></span>'
+    sub /(?<scheme>[a-z]+:\/\/)?(?<abbr>.*?)(?<frag>[^#\/]+)\/?$/,'<span class="abbr"><span class="scheme">\k<scheme></span>\k<abbr></span><span class="frag">\k<frag></span>'
   end
-  def html e=nil
-# CGI.escapeHTML self
+  def html e=nil,g=nil
     self
   end
 end
 
 class Fixnum
-  def html e=nil; to_s end
+  def html e=nil,g=nil; to_s end
 end
 
 class Float
-  def html e=nil; to_s end
+  def html e=nil,g=nil; to_s end
 end
 
 class TrueClass
-  def html e=nil; H({_: :input, type: :checkbox, title: :True, checked: :checked}) end
+  def html e=nil,g=nil; H({_: :input, type: :checkbox, title: :True, checked: :checked}) end
 end
 
 class FalseClass
-  def html e=nil; H({_: :input, type: :checkbox, title: :False}) end
+  def html e=nil,g=nil; H({_: :input, type: :checkbox, title: :False}) end
 end
 
+IsBnode = /^_:/
+
 class Hash
-  def html e={'SERVER_NAME'=>'localhost'}, key=true
-    (keys.size == 1 && has_key?('uri')) ? url.href : 
-      H({_: :table, class: :html, c:
-        map{|k,v|
-          {_: :tr, property: k, c:
-           [({_: :td,
-               c: [{_: :a, name: k, href: (k == 'uri' ? v : k), c: k.to_s.abbrURI}], class: :key} if key),
-             {_: :td,
-               c: (case k
-                   when E::Content
-                     v
-                   when 'uri'
-                     u = v.E
-                     {_: :a, id: u, href: u.url, c: v}
-                   else
-                     v.html e
-                   end), class: :val}]}}})
+  def html e={'SERVER_NAME'=>'localhost'}, g={}, key=true
+    if keys.size == 1 && has_key?('uri')
+      if uri.match IsBnode
+        g[uri].do{|r|
+          r.html e,g,key } || uri.href
+      else
+        uri.href
+      end
+    else
+      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} :
+                 [
+                  ({_: :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},
+                 ]]}
+            end
+          }})
+    end
   end
 end
 
@@ -107,17 +116,21 @@ class E
   end
 
   fn 'view',->d,e{
-    d.values.sort_by{|r| r[Date].do{|d| d[0].to_s} || ''}.reverse.
-    map{|r| Fn 'view/select',r,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}}
 
-  fn 'view/base',->d,e,k=true{
+  fn 'view/base',->d,e,k=true,graph=nil{
     [H.once(e,'base',H.css('/css/html')),
-     d.values.map{|v|v.html e,k}]}
+     d.values.map{|v|v.html e,graph,k}]}
 
-  fn 'view/select',->r,e{
+  fn 'view/select',->r,e,d{
     graph = {r.uri => r}
-    view = F['view/base']
-    # find types, skipping malformed/missing info
+    view = nil
     if r.class == Hash
       (r[Type].class==Array ? r[Type] : [r[Type]]).do{|types|
         views = types.map{|t|
@@ -131,13 +144,11 @@ class E
         flatten.compact
         view = views[0] unless views.empty?}
     end
-    view[graph,e]}
-
-  # multiple views (comma-separated)
-  fn 'view/multi',->d,e{
-    e.q['views'].do{|vs|
-      vs.split(',').map{|v|
-        F['view/'+v].do{|f|f[d,e]}}}}
+    if !view # default view
+      F['view/base'][graph,e,true,d]
+    else
+      view[graph,e]
+    end}
 
   # enumerate available views
   fn 'view/?',->d,e{
@@ -154,10 +165,24 @@ 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 {
+    b.to_s.split(/<body[^>]*>/)[-1].to_s.split(/<\/body>/)[0] }
+
+  F['cleanHTML'] = -> b {
+    h = Nokogiri::HTML.fragment F['HTMLbody'][b]
+    h.css('iframe').remove
+    h.css('script').remove
+    h.xpath("//@*[starts-with(name(),'on')]").remove
+    h.to_s
+  }
+
   def contentURIresolve *f
     send(*f){|s,p,o|
       yield s, p, p == Content ?
-      (Nokogiri::HTML.parse o).do{|o|
+      (Nokogiri::HTML.fragment o).do{|o|
         o.css('a').map{|a|
           if a.has_attribute? 'href'
             (a.set_attribute 'href', (URI.join s, (a.attr 'href'))) rescue nil
@@ -216,16 +241,18 @@ class E
       "table= layout arg required"
     end}
 
-  fn 'view/table',->i,e{[H.css('/css/table'),(Fn 'table',i.values,e)]}
-
-  fn 'table',->es,q=nil{ p = {}
-    es.map{|e|e.respond_to?(:keys) &&
-              e.keys.map{|k|p[k]=true}}
-    keys = p.keys
-    keys.empty? ? es.html :
-    H({_: :table,:class => :tab,
-        c: [{_: :tr, c: keys.map{|k|{_: :th, class: :label, property: k, c: k.abbrURI}}},
-            *es.map{|e|
-              {_: :tr, about: e.uri, c: keys.map{|k| {_: :td, property: k, c: k=='uri' ? e.E.html : e[k].html}}}}]})}
+  fn 'view/table',->g,e{
+    keys = E.graphProperties g
+    v = g.values
+    e.q['sort'].do{|p|
+      p = p.expand
+      v = v.sort_by{|s|
+        s[p].do{|o|
+          o[0].to_s}||''}} # cast to a single type (String) so sort will work. every class seems to have a #to_s
+    v = v.reverse if e.q['reverse']
+    [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}}}}]}]}
 
 end

data/infod/image.rb

@@ -78,7 +78,7 @@ class E
          # view 
          {uri: s,
            # img and  link to containing resource
-           c: ->{"<a href='#{v.uri.to_s.do{|u|u.path? ? u : u.E.url}}'><img style='float:left;#{h}' src='#{s}'></a>"}}}}.flatten.map{|i|
+           c: ->{"<a href='#{v.uri}'><img style='float:left;#{h}' src='#{s}'></a>"}}}}.flatten.map{|i|
 
        # show and mark as seen
        !seen[i[:uri]] &&

data/infod/index.rb

@@ -1,4 +1,4 @@
-watch __FILE__
+#watch __FILE__
 class E
 
   # POSIX-fs based index of triples
@@ -11,9 +11,9 @@ class E
   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
-#    puts "index #{p} #{o} #{a}"
     p.pIndex.noIndex[o,self,a]
   end
   def noIndex
@@ -36,79 +36,46 @@ class E
     g
   end
 
-  # subtree traverse
-  fn 'set/subtree',->d,r,m{
-    c =(r['c'].do{|c|c.to_i + 1} || 3).max(100) # one extra for start of next-page
-    o = r['d'] =~ /^a/ ? :asc : :desc           # direction
-
-    ('/'.E.take c, o, d.uri).do{|s|             # take subtree
-      desc, asc = o == :desc ?                  # orient pagination hints
-      [s.pop, s[0]] : [s[0], s.pop]
+  fn 'set/depth',->d,r,m{ # depth-first
+    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
+    o = r['d'] =~ /^a/ ? :asc : :desc            # direction
+    (p.take c, o, r['offset'].do{|o|o.E}).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[Prev] = {'uri' => desc.url + {'d' => 'desc'}.qs} if desc
-      u[Next] = {'uri' => asc.url  + {'d' => 'asc'}.qs} if asc
+      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 }}
 
-  # subtree traverse index on p+o cursor
-  fn 'set/index',->d,r,m{
-    top = r['p'].expand.E
-    count = r['c'] &&
-            r['c'].to_i.max(1000) || 8
-    dir = r['d'] && r['d'].match(/^(a|de)sc$/) &&
-          r['d'].to_sym || :desc
-
-    (top.rangePO count+1, dir, r['offset'], r['o']).do{|s|
-      # orient pagination pointers
-      ascending = r['d'].do{|d| d == 'asc' }
-      first, last = s[0], s.size > 1 && s.pop
-      desc, asc = ascending && [first,last] || [last,first]
-      # response description
-      u = m['#']
-      u[RDFs+'member'] = s
-      u[Prev] = {'uri' => '/index/' + r['p'] + '/' + CGI.escape(r['o']) + {'offset' => desc.uri, 'c' => count}.qs } if desc
-      u[Next] = {'uri' => '/index/' + r['p'] + '/' + CGI.escape(r['o']) + {'offset' => asc.uri, 'c' => count}.qs } if asc
-
-      s.map(&:docs).flatten.uniq }}
-
-  fn '/index/GET',->e,r{
-    a = e.pathSegment.uri[7..-1].split '/',2
-    r.q['set'] = 'index'
-    r.q['p'] = a[0]
-    r.q['o'] = CGI.unescape a[1]
-    e.response}
-
-  # predicate index
   def pIndex
     shorten.prependURI '/index/'
   end
 
-  # predicate-object index
   def poIndex o
     pIndex.concatURI o
   end
  
-  # predicate-object index lookup
+  # predicate+object pair lookup
   def po o
     pIndex[o.class == E ? o : literal(o)]
   end
 
-  # range query - predicate
   def rangeP size=8, dir=:desc, offset=nil, object=nil
     pIndex.subtree(size,dir,offset).map &:ro
   end
 
-  # range query - predicate-object
   def rangePO n=8,d=:desc,s=nil,o
     poIndex(o).subtree(n,d,s).map &:ro
   end
 
-  # E -> [node]
   def subtree *a
     u.take *a
   end
 
-  # E -> [E]
   def take *a
     no.take(*a).map &:E
   end
@@ -129,49 +96,32 @@ end
 
 class Pathname
 
-  # take N els from fs tree in sorted, depth-first order
   def take count=1000, direction=:desc, offset=nil
+    offset = offset.d if offset
 
-    # construct offset-path
-    offset = (to_s + offset).gsub(/\/+/,'/').E.path if offset
-
-    # in-range indicator
-    ok = false
-
-    # result set
+    ok = false    # in-range mark
     set=[]
-
-    # asc/desc operators
     v,m={asc:      [:id,:>=],
         desc: [:reverse,:<=]}[direction]
 
-    # visitation function
     visit=->nodes{
-
-      # sort nodes in asc or desc order
       nodes.sort_by(&:to_s).send(v).each{|n|
         ns = n.to_s
-        # have we got enough nodes?
         return if 0 >= count
 
-        # continue if
-        (# already in-range
-         ok ||
-         # no offset specified
-         !offset ||
-         # offset satisfies in-range operator
+        (ok || # already in-range
+         !offset || # no offset required
          (sz = [ns,offset].map(&:size).min
-          ns[0..sz-1].send(m,offset[0..sz-1]))) && (
-         if !(c = n.c).empty? # has children?
+          ns[0..sz-1].send(m,offset[0..sz-1]))) &&
+        (if !(c = n.c).empty? # has children?
            visit.(c)          # visit children
          else
-           count = count - 1 # decrement wanted-nodes count
+           count = count - 1 # decrement nodes-left count
            set.push n        # add node to result-set
-           ok = true         # iterator is now within range
+           ok = true         # mark iterator as within range
         end )}}
 
-    visit.(c) # start
-    # result set
+    visit.(c)
     set
   end