infod 0.0.1

data/infod/N.rb

@@ -0,0 +1,248 @@
+%w{base64 cgi shellwords}.each{|r|require(r)}
+
+def E e
+  return e if e.class == E
+  return e unless e
+  E.new e
+end
+
+class E
+  def E.[] u; E u end
+  def E e=uri; super e end
+
+                      attr_reader :uri
+  def initialize uri; @uri = uri.to_s end
+  
+  def base
+    File.basename path
+  end
+
+  def bare
+    base.sub(/\.#{ext}$/,'')
+    rescue
+    base
+  end
+
+  def docBase
+    readlink.uri.
+      split(/#/)[0].E.
+      do{|d|
+        d.dirname.as d.bare}
+  end
+
+    def ef;  @ef ||= docBase.a('.e') end
+    def nt;  @nt ||= docBase.a('.nt') end
+   def ttl; @ttl ||= docBase.a('.ttl') end
+
+  def docBaseURI
+    u = URI uri
+    s = u.scheme
+    p = u.path
+    p = '/' if p.empty?
+    ((s ? s + '://' : '') + # scheme
+     u.host +               # host
+     File.dirname(p).t +    # path
+     File.basename(p)[0..-(File.extname(p).size+1)]).E # doc
+  end
+
+  def frag
+    uri.frag
+  end
+
+  def docs
+    (e ? [self] : []). # directly-referenced
+      concat(docBase.glob ".{e,html,n3,nt,owl,rdf,ttl}"). # docs
+      concat((d? && uri[-1]=='/') ? c : []) # trailing slash -> children
+  end
+
+  def dirname
+    no.dirname.E
+  end
+  
+  # generate URL for non-URL identifier (mail ID, Tag URI..)
+  def url
+    path? ? uri : Prefix + (CGI.escape uri)
+   end
+  
+  # URI extension :: E -> string
+  def ext
+    File.extname(uri).tail||''
+  end
+
+  def label
+    uri.label
+  end
+
+  def expand
+    uri.expand.E
+  end
+
+  # concatenate URIs with separator
+  # s :: E -> E
+  def s b
+    u.a E(b).path
+  end
+
+  def prependURI s
+    (s + uri).E
+  end
+
+  def appendURI s
+    (uri + s).E
+  end
+  alias_method :a, :appendURI
+  alias_method :+, :appendURI
+
+  def appendSlashURI s
+    E uri.t + s
+  end
+  alias_method :as, :appendSlashURI
+
+  # path? :: E -> Bool
+  def path?
+    uri.path?
+  end
+
+  # path :: E -> String
+  def path
+    @path ||=
+      path? ? (uri.match(/^\//) ? 
+               uri : '/'+uri) :
+      '/E/'+uri.h.dive[0..5]+(Base64.urlsafe_encode64 uri)
+  end
+
+  def u
+    @u ||= E (f ? dirname + '/.' + File.basename(path) : path.t + E::S)
+  end
+
+  # E (_ _ o) -> E o
+  def ro
+    uri.split(/#{E::S}\//)[-1].unpath false
+  end
+
+  def sh
+    d.force_encoding('UTF-8').sh
+  end
+
+  # literal -> URI
+  def literal o
+    return literalBlob o unless o.class == String
+    return literalURI o if (Literal[uri] || o.size<=88) && !o.match(/\//)
+    return E o if o.match %r{\A[a-z]+://[^\s]+\Z}
+    literalBlob o
+  end
+
+  # pathname for short literals
+  def literalURI o
+    E "/u/"+(Literal[uri] && o.gsub(/[\.:\-T+]/,'/'))+'/'+o
+  end
+ 
+  def literalBlobURI o
+    if o.class == String
+      E "/blob/"+o.h.dive
+    else
+      E "/json/"+[o].to_json.h.dive
+    end
+  end
+
+  # spaceship
+  def <=> c
+    to_s <=> c.to_s
+  end
+
+  # example: E('wiggly').to_s -> "wiggly"
+  def to_s # string
+    uri
+  end
+
+end
+
+class Hash
+  def uri
+    self["uri"]
+  end
+  def url; self.E.url end
+  def label
+    self[E::Label] || uri.label
+  end
+  def E
+    E.new uri
+  end
+end
+
+class Array
+  def E
+    self[0].E if self[0].class==Hash
+  end
+end
+
+class String
+  def dive
+    self[0..1]+'/'+
+    self[2..3]+'/'+
+    self[4..-1]
+  end
+
+  # expand qname-style identifier to URI
+  Expand={}
+  def expand
+    # memoize lookups
+   (Expand.has_key? self) ?
+    Expand[self] :
+   (Expand[self] =
+     match(/([^:]+):([^\/].*)/).do{|e|
+       (E::Abbrev[e[1]]||e[1]+':')+e[2]} || 
+     self )
+  end
+
+  def sh
+    Shellwords.escape self
+  end
+
+  BaseLen  = E::FSbase.size.succ
+
+  def pathToURI          r = true
+    self[BaseLen..-1].unpath r
+  end
+
+  # string -> E || literal
+  def unpath r=true # dereference literal? 
+
+    if m=(match /^([a-z]+:)\/+(.*)/) # URL
+      (m[1]+'//'+m[2]).E
+
+    elsif match /^blob/ # string
+      r ? ('/'+self).E.r : ('/'+self).E
+
+    elsif match /^json/ # JSON
+      r ? (('/'+self).E.r true) : ('/'+self).E
+
+    elsif match /^u\// # trie
+      r ? (File.basename self) : ('/'+self).E
+
+    elsif match /^E\/..\/..\// # !fs-compatible URI
+      self[8..-1].match(/([^.]+)(.*)/).do{|c|
+        (Base64.urlsafe_decode64 c[1]) + c[2]
+      }.E
+    else # path
+      ('/'+self).E
+    end
+  end
+  
+  def E
+    E.new self
+  end
+
+  def path?
+    (match /^(\.|\/|https?:\/)/) && true || false
+  end
+
+  def frag
+    split(/#/).pop()
+  end
+
+  def label
+    split(/[\/#]/)[-1]
+  end
+
+end

data/infod/Rb.rb

@@ -0,0 +1,71 @@
+# Rb    Rubidium
+
+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 h; join.h end
+  def intersperse i
+    inject([]){|a,b|a << b << i}[0..-2]
+  end
+  def sum
+    inject 0, &:+
+  end
+  def cr
+    intersperse "\n"
+  end
+end
+
+class Hash
+  def except *ks
+    clone.do{|h|
+      ks.map{|k|h.delete k}
+      h}
+  end
+  def has_keys ks; ks.each{|k|
+      return false unless has_key? k
+    }; true
+  end
+  def has_any_key ks; ks.each{|k|
+      return true if has_key? k
+    }; false
+  end
+end
+
+class Float
+  def max i; i > self ? self : i end
+  def min i; i < self ? self : i end
+end
+
+class Fixnum
+  def max i; i > self ? self : i end
+  def min i; i < self ? self : i end
+end
+
+class Object
+  def id; self end
+  def do; yield self end
+end
+
+class String
+  def h; Digest::SHA1.hexdigest self end
+  def hsub h; map{|e|h[e]||e} end
+  def map; each_char.map{|l| yield l}.join end
+  def tail; self[1..-1] end
+  def to_utf8; encode('UTF-8', undef: :replace) end
+  def t; match(/\/$/) ? self : self+'/' end
+end
+class  FalseClass
+  def do; nil end
+  def to_s; "" end
+  alias_method :to_str,:to_s
+end
+
+class NilClass
+  def do; nil end
+  def to_ary; [] end
+  def to_s; "" end
+  alias_method :to_str,:to_s
+  def method_missing *a; nil; end
+end

data/infod/Th/404.rb

@@ -0,0 +1,55 @@
+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)]]}
+
+  # qs y=404 to force a 404 response
+  F['req/404'] = F[E404]
+
+  fn 'view/'+HTTP+'404',->d,e{
+    [H.css('/css/404'),{_: :h1, c: '404'},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;}"]]}
+
+  # show response-codes for a list of URIs
+  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
+    }
+    puts "\n\n"
+    r.map{|c|
+      # show anomalies
+      puts c.join(' ') unless c[0] == 200
+    }
+  end
+
+end

data/infod/Th/500.rb

@@ -0,0 +1,10 @@
+#watch __FILE__
+class E
+
+  fn 'backtrace',->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>']]}
+
+end

data/infod/Th/GET.rb

@@ -0,0 +1,132 @@
+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
+  end
+
+  def send?
+    !((m=@r['HTTP_IF_NONE_MATCH']) && m.strip.split(/\s*,\s*/).include?(@r['ETag']))
+  end  
+
+  def GET_file
+    @r['ETag'] = [m,size].h
+    maybeSend mime,->{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
+    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 }
+  end
+  
+end

data/infod/Th/HEAD.rb

@@ -0,0 +1,5 @@
+class E
+  def HEAD
+    self.GET.do{|s,h,b|[s,h,[]]}
+  end
+end

data/infod/Th/PATCH.rb

@@ -0,0 +1,5 @@
+class E
+  def PATCH
+
+  end
+end

data/infod/Th/POST.rb

@@ -0,0 +1,19 @@
+class E
+  def POST
+    as('POST').y(self,@r) || basicPOST
+  rescue Exception => x
+    Fn 'backtrace',x,@r
+  end
+
+  def basicPOST
+    
+  end
+
+  # mint URI to POSTs here
+  fn '/post/POST',->e,r{
+
+    
+  }
+
+
+end

data/infod/Th/local.rb

@@ -0,0 +1,22 @@
+class E
+=begin
+ this code is not loaded by default
+
+ server looks in hostname-root paths for *.rb files, reporting found code:
+ site config http://data.whats-your.name/data.rb 
+
+=end
+  
+  # disallow custom-query crawling on all sites
+  fn '/robots.txt/GET',->e,r{
+    [200,{'Content-Type'=>'text/plain'},["User-agent: *\nDisallow: /*?*\n"]]}
+  
+  # schema search forward from site root
+  fn 'http://data.whats-your.name/GET',->e,r{
+    [302,{'Location'=>'/schema'},[]]}  
+  
+  # webize PS(1)
+  fn '/ps/GET',->e,r{
+    [200,{'Content-Type'=>'text/plain'},[`ps aux`]]}
+
+end

data/infod/Th/uid.rb

@@ -0,0 +1,24 @@
+#watch __FILE__
+
+module Th
+  FingerprintKeys = %w{
+   HTTP_ACCEPT
+   HTTP_ACCEPT_CHARSET
+   HTTP_ACCEPT_LANGUAGE
+   HTTP_ACCEPT_ENCODING
+   HTTP_USER_AGENT
+   HTTP_ORIGIN_ADDR
+   REMOTE_ADDR
+}
+
+  def uid
+    ('/u/'+FingerprintKeys.map{|i|self[i]}.h.dive).E
+  end
+end
+
+class E
+
+  fn '/whoami/GET',->e,r{
+    [302,{Location: '/@'+r.uid.uri},[]]}
+
+end

data/infod/Th.rb

@@ -0,0 +1,110 @@
+%w{GET HEAD POST PATCH uid 404 500}.map{|i|require_relative 'Th/' + i}
+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
+
+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 }
+    end
+
+  # load site-specific code-base
+
+  E['http:/*/*.rb'].glob.map{|s| puts "site config #{s}"
+    require s.d}
+
+end