infod 0.0.1 → 0.0.2

data/infod.rb

@@ -1,13 +1,12 @@
 
 # the table of elements
 
-# Es search
+# Es infrastructure
 # H  HTML
 # K  constants
 # N  naming
 # Rb Ruby native-types
 # Th HTTP
-# W  forms and formats
 # Y  lambdas
 
-%w{Y K Rb N W Th H Es}.map{|e| require 'infod/' + e}
+%w{Y K Rb N Es H Th}.map{|e| require 'infod/' + e}

data/infod/Es.rb

@@ -1,67 +1,31 @@
-%w{fs groonga redis}.map{|e|require_relative 'Es/'+e}
-
-class E
-
-  # accumulate a graph recursively along set-membership arc
-  def walk p,m={}
-    graph m # accumulative graph
-    o = []  # resources to visit 
-    o.concat m[uri][p]     # outgoing arc targets
-    o.concat (E p).po self # incoming arc sources
-    o.map{|r|              # walk
-      r.E.walk p,m unless m[r.uri]}
-    m
-  end
-
-  # random leaf
-  def randomLeaf
-    c.empty? && self || c.r.randomLeaf
-  end
-  fn 'set/randomLeaf',->d,e,m{[d.randomLeaf]}
-  fn 'req/randomLeaf',->e,r{[302, {Location: e.randomLeaf.uri},[]]}
-
-  # Graph -> [Predicate]
-  def E.graphProperties g
-    g.values.select{|v|v.respond_to? :keys}.map(&:keys).flatten.uniq
-  end
-
-  fn 'filter/p',->e,m,_{
-    a=Hash[*e['p'].split(/,/).map(&:expand).map{|p|[p,true]}.flatten]
-    m.values.map{|r|
-      r.delete_if{|p,o|!a[p]}}}
-
-  fn 'filter/frag',->e,m,r{
-    f = [r.uri].concat m['frag']['res']
-    m.keys.map{|u|
-      m.delete u unless f.member? u}}
-
-  fn 'filter/basic',->o,m,_{
-    d=m.values
-    o['match'] && (p=o['matchP'].expand
-                   d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_s.match o['match']}})
-    o['min'] && (min=o['min'].to_f
-                 p=o['minP'].expand
-                 d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_f >= min }})
-    o['max'] && (max=o['max'].to_f
-                 p=o['maxP'].expand
-                 d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_f <= max }})
-    o['sort'] && (p=o['sort'].expand
-                       _ = d.partition{|r|r[p]}
-                       d =_[0].sort_by{|r|r[p]}.concat _[1] rescue d)
-    o['sortN'] && (p=o['sortN'].expand
-                       _ = d.partition{|r|r[p]}
-                       d =_[0].sort_by{|r|
-                     (r[p].class==Array && r[p] || [r[p]])[0].do{|d|
-                       d.class==String && d.to_i || d
-                     }
-                   }.concat _[1])
-    o.has_key?('reverse') && d.reverse!
-    m.clear;d.map{|r|m[r['uri']]=r}}
-  
-  def self.filter o,m,r
-    o['filter'].do{|f|f.split(/,/).map{|f|Fn 'filter/'+f,o,m,r}}
-    Fn'filter/basic',o,m,r if o.has_any_key ['reverse','sort','max','min','match']
-    m
-  end
-
-end
+%w{
+code
+css
+csv
+du
+feed
+filter
+find
+fs
+glob
+grep
+groonga
+html
+image
+in
+index
+json
+kv
+ls
+mail
+man
+mime
+out
+pager
+pdf
+rdf
+schema
+search
+sh
+text
+}.map{|e|require_relative 'Es/'+e}

data/infod/{W/source.rb → Es/code.rb}

@@ -1,25 +1,21 @@
 class E
   
-  # show available querystring aliases
-  fn '/qs/GET',->e,r{H([H.css('/css/404'),F['?'].html]).hR}
-
   def triplrSourceCode
-    # MIME                   strip x-
     m = mime.split(/\//)[-1].sub(/^x-/,'')
-
     # show line numbers?
     n = @r.has_key?('n') && "--line-number-ref=#{uri.sh}"
-
-    yield uri,Content,
-    `source-highlight -f html -o STDOUT -i #{sh} -s #{m} #{n}`
-  end
+    if size < 512e3
+      yield uri,Content,
+      `source-highlight -f html -o STDOUT -i #{sh} -s #{m} #{n}`
+    end
+ end
 
   fn 'view/code',->d,e{[{_: :style, c: 'body{background-color:white;color:black}'},
     d.values.map{|r|[r.E.do{|e|[{_: :a,name: e.uri},e.html(e.base,true)]},'<br>',
                       r[Content]]}]}
 
   # ls /usr/share/source-highlight/*.lang | xargs -i basename {} .lang | tr "\n" " "
-  %w{ada applescript asm awk bat bib bison caml changelog c clipper cobol conf cpp csharp css desktop diff d erlang errors flex fortran function glsl haskell haskell_literate haxe html html_simple java javascript key_string langdef latex ldap lisp log logtalk lsm lua m4 makefile manifest nohilite number outlang oz pascal pc perl php postscript prolog properties proto python ruby scala script_comment sh slang sml spec sql style symbols tcl texinfo todo url vala vbscript xml}
+  %w{ada applescript asm awk bat bib bison caml changelog c clipper cobol conf cpp csharp css desktop diff d erlang errors flex fortran function glsl haskell haskell_literate haxe html html_simple java javascript key_string langdef latex ldap lisp log logtalk lsm lua m4 makefile manifest nohilite number outlang oz pascal pc perl php postscript prolog properties proto python ruby scala script_comment sh shellscript slang sml spec sql style symbols tcl texinfo todo url vala vbscript xml}
     .map{|l|
     ma = 'application/' + l
     mt = 'text/x-' + l

data/infod/Es/css.rb

@@ -0,0 +1,21 @@
+require 'nokogiri'
+class E
+
+  def nokogiri;  Nokogiri::HTML.parse read end
+
+  MIMEsource['text/css'] ||= [:triplrSourceCode]
+
+end
+
+class H
+
+  def H.css a,inline=false
+    p = a + '.css'
+    if inline
+      {_: :style, c: p.E.r}
+    else
+      {_: :link, href: p, rel: :stylesheet, type: E::MIME[:css]}
+    end
+  end
+
+end

data/infod/Es/du.rb

@@ -0,0 +1,16 @@
+class E
+
+  fn 'protograph/du',->d,_,m{
+    e = [d,d.pathSegment].compact.find &:e
+    m[e.uri] = e if e
+    rand.to_s.h }
+
+  fn 'graph/du',->e,_,m{
+    `du -a #{m.values[0].sh}`.each_line{|l|
+      s,p = l.chomp.split /\t/ # size, path
+      p = p.unpathFs           # path -> URI
+      m[p.uri] = {'uri' => p.uri,
+            Stat+'size' => [s.to_i]}}
+    m }
+
+end

data/infod/{W → Es}/feed.rb

@@ -20,16 +20,18 @@ module FeedParse
     #items
     scan(%r{<(rss:|atom:)?(item|entry)([\s][^>]*)?>(.*?)</\1?\2>}mi){|m|
 
-      #URI
-      u = m[2] && (u=m[2].match /about=["']?([^'">\s]+)/) && u[1] ||
-          m[3] && (((u=m[3].match /<(gu)?id[^>]*>([^<]+)/) || (u=m[3].match /<(link)>([^<]+)/)) && u[2])
-      yield u,E::Type,(E::SIOC+'Post').E
+      # TODO (gu)id field is often unresolvable. maybe use link[rel=alternate] as identifier instead since it's resolvable & HTTP
+
+      # find identifier
+      u = m[2] && (u = m[2].match /about=["']?([^'">\s]+)/) && u[1] ||
+          m[3] && (((u = m[3].match /<(gu)?id[^>]*>([^<]+)/) || (u = m[3].match /<(link)>([^<]+)/)) && u[2])
+
+      yield u, E::Type, (E::SIOC+'Post').E
 
       #links
       m[3].scan(%r{<(link|enclosure|media)([^>]+)>}mi){|e|
-        yield(u,                                                                       # s
-              E::Atom+'/link/'+((r=e[1].match(/rel=['"]?([^'">\s]+)/)) ? r[1] : e[0]), # p
-              e[1].match(/(href|url|src)=['"]?([^'">\s]+)/)[2].E)}                     # o
+        e[1].match(/(href|url|src)=['"]?([^'">\s]+)/).do{|url|
+          yield(u,E::Atom+'/link/'+((r=e[1].match(/rel=['"]?([^'">\s]+)/)) ? r[1] : e[0]), url[2].E)}}
 
       #elements
       m[3].scan(%r{<([a-z]+:)?([a-z]+)([\s][^>]*)?>(.*?)</\1?\2>}mi){|e|
@@ -61,7 +63,6 @@ class E
   end
 
   def triplrFeedReddit &f
-    require 'nokogiri'
     triplrFeed {|s,p,o|
      p == Content ?
       Nokogiri::HTML.parse(o).do{|o|
@@ -109,8 +110,9 @@ class E
                      d[Title].do{|t|{_: :title, c: t}},
                      d[Creator].do{|c|{_: :author, c: c[0]}},
                      {_: :content, type: :xhtml,
-                       c: {xmlns:"http://www.w3.org/1999/xhtml", c: d[Content]}}
-                    ].intersperse("\n")}
-             }.intersperse("\n")]}])}
+                       c: {xmlns:"http://www.w3.org/1999/xhtml",
+                         c: d[Content]}}].cr
+               }}.cr
+            ]}])}
 
 end

data/infod/Es/filter.rb

@@ -0,0 +1,75 @@
+class E
+
+  # narrow to specified properties
+  fn 'filter/p',->e,m,_{
+    a=Hash[*e['p'].split(/,/).map(&:expand).map{|p|[p,true]}.flatten]
+    m.values.map{|r|
+      r.delete_if{|p,o|!a[p]}}}
+
+  fn 'filter/frag',->e,m,r{
+    f = [r.uri].concat m['frag']['res']
+    m.keys.map{|u|
+      m.delete u unless f.member? u}}
+
+  fn 'filter/basic',->o,m,_{
+    d=m.values
+    o['match'] && (p=o['matchP'].expand
+                   d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_s.match o['match']}})
+    o['min'] && (min=o['min'].to_f
+                 p=o['minP'].expand
+                 d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_f >= min }})
+    o['max'] && (max=o['max'].to_f
+                 p=o['maxP'].expand
+                 d=d.select{|r|r[p].do{|p|(p.class==Array ? p[0] : p).to_f <= max }})
+    o['sort'] && (p=o['sort'].expand
+                       _ = d.partition{|r|r[p]}
+                       d =_[0].sort_by{|r|r[p]}.concat _[1] rescue d)
+    o['sortN'] && (p=o['sortN'].expand
+                       _ = d.partition{|r|r[p]}
+                       d =_[0].sort_by{|r|
+                     (r[p].class==Array && r[p] || [r[p]])[0].do{|d|
+                       d.class==String && d.to_i || d
+                     }
+                   }.concat _[1])
+    o.has_key?('reverse') && d.reverse!
+    m.clear;d.map{|r|m[r['uri']]=r}}
+
+  fn 'filter/map',->o,m,_{
+    o.except('filter','graph','view').map{|p,n|
+     p=p.expand
+     n=n.expand
+      p!=n &&
+      m.values.map{|r|
+        r[p].do{|o|
+          r[n]=o
+          r.delete p }}}}
+
+  fn 'view/map',->d,e{
+    [H.js('/js/normal'),(H.once e,:mu,(H.js '/js/mu')),
+'<style>.b {display:inline-block;font-weight:bold;padding-right:.8em;text-align:right;min-width:12em}
+        .exerpt {display:inline-block;max-height:1em;overflow:hidden;max-width:44em;font-size: .9em} </style>',
+     {_: :form, c:
+      [d.values.map(&:keys).flatten.uniq.-(['uri']).do{|ps|
+        ps.map{|p|
+           [{class: :b, c: p},{_: :select, name: p, c: 
+            (ps + [Date,Creator,Content,Title]).map{|q|
+              {_: :option, c: q}.
+                  update(p==q ? {selected: :selected}:{})}},
+              {class: :exerpt, c: d.values.map{|r|r[p]}.flatten.uniq.html},
+              '<br>']}},
+       {_: :input, type: :hidden, name: :view, value: :tab},
+       {_: :input, type: :hidden, name: :filter, value: :map},
+       {_: :input, type: :submit}
+       ]}]}
+  
+  def self.filter o,m,r
+    o['filter'].do{|f|f.split(/,/).map{|f|Fn 'filter/'+f,o,m,r}}
+    Fn'filter/basic',o,m,r if o.has_any_key ['reverse','sort','max','min','match']
+    m
+  end
+
+  def E.graphProperties g
+    g.values.select{|v|v.respond_to? :keys}.map(&:keys).flatten.uniq
+  end
+
+end

data/infod/Es/find.rb

@@ -0,0 +1,20 @@
+#watch __FILE__
+class E
+
+  fn 'set/find',->e,q,m,x=''{
+    q['q'].do{|q|
+      r = '-iregex ' + ('.*' + q + '.*' + x).sh
+      s = q['size'].do{|s| s.match(/^\d+$/) && '-size +' + s + 'M'}
+      t = q['day'].do{|d| d.match(/^\d+$/) && '-ctime -' + d }
+      [e,e.pathSegment].compact.select(&:e).map{|e|
+        `find #{e.sh} #{t} #{s} #{r} | head -n 1000`.
+        lines.map{|l|l.chomp.unpathFs}}.compact.flatten}}
+
+  fn 'view/find',->i,e{
+    {_: :form, method: :GET, action: e['REQUEST_PATH'].t,
+      c: [{_: :input, name: :set, value: :find, type: :hidden},
+          {_: :input, name: :triplr, value: :id, type: :hidden},
+          {_: :input, name: :view, value: :ls, type: :hidden},
+          {_: :input, name: :q, style: 'float: left;font-size:1.3em'}]}}
+
+end

data/infod/Es/fs.rb

@@ -1,154 +1,163 @@
+#watch __FILE__
+
+%w{date digest/sha1 fileutils json open-uri pathname}.each{|r|require(r)}
+
 class E
 
-  # POSIX-filesystem index for triples
-  # 
+  def d
+    node.to_s
+  end
+
+  def node
+    Pathname.new FSbase + path
+  end
+  alias_method :no, :node
+
+  def siblings
+    parent.c
+  end
+
+  def children
+    node.c.map &:E
+  end
+  alias_method :c, :children
+
+
+  # node exists?
+  def exist?
+    node.exist?
+  end
+  alias_method :e, :exist?
+
+  # directory?
+  def d?
+    node.directory?
+  end
+
+  # file?
+  def file?
+    node.file?
+  end
+  alias_method :f, :file?
 
-  # index a triple 
-  def index p,o
-    # normalize predicate typeclass (accept URI string or resources) 
-    indexEdit E(p),
-    # literal -> URI conversion
-      (o.class == E ? o : E(p).literal(o)),
-       nil
+  # modification time
+  def mtime
+    node.stat.mtime if e
   end
+  alias_method :m, :mtime
 
-  # index a triple - no input-cleanup
-  def indexEdit p,o,a
-    return if @noIndex
-    p.pIndex.noIndex[o,self,a]
+  def triplrInode children=true
+    e && (d? && (yield uri, Posix + 'dir#parent', parent
+                 children && c.map{|c| yield uri, Posix + 'dir#child', c})
+          node.stat.do{|s|[:size,:ftype,:mtime].map{|p| yield uri, Stat+p.to_s, (s.send p)}})
+  end
+  
+  def triplrSymlink
+    realpath.do{|t|
+      target = t.to_s.index(FSbase)==0 ? t.E : t.to_s
+      yield uri, '/linkTarget', target }
+  end
+  
+  def realpath
+    node.realpath
+  rescue Errno::ENOENT
+    nil
   end
-  def noIndex
-    @noIndex = 1
+
+  def mk
+    e || FileUtils.mkdir_p(d)
     self
   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]
-      m['prev'] = {'uri' => 'prev', 'url' => desc.url,'d' => 'desc'}
-      m['next'] = {'uri' => 'next', 'url' => asc.url, 'd' => 'asc'}
-      s }}
-
-  # subtree traverse index on p+o cursor
-  fn 'set/index',->d,r,m,f=:rangePO{
-    (# predicate
-     (f == :rangeP ? d : r['p']).expand.E.
-     # query
-     send f,
-     # count
-     (r['c']&&
-      r['c'].to_i.max(808)+1 || 22),
-     # direction
-     (r['d']&&
-      r['d'].match(/^(a|de)sc$/) &&
-      r['d'].to_sym ||
-      :desc),
-     # offset
-     r['offset'],
-     # object
-     (d if f == :rangePO)
-     ).do{|s|
-      # pagination pointers
-      a,b = s[0], s.size > 1 && s.pop
-      desc,asc = r['d'] && r['d']=='asc' && [a,b]||[b,a]
-      # insert pointers in response-graph
-      m['prev']={'uri' => 'prev','url' => d.url,'d' => 'desc','offset' => desc.uri} if desc
-      m['next']={'uri' => 'next','url' => d.url,'d' => 'asc', 'offset' => asc.uri}  if asc
-      s }}
-  F['set/indexPO']=F['set/index']
-  fn 'set/indexP',->d,r,m{Fn 'set/index',d,r,m,:rangeP}
-
-  # predicate index
-  def pIndex
-    '/index'.E.s self
-  end
-
-  # predicate-object index
-  def poIndex o
-    pIndex.s o
-  end
- 
-  # predicate-object index lookup
-  def po o
-    pIndex[o.class == E ? o : literal(o)]
-  end
-
-  # range query - predicate
-  def rangeP n=8,d=:desc,s=nil,o=nil
-    puts "rangeP #{uri} count #{n} dir #{d} cursor #{s}"
-    pIndex.subtree(n,d,s).map &:ro
-  end
-
-  # range query - predicate-object
-  def rangePO n=8,d=:desc,s=nil,o
-    puts "rangePO #{uri} #{o} count #{n} dir #{d} cursor #{s}"
-    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
+  # create link
+  def ln t
+    t = t.E # cast bare URI/string to resource
+    if !t.e # destination exist?
+      t.dirname.mk
+      FileUtils.link node, t.node
+    end
   end
 
-end
+  # create symlink
+  def ln_s t
+    t = t.E # cast bare URI/string to resource
+    if !t.e # destination exist?
+      t.dirname.mk
+      FileUtils.symlink node, t.node
+    end
+  end
+
+  def touch
+    FileUtils.touch node
+    self
+  end
+    
+  def deleteNode
+    node.deleteNode if e
+    self
+  end
+
+  def size
+    node.size
+  end
+
+  def read
+    f ? r : get
+  end
+
+  def get
+    (open uri).read
+  end
+
+  def r p=false
+    if f
+      p ? (JSON.parse readFile) : readFile
+    else
+      puts "tried to open #{d}"
+      nil
+    end
+  rescue Exception => e
+    puts e
+  end
+
+  def w o,s=false
+    dirname.mk
+    writeFile (s ? o.to_json : o)
+    self
+  end
+
+  def writeFile c
+    File.open(d,'w'){|f|f << c}
+  end
 
+  def readFile
+    File.open(d).read
+  end
+
+end
 
 class Pathname
 
-  # take N els from fs tree in sorted, depth-first order
-  def take count=1000, direction=:desc, offset=nil
-
-    # construct offset-path
-    offset = to_s + offset.gsub(/\/+/,'/').E.path if offset
-
-    # in-range indicator
-    ok = false
-
-    # result set
-    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
-         (sz = [ns,offset].map(&:size).min
-          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
-           set.push n        # add node to result-set
-           ok = true         # iterator is now within range
-        end )}}
-
-    visit.(c) # start 
-
-    # result set
-    set
+  def E
+    to_s.force_encoding('UTF-8').unpathFs
   end
 
+  def c
+    return [] unless directory?
+    children.delete_if{|n| n.basename.to_s.match /^\./}
+    rescue
+      []
+  end
+  
+  def deleteNode
+    FileUtils.send file? ? :rm : :rmdir, self
+    parent.deleteNode if parent.c.empty?
+  end
+
+end
+
+class File::Stat
+  def utime
+    mtime.to_i
+  end
 end