infod 0.0.1 → 0.0.2

data/infod/Rb.rb

@@ -4,7 +4,7 @@ class Array
   def head; self[0] end
   def tail; self[1..-1] end
   def snd;  self[1] end
-  def r; self[rand length] end
+  def random; self[rand length] end
   def h; join.h end
   def intersperse i
     inject([]){|a,b|a << b << i}[0..-2]
@@ -65,7 +65,7 @@ end
 class NilClass
   def do; nil end
   def to_ary; [] end
+  def to_hash; {} end
   def to_s; "" end
-  alias_method :to_str,:to_s
-  def method_missing *a; nil; end
+  %w{html to_str}.map{|m|alias_method m,:to_s}
 end

data/infod/Th.rb

@@ -1,110 +1,36 @@
-%w{GET HEAD POST PATCH uid 404 500}.map{|i|require_relative 'Th/' + i}
+#watch __FILE__
 require 'rack'
-
-class String
-  # parse querystring
-  def qp
-    d={}
-    split(/&/).map{|e|
-      k,v=e.split(/=/,2).map{|x|
-         CGI.unescape x}
-      d[k]=v}
-    d
-  end
-  def hR
-    [200,{'Content-Type'=>'text/html'},[self]]
-  end
-end
-
-module Tb
-  def q
-   @q ||= self.().qp
-  end
-end
-
-module Th
-  def qs
-    (['GET','HEAD'].member? fn) ? self['QUERY_STRING'] : self['rack.input'].read
-  end
-  # read querystring
-  def q
-    @q ||= (qs||'').qp.do{|q|
-      (q['?']).do{|d|
-        E::F['?'][d].do{|g| # expand aliases
-          g.merge q
-        } || q } || q}
-  end
-  # read Accept header
-  def accept_ k=''
-    d={}
-    self['HTTP_ACCEPT'+k].do{|k|
-      k.split(/,/).map{|e|
-        f,q=e.split(/;/)
-        i=q&&q.split(/=/)[1].to_f||1
-        d[i]||=[]
-        d[i].push f}}
-    d
-  end
-
-  def format
-    @format ||= conneg
-  end
-
-  def conneg
-    # choose a preferred content-type
-    return q['format'] if q['format'] && E::F[E::Render+q['format']]
-    accept.sort.reverse.map{|p|p[1].map{|mime|
-        return mime if E::F[E::Render+mime]
-      }}
-    'text/html'
-  end
-
-  def accept; @accept ||= accept_ end
-
-  def fn
-    # request method (Symbol) getter
-    self['REQUEST_METHOD']
-  end
-end
-
-class Hash
-  def qs
-   '?'+map{|k,v|k.to_s+'='+(v ? (CGI.escape [*v][0].to_s) : '')}.intersperse("&").join('')
-  end
-  def env r # thread environment through to children
-    @r = r
-    self
-  end
-end
+%w{GET HEAD POST PATCH perf uid util 404 500}.map{|i|require_relative 'Th/' + i}
 
 class E
 
-  F['?'] ||= {}
-
-  # access or update request environment
-  def env r=nil
-    r ? (@r = r
-         self) : @r
-  end
-
   def E.call e
-    dev         # check for changed source code
-    e.extend Th # enable request-related utility functions
-    e['HTTP_X_FORWARDED_HOST'].do{|h| e['SERVER_NAME'] = h } # hostname
-   (e['REQUEST_PATH'].force_encoding('UTF-8').do{|u|         # path
-      CGI.unescape(u.index(Prefix)==0 ? u[Prefix.size..-1] : # non-local or non-HTTP URI
-      'http://' + e['SERVER_NAME'] + u.gsub('+','%2B'))      # HTTP URI
-    }.E.env(e).jail.do{|r|           # valid path?
-      e['uri']=r.uri; r.send e.fn    # update URI and continue
-    } || [403,{},['invalid path']]). # reject
-      do{|response| puts [           # inspect
-        e.fn, response[0],['http://', e['SERVER_NAME'], e['REQUEST_URI']].join,e['HTTP_USER_AGENT'],e['HTTP_REFERER']].join ' '
-        response }
+    dev
+    e.extend Th
+    e['HTTP_X_FORWARDED_HOST'].do{|h| e['SERVER_NAME'] = h }
+    p = e['REQUEST_PATH'].force_encoding 'UTF-8'
+
+    uri = CGI.unescape(if (p.index Prefix) == 0
+                         p[Prefix.size..-1]
+                       else
+                         'http://' + e['SERVER_NAME'] + (p.gsub '+','%2B')
+                       end).E.env e
+    
+    if (uri.node.expand_path.to_s.index FSbase) == 0
+      e['uri'] = uri.uri
+      # response
+      r = nil              # request method
+      b = Benchmark.measure{ r = uri.send e.fn }
+      F['log'][r[0],e,b.real]
+      r
+    else
+      [403,{},['Forbidden']]
     end
 
-  # load site-specific code-base
-
-  E['http:/*/*.rb'].glob.map{|s| puts "site config #{s}"
-    require s.d}
+  rescue Exception => x
+    $stderr.puts 500, e['REQUEST_URI'] ,x.message,x.backtrace
+    F['log'][500,e]
+    F['E500'][x,@r]
+  end
 
 end

data/infod/Th/404.rb

@@ -1,55 +1,48 @@
+watch __FILE__
 class E
 
-  # 404 response URI
   E404 = 'req/'+HTTP+'404'
 
-  # 404 response function
   fn E404,->e,r{
-    u = e.uri     # response URI
-    g = {u => {}} # response graph
-    s = g[u]      # resource pointer
-    # add request data to response graph
-    r.map{|k,v| s[k] = [v] }
-    s[Type] = [E[HTTP+'404']]
-    s['uri'] = u
-    s['QUERY'] = [r.q]
-    s['ACCEPT']= [r.accept]
-    s['SERVER_SOFTWARE']=[('//'+r['SERVER_NAME']).E]
-    s['http://buzzword.org.uk/rdf/personal-link-types#edit']=[E[u+'?view=edit&graph=_']]
-    %w{CHARSET LANGUAGE ENCODING}.map{|a|s['ACCEPT_'+a] = [(r.accept_ '_' + a)]}
-    # output
-    r.q.delete 'view' # use 404 view if HTML
-    [404,{'Content-Type'=> r.format},[e.render(r.format,g,r)]]}
+   id = e.uri     # response URI
+    g = {id=>{}}  # response graph
+    s = g[id]     # resource pointer
+   fn = r['REQUEST_METHOD']
 
-  # qs y=404 to force a 404 response
-  F['req/404'] = F[E404]
+    # request environment -> graph
+r.map{|k,v| s[Header + k] = k == 'uri' ? v : [v] }
+  %w{CHARSET LANGUAGE ENCODING}.map{|a|
+    s[Header+'ACCEPT_'+a] = [r.accept_('_' + a)]}
+       s[Header+'ACCEPT'] = [r.accept]
+                  s[Type] = [E[HTTP+'Response']]
+s[HTTP+'statusCodeValue'] = [404]
+    s[Header+'HTTP_HOST'] = [E['http://' + s[Header+'HTTP_HOST'][0]]]
+                  s[Edit] = [E[r['REQUEST_PATH']+'?view=edit&graph=editable']]
+              s['#query'] = [r.q]
+            s['#seeAlso'] = [e.parent,*e.a('*').glob]
+              r.q['view'] = '404'
 
-  fn 'view/'+HTTP+'404',->d,e{
-    [H.css('/css/404'),{_: :h1, c: '404'},d.html]}
+    [404,{'Content-Type'=> r.format},[e.render(r.format,g,r)]]}
+  
+  fn 'view/404',->d,e{
+    [H.css('/css/404'),{_: :style, c: "a {background-color:#{E.cs}}"},
+     d.html]}
 
-  # 404.css if fs content is missing
-  fn '/css/404.css/GET',->e,r{
-    [200,{'Content-Type'=>'text/css'},
-["body {background-color:#000;color:#fff; font-family: sans-serif}
-a {font-size:1.05em;background-color:#1ef;color:#000;text-decoration:none;padding:.1em}
-td.key {text-align:right}
-td.key .frag {font-weight:bold;background-color:#0f0;color:#000;padding-left:.2em;border-radius:.38em 0 0 .38em}
-td.key .abbr {color:#eee;font-size:.92em}
-td.val {border-style:dotted;border-width:0 0 .1em 0;border-color:#00f;}"]]}
+  # a small non-empty graph
+  fn 'protograph/_',->d,_,m{
+    m[d.uri] = {}
+    rand.to_s.h}
 
-  # show response-codes for a list of URIs
+  # check response-codes for a list of URIs (linebreak-separated *.u files)
   def checkURIs
     r = uris.select{|u|u.to_s.match /^http/}.map{|u|
       c = [`curl -IsA 404? "#{u}"`.lines.to_a[0].match(/\d{3}/)[0].to_i,u] # HEAD
-     #c = [`curl -s -o /dev/null -w %{http_code} "#{u}"`.chomp.to_i,u] # GET
       puts c.join ' ' 
-      c # status, uri tuple
-    }
+      c } # status, uri tuple
     puts "\n\n"
     r.map{|c|
       # show anomalies
-      puts c.join(' ') unless c[0] == 200
-    }
+      puts c.join(' ') unless c[0] == 200 }
   end
 
 end

data/infod/Th/500.rb

@@ -1,10 +1,41 @@
-#watch __FILE__
 class E
 
-  fn 'backtrace',->x,r{
+  fn '/css/500.css/GET',->e,r{
+    [200,{'Content-Type'=>'text/css'},["
+body {margin:0; font-family: sans-serif; background-color:#fff; color:#000}
+h1 {padding:.2em; background-color:#f00; color:#fff; margin:0}
+div {display:inline}
+table {border-spacing:0;margin:0}
+b {background-color:#eee;color:#500;padding:.1em .3em .1em .3em}
+.frag {font-weight:bold; color:#000; background-color:#{E.cs}}
+td.space {background-color:#ddd}
+td.message {background-color:#009;color:#fff}
+td.path {text-align:right}
+td.index {text-align:right;border-color:#000;border-width:0 0 .1em 0;border-style:dotted;background-color:#ddd;color:#000}
+td.context {border-color:#ddd;border-width:0 0 .1em 0;border-style:dotted;padding:.15em}"]]}
+
+  F['/E/error/GET'] = ->e,r{1/0}
+
+  fn 'E500',->x,r{
   [500,{'Content-Type'=>'text/html'},
-   ['<html><head><title>500</title></head><body><h1>500</h1><pre>',
-     [x.class.to_s,x.message,*x.backtrace].join("\n").hrefs,
-     '</pre></body></html>']]}
+   [H[{_: :html,
+        c: [{_: :head,
+              c: [{_: :title, c: 500},(H.css '/css/500')]},
+            {_: :body,
+              c: [{_: :h1, c: 500},
+                  {_: :table,
+                    c: [{_: :tr,
+                          c: [{_: :td, c: {_: :b, c: x.class}},
+                              {_: :td, class: :space},
+                              {_: :td, class: :message, c: x.message.hrefs}
+                             ]},
+                        x.backtrace.map{|p|
+                          p = p.split /:/, 3
+                          {_: :tr,
+                            c: [{_: :td, class: :path, c: F['abbrURI'][p[0]]},
+                                {_: :td, class: :index, c: p[1]},
+                                {_: :td, class: :context, c: (p[2]||'').hrefs}].cr}}.cr]}]}]}]]]}
 
+  F['/500/GET'] = ->e,r{H([Errors.sort_by{|u,r|r[:time]}.reverse.html,H.css('/css/500')]).hR}
+  
 end

data/infod/Th/GET.rb

@@ -1,132 +1,62 @@
 class E
 
   def GET
-    a = @r.accept.values.flatten # acceptable MIME types
-    send(f ? (if (@r.q.has_any_key(['format','graph','view']) || # user-specified view
-                 (MIMEcook[mime] && !@r.q.has_key?('raw')) ||    # view for MIME-type
-                 !(a.empty?||a.member?(mime)||a.member?('*/*'))) # file MIME not accepted
-                 :GET_resource # invoke resource handler
-              else
-                :GET_img # continue to file handler
-              end) :
-         :GET_resource)
-  rescue Exception => x
-    $stderr.puts 500,x.message,x.backtrace
-    Fn 'backtrace',x,@r
-  end
-
-  def maybeSend m,b,lH=false
-    send? ? # agent already has this version?
-    b.().do{|b| # continue
-      h = {'Content-Type'=> m, 'ETag'=> @r['ETag']} # response header
-      m.match(/^(audio|image|video)/) &&            # media MIME-type?
-      h.update({'Cache-Control' => 'no-transform'}) # no further compression
-      h.update({'MS-Author-Via' => 'DAV, SPARQL'})  # authoring
-      lH && h.update({'Link' => '<' + (URI.escape uri) + '?format=text/n3>; rel=meta'}) # Link Header - full URI variant
-      b.class == E ? (Nginx ?                                                     # nginx env-var
-                      [200,h.update({'X-Accel-Redirect' => '/fs' + b.path}),[]] : # Nginx file-handler
-                      Apache ?                                              # Apache env-var
-                      [200,h.update({'X-Sendfile' => b.d}),[]] : # Apache file-handler
-                      (r = Rack::File.new nil                      # create Rack file-handler
-                       r.instance_variable_set '@path',b.d         # set path
-                       r.serving(@r).do{|s,m,b|[s,m.update(h),b]}) # Rack file-handler
-                      ) :
-      [200, h, b]} : # response triple
-      [304,{},[]]    # not modified
+    # bespoke handler ||
+    # raw file ||
+    # resource
+    if reqFn = F['req/'+@r.q['y']]
+      reqFn[self,@r]
+    elsif file = [self,pathSegment].compact.find(&:f)
+      a = @r.accept.values.flatten
+      accepted = a.empty? || (a.member? file.mimeP) || (a.member? '*/*')
+      (@r.q.has_any_key(%w{format view}) ||
+       MIMEcook[file.mimeP] || !accepted) ? resource : (file.env @r).getFile
+    else
+      resource
+    end
   end
 
-  def send?
-    !((m=@r['HTTP_IF_NONE_MATCH']) && m.strip.split(/\s*,\s*/).include?(@r['ETag']))
-  end  
-
-  def GET_file
+  def getFile
     @r['ETag'] = [m,size].h
-    maybeSend mime,->{self},:link
+    maybeSend mimeP,->{self},:link
   end
 
-  def GET_img
-   (thumb? ? thumb : self).GET_file
-  end
-
-  def GET_resource                 # for 
-    (F['req/'+@r.q['y']] ||           # any URI 
-     F[@r['REQUEST_PATH'].t+('GET')]||# specific path
-     F[uri.t+('GET')]                 # specific URI
-     ).do{|y|y.(self,@r)} ||       # custom handler
-    as('index.html').do{|i|        # HTML index
-      i.e &&                       #  exists?
-      ((uri[-1]=='/') ? i.env(@r).GET_file : # are we inside dir?
-       [301, {Location: uri.t}]  )} ||       # rebase to index dir
+  def resource
+    # bubble up site then global tree until handled (false return-value to pass)
+    pathSegment.do{|path|
+      lambdas = path.cascade.map{|p| p.uri.t + 'GET' }
+      ['http://'+@r['SERVER_NAME'],""].map{|h| lambdas.map{|p|
+          F[h + p].do{|fn| fn[self,@r].do{|r| return r}}}}}
+    
+    # default handler
     response
   end
 
-  # graph constructor
-  fn 'graph/',->e,q,m{
-    F['set/' + q['set']][e, q, m]. # doc set
-    map{|u|m[u.uri] ||= u}}
-
-  # document set constructor
-  fn 'set/',->d,e,m{d.docs}
-  
-  # construct HTTP response
-  def response
-
-    # request arguments
-    q = @r.q       # query-string
-    g = q['graph'] # graph-generation function selector
-
-    # request graph 
-    m = {}
-
-    # add resources to request graph 
-    F['graph/' + g][self,q,m]
-
-    # empty graph -> 404
-    return F[E404][self,@r] if m.empty?
-
-    # inspect request-graph
-    if q.has_key? 'debug'
-      puts "docs #{m.keys.join ' '}"
-      puts "resources #{m['frag']['res']}" if m['frag']
-    end
-
-    # request-graph identifier
-    s = (q.has_key?('nocache') ? rand.to_s :  # random identifier
-         m.sort.map{|u,r|[u, r.respond_to?(:m) && r.m]}).h # canonicalized set signature
-
-    # response identifier
-    @r['ETag'] ||= [s, q, @r.format].h
-
-    # check if client has response
-    maybeSend @r.format, ->{
-      
-      # cached response identifier
-      r = E'/E/req/' + @r['ETag'].dive
-      
-      if r.e # response already generated
-        r    # cached response
-      else
-        
-        # cached graph identifier
-        c = E '/E/graph/' + s.dive
-
-        if c.e # cached graph exists
-          m.merge! c.r true # read cache
-        else
-          # construct response graph
-          m.values.map{|r|
-            r.env(@r).graphFromFile m}
-
-          # cache response graph
-          c.w m,true
-        end
-
-        # response graph sorting/filtering
-        E.filter q, m, self
-
-        # response body
-        r.w render @r.format, m, @r
-      end }
+  def send?
+    !((m=@r['HTTP_IF_NONE_MATCH']) && m.strip.split(/\s*,\s*/).include?(@r['ETag']))
   end
   
+  def maybeSend m,b,lH=false
+    # agent need this version?
+    send? ?
+    # continue
+    b[].do{|b|
+      # response metadata
+      h = {'Content-Type'=> m,
+           'ETag'=> @r['ETag']}
+      h.update({'Cache-Control' => 'no-transform'}) if m.match /^(audio|image|video)/
+      h.update({'Link' => '<' + @r['uri'] + '?view=base>; rel=meta'}) if lH
+
+      b.class == E ? (Nginx ?                                                     # nginx enabled
+                      [200,h.update({'X-Accel-Redirect' => '/fs' + b.path}),[]] : # Nginx file-handler
+                      Apache ?                                              # Apache enabled
+                      [200,h.update({'X-Sendfile' => b.d}),[]] :   # Apache file-handler
+                      (r = Rack::File.new nil                      # Rack file-handler
+                       r.instance_variable_set '@path',b.d
+                       r.serving(@r).do{|s,m,b|[s,m.update(h),b]})
+                      ) :
+      [200, h, b]} : # normal (unaccelerated) response
+      [304,{},[]]    # client has response version
+  end
+
 end